GitHub Copilot Skill

mixamo-retarget

(EXPERIMENTAL — extracted and syntax-checked, fixture validation pending) Retarget Mixamo (or any FBX/DAE) animations onto a custom Blender rig — including the DayZ skeleton — with fuzzy bone matching, preset mappings (mixamo_to_rigify), persistent per-pair bone maps, NLA stackin

LLM Mart · 0 points · 3 views 0 listing impressions 0 install-command copies
Download willy92wins-dayz-modding-knowledge-pack-skills_mixamo-retarget-22c35fd.zip · 15 KB

Install

skills CLI npx skills add https://github.com/willy92wins/DayZ-Modding-Knowledge-Pack/tree/main/skills/mixamo-retarget
Claude Code claude plugin marketplace add https://llmmart.ai/marketplace.json && claude plugin install willy92wins-dayz-modding-knowledge-pack@llmmart
Git git clone https://github.com/willy92wins/DayZ-Modding-Knowledge-Pack.git

The skills CLI installs just this skill, for any of its supported agents. Claude Code installs the whole willy92wins/dayz-modding-knowledge-pack collection as a plugin from our marketplace. Git is the plain clone.

Skill manifest

Mixamo Retarget (via Blender MCP)

Retargets skeletal animations between armatures inside Blender, driven entirely through the already-connected Blender MCP. The engine is the retargeting module extracted from Dev-GOM's blender-toolkit (Apache-2.0; attribution below) — the valuable 700 lines, without the plugin's WebSocket server, CLI build, hooks, or second Blender addon.

Status: EXPERIMENTAL — extracted and syntax-checked, not yet fixture-validated. Before first production use, run the fixture at the bottom and record the result.

What it does

  • auto_map_bones(source, target) — fuzzy bone matching with a Mixamo alias table (works on mixamorig:-prefixed and bare names).
  • get_preset_bone_mapping("mixamo_to_rigify") — known-good preset.
  • store_bone_mapping / load_bone_mapping — persist a reviewed map per armature pair (scene-level), so the fuzzy pass runs once and the corrected map is reused.
  • retarget_animation(source, target, bone_map, action_name) — bakes the retargeted action onto the target rig.
  • import_fbx / import_dae, list_armatures, get_bones, list_animations, play_animation, add_to_nla.

How to run it (through the Blender MCP)

The two modules in scripts/ are plain Blender-Python. Load them once per session by exec-ing them in Blender's interpreter, in dependency order:

  1. Read scripts/bone_matching.py and scripts/retargeting.py from this skill.
  2. Send each through execute_blender_code (bone_matching first — retargeting imports fuzzy_match_bones from it; when exec'd into the same namespace, replace its from bone_matching import … line with nothing, or exec bone_matching's source first so the names already exist).
  3. Then drive the workflow:
# inside execute_blender_code, after both modules are loaded
import_fbx(r"C:\path\to\Walking.fbx")          # brings in the Mixamo armature + action
print(list_armatures())                          # e.g. ['Armature', 'MyDayZRig']
bm = auto_map_bones("Armature", "MyDayZRig")    # fuzzy pass — REVIEW THIS DICT
print(bm)
  1. Two-phase discipline (kept from the original design): never retarget straight off the fuzzy map. Print it, review/correct it (the human or a reasoned pass), store_bone_mapping the corrected version, then:
retarget_animation("Armature", "MyDayZRig", bone_map=bm, action_name="Walking_retarget")
play_animation("MyDayZRig", "Walking_retarget")

references/bone-mapping-guide.md (653 lines, from the original project) covers alias logic, naming conventions, and fixing bad matches — read it when the fuzzy map comes back with gaps.

Rest-pose caveat (the classic failure)

