reze-engine 0.3.5 → 0.3.6

package/dist/ik.js

@@ -0,0 +1,337 @@
+import { Quat, Vec3, Mat4 } from "./math";
+export class IK {
+    constructor(chains = []) {
+        // Track last target positions to detect movement
+        this.lastTargetPositions = new Map();
+        // Track convergence state for each chain (true = converged, skip solving)
+        this.convergedChains = new Set();
+        // Accumulated IK rotations for each bone (boneIndex -> quaternion)
+        this.ikRotations = new Map();
+        this.chains = chains;
+    }
+    // Set the callback to use Model's computeWorldMatrices
+    // The callback doesn't need parameters since Model uses its own runtime state
+    setComputeWorldMatricesCallback(callback) {
+        this.computeWorldMatricesCallback = callback;
+    }
+    getChains() {
+        return this.chains;
+    }
+    // Enable/disable IK chain by target bone name
+    enableChain(targetBoneName, enabled) {
+        // Chains are identified by target bone index, but we need to find by name
+        // This will be called from Model which has bone name lookup
+        for (const chain of this.chains) {
+            // We'll need to pass bone names or use indices - for now, this is a placeholder
+            // The actual implementation will be in Model class
+        }
+    }
+    // Main IK solve method - modifies bone local rotations in-place
+    solve(skeleton, localRotations, localTranslations, worldMatrices) {
+        if (this.chains.length === 0)
+            return;
+        const boneCount = skeleton.bones.length;
+        // Reset accumulated IK rotations for all chain bones (as per reference)
+        for (const chain of this.chains) {
+            for (const link of chain.links) {
+                const boneIdx = link.boneIndex;
+                if (boneIdx >= 0 && boneIdx < boneCount) {
+                    this.ikRotations.set(boneIdx, new Quat(0, 0, 0, 1));
+                }
+            }
+        }
+        // Use Model's computeWorldMatrices if available (it uses the same arrays)
+        // Otherwise fall back to simplified version
+        if (this.computeWorldMatricesCallback) {
+            this.computeWorldMatricesCallback();
+        }
+        else {
+            // Fallback to simplified version (shouldn't happen in normal usage)
+            this.computeWorldMatrices(skeleton, localRotations, localTranslations, worldMatrices);
+        }
+        // Solve each IK chain
+        for (const chain of this.chains) {
+            if (!chain.enabled)
+                continue;
+            const targetBoneIdx = chain.targetBoneIndex;
+            const effectorBoneIdx = chain.effectorBoneIndex;
+            if (targetBoneIdx < 0 || targetBoneIdx >= boneCount || effectorBoneIdx < 0 || effectorBoneIdx >= boneCount) {
+                continue;
+            }
+            // Get target position (world position of target bone)
+            // In MMD, the target bone is the bone that should reach a specific position
+            // The target bone's current world position is where we want the effector to reach
+            const targetWorldMatIdx = targetBoneIdx * 16;
+            const targetWorldMat = new Mat4(worldMatrices.subarray(targetWorldMatIdx, targetWorldMatIdx + 16));
+            const targetPos = targetWorldMat.getPosition();
+            // Check if target has moved (detect any movement, even small)
+            const lastTargetPos = this.lastTargetPositions.get(targetBoneIdx);
+            let targetMoved = false;
+            if (!lastTargetPos) {
+                // First time seeing this target, initialize position and always solve
+                this.lastTargetPositions.set(targetBoneIdx, new Vec3(targetPos.x, targetPos.y, targetPos.z));
+                targetMoved = true;
+            }
+            else {
+                const targetMoveDistance = targetPos.subtract(lastTargetPos).length();
+                targetMoved = targetMoveDistance > 0.001; // Detect any movement > 0.001 units (0.1mm)
+            }
+            // Get current effector position
+            const effectorWorldMatIdx = effectorBoneIdx * 16;
+            const effectorWorldMat = new Mat4(worldMatrices.subarray(effectorWorldMatIdx, effectorWorldMatIdx + 16));
+            const effectorPos = effectorWorldMat.getPosition();
+            // Check distance to target
+            const distanceToTarget = effectorPos.subtract(targetPos).length();
+            // If target moved, always clear convergence and solve
+            if (targetMoved) {
+                this.convergedChains.delete(targetBoneIdx);
+                this.lastTargetPositions.set(targetBoneIdx, new Vec3(targetPos.x, targetPos.y, targetPos.z));
+                // Always solve when target moves, regardless of distance
+            }
+            else if (distanceToTarget < 0.1) {
+                // Target hasn't moved and we're already close, skip solving
+                if (!this.convergedChains.has(targetBoneIdx)) {
+                    this.convergedChains.add(targetBoneIdx);
+                }
+                continue;
+            }
+            // Otherwise, solve (target hasn't moved but effector is far from target)
+            // Solve using CCD
+            // Note: In PMX, links are stored from effector toward root
+            // So links[0] is the effector, links[links.length-1] is closest to root
+            this.solveCCD(chain, skeleton, localRotations, localTranslations, worldMatrices, targetPos);
+            // Recompute world matrices after IK adjustments
+            if (this.computeWorldMatricesCallback) {
+                this.computeWorldMatricesCallback();
+            }
+            else {
+                this.computeWorldMatrices(skeleton, localRotations, localTranslations, worldMatrices);
+            }
+        }
+    }
+    // Cyclic Coordinate Descent IK solver (based on saba MMD implementation)
+    solveCCD(chain, skeleton, localRotations, localTranslations, worldMatrices, targetPos) {
+        const bones = skeleton.bones;
+        const iterationCount = chain.iterationCount;
+        const rotationConstraint = chain.rotationConstraint;
+        const links = chain.links;
+        if (links.length === 0)
+            return;
+        const effectorBoneIdx = chain.effectorBoneIndex;
+        // Get effector position
+        const effectorWorldMatIdx = effectorBoneIdx * 16;
+        const effectorWorldMat = new Mat4(worldMatrices.subarray(effectorWorldMatIdx, effectorWorldMatIdx + 16));
+        let effectorPos = effectorWorldMat.getPosition();
+        // Check initial distance - only skip if extremely close (numerical precision threshold)
+        const initialDistanceSq = effectorPos.subtract(targetPos).lengthSquared();
+        if (initialDistanceSq < 1.0e-10) {
+            this.convergedChains.add(chain.targetBoneIndex);
+            return;
+        }
+        const halfIteration = iterationCount >> 1;
+        for (let iter = 0; iter < iterationCount; iter++) {
+            const useAxis = iter < halfIteration;
+            for (let linkIdx = 0; linkIdx < links.length; linkIdx++) {
+                const link = links[linkIdx];
+                const jointBoneIdx = link.boneIndex;
+                if (jointBoneIdx < 0 || jointBoneIdx >= bones.length)
+                    continue;
+                const bone = bones[jointBoneIdx];
+                // Get joint world position
+                const jointWorldMatIdx = jointBoneIdx * 16;
+                const jointWorldMat = new Mat4(worldMatrices.subarray(jointWorldMatIdx, jointWorldMatIdx + 16));
+                const jointPos = jointWorldMat.getPosition();
+                // Vectors: from joint to target and effector (REVERSED from typical CCD!)
+                // This matches the reference implementation
+                const chainTargetVector = jointPos.subtract(targetPos).normalize();
+                const chainIkVector = jointPos.subtract(effectorPos).normalize();
+                // Rotation axis: cross product
+                const chainRotationAxis = chainTargetVector.cross(chainIkVector);
+                const axisLenSq = chainRotationAxis.lengthSquared();
+                // Skip if axis is too small (vectors are parallel)
+                if (axisLenSq < 1.0e-8)
+                    continue;
+                const chainRotationAxisNorm = chainRotationAxis.normalize();
+                // Get parent's world rotation matrix (rotation part only)
+                let parentWorldRot;
+                if (bone.parentIndex >= 0 && bone.parentIndex < bones.length) {
+                    const parentWorldMatIdx = bone.parentIndex * 16;
+                    const parentWorldMat = new Mat4(worldMatrices.subarray(parentWorldMatIdx, parentWorldMatIdx + 16));
+                    parentWorldRot = parentWorldMat.toQuat();
+                }
+                else {
+                    parentWorldRot = new Quat(0, 0, 0, 1);
+                }
+                // Transform rotation axis to parent's local space
+                // Invert parent rotation: parentWorldRot^-1
+                const parentWorldRotInv = parentWorldRot.conjugate();
+                // Transform axis: parentWorldRotInv * axis (as vector)
+                const localAxis = parentWorldRotInv.rotateVec(chainRotationAxisNorm).normalize();
+                // Calculate angle between vectors
+                const dot = Math.max(-1.0, Math.min(1.0, chainTargetVector.dot(chainIkVector)));
+                const angle = Math.min(rotationConstraint * (linkIdx + 1), Math.acos(dot));
+                // Create rotation quaternion from axis and angle
+                // q = (sin(angle/2) * axis, cos(angle/2))
+                const halfAngle = angle * 0.5;
+                const sinHalf = Math.sin(halfAngle);
+                const cosHalf = Math.cos(halfAngle);
+                const rotationFromAxis = new Quat(localAxis.x * sinHalf, localAxis.y * sinHalf, localAxis.z * sinHalf, cosHalf).normalize();
+                // Get accumulated ikRotation for this bone (or identity if first time)
+                let accumulatedIkRot = this.ikRotations.get(jointBoneIdx) || new Quat(0, 0, 0, 1);
+                // Accumulate rotation: ikRotation = rotationFromAxis * ikRotation
+                // Reference: ikRotation.multiplyToRef(chainBone.ikChainInfo!.ikRotation, chainBone.ikChainInfo!.ikRotation)
+                // This means: ikRotation = rotationFromAxis * accumulatedIkRot
+                accumulatedIkRot = rotationFromAxis.multiply(accumulatedIkRot);
+                this.ikRotations.set(jointBoneIdx, accumulatedIkRot);
+                // Get current local rotation
+                const qi = jointBoneIdx * 4;
+                const currentLocalRot = new Quat(localRotations[qi], localRotations[qi + 1], localRotations[qi + 2], localRotations[qi + 3]);
+                // Reference: ikRotation.multiplyToRef(chainBone.ikChainInfo!.localRotation, ikRotation)
+                // This means: tempRot = accumulatedIkRot * currentLocalRot
+                let tempRot = accumulatedIkRot.multiply(currentLocalRot);
+                // Apply angle constraints if specified (on the combined rotation)
+                if (link.hasLimit && link.minAngle && link.maxAngle) {
+                    tempRot = this.applyAngleConstraints(tempRot, link.minAngle, link.maxAngle);
+                }
+                // Reference: ikRotation.multiplyToRef(invertedLocalRotation, ikRotation)
+                // This means: accumulatedIkRot = tempRot * currentLocalRot^-1
+                // But we need the new local rotation, not the accumulated IK rotation
+                // The new local rotation should be: newLocalRot such that accumulatedIkRot * newLocalRot = tempRot
+                // So: newLocalRot = accumulatedIkRot^-1 * tempRot
+                // But wait, the reference updates ikRotation, not localRotation directly...
+                // Actually, looking at the reference, it seems like ikRotation is used to compute the final rotation
+                // Let me try a different approach: the reference applies constraints to (ikRotation * localRotation)
+                // then extracts the new ikRotation, but we need the new localRotation
+                // Actually, I think the issue is that we should apply: newLocalRot = tempRot (the constrained result)
+                // But we need to extract what the new local rotation should be
+                // If tempRot = accumulatedIkRot * currentLocalRot (after constraints)
+                // Then: newLocalRot = accumulatedIkRot^-1 * tempRot
+                const accumulatedIkRotInv = accumulatedIkRot.conjugate();
+                let newLocalRot = accumulatedIkRotInv.multiply(tempRot);
+                // Update local rotation
+                const normalized = newLocalRot.normalize();
+                localRotations[qi] = normalized.x;
+                localRotations[qi + 1] = normalized.y;
+                localRotations[qi + 2] = normalized.z;
+                localRotations[qi + 3] = normalized.w;
+                // Update accumulated IK rotation as per reference
+                const localRotInv = currentLocalRot.conjugate();
+                accumulatedIkRot = tempRot.multiply(localRotInv);
+                this.ikRotations.set(jointBoneIdx, accumulatedIkRot);
+                // Update world matrices after this link adjustment (only once per link, not per bone)
+                if (this.computeWorldMatricesCallback) {
+                    this.computeWorldMatricesCallback();
+                }
+                else {
+                    this.computeWorldMatrices(skeleton, localRotations, localTranslations, worldMatrices);
+                }
+                // Update effector position for next link
+                const updatedEffectorMat2 = new Mat4(worldMatrices.subarray(effectorWorldMatIdx, effectorWorldMatIdx + 16));
+                effectorPos = updatedEffectorMat2.getPosition();
+                // Early exit if converged (check against original target position)
+                const currentDistanceSq = effectorPos.subtract(targetPos).lengthSquared();
+                if (currentDistanceSq < 1.0e-10) {
+                    this.convergedChains.add(chain.targetBoneIndex);
+                    return;
+                }
+            }
+            // Check convergence at end of iteration
+            const finalEffectorMat = new Mat4(worldMatrices.subarray(effectorWorldMatIdx, effectorWorldMatIdx + 16));
+            const finalEffectorPos = finalEffectorMat.getPosition();
+            const finalDistanceSq = finalEffectorPos.subtract(targetPos).lengthSquared();
+            if (finalDistanceSq < 1.0e-10) {
+                this.convergedChains.add(chain.targetBoneIndex);
+                break;
+            }
+        }
+    }
+    // Apply angle constraints to local rotation (Euler angle limits)
+    applyAngleConstraints(localRot, minAngle, maxAngle) {
+        // Convert quaternion to Euler angles
+        const euler = localRot.toEuler();
+        // Clamp each Euler angle component
+        let clampedX = Math.max(minAngle.x, Math.min(maxAngle.x, euler.x));
+        let clampedY = Math.max(minAngle.y, Math.min(maxAngle.y, euler.y));
+        let clampedZ = Math.max(minAngle.z, Math.min(maxAngle.z, euler.z));
+        // Convert back to quaternion (ZXY order, left-handed)
+        return Quat.fromEuler(clampedX, clampedY, clampedZ);
+    }
+    // Compute world matrices from local rotations and translations
+    // This matches Model.computeWorldMatrices logic (including append transforms)
+    computeWorldMatrices(skeleton, localRotations, localTranslations, worldMatrices) {
+        const bones = skeleton.bones;
+        const boneCount = bones.length;
+        const computed = new Array(boneCount).fill(false);
+        const computeWorld = (i) => {
+            if (computed[i])
+                return;
+            const bone = bones[i];
+            if (bone.parentIndex >= boneCount) {
+                console.warn(`[IK] bone ${i} parent out of range: ${bone.parentIndex}`);
+            }
+            const qi = i * 4;
+            const ti = i * 3;
+            // Get local rotation
+            let rotateM = Mat4.fromQuat(localRotations[qi], localRotations[qi + 1], localRotations[qi + 2], localRotations[qi + 3]);
+            let addLocalTx = 0, addLocalTy = 0, addLocalTz = 0;
+            // Handle append transforms (same as Model.computeWorldMatrices)
+            const appendParentIdx = bone.appendParentIndex;
+            const hasAppend = bone.appendRotate && appendParentIdx !== undefined && appendParentIdx >= 0 && appendParentIdx < boneCount;
+            if (hasAppend) {
+                const ratio = bone.appendRatio === undefined ? 1 : Math.max(-1, Math.min(1, bone.appendRatio));
+                const hasRatio = Math.abs(ratio) > 1e-6;
+                if (hasRatio) {
+                    const apQi = appendParentIdx * 4;
+                    const apTi = appendParentIdx * 3;
+                    if (bone.appendRotate) {
+                        let ax = localRotations[apQi];
+                        let ay = localRotations[apQi + 1];
+                        let az = localRotations[apQi + 2];
+                        const aw = localRotations[apQi + 3];
+                        const absRatio = ratio < 0 ? -ratio : ratio;
+                        if (ratio < 0) {
+                            ax = -ax;
+                            ay = -ay;
+                            az = -az;
+                        }
+                        const identityQuat = new Quat(0, 0, 0, 1);
+                        const appendQuat = new Quat(ax, ay, az, aw);
+                        const result = Quat.slerp(identityQuat, appendQuat, absRatio);
+                        rotateM = Mat4.fromQuat(result.x, result.y, result.z, result.w).multiply(rotateM);
+                    }
+                    if (bone.appendMove) {
+                        const appendRatio = bone.appendRatio ?? 1;
+                        addLocalTx = localTranslations[apTi] * appendRatio;
+                        addLocalTy = localTranslations[apTi + 1] * appendRatio;
+                        addLocalTz = localTranslations[apTi + 2] * appendRatio;
+                    }
+                }
+            }
+            // Get bone's own translation
+            const boneTx = localTranslations[ti];
+            const boneTy = localTranslations[ti + 1];
+            const boneTz = localTranslations[ti + 2];
+            // Build local matrix: bindTranslation + rotation + (bone translation + append translation)
+            const localM = Mat4.identity().translateInPlace(bone.bindTranslation[0], bone.bindTranslation[1], bone.bindTranslation[2]);
+            const transM = Mat4.identity().translateInPlace(boneTx + addLocalTx, boneTy + addLocalTy, boneTz + addLocalTz);
+            const localMatrix = localM.multiply(rotateM).multiply(transM);
+            const worldOffset = i * 16;
+            if (bone.parentIndex >= 0) {
+                const p = bone.parentIndex;
+                if (!computed[p])
+                    computeWorld(p);
+                const parentOffset = p * 16;
+                const parentWorldMat = new Mat4(worldMatrices.subarray(parentOffset, parentOffset + 16));
+                const worldMat = parentWorldMat.multiply(localMatrix);
+                worldMatrices.set(worldMat.values, worldOffset);
+            }
+            else {
+                worldMatrices.set(localMatrix.values, worldOffset);
+            }
+            computed[i] = true;
+        };
+        // Process all bones
+        for (let i = 0; i < boneCount; i++)
+            computeWorld(i);
+    }
+}

