En aquest tema, explorarem la simulació de rigid bodies, que és fonamental per crear interaccions realistes en els videojocs. Els rigid bodies són objectes que no es deformen quan es mouen o col·lisionen. La seva simulació implica calcular forces, velocitats i col·lisions per representar el moviment de manera precisa.

Conceptes Clau

  1. Definició de Rigid Body

Un rigid body és un objecte que manté la seva forma i volum constants durant el moviment. A diferència dels soft bodies, els rigid bodies no es deformen.

  1. Propietats dels Rigid Bodies

Les propietats principals que defineixen un rigid body són:

  • Massa: Quantitat de matèria en l'objecte.
  • Inèrcia: Resistència a canvis en el moviment.
  • Centre de Massa: Punt on es pot considerar que tota la massa de l'objecte està concentrada.
  • Velocitat Lineal: Velocitat a la qual es mou l'objecte.
  • Velocitat Angular: Velocitat a la qual l'objecte gira.

  1. Forces i Moments

Les forces aplicades a un rigid body poden causar translació (moviment lineal) i rotació (moviment angular). Les forces es poden aplicar en qualsevol punt de l'objecte, i els moments (o torques) són les forces que causen rotació.

Equacions de Moviment

  1. Equació de Newton per la Translació

La segona llei de Newton per la translació és: \[ F = m \cdot a \] on \( F \) és la força aplicada, \( m \) és la massa de l'objecte, i \( a \) és l'acceleració resultant.

  1. Equació de Rotació

L'equivalent per la rotació és: \[ \tau = I \cdot \alpha \] on \( \tau \) és el moment (torque), \( I \) és el moment d'inèrcia, i \( \alpha \) és l'acceleració angular.

  1. Actualització de la Posició i Orientació

Per actualitzar la posició i l'orientació d'un rigid body, utilitzem les següents equacions:

  • Posició: \( \mathbf{p}_{t+1} = \mathbf{p}_t + \mathbf{v}_t \cdot \Delta t \)
  • Orientació: \( \mathbf{q}_{t+1} = \mathbf{q}_t + \mathbf{\omega}_t \cdot \Delta t \)

on \( \mathbf{p} \) és la posició, \( \mathbf{v} \) és la velocitat lineal, \( \mathbf{q} \) és l'orientació (quaternion), \( \mathbf{\omega} \) és la velocitat angular, i \( \Delta t \) és el pas de temps.

Implementació Pràctica

  1. Configuració Inicial

Abans de començar la simulació, cal definir les propietats inicials del rigid body, com la massa, el centre de massa, i el moment d'inèrcia.

public class RigidBody
{
    public float Mass { get; set; }
    public Vector3 Position { get; set; }
    public Quaternion Orientation { get; set; }
    public Vector3 Velocity { get; set; }
    public Vector3 AngularVelocity { get; set; }
    public Matrix3x3 InertiaTensor { get; set; }
    
    public RigidBody(float mass, Vector3 position, Quaternion orientation)
    {
        Mass = mass;
        Position = position;
        Orientation = orientation;
        Velocity = Vector3.zero;
        AngularVelocity = Vector3.zero;
        InertiaTensor = CalculateInertiaTensor();
    }
    
    private Matrix3x3 CalculateInertiaTensor()
    {
        // Càlcul del tensor d'inèrcia basat en la forma de l'objecte
        // Exemple per a un cub
        float I = (1/6) * Mass * (sideLength * sideLength);
        return new Matrix3x3(I, 0, 0, 0, I, 0, 0, 0, I);
    }
}

  1. Aplicació de Forces i Moments

Les forces i moments es poden aplicar en qualsevol moment durant la simulació. Això afecta la velocitat lineal i angular del rigid body.

public void ApplyForce(Vector3 force, Vector3 point)
{
    // Actualitzar la velocitat lineal
    Vector3 acceleration = force / Mass;
    Velocity += acceleration * Time.deltaTime;
    
    // Actualitzar la velocitat angular
    Vector3 torque = Vector3.Cross(point - Position, force);
    Vector3 angularAcceleration = InertiaTensor.inverse * torque;
    AngularVelocity += angularAcceleration * Time.deltaTime;
}

  1. Actualització de l'Estat

Durant cada pas de temps de la simulació, cal actualitzar la posició i l'orientació del rigid body.

public void Update(float deltaTime)
{
    // Actualitzar la posició
    Position += Velocity * deltaTime;
    
    // Actualitzar l'orientació
    Quaternion deltaRotation = Quaternion.Euler(AngularVelocity * deltaTime);
    Orientation = deltaRotation * Orientation;
}

Exercici Pràctic

Exercici

Implementa una simulació bàsica d'un rigid body en un motor de física de la teva elecció (Unity, Unreal Engine, etc.). Defineix un cub amb propietats inicials i aplica una força constant per veure com es mou i rota.

Solució

// Unity Script
public class RigidBodySimulation : MonoBehaviour
{
    public float mass = 1.0f;
    public Vector3 initialPosition = Vector3.zero;
    public Quaternion initialOrientation = Quaternion.identity;
    public Vector3 force = new Vector3(10, 0, 0);
    public Vector3 forceApplicationPoint = new Vector3(0, 1, 0);

    private RigidBody rigidBody;

    void Start()
    {
        rigidBody = new RigidBody(mass, initialPosition, initialOrientation);
    }

    void Update()
    {
        rigidBody.ApplyForce(force, forceApplicationPoint);
        rigidBody.Update(Time.deltaTime);

        // Actualitzar la posició i orientació del GameObject
        transform.position = rigidBody.Position;
        transform.rotation = rigidBody.Orientation;
    }
}

Conclusió

En aquesta secció, hem après els conceptes bàsics de la simulació de rigid bodies, incloent les propietats fonamentals, les equacions de moviment, i com implementar una simulació bàsica. Aquest coneixement és essencial per crear interaccions realistes en els videojocs. En la següent secció, explorarem les interaccions entre múltiples rigid bodies i com gestionar les col·lisions entre ells.

© Copyright 2024. Tots els drets reservats