Mixamo rigs are T-pose; many targets (including game rigs) are A-pose or custom. A retarget across mismatched rest poses bakes a permanent offset into every frame. Align rest poses first (apply rotation on the Mixamo armature; or pose-match the target's rest to the source) before judging the result. Symptom: arms floating ~45° off on every frame.

DayZ integration note

For LFPG work, the output of a retarget onto the DayZ skeleton is source keyframes, not a game-ready animation: it feeds dayz-animation-pipeline Layer 2 (Blender keyframes → SEAnim → DayZATool → .anm), and the player/creature anim-graph wall still applies (one animation mod per server). Use it to harvest mocap for creatures, poses, and reference motion — not as a shortcut around the pipeline.

Fixture before first real use (AGENTS-R26)

Positive: import any Mixamo FBX, retarget onto a copy of its own armature with the identity map — the result must visually match the original (render 3 frames via blender-visual-review). Negative: retarget with an empty bone map must raise/return an error, not silently produce a frozen action. Record both outcomes; only then drop the EXPERIMENTAL label.

Attribution

Retargeting engine: retargeting.py + bone_matching.py from Dev-GOM/claude-code-marketplace plugins/blender-toolkit, Apache License 2.0. Modified: relative imports flattened, logger replaced with stdlib logging. The original project additionally offers a WebSocket CLI control plane and UI confirmation panel not included here.

Assets

This skill redistributes no Mixamo or Adobe mocap, FBX, or character assets — only the retargeting workflow. Download Mixamo clips yourself; they stay on your machine and are not part of this pack.

Files (dayz-modding-knowledge-pack)
  • references
    • bone-mapping-guide.md 15.6 KB
      Loading…
  • scripts
    • bone_matching.py 7.8 KB
      Loading…
    • retargeting.py 17 KB
      Loading…
  • SKILL.md 5.2 KB
    ---
    name: mixamo-retarget
    description: "(EXPERIMENTAL — extracted and syntax-checked, fixture validation pending) Retarget Mixamo (or any FBX/DAE) animations onto a custom Blender rig — including the DayZ skeleton — with fuzzy bone matching, preset mappings (mixamo_to_rigify), persistent per-pair bone maps, NLA stacking and playback. Use whenever the user wants to apply Mixamo mocap to a character, retarget an animation between skeletons, auto-map bones between two armatures, import an animation FBX onto an existing rig, or source motion-capture keyframes for the DayZ SEAnim pipeline (dayz-animation-pipeline Layer 2). Triggers: retarget, Mixamo, mocap a mi rig, pasar animación entre esqueletos, bone mapping, aplicar animación FBX. Runs through the existing Blender MCP (execute_blender_code) — no extra addon, no WebSocket server."
    ---
    
    # Mixamo Retarget (via Blender MCP)
    
    Retargets skeletal animations between armatures inside Blender, driven entirely through the already-connected Blender MCP. The engine is the retargeting module extracted from Dev-GOM's `blender-toolkit` (Apache-2.0; attribution below) — the valuable 700 lines, without the plugin's WebSocket server, CLI build, hooks, or second Blender addon.
    
    **Status: EXPERIMENTAL — extracted and syntax-checked, not yet fixture-validated.** Before first production use, run the fixture at the bottom and record the result.
    
    ## What it does
    
    - `auto_map_bones(source, target)` — fuzzy bone matching with a Mixamo alias table (works on `mixamorig:`-prefixed and bare names).
    - `get_preset_bone_mapping("mixamo_to_rigify")` — known-good preset.
    - `store_bone_mapping` / `load_bone_mapping` — persist a reviewed map per armature pair (scene-level), so the fuzzy pass runs once and the corrected map is reused.
    - `retarget_animation(source, target, bone_map, action_name)` — bakes the retargeted action onto the target rig.
    - `import_fbx` / `import_dae`, `list_armatures`, `get_bones`, `list_animations`, `play_animation`, `add_to_nla`.
    
    ## How to run it (through the Blender MCP)
    
    The two modules in `scripts/` are plain Blender-Python. Load them once per session by exec-ing them in Blender's interpreter, in dependency order:
    
    1. Read `scripts/bone_matching.py` and `scripts/retargeting.py` from this skill.
    2. Send each through `execute_blender_code` (bone_matching first — retargeting imports `fuzzy_match_bones` from it; when exec'd into the same namespace, replace its `from bone_matching import …` line with nothing, or exec bone_matching's source first so the names already exist).
    3. Then drive the workflow:
    
    ```python
    # inside execute_blender_code, after both modules are loaded
    import_fbx(r"C:\path\to\Walking.fbx")          # brings in the Mixamo armature + action
    print(list_armatures())                          # e.g. ['Armature', 'MyDayZRig']
    bm = auto_map_bones("Armature", "MyDayZRig")    # fuzzy pass — REVIEW THIS DICT
    print(bm)
    ```
    
    4. **Two-phase discipline (kept from the original design):** never retarget straight off the fuzzy map. Print it, review/correct it (the human or a reasoned pass), `store_bone_mapping` the corrected version, then:
    
    ```python
    retarget_animation("Armature", "MyDayZRig", bone_map=bm, action_name="Walking_retarget")
    play_animation("MyDayZRig", "Walking_retarget")
    ```
    
    `references/bone-mapping-guide.md` (653 lines, from the original project) covers alias logic, naming conventions, and fixing bad matches — read it when the fuzzy map comes back with gaps.
    
    ## Rest-pose caveat (the classic failure)
    
    Mixamo rigs are T-pose; many targets (including game rigs) are A-pose or custom. A retarget across mismatched rest poses bakes a permanent offset into every frame. Align rest poses first (apply rotation on the Mixamo armature; or pose-match the target's rest to the source) before judging the result. Symptom: arms floating ~45° off on every frame.
    
    ## DayZ integration note
    
    For LFPG work, the output of a retarget onto the DayZ skeleton is **source keyframes**, not a game-ready animation: it feeds `dayz-animation-pipeline` Layer 2 (Blender keyframes → SEAnim → DayZATool → `.anm`), and the player/creature anim-graph wall still applies (one animation mod per server). Use it to harvest mocap for creatures, poses, and reference motion — not as a shortcut around the pipeline.
    
    ## Fixture before first real use (AGENTS-R26)
    
    Positive: import any Mixamo FBX, retarget onto a copy of its own armature with the identity map — the result must visually match the original (render 3 frames via `blender-visual-review`). Negative: retarget with an empty bone map must raise/return an error, not silently produce a frozen action. Record both outcomes; only then drop the EXPERIMENTAL label.
    
    ## Attribution
    
    Retargeting engine: `retargeting.py` + `bone_matching.py` from [Dev-GOM/claude-code-marketplace](https://github.com/Dev-GOM/claude-code-marketplace) `plugins/blender-toolkit`, Apache License 2.0. Modified: relative imports flattened, logger replaced with stdlib logging. The original project additionally offers a WebSocket CLI control plane and UI confirmation panel not included here.
    
    ## Assets
    
    This skill redistributes **no** Mixamo or Adobe mocap, FBX, or character assets — only the retargeting workflow. Download Mixamo clips yourself; they stay on your machine and are not part of this pack.
    

Comments (0)

Sign in to join the conversation.

No comments yet.

Reviews (0)

No reviews yet.