reze-engine 0.2.19 → 0.3.1

package/dist/model.js

@@ -1,5 +1,22 @@
-import { Mat4, Quat, easeInOut } from "./math";
+import { Mat4, Quat, Vec3, easeInOut } from "./math";
+import { IKSolverSystem } from "./ik-solver";
 const VERTEX_STRIDE = 8;
+// Euler rotation order for angle constraints
+export var EulerRotationOrder;
+(function (EulerRotationOrder) {
+    EulerRotationOrder[EulerRotationOrder["YXZ"] = 0] = "YXZ";
+    EulerRotationOrder[EulerRotationOrder["ZYX"] = 1] = "ZYX";
+    EulerRotationOrder[EulerRotationOrder["XZY"] = 2] = "XZY";
+})(EulerRotationOrder || (EulerRotationOrder = {}));
+// Solve axis optimization
+export var SolveAxis;
+(function (SolveAxis) {
+    SolveAxis[SolveAxis["None"] = 0] = "None";
+    SolveAxis[SolveAxis["Fixed"] = 1] = "Fixed";
+    SolveAxis[SolveAxis["X"] = 2] = "X";
+    SolveAxis[SolveAxis["Y"] = 3] = "Y";
+    SolveAxis[SolveAxis["Z"] = 4] = "Z";
+})(SolveAxis || (SolveAxis = {}));
 export class Model {
     constructor(vertexData, indexData, textures, materials, skeleton, skinning, morphing, rigidbodies = [], joints = []) {
         this.textures = [];
@@ -27,6 +44,7 @@ export class Model {
         }
         this.initializeRuntimeSkeleton();
         this.initializeRotTweenBuffers();
+        this.initializeTransTweenBuffers();
         this.initializeRuntimeMorph();
         this.initializeMorphTweenBuffers();
         this.applyMorphs(); // Apply initial morphs (all weights are 0, so no change)
@@ -53,6 +71,51 @@ export class Model {
                 rotations[qi + 3] = 1;
             }
         }
+        // Initialize IK runtime state
+        this.initializeIKRuntime();
+    }
+    initializeIKRuntime() {
+        const boneCount = this.skeleton.bones.length;
+        const bones = this.skeleton.bones;
+        // Initialize IK chain info for all bones (will be populated for IK chain bones)
+        const ikChainInfo = new Array(boneCount);
+        for (let i = 0; i < boneCount; i++) {
+            ikChainInfo[i] = {
+                ikRotation: new Quat(0, 0, 0, 1),
+                localRotation: new Quat(0, 0, 0, 1),
+            };
+        }
+        // Build IK solvers from bone data
+        const ikSolvers = [];
+        let solverIndex = 0;
+        for (let i = 0; i < boneCount; i++) {
+            const bone = bones[i];
+            if (bone.ikTargetIndex !== undefined && bone.ikLinks && bone.ikLinks.length > 0) {
+                // Check if all links are affected by physics (for optimization)
+                let canSkipWhenPhysicsEnabled = true;
+                for (const link of bone.ikLinks) {
+                    // For now, assume no bones are physics-controlled (can be enhanced later)
+                    // If a bone has a rigidbody attached, it's physics-controlled
+                    const hasPhysics = this.rigidbodies.some((rb) => rb.boneIndex === link.boneIndex);
+                    if (!hasPhysics) {
+                        canSkipWhenPhysicsEnabled = false;
+                        break;
+                    }
+                }
+                const solver = {
+                    index: solverIndex++,
+                    ikBoneIndex: i,
+                    targetBoneIndex: bone.ikTargetIndex,
+                    iterationCount: bone.ikIteration ?? 1,
+                    limitAngle: bone.ikLimitAngle ?? Math.PI,
+                    links: bone.ikLinks,
+                    canSkipWhenPhysicsEnabled,
+                };
+                ikSolvers.push(solver);
+            }
+        }
+        this.runtimeSkeleton.ikChainInfo = ikChainInfo;
+        this.runtimeSkeleton.ikSolvers = ikSolvers;
     }
     initializeRotTweenBuffers() {
         const n = this.skeleton.bones.length;
@@ -64,6 +127,16 @@ export class Model {
             durationMs: new Float32Array(n),
         };
     }
