reze-engine 0.3.11 → 0.3.13

package/dist/bezier-interpolate.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Bezier interpolation for VMD animations
+ * Based on the reference implementation from babylon-mmd
+ */
+/**
+ * Bezier interpolation function
+ * @param x1 First control point X (0-127, normalized to 0-1)
+ * @param x2 Second control point X (0-127, normalized to 0-1)
+ * @param y1 First control point Y (0-127, normalized to 0-1)
+ * @param y2 Second control point Y (0-127, normalized to 0-1)
+ * @param t Interpolation parameter (0-1)
+ * @returns Interpolated value (0-1)
+ */
+export declare function bezierInterpolate(x1: number, x2: number, y1: number, y2: number, t: number): number;
+//# sourceMappingURL=bezier-interpolate.d.ts.map

package/dist/bezier-interpolate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bezier-interpolate.d.ts","sourceRoot":"","sources":["../src/bezier-interpolate.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;;;;;GAQG;AACH,wBAAgB,iBAAiB,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAgCnG"}

package/dist/bezier-interpolate.js

@@ -0,0 +1,40 @@
+/**
+ * Bezier interpolation for VMD animations
+ * Based on the reference implementation from babylon-mmd
+ */
+/**
+ * Bezier interpolation function
+ * @param x1 First control point X (0-127, normalized to 0-1)
+ * @param x2 Second control point X (0-127, normalized to 0-1)
+ * @param y1 First control point Y (0-127, normalized to 0-1)
+ * @param y2 Second control point Y (0-127, normalized to 0-1)
+ * @param t Interpolation parameter (0-1)
+ * @returns Interpolated value (0-1)
+ */
+export function bezierInterpolate(x1, x2, y1, y2, t) {
+    // Clamp t to [0, 1]
+    t = Math.max(0, Math.min(1, t));
+    // Binary search for the t value that gives us the desired x
+    // We're solving for t in the Bezier curve: x(t) = 3*(1-t)^2*t*x1 + 3*(1-t)*t^2*x2 + t^3
+    let start = 0;
+    let end = 1;
+    let mid = 0.5;
+    // Iterate until we find the t value that gives us the desired x
+    for (let i = 0; i < 15; i++) {
+        // Evaluate Bezier curve at mid point
+        const x = 3 * (1 - mid) * (1 - mid) * mid * x1 + 3 * (1 - mid) * mid * mid * x2 + mid * mid * mid;
+        if (Math.abs(x - t) < 0.0001) {
+            break;
+        }
+        if (x < t) {
+            start = mid;
+        }
+        else {
+            end = mid;
+        }
+        mid = (start + end) / 2;
+    }
+    // Now evaluate the y value at this t
+    const y = 3 * (1 - mid) * (1 - mid) * mid * y1 + 3 * (1 - mid) * mid * mid * y2 + mid * mid * mid;
+    return y;
+}

package/dist/engine.d.ts

@@ -5,7 +5,9 @@ export type EngineOptions = {
     rimLightIntensity?: number;
     cameraDistance?: number;
     cameraTarget?: Vec3;
+    cameraFov?: number;
 };
