Fix mesh stretching

blazerod/model/model-base/PhysicalJoint.kt

@@ -16,6 +16,9 @@ data class PhysicalJoint(
     val rotationMax: Vector3fc,
     val positionSpring: Vector3fc,
     val rotationSpring: Vector3fc,
+    val softness: Float = 1.0f,
+    val biasFactor: Float = 0.3f,
+    val relaxationFactor: Float = 1.0f,
 ) {
     enum class JointType {
         SPRING_6DOF,

blazerod/model/model-base/RigidBody.kt

@@ -17,6 +17,9 @@ data class RigidBody(
     val repulsion: Float,
     val frictionForce: Float,
     val physicsMode: PhysicsMode,
+    val ccdMotionThreshold: Float = 0f,
+    val ccdSweptSphereRadius: Float = 0f,
+    val collisionMargin: Float = 0.04f,
 ) {
     enum class ShapeType {
         SPHERE,

blazerod/render/api/physics/PhysicsEngine.kt

@@ -4,21 +4,32 @@ import top.fifthlight.blazerod.api.resource.ModelInstance
 
 object PhysicsEngine {
     private val activeWorlds = mutableMapOf<ModelInstance, PhysicsWorld>()
+    private val providers = mutableMapOf<ModelInstance, PhysicsProvider>()
 
     fun register(instance: ModelInstance, provider: PhysicsProvider) {
+        providers[instance] = provider
         if (!activeWorlds.containsKey(instance)) {
             activeWorlds[instance] = provider.createWorld(instance)
         }
     }
 
     fun unregister(instance: ModelInstance) {
+        providers.remove(instance)
         activeWorlds.remove(instance)?.dispose()
     }
 
     fun getWorld(instance: ModelInstance): PhysicsWorld? {
         return activeWorlds[instance]
     }
 
+    fun recreate(instance: ModelInstance): PhysicsWorld? {
+        val provider = providers[instance] ?: return null
+        activeWorlds.remove(instance)?.dispose()
+        val world = provider.createWorld(instance)
+        activeWorlds[instance] = world
+        return world
+    }
+
     fun update(time: Float) {
         val iterator = activeWorlds.iterator()
         while (iterator.hasNext()) {

blazerod/render/api/resource/ModelInstance.kt

@@ -15,6 +15,7 @@ interface ModelInstance : RefCount {
     var lodDistance: Float
 
     fun clearTransform()
+    fun resetPhysics(time: Float)
     fun setTransformMatrix(nodeIndex: Int, transformId: TransformId, matrix: Matrix4f)
     fun setTransformMatrix(nodeIndex: Int, transformId: TransformId, updater: Consumer<NodeTransform.Matrix>)
     fun setTransformMatrix(nodeIndex: Int, transformId: TransformId, updater: NodeTransform.Matrix.() -> Unit)
@@ -31,6 +32,7 @@ interface ModelInstance : RefCount {
 
     fun debugRender(viewProjectionMatrix: Matrix4fc, bufferSource: MultiBufferSource, time: Float)
     fun updateRenderData(time: Float)
+    fun updateRenderDataNoPhysics(time: Float)
 
     fun createRenderTask(
         modelMatrix: Matrix4fc,
@@ -42,4 +44,4 @@ interface ModelInstance : RefCount {
     interface Factory {
         fun of(scene: RenderScene): ModelInstance
     }
-}
+}

blazerod/render/main/animation/CrossfadeAnimationItemInstance.kt

@@ -14,7 +14,8 @@ import kotlin.math.min
 class CrossfadeAnimationItemPendingValues(
     val sourcePending: AnimationItemPendingValues,
     val targetPending: AnimationItemPendingValues,
-    var weight: Float
+    var weight: Float,
+    var rootWeight: Float
 ) : AnimationItemPendingValues
 
 class CrossfadeAnimationState(
@@ -66,8 +67,9 @@ class CrossfadeAnimationItemInstance(
         val targetPending = targetInstance.update(context, crossfadeState.targetState)
 
         val weight = min(1f, max(0f, crossfadeState.elapsedTime / crossfadeState.duration))
+        val rootWeight = min(1f, max(0f, crossfadeState.elapsedTime / 0.05f))
 
-        return CrossfadeAnimationItemPendingValues(sourcePending, targetPending, weight)
+        return CrossfadeAnimationItemPendingValues(sourcePending, targetPending, weight, rootWeight)
     }
 
     @Suppress("UNCHECKED_CAST", "NOTHING_TO_INLINE")
@@ -81,8 +83,8 @@ class CrossfadeAnimationItemInstance(
         val modelImpl = instance as ModelInstanceImpl
 
         val weight = crossfadeValues.weight
+        val rootWeight = crossfadeValues.rootWeight
 
-        // If the crossfade is complete, just apply the target animation directly
         if (weight >= 1f) {
             targetInstance.apply(modelImpl, crossfadeValues.targetPending)
             return
@@ -91,7 +93,6 @@ class CrossfadeAnimationItemInstance(
         val sourcePendingImpl = crossfadeValues.sourcePending as AnimationItemPendingValuesImpl
         val targetPendingImpl = crossfadeValues.targetPending as AnimationItemPendingValuesImpl
 
-        // Fast path: if weight is 0, just apply source
         if (weight <= 0f) {
             sourceInstance.apply(modelImpl, crossfadeValues.sourcePending)
             return
@@ -121,45 +122,46 @@ class CrossfadeAnimationItemInstance(
 
             appliedNodes.add(key)
 
+            // Check if this is a Root node (no parent)
+            val isRoot = modelImpl.scene.nodes[nodeIdx].parent == null
+            val currentWeight = if (isRoot && tChannel is AnimationChannelItem.TranslationItem) rootWeight else weight
+
             when (tChannel) {
                 is AnimationChannelItem.TranslationItem -> {
                     val tVec = tVal as Vector3f
                     if (sVal != null) {
                         val sVec = sVal as Vector3f
-                        tVec.lerp(sVec, 1f - weight) // if weight=1, tVec unchanged. if weight=0, tVec=sVec.
+                        tVec.lerp(sVec, 1f - currentWeight)
                     } else {
-                        // interpolate from identity (0,0,0)
                         val sVec = Vector3f(0f, 0f, 0f)
-                        tVec.lerp(sVec, 1f - weight)
+                        tVec.lerp(sVec, 1f - currentWeight)
                     }
                     tChannel.applyUnsafe(modelImpl, tVec)
                 }
                 is AnimationChannelItem.RotationItem -> {
                     val tQuat = tVal as Quaternionf
                     if (sVal != null) {
                         val sQuat = sVal as Quaternionf
-                        tQuat.slerp(sQuat, 1f - weight)
+                        tQuat.slerp(sQuat, 1f - currentWeight)
                     } else {
-                        // interpolate from identity
                         val sQuat = Quaternionf()
-                        tQuat.slerp(sQuat, 1f - weight)
+                        tQuat.slerp(sQuat, 1f - currentWeight)
                     }
                     tChannel.applyUnsafe(modelImpl, tQuat)
                 }
                 is AnimationChannelItem.ScaleItem -> {
                     val tVec = tVal as Vector3f
                     if (sVal != null) {
                         val sVec = sVal as Vector3f
-                        tVec.lerp(sVec, 1f - weight)
+                        tVec.lerp(sVec, 1f - currentWeight)
                     } else {
-                        // interpolate from identity (1,1,1)
                         val sVec = Vector3f(1f, 1f, 1f)
-                        tVec.lerp(sVec, 1f - weight)
+                        tVec.lerp(sVec, 1f - currentWeight)
                     }
                     tChannel.applyUnsafe(modelImpl, tVec)
                 }
                 else -> {
-                    if (weight >= 0.5f) {
+                    if (currentWeight >= 0.5f) {
                         tChannel.applyUnsafe(modelImpl, tVal)
                     } else if (sVal != null) {
                         for (j in sourceChannels.indices) {
@@ -182,27 +184,31 @@ class CrossfadeAnimationItemInstance(
 
             if (!appliedNodes.contains(key)) {
                 val sVal = sourcePendingImpl.pendingValues[i]
+
+                val isRoot = modelImpl.scene.nodes[nodeIdx].parent == null
+                val currentWeight = if (isRoot && sChannel is AnimationChannelItem.TranslationItem) rootWeight else weight
+
                 when (sChannel) {
                     is AnimationChannelItem.TranslationItem -> {
                         val sVec = sVal as Vector3f
                         val tVec = Vector3f(0f, 0f, 0f)
-                        sVec.lerp(tVec, weight) // if weight=1, sVec=(0,0,0)
+                        sVec.lerp(tVec, currentWeight)
                         sChannel.applyUnsafe(modelImpl, sVec)
                     }
                     is AnimationChannelItem.RotationItem -> {
                         val sQuat = sVal as Quaternionf
                         val tQuat = Quaternionf()
-                        sQuat.slerp(tQuat, weight)
+                        sQuat.slerp(tQuat, currentWeight)
                         sChannel.applyUnsafe(modelImpl, sQuat)
                     }
                     is AnimationChannelItem.ScaleItem -> {
                         val sVec = sVal as Vector3f
                         val tVec = Vector3f(1f, 1f, 1f)
-                        sVec.lerp(tVec, weight)
+                        sVec.lerp(tVec, currentWeight)
                         sChannel.applyUnsafe(modelImpl, sVec)
                     }
                     else -> {
-                        if (weight < 0.5f) {
+                        if (currentWeight < 0.5f) {
                             sChannel.applyUnsafe(modelImpl, sVal)
                         }
                     }

blazerod/render/main/physics/PhysicsLibrary.java

@@ -38,6 +38,8 @@ public native static void resetRigidBody(long physicsWorld, int rigidBodyIndex,
     public native static void applyVelocityDamping(long physicsWorld, int rigidBodyIndex,
                                                    float linearAttenuation, float angularAttenuation);
 
+    public native static void setSolverIterations(long physicsWorld, int iterations);
+
     public native static void destroyPhysicsWorld(long physicsWorld);
 
     public static boolean isPhysicsAvailable() {
@@ -113,8 +115,6 @@ public static boolean load() {
             return true;
         } catch (Exception | LinkageError ex) {
             logger.error("Failed to load bullet physics native library", ex);
-            System.err.println("CRITICAL JNI LOAD ERROR:");
-            ex.printStackTrace(System.err);
             return false;
         }
     }

blazerod/render/main/physics/PhysicsScene.cpp

@@ -28,7 +28,7 @@ static void CopyVector3fField(Vector3f& vector, void* data) {
 }
 
 static std::vector<RigidBody> DeserializeRigidbodies(size_t size, void* data) {
-    const size_t rigidbody_size = 72;
+    const size_t rigidbody_size = 84;
     if (size == 0) {
         throw std::invalid_argument("Empty rigidbody data");
     }
@@ -56,6 +56,9 @@ static std::vector<RigidBody> DeserializeRigidbodies(size_t size, void* data) {
         CopyField(rigidbody.rotation_damping, rigidbody_data + 60);
         CopyField(rigidbody.repulsion, rigidbody_data + 64);
         CopyField(rigidbody.friction_force, rigidbody_data + 68);
+        CopyField(rigidbody.ccd_motion_threshold, rigidbody_data + 72);
+        CopyField(rigidbody.ccd_swept_sphere_radius, rigidbody_data + 76);
+        CopyField(rigidbody.collision_margin, rigidbody_data + 80);
 
         rigidbodies.push_back(rigidbody);
     }
@@ -64,7 +67,7 @@ static std::vector<RigidBody> DeserializeRigidbodies(size_t size, void* data) {
 }
 
 static std::vector<Joint> DeserializeJoints(size_t size, void* data) {
-    const size_t joint_size = 108;
+    const size_t joint_size = 120;
     if (size % joint_size != 0) {
         throw std::invalid_argument("Invalid joint size");
     }
@@ -88,6 +91,9 @@ static std::vector<Joint> DeserializeJoints(size_t size, void* data) {
         CopyVector3fField(joint.rotation_max, joint_data + 72);
         CopyVector3fField(joint.position_spring, joint_data + 84);
         CopyVector3fField(joint.rotation_spring, joint_data + 96);
+        CopyField(joint.softness, joint_data + 108);
+        CopyField(joint.bias_factor, joint_data + 112);
+        CopyField(joint.relaxation_factor, joint_data + 116);
 
         joints.push_back(joint);
     }

blazerod/render/main/physics/PhysicsScene.h

@@ -42,6 +42,9 @@ struct RigidBody {
     float repulsion;
     float friction_force;
     PhysicsMode physics_mode;
+    float ccd_motion_threshold;
+    float ccd_swept_sphere_radius;
+    float collision_margin;
 };
 
 struct Joint {
@@ -56,6 +59,9 @@ struct Joint {
     Vector3f rotation_max;
     Vector3f position_spring;
     Vector3f rotation_spring;
+    float softness;
+    float bias_factor;
+    float relaxation_factor;
 };
 
 class PhysicsScene {

blazerod/render/main/physics/PhysicsScene.kt

@@ -28,7 +28,7 @@ class PhysicsScene(
             .putFloat(offset + 4, vector.y())
             .putFloat(offset + 8, vector.z())
 
-        val rigidBodyItemSize = 72
+        val rigidBodyItemSize = 84
         val rigidBodiesBuffer = ByteBuffer.allocateDirect(rigidBodyItemSize * rigidBodies.size)
             .order(ByteOrder.nativeOrder())
         rigidBodies.forEachIndexed { index, rigidBody ->
@@ -45,9 +45,12 @@ class PhysicsScene(
             rigidBodiesBuffer.putFloat(offset + 60, rigidBody.rotationDamping)
             rigidBodiesBuffer.putFloat(offset + 64, rigidBody.repulsion)
             rigidBodiesBuffer.putFloat(offset + 68, rigidBody.frictionForce)
+            rigidBodiesBuffer.putFloat(offset + 72, rigidBody.ccdMotionThreshold)
+            rigidBodiesBuffer.putFloat(offset + 76, rigidBody.ccdSweptSphereRadius)
+            rigidBodiesBuffer.putFloat(offset + 80, rigidBody.collisionMargin)
         }
 
-        val jointItemSize = 108
+        val jointItemSize = 120
         val jointsBuffer = ByteBuffer.allocateDirect(jointItemSize * joints.size)
             .order(ByteOrder.nativeOrder())
         joints.forEachIndexed { index, joint ->
@@ -63,6 +66,9 @@ class PhysicsScene(
             jointsBuffer.putVector3f(offset + 72, joint.rotationMax)
             jointsBuffer.putVector3f(offset + 84, joint.positionSpring)
             jointsBuffer.putVector3f(offset + 96, joint.rotationSpring)
+            jointsBuffer.putFloat(offset + 108, joint.softness)
+            jointsBuffer.putFloat(offset + 112, joint.biasFactor)
+            jointsBuffer.putFloat(offset + 116, joint.relaxationFactor)
         }
 
         try {