reze-engine 0.1.0

package/dist/physics.js

@@ -0,0 +1,503 @@
+import { Quat, Vec3, Mat4 } from "./math";
+import { loadAmmo } from "./ammo-loader";
+export var RigidbodyShape;
+(function (RigidbodyShape) {
+    RigidbodyShape[RigidbodyShape["Sphere"] = 0] = "Sphere";
+    RigidbodyShape[RigidbodyShape["Box"] = 1] = "Box";
+    RigidbodyShape[RigidbodyShape["Capsule"] = 2] = "Capsule";
+})(RigidbodyShape || (RigidbodyShape = {}));
+export var RigidbodyType;
+(function (RigidbodyType) {
+    RigidbodyType[RigidbodyType["Static"] = 0] = "Static";
+    RigidbodyType[RigidbodyType["Dynamic"] = 1] = "Dynamic";
+    RigidbodyType[RigidbodyType["Kinematic"] = 2] = "Kinematic";
+})(RigidbodyType || (RigidbodyType = {}));
+export class Physics {
+    constructor(rigidbodies, joints = []) {
+        this.gravity = new Vec3(0, -98, 0); // Gravity acceleration (cm/s²), MMD-style default
+        this.ammoInitialized = false;
+        this.ammoPromise = null;
+        this.ammo = null;
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        this.dynamicsWorld = null; // btDiscreteDynamicsWorld
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        this.ammoRigidbodies = []; // btRigidBody instances
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        this.ammoConstraints = []; // btTypedConstraint instances
+        this.rigidbodiesInitialized = false; // bodyOffsetMatrixInverse computed and bodies positioned
+        this.jointsCreated = false; // Joints delayed until after rigidbodies are positioned
+        this.firstFrame = true; // Needed to reposition bodies before creating joints
+        this.forceDisableOffsetForConstraintFrame = true; // MMD compatibility (Bullet 2.75 behavior)
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        this.zeroVector = null; // Cached zero vector for velocity clearing
+        this.rigidbodies = rigidbodies;
+        this.joints = joints;
+        this.initAmmo();
+    }
+    async initAmmo() {
+        if (this.ammoInitialized || this.ammoPromise)
+            return;
+        this.ammoPromise = loadAmmo();
+        try {
+            this.ammo = await this.ammoPromise;
+            this.createAmmoWorld();
+            this.ammoInitialized = true;
+        }
+        catch (error) {
+            console.error("[Physics] Failed to initialize Ammo:", error);
+            this.ammoPromise = null;
+        }
+    }
+    setGravity(gravity) {
+        this.gravity = gravity;
+        if (this.dynamicsWorld && this.ammo) {
+            const Ammo = this.ammo;
+            const gravityVec = new Ammo.btVector3(gravity.x, gravity.y, gravity.z);
+            this.dynamicsWorld.setGravity(gravityVec);
+            Ammo.destroy(gravityVec);
+        }
+    }
+    getGravity() {
+        return this.gravity;
+    }
+    getRigidbodies() {
+        return this.rigidbodies;
+    }
+    getJoints() {
+        return this.joints;
+    }
+    getRigidbodyTransforms() {
+        const transforms = [];
+        if (!this.ammo || !this.ammoRigidbodies.length) {
+            for (let i = 0; i < this.rigidbodies.length; i++) {
+                transforms.push({
+                    position: new Vec3(this.rigidbodies[i].shapePosition.x, this.rigidbodies[i].shapePosition.y, this.rigidbodies[i].shapePosition.z),
+                    rotation: Quat.fromEuler(this.rigidbodies[i].shapeRotation.x, this.rigidbodies[i].shapeRotation.y, this.rigidbodies[i].shapeRotation.z),
+                });
+            }
+            return transforms;
+        }
+        for (let i = 0; i < this.ammoRigidbodies.length; i++) {
+            const ammoBody = this.ammoRigidbodies[i];
+            if (!ammoBody) {
+                const rb = this.rigidbodies[i];
+                transforms.push({
+                    position: new Vec3(rb.shapePosition.x, rb.shapePosition.y, rb.shapePosition.z),
+                    rotation: Quat.fromEuler(rb.shapeRotation.x, rb.shapeRotation.y, rb.shapeRotation.z),
+                });
+                continue;
+            }
+            const transform = ammoBody.getWorldTransform();
+            const origin = transform.getOrigin();
+            const rotQuat = transform.getRotation();
+            transforms.push({
+                position: new Vec3(origin.x(), origin.y(), origin.z()),
+                rotation: new Quat(rotQuat.x(), rotQuat.y(), rotQuat.z(), rotQuat.w()),
+            });
+        }
+        return transforms;
+    }
+    createAmmoWorld() {
+        if (!this.ammo)
+            return;
+        const Ammo = this.ammo;
+        const collisionConfiguration = new Ammo.btDefaultCollisionConfiguration();
+        const dispatcher = new Ammo.btCollisionDispatcher(collisionConfiguration);
+        const overlappingPairCache = new Ammo.btDbvtBroadphase();
+        const solver = new Ammo.btSequentialImpulseConstraintSolver();
+        this.dynamicsWorld = new Ammo.btDiscreteDynamicsWorld(dispatcher, overlappingPairCache, solver, collisionConfiguration);
+        const gravityVec = new Ammo.btVector3(this.gravity.x, this.gravity.y, this.gravity.z);
+        this.dynamicsWorld.setGravity(gravityVec);
+        Ammo.destroy(gravityVec);
+        this.createAmmoRigidbodies();
+    }
+    createAmmoRigidbodies() {
+        if (!this.ammo || !this.dynamicsWorld)
+            return;
+        const Ammo = this.ammo;
+        this.ammoRigidbodies = [];
+        for (let i = 0; i < this.rigidbodies.length; i++) {
+            const rb = this.rigidbodies[i];
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            let shape = null;
+            const size = rb.size;
+            switch (rb.shape) {
+                case RigidbodyShape.Sphere:
+                    const radius = size.x;
+                    shape = new Ammo.btSphereShape(radius);
+                    break;
+                case RigidbodyShape.Box:
+                    const sizeVector = new Ammo.btVector3(size.x, size.y, size.z);
+                    shape = new Ammo.btBoxShape(sizeVector);
+                    Ammo.destroy(sizeVector);
+                    break;
+                case RigidbodyShape.Capsule:
+                    const capsuleRadius = size.x;
+                    const capsuleHalfHeight = size.y;
+                    shape = new Ammo.btCapsuleShape(capsuleRadius, capsuleHalfHeight);
+                    break;
+                default:
+                    const defaultHalfExtents = new Ammo.btVector3(size.x / 2, size.y / 2, size.z / 2);
+                    shape = new Ammo.btBoxShape(defaultHalfExtents);
+                    Ammo.destroy(defaultHalfExtents);
+                    break;
+            }
+            // Bodies must start at correct position to avoid explosions when joints are created
+            const transform = new Ammo.btTransform();
+            transform.setIdentity();
+            const shapePos = new Ammo.btVector3(rb.shapePosition.x, rb.shapePosition.y, rb.shapePosition.z);
+            transform.setOrigin(shapePos);
+            Ammo.destroy(shapePos);
+            const shapeRotQuat = Quat.fromEuler(rb.shapeRotation.x, rb.shapeRotation.y, rb.shapeRotation.z);
+            const quat = new Ammo.btQuaternion(shapeRotQuat.x, shapeRotQuat.y, shapeRotQuat.z, shapeRotQuat.w);
+            transform.setRotation(quat);
+            Ammo.destroy(quat);
+            // All types use the same motionState constructor
+            const motionState = new Ammo.btDefaultMotionState(transform);
+            const mass = rb.type === RigidbodyType.Dynamic ? rb.mass : 0;
+            const isDynamic = rb.type === RigidbodyType.Dynamic;
+            const localInertia = new Ammo.btVector3(0, 0, 0);
+            if (isDynamic && mass > 0) {
+                shape.calculateLocalInertia(mass, localInertia);
+            }
+            const rbInfo = new Ammo.btRigidBodyConstructionInfo(mass, motionState, shape, localInertia);
+            rbInfo.set_m_restitution(rb.restitution);
+            rbInfo.set_m_friction(rb.friction);
+            rbInfo.set_m_linearDamping(rb.linearDamping);
+            rbInfo.set_m_angularDamping(rb.angularDamping);
+            const body = new Ammo.btRigidBody(rbInfo);
+            body.setSleepingThresholds(0.0, 0.0);
+            // Static (FollowBone) should be kinematic, not static - must follow bones
+            if (rb.type === RigidbodyType.Static || rb.type === RigidbodyType.Kinematic) {
+                body.setCollisionFlags(body.getCollisionFlags() | 2); // CF_KINEMATIC_OBJECT
+                body.setActivationState(4); // DISABLE_DEACTIVATION
+            }
+            const collisionGroup = 1 << rb.group;
+            const collisionMask = rb.collisionMask;
+            const isZeroVolume = (rb.shape === RigidbodyShape.Sphere && rb.size.x === 0) ||
+                (rb.shape === RigidbodyShape.Box && (rb.size.x === 0 || rb.size.y === 0 || rb.size.z === 0)) ||
+                (rb.shape === RigidbodyShape.Capsule && (rb.size.x === 0 || rb.size.y === 0));
+            if (collisionMask === 0 || isZeroVolume) {
+                body.setCollisionFlags(body.getCollisionFlags() | 4); // CF_NO_CONTACT_RESPONSE
+            }
+            this.dynamicsWorld.addRigidBody(body, collisionGroup, collisionMask);
+            this.ammoRigidbodies.push(body);
+            Ammo.destroy(rbInfo);
+            Ammo.destroy(localInertia);
+        }
+    }
+    createAmmoJoints() {
+        if (!this.ammo || !this.dynamicsWorld || this.ammoRigidbodies.length === 0)
+            return;
+        const Ammo = this.ammo;
+        this.ammoConstraints = [];
+        for (const joint of this.joints) {
+            const rbIndexA = joint.rigidbodyIndexA;
+            const rbIndexB = joint.rigidbodyIndexB;
+            if (rbIndexA < 0 ||
+                rbIndexA >= this.ammoRigidbodies.length ||
+                rbIndexB < 0 ||
+                rbIndexB >= this.ammoRigidbodies.length) {
+                console.warn(`[Physics] Invalid joint indices: ${rbIndexA}, ${rbIndexB}`);
+                continue;
+            }
+            const bodyA = this.ammoRigidbodies[rbIndexA];
+            const bodyB = this.ammoRigidbodies[rbIndexB];
+            if (!bodyA || !bodyB) {
+                console.warn(`[Physics] Body not found for joint ${joint.name}: bodyA=${!!bodyA}, bodyB=${!!bodyB}`);
+                continue;
+            }
+            // Compute joint frames using actual current body positions (after repositioning)
+            const bodyATransform = bodyA.getWorldTransform();
+            const bodyBTransform = bodyB.getWorldTransform();
+            const bodyAOrigin = bodyATransform.getOrigin();
+            const bodyARotQuat = bodyATransform.getRotation();
+            const bodyAPos = new Vec3(bodyAOrigin.x(), bodyAOrigin.y(), bodyAOrigin.z());
+            const bodyARot = new Quat(bodyARotQuat.x(), bodyARotQuat.y(), bodyARotQuat.z(), bodyARotQuat.w());
+            const bodyAMat = Mat4.fromPositionRotation(bodyAPos, bodyARot);
+            const bodyBOrigin = bodyBTransform.getOrigin();
+            const bodyBRotQuat = bodyBTransform.getRotation();
+            const bodyBPos = new Vec3(bodyBOrigin.x(), bodyBOrigin.y(), bodyBOrigin.z());
+            const bodyBRot = new Quat(bodyBRotQuat.x(), bodyBRotQuat.y(), bodyBRotQuat.z(), bodyBRotQuat.w());
+            const bodyBMat = Mat4.fromPositionRotation(bodyBPos, bodyBRot);
+            const scalingFactor = 1.0;
+            const jointRotQuat = Quat.fromEuler(joint.rotation.x, joint.rotation.y, joint.rotation.z);
+            const jointPos = new Vec3(joint.position.x * scalingFactor, joint.position.y * scalingFactor, joint.position.z * scalingFactor);
+            const jointTransform = Mat4.fromPositionRotation(jointPos, jointRotQuat);
+            // Transform joint world position to body A's local space
+            const frameInAMat = bodyAMat.inverse().multiply(jointTransform);
+            const framePosA = frameInAMat.getPosition();
+            const frameRotA = frameInAMat.toQuat();
+            // Transform joint world position to body B's local space
+            const frameInBMat = bodyBMat.inverse().multiply(jointTransform);
+            const framePosB = frameInBMat.getPosition();
+            const frameRotB = frameInBMat.toQuat();
+            const frameInA = new Ammo.btTransform();
+            frameInA.setIdentity();
+            const pivotInA = new Ammo.btVector3(framePosA.x, framePosA.y, framePosA.z);
+            frameInA.setOrigin(pivotInA);
+            const quatA = new Ammo.btQuaternion(frameRotA.x, frameRotA.y, frameRotA.z, frameRotA.w);
+            frameInA.setRotation(quatA);
+            const frameInB = new Ammo.btTransform();
+            frameInB.setIdentity();
+            const pivotInB = new Ammo.btVector3(framePosB.x, framePosB.y, framePosB.z);
+            frameInB.setOrigin(pivotInB);
+            const quatB = new Ammo.btQuaternion(frameRotB.x, frameRotB.y, frameRotB.z, frameRotB.w);
+            frameInB.setRotation(quatB);
+            const useLinearReferenceFrameA = true;
+            const constraint = new Ammo.btGeneric6DofSpringConstraint(bodyA, bodyB, frameInA, frameInB, useLinearReferenceFrameA);
+            // Disable offset for constraint frame for MMD compatibility (Bullet 2.75 behavior)
+            if (this.forceDisableOffsetForConstraintFrame) {
+                let jointPtr;
+                if (typeof Ammo.getPointer === "function") {
+                    jointPtr = Ammo.getPointer(constraint);
+                }
+                else {
+                    const constraintWithPtr = constraint;
+                    jointPtr = constraintWithPtr.ptr;
+                }
+                if (jointPtr !== undefined && Ammo.HEAP8) {
+                    const heap8 = Ammo.HEAP8;
+                    // jointPtr + 1300 = m_useLinearReferenceFrameA, jointPtr + 1301 = m_useOffsetForConstraintFrame
+                    if (heap8[jointPtr + 1300] === (useLinearReferenceFrameA ? 1 : 0) && heap8[jointPtr + 1301] === 1) {
+                        heap8[jointPtr + 1301] = 0;
+                    }
+                }
+            }
+            for (let i = 0; i < 6; ++i) {
+                constraint.setParam(2, 0.475, i); // BT_CONSTRAINT_STOP_ERP
+            }
+            const lowerLinear = new Ammo.btVector3(joint.positionMin.x, joint.positionMin.y, joint.positionMin.z);
+            const upperLinear = new Ammo.btVector3(joint.positionMax.x, joint.positionMax.y, joint.positionMax.z);
+            constraint.setLinearLowerLimit(lowerLinear);
+            constraint.setLinearUpperLimit(upperLinear);
+            const lowerAngular = new Ammo.btVector3(this.normalizeAngle(joint.rotationMin.x), this.normalizeAngle(joint.rotationMin.y), this.normalizeAngle(joint.rotationMin.z));
+            const upperAngular = new Ammo.btVector3(this.normalizeAngle(joint.rotationMax.x), this.normalizeAngle(joint.rotationMax.y), this.normalizeAngle(joint.rotationMax.z));
+            constraint.setAngularLowerLimit(lowerAngular);
+            constraint.setAngularUpperLimit(upperAngular);
+            // Linear springs: only enable if stiffness is non-zero
+            if (joint.springPosition.x !== 0) {
+                constraint.setStiffness(0, joint.springPosition.x);
+                constraint.enableSpring(0, true);
+            }
+            else {
+                constraint.enableSpring(0, false);
+            }
+            if (joint.springPosition.y !== 0) {
+                constraint.setStiffness(1, joint.springPosition.y);
+                constraint.enableSpring(1, true);
+            }
+            else {
+                constraint.enableSpring(1, false);
+            }
+            if (joint.springPosition.z !== 0) {
+                constraint.setStiffness(2, joint.springPosition.z);
+                constraint.enableSpring(2, true);
+            }
+            else {
+                constraint.enableSpring(2, false);
+            }
+            // Angular springs: always enable
+            constraint.setStiffness(3, joint.springRotation.x);
+            constraint.enableSpring(3, true);
+            constraint.setStiffness(4, joint.springRotation.y);
+            constraint.enableSpring(4, true);
+            constraint.setStiffness(5, joint.springRotation.z);
+            constraint.enableSpring(5, true);
+            this.dynamicsWorld.addConstraint(constraint, false);
+            this.ammoConstraints.push(constraint);
+            Ammo.destroy(pivotInA);
+            Ammo.destroy(pivotInB);
+            Ammo.destroy(quatA);
+            Ammo.destroy(quatB);
+            Ammo.destroy(lowerLinear);
+            Ammo.destroy(upperLinear);
+            Ammo.destroy(lowerAngular);
+            Ammo.destroy(upperAngular);
+        }
+    }
+    // Normalize angle to [-π, π] range
+    normalizeAngle(angle) {
+        const pi = Math.PI;
+        const twoPi = 2 * pi;
+        angle = angle % twoPi;
+        if (angle < -pi) {
+            angle += twoPi;
+        }
+        else if (angle > pi) {
+            angle -= twoPi;
+        }
+        return angle;
+    }
+    // Syncs bones to rigidbodies, simulates dynamics, solves constraints
+    // Modifies boneWorldMatrices in-place for dynamic rigidbodies that drive bones
+    step(dt, boneWorldMatrices, boneInverseBindMatrices) {
+        // Wait for Ammo to initialize
+        if (!this.ammoInitialized || !this.ammo || !this.dynamicsWorld) {
+            return;
+        }
+        const boneCount = boneWorldMatrices.length / 16;
+        if (this.firstFrame) {
+            if (!this.rigidbodiesInitialized) {
+                this.computeBodyOffsets(boneInverseBindMatrices, boneCount);
+                this.rigidbodiesInitialized = true;
+            }
+            // Position bodies based on current bone poses (not bind pose) before creating joints
+            this.positionBodiesFromBones(boneWorldMatrices, boneCount);
+            if (!this.jointsCreated) {
+                this.createAmmoJoints();
+                this.jointsCreated = true;
+            }
+            if (this.dynamicsWorld.stepSimulation) {
+                this.dynamicsWorld.stepSimulation(0, 0, 0);
+            }
+            this.firstFrame = false;
+        }
+        // Step order: 1) Sync Static/Kinematic from bones, 2) Step physics, 3) Apply dynamic to bones
+        this.syncFromBones(boneWorldMatrices, boneInverseBindMatrices, boneCount);
+        this.stepAmmoPhysics(dt);
+        this.applyAmmoRigidbodiesToBones(boneWorldMatrices, boneInverseBindMatrices, boneCount);
+    }
+    // Compute bodyOffsetMatrixInverse for all rigidbodies (called once during initialization)
+    computeBodyOffsets(boneInverseBindMatrices, boneCount) {
+        if (!this.ammo || !this.dynamicsWorld)
+            return;
+        for (let i = 0; i < this.rigidbodies.length; i++) {
+            const rb = this.rigidbodies[i];
+            if (rb.boneIndex >= 0 && rb.boneIndex < boneCount) {
+                const boneIdx = rb.boneIndex;
+                const invBindIdx = boneIdx * 16;
+                const invBindMat = new Mat4(boneInverseBindMatrices.subarray(invBindIdx, invBindIdx + 16));
+                // Compute shape transform in bone-local space: shapeLocal = boneInverseBind × shapeWorldBind
+                const shapeRotQuat = Quat.fromEuler(rb.shapeRotation.x, rb.shapeRotation.y, rb.shapeRotation.z);
+                const shapeWorldBind = Mat4.fromPositionRotation(rb.shapePosition, shapeRotQuat);
+                // shapeLocal = boneInverseBind × shapeWorldBind (not shapeWorldBind × boneInverseBind)
+                const bodyOffsetMatrix = invBindMat.multiply(shapeWorldBind);
+                rb.bodyOffsetMatrixInverse = bodyOffsetMatrix.inverse();
+                rb.bodyOffsetMatrix = bodyOffsetMatrix; // Cache non-inverse to avoid expensive inverse() calls
+            }
+            else {
+                rb.bodyOffsetMatrixInverse = Mat4.identity();
+                rb.bodyOffsetMatrix = Mat4.identity(); // Cache non-inverse
+            }
+        }
+    }
+    // Position bodies based on current bone transforms (called on first frame only)
+    positionBodiesFromBones(boneWorldMatrices, boneCount) {
+        if (!this.ammo || !this.dynamicsWorld)
+            return;
+        const Ammo = this.ammo;
+        for (let i = 0; i < this.rigidbodies.length; i++) {
+            const rb = this.rigidbodies[i];
+            const ammoBody = this.ammoRigidbodies[i];
+            if (!ammoBody || rb.boneIndex < 0 || rb.boneIndex >= boneCount)
+                continue;
+            const boneIdx = rb.boneIndex;
+            const worldMatIdx = boneIdx * 16;
+            const boneWorldMat = new Mat4(boneWorldMatrices.subarray(worldMatIdx, worldMatIdx + 16));
+            // nodeWorld = boneWorld × shapeLocal (not shapeLocal × boneWorld)
+            const bodyOffsetMatrix = rb.bodyOffsetMatrix || rb.bodyOffsetMatrixInverse.inverse();
+            const nodeWorldMatrix = boneWorldMat.multiply(bodyOffsetMatrix);
+            const worldPos = nodeWorldMatrix.getPosition();
+            const worldRot = nodeWorldMatrix.toQuat();
+            const transform = new Ammo.btTransform();
+            const pos = new Ammo.btVector3(worldPos.x, worldPos.y, worldPos.z);
+            const quat = new Ammo.btQuaternion(worldRot.x, worldRot.y, worldRot.z, worldRot.w);
+            transform.setOrigin(pos);
+            transform.setRotation(quat);
+            if (rb.type === RigidbodyType.Static || rb.type === RigidbodyType.Kinematic) {
+                ammoBody.setCollisionFlags(ammoBody.getCollisionFlags() | 2); // CF_KINEMATIC_OBJECT
+                ammoBody.setActivationState(4); // DISABLE_DEACTIVATION
+            }
+            ammoBody.setWorldTransform(transform);
+            ammoBody.getMotionState().setWorldTransform(transform);
+            if (!this.zeroVector) {
+                this.zeroVector = new Ammo.btVector3(0, 0, 0);
+            }
+            ammoBody.setLinearVelocity(this.zeroVector);
+            ammoBody.setAngularVelocity(this.zeroVector);
+            Ammo.destroy(pos);
+            Ammo.destroy(quat);
+            Ammo.destroy(transform);
+        }
+    }
+    // Sync Static (FollowBone) and Kinematic rigidbodies to follow bone transforms
+    syncFromBones(boneWorldMatrices, boneInverseBindMatrices, boneCount) {
+        if (!this.ammo || !this.dynamicsWorld)
+            return;
+        const Ammo = this.ammo;
+        for (let i = 0; i < this.rigidbodies.length; i++) {
+            const rb = this.rigidbodies[i];
+            const ammoBody = this.ammoRigidbodies[i];
+            if (!ammoBody)
+                continue;
+            // Sync both Static (FollowBone) and Kinematic bodies - they both follow bones
+            if ((rb.type === RigidbodyType.Static || rb.type === RigidbodyType.Kinematic) &&
+                rb.boneIndex >= 0 &&
+                rb.boneIndex < boneCount) {
+                const boneIdx = rb.boneIndex;
+                const worldMatIdx = boneIdx * 16;
+                const boneWorldMat = new Mat4(boneWorldMatrices.subarray(worldMatIdx, worldMatIdx + 16));
+                // nodeWorld = boneWorld × shapeLocal (not shapeLocal × boneWorld)
+                const bodyOffsetMatrix = rb.bodyOffsetMatrix || rb.bodyOffsetMatrixInverse.inverse();
+                const nodeWorldMatrix = boneWorldMat.multiply(bodyOffsetMatrix);
+                const worldPos = nodeWorldMatrix.getPosition();
+                const worldRot = nodeWorldMatrix.toQuat();
+                const transform = new Ammo.btTransform();
+                const pos = new Ammo.btVector3(worldPos.x, worldPos.y, worldPos.z);
+                const quat = new Ammo.btQuaternion(worldRot.x, worldRot.y, worldRot.z, worldRot.w);
+                transform.setOrigin(pos);
+                transform.setRotation(quat);
+                ammoBody.setWorldTransform(transform);
+                ammoBody.getMotionState().setWorldTransform(transform);
+                if (!this.zeroVector) {
+                    this.zeroVector = new Ammo.btVector3(0, 0, 0);
+                }
+                ammoBody.setLinearVelocity(this.zeroVector);
+                ammoBody.setAngularVelocity(this.zeroVector);
+                Ammo.destroy(pos);
+                Ammo.destroy(quat);
+                Ammo.destroy(transform);
+            }
+        }
+    }
+    // Step Ammo physics simulation
+    stepAmmoPhysics(dt) {
+        if (!this.ammo || !this.dynamicsWorld)
+            return;
+        const fixedTimeStep = 1 / 75;
+        const maxSubSteps = 10;
+        this.dynamicsWorld.stepSimulation(dt, maxSubSteps, fixedTimeStep);
+    }
+    // Apply dynamic rigidbody world transforms to bone world matrices in-place
+    applyAmmoRigidbodiesToBones(boneWorldMatrices, boneInverseBindMatrices, boneCount) {
+        if (!this.ammo || !this.dynamicsWorld)
+            return;
+        for (let i = 0; i < this.rigidbodies.length; i++) {
+            const rb = this.rigidbodies[i];
+            const ammoBody = this.ammoRigidbodies[i];
+            if (!ammoBody)
+                continue;
+            // Only dynamic rigidbodies drive bones (Static/Kinematic follow bones)
+            if (rb.type === RigidbodyType.Dynamic && rb.boneIndex >= 0 && rb.boneIndex < boneCount) {
+                const boneIdx = rb.boneIndex;
+                const worldMatIdx = boneIdx * 16;
+                const transform = ammoBody.getWorldTransform();
+                const origin = transform.getOrigin();
+                const rotation = transform.getRotation();
+                const nodePos = new Vec3(origin.x(), origin.y(), origin.z());
+                const nodeRot = new Quat(rotation.x(), rotation.y(), rotation.z(), rotation.w());
+                const nodeWorldMatrix = Mat4.fromPositionRotation(nodePos, nodeRot);
+                // boneWorld = nodeWorld × bodyOffsetMatrixInverse (not bodyOffsetMatrixInverse × nodeWorld)
+                const boneWorldMat = nodeWorldMatrix.multiply(rb.bodyOffsetMatrixInverse);
+                const values = boneWorldMat.values;
+                if (!isNaN(values[0]) && !isNaN(values[15]) && Math.abs(values[0]) < 1e6 && Math.abs(values[15]) < 1e6) {
+                    boneWorldMatrices.set(values, worldMatIdx);
+                }
+                else {
+                    console.warn(`[Physics] Invalid bone world matrix for rigidbody ${i} (${rb.name}), skipping update`);
+                }
+            }
+        }
+    }
+}

