reze-engine 0.3.4 → 0.3.5

package/src/model.ts

@@ -50,24 +50,6 @@ export interface IKLink {
   hasLimit: boolean
   minAngle?: Vec3 // Minimum Euler angles (radians)
   maxAngle?: Vec3 // Maximum Euler angles (radians)
-  rotationOrder?: EulerRotationOrder // YXZ, ZYX, or XZY
-  solveAxis?: SolveAxis // None, Fixed, X, Y, or Z
-}
-
-// Euler rotation order for angle constraints
-export enum EulerRotationOrder {
-  YXZ = 0,
-  ZYX = 1,
-  XZY = 2,
-}
-
-// Solve axis optimization
-export enum SolveAxis {
-  None = 0,
-  Fixed = 1,
-  X = 2,
-  Y = 3,
-  Z = 4,
 }
 
 // IK solver definition
@@ -78,7 +60,6 @@ export interface IKSolver {
   iterationCount: number
   limitAngle: number // Max rotation per iteration (radians)
   links: IKLink[] // Chain bones from effector to root
-  canSkipWhenPhysicsEnabled: boolean
 }
 
 // IK chain info per bone (runtime state)
@@ -128,7 +109,6 @@ export interface SkeletonRuntime {
   localRotations: Float32Array // quat per bone (x,y,z,w) length = boneCount*4
   localTranslations: Float32Array // vec3 per bone length = boneCount*3
   worldMatrices: Float32Array // mat4 per bone length = boneCount*16
-  computedBones: boolean[] // length = boneCount
   ikChainInfo?: IKChainInfo[] // IK chain info per bone (only for IK chain bones)
   ikSolvers?: IKSolver[] // All IK solvers in the model
 }
@@ -245,7 +225,6 @@ export class Model {
         acc[bone.name] = index
         return acc
       }, {} as Record<string, number>),
-      computedBones: new Array(boneCount).fill(false),
     }
 
     const rotations = this.runtimeSkeleton.localRotations
@@ -283,18 +262,6 @@ export class Model {
     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: IKSolver = {
           index: solverIndex++,
           ikBoneIndex: i,
@@ -302,7 +269,6 @@ export class Model {
           iterationCount: bone.ikIteration ?? 1,
           limitAngle: bone.ikLimitAngle ?? Math.PI,
           links: bone.ikLinks,
-          canSkipWhenPhysicsEnabled,
         }
         ikSolvers.push(solver)
       }
@@ -550,14 +516,10 @@ export class Model {
           state.targetQuat[qi + 3]
         )
         const result = Quat.slerp(startQuat, targetQuat, e)
-        const cx = result.x
-        const cy = result.y
-        const cz = result.z
-        const cw = result.w
-        sx = cx
-        sy = cy
-        sz = cz
-        sw = cw
+        sx = result.x
+        sy = result.y
+        sz = result.z
+        sw = result.w
       }
 
       state.startQuat[qi] = sx