package/dist/math.d.ts

@@ -7,12 +7,10 @@ export declare class Vec3 {
     add(other: Vec3): Vec3;
     subtract(other: Vec3): Vec3;
     length(): number;
-    lengthSquared(): number;
     normalize(): Vec3;
     cross(other: Vec3): Vec3;
     dot(other: Vec3): number;
     scale(scalar: number): Vec3;
-    clone(): Vec3;
 }
 export declare class Quat {
     x: number;
@@ -26,13 +24,10 @@ export declare class Quat {
     conjugate(): Quat;
     length(): number;
     normalize(): Quat;
-    rotateVec(v: Vec3): Vec3;
-    static fromTo(from: Vec3, to: Vec3): Quat;
     static fromAxisAngle(axis: Vec3, angle: number): Quat;
     toArray(): [number, number, number, number];
     static slerp(a: Quat, b: Quat, t: number): Quat;
     static fromEuler(rotX: number, rotY: number, rotZ: number): Quat;
-    toEuler(): Vec3;
 }
 export declare class Mat4 {
     values: Float32Array;

package/dist/math.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"math.d.ts","sourceRoot":"","sources":["../src/math.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"math.d.ts","sourceRoot":"","sources":["../src/math.ts"],"names":[],"mappings":"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"}

package/dist/math.js

@@ -17,9 +17,6 @@ export class Vec3 {
     length() {
         return Math.sqrt(this.x * this.x + this.y * this.y + this.z * this.z);
     }
-    lengthSquared() {
-        return this.x * this.x + this.y * this.y + this.z * this.z;
-    }
     normalize() {
         const len = this.length();
         if (len === 0)
@@ -35,9 +32,6 @@ export class Vec3 {
     scale(scalar) {
         return new Vec3(this.x * scalar, this.y * scalar, this.z * scalar);
     }
-    clone() {
-        return new Vec3(this.x, this.y, this.z);
-    }
 }
 export class Quat {
     constructor(x, y, z, w) {
@@ -69,35 +63,6 @@ export class Quat {
             return new Quat(0, 0, 0, 1);
         return new Quat(this.x / len, this.y / len, this.z / len, this.w / len);
     }
-    // Rotate a vector by this quaternion: result = q * v * q^-1
-    rotateVec(v) {
-        // Treat v as pure quaternion (x, y, z, 0)
-        const qx = this.x, qy = this.y, qz = this.z, qw = this.w;
-        const vx = v.x, vy = v.y, vz = v.z;
-        // t = 2 * cross(q.xyz, v)
-        const tx = 2 * (qy * vz - qz * vy);
-        const ty = 2 * (qz * vx - qx * vz);
-        const tz = 2 * (qx * vy - qy * vx);
-        // result = v + q.w * t + cross(q.xyz, t)
-        return new Vec3(vx + qw * tx + (qy * tz - qz * ty), vy + qw * ty + (qz * tx - qx * tz), vz + qw * tz + (qx * ty - qy * tx));
-    }
-    // Static method: create quaternion that rotates from one direction to another
-    static fromTo(from, to) {
-        const dot = from.dot(to);
-        if (dot > 0.999999)
-            return new Quat(0, 0, 0, 1); // Already aligned
-        if (dot < -0.999999) {
-            // 180 degrees
-            let axis = from.cross(new Vec3(1, 0, 0));
-            if (axis.length() < 0.001)
-                axis = from.cross(new Vec3(0, 1, 0));
-            return new Quat(axis.x, axis.y, axis.z, 0).normalize();
-        }
-        const axis = from.cross(to);
-        const w = Math.sqrt((1 + dot) * 2);
-        const invW = 1 / w;
-        return new Quat(axis.x * invW, axis.y * invW, axis.z * invW, w * 0.5).normalize();
-    }
     // Static method: create quaternion from rotation axis and angle
     static fromAxisAngle(axis, angle) {
         const normalizedAxis = axis.normalize();
@@ -152,26 +117,6 @@ export class Quat {
         const z = cy * cx * sz - sy * sx * cz;
         return new Quat(x, y, z, w).normalize();
     }
-    // Convert quaternion to Euler angles (ZXY order, inverse of fromEuler)
-    toEuler() {
-        const qx = this.x;
-        const qy = this.y;
-        const qz = this.z;
-        const qw = this.w;
-        // ZXY order (left-handed)
-        // Roll (X): rotation around X axis
-        const sinr_cosp = 2 * (qw * qx + qy * qz);
-        const cosr_cosp = 1 - 2 * (qx * qx + qy * qy);
-        const rotX = Math.atan2(sinr_cosp, cosr_cosp);
-        // Pitch (Y): rotation around Y axis
-        const sinp = 2 * (qw * qy - qz * qx);
-        const rotY = Math.abs(sinp) >= 1 ? (sinp >= 0 ? Math.PI / 2 : -Math.PI / 2) : Math.asin(sinp);
-        // Yaw (Z): rotation around Z axis
-        const siny_cosp = 2 * (qw * qz + qx * qy);
-        const cosy_cosp = 1 - 2 * (qy * qy + qz * qz);
-        const rotZ = Math.atan2(siny_cosp, cosy_cosp);
-        return new Vec3(rotX, rotY, rotZ);
-    }
 }
 export class Mat4 {
     constructor(values) {

package/dist/model.d.ts

@@ -118,6 +118,7 @@ export declare class Model {
     private initializeRotTweenBuffers;
     private initializeTransTweenBuffers;
     private initializeMorphTweenBuffers;
+    private createTweenState;
     private initializeRuntimeMorph;
     private updateRotationTweens;
     private updateTranslationTweens;
@@ -125,7 +126,6 @@ export declare class Model {
     getVertices(): Float32Array<ArrayBuffer>;
     getTextures(): Texture[];
     getMaterials(): Material[];
-    getVertexCount(): number;
     getIndices(): Uint32Array<ArrayBuffer>;
     getSkeleton(): Skeleton;
     getSkinning(): Skinning;
@@ -133,12 +133,10 @@ export declare class Model {
     getJoints(): Joint[];
     getMorphing(): Morphing;
     getMorphWeights(): Float32Array;
-    getBoneNames(): string[];
     rotateBones(names: string[], quats: Quat[], durationMs?: number): void;
     moveBones(names: string[], relativeTranslations: Vec3[], durationMs?: number): void;
     getBoneWorldMatrices(): Float32Array;
     getBoneInverseBindMatrices(): Float32Array;
-    getMorphNames(): string[];
     setMorphWeight(name: string, weight: number, durationMs?: number): void;
     private applyMorphs;
     evaluatePose(): boolean;

package/dist/model.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"model.d.ts","sourceRoot":"","sources":["../src/model.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"model.d.ts","sourceRoot":"","sources":["../src/model.ts"],"names":[],"mappings":"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"}

package/dist/model.js

@@ -89,33 +89,21 @@ export class Model {
         this.runtimeSkeleton.ikSolvers = ikSolvers;
     }
     initializeRotTweenBuffers() {
-        const n = this.skeleton.bones.length;
-        this.rotTweenState = {
-            active: new Uint8Array(n),
-            startQuat: new Float32Array(n * 4),
-            targetQuat: new Float32Array(n * 4),
-            startTimeMs: new Float32Array(n),
-            durationMs: new Float32Array(n),
-        };
+        this.rotTweenState = this.createTweenState(this.skeleton.bones.length, 4, 4);
     }
     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),
-        };
+        this.transTweenState = this.createTweenState(this.skeleton.bones.length, 3, 3);
     }
     initializeMorphTweenBuffers() {
-        const n = this.morphing.morphs.length;
-        this.morphTweenState = {
-            active: new Uint8Array(n),
-            startWeight: new Float32Array(n),
-            targetWeight: new Float32Array(n),
-            startTimeMs: new Float32Array(n),
-            durationMs: new Float32Array(n),
+        this.morphTweenState = this.createTweenState(this.morphing.morphs.length, 1, 1);
+    }
+    createTweenState(count, startSize, targetSize) {
+        return {
+            active: new Uint8Array(count),
+            startQuat: new Float32Array(count * startSize),
+            targetQuat: new Float32Array(count * targetSize),
+            startTimeMs: new Float32Array(count),
+            durationMs: new Float32Array(count),
         };
     }
     initializeRuntimeMorph() {
@@ -194,42 +182,30 @@ export class Model {
         }
         return hasActiveTweens;
     }
-    // Get interleaved vertex data for GPU upload
-    // Format: [x,y,z, nx,ny,nz, u,v, x,y,z, nx,ny,nz, u,v, ...]
     getVertices() {
         return this.vertexData;
     }
-    // Get texture information
     getTextures() {
         return this.textures;
     }
-    // Get material information
     getMaterials() {
         return this.materials;
     }
-    // Get vertex count
-    getVertexCount() {
-        return this.vertexCount;
-    }
-    // Get index data for GPU upload
     getIndices() {
         return this.indexData;
     }
-    // Accessors for skeleton/skinning
     getSkeleton() {
         return this.skeleton;
     }
     getSkinning() {
         return this.skinning;
     }
-    // Accessors for physics data
     getRigidbodies() {
         return this.rigidbodies;
     }
     getJoints() {
         return this.joints;
     }
-    // Accessors for morphing
     getMorphing() {
         return this.morphing;
     }
@@ -237,9 +213,6 @@ export class Model {
         return this.runtimeMorph.weights;
     }
     // ------- Bone helpers (public API) -------
-    getBoneNames() {
-        return this.skeleton.bones.map((b) => b.name);
-    }
     rotateBones(names, quats, durationMs) {
         const state = this.rotTweenState;
         const normalized = quats.map((q) => q.normalize());
@@ -382,9 +355,6 @@ export class Model {
     getBoneInverseBindMatrices() {
         return this.skeleton.inverseBindMatrices;
     }
-    getMorphNames() {
-        return this.morphing.morphs.map((m) => m.name);
-    }
     setMorphWeight(name, weight, durationMs) {
         const idx = this.runtimeMorph.nameIndex[name] ?? -1;
         if (idx < 0 || idx >= this.runtimeMorph.weights.length)

package/dist/player.d.ts

@@ -13,13 +13,11 @@ export declare class Player {
     private frames;
     private boneTracks;
     private morphTracks;
-    private duration;
+    private _duration;
     private isPlaying;
     private isPaused;
-    private currentTime;
+    private _currentTime;
     private startTime;
-    private pausedTime;
-    private pauseStartTime;
     /**
      * Load VMD animation file
      */
@@ -58,21 +56,9 @@ export declare class Player {
      * 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;
+    get currentTime(): number;
+    get duration(): number;
+    get isPlayingState(): boolean;
+    get isPausedState(): boolean;
 }
 //# sourceMappingURL=player.d.ts.map