package/dist/pmx-loader.d.ts

@@ -0,0 +1,47 @@
+import { Model } from "./model";
+export declare class PmxLoader {
+    private view;
+    private offset;
+    private decoder;
+    private encoding;
+    private additionalVec4Count;
+    private vertexIndexSize;
+    private textureIndexSize;
+    private materialIndexSize;
+    private boneIndexSize;
+    private morphIndexSize;
+    private rigidBodyIndexSize;
+    private textures;
+    private materials;
+    private bones;
+    private inverseBindMatrices;
+    private joints0;
+    private weights0;
+    private rigidbodies;
+    private joints;
+    private constructor();
+    static load(url: string): Promise<Model>;
+    private parse;
+    private parseHeader;
+    private parseVertices;
+    private parseIndices;
+    private parseTextures;
+    private parseMaterials;
+    private parseBones;
+    private skipMorphs;
+    private skipDisplayFrames;
+    private parseRigidbodies;
+    private parseJoints;
+    private computeInverseBind;
+    private toModel;
+    private getUint8;
+    private getUint16;
+    private getVertexIndex;
+    private getNonVertexIndex;
+    private getInt32;
+    private getFloat32;
+    private getString;
+    private getText;
+    private getIndex;
+}
+//# sourceMappingURL=pmx-loader.d.ts.map

