blacktrigram 0.7.2

package/lib/systems/animation/builders/KeyframeInterpolation.js

@@ -0,0 +1,252 @@
+import * as THREE from "three";
+//#region src/systems/animation/builders/KeyframeInterpolation.ts
+/**
+* Keyframe interpolation for smooth skeletal animations
+* 
+* Provides interpolation between animation keyframes for smooth 60fps playback.
+* Supports linear, ease-in, ease-out, and ease-in-out easing functions.
+* 
+* @module systems/animation/KeyframeInterpolation
+* @category Animation System
+* @korean 키프레임보간
+*/
+/**
+* Cubic bezier easing for natural movement
+* 
+* **Korean**: 3차 베지어 이징
+* 
+* Implements cubic bezier curve interpolation for smooth, natural motion.
+* Based on CSS cubic-bezier() function specification.
+* 
+* This function uses a configuration object approach for better API clarity.
+* By default, uses simplified approximation (x progresses linearly with t) which
+* provides good results for animation with minimal overhead. Enable precisionMode
+* for exact calculations when needed.
+* 
+* @param t - Input time (0-1)
+* @param options - Bezier control points and configuration
+* @returns Eased value
+* 
+* @example
+* ```typescript
+* // Natural Korean martial arts movement (physics-based)
+* const eased = cubicBezierWithOptions(0.5, { 
+*   p1x: 0.25, p1y: 0.1, p2x: 0.25, p2y: 1.0 
+* });
+* 
+* // With precision mode for exact calculation
+* const precise = cubicBezierWithOptions(0.5, {
+*   p1x: 0.42, p1y: 0, p2x: 0.58, p2y: 1.0,
+*   precisionMode: true
+* });
+* ```
+* 
+* @korean 3차베지어이징옵션
+*/
+function cubicBezierWithOptions(t, options) {
+	const clampedT = Math.max(0, Math.min(1, t));
+	const u = 1 - clampedT;
+	return 3 * u * u * clampedT * options.p1y + 3 * u * clampedT * clampedT * options.p2y + clampedT * clampedT * clampedT;
+}
+/**
+* Cubic bezier easing (legacy function signature for backward compatibility)
+* 
+* **Korean**: 3차 베지어 이징 (레거시)
+* 
+* @param t - Input time (0-1)
+* @param p1x - First control point x (0-1) - currently unused, reserved for precision mode
+* @param p1y - First control point y (can exceed 0-1 for overshoot)
+* @param p2x - Second control point x (0-1) - currently unused, reserved for precision mode
+* @param p2y - Second control point y (can exceed 0-1 for overshoot)
+* @returns Eased value
+* 
+* @deprecated Use cubicBezierWithOptions for clearer API
+* @korean 3차베지어이징레거시
+*/
+function cubicBezier(t, p1x, p1y, p2x, p2y) {
+	return cubicBezierWithOptions(t, {
+		p1x,
+		p1y,
+		p2x,
+		p2y
+	});
+}
+/**
+* Create a cubic bezier easing function with control points
+* 
+* **Korean**: 베지어 이징 함수 생성
+* 
+* Factory function to create reusable bezier easing functions.
+* 
+* @param points - Bezier control points
+* @returns Easing function
+* 
+* @korean 베지어이징함수생성
+*/
+function createBezierEasing(points) {
+	return (t) => cubicBezier(t, points.p1x, points.p1y, points.p2x, points.p2y);
+}
+/**
+* Preset bezier easing curves for Korean martial arts movements
+* 
+* **Korean**: 무도 동작 이징 곡선
+* 
+* @public
+* @category Animation
+* @korean 무도동작이징곡선
+*/
+var BEZIER_PRESETS = {
+	naturalMotion: {
+		p1x: .25,
+		p1y: .1,
+		p2x: .25,
+		p2y: 1
+	},
+	smoothTransition: {
+		p1x: .42,
+		p1y: 0,
+		p2x: .58,
+		p2y: 1
+	},
+	quickStart: {
+		p1x: .1,
+		p1y: .8,
+		p2x: .25,
+		p2y: 1
+	},
+	explosivePower: {
+		p1x: .05,
+		p1y: .9,
+		p2x: .2,
+		p2y: 1
+	},
+	controlledSlow: {
+		p1x: .6,
+		p1y: 0,
+		p2x: .9,
+		p2y: .4
+	}
+};
+createBezierEasing(BEZIER_PRESETS.naturalMotion);
+createBezierEasing(BEZIER_PRESETS.smoothTransition);
+createBezierEasing(BEZIER_PRESETS.explosivePower);
+/**
+* Create motion prediction state
+* 
+* **Korean**: 동작 예측 상태 생성
+* 
+* @returns Initial motion prediction state
+* @korean 동작예측상태생성
+*/
+var createMotionPredictionState = () => ({
+	velocities: /* @__PURE__ */ new Map(),
+	angularVelocities: /* @__PURE__ */ new Map(),
+	lastUpdateTime: 0
+});
+/**
+* Update motion prediction state with new keyframe
+* 
+* **Korean**: 동작 예측 상태 업데이트
+* 
+* Calculates velocities from keyframe differences for motion prediction.
+* 
+* @param state - Current prediction state
+* @param previousKeyframe - Previous animation keyframe
+* @param currentKeyframe - Current animation keyframe
+* @param deltaTime - Time elapsed between keyframes
+* @returns Updated prediction state
+* 
+* @korean 동작예측상태업데이트
+*/
+var updateMotionPrediction = (state, previousKeyframe, currentKeyframe, deltaTime) => {
+	if (deltaTime <= 0) return state;
+	const newVelocities = /* @__PURE__ */ new Map();
+	const newAngularVelocities = /* @__PURE__ */ new Map();
+	currentKeyframe.bonePositions.forEach((currentPos, boneName) => {
+		const prevPos = previousKeyframe.bonePositions.get(boneName);
+		if (prevPos) {
+			const velocity = new THREE.Vector3().subVectors(currentPos, prevPos).divideScalar(deltaTime);
+			newVelocities.set(boneName, velocity);
+		}
+	});
+	currentKeyframe.boneRotations.forEach((currentRot, boneName) => {
+		const prevRot = previousKeyframe.boneRotations.get(boneName);
+		if (prevRot) {
+			const qCurrent = new THREE.Quaternion().setFromEuler(currentRot);
+			const qPrev = new THREE.Quaternion().setFromEuler(prevRot);
+			const qDiff = qCurrent.clone().multiply(qPrev.clone().invert());
+			const axis = new THREE.Vector3();
+			const wClamped = THREE.MathUtils.clamp(qDiff.w, -1, 1);
+			let angle = 2 * Math.acos(wClamped);
+			const sinHalfAngle = Math.sqrt(1 - wClamped * wClamped);
+			if (sinHalfAngle < 1e-4) {
+				axis.set(0, 0, 0);
+				angle = 0;
+			} else axis.set(qDiff.x / sinHalfAngle, qDiff.y / sinHalfAngle, qDiff.z / sinHalfAngle);
+			if (angle > Math.PI) angle -= 2 * Math.PI;
+			const angularVelocityVec = axis.multiplyScalar(angle / deltaTime);
+			const angularVel = new THREE.Euler(angularVelocityVec.x, angularVelocityVec.y, angularVelocityVec.z, currentRot.order);
+			newAngularVelocities.set(boneName, angularVel);
+		}
+	});
+	return {
+		velocities: newVelocities,
+		angularVelocities: newAngularVelocities,
+		lastUpdateTime: performance.now()
+	};
+};
+/**
+* Predict future keyframe using motion prediction
+* 
+* **Korean**: 동작 예측으로 미래 키프레임 예측
+* 
+* Reduces perceived latency by predicting future bone positions/rotations
+* based on current velocities. Typical prediction: 16-33ms (1-2 frames at 60fps).
+* 
+* @param currentKeyframe - Current animation keyframe
+* @param predictionState - Motion prediction state
+* @param predictionTime - Time ahead to predict (seconds, typically 0.016-0.033)
+* @returns Predicted keyframe
+* 
+* @example
+* ```typescript
+* // Predict 1 frame ahead (16.67ms at 60fps) for <50ms total latency
+* const predicted = predictFutureKeyframe(
+*   currentKeyframe,
+*   motionState,
+*   0.01667
+* );
+* applyKeyframeToRig(rig, predicted);
+* ```
+* 
+* @korean 미래키프레임예측
+*/
+var predictFutureKeyframe = (currentKeyframe, predictionState, predictionTime) => {
+	const clampedPrediction = Math.min(predictionTime, .05);
+	const predictedPositions = /* @__PURE__ */ new Map();
+	currentKeyframe.bonePositions.forEach((currentPos, boneName) => {
+		const velocity = predictionState.velocities.get(boneName);
+		if (velocity) {
+			const predicted = currentPos.clone().add(velocity.clone().multiplyScalar(clampedPrediction * .8));
+			predictedPositions.set(boneName, predicted);
+		} else predictedPositions.set(boneName, currentPos.clone());
+	});
+	const predictedRotations = /* @__PURE__ */ new Map();
+	currentKeyframe.boneRotations.forEach((currentRot, boneName) => {
+		const angularVel = predictionState.angularVelocities.get(boneName);
+		if (angularVel) {
+			const predicted = new THREE.Euler(currentRot.x + angularVel.x * clampedPrediction * .8, currentRot.y + angularVel.y * clampedPrediction * .8, currentRot.z + angularVel.z * clampedPrediction * .8, currentRot.order);
+			predictedRotations.set(boneName, predicted);
+		} else predictedRotations.set(boneName, currentRot.clone());
+	});
+	return {
+		time: currentKeyframe.time + clampedPrediction,
+		boneRotations: predictedRotations,
+		bonePositions: predictedPositions,
+		easing: currentKeyframe.easing
+	};
+};
+//#endregion
+export { createMotionPredictionState, predictFutureKeyframe, updateMotionPrediction };
+
+//# sourceMappingURL=KeyframeInterpolation.js.map

