Este artículo se enfoca en la implementación práctica del motor de física BEPUphysicsint en Unity, cubriendo desde la compilación del código fuente hasta la integración con el renderizado gráfico del motor. El objetivo es proporcionar una guía detallada para desarrolladores que deseen utilizar este sistema de física de punto fijo en sus proyectos.

Preparación e Integración del Código Fuente

El primer paso es obtener el código fuente de BEPUphysicsint. Se puede descargar directamente desde su repositorio de GitHub:

https://github.com/sam-vdp/bepuphysics1int

Una vez descargado y descomprimido, se debe analizar la estructura del proyecto para identificar los módulos esenciales. Al examinar la solución BEPUphysics.sln, se observa que las carpetas BEPUik y BEPUphysics contienen la lógica central del motor, incluyendo clases como IKJoint.cs, Entity y Space. Adicionalmente, BEPUutilities proporciona utilidades necesarias, y FixedMath.Net maneja la aritmética de punto fijo, fundamental para BEPUphysicsint. El módulo ConversionHelper también puede ser útil para la conversión entre tipos de punto fijo y flotantes.

Configuración del Proyecto Unity

Crear un nuevo proyecto Unity (por ejemplo, en la versión 2020.3.33f1 o superior) y organizar su estructura de carpetas. Una posible organización podría ser:

• Assets/Core
• Assets/Scenes
• Assets/Scripts/ThirdParty
• Assets/Scripts/Framework

Dentro de Assets/Scripts/ThirdParty, se puede crear una subcarpeat BEPU y copiar los módulos identificados como esenciales (BEPUutilities, BEPUik, BEPUphysics, FixedMath.Net) en ella.

Resolución de Problemas de Compilación

Al copiar el código fuente, es común encontrar errores de compilación. Se deben seguir los siguientes pasos para resolverlos:

1. Eliminar archivos innecesarios: Las carpetas bin y obj, generadas durante la compilación del proyecto original de C#, deben ser eliminadas, ya que no son relevantes para Unity. De igual manera, los archivos AssemblyInfo.cs que suelen encontrarse en la carpeta "Properties" de cada proyecto, pueden ser eliminados, ya que Unity gestiona su propia información de ensamblado.
2. Habilitar código inseguro: BEPUphysicsint utiliza bloques de código unsafe para optimizaciones. Para que Unity compile este código, es necesario habilitar la opción correspondiente en la configuración del proyecto. Vaya a Edit > Project Settings > Player > Other Settings, y en la sección "Configuraton", active la casilla Allow 'unsafe' Code. En algunos casos, también podría ser necesario añadir el símbolo de compilación ALLOWUNSAFE en "Scripting Define Symbols".

Tras estas operaciones, el código de BEPUphysicsint debería compilarse sin errores en Unity.

Inicialización del Mundo Físico de BEPUphysicsint en Unity

Una vez que el motor de física está compilado, se necesita inicializar su "espacio" físico y gestionarlo dentro de Unity. Esto implica crear una instancia del mundo de BEPUphysicsint, configurar sus parámetros y desatcivar el motor de física nativo de Unity para evitar conflictos.

Se puede implementar un gestor global como un componente singleton en Unity. A continuación, se muestra un ejemplo de cómo configurar un BEPUPhysicsManager:

using UnityEngine;
using BEPUphysics;
using BEPUutilities; // Para Vector3 y otras utilidades
using FixedMath.Net; // Para decimales de punto fijo

public class BEPUPhysicsManager : MonoBehaviour
{
    public Space physicsSpace;
    public static BEPUPhysicsManager Instance { get; private set; }

