# @isis/universal-rigging Topology-agnostic auto-rigging foundations for Isis 3D pipelines. Current status: - workspace-integrated Nx/TypeScript/Vitest/tsup library scaffold - shipped `ml-skeleton-prediction` workflow for in-memory mesh geometry - trainable geometry-conditioned statistical model that learns checkpoint priors from normalized Mixamo, RigNet, and Rig-XL training records - Python runner that trains a checkpoint and predicts joint positions plus a hierarchy directly from mesh geometry - topology-agnostic joint placement built on deterministic surface-point-cloud sampling so sparse, dense, and messy triangulations of the same shape land on similar anchor positions - role-aware bone hierarchy inference that turns joint candidates into a parent-child tree with explicit `axial-chain`, `branch-anchor`, and `branch-chain` edges plus normalized joint rest orientations as quaternions - automatic skin-weight computation that turns the inferred skeleton into smooth bind weights using a local hybrid geodesic/heat pass over mesh topology with per-segment confidence and side-aware branch damping - joint-limit inference that turns mesh aspect ratios, limb reach, axial chain coverage, and paired branch symmetry into deterministic per-joint local rotation ranges for downstream constraint setup - IK setup automation that turns the predicted hierarchy and joint-limit profile into solver-ready spine, limb, and foot-roll control layouts - rigging confidence scoring that fuses placement, hierarchy, skinning, limit, IK, symmetry, and disconnected-mesh signals into per-joint, per-region, and manual-adjustment reports - guided landmark placement fallback that turns low-confidence auto-rig reports into a stepwise operator queue with per-joint landmarks, symmetry assists, view hints, and completion checks instead of leaving manual recovery as an ad-hoc DCC-side exercise - humanoid A-pose / T-pose rest-pose normalization that detects arm-spread stance from mesh width profiles plus upper-arm chains and can convert the inferred rig toward either rest pose while preserving bone lengths - facial rig generation that isolates a front-facing head region from the predicted head/neck chain, emits control anchors, synthesizes all 52 ARKit blend shapes, and layers 23 FACS action units on top as weighted driver compositions - eye rig generation that reuses the shipped facial landmarks to emit bilateral look-at targets, eye aim controls, and upper/lower eyelid controls aligned with the ARKit blink, wide, squint, and gaze shapes - corrective blend-shape generation that uses the shipped skin weights and inferred joint limits to emit pose-space shoulder, elbow, and knee deformation correctives with explicit activation ranges and sparse morph deltas - clothing rig binding that projects garment vertices onto the bound body mesh, transfers underlying skin weights, and preserves the garment's rest-space shell offset as tangent/bitangent/normal attachment data - Mixamo-compatible skeleton export that turns the shipped humanoid rig outputs into canonical `mixamorig:*` body and finger chains, recomputes compatible weights, and emits bind-pose matrices for downstream animation interchange - VRM-compatible skeleton export that turns the same rig outputs into VRM 1.0 humanoid bone names with `upperChest`, VRM-aligned finger names, and right-handed Y-up metadata for VTuber and social-VR pipelines - MetaHuman-compatible skeleton mapping that remaps the same semantic body and finger outputs to Unreal/MetaHuman naming, synthesizes `root`, `spine_04`, and per-finger metacarpals when enough signal exists, and exposes the still omitted twist/facial/corrective groups explicitly in metadata instead of pretending the current package can author the full MetaHuman bind rig - quadruped auto-rigging that infers head-vs-tail direction from elongated four-legged meshes, lays out pelvis/spine/withers/neck/head plus fore/hind leg chains and an optional tail rig, and recomputes skin weights for dogs, horses, cats, deer, and generic quadruped bodies - bird auto-rigging that infers avian head-vs-tail direction, lays out a pelvis/spine/chest/neck/head/beak chain plus bilateral wing and leg chains, synthesizes feather-spread controls, and recomputes weights for raptor, songbird, waterfowl, flightless, and generic bird silhouettes - insect/arachnid auto-rigging that lays out an arthropod abdomen/thorax/head chain, synthesizes six or eight leg chains depending on archetype, emits mandibles plus antennae or pedipalps honestly, and adds wing chains only for insect profiles that actually carry them - fish/marine auto-rigging that infers head-vs-tail direction from elongated marine meshes, lays out an anterior spine/head chain plus caudal tail joints, emits pectoral/pelvic/dorsal/anal fin rigs when the archetype supports them, and switches honestly between heterocercal shark tails, homocercal fish tails, and cetacean flukes - serpent/snake auto-rigging that lays out a long spine chain from head to tail, emits segmented IK-ready body controls, adds a jaw rig for mouth opening, and supports cobra hood spread plus rattlesnake or sea-snake tail specializations only when the archetype actually carries them - multi-limbed creature rigging that lays out hybrid axial rigs for centaurs, multi-armed bipeds, and tentacled creatures, emitting honest arm, leg, tail, and radial tentacle control chains without collapsing those bodies back into a humanoid-only skeleton template - winged creature rigging that lays out dragon, bat, and angel body plans with articulated wing chains, honest membrane-vs-feather wing metadata, biped or quadruped support layouts, and tail rigs only when the archetype actually carries one - plant/tree rigging that infers a growth axis for woody trunks or climbing stems, emits trunk and branch chains, synthesizes leaf-cluster controls, and publishes wind-response profiles instead of leaving vegetation motion as a downstream manual rigging problem - mechanical/robot rigging that lays out rigid body chains, piston and actuator linkages, tread modules, and turret assemblies for bipedal mechs, tracked robots, and turret platforms instead of treating those devices like organic skeletons - vehicle rigging that lays out four-wheel, two-wheel, and multi-axle chassis assemblies with wheel hubs, suspension travel joints, steering controls, and articulated doors / hood / trunk panels only on archetypes that actually carry them - furniture/prop rigging that lays out cabinet doors, drawer slides, storage chest lids, and standalone door props with explicit hinge / slide semantics instead of leaving common environment assets as static unrigged meshes - custom creature template fitting that accepts a user-defined axial chain and appendage topology, then fits the declared skeleton onto the mesh with template-conditioned placement diagnostics instead of forcing exotic creatures through fixed archetype presets - humanoid animation library coverage that catalogs more than a thousand Mixamo-, CMU-, and KIT-sourced motion descriptors across idle, walk, run, jump, combat, dance, gesture, and emote families for downstream selection and retargeting instead of leaving motion sourcing as an external spreadsheet task - quadruped animation library coverage that catalogs more than twelve hundred canine and equine motion descriptors across walk, trot, gallop, sit, lie down, eat, shake, and play families with gait metadata and source-backed readiness scoring for downstream retargeting - humanoid animation retargeting that remaps canonical humanoid animation clips onto any shipped humanoid rig, scaling root motion and per-limb translation by target proportions while compensating for A-pose vs T-pose differences and clamping rotations back to inferred joint limits - cross-species animation retargeting that classifies canonical humanoid motion, adapts it into quadruped walk/trot/gallop or stationary pose families, and drives the shipped quadruped rig chains with species-aware spine, tail, and limb timing instead of pretending humanoid clips can be renamed into animal joints without gait conversion - animation blending and transition graph generation that turns the shipped humanoid, quadruped, and retargeted clip descriptors into a parameterized locomotion blend tree, explicit state transitions, and optional overlay layers instead of leaving animation assembly as a hand-authored engine task - Mixamo animation import pipeline that turns downloaded Mixamo FBX files into local source skeleton/clip data, publishes an honest browser download plan instead of pretending there is a supported direct API, and retargets the imported motion back onto shipped auto-rigged humanoid meshes - animation preview renderer that skin-deforms the shipped auto-rigged mesh on the CPU, emits quick turntable frames plus sampled animation preview frames as SVG contact sheets, and publishes floor-penetration / screen-coverage / planted-foot-sliding diagnostics for fast local quality validation - animation export that turns the shipped skinned rig plus retargeted or generic clip data into real GLB, ASCII FBX, and BVH packages, including embedded skinning for GLB/FBX and honest BVH warnings when non-root translation tracks cannot be represented by the format - hand rig generation that turns each detected upper-limb terminal into a 21-joint articulated hand layout with explicit thumb, index, middle, ring, and pinky chains plus palm-profile metadata for downstream posing tools - speech articulation rig generation that reuses the facial landmarks to emit a three-joint jaw chain, a five-joint tongue chain, driver controls, and the repo-standard 15 viseme presets for downstream lip-sync animation - explicit planned workflow families for humanoid rigging enhancement, non-humanoid rigging, and animation retargeting The skeleton prediction stack expects normalized `skeleton-training-record-v1` JSON manifests instead of raw FBX/GLB archives. That is deliberate: Mixamo, RigNet, and open rigging corpora use different native asset formats, so this phase standardizes them before training rather than pretending one parser can ingest every source honestly. The shipped model is lightweight and fully local: - training aggregates geometry-conditioned priors such as axial joint count, root height, branch anchor fractions, symmetry thresholds, and outward branch spread from the normalized datasets - inference blends those learned priors with a topology-agnostic surface-point placement signature, then predicts an axial chain plus mirrored branch joints and emits the hierarchy as JSON - hierarchy inference is now a separate deterministic stage that scores parent candidates by role, dominant-axis progress, anchor priors, and branch side, then computes right-handed `y`-aim joint orientations for downstream skinning, limits, and IK setup - skinning now runs as a deterministic TS postprocess over the predicted mesh and hierarchy, distributing segment influence to parent/child joints by closest-point interpolation, smoothing through surface adjacency, and clamping to GPU-safe top-4 influences per vertex - joint limits now run as a second deterministic TS postprocess over the predicted hierarchy, classifying pelvis/spine/head/limb archetypes and fitting local `x/y/z` degree limits from the mesh proportion signature rather than shipping one hard-coded ROM preset for every body shape - IK setup now runs as a third deterministic TS postprocess, choosing `FABRIK`, `CCD`, or `analytical` per chain, emitting repo-aligned effector and pole control names, and deriving left/right foot roll pivots from the lower support region of the mesh - confidence scoring now runs as a fourth deterministic TS postprocess, turning the shipped rig outputs into adjustment-ready QA data instead of a single vague score, and explicitly calling out the joints and regions that should be reviewed manually - humanoid rest-pose normalization now runs as a fifth deterministic TS postprocess, detecting T-pose vs A-pose honestly from the actual mesh/rig signal and rotating upper-limb chains toward a requested rest pose instead of guessing from prompt text alone - facial rig generation now runs as a sixth deterministic TS postprocess for humanoid candidates, inferring a face box from the head chain, sampling landmark anchors from the actual frontal mesh region, generating sparse ARKit morph deltas locally, and exposing FACS controls as blended driver outputs - eye rig generation now runs as a seventh deterministic TS postprocess for humanoid candidates, deriving bilateral look-at targets plus upper/lower lid follow controls directly from the shipped facial landmarks instead of pretending eye aim can be inferred from a single eyeball pivot - corrective blend-shape generation now runs as an eighth deterministic TS postprocess for humanoid candidates, combining the shipped skin weights with the inferred shoulder/elbow/knee limit profile to author sparse pose-space deformation correctives instead of leaving limb collapse as a downstream DCC manual-fix problem - clothing rig binding now ships as a deterministic helper workflow for garment assets, projecting each garment vertex onto the body surface, transferring the blended body weights, and preserving the stand-off shell offset explicitly so jackets, shirts, and armor shells can follow the bound character skeleton without losing their authored separation from the body - Mixamo-compatible skeleton output now ships as a deterministic helper workflow for downstream animation interchange, canonicalizing the shipped humanoid torso/limb/hand outputs into repo-aligned `mixamorig:*` naming, filling intermediate clavicle, forearm, toe, and finger joints when needed, and recomputing skin weights against that exported hierarchy instead of pretending the coarse prediction joints already match Mixamo one-to-one - VRM-compatible skeleton output now ships as a sibling deterministic helper workflow, remapping the same semantic humanoid skeleton to the fixed VRM humanoid configuration, preserving `upperChest` and finger chains when available, and emitting bind-pose matrices plus Y-up metadata that align with current VRM 1.0 expectations - MetaHuman-compatible skeleton mapping now ships as another deterministic helper workflow, remapping the same semantic humanoid skeleton to Unreal / MetaHuman body names, inserting a retarget `root`, `spine_04`, and metacarpals for the non-thumb fingers, and recomputing skin weights against that export surface while explicitly flagging the remaining twist, facial, and post-process corrective groups as out of scope for this body-only mapper - quadruped auto-rigging now ships as the first non-humanoid workflow, using the shared mesh-summary and skin-weighting primitives to infer a four-legged anatomy model with pelvis/spine/withers/neck/head, fore/hind limb chains, optional tail chains, and species-specific spine flexibility metadata instead of forcing quadrupeds through the humanoid topology assumptions - bird auto-rigging now ships as a sibling non-humanoid workflow, using the same mesh-summary and orientation helpers to infer a pelvis/spine/chest/neck axial chain, bilateral wing and leg chains, optional tail fan chains, and explicit primary/secondary feather-spread controls rather than forcing avian bodies through quadruped limb layouts - insect/arachnid auto-rigging now ships as another non-humanoid workflow, using the shared mesh-summary, orientation, and skin-weighting helpers to infer an arthropod abdomen/thorax/head chain, six or eight leg chains, mandibles, and honest antenna or pedipalp rigs while omitting wing rigs for arachnid archetypes instead of pretending every arthropod shares insect appendages - fish/marine auto-rigging now ships as another non-humanoid workflow, using the same mesh-summary, orientation, and skin-weighting helpers to infer a marine spine/head/tail layout, honest paired and median fin rigs, optional jaw controls, and archetype-specific shark vs fish vs cetacean tail behavior instead of forcing aquatic bodies through quadruped or bird skeleton layouts - serpent/snake auto-rigging now ships as another non-humanoid workflow, using the same mesh-summary, orientation, and skin-weighting helpers to infer a long axial spine chain, overlapping IK body controls, optional jaw rigging, and cobra/rattlesnake/sea-snake specializations instead of collapsing serpentine bodies into short torso-plus-limb skeleton assumptions - multi-limbed creature rigging now ships as another non-humanoid workflow, using the same mesh-summary, orientation, and skin-weighting helpers to infer centaur-style quadruped hybrids, stacked multi-arm torso layouts, and radial tentacle chains instead of forcing those bodies through either pure humanoid or pure quadruped assumptions - winged creature rigging now ships as another non-humanoid workflow, using the same mesh-summary, orientation, and skin-weighting helpers to infer dragon, bat, and angel body plans with dedicated wing chains, honest membrane-digit vs feather-spread metadata, and tail omission for tailless archetypes instead of pretending every winged silhouette is just a reskinned bird - plant/tree rigging now ships as another non-humanoid workflow, using a growth-axis-aware vertical fit to infer trunk chains, radial branch chains, leaf clusters, and per-chain wind-response profiles instead of treating vegetation as an unriggable static prop - mechanical/robot rigging now ships as another non-humanoid workflow, using deterministic rigid-segment fitting to infer bipedal mech joints, tracked tread loops, piston and actuator linkages, and turret yaw/pitch assemblies instead of forcing robots and devices through organic limb assumptions - vehicle rigging now ships as another non-humanoid workflow, using the same mesh-summary, orientation, and skin-weighting helpers to infer automobile, motorcycle, and truck chassis assemblies with honest wheel/suspension chains, steering linkages, and articulated panel rigs instead of collapsing vehicles back into the mechanical robot templates - furniture/prop rigging now ships as another non-humanoid workflow, using the same mesh-summary, orientation, and skin-weighting helpers to infer cabinets, drawer stacks, storage chests, and standalone doors with honest hinge and slide controls instead of flattening those props into inert scene geometry - custom creature template fitting now ships as another non-humanoid workflow, letting callers declare axial nodes and arbitrary appendage groups, then using the same geometry-conditioned placement prior and skin-weighting helpers to fit bespoke skeleton topologies, radial appendages, and special creature silhouettes onto a target mesh instead of requiring a baked-in archetype - humanoid animation library coverage now ships as the first animation-library workflow, generating a deterministic 1,120-entry motion catalog backed by Mixamo, CMU Graphics Lab, and KIT Whole-Body source descriptors with category coverage, query scoring, and retarget-readiness metadata instead of pretending those motion sets are already normalized and indexed elsewhere in the repo - quadruped animation library coverage now ships alongside it, generating a deterministic 1,264-entry catalog backed by RGBD-Dog, 3DDogs, DogMo, and VAREN source descriptors with species-aware gait metadata, source coverage summaries, and cross-species readiness scoring instead of hand-waving animal motion sourcing until the retargeting tasks - humanoid animation retargeting now ships as the first animation transfer workflow, converting canonical humanoid slot tracks into target rig joint ids with per-slot length ratios, root-motion scaling, rest-pose offsets, and inferred joint-limit clamping instead of assuming every generated rig shares the source performer proportions - cross-species animation retargeting now ships alongside it, classifying humanoid clips into locomotion or stationary intent, selecting quadruped gait families, querying the shipped quadruped motion catalog for the closest species-backed reference, and synthesizing quadruped root, spine, tail, and limb tracks instead of copying biped timing directly onto four-legged rigs - animation blending and transition graph generation now ships on top of the clip surfaces, building engine-agnostic 1D locomotion blend trees, direct overlay layers for compatible upper-body actions, and explicit state-machine transitions for jumps, posture clips, and discrete full-body actions instead of exporting a flat list of clips with no runtime assembly guidance - hand rig generation now runs as a ninth deterministic TS postprocess for humanoid candidates, classifying the deepest upper-limb joints as wrist sources, synthesizing missing wrist anchors conservatively when needed, and emitting two 21-joint hand rigs with per-finger articulation ranges - speech articulation rig generation now runs as a tenth deterministic TS postprocess for humanoid candidates, reusing the shipped facial landmarks to derive jaw hinges, tongue curve joints, and normalized viseme driver presets instead of shipping a disconnected speech-rig schema - later Phase 71 tasks can improve topology robustness, parent-child inference, and skin weighting without replacing the package surface added here Key exports: - `createLocal3DUniversalRiggingMLSkeletonPredictionCapabilities()` - `createLocal3DUniversalRiggingMLSkeletonPredictionTrainingPlan()` - `createLocal3DUniversalRiggingAutomaticSkinWeightComputationCapabilities()` - `computeLocal3DUniversalRiggingSkinWeights()` - `createLocal3DUniversalRiggingBoneHierarchyInferenceCapabilities()` - `inferLocal3DUniversalRiggingBoneHierarchy()` - `createLocal3DUniversalRiggingJointLimitInferenceCapabilities()` - `inferLocal3DUniversalRiggingJointLimits()` - `createLocal3DUniversalRiggingIKChainSetupAutomationCapabilities()` - `setupLocal3DUniversalRiggingIKChains()` - `createLocal3DUniversalRiggingConfidenceScoringCapabilities()` - `scoreLocal3DUniversalRiggingConfidence()` - `createLocal3DUniversalRiggingHumanoidRestPoseNormalizationCapabilities()` - `detectLocal3DUniversalRiggingHumanoidRestPose()` - `convertLocal3DUniversalRiggingHumanoidRestPose()` - `createLocal3DUniversalRiggingFacialRigGenerationCapabilities()` - `generateLocal3DUniversalRiggingFacialRig()` - `createLocal3DUniversalRiggingEyeRigGenerationCapabilities()` - `generateLocal3DUniversalRiggingEyeRig()` - `createLocal3DUniversalRiggingCorrectiveBlendShapeGenerationCapabilities()` - `generateLocal3DUniversalRiggingCorrectiveBlendShapes()` - `createLocal3DUniversalRiggingClothingRigBindingCapabilities()` - `bindLocal3DUniversalRiggingClothingRig()` - `createLocal3DUniversalRiggingMixamoCompatibleSkeletonOutputCapabilities()` - `createLocal3DUniversalRiggingMixamoCompatibleSkeletonOutput()` - `createLocal3DUniversalRiggingMixamoAnimationImportPipelineCapabilities()` - `createLocal3DUniversalRiggingMixamoAnimationDownloadPlan()` - `importLocal3DUniversalRiggingMixamoAnimationAndApplyToMesh()` - `createLocal3DUniversalRiggingGenericAnimationClipFromHumanoidRetargeting()` - `createLocal3DUniversalRiggingAnimationPreviewRendererCapabilities()` - `renderLocal3DUniversalRiggingAnimationPreview()` - `createLocal3DUniversalRiggingAnimationExportCapabilities()` - `exportLocal3DUniversalRiggingAnimationPackage()` - `createLocal3DUniversalRiggingVRMCompatibleSkeletonOutputCapabilities()` - `createLocal3DUniversalRiggingVRMCompatibleSkeletonOutput()` - `createLocal3DUniversalRiggingMetaHumanCompatibleSkeletonMappingCapabilities()` - `createLocal3DUniversalRiggingMetaHumanCompatibleSkeletonMapping()` - `createLocal3DUniversalRiggingAnimationBlendingTransitionGraphCapabilities()` - `createLocal3DUniversalRiggingAnimationClipDescriptorFromHumanoidLibraryEntry()` - `createLocal3DUniversalRiggingAnimationClipDescriptorFromQuadrupedLibraryEntry()` - `createLocal3DUniversalRiggingAnimationClipDescriptorFromHumanoidRetargetingResult()` - `createLocal3DUniversalRiggingAnimationClipDescriptorFromCrossSpeciesRetargetingResult()` - `createLocal3DUniversalRiggingAnimationBlendingTransitionGraph()` - `createLocal3DUniversalRiggingCrossSpeciesAnimationRetargetingCapabilities()` - `retargetLocal3DUniversalRiggingCrossSpeciesAnimation()` - `createLocal3DUniversalRiggingBirdAutoRiggingCapabilities()` - `createLocal3DUniversalRiggingBirdAutoRigging()` - `createLocal3DUniversalRiggingFishMarineAutoRiggingCapabilities()` - `createLocal3DUniversalRiggingFishMarineAutoRigging()` - `createLocal3DUniversalRiggingFurniturePropRiggingCapabilities()` - `createLocal3DUniversalRiggingFurniturePropRigging()` - `createLocal3DUniversalRiggingSerpentSnakeAutoRiggingCapabilities()` - `createLocal3DUniversalRiggingSerpentSnakeAutoRigging()` - `createLocal3DUniversalRiggingInsectArachnidAutoRiggingCapabilities()` - `createLocal3DUniversalRiggingInsectArachnidAutoRigging()` - `createLocal3DUniversalRiggingMultiLimbedCreatureCapabilities()` - `createLocal3DUniversalRiggingMultiLimbedCreatureRigging()` - `createLocal3DUniversalRiggingWingedCreatureCapabilities()` - `createLocal3DUniversalRiggingWingedCreatureRigging()` - `createLocal3DUniversalRiggingPlantTreeCapabilities()` - `createLocal3DUniversalRiggingPlantTreeRigging()` - `createLocal3DUniversalRiggingMechanicalRobotCapabilities()` - `createLocal3DUniversalRiggingMechanicalRobotRigging()` - `createLocal3DUniversalRiggingHumanoidAnimationRetargetingCapabilities()` - `retargetLocal3DUniversalRiggingHumanoidAnimation()` - `createLocal3DUniversalRiggingQuadrupedAutoRiggingCapabilities()` - `createLocal3DUniversalRiggingQuadrupedAutoRigging()` - `createLocal3DUniversalRiggingQuadrupedAnimationLibraryCapabilities()` - `createLocal3DUniversalRiggingQuadrupedAnimationLibraryCatalog()` - `queryLocal3DUniversalRiggingQuadrupedAnimationLibrary()` - `createLocal3DUniversalRiggingHandRigGenerationCapabilities()` - `generateLocal3DUniversalRiggingHandRig()` - `createLocal3DUniversalRiggingSpeechArticulationRigCapabilities()` - `generateLocal3DUniversalRiggingSpeechArticulationRig()` - `summarizeLocal3DUniversalRiggingMeshGeometry()` - `createLocal3DUniversalRiggingTopologyAgnosticJointPlacementSignature()` - `Local3DUniversalRiggingMLSkeletonPredictionProcess` Research grounding for the workflow design: - RigNet official codebase for diverse rig supervision and mesh-to-rig task structure: https://github.com/zhan-xu/RigNet - UniRig paper for large-scale diverse rig generation and autoregressive skeleton reasoning: https://arxiv.org/abs/2506.05339 - RigAnything paper for BFS-ordered parent-index skeleton generation and hierarchy-aware auto-rigging design: https://arxiv.org/abs/2502.09615 - OpenSim coordinate-based joint modeling reference for expressing per-axis rotational coordinates and limits in a local joint frame: https://opensimconfluence.atlassian.net/wiki/spaces/OpenSim/pages/53090621 - Adobe Mixamo help for the humanoid auto-rigging baseline this package is designed to exceed: https://helpx.adobe.com/ie/mixamo/using/mixamo-faq.html - RGBD-Dog official CVPR 2020 publication describing synchronized canine RGB-D and mocap capture, which grounds the shipped dog action-library source descriptors: https://openaccess.thecvf.com/content_CVPR_2020/html/Kearney_RGBD-Dog_Predicting_Canine_Pose_from_RGBD_Sensors_CVPR_2020_paper.html - 3DDogs official dataset page documenting optical mocap dog trot sequences, which grounds the shipped trotting reference coverage: https://cvssp.org/data/3DDogs/ - DogMo official project page describing a large-scale multi-view canine motion dataset, which grounds the broader dog walk/gallop/rest/play descriptor coverage: https://pie-lab.cn/DogMo/ - VAREN official project page documenting an articulated equine model learned from real 3D horse scans, which grounds the shipped equine walk/trot/gallop descriptor coverage: https://varen.is.tue.mpg.de/ - Unity Manual documentation for humanoid retargeting and Avatar mapping, which grounds the canonical-slot transfer design used by the shipped humanoid retargeting workflow: https://docs.unity3d.com/Manual/Retargeting.html - Unreal Engine documentation for IK Rig and IK Retargeter workflows, which grounds the shipped rest-pose correction and chain-aware transfer metadata: https://dev.epicgames.com/documentation/en-us/unreal-engine/ik-rig-animation-retargeting-in-unreal-engine - ACE project and paper materials describing semantic motion adaptation across skeletons, which ground the shipped cross-species transfer step's emphasis on motion-class analysis before target gait synthesis: https://arxiv.org/abs/2305.14792 - Skeleton-Aware Networks for Deep Motion Retargeting project page, which grounds the shipped transfer design's use of chain-aware timing rather than direct per-joint name remaps across incompatible bodies: https://deepmotionediting.github.io/retargeting - HumanConQuad project page for human-to-quadruped motion conversion, which grounds the shipped gait-adaptation workflow's explicit human-locomotion to quadruped-gait classification step: https://sites.google.com/view/humanconquad - Unity Blend Trees manual documenting when similar motions should be blended by shared numeric parameters, which grounds the shipped locomotion blend-tree builder instead of encoding locomotion as isolated states: https://docs.unity3d.com/es/current/Manual/class-BlendTree.html - Unity Animation Transitions manual documenting parameter-gated state-machine transitions and normalized transition durations, which grounds the shipped transition-condition and exit-time surface: https://docs.unity3d.com/es/530/Manual/class-Transition.html - Unreal locomotion blend-space documentation showing the standard speed-driven walk/jog locomotion blend model that grounds the shipped engine-agnostic speed-threshold locomotion graph layout: https://dev.epicgames.com/documentation/en-us/unreal-engine/locomotion-based-blending-in-unreal-engine - Adobe Mixamo help stating rigged FBX uploads are automatically mapped to the Mixamo system, which is the compatibility target for the exported naming and hierarchy surface: https://helpx.adobe.com/creative-cloud/help/mixamo-rigging-animation.html - Adobe Creative Cloud help documenting the current browser workflow for choosing and downloading Mixamo animations, which grounds the shipped guided download plan and the decision not to pretend there is a stable public Mixamo download API: https://helpx.adobe.com/creative-cloud/help/animate-characters-mixamo.html - VRM developer documentation confirming VRM 0.x and 1.0 are fixed-bone humanoid formats in a right-handed Y-up coordinate system, which grounds the shipped VRM export naming and metadata surface: https://vrm.dev/en/vrm/vrm_development/ - Epic MetaHuman documentation recording current bind-rig hierarchy/orientation changes such as planar `hand_l/r`, planar finger chains from metacarpal through DIP, and the `spine_04` corrective neighborhood that this mapping is designed to stay compatible with: https://dev.epicgames.com/documentation/en-us/metahuman/metahuman-5-6-asset-changes - Epic Unreal Datasmith export guidelines confirming the engine-side left-handed Z-up target coordinate system that the MetaHuman mapping metadata now publishes for downstream conversion: https://dev.epicgames.com/documentation/en-us/unreal-engine/datasmith-export-sdk-guidelines - Blender Rigify manual documenting bundled `Basic Quadruped`, `Cat`, `Wolf`, and `Horse` meta-rigs plus the expectation that creators position those bones to real quadruped anatomy before generating control rigs, which grounds the species-aware layout choices in the shipped quadruped workflow: https://docs.blender.org/manual/en/4.2/addons/rigging/rigify/basics.html - Blender Rigify bird metarig source showing the existing control-rig layout for spine, wing, leg, claw, feather, and neck groups, which grounds the shipped bird and winged-creature workflows' wing-chain and feather-spread structure: https://raw.githubusercontent.com/blender/blender-addons/main/rigify/metarigs/Animals/bird.py - Blender Rigify shark metarig source showing the existing control-rig layout for spine, jaw, dorsal fins, pectoral fins, pelvic fins, and caudal support, which grounds the shipped fish/marine workflow's shark-specific fin and tail structure: https://raw.githubusercontent.com/blender/blender-addons/main/rigify/metarigs/Animals/shark.py - Blender Rigify chain rig documentation showing the existing spline/segment chain building blocks used for long deforming spines, arm bands, and tentacle controls, which grounds the shipped serpent and multi-limbed workflows' overlapping IK body-control design: https://docs.blender.org/manual/en/latest/addons/rigging/rigify/rig_types/chains.html - Blender Spline IK documentation showing the existing curve-aligned chain control model for flexible stems and trunks, which grounds the shipped plant/tree workflow's wind-ready trunk and branch control-chain design: https://docs.blender.org/manual/en/latest/animation/constraints/tracking/spline_ik.html - Blender Copy Rotation, Damped Track, and Drivers documentation grounding the mechanically coupled hinge, piston, turret, and actuator behaviors used by the shipped mechanical/robot workflow: https://docs.blender.org/manual/en/latest/animation/constraints/transform/copy_rotation.html https://docs.blender.org/manual/en/latest/animation/constraints/tracking/damped_track.html https://docs.blender.org/manual/en/latest/animation/drivers/index.html - Apple ARKit face anchor blend-shape taxonomy for the shipped ARKit-compatible facial rig output: https://developer.apple.com/documentation/arkit/arfaceanchor/blendshapelocation - Autodesk Maya Pose Editor documentation for production corrective-shape authoring driven by joint pose ranges: https://help.autodesk.com/view/MAYAUL/2025/ENU/?guid=GUID-E36FB90D-84C1-49F2-9A45-46F057171950 - Blender Armature modifier documentation for deform-based mesh attachment and preserve-volume behavior that informs the garment offset binding model: https://docs.blender.org/manual/en/latest/modeling/modifiers/deform/armature.html