package/lib/systems/animation/builders/KeyframeInterpolation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"KeyframeInterpolation.js","names":[],"sources":["../../../../src/systems/animation/builders/KeyframeInterpolation.ts"],"sourcesContent":["/**\n * Keyframe interpolation for smooth skeletal animations\n * \n * Provides interpolation between animation keyframes for smooth 60fps playback.\n * Supports linear, ease-in, ease-out, and ease-in-out easing functions.\n * \n * @module systems/animation/KeyframeInterpolation\n * @category Animation System\n * @korean 키프레임보간\n */\n\nimport * as THREE from \"three\";\nimport type {\n  AnimationKeyframe,\n  SkeletalAnimation,\n  SkeletalRig,\n} from \"@/types/skeletal\";\n\n/**\n * Easing function type\n * \n * @param t - Time value between 0 and 1\n * @returns Eased value between 0 and 1\n * \n * @korean 이징함수타입\n */\ntype EasingFunction = (t: number) => number;\n\n/**\n * Cubic bezier control points for easing curves\n * \n * **Korean**: 3차 베지어 제어점\n * \n * @public\n * @category Animation\n * @korean 베지어제어점\n */\nexport interface BezierControlPoints {\n  /** First control point x (0-1) */\n  readonly p1x: number;\n  /** First control point y (0-1) */\n  readonly p1y: number;\n  /** Second control point x (0-1) */\n  readonly p2x: number;\n  /** Second control point y (0-1) */\n  readonly p2y: number;\n  /** \n   * Enable precision mode for exact bezier curve calculation\n   * \n   * **Reserved for future implementation.**\n   * \n   * When false (default), uses simplified approximation assuming x progresses linearly with t.\n   * This is standard for CSS cubic-bezier() and provides good results with minimal overhead.\n   * \n   * When true (future), will perform iterative solving for accurate x-t mapping (higher CPU cost).\n   * This would enable non-linear time progression for more complex easing curves.\n   * \n   * Currently unused - kept in interface for forward compatibility without breaking API changes.\n   * \n   * @korean 정밀모드\n   */\n  readonly precisionMode?: boolean;\n}\n\n/**\n * Cubic bezier easing for natural movement\n * \n * **Korean**: 3차 베지어 이징\n * \n * Implements cubic bezier curve interpolation for smooth, natural motion.\n * Based on CSS cubic-bezier() function specification.\n * \n * This function uses a configuration object approach for better API clarity.\n * By default, uses simplified approximation (x progresses linearly with t) which\n * provides good results for animation with minimal overhead. Enable precisionMode\n * for exact calculations when needed.\n * \n * @param t - Input time (0-1)\n * @param options - Bezier control points and configuration\n * @returns Eased value\n * \n * @example\n * ```typescript\n * // Natural Korean martial arts movement (physics-based)\n * const eased = cubicBezierWithOptions(0.5, { \n *   p1x: 0.25, p1y: 0.1, p2x: 0.25, p2y: 1.0 \n * });\n * \n * // With precision mode for exact calculation\n * const precise = cubicBezierWithOptions(0.5, {\n *   p1x: 0.42, p1y: 0, p2x: 0.58, p2y: 1.0,\n *   precisionMode: true\n * });\n * ```\n * \n * @korean 3차베지어이징옵션\n */\nexport function cubicBezierWithOptions(\n  t: number,\n  options: BezierControlPoints\n): number {\n  // Clamp t to [0, 1]\n  const clampedT = Math.max(0, Math.min(1, t));\n  \n  // For performance, use direct calculation (standard for CSS cubic-bezier)\n  // Note: options.precisionMode is currently unused and reserved for future implementation\n  // where we could add iterative solving for exact x-t mapping\n  const u = 1 - clampedT;\n  \n  // Cubic bezier formula: B(t) = (1-t)³P₀ + 3(1-t)²tP₁ + 3(1-t)t²P₂ + t³P₃\n  // For easing, P₀ = (0,0) and P₃ = (1,1), so:\n  // y(t) = 3(1-t)²t*p1y + 3(1-t)t²*p2y + t³\n  const result = 3 * u * u * clampedT * options.p1y + \n                 3 * u * clampedT * clampedT * options.p2y + \n                 clampedT * clampedT * clampedT;\n  \n  return result;\n}\n\n/**\n * Cubic bezier easing (legacy function signature for backward compatibility)\n * \n * **Korean**: 3차 베지어 이징 (레거시)\n * \n * @param t - Input time (0-1)\n * @param p1x - First control point x (0-1) - currently unused, reserved for precision mode\n * @param p1y - First control point y (can exceed 0-1 for overshoot)\n * @param p2x - Second control point x (0-1) - currently unused, reserved for precision mode\n * @param p2y - Second control point y (can exceed 0-1 for overshoot)\n * @returns Eased value\n * \n * @deprecated Use cubicBezierWithOptions for clearer API\n * @korean 3차베지어이징레거시\n */\nexport function cubicBezier(\n  t: number,\n  p1x: number,\n  p1y: number,\n  p2x: number,\n  p2y: number\n): number {\n  return cubicBezierWithOptions(t, { p1x, p1y, p2x, p2y });\n}\n\n/**\n * Create a cubic bezier easing function with control points\n * \n * **Korean**: 베지어 이징 함수 생성\n * \n * Factory function to create reusable bezier easing functions.\n * \n * @param points - Bezier control points\n * @returns Easing function\n * \n * @korean 베지어이징함수생성\n */\nexport function createBezierEasing(points: BezierControlPoints): EasingFunction {\n  return (t: number) => cubicBezier(t, points.p1x, points.p1y, points.p2x, points.p2y);\n}\n\n/**\n * Preset bezier easing curves for Korean martial arts movements\n * \n * **Korean**: 무도 동작 이징 곡선\n * \n * @public\n * @category Animation\n * @korean 무도동작이징곡선\n */\nexport const BEZIER_PRESETS = {\n  /**\n   * Natural motion with physics-based acceleration/deceleration\n   * Ideal for: Stance transitions, body rotations, weight shifts\n   * **Korean**: 자연스러운 물리 기반 동작\n   */\n  naturalMotion: { p1x: 0.25, p1y: 0.1, p2x: 0.25, p2y: 1.0 },\n  \n  /**\n   * Smooth S-curve for fluid transitions\n   * Ideal for: Attack wind-ups, defensive positioning, footwork\n   * **Korean**: 부드러운 S곡선 전환\n   */\n  smoothTransition: { p1x: 0.42, p1y: 0.0, p2x: 0.58, p2y: 1.0 },\n  \n  /**\n   * Quick start with gentle landing\n   * Ideal for: Strike recoil, guard recovery, step completion\n   * **Korean**: 빠른 시작과 부드러운 착지\n   */\n  quickStart: { p1x: 0.1, p1y: 0.8, p2x: 0.25, p2y: 1.0 },\n  \n  /**\n   * Explosive power curve\n   * Ideal for: Explosive strikes, power techniques, ki projection\n   * **Korean**: 폭발적 힘 곡선\n   */\n  explosivePower: { p1x: 0.05, p1y: 0.9, p2x: 0.2, p2y: 1.0 },\n  \n  /**\n   * Controlled deceleration\n   * Ideal for: Defensive withdrawals, cautious movements, guard stance\n   * **Korean**: 제어된 감속\n   */\n  controlledSlow: { p1x: 0.6, p1y: 0.0, p2x: 0.9, p2y: 0.4 },\n} as const;\n\n/**\n * Linear easing (no easing)\n * \n * @param t - Input time (0-1)\n * @returns Same as input\n * \n * @korean 선형이징\n */\nexport const easeLinear: EasingFunction = (t: number): number => t;\n\n/**\n * Ease-in (slow start, fast end) - Simple quadratic\n * \n * @param t - Input time (0-1)\n * @returns Eased value\n * \n * @korean 이즈인\n */\nexport const easeIn: EasingFunction = (t: number): number => t * t;\n\n/**\n * Ease-out (fast start, slow end) - Simple quadratic\n * \n * @param t - Input time (0-1)\n * @returns Eased value\n * \n * @korean 이즈아웃\n */\nexport const easeOut: EasingFunction = (t: number): number => t * (2 - t);\n\n/**\n * Ease-in-out (slow start, slow end) - Simple quadratic\n * \n * @param t - Input time (0-1)\n * @returns Eased value\n * \n * @korean 이즈인아웃\n */\nexport const easeInOut: EasingFunction = (t: number): number => {\n  if (t < 0.5) {\n    return 2 * t * t;\n  }\n  return -1 + (4 - 2 * t) * t;\n};\n\n/**\n * Natural motion bezier easing (preset)\n * \n * **Korean**: 자연스러운 동작 이징\n * \n * Physics-based movement ideal for Korean martial arts.\n * \n * @param t - Input time (0-1)\n * @returns Eased value\n * \n * @korean 자연동작이징\n */\nexport const easeNaturalMotion: EasingFunction = createBezierEasing(BEZIER_PRESETS.naturalMotion);\n\n/**\n * Smooth transition bezier easing (preset)\n * \n * **Korean**: 부드러운 전환 이징\n * \n * S-curve for fluid stance transitions.\n * \n * @param t - Input time (0-1)\n * @returns Eased value\n * \n * @korean 부드러운전환이징\n */\nexport const easeSmoothTransition: EasingFunction = createBezierEasing(BEZIER_PRESETS.smoothTransition);\n\n/**\n * Explosive power bezier easing (preset)\n * \n * **Korean**: 폭발적 힘 이징\n * \n * Explosive acceleration for power strikes.\n * \n * @param t - Input time (0-1)\n * @returns Eased value\n * \n * @korean 폭발적힘이징\n */\nexport const easeExplosivePower: EasingFunction = createBezierEasing(BEZIER_PRESETS.explosivePower);\n\n/**\n * Extended easing function names including bezier presets\n * \n * **Korean**: 확장된 이징 함수 이름\n * \n * @public\n * @category Animation\n * @korean 확장이징함수이름\n */\nexport type EasingName = \n  | \"linear\"\n  | \"ease-in\" \n  | \"ease-out\" \n  | \"ease-in-out\"\n  | \"natural-motion\"\n  | \"smooth-transition\"\n  | \"quick-start\"\n  | \"explosive-power\"\n  | \"controlled-slow\";\n\n/**\n * Get easing function by name\n * \n * **Korean**: 이름으로 이징 함수 구하기\n * \n * @param name - Easing function name (supports bezier presets)\n * @returns Easing function\n * \n * @example\n * ```typescript\n * // Get natural motion easing for Korean martial arts\n * const easing = getEasingFunction(\"natural-motion\");\n * const easedValue = easing(0.5); // Smooth physics-based interpolation\n * \n * // Get explosive power for strike animations\n * const powerEasing = getEasingFunction(\"explosive-power\");\n * ```\n * \n * @korean 이징함수구하기\n */\nexport const getEasingFunction = (\n  name: EasingName = \"linear\"\n): EasingFunction => {\n  switch (name) {\n    case \"ease-in\":\n      return easeIn;\n    case \"ease-out\":\n      return easeOut;\n    case \"ease-in-out\":\n      return easeInOut;\n    case \"natural-motion\":\n      return easeNaturalMotion;\n    case \"smooth-transition\":\n      return easeSmoothTransition;\n    case \"quick-start\":\n      return createBezierEasing(BEZIER_PRESETS.quickStart);\n    case \"explosive-power\":\n      return easeExplosivePower;\n    case \"controlled-slow\":\n      return createBezierEasing(BEZIER_PRESETS.controlledSlow);\n    default:\n      return easeLinear;\n  }\n};\n\n/**\n * Find keyframes surrounding current time\n * \n * Returns the two keyframes to interpolate between for current animation time.\n * \n * @param animation - Skeletal animation\n * @param currentTime - Current time in animation (seconds)\n * @returns Tuple of [previousKeyframe, nextKeyframe, interpolationFactor]\n * \n * @korean 주변키프레임찾기\n */\nexport const findSurroundingKeyframes = (\n  animation: SkeletalAnimation,\n  currentTime: number\n): [AnimationKeyframe, AnimationKeyframe, number] => {\n  const { keyframes } = animation;\n\n  // Clamp time to animation duration\n  const clampedTime = Math.max(\n    0,\n    Math.min(currentTime, animation.duration)\n  );\n\n  // Find keyframes\n  let prevKeyframe = keyframes[0];\n  let nextKeyframe = keyframes[keyframes.length - 1];\n  let interpolationFactor = 0;\n\n  for (let i = 0; i < keyframes.length - 1; i++) {\n    const current = keyframes[i];\n    const next = keyframes[i + 1];\n\n    if (clampedTime >= current.time && clampedTime <= next.time) {\n      prevKeyframe = current;\n      nextKeyframe = next;\n\n      // Calculate interpolation factor (0 to 1)\n      const timeDelta = next.time - current.time;\n      if (timeDelta > 0) {\n        interpolationFactor = (clampedTime - current.time) / timeDelta;\n      }\n      break;\n    }\n  }\n\n  return [prevKeyframe, nextKeyframe, interpolationFactor];\n};\n\n/**\n * Interpolate between two Euler rotations\n * \n * Performs spherical linear interpolation (slerp) for smooth rotation.\n * \n * @param from - Start rotation\n * @param to - End rotation\n * @param t - Interpolation factor (0-1)\n * @param easingFn - Easing function to apply\n * @returns Interpolated rotation\n * \n * @korean 회전보간\n */\nexport const interpolateRotation = (\n  from: THREE.Euler,\n  to: THREE.Euler,\n  t: number,\n  easingFn: EasingFunction = easeLinear\n): THREE.Euler => {\n  const easedT = easingFn(t);\n\n  // Convert Euler to Quaternion for proper slerp\n  const fromQuat = new THREE.Quaternion().setFromEuler(from);\n  const toQuat = new THREE.Quaternion().setFromEuler(to);\n\n  // Slerp between quaternions\n  const result = new THREE.Quaternion().slerpQuaternions(\n    fromQuat,\n    toQuat,\n    easedT\n  );\n\n  // Convert back to Euler\n  const resultEuler = new THREE.Euler().setFromQuaternion(result);\n  return resultEuler;\n};\n\n/**\n * Interpolate between two Vector3 positions\n * \n * Performs linear interpolation for smooth position changes.\n * \n * @param from - Start position\n * @param to - End position\n * @param t - Interpolation factor (0-1)\n * @param easingFn - Easing function to apply\n * @returns Interpolated position\n * \n * @korean 위치보간\n */\nexport const interpolatePosition = (\n  from: THREE.Vector3,\n  to: THREE.Vector3,\n  t: number,\n  easingFn: EasingFunction = easeLinear\n): THREE.Vector3 => {\n  const easedT = easingFn(t);\n  return new THREE.Vector3().lerpVectors(from, to, easedT);\n};\n\n/**\n * Get interpolated keyframe at current time\n * \n * Calculates bone transformations by interpolating between keyframes.\n * \n * @param animation - Skeletal animation\n * @param currentTime - Current time in animation (seconds)\n * @returns Interpolated keyframe\n * \n * @korean 보간된키프레임구하기\n */\nexport const getInterpolatedKeyframe = (\n  animation: SkeletalAnimation,\n  currentTime: number\n): AnimationKeyframe => {\n  const [prevKeyframe, nextKeyframe, t] =\n    findSurroundingKeyframes(animation, currentTime);\n\n  // Get easing function from next keyframe\n  const easingFn = getEasingFunction(nextKeyframe.easing);\n\n  // Interpolate bone rotations\n  const boneRotations = new Map<string, THREE.Euler>();\n  const allBoneNames = new Set([\n    ...prevKeyframe.boneRotations.keys(),\n    ...nextKeyframe.boneRotations.keys(),\n  ]);\n\n  for (const boneName of allBoneNames) {\n    const prevRotation =\n      prevKeyframe.boneRotations.get(boneName) ?? new THREE.Euler();\n    const nextRotation =\n      nextKeyframe.boneRotations.get(boneName) ?? new THREE.Euler();\n\n    const interpolated = interpolateRotation(\n      prevRotation,\n      nextRotation,\n      t,\n      easingFn\n    );\n    boneRotations.set(boneName, interpolated);\n  }\n\n  // Interpolate bone positions\n  const bonePositions = new Map<string, THREE.Vector3>();\n  const allPositionBones = new Set([\n    ...prevKeyframe.bonePositions.keys(),\n    ...nextKeyframe.bonePositions.keys(),\n  ]);\n\n  for (const boneName of allPositionBones) {\n    const prevPosition =\n      prevKeyframe.bonePositions.get(boneName) ?? new THREE.Vector3();\n    const nextPosition =\n      nextKeyframe.bonePositions.get(boneName) ?? new THREE.Vector3();\n\n    const interpolated = interpolatePosition(\n      prevPosition,\n      nextPosition,\n      t,\n      easingFn\n    );\n    bonePositions.set(boneName, interpolated);\n  }\n\n  return {\n    time: currentTime,\n    boneRotations,\n    bonePositions,\n    easing: nextKeyframe.easing,\n  };\n};\n\n/**\n * Apply keyframe to skeletal rig\n * \n * Updates all bone transformations based on keyframe data.\n * \n * @param rig - Skeletal rig to update\n * @param keyframe - Keyframe to apply\n * \n * @korean 키프레임적용\n */\nexport const applyKeyframeToRig = (\n  rig: SkeletalRig,\n  keyframe: AnimationKeyframe\n): void => {\n  // Apply bone rotations\n  keyframe.boneRotations.forEach((rotation, boneName) => {\n    const bone = rig.bones.get(boneName);\n    if (bone) {\n      bone.rotation.copy(rotation);\n    }\n  });\n\n  // Apply bone positions (offset from rest pose)\n  keyframe.bonePositions.forEach((position, boneName) => {\n    const bone = rig.bones.get(boneName);\n    if (bone) {\n      // Add position offset to rest position\n      bone.position.copy(bone.restPosition).add(position);\n    }\n  });\n};\n\n/**\n * Blend between two keyframes\n * \n * Creates smooth transition between two animations for animation blending.\n * Useful for transitioning between stance change and attack, etc.\n * \n * @param keyframe1 - First keyframe\n * @param keyframe2 - Second keyframe\n * @param blendFactor - Blend amount (0 = keyframe1, 1 = keyframe2)\n * @returns Blended keyframe\n * \n * @korean 키프레임블렌드\n */\nexport const blendKeyframes = (\n  keyframe1: AnimationKeyframe,\n  keyframe2: AnimationKeyframe,\n  blendFactor: number\n): AnimationKeyframe => {\n  const clampedBlend = Math.max(0, Math.min(1, blendFactor));\n\n  // Blend rotations\n  const boneRotations = new Map<string, THREE.Euler>();\n  const allBones = new Set([\n    ...keyframe1.boneRotations.keys(),\n    ...keyframe2.boneRotations.keys(),\n  ]);\n\n  allBones.forEach((boneName) => {\n    const rot1 = keyframe1.boneRotations.get(boneName) ?? new THREE.Euler();\n    const rot2 = keyframe2.boneRotations.get(boneName) ?? new THREE.Euler();\n    const blended = interpolateRotation(rot1, rot2, clampedBlend);\n    boneRotations.set(boneName, blended);\n  });\n\n  // Blend positions\n  const bonePositions = new Map<string, THREE.Vector3>();\n  const allPositionBones = new Set([\n    ...keyframe1.bonePositions.keys(),\n    ...keyframe2.bonePositions.keys(),\n  ]);\n\n  allPositionBones.forEach((boneName) => {\n    const pos1 = keyframe1.bonePositions.get(boneName) ?? new THREE.Vector3();\n    const pos2 = keyframe2.bonePositions.get(boneName) ?? new THREE.Vector3();\n    const blended = interpolatePosition(pos1, pos2, clampedBlend);\n    bonePositions.set(boneName, blended);\n  });\n\n  return {\n    time: 0,\n    boneRotations,\n    bonePositions,\n    easing: \"linear\",\n  };\n};\n\n/**\n * Update animation state\n * \n * Advances animation time and returns current interpolated keyframe.\n * Handles looping animations automatically.\n * \n * @param animation - Skeletal animation\n * @param currentTime - Current time in animation\n * @param deltaTime - Time since last update (seconds)\n * @param playbackSpeed - Speed multiplier (1.0 = normal)\n * @returns Updated time and current keyframe\n * \n * @korean 애니메이션상태업데이트\n */\nexport const updateAnimation = (\n  animation: SkeletalAnimation,\n  currentTime: number,\n  deltaTime: number,\n  playbackSpeed = 1.0\n): { time: number; keyframe: AnimationKeyframe; completed: boolean } => {\n  // Advance time\n  let newTime = currentTime + deltaTime * playbackSpeed;\n  let completed = false;\n\n  // Handle looping or completion\n  if (newTime >= animation.duration) {\n    if (animation.loop) {\n      newTime = newTime % animation.duration;\n    } else {\n      newTime = animation.duration;\n      completed = true;\n    }\n  }\n\n  // Get interpolated keyframe\n  const keyframe = getInterpolatedKeyframe(animation, newTime);\n\n  return {\n    time: newTime,\n    keyframe,\n    completed,\n  };\n};\n\n/**\n * Cross-fade blend between two animations\n * \n * **Korean**: 크로스페이드 블렌드\n * \n * Smoothly blends between two overlapping animations to prevent popping.\n * Uses cubic bezier easing for natural transitions.\n * \n * @param animation1 - First animation\n * @param time1 - Current time in first animation\n * @param animation2 - Second animation\n * @param time2 - Current time in second animation\n * @param blendFactor - Blend weight (0 = animation1, 1 = animation2)\n * @param easingName - Easing curve for blend transition\n * @returns Blended keyframe\n * \n * @example\n * ```typescript\n * // Cross-fade from idle to attack over 100ms\n * const blended = crossFadeAnimations(\n *   idleAnim, idleTime,\n *   attackAnim, attackTime,\n *   0.5, // 50% blend\n *   \"smooth-transition\"\n * );\n * applyKeyframeToRig(rig, blended);\n * ```\n * \n * @korean 크로스페이드블렌드\n */\nexport const crossFadeAnimations = (\n  animation1: SkeletalAnimation,\n  time1: number,\n  animation2: SkeletalAnimation,\n  time2: number,\n  blendFactor: number,\n  easingName: EasingName = \"smooth-transition\"\n): AnimationKeyframe => {\n  const keyframe1 = getInterpolatedKeyframe(animation1, time1);\n  const keyframe2 = getInterpolatedKeyframe(animation2, time2);\n  \n  // Apply easing to blend factor\n  const easingFn = getEasingFunction(easingName);\n  const easedBlend = easingFn(Math.max(0, Math.min(1, blendFactor)));\n  \n  return blendKeyframes(keyframe1, keyframe2, easedBlend);\n};\n\n/**\n * Motion prediction state for latency reduction\n * \n * **Korean**: 동작 예측 상태\n * \n * Stores recent animation velocities for motion prediction.\n * \n * @public\n * @category Animation\n * @korean 동작예측상태\n */\nexport interface MotionPredictionState {\n  /** Recent position velocities per bone */\n  readonly velocities: Map<string, THREE.Vector3>;\n  /** Recent rotation velocities per bone */\n  readonly angularVelocities: Map<string, THREE.Euler>;\n  /** Last update timestamp */\n  readonly lastUpdateTime: number;\n}\n\n/**\n * Create motion prediction state\n * \n * **Korean**: 동작 예측 상태 생성\n * \n * @returns Initial motion prediction state\n * @korean 동작예측상태생성\n */\nexport const createMotionPredictionState = (): MotionPredictionState => ({\n  velocities: new Map(),\n  angularVelocities: new Map(),\n  lastUpdateTime: 0,\n});\n\n/**\n * Update motion prediction state with new keyframe\n * \n * **Korean**: 동작 예측 상태 업데이트\n * \n * Calculates velocities from keyframe differences for motion prediction.\n * \n * @param state - Current prediction state\n * @param previousKeyframe - Previous animation keyframe\n * @param currentKeyframe - Current animation keyframe\n * @param deltaTime - Time elapsed between keyframes\n * @returns Updated prediction state\n * \n * @korean 동작예측상태업데이트\n */\nexport const updateMotionPrediction = (\n  state: MotionPredictionState,\n  previousKeyframe: AnimationKeyframe,\n  currentKeyframe: AnimationKeyframe,\n  deltaTime: number\n): MotionPredictionState => {\n  if (deltaTime <= 0) return state;\n  \n  const newVelocities = new Map<string, THREE.Vector3>();\n  const newAngularVelocities = new Map<string, THREE.Euler>();\n  \n  // Calculate position velocities\n  currentKeyframe.bonePositions.forEach((currentPos, boneName) => {\n    const prevPos = previousKeyframe.bonePositions.get(boneName);\n    if (prevPos) {\n      const velocity = new THREE.Vector3()\n        .subVectors(currentPos, prevPos)\n        .divideScalar(deltaTime);\n      newVelocities.set(boneName, velocity);\n    }\n  });\n  \n  // Calculate angular velocities using quaternion-based rotation differences\n  // This avoids gimbal lock and angle wrapping issues with Euler angle differences\n  currentKeyframe.boneRotations.forEach((currentRot, boneName) => {\n    const prevRot = previousKeyframe.boneRotations.get(boneName);\n    if (prevRot) {\n      // Convert Euler rotations to quaternions\n      const qCurrent = new THREE.Quaternion().setFromEuler(currentRot);\n      const qPrev = new THREE.Quaternion().setFromEuler(prevRot);\n      \n      // Calculate relative rotation: qDiff = qCurrent * qPrev^(-1)\n      const qDiff = qCurrent.clone().multiply(qPrev.clone().invert());\n      \n      // Extract axis-angle representation for angular velocity\n      const axis = new THREE.Vector3();\n      const wClamped = THREE.MathUtils.clamp(qDiff.w, -1, 1);\n      let angle = 2 * Math.acos(wClamped);\n      const sinHalfAngle = Math.sqrt(1 - wClamped * wClamped);\n      \n      if (sinHalfAngle < 0.0001) {\n        // If sinHalfAngle is too small, rotation is negligible - use zero velocity\n        axis.set(0, 0, 0);\n        angle = 0;\n      } else {\n        // Extract normalized axis from quaternion\n        axis.set(\n          qDiff.x / sinHalfAngle,\n          qDiff.y / sinHalfAngle,\n          qDiff.z / sinHalfAngle\n        );\n      }\n      \n      // Use shortest rotation path\n      if (angle > Math.PI) {\n        angle -= 2 * Math.PI;\n      }\n      \n      // Angular velocity vector = axis * (angle / deltaTime)\n      const angularVelocityVec = axis.multiplyScalar(angle / deltaTime);\n      \n      // Store as Euler for consistency with existing API\n      const angularVel = new THREE.Euler(\n        angularVelocityVec.x,\n        angularVelocityVec.y,\n        angularVelocityVec.z,\n        currentRot.order\n      );\n      newAngularVelocities.set(boneName, angularVel);\n    }\n  });\n  \n  return {\n    velocities: newVelocities,\n    angularVelocities: newAngularVelocities,\n    lastUpdateTime: performance.now(),\n  };\n};\n\n/**\n * Predict future keyframe using motion prediction\n * \n * **Korean**: 동작 예측으로 미래 키프레임 예측\n * \n * Reduces perceived latency by predicting future bone positions/rotations\n * based on current velocities. Typical prediction: 16-33ms (1-2 frames at 60fps).\n * \n * @param currentKeyframe - Current animation keyframe\n * @param predictionState - Motion prediction state\n * @param predictionTime - Time ahead to predict (seconds, typically 0.016-0.033)\n * @returns Predicted keyframe\n * \n * @example\n * ```typescript\n * // Predict 1 frame ahead (16.67ms at 60fps) for <50ms total latency\n * const predicted = predictFutureKeyframe(\n *   currentKeyframe,\n *   motionState,\n *   0.01667\n * );\n * applyKeyframeToRig(rig, predicted);\n * ```\n * \n * @korean 미래키프레임예측\n */\nexport const predictFutureKeyframe = (\n  currentKeyframe: AnimationKeyframe,\n  predictionState: MotionPredictionState,\n  predictionTime: number\n): AnimationKeyframe => {\n  // Clamp prediction time to reasonable bounds (max 50ms)\n  const clampedPrediction = Math.min(predictionTime, 0.05);\n  \n  // Predict bone positions\n  const predictedPositions = new Map<string, THREE.Vector3>();\n  currentKeyframe.bonePositions.forEach((currentPos, boneName) => {\n    const velocity = predictionState.velocities.get(boneName);\n    if (velocity) {\n      // Apply damping to prevent overshoot (0.8 factor for natural motion)\n      const predicted = currentPos.clone().add(\n        velocity.clone().multiplyScalar(clampedPrediction * 0.8)\n      );\n      predictedPositions.set(boneName, predicted);\n    } else {\n      predictedPositions.set(boneName, currentPos.clone());\n    }\n  });\n  \n  // Predict bone rotations\n  const predictedRotations = new Map<string, THREE.Euler>();\n  currentKeyframe.boneRotations.forEach((currentRot, boneName) => {\n    const angularVel = predictionState.angularVelocities.get(boneName);\n    if (angularVel) {\n      // Apply damping to prevent overshoot\n      const predicted = new THREE.Euler(\n        currentRot.x + angularVel.x * clampedPrediction * 0.8,\n        currentRot.y + angularVel.y * clampedPrediction * 0.8,\n        currentRot.z + angularVel.z * clampedPrediction * 0.8,\n        currentRot.order\n      );\n      predictedRotations.set(boneName, predicted);\n    } else {\n      predictedRotations.set(boneName, currentRot.clone());\n    }\n  });\n  \n  return {\n    time: currentKeyframe.time + clampedPrediction,\n    boneRotations: predictedRotations,\n    bonePositions: predictedPositions,\n    easing: currentKeyframe.easing,\n  };\n};\n"],"mappings":"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"}