    void Awake()
    {
        if (Instance != null && Instance != this)
        {
            Destroy(gameObject);
            return;
        }
        Instance = this;

        // Desactivar la simulación automática del motor de física de Unity
        // Esto previene que Unity simule la física y se superponga con BEPUphysicsint
        Physics.autoSimulation = false;
        // Physics.autoSyncTransforms = false; // Deshabilitar la sincronización de transformaciones de Unity si se desea un control total

        // Inicializar el espacio de física de BEPU
        physicsSpace = new Space();

        // Configurar la gravedad
        physicsSpace.ForceUpdater.Gravity = new Vector3(0, (Fix64)(-9.81m), 0);

        // Configurar el paso de tiempo para la simulación
        // BEPUphysicsint trabaja con FixedMath.Net.Fix64, que se convierte de decimal.
        physicsSpace.TimeStepSettings.TimeStepDuration = (Fix64)(1m / 60m); 
    }

    void FixedUpdate() // Utilizar FixedUpdate para la simulación de física
    {
        // Actualizar el mundo de física de BEPU en cada paso de tiempo fijo
        physicsSpace.Update();
    }
}

Cree un GameObject vacío en su escena de Unity (por ejemplo, "PhysicsManager") y adjunte este script BEPUPhysicsManager. Asegúrese de que este objeto esté presente y activo al inicio de la escena. Para los objetos que interactuarán con BEPUphysicsint, remueva cualquier componente de colisionador o Rigidbody de Unity que puedan tener.

Creación y Sincronización de Entidades Físicas

El siguiente paso es poblar el mundo físico de BEPUphysicsint con entidades y sincronizar sus transformaciones con los objetos visuales en Unity. Esto requiere un componente personalizado que:

1. Cree la entidad física de BEPUphysicsint (por ejemplo, una caja, esfera, etc.) basándose en las propiedades del objeto de Unity.
2. Añada esta entidad al Space de BEPUphysicsint.
3. Sincronice la posición y rotación de la entidad de BEPUphysicsint con el Transform del GameObject de Unity después de cada actualización física.

A continuación, se presenta un ejemplo para una entidad de caja (PhyBoxComponent):

using UnityEngine;
using BEPUphysics.Entities.Prefabs;
using BEPUutilities;
using FixedMath.Net; // Para Fix64 y conversiones

[RequireComponent(typeof(BoxCollider))] // Asegura que el GameObject tenga un BoxCollider
public class PhyBoxComponent : MonoBehaviour
{
    private Box bepuBoxEntity;

    public bool isStatic = false; // Define si la entidad es estática o dinámica

    // Variables internas para las dimensiones y el desplazamiento del centro
    private float entityWidth = 1f;
    private float entityHeight = 1f;
    private float entityLength = 1f;
    private Vector3 entityCenterOffset = Vector3.zero;

    void Start()
    {
        InitializePhysicsEntity();
        if (!isStatic)
        {
            // Establecer la posición inicial del objeto BEPUphysicsint
            // La posición en BEPUphysicsint es el centro del objeto
            SetBEPUPositionFromUnityTransform();
        }
    }

    void InitializePhysicsEntity()
    {
        // Leer las dimensiones y el centro del BoxCollider de Unity
        BoxCollider unityBoxCollider = GetComponent<BoxCollider>();
        if (unityBoxCollider == null)
        {
            Debug.LogError("PhyBoxComponent requiere un BoxCollider.", this);
            enabled = false;
            return;
        }

        entityWidth = unityBoxCollider.size.x * transform.localScale.x;
        entityHeight = unityBoxCollider.size.y * transform.localScale.y;
        entityLength = unityBoxCollider.size.z * transform.localScale.z;
        entityCenterOffset = unityBoxCollider.center;

        // Calcular la posición inicial de la entidad BEPUphysicsint, considerando el offset del centro
        Vector3 initialPos = transform.position + transform.TransformVector(entityCenterOffset);
        BEPUutilities.Vector3 bepuInitialPos = ConvertUnityVectorToBEPU(initialPos);

        // Crear la entidad Box de BEPUphysicsint
        if (isStatic)
        {
            bepuBoxEntity = new Box(bepuInitialPos, (Fix64)entityWidth, (Fix64)entityHeight, (Fix64)entityLength);
        }
        else
        {
            // Para entidades dinámicas, el último parámetro es la masa. Aquí se usa 1.
            bepuBoxEntity = new Box(bepuInitialPos, (Fix64)entityWidth, (Fix64)entityHeight, (Fix64)entityLength, (Fix64)1);
        }

        // Añadir la entidad al espacio de física
        if (BEPUPhysicsManager.Instance != null && BEPUPhysicsManager.Instance.physicsSpace != null)
        {
            BEPUPhysicsManager.Instance.physicsSpace.Add(bepuBoxEntity);
        }
        else
        {
            Debug.LogError("BEPUPhysicsManager o su physicsSpace no están inicializados.", this);
            enabled = false;
        }
    }

