Physics and Held Item Placement Improvement!

.github/workflows/build.yml

@@ -15,7 +15,7 @@ jobs:
       - uses: bazel-contrib/setup-bazel@0.14.0
         with:
           bazelisk-cache: true
-          disk-cache: ${{ github.workflow }}
+          disk-cache: true
           repository-cache: true
       - name: build
         run: |
@@ -39,20 +39,24 @@ jobs:
             --verbose_failures \
             //blazerod/model:test \
             //blazerod/render:test
+      - name: collect artifacts
+        run: |
+          mkdir -p artifacts
+          BAZEL_BIN=$(bazel info bazel-bin --config opt)
+          cp "$BAZEL_BIN/mod/mod_fabric.jar" artifacts/
+          cp "$BAZEL_BIN/mod/mod_neoforge.jar" artifacts/
+          cp "$BAZEL_BIN/blazerod/blazerod_fabric.jar" artifacts/
+          cp "$BAZEL_BIN/blazerod/blazerod_neoforge.jar" artifacts/
+          cp "$BAZEL_BIN/blazerod/model/model-base/model-base.jar" artifacts/
+          cp "$BAZEL_BIN/blazerod/model/model-formats/model-formats.jar" artifacts/
+          cp "$BAZEL_BIN/blazerod/model/model-gltf/model-gltf.jar" artifacts/
+          cp "$BAZEL_BIN/blazerod/model/model-pmd/model-pmd.jar" artifacts/
+          cp "$BAZEL_BIN/blazerod/model/model-pmx/model-pmx.jar" artifacts/
+          cp "$BAZEL_BIN/blazerod/model/model-vmd/model-vmd.jar" artifacts/
+          cp "$BAZEL_BIN/blazerod/model/model-assimp/model-assimp-merged.jar" artifacts/
+          cp "$BAZEL_BIN/blazerod/example/ball_block/ball_block.jar" artifacts/
       - name: capture build artifacts
         uses: actions/upload-artifact@v4
         with:
           name: artifacts-bazel
-          path: |
-            bazel-bin/mod/mod_fabric.jar
-            bazel-bin/mod/mod_neoforge.jar
-            bazel-bin/blazerod/blazerod_fabric.jar
-            bazel-bin/blazerod/blazerod_neoforge.jar
-            bazel-bin/blazerod/model/model-base/model-base.jar
-            bazel-bin/blazerod/model/model-formats/model-formats.jar
-            bazel-bin/blazerod/model/model-gltf/model-gltf.jar
-            bazel-bin/blazerod/model/model-pmd/model-pmd.jar
-            bazel-bin/blazerod/model/model-pmx/model-pmx.jar
-            bazel-bin/blazerod/model/model-vmd/model-vmd.jar
-            bazel-bin/blazerod/model/model-assimp/model-assimp-merged.jar
-            bazel-bin/blazerod/example/ball_block/ball_block.jar
+          path: artifacts/

.gitignore

@@ -54,3 +54,6 @@ compile_commands.json
 .bazelbsp
 bazel-*
 external
+
+#KAIMyEntity-C
+KAIMyEntity-C/

blazerod/model/model-pmx/PmxLoader.kt