package/lib/systems/animation/builders/KickPhaseApplicator.d.ts

@@ -0,0 +1,119 @@
+/**
+ * Kick Phase Application Utilities
+ *
+ * Utilities for applying kick phase poses to keyframes with integrated
+ * anatomy awareness (foot highlighting for kicks).
+ * 발차기 단계 적용 유틸리티 (해부학 통합)
+ *
+ * @module systems/animation/KickPhaseApplicator
+ * @korean 발차기단계적용기
+ */
+import type { KeyframeConfig } from "./KeyframeConfig";
+import { KICK_PHASES } from "./MartialArtsConstants";
+/**
+ * Interface for basic kick phases (CHAMBER, EXTENSION, HIGH_PEAK)
+ * These phases have pelvis as a tuple [x, y, z]
+ */
+interface BasicKickPhase {
+    readonly hip: readonly [number, number, number];
+    readonly knee: readonly [number, number, number];
+    readonly ankle?: readonly [number, number, number];
+    readonly supportKnee?: readonly [number, number, number];
+    readonly pelvis?: readonly [number, number, number];
+}
+/**
+ * Interface for rotational kick phases (ROUNDHOUSE_CHAMBER, SIDE_CHAMBER)
+ * These phases have pelvisY as a single Y-axis value
+ */
+interface RotationalKickPhase {
+    readonly hip: readonly [number, number, number];
+    readonly knee: readonly [number, number, number];
+    readonly pelvisY?: number;
+    readonly spineY?: number;
+    readonly spineLean?: number;
+}
+/** Phase name keys */
+export type KickPhaseName = keyof typeof KICK_PHASES;
+/** Kick side for left/right leg distinction */
+export type KickSide = "left" | "right";
+/**
+ * Apply basic kick phase to a KeyframeConfig with anatomy integration
+ * Handles common kick phase bones: hip, knee, supportKnee, pelvis, ankle
+ * Now includes automatic foot highlighting for kick visualization
+ *
+ * @param kf - KeyframeConfig to apply phase to
+ * @param phase - Basic kick phase data (CHAMBER, EXTENSION, HIGH_PEAK)
+ * @param options - Configuration including anatomy options
+ *
+ * @example
+ * ```typescript
+ * // Apply kick with automatic foot highlight
+ * applyKickPhaseToConfig(kf, KICK_PHASES.EXTENSION, {
+ *   highlightKickingFoot: true
+ * });
+ * ```
+ *
+ * @korean KeyframeConfig에발차기단계적용
+ */
+export declare function applyKickPhaseToConfig(kf: KeyframeConfig, phase: BasicKickPhase, options?: {
+    readonly includeAnkle?: boolean;
+    readonly includePelvis?: boolean;
+    readonly resetFoot?: boolean;
+    readonly side?: KickSide;
+    readonly highlightKickingFoot?: boolean;
+}): void;
+/**
+ * Apply roundhouse-specific kick phase with anatomy integration
+ * Includes pelvisY and spineY single-axis rotations
+ *
+ * @param kf - KeyframeConfig to apply phase to
+ * @param phase - Rotational kick phase data (ROUNDHOUSE_CHAMBER)
+ * @param options - Configuration including anatomy options
+ *
+ * @korean 돌려차기단계적용
+ */
+export declare function applyRoundhousePhaseToConfig(kf: KeyframeConfig, phase: RotationalKickPhase, options?: {
+    readonly side?: KickSide;
+    readonly highlightKickingFoot?: boolean;
+}): void;
+/**
+ * Apply side kick phase with anatomy integration
+ * Includes pelvisY, spineY, and spineLean
+ *
+ * @param kf - KeyframeConfig to apply phase to
+ * @param phase - Rotational kick phase data (SIDE_CHAMBER)
+ * @param options - Configuration including anatomy options
+ *
+ * @korean 옆차기단계적용
+ */
+export declare function applySideKickPhaseToConfig(kf: KeyframeConfig, phase: RotationalKickPhase, options?: {
+    readonly side?: KickSide;
+    readonly highlightKickingFoot?: boolean;
+}): void;
+/**
+ * Apply high peak phase (axe kick rise) with anatomy integration
+ * Includes full pelvis tuple and support knee
+ *
+ * @param kf - KeyframeConfig to apply phase to
+ * @param phase - Basic kick phase data (HIGH_PEAK)
+ * @param options - Configuration including anatomy options
+ *
+ * @korean 높이올리기단계적용
+ */
+export declare function applyHighPeakPhaseToConfig(kf: KeyframeConfig, phase: BasicKickPhase, options?: {
+    readonly side?: KickSide;
+    readonly highlightKickingFoot?: boolean;
+}): void;
+/** Union type for any kick phase from KICK_PHASES */
+export type KickPhase = (typeof KICK_PHASES)[keyof typeof KICK_PHASES];
+/**
+ * Get a kick phase by name
+ *
+ * @param phaseName - Name of the phase from KICK_PHASES
+ * @returns The kick phase data
+ *
+ * @korean 발차기단계가져오기
+ */
+export declare function getKickPhase(phaseName: KickPhaseName): KickPhase;
+export {};
+//# sourceMappingURL=KickPhaseApplicator.d.ts.map