    void SetBEPUPositionFromUnityTransform()
    {
        Vector3 unityWorldPosition = transform.position + transform.TransformVector(entityCenterOffset);
        bepuBoxEntity.Position = ConvertUnityVectorToBEPU(unityWorldPosition);
    }

    void LateUpdate()
    {
        // Solo las entidades dinámicas necesitan sincronizar su posición desde BEPUphysicsint
        if (isStatic)
        {
            return;
        }

        // Obtener la posición y rotación de la entidad BEPUphysicsint
        BEPUutilities.Vector3 bepuWorldPos = bepuBoxEntity.Position;
        BEPUutilities.Quaternion bepuWorldRot = bepuBoxEntity.Orientation;

        // Convertir la posición de BEPUphysicsint a Unity
        Vector3 unityPosition = ConvertBEPUVectorToUnity(bepuWorldPos);
        Quaternion unityRotation = ConvertBEPUQuaternionToUnity(bepuWorldRot);

        // Ajustar la posición de Unity considerando el offset del centro
        // Es importante aplicar la rotación antes del offset para que el pivote sea correcto
        transform.position = unityPosition - unityRotation * entityCenterOffset;
        transform.rotation = unityRotation;
    }

    // Funciones de conversión entre tipos de Unity y BEPUphysicsint
    private BEPUutilities.Vector3 ConvertUnityVectorToBEPU(Vector3 unityVec)
    {
        return new BEPUutilities.Vector3((Fix64)unityVec.x, (Fix64)unityVec.y, (Fix64)unityVec.z);
    }

    private Vector3 ConvertBEPUVectorToUnity(BEPUutilities.Vector3 bepuVec)
    {
        return new Vector3((float)(decimal)bepuVec.X, (float)(decimal)bepuVec.Y, (float)(decimal)bepuVec.Z);
    }

    private BEPUutilities.Quaternion ConvertUnityQuaternionToBEPU(Quaternion unityQuat)
    {
        return new BEPUutilities.Quaternion((Fix64)unityQuat.x, (Fix64)unityQuat.y, (Fix64)unityQuat.z, (Fix64)unityQuat.w);
    }

    private Quaternion ConvertBEPUQuaternionToUnity(BEPUutilities.Quaternion bepuQuat)
    {
        return new Quaternion((float)(decimal)bepuQuat.X, (float)(decimal)bepuQuat.Y, (float)(decimal)bepuQuat.Z, (float)(decimal)bepuQuat.W);
    }

    void OnDestroy()
    {
        if (bepuBoxEntity != null && BEPUPhysicsManager.Instance != null && BEPUPhysicsManager.Instance.physicsSpace != null)
        {
            BEPUPhysicsManager.Instance.physicsSpace.Remove(bepuBoxEntity);
        }
    }
}

Este script se adjunta a cada GameObject que representará una entidad de caja en el mundo físico de BEPUphysicsint. El atributo [RequireComponent(typeof(BoxCollider))] garantiza que el GameObject siempre tenga un BoxCollider, cuyas propiedades (tamaño y centro) se utilizan para definir la forma de la entidad BEPUphysicsint. Esto permite una edición visual intuitiva del tamaño del colisionador en el editor de Unity.

Para otras formas (esferas, cilindros, etc.), se seguiría un enfoque similar, creando componentes específicos (PhySphereComponent, PhyCylinderComponent) que lean las propiedades de los colisionadores de Unity correspondientes.