@@ -1022,7 +1022,10 @@ class PmxLoader : ModelFileLoader {
                     shape = loadShapeType(buffer.get()),
                     shapeSize = loadVector3f(buffer).mul(MMD_SCALE),
                     shapePosition = loadVector3f(buffer).transformPosition(),
-                    shapeRotation = loadVector3f(buffer).also { it.y *= -1 },
+                    shapeRotation = loadVector3f(buffer).also {
+                        it.y *= -1
+                        it.z *= -1
+                    },
                     mass = buffer.getFloat(),
                     moveAttenuation = buffer.getFloat(),
                     rotationDamping = buffer.getFloat(),
@@ -1060,7 +1063,10 @@ class PmxLoader : ModelFileLoader {
                 val rigidBodyIndexA = loadRigidBodyIndex(buffer)
                 val rigidBodyIndexB = loadRigidBodyIndex(buffer)
                 val position = loadVector3f(buffer).transformPosition()
-                val rotation = loadVector3f(buffer).also { it.y *= -1 }
+                val rotation = loadVector3f(buffer).also {
+                    it.y *= -1
+                    it.z *= -1
+                }
 
                 val positionMinimumOrig = loadVector3f(buffer).transformPosition()
                 val positionMaximumOrig = loadVector3f(buffer).transformPosition()
@@ -1069,10 +1075,18 @@ class PmxLoader : ModelFileLoader {
 
                 val rotationMinimumOrig = loadVector3f(buffer)
                 val rotationMaximumOrig = loadVector3f(buffer)
-                val rotationMinimum = Vector3f(-rotationMaximumOrig.x, rotationMinimumOrig.y, rotationMinimumOrig.z)
-                val rotationMaximum = Vector3f(-rotationMinimumOrig.x, rotationMaximumOrig.y, rotationMaximumOrig.z)
+                val rotationMinimum = Vector3f(
+                    rotationMinimumOrig.x,
+                    -rotationMaximumOrig.y,
+                    -rotationMaximumOrig.z,
+                )
+                val rotationMaximum = Vector3f(
+                    rotationMaximumOrig.x,
+                    -rotationMinimumOrig.y,
+                    -rotationMinimumOrig.z,
+                )
                 val positionSpring = loadVector3f(buffer)
-                val rotationSpring = loadVector3f(buffer).also { it.x *= -1 }
+                val rotationSpring = loadVector3f(buffer)
 
                 PmxJoint(
                     nameLocal = nameLocal,
@@ -1166,15 +1180,56 @@ class PmxLoader : ModelFileLoader {
                             )
                         )
                     }
+
                     boneToRigidBodyMap[index]?.forEach { index ->
                         add(
                             NodeComponent.RigidBodyComponent(
                                 rigidBodyId = RigidBodyId(modelId, index),
                                 rigidBody = rigidBodies[index].let { rigidBody ->
+                                    val enableNameBasedOverrides = false
+                                    val basePhysicsMode = when (rigidBody.physicsMode) {
+                                        PmxRigidBody.PhysicsMode.FOLLOW_BONE -> RigidBody.PhysicsMode.FOLLOW_BONE
+                                        PmxRigidBody.PhysicsMode.PHYSICS -> RigidBody.PhysicsMode.PHYSICS
+                                        PmxRigidBody.PhysicsMode.PHYSICS_PLUS_BONE -> RigidBody.PhysicsMode.PHYSICS_PLUS_BONE
+                                    }
+
+                                    val nameLocal = rigidBody.nameLocal
+                                    val adjustedPhysicsMode = if (enableNameBasedOverrides) {
+                                        when {
+                                            nameLocal.startsWith("Skirt_D_") ->
+                                                RigidBody.PhysicsMode.FOLLOW_BONE
+                                            nameLocal.startsWith("Ribbon_Braid_") -> basePhysicsMode
+                                            nameLocal.startsWith("Ribbon_") ||
+                                                nameLocal.startsWith("Pocket Watch_") ||
+                                                nameLocal.startsWith("Strap_") ->
+                                                RigidBody.PhysicsMode.FOLLOW_BONE
+                                            nameLocal.startsWith("Skirt_") &&
+                                                basePhysicsMode == RigidBody.PhysicsMode.PHYSICS ->
+                                                RigidBody.PhysicsMode.PHYSICS_PLUS_BONE
+                                            else -> basePhysicsMode
+                                        }
+                                    } else {
+                                        basePhysicsMode
+                                    }
+
+                                    val baseGroup = 1 shl rigidBody.groupId
+                                    val collisionMask = rigidBody.nonCollisionGroup and 0xFFFF
+                                    val defaultMask = collisionMask
+                                    println(
+                                        "PHYSDBG RB_GROUP " +
+                                            "idx=$index " +
+                                            "name=${rigidBody.nameLocal} " +
+                                            "groupId=${rigidBody.groupId} " +
+                                            "nonColl=${rigidBody.nonCollisionGroup} " +
+                                            "baseGroup=$baseGroup " +
+                                            "defaultMask=$defaultMask " +
+                                            "finalMask=$collisionMask",
+                                    )
+
                                     RigidBody(
                                         name = rigidBody.nameLocal.takeIf(String::isNotBlank),
-                                        collisionGroup = rigidBody.groupId,
-                                        collisionMask = rigidBody.nonCollisionGroup,
+                                        collisionGroup = baseGroup,
+                                        collisionMask = collisionMask,
                                         shape = when (rigidBody.shape) {
                                             PmxRigidBody.ShapeType.SPHERE -> RigidBody.ShapeType.SPHERE
                                             PmxRigidBody.ShapeType.BOX -> RigidBody.ShapeType.BOX
@@ -1188,11 +1243,7 @@ class PmxLoader : ModelFileLoader {
                                         rotationDamping = rigidBody.rotationDamping,
                                         repulsion = rigidBody.repulsion,
                                         frictionForce = rigidBody.frictionForce,
-                                        physicsMode = when (rigidBody.physicsMode) {
-                                            PmxRigidBody.PhysicsMode.FOLLOW_BONE -> RigidBody.PhysicsMode.FOLLOW_BONE
-                                            PmxRigidBody.PhysicsMode.PHYSICS -> RigidBody.PhysicsMode.PHYSICS
-                                            PmxRigidBody.PhysicsMode.PHYSICS_PLUS_BONE -> RigidBody.PhysicsMode.PHYSICS_PLUS_BONE
-                                        },
+                                        physicsMode = adjustedPhysicsMode,
                                     )
                                 },
                             )

blazerod/render/api/animation/AnimationItem.kt

@@ -31,4 +31,12 @@ interface AnimationItemInstance {
     interface Factory {
         fun of(animation: AnimationItem): AnimationItemInstance
     }
+}
+
+interface MaskableAnimationItemInstance {
+    fun applyMasked(
+        instance: ModelInstance,
+        pendingValues: AnimationItemPendingValues,
+        allowedNodeIndices: BooleanArray,
+    )
 }

blazerod/render/api/resource/ModelInstance.kt

@@ -13,6 +13,8 @@ import java.util.function.Consumer
 interface ModelInstance : RefCount {
     val scene: RenderScene
 
+    fun copyNodeWorldTransform(nodeIndex: Int, dest: Matrix4f)
+
     fun clearTransform()
     fun setTransformMatrix(nodeIndex: Int, transformId: TransformId, matrix: Matrix4f)
     fun setTransformMatrix(nodeIndex: Int, transformId: TransformId, updater: Consumer<NodeTransform.Matrix>)

blazerod/render/api/resource/RenderScene.kt

@@ -4,6 +4,7 @@ import top.fifthlight.blazerod.api.refcount.RefCount
 import top.fifthlight.blazerod.model.Camera
 import top.fifthlight.blazerod.model.HumanoidTag
 import top.fifthlight.blazerod.model.NodeId
+import top.fifthlight.blazerod.model.NodeTransformView
 
 interface RenderScene : RefCount {
     val rootNode: RenderNode
@@ -12,6 +13,8 @@ interface RenderScene : RefCount {
     val expressionGroups: List<RenderExpressionGroup>
     val cameras: List<Camera>
 
+    val renderTransform: NodeTransformView?
+
     val ikTargetData: List<IkTargetData>
     val nodeIdMap: Map<NodeId, RenderNode>
     val nodeNameMap: Map<String, RenderNode>

blazerod/render/main/animation/AnimationChannelItem.kt

@@ -15,6 +15,13 @@ import top.fifthlight.blazerod.runtime.resource.CameraTransformImpl
 sealed class AnimationChannelItem<T : Any, D, P : Any>(
     val channel: AnimationChannel<T, D>,
 ) {
+    open val targetNodeIndex: Int? = null
+
+    @Suppress("UNCHECKED_CAST")
+    fun applyUnsafe(instance: ModelInstanceImpl, pendingValue: Any) {
+        (this as AnimationChannelItem<Any, Any, Any>).apply(instance, pendingValue)
+    }
+
     abstract fun createPendingValue(): P
 
     // run on client thread
@@ -28,6 +35,8 @@ sealed class AnimationChannelItem<T : Any, D, P : Any>(
         private val transformId: TransformId,
         channel: AnimationChannel<Vector3f, Unit>,
     ) : AnimationChannelItem<Vector3f, Unit, Vector3f>(channel) {
+        override val targetNodeIndex: Int = index
+
         init {
             require(channel.type == AnimationChannel.Type.Translation) { "Unmatched animation channel: want translation, but got ${channel.type}" }
         }
@@ -50,6 +59,8 @@ sealed class AnimationChannelItem<T : Any, D, P : Any>(
         private val transformId: TransformId,
         channel: AnimationChannel<Vector3f, Unit>,
     ) : AnimationChannelItem<Vector3f, Unit, Vector3f>(channel) {
+        override val targetNodeIndex: Int = index
+
         init {
             require(channel.type == AnimationChannel.Type.Scale) { "Unmatched animation channel: want scale, but got ${channel.type}" }
         }
@@ -72,6 +83,8 @@ sealed class AnimationChannelItem<T : Any, D, P : Any>(
         private val transformId: TransformId,
         channel: AnimationChannel<Quaternionf, Unit>,
     ) : AnimationChannelItem<Quaternionf, Unit, Quaternionf>(channel) {
+        override val targetNodeIndex: Int = index
+
         init {
             require(channel.type == AnimationChannel.Type.Rotation) { "Unmatched animation channel: want rotation, but got ${channel.type}" }
         }
@@ -95,6 +108,8 @@ sealed class AnimationChannelItem<T : Any, D, P : Any>(
         private val transformId: TransformId,
         channel: AnimationChannel<Vector3f, Unit>,
     ) : AnimationChannelItem<Vector3f, Unit, Vector3f>(channel) {
+        override val targetNodeIndex: Int = index
+
         init {
             require(channel.type == AnimationChannel.Type.BedrockTranslation) { "Unmatched animation channel: want translation, but got ${channel.type}" }
         }
@@ -117,6 +132,8 @@ sealed class AnimationChannelItem<T : Any, D, P : Any>(
         private val transformId: TransformId,
         channel: AnimationChannel<Vector3f, Unit>,
     ) : AnimationChannelItem<Vector3f, Unit, Vector3f>(channel) {
+        override val targetNodeIndex: Int = index
+
         init {
             require(channel.type == AnimationChannel.Type.BedrockScale) { "Unmatched animation channel: want scale, but got ${channel.type}" }
         }
@@ -139,6 +156,8 @@ sealed class AnimationChannelItem<T : Any, D, P : Any>(
         private val transformId: TransformId,
         channel: AnimationChannel<Quaternionf, Unit>,
     ) : AnimationChannelItem<Quaternionf, Unit, Quaternionf>(channel) {
+        override val targetNodeIndex: Int = index
+
         init {
             require(channel.type == AnimationChannel.Type.BedrockRotation) { "Unmatched animation channel: want rotation, but got ${channel.type}" }
         }

blazerod/render/main/animation/AnimationItemImpl.kt

@@ -3,6 +3,7 @@ package top.fifthlight.blazerod.animation
 import top.fifthlight.blazerod.api.animation.AnimationItem
 import top.fifthlight.blazerod.api.animation.AnimationItemInstance
 import top.fifthlight.blazerod.api.animation.AnimationItemPendingValues
+import top.fifthlight.blazerod.api.animation.MaskableAnimationItemInstance
 import top.fifthlight.blazerod.api.resource.ModelInstance
 import top.fifthlight.blazerod.api.resource.RenderScene
 import top.fifthlight.blazerod.model.animation.Animation
@@ -40,7 +41,7 @@ class AnimationItemPendingValuesImpl(animationItem: AnimationItemImpl) : Animati
 }
 
 @ActualImpl(AnimationItemInstance::class)
-class AnimationItemInstanceImpl(val animationItem: AnimationItemImpl) : AnimationItemInstance {
+class AnimationItemInstanceImpl(val animationItem: AnimationItemImpl) : AnimationItemInstance, MaskableAnimationItemInstance {
     @ActualConstructor("of")
     constructor(animationItem: AnimationItem) : this(animationItem as AnimationItemImpl)
 
@@ -76,10 +77,42 @@ class AnimationItemInstanceImpl(val animationItem: AnimationItemImpl) : Animatio
             pendingValues.pendingValues[index].let { pendingValue ->
                 channel.applyUnsafe(instance, pendingValue)
             }
-            if (!pendingValues.applied) {
-                pendingValues.applied = true
-                pendingStack.addLast(pendingValues)
+        }
+        if (!pendingValues.applied) {
+            pendingValues.applied = true
+            pendingStack.addLast(pendingValues)
+        }
+    }
+
+    override fun applyMasked(
+        instance: ModelInstance,
+        pendingValues: AnimationItemPendingValues,
+        allowedNodeIndices: BooleanArray,
+    ) {
+        val instance = instance as ModelInstanceImpl
+        val pendingValues = pendingValues as AnimationItemPendingValuesImpl
+
+        animationItem.channels.forEachIndexed { index, channel ->
+            val targetNodeIndex = channel.targetNodeIndex
+            if (targetNodeIndex == null || targetNodeIndex !in allowedNodeIndices.indices || !allowedNodeIndices[targetNodeIndex]) {
+                return@forEachIndexed
             }
+
+            pendingValues.pendingValues[index].let { pendingValue ->
+                channel.applyUnsafe(instance, pendingValue)
+            }
+        }
+        if (!pendingValues.applied) {
+            pendingValues.applied = true
+            pendingStack.addLast(pendingValues)
+        }
+    }
+
+    fun recyclePendingValues(pendingValues: AnimationItemPendingValues) {
+        val pendingValues = pendingValues as? AnimationItemPendingValuesImpl ?: return
+        if (!pendingValues.applied) {
+            pendingValues.applied = true
+            pendingStack.addLast(pendingValues)
         }
     }
 }

blazerod/render/main/physics/PhysicsLibrary.java

@@ -31,6 +31,10 @@ private PhysicsLibrary() {
 
     public native static void stepPhysicsWorld(long physicsWorld, float deltaTime, int maxSubSteps, float fixedTimeStep);
 
+    public native static void resetRigidBody(long physicsWorld, int rigidBodyIndex,
+                                             float px, float py, float pz,
+                                             float qx, float qy, float qz, float qw);
+
     public native static void destroyPhysicsWorld(long physicsWorld);
 
     public static boolean isPhysicsAvailable() {

blazerod/render/main/physics/PhysicsScene.kt

@@ -2,6 +2,7 @@ package top.fifthlight.blazerod.physics
 
 import org.joml.Vector3fc
 import top.fifthlight.blazerod.model.RigidBody
+import top.fifthlight.blazerod.model.util.MMD_SCALE
 import top.fifthlight.blazerod.runtime.resource.RenderPhysicsJoint
 import java.lang.ref.Reference
 import java.nio.ByteBuffer