@@ -706,10 +668,9 @@ export class Model {
     // Animated change
     const state = this.morphTweenState
     const now = performance.now()
-    const currentWeight = this.runtimeMorph.weights[idx]
 
     // If already tweening, start from current interpolated value
-    let startWeight = currentWeight
+    let startWeight = this.runtimeMorph.weights[idx]
     if (state.active[idx] === 1) {
       const startMs = state.startTimeMs[idx]
       const prevDur = Math.max(1, state.durationMs[idx])
@@ -802,13 +763,13 @@ export class Model {
       this.applyMorphs()
     }
 
-    // Compute initial world matrices (needed for IK solving)
+    // Compute initial world matrices (needed for IK solving to read bone positions)
     this.computeWorldMatrices()
 
-    // Solve IK chains (modifies localRotations)
+    // Solve IK chains (modifies localRotations with final IK rotations)
     this.solveIKChains()
 
-    // Recompute world matrices with IK rotations applied
+    // Recompute world matrices with final IK rotations applied to localRotations
     this.computeWorldMatrices()
 
     return hasActiveMorphTweens
@@ -827,8 +788,7 @@ export class Model {
       this.runtimeSkeleton.localRotations,
       this.runtimeSkeleton.localTranslations,
       this.runtimeSkeleton.worldMatrices,
-      ikChainInfo,
-      false // usePhysics - can be enhanced later
+      ikChainInfo
     )
   }
 
@@ -837,11 +797,13 @@ export class Model {
     const localRot = this.runtimeSkeleton.localRotations
     const localTrans = this.runtimeSkeleton.localTranslations
     const worldBuf = this.runtimeSkeleton.worldMatrices
-    const computed = this.runtimeSkeleton.computedBones.fill(false)
     const boneCount = bones.length
 
     if (boneCount === 0) return
 
+    // Local computed array (avoids instance field overhead)
+    const computed = new Array<boolean>(boneCount).fill(false)
+
     const computeWorld = (i: number): void => {
       if (computed[i]) return
 
@@ -880,14 +842,9 @@ export class Model {
               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)
-            const rx = result.x
-            const ry = result.y
-            const rz = result.z
-            const rw = result.w
-            rotateM = Mat4.fromQuat(rx, ry, rz, rw).multiply(rotateM)
+            const result = Quat.slerp(new Quat(0, 0, 0, 1), appendQuat, absRatio)
+            rotateM = Mat4.fromQuat(result.x, result.y, result.z, result.w).multiply(rotateM)
           }
 
           if (b.appendMove) {

package/src/player.ts

@@ -1,5 +1,4 @@
-import { bezierInterpolate } from "./bezier-interpolate"
-import { Quat, Vec3 } from "./math"
+import { Quat, Vec3, bezierInterpolate } from "./math"
 import { BoneFrame, MorphFrame, VMDKeyFrame, VMDLoader } from "./vmd-loader"
 
 export interface AnimationPose {

package/dist/ik.d.ts

@@ -1,32 +0,0 @@
-import { Vec3 } from "./math";
-import type { Skeleton } from "./model";
-export interface IKLink {
-    boneIndex: number;
-    hasLimit: boolean;
-    minAngle?: Vec3;
-    maxAngle?: Vec3;
-}
-export interface IKChain {
-    targetBoneIndex: number;
-    effectorBoneIndex: number;
-    iterationCount: number;
-    rotationConstraint: number;
-    links: IKLink[];
-    enabled: boolean;
-}
-export declare class IK {
-    private chains;
-    private computeWorldMatricesCallback?;
-    private lastTargetPositions;
-    private convergedChains;
-    private ikRotations;
-    constructor(chains?: IKChain[]);
-    setComputeWorldMatricesCallback(callback: () => void): void;
-    getChains(): IKChain[];
-    enableChain(targetBoneName: string, enabled: boolean): void;
-    solve(skeleton: Skeleton, localRotations: Float32Array, localTranslations: Float32Array, worldMatrices: Float32Array): void;
-    private solveCCD;
-    private applyAngleConstraints;
-    private computeWorldMatrices;
-}
-//# sourceMappingURL=ik.d.ts.map

package/dist/ik.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ik.d.ts","sourceRoot":"","sources":["../src/ik.ts"],"names":[],"mappings":"AAAA,OAAO,EAAQ,IAAI,EAAQ,MAAM,QAAQ,CAAA;AACzC,OAAO,KAAK,EAAQ,QAAQ,EAAE,MAAM,SAAS,CAAA;AAE7C,MAAM,WAAW,MAAM;IACrB,SAAS,EAAE,MAAM,CAAA;IACjB,QAAQ,EAAE,OAAO,CAAA;IACjB,QAAQ,CAAC,EAAE,IAAI,CAAA;IACf,QAAQ,CAAC,EAAE,IAAI,CAAA;CAChB;AAED,MAAM,WAAW,OAAO;IACtB,eAAe,EAAE,MAAM,CAAA;IACvB,iBAAiB,EAAE,MAAM,CAAA;IACzB,cAAc,EAAE,MAAM,CAAA;IACtB,kBAAkB,EAAE,MAAM,CAAA;IAC1B,KAAK,EAAE,MAAM,EAAE,CAAA;IACf,OAAO,EAAE,OAAO,CAAA;CACjB;AAED,qBAAa,EAAE;IACb,OAAO,CAAC,MAAM,CAAW;IACzB,OAAO,CAAC,4BAA4B,CAAC,CAAY;IAEjD,OAAO,CAAC,mBAAmB,CAA+B;IAE1D,OAAO,CAAC,eAAe,CAAyB;IAEhD,OAAO,CAAC,WAAW,CAA+B;gBAEtC,MAAM,GAAE,OAAO,EAAO;IAMlC,+BAA+B,CAAC,QAAQ,EAAE,MAAM,IAAI,GAAG,IAAI;IAI3D,SAAS,IAAI,OAAO,EAAE;IAKtB,WAAW,CAAC,cAAc,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,GAAG,IAAI;IAU3D,KAAK,CACH,QAAQ,EAAE,QAAQ,EAClB,cAAc,EAAE,YAAY,EAC5B,iBAAiB,EAAE,YAAY,EAC/B,aAAa,EAAE,YAAY,GAC1B,IAAI;IA2FP,OAAO,CAAC,QAAQ;IAqLhB,OAAO,CAAC,qBAAqB;IAe7B,OAAO,CAAC,oBAAoB;CAsG7B"}

package/dist/ik.js

@@ -1,337 +0,0 @@
-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/pool-scene.d.ts

@@ -1,52 +0,0 @@
-export interface PoolSceneConfig {
-    cloudSharpness?: number;
-    windSpeed?: [number, number];
-    bumpFactor?: number;
-    bumpDistance?: number;
-    skyColor?: [number, number, number];
-    moonlightColor?: [number, number, number];
-    skyByMoonlightColor?: [number, number, number];
-    waterColor?: [number, number, number];
-    exposure?: number;
-    epsilon?: number;
-    marchSteps?: number;
-    moonPosition?: [number, number, number];
-}
-export declare class PoolScene {
-    private device;
-    private pipeline;
-    private computePipeline;
-    private uniformBuffer;
-    private computeUniformBuffer;
-    private bindGroup;
-    private computeBindGroup;
-    private startTime;
-    private config;
-    private format;
-    private sampleCount;
-    private cameraUniformBuffer;
-    private waterHeightTexture;
-    private waterHeightTextureView;
-    private waterHeightSampler;
-    private waterHeightTextureSize;
-    private waterPlanePipeline;
-    private waterPlaneVertexBuffer;
-    private waterPlaneIndexBuffer;
-    private waterPlaneBindGroup;
-    private waterPlaneSize;
-    private waterPlaneSubdivisions;
-    private moonPosition;
-    private moonRadius;
-    constructor(device: GPUDevice, format: GPUTextureFormat, sampleCount: number, cameraUniformBuffer: GPUBuffer, config?: PoolSceneConfig);
-    private createWaterHeightTexture;
-    private createComputePipeline;
-    private createPipeline;
-    private createUniformBuffer;
-    dispatchCompute(encoder: GPUCommandEncoder, width: number, height: number, modelPos?: [number, number, number]): void;
-    private createWaterPlane;
-    private createWaterPlanePipeline;
-    renderWaterPlane(pass: GPURenderPassEncoder, width: number, height: number, modelPos?: [number, number, number]): void;
-    render(pass: GPURenderPassEncoder, width: number, height: number, modelPos?: [number, number, number]): void;
-    getSkyColor(): [number, number, number];
-}
-//# sourceMappingURL=pool-scene.d.ts.map

package/dist/pool-scene.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"pool-scene.d.ts","sourceRoot":"","sources":["../src/pool-scene.ts"],"names":[],"mappings":"AAEA,MAAM,WAAW,eAAe;IAC9B,cAAc,CAAC,EAAE,MAAM,CAAA;IACvB,SAAS,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IAC5B,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;IACnC,cAAc,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;IACzC,mBAAmB,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;IAC9C,UAAU,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;IACrC,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,YAAY,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;CACxC;AAED,qBAAa,SAAS;IACpB,OAAO,CAAC,MAAM,CAAW;IACzB,OAAO,CAAC,QAAQ,CAAoB;IACpC,OAAO,CAAC,eAAe,CAAqB;IAC5C,OAAO,CAAC,aAAa,CAAY;IACjC,OAAO,CAAC,oBAAoB,CAAY;IACxC,OAAO,CAAC,SAAS,CAAe;IAChC,OAAO,CAAC,gBAAgB,CAAe;IACvC,OAAO,CAAC,SAAS,CAA4B;IAC7C,OAAO,CAAC,MAAM,CAA2B;IACzC,OAAO,CAAC,MAAM,CAAkB;IAChC,OAAO,CAAC,WAAW,CAAQ;IAC3B,OAAO,CAAC,mBAAmB,CAAY;IACvC,OAAO,CAAC,kBAAkB,CAAa;IACvC,OAAO,CAAC,sBAAsB,CAAiB;IAC/C,OAAO,CAAC,kBAAkB,CAAa;IACvC,OAAO,CAAC,sBAAsB,CAAc;IAC5C,OAAO,CAAC,kBAAkB,CAAoB;IAC9C,OAAO,CAAC,sBAAsB,CAAY;IAC1C,OAAO,CAAC,qBAAqB,CAAY;IACzC,OAAO,CAAC,mBAAmB,CAAe;IAC1C,OAAO,CAAC,cAAc,CAAgB;IACtC,OAAO,CAAC,sBAAsB,CAAc;IAC5C,OAAO,CAAC,YAAY,CAA0B;IAC9C,OAAO,CAAC,UAAU,CAAe;gBAG/B,MAAM,EAAE,SAAS,EACjB,MAAM,EAAE,gBAAgB,EACxB,WAAW,EAAE,MAAM,EACnB,mBAAmB,EAAE,SAAS,EAC9B,MAAM,GAAE,eAAoB;IA6B9B,OAAO,CAAC,wBAAwB;IAmBhC,OAAO,CAAC,qBAAqB;IA8G7B,OAAO,CAAC,cAAc;IAqatB,OAAO,CAAC,mBAAmB;IAgCpB,eAAe,CACpB,OAAO,EAAE,iBAAiB,EAC1B,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,EACd,QAAQ,GAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAa;IA2ChD,OAAO,CAAC,gBAAgB;IA4DxB,OAAO,CAAC,wBAAwB;IAmazB,gBAAgB,CACrB,IAAI,EAAE,oBAAoB,EAC1B,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,EACd,QAAQ,GAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAa;IAiBzC,MAAM,CACX,IAAI,EAAE,oBAAoB,EAC1B,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,EACd,QAAQ,GAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAa;IAezC,WAAW,IAAI,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC;CAG/C"}