package/lib/systems/animation/builders/KickPhaseApplicator.d.ts.map

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

package/lib/systems/animation/builders/KickPhaseApplicator.js

@@ -0,0 +1,119 @@
+import { BoneName } from "../../../types/skeletal.js";
+//#region src/systems/animation/builders/KickPhaseApplicator.ts
+/**
+* Kick Phase Application Utilities
+*
+* Utilities for applying kick phase poses to keyframes with integrated
+* anatomy awareness (foot highlighting for kicks).
+* 발차기 단계 적용 유틸리티 (해부학 통합)
+*
+* @module systems/animation/KickPhaseApplicator
+* @korean 발차기단계적용기
+*/
+/**
+* Apply basic kick phase to a KeyframeConfig with anatomy integration
+* Handles common kick phase bones: hip, knee, supportKnee, pelvis, ankle
+* Now includes automatic foot highlighting for kick visualization
+*
+* @param kf - KeyframeConfig to apply phase to
+* @param phase - Basic kick phase data (CHAMBER, EXTENSION, HIGH_PEAK)
+* @param options - Configuration including anatomy options
+*
+* @example
+* ```typescript
+* // Apply kick with automatic foot highlight
+* applyKickPhaseToConfig(kf, KICK_PHASES.EXTENSION, {
+*   highlightKickingFoot: true
+* });
+* ```
+*
+* @korean KeyframeConfig에발차기단계적용
+*/
+function applyKickPhaseToConfig(kf, phase, options = {}) {
+	const { includeAnkle = false, includePelvis = true, resetFoot = false, side = "right", highlightKickingFoot = false } = options;
+	const hipBone = side === "right" ? BoneName.HIP_R : BoneName.HIP_L;
+	const kneeBone = side === "right" ? BoneName.KNEE_R : BoneName.KNEE_L;
+	const footBone = side === "right" ? BoneName.FOOT_R : BoneName.FOOT_L;
+	const supportKneeBone = side === "right" ? BoneName.KNEE_L : BoneName.KNEE_R;
+	kf.rotate(hipBone, phase.hip[0], phase.hip[1], phase.hip[2]);
+	kf.rotate(kneeBone, phase.knee[0], phase.knee[1], phase.knee[2]);
+	if (phase.supportKnee) kf.rotate(supportKneeBone, phase.supportKnee[0], phase.supportKnee[1], phase.supportKnee[2]);
+	if (includePelvis && phase.pelvis) {
+		const pelvisYRotation = "pelvisY" in phase && typeof phase.pelvisY === "number" ? phase.pelvisY : phase.pelvis[1];
+		kf.rotate(BoneName.PELVIS, phase.pelvis[0], pelvisYRotation, phase.pelvis[2]);
+	}
+	if (includeAnkle && phase.ankle) kf.rotate(footBone, phase.ankle[0], phase.ankle[1], phase.ankle[2]);
+	if (resetFoot) kf.rotate(footBone, 0, 0, 0);
+	if (highlightKickingFoot) kf.setFootHighlight(side, true);
+}
+/**
+* Apply roundhouse-specific kick phase with anatomy integration
+* Includes pelvisY and spineY single-axis rotations
+*
+* @param kf - KeyframeConfig to apply phase to
+* @param phase - Rotational kick phase data (ROUNDHOUSE_CHAMBER)
+* @param options - Configuration including anatomy options
+*
+* @korean 돌려차기단계적용
+*/
+function applyRoundhousePhaseToConfig(kf, phase, options = {}) {
+	const { side = "right", highlightKickingFoot = false } = options;
+	const hipBone = side === "right" ? BoneName.HIP_R : BoneName.HIP_L;
+	const kneeBone = side === "right" ? BoneName.KNEE_R : BoneName.KNEE_L;
+	kf.rotate(hipBone, phase.hip[0], phase.hip[1], phase.hip[2]);
+	kf.rotate(kneeBone, phase.knee[0], phase.knee[1], phase.knee[2]);
+	if (phase.pelvisY !== void 0) kf.rotate(BoneName.PELVIS, 0, phase.pelvisY, 0);
+	if (phase.spineY !== void 0) kf.rotate(BoneName.SPINE_UPPER, 0, phase.spineY, 0);
+	if (highlightKickingFoot) kf.setFootHighlight(side, true);
+}
+/**
+* Apply side kick phase with anatomy integration
+* Includes pelvisY, spineY, and spineLean
+*
+* @param kf - KeyframeConfig to apply phase to
+* @param phase - Rotational kick phase data (SIDE_CHAMBER)
+* @param options - Configuration including anatomy options
+*
+* @korean 옆차기단계적용
+*/
+function applySideKickPhaseToConfig(kf, phase, options = {}) {
+	const { side = "right", highlightKickingFoot = false } = options;
+	const hipBone = side === "right" ? BoneName.HIP_R : BoneName.HIP_L;
+	const kneeBone = side === "right" ? BoneName.KNEE_R : BoneName.KNEE_L;
+	kf.rotate(hipBone, phase.hip[0], phase.hip[1], phase.hip[2]);
+	kf.rotate(kneeBone, phase.knee[0], phase.knee[1], phase.knee[2]);
+	if (phase.pelvisY !== void 0) kf.rotate(BoneName.PELVIS, 0, phase.pelvisY, 0);
+	if (phase.spineY !== void 0) {
+		const lean = phase.spineLean ?? 0;
+		kf.rotate(BoneName.SPINE_LOWER, 0, phase.spineY, 0);
+		kf.rotate(BoneName.SPINE_UPPER, 0, phase.spineY, lean);
+	}
+	if (highlightKickingFoot) kf.setFootHighlight(side, true);
+}
+/**
+* Apply high peak phase (axe kick rise) with anatomy integration
+* Includes full pelvis tuple and support knee
+*
+* @param kf - KeyframeConfig to apply phase to
+* @param phase - Basic kick phase data (HIGH_PEAK)
+* @param options - Configuration including anatomy options
+*
+* @korean 높이올리기단계적용
+*/
+function applyHighPeakPhaseToConfig(kf, phase, options = {}) {
+	const { side = "right", highlightKickingFoot = false } = options;
+	const hipBone = side === "right" ? BoneName.HIP_R : BoneName.HIP_L;
+	const kneeBone = side === "right" ? BoneName.KNEE_R : BoneName.KNEE_L;
+	const footBone = side === "right" ? BoneName.FOOT_R : BoneName.FOOT_L;
+	const supportKneeBone = side === "right" ? BoneName.KNEE_L : BoneName.KNEE_R;
+	kf.rotate(hipBone, phase.hip[0], phase.hip[1], phase.hip[2]);
+	kf.rotate(kneeBone, phase.knee[0], phase.knee[1], phase.knee[2]);
+	if (phase.ankle) kf.rotate(footBone, phase.ankle[0], phase.ankle[1], phase.ankle[2]);
+	if (phase.supportKnee) kf.rotate(supportKneeBone, phase.supportKnee[0], phase.supportKnee[1], phase.supportKnee[2]);
+	if (phase.pelvis) kf.rotate(BoneName.PELVIS, phase.pelvis[0], phase.pelvis[1], phase.pelvis[2]);
+	if (highlightKickingFoot) kf.setFootHighlight(side, true);
+}
+//#endregion
+export { applyHighPeakPhaseToConfig, applyKickPhaseToConfig, applyRoundhousePhaseToConfig, applySideKickPhaseToConfig };
+
+//# sourceMappingURL=KickPhaseApplicator.js.map