+export declare const DEFAULT_ENGINE_OPTIONS: Required<EngineOptions>;
 export interface EngineStats {
     fps: number;
     frameTime: number;
@@ -20,6 +22,7 @@ export declare class Engine {
     private cameraMatrixData;
     private cameraDistance;
     private cameraTarget;
+    private cameraFov;
     private lightUniformBuffer;
     private lightData;
     private vertexBuffer;
@@ -44,14 +47,6 @@ export declare class Engine {
     private renderPassDescriptor;
     private readonly STENCIL_EYE_VALUE;
     private readonly BLOOM_DOWNSCALE_FACTOR;
-    private static readonly DEFAULT_BLOOM_THRESHOLD;
-    private static readonly DEFAULT_BLOOM_INTENSITY;
-    private static readonly DEFAULT_RIM_LIGHT_INTENSITY;
-    private static readonly DEFAULT_CAMERA_DISTANCE;
-    private static readonly DEFAULT_CAMERA_TARGET;
-    private static readonly TRANSPARENCY_EPSILON;
-    private static readonly STATS_FPS_UPDATE_INTERVAL_MS;
-    private static readonly STATS_FRAME_TIME_ROUNDING;
     private ambientColor;
     private sceneRenderTexture;
     private sceneRenderTextureView;

package/dist/engine.d.ts.map

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

package/dist/engine.js

@@ -1,24 +1,23 @@
 import { Camera } from "./camera";
 import { Vec3 } from "./math";
 import { PmxLoader } from "./pmx-loader";
+export const DEFAULT_ENGINE_OPTIONS = {
+    ambientColor: new Vec3(1.0, 1.0, 1.0),
+    bloomIntensity: 0.12,
+    rimLightIntensity: 0.45,
+    cameraDistance: 26.6,
+    cameraTarget: new Vec3(0, 12.5, 0),
+    cameraFov: Math.PI / 4,
+};
 export class Engine {
     constructor(canvas, options) {
         this.cameraMatrixData = new Float32Array(36);
-        this.cameraDistance = 26.6;
-        this.cameraTarget = new Vec3(0, 12.5, 0);
         this.lightData = new Float32Array(4);
         this.resizeObserver = null;
         this.sampleCount = 4;
         // Constants
         this.STENCIL_EYE_VALUE = 1;
         this.BLOOM_DOWNSCALE_FACTOR = 2;
-        // Ambient light settings
-        this.ambientColor = new Vec3(1.0, 1.0, 1.0);
-        // Bloom settings
-        this.bloomThreshold = Engine.DEFAULT_BLOOM_THRESHOLD;
-        this.bloomIntensity = Engine.DEFAULT_BLOOM_INTENSITY;
-        // Rim light settings
-        this.rimLightIntensity = Engine.DEFAULT_RIM_LIGHT_INTENSITY;
         this.currentModel = null;
         this.modelDir = "";
         this.textureCache = new Map();
@@ -38,11 +37,12 @@ export class Engine {
         this.renderLoopCallback = null;
         this.canvas = canvas;
         if (options) {
-            this.ambientColor = options.ambientColor ?? new Vec3(1.0, 1.0, 1.0);
-            this.bloomIntensity = options.bloomIntensity ?? Engine.DEFAULT_BLOOM_INTENSITY;
-            this.rimLightIntensity = options.rimLightIntensity ?? Engine.DEFAULT_RIM_LIGHT_INTENSITY;
-            this.cameraDistance = options.cameraDistance ?? Engine.DEFAULT_CAMERA_DISTANCE;
-            this.cameraTarget = options.cameraTarget ?? Engine.DEFAULT_CAMERA_TARGET;
+            this.ambientColor = options.ambientColor ?? DEFAULT_ENGINE_OPTIONS.ambientColor;
+            this.bloomIntensity = options.bloomIntensity ?? DEFAULT_ENGINE_OPTIONS.bloomIntensity;
+            this.rimLightIntensity = options.rimLightIntensity ?? DEFAULT_ENGINE_OPTIONS.rimLightIntensity;
+            this.cameraDistance = options.cameraDistance ?? DEFAULT_ENGINE_OPTIONS.cameraDistance;
+            this.cameraTarget = options.cameraTarget ?? DEFAULT_ENGINE_OPTIONS.cameraTarget;
+            this.cameraFov = options.cameraFov ?? DEFAULT_ENGINE_OPTIONS.cameraFov;
         }
     }
     // Step 1: Get WebGPU device and context
@@ -250,12 +250,12 @@ export class Engine {
 
           let lightAccum = light.ambientColor;
           
-          // Rim light calculation
+          // Rim light calculation - proper Fresnel for edge-only highlights
           let viewDir = normalize(camera.viewPos - input.worldPos);
-          var rimFactor = 1.0 - max(dot(n, viewDir), 0.0);
-          rimFactor = rimFactor * rimFactor; // Optimized: direct multiply instead of pow(x, 2.0)
+          let fresnel = 1.0 - abs(dot(n, viewDir));
+          let rimFactor = pow(fresnel, 4.0); // Higher power for sharper edge-only effect
           let rimLight = material.rimColor * material.rimIntensity * rimFactor;
-          
+
           let color = albedo * lightAccum + rimLight;
           
           return vec4f(color, finalAlpha);
@@ -890,7 +890,7 @@ export class Engine {
             size: 40 * 4,
             usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST,
         });
-        this.camera = new Camera(Math.PI, Math.PI / 2.5, this.cameraDistance, this.cameraTarget);
+        this.camera = new Camera(Math.PI, Math.PI / 2.5, this.cameraDistance, this.cameraTarget, this.cameraFov);
         this.camera.aspect = this.canvas.width / this.canvas.height;
         this.camera.attachControl(this.canvas);
     }
@@ -1070,7 +1070,7 @@ export class Engine {
             if (!diffuseTexture)
                 throw new Error(`Material "${mat.name}" has no diffuse texture`);
             const materialAlpha = mat.diffuse[3];
-            const isTransparent = materialAlpha < 1.0 - Engine.TRANSPARENCY_EPSILON;
+            const isTransparent = materialAlpha < 1.0 - 0.001;
             const materialUniformBuffer = this.createMaterialUniformBuffer(mat.name, materialAlpha, 0.0);
             // Create bind groups using the shared bind group layout - All pipelines (main, eye, hair multiply, hair opaque) use the same shader and layout
             const bindGroup = this.device.createBindGroup({
@@ -1460,26 +1460,15 @@ export class Engine {
             this.frameTimeSum -= avg;
             this.frameTimeCount = maxSamples;
         }
-        this.stats.frameTime =
-            Math.round((this.frameTimeSum / this.frameTimeCount) * Engine.STATS_FRAME_TIME_ROUNDING) /
-                Engine.STATS_FRAME_TIME_ROUNDING;
+        this.stats.frameTime = Math.round((this.frameTimeSum / this.frameTimeCount) * 100) / 100;
         // FPS tracking
         const now = performance.now();
         this.framesSinceLastUpdate++;
         const elapsed = now - this.lastFpsUpdate;
-        if (elapsed >= Engine.STATS_FPS_UPDATE_INTERVAL_MS) {
-            this.stats.fps = Math.round((this.framesSinceLastUpdate / elapsed) * Engine.STATS_FPS_UPDATE_INTERVAL_MS);
+        if (elapsed >= 1000) {
+            this.stats.fps = Math.round((this.framesSinceLastUpdate / elapsed) * 1000);
             this.framesSinceLastUpdate = 0;
             this.lastFpsUpdate = now;
         }
     }
 }
-// Default values
-Engine.DEFAULT_BLOOM_THRESHOLD = 0.01;
-Engine.DEFAULT_BLOOM_INTENSITY = 0.12;
-Engine.DEFAULT_RIM_LIGHT_INTENSITY = 0.45;
-Engine.DEFAULT_CAMERA_DISTANCE = 26.6;
-Engine.DEFAULT_CAMERA_TARGET = new Vec3(0, 12.5, 0);
-Engine.TRANSPARENCY_EPSILON = 0.001;
-Engine.STATS_FPS_UPDATE_INTERVAL_MS = 1000;
-Engine.STATS_FRAME_TIME_ROUNDING = 100;

package/dist/ik.d.ts

@@ -0,0 +1,32 @@
+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

@@ -0,0 +1 @@
+{"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

@@ -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/pool-scene.d.ts

@@ -0,0 +1,52 @@
+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