package/dist/pmx-loader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pmx-loader.d.ts","sourceRoot":"","sources":["../src/pmx-loader.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAA+C,MAAM,SAAS,CAAA;AAI5E,qBAAa,SAAS;IACpB,OAAO,CAAC,IAAI,CAAU;IACtB,OAAO,CAAC,MAAM,CAAI;IAClB,OAAO,CAAC,OAAO,CAAc;IAC7B,OAAO,CAAC,QAAQ,CAAI;IACpB,OAAO,CAAC,mBAAmB,CAAI;IAC/B,OAAO,CAAC,eAAe,CAAI;IAC3B,OAAO,CAAC,gBAAgB,CAAI;IAC5B,OAAO,CAAC,iBAAiB,CAAI;IAC7B,OAAO,CAAC,aAAa,CAAI;IACzB,OAAO,CAAC,cAAc,CAAI;IAC1B,OAAO,CAAC,kBAAkB,CAAI;IAC9B,OAAO,CAAC,QAAQ,CAAgB;IAChC,OAAO,CAAC,SAAS,CAAiB;IAClC,OAAO,CAAC,KAAK,CAAa;IAC1B,OAAO,CAAC,mBAAmB,CAA4B;IACvD,OAAO,CAAC,OAAO,CAA2B;IAC1C,OAAO,CAAC,QAAQ,CAA0B;IAC1C,OAAO,CAAC,WAAW,CAAkB;IACrC,OAAO,CAAC,MAAM,CAAc;IAE5B,OAAO;WAIM,IAAI,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,KAAK,CAAC;IAK9C,OAAO,CAAC,KAAK;IAgBb,OAAO,CAAC,WAAW;IA+CnB,OAAO,CAAC,aAAa;IA+FrB,OAAO,CAAC,YAAY;IAWpB,OAAO,CAAC,aAAa;IAkBrB,OAAO,CAAC,cAAc;IAkEtB,OAAO,CAAC,UAAU;IA2IlB,OAAO,CAAC,UAAU;IAyGlB,OAAO,CAAC,iBAAiB;IAgDzB,OAAO,CAAC,gBAAgB;IAyFxB,OAAO,CAAC,WAAW;IAmGnB,OAAO,CAAC,kBAAkB;IAmC1B,OAAO,CAAC,OAAO;IA2If,OAAO,CAAC,QAAQ;IAOhB,OAAO,CAAC,SAAS;IAUjB,OAAO,CAAC,cAAc;IAWtB,OAAO,CAAC,iBAAiB;IAczB,OAAO,CAAC,QAAQ;IAShB,OAAO,CAAC,UAAU;IASlB,OAAO,CAAC,SAAS;IAMjB,OAAO,CAAC,OAAO;IAmBf,OAAO,CAAC,QAAQ;CAIjB"}