+    initializeTransTweenBuffers() {
+        const n = this.skeleton.bones.length;
+        this.transTweenState = {
+            active: new Uint8Array(n),
+            startVec: new Float32Array(n * 3),
+            targetVec: new Float32Array(n * 3),
+            startTimeMs: new Float32Array(n),
+            durationMs: new Float32Array(n),
+        };
+    }
     initializeMorphTweenBuffers() {
         const n = this.morphing.morphs.length;
         this.morphTweenState = {
@@ -108,6 +181,26 @@ export class Model {
                 state.active[i] = 0;
         }
     }
+    updateTranslationTweens() {
+        const state = this.transTweenState;
+        const now = performance.now();
+        const translations = this.runtimeSkeleton.localTranslations;
+        const boneCount = this.skeleton.bones.length;
+        for (let i = 0; i < boneCount; i++) {
+            if (state.active[i] !== 1)
+                continue;
+            const startMs = state.startTimeMs[i];
+            const durMs = Math.max(1, state.durationMs[i]);
+            const t = Math.max(0, Math.min(1, (now - startMs) / durMs));
+            const e = easeInOut(t);
+            const ti = i * 3;
+            translations[ti] = state.startVec[ti] + (state.targetVec[ti] - state.startVec[ti]) * e;
+            translations[ti + 1] = state.startVec[ti + 1] + (state.targetVec[ti + 1] - state.startVec[ti + 1]) * e;
+            translations[ti + 2] = state.startVec[ti + 2] + (state.targetVec[ti + 2] - state.startVec[ti + 2]) * e;
+            if (t >= 1)
+                state.active[i] = 0;
+        }
+    }
     updateMorphWeightTweens() {
         const state = this.morphTweenState;
         const now = performance.now();
@@ -231,6 +324,91 @@ export class Model {
             state.active[idx] = 1;
         }
     }
+    // Move bones using VMD-style relative translations (relative to bind pose world position)
+    // This is the default behavior for VMD animations
+    moveBones(names, relativeTranslations, durationMs) {
+        const state = this.transTweenState;
+        const now = performance.now();
+        const dur = durationMs && durationMs > 0 ? durationMs : 0;
+        const localRot = this.runtimeSkeleton.localRotations;
+        // Compute bind pose world positions for all bones
+        const skeleton = this.skeleton;
+        const computeBindPoseWorldPosition = (idx) => {
+            const bone = skeleton.bones[idx];
+            const bindPos = new Vec3(bone.bindTranslation[0], bone.bindTranslation[1], bone.bindTranslation[2]);
+            if (bone.parentIndex >= 0 && bone.parentIndex < skeleton.bones.length) {
+                const parentWorldPos = computeBindPoseWorldPosition(bone.parentIndex);
+                return parentWorldPos.add(bindPos);
+            }
+            else {
+                return bindPos;
+            }
+        };
+        for (let i = 0; i < names.length; i++) {
+            const name = names[i];
+            const idx = this.runtimeSkeleton.nameIndex[name] ?? -1;
+            if (idx < 0 || idx >= this.skeleton.bones.length)
+                continue;
+            const bone = this.skeleton.bones[idx];
+            const ti = idx * 3;
+            const qi = idx * 4;
+            const translations = this.runtimeSkeleton.localTranslations;
+            const vmdRelativeTranslation = relativeTranslations[i];
+            // VMD translation is relative to bind pose world position
+            // targetWorldPos = bindPoseWorldPos + vmdRelativeTranslation
+            const bindPoseWorldPos = computeBindPoseWorldPosition(idx);
+            const targetWorldPos = bindPoseWorldPos.add(vmdRelativeTranslation);
+            // Convert target world position to local translation
+            // We need parent's bind pose world position to transform to parent space
+            let parentBindPoseWorldPos;
+            if (bone.parentIndex >= 0) {
+                parentBindPoseWorldPos = computeBindPoseWorldPosition(bone.parentIndex);
+            }
+            else {
+                parentBindPoseWorldPos = new Vec3(0, 0, 0);
+            }
+            // Transform target world position to parent's local space
+            // In bind pose, parent's world matrix is just a translation
+            const parentSpacePos = targetWorldPos.subtract(parentBindPoseWorldPos);
+            // Subtract bindTranslation to get position after bind translation
+            const afterBindTranslation = parentSpacePos.subtract(new Vec3(bone.bindTranslation[0], bone.bindTranslation[1], bone.bindTranslation[2]));
+            // Apply inverse rotation to get local translation
+            const localRotation = new Quat(localRot[qi], localRot[qi + 1], localRot[qi + 2], localRot[qi + 3]);
+            const invRotation = localRotation.conjugate().normalize();
+            const rotationMat = Mat4.fromQuat(invRotation.x, invRotation.y, invRotation.z, invRotation.w);
+            const rm = rotationMat.values;
+            const localTranslation = new Vec3(rm[0] * afterBindTranslation.x + rm[4] * afterBindTranslation.y + rm[8] * afterBindTranslation.z, rm[1] * afterBindTranslation.x + rm[5] * afterBindTranslation.y + rm[9] * afterBindTranslation.z, rm[2] * afterBindTranslation.x + rm[6] * afterBindTranslation.y + rm[10] * afterBindTranslation.z);
+            const [tx, ty, tz] = [localTranslation.x, localTranslation.y, localTranslation.z];
+            if (dur === 0) {
+                translations[ti] = tx;
+                translations[ti + 1] = ty;
+                translations[ti + 2] = tz;
+                state.active[idx] = 0;
+                continue;
+            }
+            let sx = translations[ti];
+            let sy = translations[ti + 1];
+            let sz = translations[ti + 2];
+            if (state.active[idx] === 1) {
+                const startMs = state.startTimeMs[idx];
+                const prevDur = Math.max(1, state.durationMs[idx]);
+                const t = Math.max(0, Math.min(1, (now - startMs) / prevDur));
+                const e = easeInOut(t);
+                sx = state.startVec[ti] + (state.targetVec[ti] - state.startVec[ti]) * e;
+                sy = state.startVec[ti + 1] + (state.targetVec[ti + 1] - state.startVec[ti + 1]) * e;
+                sz = state.startVec[ti + 2] + (state.targetVec[ti + 2] - state.startVec[ti + 2]) * e;
+            }
+            state.startVec[ti] = sx;
+            state.startVec[ti + 1] = sy;
+            state.startVec[ti + 2] = sz;
+            state.targetVec[ti] = tx;
+            state.targetVec[ti + 1] = ty;
+            state.targetVec[ti + 2] = tz;
+            state.startTimeMs[idx] = now;
+            state.durationMs[idx] = dur;
+            state.active[idx] = 1;
+        }
+    }
     getBoneWorldMatrices() {
         return this.runtimeSkeleton.worldMatrices;
     }
@@ -334,13 +512,29 @@ export class Model {
     }
     evaluatePose() {
         this.updateRotationTweens();
+        this.updateTranslationTweens();
         const hasActiveMorphTweens = this.updateMorphWeightTweens();
         if (hasActiveMorphTweens) {
             this.applyMorphs();
         }
+        // Compute initial world matrices (needed for IK solving)
+        this.computeWorldMatrices();
+        // Solve IK chains (modifies localRotations)
+        this.solveIKChains();
+        // Recompute world matrices with IK rotations applied
         this.computeWorldMatrices();
         return hasActiveMorphTweens;
     }
+    solveIKChains() {
+        const ikSolvers = this.runtimeSkeleton.ikSolvers;
+        if (!ikSolvers || ikSolvers.length === 0)
+            return;
+        const ikChainInfo = this.runtimeSkeleton.ikChainInfo;
+        if (!ikChainInfo)
+            return;
+        IKSolverSystem.solve(ikSolvers, this.skeleton.bones, this.runtimeSkeleton.localRotations, this.runtimeSkeleton.localTranslations, this.runtimeSkeleton.worldMatrices, ikChainInfo, false // usePhysics - can be enhanced later
+        );
+    }
     computeWorldMatrices() {
         const bones = this.skeleton.bones;
         const localRot = this.runtimeSkeleton.localRotations;
@@ -397,11 +591,15 @@ export class Model {
                     }
                 }
             }
