reze-engine 0.6.4 → 0.6.6

package/src/ik-solver.ts

@@ -7,6 +7,9 @@
 import { Mat4, Quat, Vec3 } from "./math"
 import { Bone, IKLink, IKSolver, IKChainInfo } from "./model"
 
+// Callback type for updating world matrix (provided by model to handle append transformations)
+export type UpdateWorldMatrixFn = (boneIndex: number, applyIK: boolean) => void
+
 const enum InternalEulerRotationOrder {
   YXZ = 0,
   ZYX = 1,
@@ -89,10 +92,11 @@ export class IKSolverSystem {
     localRotations: Quat[],
     localTranslations: Vec3[],
     worldMatrices: Mat4[],
-    ikChainInfo: IKChainInfo[]
+    ikChainInfo: IKChainInfo[],
+    updateWorldMatrix?: UpdateWorldMatrixFn
   ): void {
     for (const solver of ikSolvers) {
-      this.solveIK(solver, bones, localRotations, localTranslations, worldMatrices, ikChainInfo)
+      this.solveIK(solver, bones, localRotations, localTranslations, worldMatrices, ikChainInfo, updateWorldMatrix)
     }
   }
 
@@ -102,7 +106,8 @@ export class IKSolverSystem {
     localRotations: Quat[],
     localTranslations: Vec3[],
     worldMatrices: Mat4[],
-    ikChainInfo: IKChainInfo[]
+    ikChainInfo: IKChainInfo[],
+    updateWorldMatrix?: UpdateWorldMatrixFn
   ): void {
     if (solver.links.length === 0) return
 
@@ -126,10 +131,17 @@ export class IKSolverSystem {
     }
 
     // Update chain bones and target bone world matrices (initial state, no IK yet)
-    for (let i = chains.length - 1; i >= 0; i--) {
-      this.updateWorldMatrix(chains[i].boneIndex, bones, localRotations, localTranslations, worldMatrices, undefined)
+    if (updateWorldMatrix) {
+      for (let i = chains.length - 1; i >= 0; i--) {
+        updateWorldMatrix(chains[i].boneIndex, false)
+      }
+      updateWorldMatrix(targetBoneIndex, false)
+    } else {
+      for (let i = chains.length - 1; i >= 0; i--) {
+        this.updateWorldMatrix(chains[i].boneIndex, bones, localRotations, localTranslations, worldMatrices, undefined)
+      }
+      this.updateWorldMatrix(targetBoneIndex, bones, localRotations, localTranslations, worldMatrices, undefined)
     }
-    this.updateWorldMatrix(targetBoneIndex, bones, localRotations, localTranslations, worldMatrices, undefined)
 
     if (this.getDistance(ikBoneIndex, targetBoneIndex, worldMatrices) < this.EPSILON) return
 
@@ -152,7 +164,8 @@ export class IKSolverSystem {
             localTranslations,
             worldMatrices,
             ikChainInfo,
-            i < halfIteration
+            i < halfIteration,
+            updateWorldMatrix
           )
         }
       }
@@ -182,7 +195,8 @@ export class IKSolverSystem {
     localTranslations: Vec3[],
     worldMatrices: Mat4[],
     ikChainInfo: IKChainInfo[],
-    useAxis: boolean
+    useAxis: boolean,
+    updateWorldMatrix?: UpdateWorldMatrixFn
   ): void {
     const chainBoneIndex = chain.boneIndex
     const chainPosition = this.getWorldTranslation(chainBoneIndex, worldMatrices)
@@ -254,13 +268,21 @@ export class IKSolverSystem {
       }
     }
 
-    // Update world matrices for affected bones (using IK-modified rotations)
-    for (let i = chainIndex; i >= 0; i--) {
-      const link = solver.links[i]
-      this.updateWorldMatrix(link.boneIndex, bones, localRotations, localTranslations, worldMatrices, ikChainInfo)
+    // Update world matrices for affected bones (using callback - handles append correctly)
+    if (updateWorldMatrix) {
+      for (let i = chainIndex; i >= 0; i--) {
+        const link = solver.links[i]
+        updateWorldMatrix(link.boneIndex, true)  // applyIK = true
+      }
+      updateWorldMatrix(targetBoneIndex, false)
+    } else {
+      for (let i = chainIndex; i >= 0; i--) {
+        const link = solver.links[i]
+        this.updateWorldMatrix(link.boneIndex, bones, localRotations, localTranslations, worldMatrices, ikChainInfo)
+      }
+      this.updateWorldMatrix(ikBoneIndex, bones, localRotations, localTranslations, worldMatrices, undefined)
+      this.updateWorldMatrix(targetBoneIndex, bones, localRotations, localTranslations, worldMatrices, undefined)
     }
-    this.updateWorldMatrix(ikBoneIndex, bones, localRotations, localTranslations, worldMatrices, undefined)
-    this.updateWorldMatrix(targetBoneIndex, bones, localRotations, localTranslations, worldMatrices, undefined)
   }
 
   private static limitAngle(angle: number, min: number, max: number, useAxis: boolean): number {
@@ -410,3 +432,4 @@ export class IKSolverSystem {
     }
   }
 }
