@directivegames/genesys.js 3.1.24

package/dist/src/animation/AnimationRetargeting.js

@@ -0,0 +1,455 @@
+/**
+ * AnimationRetargeting - runtime animation retargeting between different skeleton conventions.
+ *
+ * Uses the UPF GTI AnimationRetargeting algorithm which handles bind pose differences
+ * between skeletons through quaternion space transformations.
+ *
+ * Retargets animation clips from one skeleton format to another using explicit semantic
+ * bone mappings defined in SkeletonProfiles. This enables using animations from external
+ * sources (Mixamo, UE5, etc.) on characters with different bone naming conventions.
+ *
+ * Recommended usage (for humans and AI assistants):
+ * - Define source and target profiles explicitly in AnimationStateMachineConfig
+ * - Profiles are loaded from JSON assets or referenced by name
+ * - Retargeting happens automatically during external animation loading
+ */
+import * as THREE from 'three';
+import { applyTPose as applyTPoseInternal, AnimationRetargeting as UPFRetargeting } from './retargeting.js';
+// Re-export for external use
+export { applyTPoseInternal as applyTPose };
+import { BoneRole } from './SkeletonProfile.js';
+/** Default name for synthetic root bones */
+const SYNTHETIC_ROOT_BONE_NAME = 'syntheticRoot';
+/**
+ * Add a synthetic root bone to a skeleton that doesn't have one.
+ *
+ * This modifies the skeleton in-place by:
+ * 1. Creating a new root bone at ground level (0,0,0)
+ * 2. Reparenting the current root (typically hips) to be a child of the new root
+ * 3. Rebuilding the skeleton's bone array and inverse bind matrices
+ *
+ * @param skeleton - The skeleton to modify (will be modified in-place)
+ * @param skinnedMesh - The skinned mesh using this skeleton (will be updated)
+ * @param profile - The skeleton profile (will be cloned and updated)
+ * @param rootBoneName - Name for the synthetic root bone
+ * @returns Result containing the modified skeleton and updated profile
+ */
+export function addSyntheticRootBone(skeleton, skinnedMesh, profile, rootBoneName = SYNTHETIC_ROOT_BONE_NAME) {
+    // Don't add if skeleton already has a root bone
+    const existingRootBone = Object.entries(profile.boneToRole)
+        .find(([, role]) => role === BoneRole.Root);
+    if (existingRootBone) {
+        console.warn(`[AnimationRetargeting] Skeleton already has a root bone: ${existingRootBone[0]}`);
+        return { skeleton, rootBoneName: existingRootBone[0], updatedProfile: profile };
+    }
+    const oldBones = skeleton.bones;
+    if (oldBones.length === 0) {
+        throw new Error('[AnimationRetargeting] Cannot add synthetic root to empty skeleton');
+    }
+    // Find the current root bone (the one with no parent in the skeleton)
+    const currentRoot = oldBones[0];
+    // Store the current root's parent (if any, typically the armature or model)
+    const originalParent = currentRoot.parent;
+    // Create synthetic root bone at local origin
+    const syntheticRoot = new THREE.Bone();
+    syntheticRoot.name = rootBoneName;
+    syntheticRoot.position.set(0, 0, 0);
+    syntheticRoot.quaternion.identity();
+    syntheticRoot.scale.set(1, 1, 1);
+    // Reparent: synthetic root becomes parent of current root
+    // Keep hips' local transform unchanged - it becomes relative to synthetic root
+    if (originalParent) {
+        originalParent.remove(currentRoot);
+        originalParent.add(syntheticRoot);
+    }
+    syntheticRoot.add(currentRoot);
+    // Update world matrices
+    syntheticRoot.updateMatrixWorld(true);
+    // Build new bone array with synthetic root at index 0
+    const newBones = [syntheticRoot, ...oldBones];
+    // CRITICAL: Update skin indices in the geometry
+    // Since we inserted a bone at index 0, all existing bone indices must shift by +1
+    const geometry = skinnedMesh.geometry;
+    const skinIndexAttr = geometry.getAttribute('skinIndex');
+    if (skinIndexAttr) {
+        const skinIndices = skinIndexAttr.array;
+        for (let i = 0; i < skinIndices.length; i++) {
+            skinIndices[i] += 1;
+        }
+        skinIndexAttr.needsUpdate = true;
+    }
+    // Preserve original boneInverses and prepend identity for synthetic root
+    // The synthetic root is at origin with identity rotation, so its inverse is identity
+    const syntheticRootInverse = new THREE.Matrix4(); // identity
+    const newBoneInverses = [syntheticRootInverse, ...skeleton.boneInverses];
+    // Create new skeleton with preserved boneInverses
+    const newSkeleton = new THREE.Skeleton(newBones, newBoneInverses);
+    // Update the skinned mesh to use the new skeleton
+    skinnedMesh.bind(newSkeleton, skinnedMesh.bindMatrix);
+    // Create updated profile with synthetic root mapping
+    const updatedProfile = {
+        ...profile,
+        boneToRole: {
+            [rootBoneName]: BoneRole.Root,
+            ...profile.boneToRole
+        }
+    };
+    console.log(`[AnimationRetargeting] Added synthetic root bone "${rootBoneName}" to skeleton. ` +
+        `New bone count: ${newBones.length}`);
+    return {
+        skeleton: newSkeleton,
+        rootBoneName,
+        updatedProfile
+    };
+}
+/**
+ * Check if a skeleton needs a synthetic root bone for retargeting from a source that has one.
+ */
+export function needsSyntheticRoot(sourceProfile, targetProfile) {
+    const sourceHasRoot = Object.values(sourceProfile.boneToRole).includes(BoneRole.Root);
+    const targetHasRoot = Object.values(targetProfile.boneToRole).includes(BoneRole.Root);
+    return sourceHasRoot && !targetHasRoot;
+}
+/**
+ * Add getBoneByName helper to skeleton if it doesn't exist
+ */
+function ensureGetBoneByName(skeleton) {
+    if (!skeleton.getBoneByName) {
+        skeleton.getBoneByName = function (name) {
+            return this.bones.find((b) => b.name === name);
+        };
+    }
+}
+/**
+ * Convert SkeletonProfile to the format applyTPose expects
+ */
+function profileToTPoseMap(profile) {
+    // Invert boneToRole to get roleToName
+    const roleToName = {};
+    for (const [boneName, role] of Object.entries(profile.boneToRole)) {
+        roleToName[role] = boneName;
+    }
+    // Map to the semantic keys applyTPose expects
+    return {
+        Hips: roleToName[BoneRole.Hips],
+        Stomach: roleToName[BoneRole.Spine],
+        ShouldersUnion: roleToName[BoneRole.Chest] ?? roleToName[BoneRole.UpperChest],
+        Neck: roleToName[BoneRole.Neck],
+        Head: roleToName[BoneRole.Head],
+        LShoulder: roleToName[BoneRole.LeftShoulder],
+        LArm: roleToName[BoneRole.LeftUpperArm],
+        LElbow: roleToName[BoneRole.LeftLowerArm],
+        LWrist: roleToName[BoneRole.LeftHand],
+        RShoulder: roleToName[BoneRole.RightShoulder],
+        RArm: roleToName[BoneRole.RightUpperArm],
+        RElbow: roleToName[BoneRole.RightLowerArm],
+        RWrist: roleToName[BoneRole.RightHand],
+        LUpLeg: roleToName[BoneRole.LeftUpperLeg],
+        LLeg: roleToName[BoneRole.LeftLowerLeg],
+        LFoot: roleToName[BoneRole.LeftFoot],
+        LToeBase: roleToName[BoneRole.LeftToeBase],
+        RUpLeg: roleToName[BoneRole.RightUpperLeg],
+        RLeg: roleToName[BoneRole.RightLowerLeg],
+        RFoot: roleToName[BoneRole.RightFoot],
+        RToeBase: roleToName[BoneRole.RightToeBase]
+    };
+}
+/**
+ * Create a bone name mapping between source and target skeletons using their profiles.
+ * Returns an object compatible with UPF AnimationRetargeting: { sourceRole: targetBoneName }
+ */
+export function createBoneMapping(sourceProfile, targetProfile, sourceSkeleton, targetSkeleton) {
+    const mapping = {};
+    // Build reverse map for source: role -> bone name
+    const sourceRoleToBone = new Map();
+    for (const bone of sourceSkeleton.bones) {
+        const role = sourceProfile.boneToRole[bone.name];
+        if (role) {
+            sourceRoleToBone.set(role, bone.name);
+        }
+    }
+    // Build reverse map for target: role -> bone name
+    const targetRoleToBone = new Map();
+    for (const bone of targetSkeleton.bones) {
+        const role = targetProfile.boneToRole[bone.name];
+        if (role) {
+            targetRoleToBone.set(role, bone.name);
+        }
+    }
+    // Map source bones to target bones via semantic roles
+    for (const [role, sourceBoneName] of sourceRoleToBone) {
+        const targetBoneName = targetRoleToBone.get(role);
+        if (targetBoneName) {
+            mapping[sourceBoneName] = targetBoneName;
+        }
+    }
+    // Note: Root motion is dropped when target has no root bone
+    return mapping;
+}
+/**
+ * Retarget an animation clip from source skeleton to target skeleton using UPF GTI retargeting.
+ *
+ * @param sourceClip - The animation clip to retarget
+ * @param sourceProfile - Skeleton profile for the source animation
+ * @param targetProfile - Skeleton profile for the target character
+ * @param sourceSkeleton - Source skeleton (from the animation's original GLTF)
+ * @param targetSkeleton - Target skeleton (from the character being animated)
+ * @param targetSkinnedMesh - Target skinned mesh (required by Three.js retargeting)
+ * @returns Retargeted animation clip, or null if retargeting failed
+ */
+export function retargetAnimationClip(sourceClip, sourceProfile, targetProfile, sourceSkeleton, targetSkeleton, targetSkinnedMesh) {
+    // Build reverse map for source: role -> bone name
+    const sourceRoleToBone = new Map();
+    for (const bone of sourceSkeleton.bones) {
+        const role = sourceProfile.boneToRole[bone.name];
+        if (role) {
+            sourceRoleToBone.set(role, bone.name);
+        }
+    }
+    // Create bone mapping using our profile system
+    const boneMapping = createBoneMapping(sourceProfile, targetProfile, sourceSkeleton, targetSkeleton);
+    if (Object.keys(boneMapping).length === 0) {
+        console.error('[AnimationRetargeting] Failed to create bone mapping - no bones matched');
+        return null;
+    }
+    try {
+        // Add getBoneByName helper method required by applyTPose
+        ensureGetBoneByName(sourceSkeleton);
+        ensureGetBoneByName(targetSkeleton);
+        // Convert our profiles to the format applyTPose expects
+        const sourceTPoseMap = profileToTPoseMap(sourceProfile);
+        const targetTPoseMap = profileToTPoseMap(targetProfile);
+        // Apply T-Pose to both skeletons for consistent bind poses
+        try {
+            const sourceTPose = applyTPoseInternal(sourceSkeleton, sourceTPoseMap);
+            const targetTPose = applyTPoseInternal(targetSkeleton, targetTPoseMap);
+            // Create UPF retargeting instance using CURRENT pose mode to capture the T-Poses
+            const retargeter = new UPFRetargeting(sourceTPose.skeleton, targetTPose.skeleton, {
+                boneNameMap: boneMapping,
+                srcPoseMode: UPFRetargeting.BindPoseModes.CURRENT,
+                trgPoseMode: UPFRetargeting.BindPoseModes.CURRENT,
+                srcEmbedWorldTransforms: true,
+                trgEmbedWorldTransforms: true,
+                positionAxisFlips: targetProfile.positionAxisFlips,
+                hipsPositionAxisFlips: targetProfile.hipsPositionAxisFlips
+            });
+            // Retarget the animation
+            const retargetedClip = retargeter.retargetAnimation(sourceClip);
+            if (!retargetedClip || retargetedClip.tracks.length === 0) {
+                console.error(`[AnimationRetargeting] Failed to retarget "${sourceClip.name}": no tracks generated`);
+                return null;
+            }
+            // CRITICAL: Remove scale tracks to prevent shrinking/deformation
+            const originalTrackCount = retargetedClip.tracks.length;
+            retargetedClip.tracks = retargetedClip.tracks.filter(track => {
+                return !track.name.endsWith('.scale');
+            });
+            // Handle root motion incompatibility between source and target
+            const sourceRootBoneName = sourceRoleToBone.get(BoneRole.Root);
+            const targetRootBoneName = targetProfile.boneToRole[targetSkeleton.bones[0]?.name];
+            const targetHipsBoneName = Array.from(Object.entries(targetProfile.boneToRole))
+                .find(([, role]) => role === BoneRole.Hips)?.[0];
+            // Case 1: Source has no root bone but target does
+            // Mixamo hips position tracks should NOT be applied to Rigify hips (child of root)
+            if (!sourceRootBoneName && targetRootBoneName === BoneRole.Root && targetHipsBoneName) {
+                const hipsPositionTrackIndex = retargetedClip.tracks.findIndex(track => track.name.includes(targetHipsBoneName) && track.name.endsWith('.position'));
+                if (hipsPositionTrackIndex !== -1) {
+                    retargetedClip.tracks.splice(hipsPositionTrackIndex, 1);
+                    console.warn(`[AnimationRetargeting] Removed hips position track from "${sourceClip.name}" ` +
+                        'because source skeleton lacks a root bone (Mixamo) but target has one (Rigify).');
+                }
+            }
+            // Case 2: Source has root motion but target doesn't
+            const sourceHasRootMotion = sourceRootBoneName &&
+                sourceClip.tracks.some(track => track.name.includes(sourceRootBoneName) && track.name.endsWith('.position'));
+            if (sourceHasRootMotion && targetRootBoneName !== BoneRole.Root) {
+                console.warn(`[AnimationRetargeting] Source animation "${sourceClip.name}" contains root motion. ` +
+                    'Root motion tracks are not transferred when target skeleton lacks a root bone. ' +
+                    'Consider implementing root motion extraction to model transform.');
+            }
+            // Reset all bone scales to (1,1,1) to prevent accumulated scale issues
+            targetSkeleton.bones.forEach(bone => {
+                bone.scale.set(1, 1, 1);
+            });
+            targetSkeleton.update();
+            return retargetedClip;
+        }
+        catch (tPoseError) {
+            console.error('[AnimationRetargeting] T-Pose failed, falling back to default bind poses:', tPoseError);
+            // Fallback: use default bind poses without T-Pose
+            const retargeter = new UPFRetargeting(sourceSkeleton, targetSkeleton, {
+                boneNameMap: boneMapping,
+                srcPoseMode: UPFRetargeting.BindPoseModes.DEFAULT,
+                trgPoseMode: UPFRetargeting.BindPoseModes.DEFAULT,
+                positionAxisFlips: targetProfile.positionAxisFlips,
+                hipsPositionAxisFlips: targetProfile.hipsPositionAxisFlips
+            });
+            // Retarget the animation
+            const retargetedClip = retargeter.retargetAnimation(sourceClip);
+            if (!retargetedClip || retargetedClip.tracks.length === 0) {
+                console.error(`[AnimationRetargeting] Failed to retarget "${sourceClip.name}": no tracks generated`);
+                return null;
+            }
+            // CRITICAL: Remove scale tracks to prevent shrinking/deformation
+            retargetedClip.tracks = retargetedClip.tracks.filter(track => {
+                return !track.name.endsWith('.scale');
+            });
+            targetSkeleton.bones.forEach(bone => {
+                bone.scale.set(1, 1, 1);
+            });
+            targetSkeleton.update();
+            return retargetedClip;
+        }
+    }
+    catch (error) {
+        console.error(`[AnimationRetargeting] Failed to retarget "${sourceClip.name}":`, error);
+        return null;
+    }
+}
+/**
+ * A reusable retargeting session that initializes T-poses once and can retarget multiple clips.
+ * This is more efficient than calling retargetAnimationClip for each clip individually.
+ */
+export class RetargetingSession {
+    constructor(sourceProfile, targetProfile, sourceSkeleton, targetSkeleton) {
+        Object.defineProperty(this, "retargeter", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "sourceRoleToBone", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+        Object.defineProperty(this, "targetProfile", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "targetSkeleton", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "initialized", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        this.targetProfile = targetProfile;
+        this.targetSkeleton = targetSkeleton;
+        // Build reverse map for source: role -> bone name
+        for (const bone of sourceSkeleton.bones) {
+            const role = sourceProfile.boneToRole[bone.name];
+            if (role) {
+                this.sourceRoleToBone.set(role, bone.name);
+            }
+        }
+        // Create bone mapping
+        const boneMapping = createBoneMapping(sourceProfile, targetProfile, sourceSkeleton, targetSkeleton);
+        if (Object.keys(boneMapping).length === 0) {
+            console.error('[RetargetingSession] Failed to create bone mapping - no bones matched');
+            return;
+        }
+        // Add getBoneByName helper
+        ensureGetBoneByName(sourceSkeleton);
+        ensureGetBoneByName(targetSkeleton);
+        // Convert profiles to T-pose map format
+        const sourceTPoseMap = profileToTPoseMap(sourceProfile);
+        const targetTPoseMap = profileToTPoseMap(targetProfile);
+        // Apply T-Pose ONCE to both skeletons
+        try {
+            // const sourceTPose = applyTPoseInternal(sourceSkeleton, sourceTPoseMap);
+            // const targetTPose = applyTPoseInternal(targetSkeleton, targetTPoseMap);
+            // Create retargeter instance ONCE
+            this.retargeter = new UPFRetargeting(sourceSkeleton, targetSkeleton, {
+                boneNameMap: boneMapping,
+                srcPoseMode: UPFRetargeting.BindPoseModes.CURRENT,
+                trgPoseMode: UPFRetargeting.BindPoseModes.CURRENT,
+                srcEmbedWorldTransforms: true,
+                trgEmbedWorldTransforms: true,
+                positionAxisFlips: targetProfile.positionAxisFlips,
+                hipsPositionAxisFlips: targetProfile.hipsPositionAxisFlips
+            });
+            this.initialized = true;
+            console.log('[RetargetingSession] Initialized with T-poses applied once');
+        }
+        catch (error) {
+            console.error('[RetargetingSession] Failed to initialize:', error);
+        }
+    }
+    /**
+     * Retarget a single clip using the pre-initialized session.
+     */
+    retargetClip(sourceClip) {
+        if (!this.initialized || !this.retargeter) {
+            console.error('[RetargetingSession] Session not initialized');
+            return null;
+        }
+        try {
+            const retargetedClip = this.retargeter.retargetAnimation(sourceClip);
+            if (!retargetedClip || retargetedClip.tracks.length === 0) {
+                console.error(`[RetargetingSession] Failed to retarget "${sourceClip.name}": no tracks generated`);
+                return null;
+            }
+            // Remove scale tracks
+            retargetedClip.tracks = retargetedClip.tracks.filter(track => !track.name.endsWith('.scale'));
+            // Handle root motion incompatibility
+            const sourceRootBoneName = this.sourceRoleToBone.get(BoneRole.Root);
+            const targetRootBoneName = this.targetProfile.boneToRole[this.targetSkeleton.bones[0]?.name];
+            const targetHipsBoneName = Array.from(Object.entries(this.targetProfile.boneToRole))
+                .find(([, role]) => role === BoneRole.Hips)?.[0];
+            if (!sourceRootBoneName && targetRootBoneName === BoneRole.Root && targetHipsBoneName) {
+                const hipsPositionTrackIndex = retargetedClip.tracks.findIndex(track => track.name.includes(targetHipsBoneName) && track.name.endsWith('.position'));
+                if (hipsPositionTrackIndex !== -1) {
+                    retargetedClip.tracks.splice(hipsPositionTrackIndex, 1);
+                }
+            }
+            return retargetedClip;
+        }
+        catch (error) {
+            console.error(`[RetargetingSession] Failed to retarget "${sourceClip.name}":`, error);
+            return null;
+        }
+    }
+    /**
+     * Retarget multiple clips using the pre-initialized session.
+     */
+    retargetClips(sourceClips) {
+        return sourceClips.map(sourceClip => ({
+            clip: this.retargetClip(sourceClip),
+            success: this.retargetClip(sourceClip) !== null,
+            originalName: sourceClip.name
+        }));
+    }
+    isInitialized() {
+        return this.initialized;
+    }
+}
+/**
+ * Batch retarget multiple animation clips.
+ * Uses RetargetingSession internally to apply T-poses only once.
+ */
+export function retargetAnimationClips(sourceClips, sourceProfile, targetProfile, sourceSkeleton, targetSkeleton, _targetSkinnedMesh) {
+    // Create a session that initializes T-poses once
+    const session = new RetargetingSession(sourceProfile, targetProfile, sourceSkeleton, targetSkeleton);
+    if (!session.isInitialized()) {
+        return sourceClips.map(clip => ({ clip: null, success: false, originalName: clip.name }));
+    }
+    // Retarget all clips using the same session
+    return sourceClips.map(sourceClip => {
+        const retargetedClip = session.retargetClip(sourceClip);
+        return {
+            clip: retargetedClip,
+            success: retargetedClip !== null,
+            originalName: sourceClip.name
+        };
+    });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"AnimationRetargeting.js","sourceRoot":"","sources":["../../../src/animation/AnimationRetargeting.ts"],"names":[],"mappings":"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"}

package/dist/src/animation/SkeletonProfile.d.ts

@@ -0,0 +1,112 @@
+/**
+ * SkeletonProfile - defines bone naming conventions for animation retargeting.
+ *
+ * Skeleton profiles map bone names to semantic roles (e.g., "mixamorigHips" -> Hips),
+ * enabling animation retargeting between different skeleton conventions. Profiles can
+ * be loaded from JSON files or defined programmatically.
+ *
+ * Recommended usage (for humans and AI assistants):
+ * - Store profile JSON files in assets/animation-profiles/
+ * - Reference profiles explicitly in AnimationStateMachineConfig
+ * - Use built-in profiles (Mixamo, UE5, Standard, etc.) or create custom ones
+ */
+/**
+ * Semantic bone roles for humanoid characters.
+ * This is the universal language that different skeletons are mapped to.
+ */
+export declare enum BoneRole {
+    Root = "Root",
+    Hips = "Hips",
+    Spine = "Spine",
+    Chest = "Chest",
+    UpperChest = "UpperChest",
+    Neck = "Neck",
+    Head = "Head",
+    LeftShoulder = "LeftShoulder",
+    LeftUpperArm = "LeftUpperArm",
+    LeftLowerArm = "LeftLowerArm",
+    LeftHand = "LeftHand",
+    RightShoulder = "RightShoulder",
+    RightUpperArm = "RightUpperArm",
+    RightLowerArm = "RightLowerArm",
+    RightHand = "RightHand",
+    LeftUpperLeg = "LeftUpperLeg",
+    LeftLowerLeg = "LeftLowerLeg",
+    LeftFoot = "LeftFoot",
+    LeftToeBase = "LeftToeBase",
+    RightUpperLeg = "RightUpperLeg",
+    RightLowerLeg = "RightLowerLeg",
+    RightFoot = "RightFoot",
+    RightToeBase = "RightToeBase",
+    LeftHandThumb1 = "LeftHandThumb1",
+    LeftHandThumb2 = "LeftHandThumb2",
+    LeftHandThumb3 = "LeftHandThumb3",
+    LeftHandIndex1 = "LeftHandIndex1",
+    LeftHandIndex2 = "LeftHandIndex2",
+    LeftHandIndex3 = "LeftHandIndex3",
+    LeftHandMiddle1 = "LeftHandMiddle1",
+    LeftHandMiddle2 = "LeftHandMiddle2",
+    LeftHandMiddle3 = "LeftHandMiddle3",
+    LeftHandRing1 = "LeftHandRing1",
+    LeftHandRing2 = "LeftHandRing2",
+    LeftHandRing3 = "LeftHandRing3",
+    LeftHandPinky1 = "LeftHandPinky1",
+    LeftHandPinky2 = "LeftHandPinky2",
+    LeftHandPinky3 = "LeftHandPinky3",
+    RightHandThumb1 = "RightHandThumb1",
+    RightHandThumb2 = "RightHandThumb2",
+    RightHandThumb3 = "RightHandThumb3",
+    RightHandIndex1 = "RightHandIndex1",
+    RightHandIndex2 = "RightHandIndex2",
+    RightHandIndex3 = "RightHandIndex3",
+    RightHandMiddle1 = "RightHandMiddle1",
+    RightHandMiddle2 = "RightHandMiddle2",
+    RightHandMiddle3 = "RightHandMiddle3",
+    RightHandRing1 = "RightHandRing1",
+    RightHandRing2 = "RightHandRing2",
+    RightHandRing3 = "RightHandRing3",
+    RightHandPinky1 = "RightHandPinky1",
+    RightHandPinky2 = "RightHandPinky2",
+    RightHandPinky3 = "RightHandPinky3",
+    RightEye = "RightEye",
+    LeftEye = "LeftEye",
+    Jaw = "Jaw"
+}
+/**
+ * Axis flip configuration for position retargeting.
+ * Used to handle coordinate system differences between skeletons.
+ */
+export interface PositionAxisFlips {
+    /** Flip X axis for root motion */
+    x?: boolean;
+    /** Flip Y axis for root motion */
+    y?: boolean;
+    /** Flip Z axis for root motion */
+    z?: boolean;
+}
+/**
+ * Skeleton profile - maps bone names to semantic roles.
+ * Can be serialized to/from JSON for asset storage.
+ */
+export interface SkeletonProfile {
+    /** Profile name (e.g., "Mixamo", "UE5", "Standard") */
+    name: string;
+    /** Human-readable description */
+    description: string;
+    /** Map bone name -> semantic role */
+    boneToRole: Record<string, BoneRole>;
+    /** Hip bone name (required for retargeting root motion) */
+    hipBoneName: string;
+    /** Optional scale factor for unit conversion (e.g., 0.01 for cm to m) */
+    scale?: number;
+    /**
+     * Optional axis flips for root position retargeting.
+     * Used when this profile is the TARGET to correct coordinate system differences.
+     */
+    positionAxisFlips?: PositionAxisFlips;
+    /**
+     * Optional axis flips for hips position retargeting.
+     * Separate from root because hips may have different coordinate system.
+     */
+    hipsPositionAxisFlips?: PositionAxisFlips;
+}