reze-engine 0.2.19 → 0.3.0

package/src/model.ts

@@ -1,5 +1,6 @@
-import { Mat4, Quat, easeInOut } from "./math"
+import { Mat4, Quat, Vec3, easeInOut } from "./math"
 import { Rigidbody, Joint } from "./physics"
+import { IKSolverSystem } from "./ik-solver"
 
 const VERTEX_STRIDE = 8
 
@@ -37,6 +38,53 @@ export interface Bone {
   appendRatio?: number // 0..1
   appendRotate?: boolean
   appendMove?: boolean
+  ikTargetIndex?: number // IK target bone index (if this bone is an IK effector)
+  ikIteration?: number // IK iteration count
+  ikLimitAngle?: number // IK rotation constraint (radians)
+  ikLinks?: IKLink[] // IK chain links
+}
+
+// IK link with angle constraints
+export interface IKLink {
+  boneIndex: number
+  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
+export interface IKSolver {
+  index: number
+  ikBoneIndex: number // Effector bone (the bone that should reach the target)
+  targetBoneIndex: number // Target bone
+  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)
+export interface IKChainInfo {
+  ikRotation: Quat // Accumulated IK rotation
+  localRotation: Quat // Cached local rotation before IK
 }
 
 export interface Skeleton {
@@ -81,6 +129,8 @@ export interface SkeletonRuntime {
   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
 }
 
 // Runtime morph state
@@ -107,6 +157,15 @@ interface MorphWeightTweenState {
   durationMs: Float32Array // one float per morph (ms)
 }
 
+// Translation tween state per bone
+interface TranslationTweenState {
+  active: Uint8Array // 0/1 per bone
+  startVec: Float32Array // vec3 per bone (x,y,z)
+  targetVec: Float32Array // vec3 per bone (x,y,z)
+  startTimeMs: Float32Array // one float per bone (ms)
+  durationMs: Float32Array // one float per bone (ms)
+}
+
 export class Model {
   private vertexData: Float32Array<ArrayBuffer>
   private baseVertexData: Float32Array<ArrayBuffer> // Original vertex data before morphing
@@ -136,6 +195,7 @@ export class Model {
   private cachedIdentityMat2 = Mat4.identity()
 
   private rotTweenState!: RotationTweenState
+  private transTweenState!: TranslationTweenState
   private morphTweenState!: MorphWeightTweenState
 
   constructor(
@@ -168,6 +228,7 @@ export class Model {
 
     this.initializeRuntimeSkeleton()
     this.initializeRotTweenBuffers()
+    this.initializeTransTweenBuffers()
     this.initializeRuntimeMorph()
     this.initializeMorphTweenBuffers()
     this.applyMorphs() // Apply initial morphs (all weights are 0, so no change)
@@ -197,6 +258,58 @@ export class Model {
         rotations[qi + 3] = 1
       }
     }
+
+    // Initialize IK runtime state
+    this.initializeIKRuntime()
+  }
+
+  private initializeIKRuntime(): void {
+    const boneCount = this.skeleton.bones.length
+    const bones = this.skeleton.bones
+
+    // Initialize IK chain info for all bones (will be populated for IK chain bones)
+    const ikChainInfo: IKChainInfo[] = new Array(boneCount)
+    for (let i = 0; i < boneCount; i++) {
+      ikChainInfo[i] = {
+        ikRotation: new Quat(0, 0, 0, 1),
+        localRotation: new Quat(0, 0, 0, 1),
+      }
+    }
+
+    // Build IK solvers from bone data
+    const ikSolvers: IKSolver[] = []
+    let solverIndex = 0
+
+    for (let i = 0; i < boneCount; i++) {
+      const bone = bones[i]
+      if (bone.ikTargetIndex !== undefined && bone.ikLinks && bone.ikLinks.length > 0) {
+        // Check if all links are affected by physics (for optimization)
+        let canSkipWhenPhysicsEnabled = true
+        for (const link of bone.ikLinks) {
+          // For now, assume no bones are physics-controlled (can be enhanced later)
+          // If a bone has a rigidbody attached, it's physics-controlled
+          const hasPhysics = this.rigidbodies.some((rb) => rb.boneIndex === link.boneIndex)
+          if (!hasPhysics) {
+            canSkipWhenPhysicsEnabled = false
+            break
+          }
+        }
+
+        const solver: IKSolver = {
+          index: solverIndex++,
+          ikBoneIndex: i,
+          targetBoneIndex: bone.ikTargetIndex,
+          iterationCount: bone.ikIteration ?? 1,
+          limitAngle: bone.ikLimitAngle ?? Math.PI,
+          links: bone.ikLinks,
+          canSkipWhenPhysicsEnabled,
+        }
+        ikSolvers.push(solver)
+      }
+    }
+
+    this.runtimeSkeleton.ikChainInfo = ikChainInfo
+    this.runtimeSkeleton.ikSolvers = ikSolvers
   }
 
   private initializeRotTweenBuffers(): void {
@@ -210,6 +323,17 @@ export class Model {
     }
   }
 
+  private initializeTransTweenBuffers(): void {
+    const n = this.skeleton.bones.length
+    this.transTweenState = {
+      active: new Uint8Array(n),
+      startVec: new Float32Array(n * 3),
+      targetVec: new Float32Array(n * 3),
+      startTimeMs: new Float32Array(n),
+      durationMs: new Float32Array(n),
+    }
+  }
+
   private initializeMorphTweenBuffers(): void {
     const n = this.morphing.morphs.length
     this.morphTweenState = {
@@ -270,6 +394,29 @@ export class Model {
     }
   }
 
+  private updateTranslationTweens(): void {
+    const state = this.transTweenState
+    const now = performance.now()
+    const translations = this.runtimeSkeleton.localTranslations
+    const boneCount = this.skeleton.bones.length
+
+    for (let i = 0; i < boneCount; i++) {
+      if (state.active[i] !== 1) continue
+
+      const startMs = state.startTimeMs[i]
+      const durMs = Math.max(1, state.durationMs[i])
+      const t = Math.max(0, Math.min(1, (now - startMs) / durMs))
+      const e = easeInOut(t)
+
+      const ti = i * 3
+      translations[ti] = state.startVec[ti] + (state.targetVec[ti] - state.startVec[ti]) * e
+      translations[ti + 1] = state.startVec[ti + 1] + (state.targetVec[ti + 1] - state.startVec[ti + 1]) * e
+      translations[ti + 2] = state.startVec[ti + 2] + (state.targetVec[ti + 2] - state.startVec[ti + 2]) * e
+
+      if (t >= 1) state.active[i] = 0
+    }
+  }
+
   private updateMorphWeightTweens(): boolean {
     const state = this.morphTweenState
     const now = performance.now()
@@ -427,6 +574,108 @@ export class Model {
     }
   }
 
+  // Move bones using VMD-style relative translations (relative to bind pose world position)
+  // This is the default behavior for VMD animations
+  moveBones(names: string[], relativeTranslations: Vec3[], durationMs?: number): void {
+    const state = this.transTweenState
+    const now = performance.now()
+    const dur = durationMs && durationMs > 0 ? durationMs : 0
+    const localRot = this.runtimeSkeleton.localRotations
+
+    // Compute bind pose world positions for all bones
+    const skeleton = this.skeleton
+    const computeBindPoseWorldPosition = (idx: 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 (let i = 0; i < names.length; i++) {
+      const name = names[i]
+      const idx = this.runtimeSkeleton.nameIndex[name] ?? -1
+      if (idx < 0 || idx >= this.skeleton.bones.length) continue
+
+      const bone = this.skeleton.bones[idx]
+      const ti = idx * 3
+      const qi = idx * 4
+      const translations = this.runtimeSkeleton.localTranslations
+      const vmdRelativeTranslation = relativeTranslations[i]
+
+      // VMD translation is relative to bind pose world position
+      // targetWorldPos = bindPoseWorldPos + vmdRelativeTranslation
+      const bindPoseWorldPos = computeBindPoseWorldPosition(idx)
+      const targetWorldPos = bindPoseWorldPos.add(vmdRelativeTranslation)
+
+      // Convert target world position to local translation
+      // We need parent's bind pose world position to transform to parent space
+      let parentBindPoseWorldPos: Vec3
+      if (bone.parentIndex >= 0) {
+        parentBindPoseWorldPos = computeBindPoseWorldPosition(bone.parentIndex)
+      } else {
+        parentBindPoseWorldPos = new Vec3(0, 0, 0)
+      }
+
+      // Transform target world position to parent's local space
+      // In bind pose, parent's world matrix is just a translation
+      const parentSpacePos = targetWorldPos.subtract(parentBindPoseWorldPos)
+
+      // Subtract bindTranslation to get position after bind translation
+      const afterBindTranslation = parentSpacePos.subtract(
+        new Vec3(bone.bindTranslation[0], bone.bindTranslation[1], bone.bindTranslation[2])
+      )
+
+      // Apply inverse rotation to get local translation
+      const localRotation = new Quat(localRot[qi], localRot[qi + 1], localRot[qi + 2], localRot[qi + 3])
+      const invRotation = localRotation.conjugate().normalize()
+      const rotationMat = Mat4.fromQuat(invRotation.x, invRotation.y, invRotation.z, invRotation.w)
+      const rm = rotationMat.values
+      const localTranslation = new Vec3(
+        rm[0] * afterBindTranslation.x + rm[4] * afterBindTranslation.y + rm[8] * afterBindTranslation.z,
+        rm[1] * afterBindTranslation.x + rm[5] * afterBindTranslation.y + rm[9] * afterBindTranslation.z,
+        rm[2] * afterBindTranslation.x + rm[6] * afterBindTranslation.y + rm[10] * afterBindTranslation.z
+      )
+
+      const [tx, ty, tz] = [localTranslation.x, localTranslation.y, localTranslation.z]
+
+      if (dur === 0) {
+        translations[ti] = tx
+        translations[ti + 1] = ty
+        translations[ti + 2] = tz
+        state.active[idx] = 0
+        continue
+      }
+
+      let sx = translations[ti]
+      let sy = translations[ti + 1]
+      let sz = translations[ti + 2]
+
+      if (state.active[idx] === 1) {
+        const startMs = state.startTimeMs[idx]
+        const prevDur = Math.max(1, state.durationMs[idx])
+        const t = Math.max(0, Math.min(1, (now - startMs) / prevDur))
+        const e = easeInOut(t)
+        sx = state.startVec[ti] + (state.targetVec[ti] - state.startVec[ti]) * e
+        sy = state.startVec[ti + 1] + (state.targetVec[ti + 1] - state.startVec[ti + 1]) * e
+        sz = state.startVec[ti + 2] + (state.targetVec[ti + 2] - state.startVec[ti + 2]) * e
+      }
+
+      state.startVec[ti] = sx
+      state.startVec[ti + 1] = sy
+      state.startVec[ti + 2] = sz
+      state.targetVec[ti] = tx
+      state.targetVec[ti + 1] = ty
+      state.targetVec[ti + 2] = tz
+      state.startTimeMs[idx] = now
+      state.durationMs[idx] = dur
+      state.active[idx] = 1
+    }
+  }
+
   getBoneWorldMatrices(): Float32Array {
     return this.runtimeSkeleton.worldMatrices
   }
@@ -547,14 +796,42 @@ export class Model {
 
   evaluatePose(): boolean {
     this.updateRotationTweens()
+    this.updateTranslationTweens()
     const hasActiveMorphTweens = this.updateMorphWeightTweens()
     if (hasActiveMorphTweens) {
       this.applyMorphs()
     }
+
+    // Compute initial world matrices (needed for IK solving)
     this.computeWorldMatrices()
+
+    // Solve IK chains (modifies localRotations)
+    this.solveIKChains()
+
+    // Recompute world matrices with IK rotations applied
+    this.computeWorldMatrices()
+
     return hasActiveMorphTweens
   }
 
+  private solveIKChains(): void {
+    const ikSolvers = this.runtimeSkeleton.ikSolvers
+    if (!ikSolvers || ikSolvers.length === 0) return
+
+    const ikChainInfo = this.runtimeSkeleton.ikChainInfo
+    if (!ikChainInfo) return
+
+    IKSolverSystem.solve(
+      ikSolvers,
+      this.skeleton.bones,
+      this.runtimeSkeleton.localRotations,
+      this.runtimeSkeleton.localTranslations,
+      this.runtimeSkeleton.worldMatrices,
+      ikChainInfo,
+      false // usePhysics - can be enhanced later
+    )
+  }
+
   private computeWorldMatrices(): void {
     const bones = this.skeleton.bones
     const localRot = this.runtimeSkeleton.localRotations
@@ -622,11 +899,15 @@ export class Model {
         }
       }
 
-      // Build local matrix: identity + bind translation, then rotation, then append translation
+      // Build local matrix: identity + bind translation, then rotation, then local translation, then append translation
+      const ti = i * 3
+      const localTx = localTrans[ti] + addLocalTx
+      const localTy = localTrans[ti + 1] + addLocalTy
+      const localTz = localTrans[ti + 2] + addLocalTz
       this.cachedIdentityMat1
         .setIdentity()
         .translateInPlace(b.bindTranslation[0], b.bindTranslation[1], b.bindTranslation[2])
-      this.cachedIdentityMat2.setIdentity().translateInPlace(addLocalTx, addLocalTy, addLocalTz)
+      this.cachedIdentityMat2.setIdentity().translateInPlace(localTx, localTy, localTz)
       const localM = this.cachedIdentityMat1.multiply(rotateM).multiply(this.cachedIdentityMat2)
 
       const worldOffset = i * 16