package/lib/systems/animation/builders/KickPhaseApplicator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"KickPhaseApplicator.js","names":[],"sources":["../../../../src/systems/animation/builders/KickPhaseApplicator.ts"],"sourcesContent":["/**\n * Kick Phase Application Utilities\n *\n * Utilities for applying kick phase poses to keyframes with integrated\n * anatomy awareness (foot highlighting for kicks).\n * 발차기 단계 적용 유틸리티 (해부학 통합)\n *\n * @module systems/animation/KickPhaseApplicator\n * @korean 발차기단계적용기\n */\n\nimport { BoneName } from \"@/types/skeletal\";\nimport type { KeyframeConfig } from \"./KeyframeConfig\";\nimport { KICK_PHASES } from \"./MartialArtsConstants\";\n\n/**\n * Interface for basic kick phases (CHAMBER, EXTENSION, HIGH_PEAK)\n * These phases have pelvis as a tuple [x, y, z]\n */\ninterface BasicKickPhase {\n  readonly hip: readonly [number, number, number];\n  readonly knee: readonly [number, number, number];\n  readonly ankle?: readonly [number, number, number];\n  readonly supportKnee?: readonly [number, number, number];\n  readonly pelvis?: readonly [number, number, number];\n}\n\n/**\n * Interface for rotational kick phases (ROUNDHOUSE_CHAMBER, SIDE_CHAMBER)\n * These phases have pelvisY as a single Y-axis value\n */\ninterface RotationalKickPhase {\n  readonly hip: readonly [number, number, number];\n  readonly knee: readonly [number, number, number];\n  readonly pelvisY?: number;\n  readonly spineY?: number;\n  readonly spineLean?: number;\n}\n\n/** Phase name keys */\nexport type KickPhaseName = keyof typeof KICK_PHASES;\n\n/** Kick side for left/right leg distinction */\nexport type KickSide = \"left\" | \"right\";\n\n/**\n * Apply basic kick phase to a KeyframeConfig with anatomy integration\n * Handles common kick phase bones: hip, knee, supportKnee, pelvis, ankle\n * Now includes automatic foot highlighting for kick visualization\n *\n * @param kf - KeyframeConfig to apply phase to\n * @param phase - Basic kick phase data (CHAMBER, EXTENSION, HIGH_PEAK)\n * @param options - Configuration including anatomy options\n *\n * @example\n * ```typescript\n * // Apply kick with automatic foot highlight\n * applyKickPhaseToConfig(kf, KICK_PHASES.EXTENSION, {\n *   highlightKickingFoot: true\n * });\n * ```\n *\n * @korean KeyframeConfig에발차기단계적용\n */\nexport function applyKickPhaseToConfig(\n  kf: KeyframeConfig,\n  phase: BasicKickPhase,\n  options: {\n    readonly includeAnkle?: boolean;\n    readonly includePelvis?: boolean;\n    readonly resetFoot?: boolean;\n    // Anatomy integration\n    readonly side?: KickSide;\n    readonly highlightKickingFoot?: boolean;\n  } = {},\n): void {\n  const {\n    includeAnkle = false,\n    includePelvis = true,\n    resetFoot = false,\n    side = \"right\",\n    highlightKickingFoot = false,\n  } = options;\n\n  // Select bones based on kicking leg\n  const hipBone = side === \"right\" ? BoneName.HIP_R : BoneName.HIP_L;\n  const kneeBone = side === \"right\" ? BoneName.KNEE_R : BoneName.KNEE_L;\n  const footBone = side === \"right\" ? BoneName.FOOT_R : BoneName.FOOT_L;\n  const supportKneeBone = side === \"right\" ? BoneName.KNEE_L : BoneName.KNEE_R;\n\n  // Required bones for all kick phases\n  kf.rotate(hipBone, phase.hip[0], phase.hip[1], phase.hip[2]);\n  kf.rotate(kneeBone, phase.knee[0], phase.knee[1], phase.knee[2]);\n\n  if (phase.supportKnee) {\n    kf.rotate(\n      supportKneeBone,\n      phase.supportKnee[0],\n      phase.supportKnee[1],\n      phase.supportKnee[2],\n    );\n  }\n\n  // Optional pelvis - includes both tilt (X) and rotation (Y)\n  if (includePelvis && phase.pelvis) {\n    // Use pelvisY if defined (for hip rotation power), otherwise pelvis[1]\n    const pelvisYRotation =\n      \"pelvisY\" in phase && typeof phase.pelvisY === \"number\"\n        ? phase.pelvisY\n        : phase.pelvis[1];\n    kf.rotate(\n      BoneName.PELVIS,\n      phase.pelvis[0],\n      pelvisYRotation,\n      phase.pelvis[2],\n    );\n  }\n\n  // Optional ankle\n  if (includeAnkle && phase.ankle) {\n    kf.rotate(footBone, phase.ankle[0], phase.ankle[1], phase.ankle[2]);\n  }\n\n  // Reset foot position\n  if (resetFoot) {\n    kf.rotate(footBone, 0, 0, 0);\n  }\n\n  // Anatomy integration: Highlight kicking foot\n  if (highlightKickingFoot) {\n    kf.setFootHighlight(side, true);\n  }\n}\n\n/**\n * Apply roundhouse-specific kick phase with anatomy integration\n * Includes pelvisY and spineY single-axis rotations\n *\n * @param kf - KeyframeConfig to apply phase to\n * @param phase - Rotational kick phase data (ROUNDHOUSE_CHAMBER)\n * @param options - Configuration including anatomy options\n *\n * @korean 돌려차기단계적용\n */\nexport function applyRoundhousePhaseToConfig(\n  kf: KeyframeConfig,\n  phase: RotationalKickPhase,\n  options: {\n    readonly side?: KickSide;\n    readonly highlightKickingFoot?: boolean;\n  } = {},\n): void {\n  const { side = \"right\", highlightKickingFoot = false } = options;\n\n  const hipBone = side === \"right\" ? BoneName.HIP_R : BoneName.HIP_L;\n  const kneeBone = side === \"right\" ? BoneName.KNEE_R : BoneName.KNEE_L;\n\n  kf.rotate(hipBone, phase.hip[0], phase.hip[1], phase.hip[2]);\n  kf.rotate(kneeBone, phase.knee[0], phase.knee[1], phase.knee[2]);\n\n  // Y-axis only rotations for roundhouse\n  if (phase.pelvisY !== undefined) {\n    kf.rotate(BoneName.PELVIS, 0, phase.pelvisY, 0);\n  }\n  if (phase.spineY !== undefined) {\n    kf.rotate(BoneName.SPINE_UPPER, 0, phase.spineY, 0);\n  }\n\n  // Anatomy integration\n  if (highlightKickingFoot) {\n    kf.setFootHighlight(side, true);\n  }\n}\n\n/**\n * Apply side kick phase with anatomy integration\n * Includes pelvisY, spineY, and spineLean\n *\n * @param kf - KeyframeConfig to apply phase to\n * @param phase - Rotational kick phase data (SIDE_CHAMBER)\n * @param options - Configuration including anatomy options\n *\n * @korean 옆차기단계적용\n */\nexport function applySideKickPhaseToConfig(\n  kf: KeyframeConfig,\n  phase: RotationalKickPhase,\n  options: {\n    readonly side?: KickSide;\n    readonly highlightKickingFoot?: boolean;\n  } = {},\n): void {\n  const { side = \"right\", highlightKickingFoot = false } = options;\n\n  const hipBone = side === \"right\" ? BoneName.HIP_R : BoneName.HIP_L;\n  const kneeBone = side === \"right\" ? BoneName.KNEE_R : BoneName.KNEE_L;\n\n  kf.rotate(hipBone, phase.hip[0], phase.hip[1], phase.hip[2]);\n  kf.rotate(kneeBone, phase.knee[0], phase.knee[1], phase.knee[2]);\n\n  // Side kick specific rotations\n  if (phase.pelvisY !== undefined) {\n    kf.rotate(BoneName.PELVIS, 0, phase.pelvisY, 0);\n  }\n  if (phase.spineY !== undefined) {\n    const lean = phase.spineLean ?? 0;\n    kf.rotate(BoneName.SPINE_LOWER, 0, phase.spineY, 0);\n    kf.rotate(BoneName.SPINE_UPPER, 0, phase.spineY, lean);\n  }\n\n  // Anatomy integration\n  if (highlightKickingFoot) {\n    kf.setFootHighlight(side, true);\n  }\n}\n\n/**\n * Apply high peak phase (axe kick rise) with anatomy integration\n * Includes full pelvis tuple and support knee\n *\n * @param kf - KeyframeConfig to apply phase to\n * @param phase - Basic kick phase data (HIGH_PEAK)\n * @param options - Configuration including anatomy options\n *\n * @korean 높이올리기단계적용\n */\nexport function applyHighPeakPhaseToConfig(\n  kf: KeyframeConfig,\n  phase: BasicKickPhase,\n  options: {\n    readonly side?: KickSide;\n    readonly highlightKickingFoot?: boolean;\n  } = {},\n): void {\n  const { side = \"right\", highlightKickingFoot = false } = options;\n\n  const hipBone = side === \"right\" ? BoneName.HIP_R : BoneName.HIP_L;\n  const kneeBone = side === \"right\" ? BoneName.KNEE_R : BoneName.KNEE_L;\n  const footBone = side === \"right\" ? BoneName.FOOT_R : BoneName.FOOT_L;\n  const supportKneeBone = side === \"right\" ? BoneName.KNEE_L : BoneName.KNEE_R;\n\n  kf.rotate(hipBone, phase.hip[0], phase.hip[1], phase.hip[2]);\n  kf.rotate(kneeBone, phase.knee[0], phase.knee[1], phase.knee[2]);\n\n  if (phase.ankle) {\n    kf.rotate(footBone, phase.ankle[0], phase.ankle[1], phase.ankle[2]);\n  }\n  if (phase.supportKnee) {\n    kf.rotate(\n      supportKneeBone,\n      phase.supportKnee[0],\n      phase.supportKnee[1],\n      phase.supportKnee[2],\n    );\n  }\n  if (phase.pelvis) {\n    kf.rotate(\n      BoneName.PELVIS,\n      phase.pelvis[0],\n      phase.pelvis[1],\n      phase.pelvis[2],\n    );\n  }\n\n  // Anatomy integration\n  if (highlightKickingFoot) {\n    kf.setFootHighlight(side, true);\n  }\n}\n\n/** Union type for any kick phase from KICK_PHASES */\nexport type KickPhase = (typeof KICK_PHASES)[keyof typeof KICK_PHASES];\n\n/**\n * Get a kick phase by name\n *\n * @param phaseName - Name of the phase from KICK_PHASES\n * @returns The kick phase data\n *\n * @korean 발차기단계가져오기\n */\nexport function getKickPhase(phaseName: KickPhaseName): KickPhase {\n  return KICK_PHASES[phaseName];\n}\n"],"mappings":"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"}