+

package/src/model.ts

@@ -531,62 +531,14 @@ export class Model {
     const now = this.tweenTimeMs
     const dur = durationMs && durationMs > 0 ? durationMs : 0
 
-    // Compute bind pose world positions for all bones
-    const skeleton = this.skeleton
-    const computeBindPoseWorldPosition = (idx: number): Vec3 => {
-      const bone = skeleton.bones[idx]
-      const bindPos = new Vec3(bone.bindTranslation[0], bone.bindTranslation[1], bone.bindTranslation[2])
-      if (bone.parentIndex >= 0 && bone.parentIndex < skeleton.bones.length) {
-        const parentWorldPos = computeBindPoseWorldPosition(bone.parentIndex)
-        return parentWorldPos.add(bindPos)
-      } else {
-        return bindPos
-      }
-    }
-
     for (const [name, vmdRelativeTranslation] of Object.entries(boneTranslations)) {
       const idx = this.runtimeSkeleton.nameIndex[name] ?? -1
       if (idx < 0 || idx >= this.skeleton.bones.length) continue
 
-      const bone = this.skeleton.bones[idx]
       const translations = this.runtimeSkeleton.localTranslations
-      const localRot = this.runtimeSkeleton.localRotations
-
-      // VMD translation is relative to bind pose world position
-      // targetWorldPos = bindPoseWorldPos + vmdRelativeTranslation
-      const bindPoseWorldPos = computeBindPoseWorldPosition(idx)
-      const targetWorldPos = bindPoseWorldPos.add(vmdRelativeTranslation)
-
-      // Convert target world position to local translation
-      // We need parent's bind pose world position to transform to parent space
-      let parentBindPoseWorldPos: Vec3
-      if (bone.parentIndex >= 0) {
-        parentBindPoseWorldPos = computeBindPoseWorldPosition(bone.parentIndex)
-      } else {
-        parentBindPoseWorldPos = Vec3.zeros()
-      }
-
-      // Transform target world position to parent's local space
-      // In bind pose, parent's world matrix is just a translation
-      const parentSpacePos = targetWorldPos.subtract(parentBindPoseWorldPos)
-
-      // Subtract bindTranslation to get position after bind translation
-      const afterBindTranslation = parentSpacePos.subtract(
-        new Vec3(bone.bindTranslation[0], bone.bindTranslation[1], bone.bindTranslation[2])
-      )
-
-      // Apply inverse rotation to get local translation
-      const localRotation = localRot[idx]
-      // Clone to avoid mutating, then conjugate and normalize
-      const invRotation = localRotation.clone().conjugate().normalize()
-      const rotationMat = Mat4.fromQuat(invRotation.x, invRotation.y, invRotation.z, invRotation.w)
-      const rm = rotationMat.values
-      const localTranslation = new Vec3(
-        rm[0] * afterBindTranslation.x + rm[4] * afterBindTranslation.y + rm[8] * afterBindTranslation.z,
-        rm[1] * afterBindTranslation.x + rm[5] * afterBindTranslation.y + rm[9] * afterBindTranslation.z,
-        rm[2] * afterBindTranslation.x + rm[6] * afterBindTranslation.y + rm[10] * afterBindTranslation.z
-      )
 
+      // Convert VMD relative translation to local translation
+      const localTranslation = this.convertVMDTranslationToLocal(idx, vmdRelativeTranslation)
       const [tx, ty, tz] = [localTranslation.x, localTranslation.y, localTranslation.z]
 
       if (dur === 0) {
@@ -626,6 +578,73 @@ export class Model {
     }
   }
 
+  /**
+   * Convert VMD-style relative translation (relative to bind pose world position) to local translation
+   * This helper is used by both moveBones and getPoseAtTime to ensure consistent translation handling
+   * @param boneIdx - Bone index
+   * @param vmdRelativeTranslation - VMD relative translation
+   * @param rotation - Optional rotation to use for conversion. If not provided, uses current localRotation.
+   *                   Use animation rotation (from frame) to avoid conflicts when IK modifies rotation.
+   */
+  private convertVMDTranslationToLocal(boneIdx: number, vmdRelativeTranslation: Vec3, rotation?: Quat): Vec3 {
+    const skeleton = this.skeleton
+    const bones = skeleton.bones
+    const localRot = this.runtimeSkeleton.localRotations
+
+    // Compute bind pose world positions for all bones
+    const computeBindPoseWorldPosition = (idx: number): Vec3 => {
+      const bone = bones[idx]
+      const bindPos = new Vec3(bone.bindTranslation[0], bone.bindTranslation[1], bone.bindTranslation[2])
+      if (bone.parentIndex >= 0 && bone.parentIndex < bones.length) {
+        const parentWorldPos = computeBindPoseWorldPosition(bone.parentIndex)
+        return parentWorldPos.add(bindPos)
+      } else {
+        return bindPos
+      }
+    }
+
+    const bone = bones[boneIdx]
+
+    // VMD translation is relative to bind pose world position
+    // targetWorldPos = bindPoseWorldPos + vmdRelativeTranslation
+    const bindPoseWorldPos = computeBindPoseWorldPosition(boneIdx)
+    const targetWorldPos = bindPoseWorldPos.add(vmdRelativeTranslation)
+
+    // Convert target world position to local translation
+    // We need parent's bind pose world position to transform to parent space
+    let parentBindPoseWorldPos: Vec3
+    if (bone.parentIndex >= 0) {
+      parentBindPoseWorldPos = computeBindPoseWorldPosition(bone.parentIndex)
+    } else {
+      parentBindPoseWorldPos = Vec3.zeros()
+    }
+
+    // Transform target world position to parent's local space
+    // In bind pose, parent's world matrix is just a translation
+    const parentSpacePos = targetWorldPos.subtract(parentBindPoseWorldPos)
+
+    // Subtract bindTranslation to get position after bind translation
+    const afterBindTranslation = parentSpacePos.subtract(
+      new Vec3(bone.bindTranslation[0], bone.bindTranslation[1], bone.bindTranslation[2])
+    )
+
+    // Apply inverse rotation to get local translation
+    // Use provided rotation (animation rotation) or fall back to current localRotation
+    // Using animation rotation prevents conflicts when IK modifies the rotation
+    const localRotation = rotation ?? localRot[boneIdx]
+    // Clone to avoid mutating, then conjugate and normalize
+    const invRotation = localRotation.clone().conjugate().normalize()
+    const rotationMat = Mat4.fromQuat(invRotation.x, invRotation.y, invRotation.z, invRotation.w)
+    const rm = rotationMat.values
+    const localTranslation = new Vec3(
+      rm[0] * afterBindTranslation.x + rm[4] * afterBindTranslation.y + rm[8] * afterBindTranslation.z,
+      rm[1] * afterBindTranslation.x + rm[5] * afterBindTranslation.y + rm[9] * afterBindTranslation.z,
+      rm[2] * afterBindTranslation.x + rm[6] * afterBindTranslation.y + rm[10] * afterBindTranslation.z
+    )
+
+    return localTranslation
+  }
+
   getBoneWorldMatrices(): Float32Array {
     // Convert Mat4[] to Float32Array for WebGPU compatibility
     const boneCount = this.skeleton.bones.length
@@ -1003,8 +1022,13 @@ export class Model {
 
       if (!frameB) {
         // No interpolation needed - direct assignment
-        localRot.set(frameA.rotation)
-        localTrans.set(frameA.translation)
+        // Use animation frame's rotation for translation conversion to ensure consistency
+        // This prevents conflicts when IK later modifies the rotation
+        const frameRotation = frameA.rotation
+        localRot.set(frameRotation)
+        // Convert VMD relative translation to local translation using animation rotation
+        const localTranslation = this.convertVMDTranslationToLocal(boneIdx, frameA.translation, frameRotation)
+        localTrans.set(localTranslation)
       } else {
         const timeA = keyFrames[idx].time
         const timeB = keyFrames[idx + 1].time
@@ -1024,7 +1048,7 @@ export class Model {
         // Use Quat.slerp to interpolate rotation
         const rotation = Quat.slerp(frameA.rotation, frameB.rotation, rotT)
 
-        // Interpolate translation using bezier for each component
+        // Interpolate VMD translation using bezier for each component
         // Inline getWeight to avoid function call overhead
         const getWeight = (offset: number) =>
           bezierInterpolate(
@@ -1039,11 +1063,21 @@ export class Model {
         const tyWeight = getWeight(16)
         const tzWeight = getWeight(32)
 
+        // Interpolate VMD relative translations (relative to bind pose world position)
+        const interpolatedVMDTranslation = new Vec3(
+          frameA.translation.x + (frameB.translation.x - frameA.translation.x) * txWeight,
+          frameA.translation.y + (frameB.translation.y - frameA.translation.y) * tyWeight,
+          frameA.translation.z + (frameB.translation.z - frameA.translation.z) * tzWeight
+        )
+
+        // Convert interpolated VMD translation to local translation using animation rotation
+        // This ensures translation is computed for the animation rotation, not the runtime rotation
+        // that will be modified by IK, preventing conflicts
+        const localTranslation = this.convertVMDTranslationToLocal(boneIdx, interpolatedVMDTranslation, rotation)
+
         // Direct property writes to avoid object allocation
         localRot.set(rotation)
-        localTrans.x = frameA.translation.x + (frameB.translation.x - frameA.translation.x) * txWeight
-        localTrans.y = frameA.translation.y + (frameB.translation.y - frameA.translation.y) * tyWeight
-        localTrans.z = frameA.translation.z + (frameB.translation.z - frameA.translation.z) * tzWeight
+        localTrans.set(localTranslation)
       }
     }
 
@@ -1138,14 +1172,136 @@ export class Model {
     const ikChainInfo = this.runtimeSkeleton.ikChainInfo
     if (!ikChainInfo) return
 
-    IKSolverSystem.solve(
-      ikSolvers,
-      this.skeleton.bones,
-      this.runtimeSkeleton.localRotations,
-      this.runtimeSkeleton.localTranslations,
-      this.runtimeSkeleton.worldMatrices,
-      ikChainInfo
-    )
+    // Solve each IK solver sequentially, ensuring consistent state between solvers
+    for (const solver of ikSolvers) {
+      // Recompute ALL world matrices before each solver starts
+      // This ensures each solver sees the effects of previous solvers on localRotations
+      this.computeWorldMatrices()
+      
+      // Clear computed set for this solver's pass
+      this.ikComputedSet.clear()
+
+      // Solve this IK chain
+      // Pass callback that uses model's world matrix computation (handles append correctly)
+      IKSolverSystem.solve(
+        [solver], // Solve one at a time
+        this.skeleton.bones,
+        this.runtimeSkeleton.localRotations,
+        this.runtimeSkeleton.localTranslations,
+        this.runtimeSkeleton.worldMatrices,
+        ikChainInfo,
+        (boneIndex, applyIK) => {
+          // Clear computed set for each bone update to allow recomputation in same iteration
+          this.ikComputedSet.delete(boneIndex)
+          this.computeSingleBoneWorldMatrix(boneIndex, applyIK)
+        }
+      )
+    }
+  }
+
+  // Cached set to track which bones are being computed in current IK pass (to avoid infinite recursion)
+  private ikComputedSet: Set<number> = new Set()
+
+  // Add this new method to compute a single bone's world matrix
+  // Recursively ensures parents are computed first to avoid using stale parent matrices
+  private computeSingleBoneWorldMatrix(boneIndex: number, applyIK: boolean): void {
+    const bones = this.skeleton.bones
+    const localRot = this.runtimeSkeleton.localRotations
+    const localTrans = this.runtimeSkeleton.localTranslations
+    const worldMats = this.runtimeSkeleton.worldMatrices
+    const ikChainInfo = this.runtimeSkeleton.ikChainInfo
+
+    const b = bones[boneIndex]
+
+    // Prevent infinite recursion: if this bone is already being computed in this call chain, skip
+    if (this.ikComputedSet.has(boneIndex)) {
+      return
+    }
+
+    // Mark this bone as being computed to prevent infinite recursion
+    this.ikComputedSet.add(boneIndex)
+
+    // Recursively compute parent first if it exists (ensures parent matrix is up-to-date)
+    if (b.parentIndex >= 0) {
+      this.computeSingleBoneWorldMatrix(b.parentIndex, applyIK)
+    }
+
+    // Get base rotation
+    let boneRot = localRot[boneIndex]
+
+    // Apply IK rotation if requested
+    if (applyIK && ikChainInfo) {
+      const chainInfo = ikChainInfo[boneIndex]
+      if (chainInfo?.ikRotation) {
+        boneRot = chainInfo.ikRotation.multiply(boneRot).normalize()
+      }
+    }
+
+    let rotateM = Mat4.fromQuat(boneRot.x, boneRot.y, boneRot.z, boneRot.w)
+    let addLocalTx = 0, addLocalTy = 0, addLocalTz = 0
+
+    // Handle append transformations (same logic as computeWorldMatrices)
+    const appendParentIdx = b.appendParentIndex
+    const hasAppend = b.appendRotate && 
+      appendParentIdx !== undefined && 
+      appendParentIdx >= 0 && 
+      appendParentIdx < bones.length
+
+    if (hasAppend) {
+      const ratio = b.appendRatio === undefined ? 1 : Math.max(-1, Math.min(1, b.appendRatio))
+      const hasRatio = Math.abs(ratio) > 1e-6
+
+      if (hasRatio) {
+        if (b.appendRotate) {
+          // Get append parent's rotation
+          // During IK solving, use only base local rotation (not IK rotations) to avoid
+          // conflicts with IK rotations that are still being computed incrementally
+          // IK rotations will be applied to localRotations after IK solving completes
+          if (appendParentIdx >= 0) {
+            // Compute append parent's world matrix for dependency order, but use base rotation for append
+            this.computeSingleBoneWorldMatrix(appendParentIdx, applyIK)
+          }
+          
+          // Use append parent's base local rotation only (IK rotations are applied after solving)
+          let appendRot = localRot[appendParentIdx]
+
+          let ax = appendRot.x, ay = appendRot.y, az = appendRot.z
+          const aw = appendRot.w
+          const absRatio = ratio < 0 ? -ratio : ratio
+          if (ratio < 0) { ax = -ax; ay = -ay; az = -az }
+          
+          const appendQuat = new Quat(ax, ay, az, aw)
+          const result = Quat.slerp(Quat.identity(), appendQuat, absRatio)
+          rotateM = Mat4.fromQuat(result.x, result.y, result.z, result.w).multiply(rotateM)
+        }
+
+        if (b.appendMove) {
+          const appendTrans = localTrans[appendParentIdx]
+          addLocalTx = appendTrans.x * ratio
+          addLocalTy = appendTrans.y * ratio
+          addLocalTz = appendTrans.z * ratio
+        }
+      }
+    }
+
+    const boneTrans = localTrans[boneIndex]
+    const localTx = boneTrans.x + addLocalTx
+    const localTy = boneTrans.y + addLocalTy
+    const localTz = boneTrans.z + addLocalTz
+
+    this.cachedIdentityMat1
+      .setIdentity()
+      .translateInPlace(b.bindTranslation[0], b.bindTranslation[1], b.bindTranslation[2])
+    this.cachedIdentityMat2.setIdentity().translateInPlace(localTx, localTy, localTz)
+    const localM = this.cachedIdentityMat1.multiply(rotateM).multiply(this.cachedIdentityMat2)
+
+    const worldMat = worldMats[boneIndex]
+    if (b.parentIndex >= 0) {
+      const parentMat = worldMats[b.parentIndex]
+      Mat4.multiplyArrays(parentMat.values, 0, localM.values, 0, worldMat.values, 0)
+    } else {
+      worldMat.values.set(localM.values)
+    }
   }
 
   private computeWorldMatrices(): void {
@@ -1238,4 +1394,4 @@ export class Model {
     // Process all bones (recursion handles dependencies automatically)
     for (let i = 0; i < boneCount; i++) computeWorld(i)
   }
-}
+}

package/dist/bezier-interpolate.d.ts

@@ -1,15 +0,0 @@
-/**
- * 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

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

@@ -1,40 +0,0 @@
-/**
- * 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_ts.d.ts

@@ -1,143 +0,0 @@
-import { Quat, Vec3 } from "reze-mmd";
-export type EngineOptions = {
-    ambientColor?: Vec3;
-    bloomIntensity?: number;
-    rimLightIntensity?: number;
-    cameraDistance?: number;
-    cameraTarget?: Vec3;
-};
-export interface EngineStats {
-    fps: number;
-    frameTime: number;
-}
-export declare class Engine {
-    private canvas;
-    private device;
-    private context;
-    private presentationFormat;
-    private camera;
-    private cameraUniformBuffer;
-    private cameraMatrixData;
-    private cameraDistance;
-    private cameraTarget;
-    private lightUniformBuffer;
-    private lightData;
-    private vertexBuffer;
-    private indexBuffer?;
-    private resizeObserver;
-    private depthTexture;
-    private modelPipeline;
-    private eyePipeline;
-    private hairPipelineOverEyes;
-    private hairPipelineOverNonEyes;
-    private hairDepthPipeline;
-    private outlinePipeline;
-    private hairOutlinePipeline;
-    private mainBindGroupLayout;
-    private outlineBindGroupLayout;
-    private jointsBuffer;
-    private weightsBuffer;
-    private skinMatrixBuffer?;
-    private multisampleTexture;
-    private readonly sampleCount;
-    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;
-    private bloomExtractTexture;
-    private bloomBlurTexture1;
-    private bloomBlurTexture2;
-    private bloomExtractPipeline;
-    private bloomBlurPipeline;
-    private bloomComposePipeline;
-    private blurDirectionBuffer;
-    private bloomIntensityBuffer;
-    private bloomThresholdBuffer;
-    private linearSampler;
-    private bloomExtractBindGroup?;
-    private bloomBlurHBindGroup?;
-    private bloomBlurVBindGroup?;
-    private bloomComposeBindGroup?;
-    private bloomThreshold;
-    private bloomIntensity;
-    private rimLightIntensity;
-    private currentModel;
-    private modelDir;
-    private physics;
-    private materialSampler;
-    private textureCache;
-    private vertexBufferNeedsUpdate;
-    private drawCalls;
-    private lastFpsUpdate;
-    private framesSinceLastUpdate;
-    private lastFrameTime;
-    private frameTimeSum;
-    private frameTimeCount;
-    private stats;
-    private animationFrameId;
-    private renderLoopCallback;
-    private player;
-    private hasAnimation;
-    constructor(canvas: HTMLCanvasElement, options?: EngineOptions);
-    init(): Promise<void>;
-    private createRenderPipeline;
-    private createPipelines;
-    private createBloomPipelines;
-    private setupBloom;
-    private setupResize;
-    private handleResize;
-    private setupCamera;
-    private setupLighting;
-    private setAmbientColor;
-    loadAnimation(url: string): Promise<void>;
-    playAnimation(): void;
-    stopAnimation(): void;
-    pauseAnimation(): void;
-    seekAnimation(time: number): void;
-    getAnimationProgress(): import("./player").AnimationProgress;
-    /**
-     * Apply animation pose to model
-     */
-    private applyPose;
-    /**
-     * Reset bones and physics to match a given pose
-     * @param pose The pose to apply
-     * @param resetBonesWithoutKeyframes If true, reset bones that don't have keyframes in the pose to identity
-     */
-    private resetBonesAndPhysics;
-    getStats(): EngineStats;
-    runRenderLoop(callback?: () => void): void;
-    stopRenderLoop(): void;
-    dispose(): void;
-    loadModel(path: string): Promise<void>;
-    rotateBones(bones: string[], rotations: Quat[], durationMs?: number): void;
-    moveBones(bones: string[], relativeTranslations: Vec3[], durationMs?: number): void;
-    setMorphWeight(name: string, weight: number, durationMs?: number): void;
-    private updateVertexBuffer;
-    private setupModelBuffers;
-    private setupMaterials;
-    private createMaterialUniformBuffer;
-    private createUniformBuffer;
-    private createTextureFromPath;
-    private renderEyes;
-    private renderHair;
-    render(): void;
-    private applyBloom;
-    private updateCameraUniforms;
-    private updateRenderTarget;
-    private updateModelPose;
-    private computeSkinMatrices;
-    private drawOutlines;
-    private updateStats;
-}
-//# sourceMappingURL=engine_ts.d.ts.map

package/dist/engine_ts.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"engine_ts.d.ts","sourceRoot":"","sources":["../src/engine_ts.ts"],"names":[],"mappings":"AACA,OAAO,EAAQ,IAAI,EAAE,IAAI,EAAE,MAAM,UAAU,CAAA;AAO3C,MAAM,MAAM,aAAa,GAAG;IAC1B,YAAY,CAAC,EAAE,IAAI,CAAA;IACnB,cAAc,CAAC,EAAE,MAAM,CAAA;IACvB,iBAAiB,CAAC,EAAE,MAAM,CAAA;IAC1B,cAAc,CAAC,EAAE,MAAM,CAAA;IACvB,YAAY,CAAC,EAAE,IAAI,CAAA;CACpB,CAAA;AAED,MAAM,WAAW,WAAW;IAC1B,GAAG,EAAE,MAAM,CAAA;IACX,SAAS,EAAE,MAAM,CAAA;CAClB;AAoBD,qBAAa,MAAM;IACjB,OAAO,CAAC,MAAM,CAAmB;IACjC,OAAO,CAAC,MAAM,CAAY;IAC1B,OAAO,CAAC,OAAO,CAAmB;IAClC,OAAO,CAAC,kBAAkB,CAAmB;IAC7C,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,mBAAmB,CAAY;IACvC,OAAO,CAAC,gBAAgB,CAAuB;IAC/C,OAAO,CAAC,cAAc,CAAe;IACrC,OAAO,CAAC,YAAY,CAA6B;IACjD,OAAO,CAAC,kBAAkB,CAAY;IACtC,OAAO,CAAC,SAAS,CAAsB;IACvC,OAAO,CAAC,YAAY,CAAY;IAChC,OAAO,CAAC,WAAW,CAAC,CAAW;IAC/B,OAAO,CAAC,cAAc,CAA8B;IACpD,OAAO,CAAC,YAAY,CAAa;IAEjC,OAAO,CAAC,aAAa,CAAoB;IACzC,OAAO,CAAC,WAAW,CAAoB;IACvC,OAAO,CAAC,oBAAoB,CAAoB;IAChD,OAAO,CAAC,uBAAuB,CAAoB;IACnD,OAAO,CAAC,iBAAiB,CAAoB;IAE7C,OAAO,CAAC,eAAe,CAAoB;IAC3C,OAAO,CAAC,mBAAmB,CAAoB;IAC/C,OAAO,CAAC,mBAAmB,CAAqB;IAChD,OAAO,CAAC,sBAAsB,CAAqB;IACnD,OAAO,CAAC,YAAY,CAAY;IAChC,OAAO,CAAC,aAAa,CAAY;IACjC,OAAO,CAAC,gBAAgB,CAAC,CAAW;IACpC,OAAO,CAAC,kBAAkB,CAAa;IACvC,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAI;IAChC,OAAO,CAAC,oBAAoB,CAA0B;IAEtD,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAAI;IACtC,OAAO,CAAC,QAAQ,CAAC,sBAAsB,CAAI;IAG3C,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,uBAAuB,CAAO;IACtD,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,uBAAuB,CAAO;IACtD,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,2BAA2B,CAAO;IAC1D,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,uBAAuB,CAAO;IACtD,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,qBAAqB,CAAuB;IACpE,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,oBAAoB,CAAQ;IACpD,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,4BAA4B,CAAO;IAC3D,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,yBAAyB,CAAM;IAGvD,OAAO,CAAC,YAAY,CAAgC;IAEpD,OAAO,CAAC,kBAAkB,CAAa;IACvC,OAAO,CAAC,sBAAsB,CAAiB;IAC/C,OAAO,CAAC,mBAAmB,CAAa;IACxC,OAAO,CAAC,iBAAiB,CAAa;IACtC,OAAO,CAAC,iBAAiB,CAAa;IAEtC,OAAO,CAAC,oBAAoB,CAAoB;IAChD,OAAO,CAAC,iBAAiB,CAAoB;IAC7C,OAAO,CAAC,oBAAoB,CAAoB;IAChD,OAAO,CAAC,mBAAmB,CAAY;IACvC,OAAO,CAAC,oBAAoB,CAAY;IACxC,OAAO,CAAC,oBAAoB,CAAY;IACxC,OAAO,CAAC,aAAa,CAAa;IAElC,OAAO,CAAC,qBAAqB,CAAC,CAAc;IAC5C,OAAO,CAAC,mBAAmB,CAAC,CAAc;IAC1C,OAAO,CAAC,mBAAmB,CAAC,CAAc;IAC1C,OAAO,CAAC,qBAAqB,CAAC,CAAc;IAE5C,OAAO,CAAC,cAAc,CAAyC;IAC/D,OAAO,CAAC,cAAc,CAAyC;IAE/D,OAAO,CAAC,iBAAiB,CAA6C;IAEtE,OAAO,CAAC,YAAY,CAAqB;IACzC,OAAO,CAAC,QAAQ,CAAa;IAC7B,OAAO,CAAC,OAAO,CAAa;IAC5B,OAAO,CAAC,eAAe,CAAa;IACpC,OAAO,CAAC,YAAY,CAAgC;IACpD,OAAO,CAAC,uBAAuB,CAAQ;IAEvC,OAAO,CAAC,SAAS,CAAiB;IAElC,OAAO,CAAC,aAAa,CAAoB;IACzC,OAAO,CAAC,qBAAqB,CAAI;IACjC,OAAO,CAAC,aAAa,CAAoB;IACzC,OAAO,CAAC,YAAY,CAAI;IACxB,OAAO,CAAC,cAAc,CAAI;IAC1B,OAAO,CAAC,KAAK,CAGZ;IACD,OAAO,CAAC,gBAAgB,CAAsB;IAC9C,OAAO,CAAC,kBAAkB,CAA4B;IAEtD,OAAO,CAAC,MAAM,CAAuB;IACrC,OAAO,CAAC,YAAY,CAAQ;gBAEhB,MAAM,EAAE,iBAAiB,EAAE,OAAO,CAAC,EAAE,aAAa;IAYjD,IAAI;IA6BjB,OAAO,CAAC,oBAAoB;IA+B5B,OAAO,CAAC,eAAe;IA4cvB,OAAO,CAAC,oBAAoB;IA4O5B,OAAO,CAAC,UAAU;IA+DlB,OAAO,CAAC,WAAW;IAMnB,OAAO,CAAC,YAAY;IA+EpB,OAAO,CAAC,WAAW;IAcnB,OAAO,CAAC,aAAa;IAYrB,OAAO,CAAC,eAAe;IAQV,aAAa,CAAC,GAAG,EAAE,MAAM;IAW/B,aAAa;IAgBb,aAAa;IAIb,cAAc;IAId,aAAa,CAAC,IAAI,EAAE,MAAM;IAU1B,oBAAoB;IAI3B;;OAEG;IACH,OAAO,CAAC,SAAS;IAuBjB;;;;OAIG;IACH,OAAO,CAAC,oBAAoB;IAmCrB,QAAQ,IAAI,WAAW;IAIvB,aAAa,CAAC,QAAQ,CAAC,EAAE,MAAM,IAAI;IAgBnC,cAAc;IAQd,OAAO;IAWD,SAAS,CAAC,IAAI,EAAE,MAAM;IAY5B,WAAW,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,EAAE,UAAU,CAAC,EAAE,MAAM;IASnE,SAAS,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,oBAAoB,EAAE,IAAI,EAAE,EAAE,UAAU,CAAC,EAAE,MAAM;IAI5E,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,MAAM,GAAG,IAAI;IAQ9E,OAAO,CAAC,kBAAkB;YAQZ,iBAAiB;YA+DjB,cAAc;IA+I5B,OAAO,CAAC,2BAA2B;IAMnC,OAAO,CAAC,mBAAmB;YAUb,qBAAqB;IAmCnC,OAAO,CAAC,UAAU;IAYlB,OAAO,CAAC,UAAU;IA8CX,MAAM;IAoFb,OAAO,CAAC,UAAU;IAmGlB,OAAO,CAAC,oBAAoB;IAY5B,OAAO,CAAC,kBAAkB;IAU1B,OAAO,CAAC,eAAe;IAavB,OAAO,CAAC,mBAAmB;IAW3B,OAAO,CAAC,YAAY;IAWpB,OAAO,CAAC,WAAW;CA0BpB"}