-            // Build local matrix: identity + bind translation, then rotation, then append translation
+            // Build local matrix: identity + bind translation, then rotation, then local translation, then append translation
+            const ti = i * 3;
+            const localTx = localTrans[ti] + addLocalTx;
+            const localTy = localTrans[ti + 1] + addLocalTy;
+            const localTz = localTrans[ti + 2] + addLocalTz;
             this.cachedIdentityMat1
                 .setIdentity()
                 .translateInPlace(b.bindTranslation[0], b.bindTranslation[1], b.bindTranslation[2]);
-            this.cachedIdentityMat2.setIdentity().translateInPlace(addLocalTx, addLocalTy, addLocalTz);
+            this.cachedIdentityMat2.setIdentity().translateInPlace(localTx, localTy, localTz);
             const localM = this.cachedIdentityMat1.multiply(rotateM).multiply(this.cachedIdentityMat2);
             const worldOffset = i * 16;
             if (b.parentIndex >= 0) {

package/dist/player.d.ts

@@ -0,0 +1,100 @@
+import { Quat, Vec3 } from "./math";
+export interface AnimationPose {
+    boneRotations: Map<string, Quat>;
+    boneTranslations: Map<string, Vec3>;
+    morphWeights: Map<string, number>;
+}
+export interface AnimationProgress {
+    current: number;
+    duration: number;
+    percentage: number;
+}
+export declare class Player {
+    private frames;
+    private boneTracks;
+    private morphTracks;
+    private duration;
+    private isPlaying;
+    private isPaused;
+    private currentTime;
+    private startTime;
+    private pausedTime;
+    private pauseStartTime;
+    private audioElement?;
+    private audioUrl?;
+    private audioLoaded;
+    /**
+     * Load VMD animation file and optionally audio
+     */
+    loadVmd(vmdUrl: string, audioUrl?: string): Promise<void>;
+    /**
+     * Load audio file
+     */
+    loadAudio(url: string): Promise<void>;
+    /**
+     * Process frames into tracks
+     */
+    private processFrames;
+    /**
+     * Start or resume playback
+     */
+    play(): void;
+    /**
+     * Pause playback
+     */
+    pause(): void;
+    /**
+     * Stop playback and reset to beginning
+     */
+    stop(): void;
+    /**
+     * Seek to specific time
+     */
+    seek(time: number): void;
+    /**
+     * Update playback and return current pose
+     * Returns null if not playing, but returns current pose if paused
+     */
+    update(currentRealTime: number): AnimationPose | null;
+    /**
+     * Get pose at specific time (pure function)
+     */
+    getPoseAtTime(time: number): AnimationPose;
+    /**
+     * Get current playback progress
+     */
+    getProgress(): AnimationProgress;
+    /**
+     * Get current time
+     */
+    getCurrentTime(): number;
+    /**
+     * Get animation duration
+     */
+    getDuration(): number;
+    /**
+     * Check if playing
+     */
+    isPlayingState(): boolean;
+    /**
+     * Check if paused
+     */
+    isPausedState(): boolean;
+    /**
+     * Check if has audio
+     */
+    hasAudio(): boolean;
+    /**
+     * Set audio volume (0.0 to 1.0)
+     */
+    setVolume(volume: number): void;
+    /**
+     * Mute audio
+     */
+    mute(): void;
+    /**
+     * Unmute audio
+     */
+    unmute(): void;
+}
+//# sourceMappingURL=player.d.ts.map

package/dist/player.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"player.d.ts","sourceRoot":"","sources":["../src/player.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAA;AAGnC,MAAM,WAAW,aAAa;IAC5B,aAAa,EAAE,GAAG,CAAC,MAAM,EAAE,IAAI,CAAC,CAAA;IAChC,gBAAgB,EAAE,GAAG,CAAC,MAAM,EAAE,IAAI,CAAC,CAAA;IACnC,YAAY,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CAClC;AAED,MAAM,WAAW,iBAAiB;IAChC,OAAO,EAAE,MAAM,CAAA;IACf,QAAQ,EAAE,MAAM,CAAA;IAChB,UAAU,EAAE,MAAM,CAAA;CACnB;AAED,qBAAa,MAAM;IAEjB,OAAO,CAAC,MAAM,CAAoB;IAClC,OAAO,CAAC,UAAU,CAAwE;IAC1F,OAAO,CAAC,WAAW,CAA0E;IAC7F,OAAO,CAAC,QAAQ,CAAY;IAG5B,OAAO,CAAC,SAAS,CAAiB;IAClC,OAAO,CAAC,QAAQ,CAAiB;IACjC,OAAO,CAAC,WAAW,CAAY;IAG/B,OAAO,CAAC,SAAS,CAAY;IAC7B,OAAO,CAAC,UAAU,CAAY;IAC9B,OAAO,CAAC,cAAc,CAAY;IAGlC,OAAO,CAAC,YAAY,CAAC,CAAkB;IACvC,OAAO,CAAC,QAAQ,CAAC,CAAQ;IACzB,OAAO,CAAC,WAAW,CAAiB;IAEpC;;OAEG;IACG,OAAO,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAW/D;;OAEG;IACG,SAAS,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAyB3C;;OAEG;IACH,OAAO,CAAC,aAAa;IAwErB;;OAEG;IACH,IAAI,IAAI,IAAI;IAyBZ;;OAEG;IACH,KAAK,IAAI,IAAI;IAYb;;OAEG;IACH,IAAI,IAAI,IAAI;IAcZ;;OAEG;IACH,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;IAgBxB;;;OAGG;IACH,MAAM,CAAC,eAAe,EAAE,MAAM,GAAG,aAAa,GAAG,IAAI;IAiCrD;;OAEG;IACH,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,aAAa;IA+I1C;;OAEG;IACH,WAAW,IAAI,iBAAiB;IAQhC;;OAEG;IACH,cAAc,IAAI,MAAM;IAIxB;;OAEG;IACH,WAAW,IAAI,MAAM;IAIrB;;OAEG;IACH,cAAc,IAAI,OAAO;IAIzB;;OAEG;IACH,aAAa,IAAI,OAAO;IAIxB;;OAEG;IACH,QAAQ,IAAI,OAAO;IAInB;;OAEG;IACH,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAM/B;;OAEG;IACH,IAAI,IAAI,IAAI;IAMZ;;OAEG;IACH,MAAM,IAAI,IAAI;CAKf"}