Initial release: prompts, metadata, T-pose renders, build pipeline (no commercial motion files)

.gitattributes

@@ -1,60 +1,10 @@
-*.7z filter=lfs diff=lfs merge=lfs -text
-*.arrow filter=lfs diff=lfs merge=lfs -text
-*.avro filter=lfs diff=lfs merge=lfs -text
-*.bin filter=lfs diff=lfs merge=lfs -text
-*.bz2 filter=lfs diff=lfs merge=lfs -text
-*.ckpt filter=lfs diff=lfs merge=lfs -text
-*.ftz filter=lfs diff=lfs merge=lfs -text
-*.gz filter=lfs diff=lfs merge=lfs -text
-*.h5 filter=lfs diff=lfs merge=lfs -text
-*.joblib filter=lfs diff=lfs merge=lfs -text
-*.lfs.* filter=lfs diff=lfs merge=lfs -text
-*.lz4 filter=lfs diff=lfs merge=lfs -text
-*.mds filter=lfs diff=lfs merge=lfs -text
-*.mlmodel filter=lfs diff=lfs merge=lfs -text
-*.model filter=lfs diff=lfs merge=lfs -text
-*.msgpack filter=lfs diff=lfs merge=lfs -text
-*.npy filter=lfs diff=lfs merge=lfs -text
-*.npz filter=lfs diff=lfs merge=lfs -text
-*.onnx filter=lfs diff=lfs merge=lfs -text
-*.ot filter=lfs diff=lfs merge=lfs -text
-*.parquet filter=lfs diff=lfs merge=lfs -text
-*.pb filter=lfs diff=lfs merge=lfs -text
-*.pickle filter=lfs diff=lfs merge=lfs -text
-*.pkl filter=lfs diff=lfs merge=lfs -text
-*.pt filter=lfs diff=lfs merge=lfs -text
-*.pth filter=lfs diff=lfs merge=lfs -text
-*.rar filter=lfs diff=lfs merge=lfs -text
-*.safetensors filter=lfs diff=lfs merge=lfs -text
-saved_model/**/* filter=lfs diff=lfs merge=lfs -text
-*.tar.* filter=lfs diff=lfs merge=lfs -text
-*.tar filter=lfs diff=lfs merge=lfs -text
-*.tflite filter=lfs diff=lfs merge=lfs -text
-*.tgz filter=lfs diff=lfs merge=lfs -text
-*.wasm filter=lfs diff=lfs merge=lfs -text
-*.xz filter=lfs diff=lfs merge=lfs -text
-*.zip filter=lfs diff=lfs merge=lfs -text
-*.zst filter=lfs diff=lfs merge=lfs -text
-*tfevents* filter=lfs diff=lfs merge=lfs -text
-# Audio files - uncompressed
-*.pcm filter=lfs diff=lfs merge=lfs -text
-*.sam filter=lfs diff=lfs merge=lfs -text
-*.raw filter=lfs diff=lfs merge=lfs -text
-# Audio files - compressed
-*.aac filter=lfs diff=lfs merge=lfs -text
-*.flac filter=lfs diff=lfs merge=lfs -text
-*.mp3 filter=lfs diff=lfs merge=lfs -text
-*.ogg filter=lfs diff=lfs merge=lfs -text
-*.wav filter=lfs diff=lfs merge=lfs -text
-# Image files - uncompressed
-*.bmp filter=lfs diff=lfs merge=lfs -text
-*.gif filter=lfs diff=lfs merge=lfs -text
-*.png filter=lfs diff=lfs merge=lfs -text
-*.tiff filter=lfs diff=lfs merge=lfs -text
-# Image files - compressed
-*.jpg filter=lfs diff=lfs merge=lfs -text
+*.fbx  filter=lfs diff=lfs merge=lfs -text
+*.FBX  filter=lfs diff=lfs merge=lfs -text
+*.bvh  filter=lfs diff=lfs merge=lfs -text
+*.BVH  filter=lfs diff=lfs merge=lfs -text
+*.jpg  filter=lfs diff=lfs merge=lfs -text
+*.JPG  filter=lfs diff=lfs merge=lfs -text
 *.jpeg filter=lfs diff=lfs merge=lfs -text
-*.webp filter=lfs diff=lfs merge=lfs -text
-# Video files - compressed
-*.mp4 filter=lfs diff=lfs merge=lfs -text
-*.webm filter=lfs diff=lfs merge=lfs -text
+*.png  filter=lfs diff=lfs merge=lfs -text
+*.tga  filter=lfs diff=lfs merge=lfs -text
+*.TGA  filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,10 @@
+.cache/
+__pycache__/
+*.pyc
+.DS_Store
+
+# Commercial Truebones ZOO assets — kept locally, never committed or uploaded.
+# Purchase from https://truebones.com and rebuild animation/ with scripts/pipeline/.
+Truebone_Z-OO/
+animation/
+animation_glb/

README.md

@@ -0,0 +1,242 @@
+---
+license: other
+pretty_name: Truebones ZOO Annotations
+language:
+- en
+size_categories:
+- 1K<n<10K
+tags:
+- 3d
+- animation
+- motion
+- animal
+- fbx
+- bvh
+- skeletal-animation
+- mocap
+configs:
+- config_name: animation
+  default: true
+  data_files: animation.csv
+- config_name: species
+  data_files: species.csv
+- config_name: clips
+  data_files: clips.csv
+---
+
+# Truebones ZOO Annotations
+
+Text prompts, per-clip metadata, rest-pose renders and the exact build pipeline for
+**Truebones ZOO** — **1,097 animal motion clips across 74 skeletons**: mammals, birds,
+reptiles, insects, marine and prehistoric creatures. 1.02 hours, 111,158 frames, uniformly
+30 fps. Rigs range from 9 to 143 joints; clips from 0.3 to 18.5 seconds.
+
+**The motion files themselves are not in this repository.** Truebones ZOO is a commercial
+library by [Truebones Motions Animation Studios](https://truebones.com) and may not be
+redistributed. What ships here is everything around the motions — one text prompt per clip,
+per-clip and per-species metadata, one rest-pose render per skeleton, and the dependency-free
+pipeline that rebuilds the exact per-clip dataset from your own purchased copy: buy the library
+at <https://truebones.gumroad.com/l/skZMC>, unpack it here, run four scripts, and `animation/`
+materialises byte-for-byte (sixteen clips excepted; see below).
+
+## Structure
+
+```
+animation.csv                      one row per clip (1,097)
+animation_prompts.json             one text prompt per clip (1,097)
+animation_frames.json              clip -> frame count
+animation_bones.json               species -> its joint names
+species.csv                        one row per species (74)
+species_tpose/<Species>.png        one rest-pose render grid per species (74)
+clips.csv                          one row per source file (2,447), mapped onto animation/
+excluded.csv                       source files no importer reads (1)
+scripts/pipeline|probes            the build pipeline and the format readers
+
+animation/<Species>-<Action>.fbx   not included — rebuilt from your purchased copy (see below)
+animation_glb/                     not included — the same clips as GLB, converted locally
+Truebone_Z-OO/<Group>/…            not included — the original commercial download
+```
+
+## Rebuilding `animation/`
+
+Purchase Truebones ZOO from <https://truebones.gumroad.com/l/skZMC> and unpack it next to
+these files as `Truebone_Z-OO/`, one folder per animal group, layout and names as shipped.
+Then run the pipeline — pure Python 3, no dependencies:
+
+```bash
+cd scripts
+python3 pipeline/build_dataset.py         # 1. index the download  -> ../clips.csv
+python3 pipeline/normalize.py             # 2. name every clip     -> ../clips.csv
+python3 pipeline/build_animation.py       # 3. one file per motion -> ../animation/
+python3 pipeline/build_metadata.py        # 4. measure animation/  -> ../animation.csv, ../species.csv, sidecars
+```
+
+The result is one flat folder, one file per motion, named `<Species>-<Action>.fbx`:
+
+```
+Cat-Walk.fbx     Trex-Big_Roar_Step.fbx     SabreToothTiger-Tired_Yawn.fbx
+```
+
+The species is a single alphanumeric token and the action never contains a hyphen, so
+`name.split("-", 1)` always recovers both parts. Actions are underscore-separated capitalised
+words with a trailing `_2` / `_3` for variants, matching the Mixamo convention.
+
+Guarantees, each checked rather than assumed: exactly one animation per file, no clip repeats
+another, every source motion is covered (one exception, `Lynx/Idle4`, ships only inside a
+combined file), and 30 fps throughout, measured from key times.
+
+Selecting and renaming only — nothing is ever re-exported. Every clip is a hardlink straight
+into `Truebone_Z-OO/`, byte for byte, so no clip carries a rig that a round trip through an
+editor has altered. Steps 1 and 4 regenerate `clips.csv`, `animation.csv`, `species.csv` and
+the two JSON sidecars; apart from the sixteen repaired clips below they should match the files
+shipped here, which is also how to verify a rebuild. Step 5, `build_prompts.py`, re-downloads
+the captions from their source; its result already ships here as `animation_prompts.json`.
+`scripts/README.md` documents each step.
+
+**Sixteen of the 1,097 clips received a one-off binary repair** that the pipeline does not
+re-apply: the four `Cat` clips had their missing texture embedded
+(`probes/fbx_embed_texture.py`), and the twelve `KingCobra` clips had a duplicated co-located
+mesh variant removed (`probes/fbx_strip_variant.py`); one of them, `KingCobra-Walk`, whose
+source shipped no mesh at all, additionally received a sibling's mesh
+(`probes/fbx_graft_mesh.py`) and had its material settings aligned with its siblings'
+(`probes/fbx_align_material.py`). These edits touch textures and meshes only, never the
+motion. All four probes are included and documented in `scripts/README.md`, each gated on a
+byte-identical no-edit round trip and writing through a temporary file so the source keeps its
+own bytes.
+
+The GLB mirror, `animation_glb/`, is a one-to-one conversion of `animation/` — mesh, armature,
+and the clip's single animation take, named after the action — for toolchains that read glTF
+rather than FBX. Regenerate it from your rebuilt clips with Blender's FBX importer and glTF
+exporter.
+
+## animation.csv
+
+| column | meaning |
+|---|---|
+| `file` | `animation/Cat-Walk.fbx` |
+| `species`, `action` | the two halves of the filename |
+| `take` | the animation stack's own name, as the source spelled it |
+| `num_takes`, `num_actions` | animation stacks in the file, and how many carry curves; `num_actions` is 1 everywhere |
+| `num_joints` | nodes in the FBX hierarchy (see *Data notes*) |
+| `root_joint` | the topmost joint carrying animation |
+| `frames`, `fps`, `duration_sec` | timeline, read off the key times |
+| `fbx_version`, `bytes` | file version and size |
+| `num_source_files` | how many files in `Truebone_Z-OO/` this clip accounts for |
+
+## species.csv
+
+Per species: `num_clips`, `num_joints`, `rig_variants`, `root_joint`, `total_frames`,
+`total_duration_sec`, `mean_duration_sec`, `num_textures`, `source_fbx`, `source_bvh`,
+`has_combined_all`, `has_tpose`.
+
+`rig_variants` is how many distinct joint-name sets the species' clips use — 1 for 72 of them,
+2 for `KingCobra` and 4 for `Monkey`.
+Counts run from 70 clips (`Trex`) to 3 (`Chicken`, `Parrot2`), median 12.
+
+## species_tpose/
+
+One 1024×1024 PNG per species: a 2×2 grid of its rest pose — front and back on the top row,
+left and right below — rendered (EEVEE) from the species' first clip in `animation/`. A visual
+index of the 74 rigs.
+
+## clips.csv
+
+One row per file in `Truebone_Z-OO/`, mapping every source path onto the dataset:
+`status` says what the file is (`linked` into `animation/`, a BVH `mirror` of a linked clip, a
+`duplicate`, a group's `combined` ALL file, a `static` pose, or an orphan), and
+`animation_file` points at the clip that carries its motion. Use it to trace any clip back to
+the exact source files it came from.
+
+## animation_frames.json and animation_bones.json
+
+Two flat sidecars, sorted by key:
+
+```json
+// animation_frames.json — 1,097 keys
+"Alligator-Big_Mouth.fbx": 136
+
+// animation_bones.json — 74 keys, one per species
+"Pigeon": ["Hips", "LeftArm", "LeftForeArm", "LeftLeg",
+           "RightArm", "RightForeArm", "RightLeg", "Spine", "Tail01"]
+```
+
+The skeleton is per species, so the bone list is keyed by species: the joint set its clips most
+often carry, taken from actual files. For 72 of the 74 every clip matches it exactly; the
+exceptions are `KingCobra` and `Monkey`, whose variants `species.csv` records as `rig_variants`.
+
+## animation_prompts.json
+
+One text prompt per clip — a flat map from filename to a small record, absent fields left out:
+
+```json
+"Trex-Death.fbx": {
+  "object_name": "Tyrannosaurus Rex",
+  "prompt": "A running tyrannosaurus rex loses balance and falls to the right.",
+  "prompt_source": "t2m4lvo"
+}
+```
+
+| field | meaning |
+|---|---|
+| `prompt` | what the clip shows, in one sentence. Median 12 words |
+| `object_name` | the species as the annotator named it — `Tyrannosaurus Rex`, `Great White Shark` |
+| `prompt_source` | `t2m4lvo` on 1,088 clips, `inferred` on 9 quiet clips captioned here instead |
+| `alt_prompt` | on 20 clips only: the source shipped that motion twice, so it was described twice |
+
+The captions come from [T2M4LVO](https://huggingface.co/datasets/1Konny/t2m4lvo-truebones-zoo),
+the annotation set released with *How to Move Your Dragon* (ICML 2025). **T2M4LVO is
+CC-BY-NC-4.0 — non-commercial use only, narrower than the rest of this repository.** Three
+captions are shared by two clips each; retrieval metrics should group ground truth by caption
+text so those pairs are not scored as misses.
+
+## Usage
+
+```python
+import csv, collections
+
+clips   = list(csv.DictReader(open("animation.csv")))
+species = list(csv.DictReader(open("species.csv")))
+
+# clips of at least a second, grouped by species
+by_species = collections.defaultdict(list)
+for c in clips:
+    if float(c["duration_sec"]) >= 1.0:
+        by_species[c["species"]].append(c)
+
+# every walk cycle in the library
+walks = [c for c in clips if c["action"].startswith("Walk")]
+```
+
+`scripts/probes/` bundles dependency-free FBX and BVH readers
+(`fbx_probe.probe(path)`, `bvh_probe.probe(path)`) that return joints, keyframes, fps,
+duration, root and joint names.
+
+## Data notes
+
+- **`num_joints` counts every node in the FBX hierarchy**, not only bones — the exporter types
+  mesh and null containers as `LimbNode` too, so an FBX typically reports two to four more
+  "joints" than the matching BVH, and for a handful of rigs `root_joint` is a container
+  (`Null`, `EAL1_2`, `N_ALL`) rather than `Hips`.
+- **Five species do not share one skeleton across their clips** — `Elephant`, `Fox`, `Monkey`,
+  `KingCobra` and `PolarBearB` vary in rest offsets along authoring-batch lines, inherited from
+  the source. Joint *names* agree everywhere; `KingCobra` additionally ships 19- and 20-joint
+  variants. A clip's rest pose is its own first frame, so these are also the five species whose
+  clips carry more than one rest pose.
+- **Source spelling is preserved verbatim**, typos included (`Angery_Swat`, `Sqwak`, `Begg`),
+  so the mapping back to `Truebone_Z-OO/` stays exact. Joint naming is not standardised across
+  species.
+- **Materials are 2014 Phong with no `ReflectionFactor` set**; Blender's importer defaults that
+  to `Metallic` 1.0, so clips import fully metallic — set `Metallic` to 0 after import for a
+  dielectric look.
+- `excluded.csv` lists the one source file no importer reads
+  (`Truebone_Z-OO/Crocodile/CrocodileALL.fbx`, not a binary FBX).
+
+## Source
+
+Truebones Z-OO by Truebones Motions Animation Studios, obtained from
+<https://truebones.gumroad.com/l/skZMC>. `Terms of Use.txt` ships with the original download and
+governs what may be done with these assets: they may not be resold or redistributed — which is
+why no FBX, GLB or BVH is included here, and why `animation/` is rebuilt from your own
+purchased copy. The metadata, sidecars and scripts describe and rebuild the library without
+containing it; the rest-pose renders are included as a visual index of the rigs. The captions
+carry their own license (CC-BY-NC-4.0; see `animation_prompts.json` above).

animation_bones.json

@@ -0,0 +1,3861 @@
+{
+ "Alligator": [
+  "EAL1",
+  "EAL1_2",
+  "L_ashi",
+  "L_hiji",
+  "L_hiza",
+  "L_kata",
+  "L_momo",
+  "L_te",
+  "N_ALL",
+  "R_ashi",
+  "R_hiji",
+  "R_hiza",
+  "R_kata",
+  "R_momo",
+  "R_te",
+  "Skin",
+  "ago",
+  "atama",
+  "hara",
+  "koshi",
+  "kubi",
+  "locator2",
+  "mune",
+  "sippo01",
+  "sippo02",
+  "sippo03",
+  "sippo04",
+  "sippo05",
+  "sippo06"
+ ],
+ "Anaconda": [
+  "AN_NPC_MOB_Anaconda_A01_SK_IRS",
+  "BN_Head",
+  "BN_Jaw",
+  "BN_Neck",
+  "BN_Spline_01",
+  "BN_Spline_02",
+  "BN_Spline_03",
+  "BN_Spline_04",
+  "BN_Spline_05",
+  "BN_Spline_06",
+  "BN_Tail_01",
+  "BN_Tail_02",
+  "BN_Tail_03",
+  "BN_Tail_04",
+  "BN_Tail_05",
+  "BN_Tail_06",
+  "BN_Tail_07",
+  "BN_Tail_08",
+  "BN_Tail_09",
+  "BN_Tail_10",
+  "BN_Tail_11",
+  "BN_Tail_12",
+  "BN_Tail_13",
+  "BN_Tone_01",
+  "BN_Tone_02",
+  "BN_Tone_03",
+  "BN_Tone_04",
+  "Hips",
+  "Null",
+  "Skin",
+  "U3DMesh 1"
+ ],
+ "Ant": [
+  "BN_Clip_L_01",
+  "BN_Clip_L_02",
+  "BN_Clip_R_01",
+  "BN_Clip_R_02",
+  "BN_Mouth_L_01",
+  "BN_Mouth_R_01",
+  "BN_Tai01",
+  "BN_Tai02",
+  "BN_Tai03",
+  "Bip01_Head",
+  "Bip01_HeadNub",
+  "Bip01_L_Calf",
+  "Bip01_L_Clavicle",
+  "Bip01_L_Finger0",
+  "Bip01_L_Finger01",
+  "Bip01_L_Finger0Nub",
+  "Bip01_L_Foot",
+  "Bip01_L_Forearm",
+  "Bip01_L_Hand",
+  "Bip01_L_Thigh",
+  "Bip01_L_Toe0",
+  "Bip01_L_Toe01",
+  "Bip01_L_Toe0Nub",
+  "Bip01_L_UpperArm",
+  "Bip01_Neck",
+  "Bip01_Pelvis",
+  "Bip01_R_Calf",
+  "Bip01_R_Clavicle",
+  "Bip01_R_Finger0",
+  "Bip01_R_Finger01",
+  "Bip01_R_Finger0Nub",
+  "Bip01_R_Foot",
+  "Bip01_R_Forearm",
+  "Bip01_R_Hand",
+  "Bip01_R_Thigh",
+  "Bip01_R_Toe0",
+  "Bip01_R_Toe01",
+  "Bip01_R_Toe0Nub",
+  "Bip01_R_UpperArm",
+  "Bip01_Spine",
+  "Hips"
+ ],
+ "Bat": [
+  "BN_L_Clavicle_01",
+  "BN_L_Ear_01",
+  "BN_L_Finger_01",
+  "BN_L_Finger_03",
+  "BN_L_Finger_05",
+  "BN_L_Finger_07",
+  "BN_L_Hand_01",
+  "BN_L_UpperArm_01",
+  "BN_L__Forearm_01",
+  "BN_Mouth_01",
+  "BN_R_Clavicle_01",
+  "BN_R_Ear_01",
+  "BN_R_Finger_01",
+  "BN_R_Finger_03",
+  "BN_R_Finger_05",
+  "BN_R_Finger_07",
+  "BN_R_Hand_01",
+  "BN_R_UpperArm_01",
+  "BN_R__Forearm_01",
+  "BN_Tail_01",
+  "BN_Tail_02",
+  "BN_Tail_03",
+  "BN_Tail_04",
+  "Bip01_Head",
+  "Bip01_HeadNub",
+  "Bip01_L_Calf",
+  "Bip01_L_Foot",
+  "Bip01_L_Thigh",
+  "Bip01_L_Toe0",
+  "Bip01_L_Toe01",
+  "Bip01_L_Toe0Nub",
+  "Bip01_L_Toe1",
+  "Bip01_L_Toe11",
+  "Bip01_L_Toe1Nub",
+  "Bip01_Neck",
+  "Bip01_Pelvis",
+  "Bip01_R_Calf",
+  "Bip01_R_Foot",
+  "Bip01_R_Thigh",
+  "Bip01_R_Toe0",
+  "Bip01_R_Toe01",
+  "Bip01_R_Toe0Nub",
+  "Bip01_R_Toe1",
+  "Bip01_R_Toe11",
+  "Bip01_R_Toe1Nub",
+  "Bip01_Spine",
+  "Bip01_Spine1",
+  "Hips"
+ ],
+ "Bear": [
+  "Hips",
+  "NPC_Head",
+  "NPC_Jaw",
+  "NPC_LArm1",
+  "NPC_LArm1_UpperArmTwist1",
+  "NPC_LArm1_UpperArmTwist2",
+  "NPC_LArm2",
+  "NPC_LArm2_ForearmTwist1",
+  "NPC_LArm2_ForearmTwist2",
+  "NPC_LArmBall1",
+  "NPC_LArmCollarbone",
+  "NPC_LArmJiggle",
+  "NPC_LArmPalm",
+  "NPC_LIndex01",
+  "NPC_LIndex02",
+  "NPC_LLeg1",
+  "NPC_LLeg2",
+  "NPC_LLegAnkle",
+  "NPC_LLegBall1",
+  "NPC_LMiddle01",
+  "NPC_LMiddle02",
+  "NPC_LPinky01",
+  "NPC_LPinky02",
+  "NPC_LRing01",
+  "NPC_LRing02",
+  "NPC_LThighJiggle",
+  "NPC_LThumb01",
+  "NPC_LThumb02",
+  "NPC_L_Eyebrow",
+  "NPC_L_Toe",
+  "NPC_LowerFrontLip",
+  "NPC_LowerLeftLip",
+  "NPC_LowerRightLip",
+  "NPC_Neck1",
+  "NPC_Neck2",
+  "NPC_NeckJiggle",
+  "NPC_Nose",
+  "NPC_Pelvis",
+  "NPC_RArm1",
+  "NPC_RArm1_UpperArmTwist1",
+  "NPC_RArm1_UpperArmTwist2",
+  "NPC_RArm2",
+  "NPC_RArm2_ForearmTwist1",
+  "NPC_RArm2_ForearmTwist2",
+  "NPC_RArmBall1",
+  "NPC_RArmCollarbone",
+  "NPC_RArmJiggle",
+  "NPC_RArmPalm",
+  "NPC_RIndex01",
+  "NPC_RIndex02",
+  "NPC_RLeg1",
+  "NPC_RLeg2",
+  "NPC_RLegAnkle",
+  "NPC_RLegBall1",
+  "NPC_RMiddle01",
+  "NPC_RMiddle02",
+  "NPC_RPinky01",
+  "NPC_RPinky02",
+  "NPC_RRing01",
+  "NPC_RRing02",
+  "NPC_RThighJiggle",
+  "NPC_RThumb01",
+  "NPC_RThumb02",
+  "NPC_R_Eyebrow",
+  "NPC_R_Toe",
+  "NPC_Ribcage",
+  "NPC_Spine1",
+  "NPC_Spine1BackJiggle",
+  "NPC_Spine1Jiggle",
+  "NPC_Spine2",
+  "NPC_Spine3",
+  "NPC_Spine4",
+  "NPC_Spine4Jiggle",
+  "NPC_UpperLeftLip",
+  "NPC_UpperLip",
+  "NPC_UpperRightLip"
+ ],
+ "Bird": [
+  "BN_Finger_L_01",
+  "BN_Finger_L_02",
+  "BN_Finger_R_01",
+  "BN_Finger_R_02",
+  "BN_Forearm_L_01",
+  "BN_Forearm_R_01",
+  "BN_Mouth_01",
+  "BN_Tail_01",
+  "BN_Tail_02",
+  "BN_Tail_03",
+  "BN_UpperArm_L_01",
+  "BN_UpperArm_R_01",
+  "BN_hand_L_01",
+  "BN_hand_R_01",
+  "Bip01_Head",
+  "Bip01_HeadNub",
+  "Bip01_L_Calf",
+  "Bip01_L_Foot",
+  "Bip01_L_HorseLink",
+  "Bip01_L_Thigh",
+  "Bip01_L_Toe0",
+  "Bip01_L_Toe01",
+  "Bip01_L_Toe02",
+  "Bip01_L_Toe0Nub",
+  "Bip01_L_Toe1",
+  "Bip01_L_Toe11",
+  "Bip01_L_Toe12",
+  "Bip01_L_Toe1Nub",
+  "Bip01_L_Toe2",
+  "Bip01_L_Toe21",
+  "Bip01_L_Toe22",
+  "Bip01_L_Toe2Nub",
+  "Bip01_L_Toe3",
+  "Bip01_L_Toe31",
+  "Bip01_L_Toe32",
+  "Bip01_L_Toe3Nub",
+  "Bip01_Neck",
+  "Bip01_Neck1",
+  "Bip01_Pelvis",
+  "Bip01_R_Calf",
+  "Bip01_R_Foot",
+  "Bip01_R_HorseLink",
+  "Bip01_R_Thigh",
+  "Bip01_R_Toe0",
+  "Bip01_R_Toe01",
+  "Bip01_R_Toe02",
+  "Bip01_R_Toe0Nub",
+  "Bip01_R_Toe1",
+  "Bip01_R_Toe11",
+  "Bip01_R_Toe12",
+  "Bip01_R_Toe1Nub",
+  "Bip01_R_Toe2",
+  "Bip01_R_Toe21",
+  "Bip01_R_Toe22",
+  "Bip01_R_Toe2Nub",
+  "Bip01_R_Toe3",
+  "Bip01_R_Toe31",
+  "Bip01_R_Toe32",
+  "Bip01_R_Toe3Nub",
+  "Bip01_Spine",
+  "Bip01_Spine1",
+  "Hips"
+ ],
+ "BrownBear": [
+  "BN_Ear_L_01",
+  "BN_Ear_R_01",
+  "BN_Mouth_01",
+  "BN_Tongue_01",
+  "BN_Tongue_02",
+  "Bip01_Head",
+  "Bip01_HeadNub",
+  "Bip01_L_Calf",
+  "Bip01_L_Clavicle",
+  "Bip01_L_Finger0",
+  "Bip01_L_Finger0Nub",
+  "Bip01_L_Finger1",
+  "Bip01_L_Finger1Nub",
+  "Bip01_L_Foot",
+  "Bip01_L_Forearm",
+  "Bip01_L_Hand",
+  "Bip01_L_Thigh",
+  "Bip01_L_Toe0",
+  "Bip01_L_Toe0Nub",
+  "Bip01_L_UpperArm",
+  "Bip01_Neck",
+  "Bip01_Neck1",
+  "Bip01_Pelvis",
+  "Bip01_R_Calf",
+  "Bip01_R_Clavicle",
+  "Bip01_R_Finger0",
+  "Bip01_R_Finger0Nub",
+  "Bip01_R_Finger1",
+  "Bip01_R_Finger1Nub",
+  "Bip01_R_Foot",
+  "Bip01_R_Forearm",
+  "Bip01_R_Hand",
+  "Bip01_R_Thigh",
+  "Bip01_R_Toe0",
+  "Bip01_R_Toe0Nub",
+  "Bip01_R_UpperArm",
+  "Bip01_Spine",
+  "Bip01_Spine1",
+  "Hips"
+ ],
+ "Buffalo": [
+  "BN_Beard_01",
+  "BN_Beard_02",
+  "BN_Ear_L_01",
+  "BN_Ear_R_01",
+  "BN_Mouth_01",
+  "BN_Tail_01",
+  "BN_Tail_02",
+  "BN_Tail_03",
+  "BN_Tail_04",
+  "BN_Tongue_01",
+  "BN_Tongue_02",
+  "Bip01_Head",
+  "Bip01_HeadNub",
+  "Bip01_L_Calf",
+  "Bip01_L_Clavicle",
+  "Bip01_L_Finger0",
+  "Bip01_L_Finger0Nub",
+  "Bip01_L_Foot",
+  "Bip01_L_Forearm",
+  "Bip01_L_Hand",
+  "Bip01_L_HorseLink",
+  "Bip01_L_Thigh",
+  "Bip01_L_Toe0",
+  "Bip01_L_Toe0Nub",
+  "Bip01_L_UpperArm",
+  "Bip01_Neck",
+  "Bip01_Neck1",
+  "Bip01_Pelvis",
+  "Bip01_R_Calf",
+  "Bip01_R_Clavicle",
+  "Bip01_R_Finger0",
+  "Bip01_R_Finger0Nub",
+  "Bip01_R_Foot",
+  "Bip01_R_Forearm",
+  "Bip01_R_Hand",
+  "Bip01_R_HorseLink",
+  "Bip01_R_Thigh",
+  "Bip01_R_Toe0",
+  "Bip01_R_Toe0Nub",
+  "Bip01_R_UpperArm",
+  "Bip01_Spine",
+  "Bip01_Spine1",
+  "Hips"
+ ],
+ "Buzzard": [
+  "BN_Eye_L",
+  "BN_Eye_R",
+  "BN_Jaw",
+  "BN_Tai_01",
+  "BN_Tai_L_01",
+  "BN_Tai_L_02",
+  "BN_Tai_R_01",
+  "BN_Tai_R_02",
+  "BN_Wing_L_01",
+  "BN_Wing_L_02",
+  "BN_Wing_L_03",
+  "BN_Wing_L_04",
+  "BN_Wing_L_06",
+  "BN_Wing_L_07",
+  "BN_Wing_R_01",
+  "BN_Wing_R_02",
+  "BN_Wing_R_03",
+  "BN_Wing_R_04",
+  "BN_Wing_R_06",
+  "BN_Wing_R_07",
+  "Bip01_Head",
+  "Bip01_HeadNub",
+  "Bip01_L_Calf",
+  "Bip01_L_Foot",
+  "Bip01_L_HorseLink",
+  "Bip01_L_Thigh",
+  "Bip01_L_Toe0",
+  "Bip01_L_Toe01",
+  "Bip01_L_Toe0Nub",
+  "Bip01_L_Toe1",
+  "Bip01_L_Toe11",
+  "Bip01_L_Toe1Nub",
+  "Bip01_L_Toe2",
+  "Bip01_L_Toe21",
+  "Bip01_L_Toe2Nub",
+  "Bip01_L_Toe3",
+  "Bip01_L_Toe31",
+  "Bip01_L_Toe3Nub",
+  "Bip01_Neck",
+  "Bip01_Neck1",
+  "Bip01_Neck2",
+  "Bip01_Pelvis",
+  "Bip01_R_Calf",
+  "Bip01_R_Foot",
+  "Bip01_R_HorseLink",
+  "Bip01_R_Thigh",
+  "Bip01_R_Toe0",
+  "Bip01_R_Toe01",
+  "Bip01_R_Toe0Nub",
+  "Bip01_R_Toe1",
+  "Bip01_R_Toe11",
+  "Bip01_R_Toe1Nub",
+  "Bip01_R_Toe2",
+  "Bip01_R_Toe21",
+  "Bip01_R_Toe2Nub",
+  "Bip01_R_Toe3",
+  "Bip01_R_Toe31",
+  "Bip01_R_Toe3Nub",
+  "Bip01_Spine",
+  "Bip01_Spine1",
+  "Bip01_Spine2",
+  "Hips"
+ ],
+ "Camel": [
+  "BN_Ear_L_01",
+  "BN_Ear_R_01",
+  "BN_Eyebrow_L",
+  "BN_Eyebrow_R",
+  "BN_Fur_01",
+  "BN_Fur_02",
+  "BN_Hair_01",
+  "BN_Mouth_01",
+  "BN_Mouth_02",
+  "BN_Tail_01",
+  "BN_Tail_02",
+  "BN_Tail_03",
+  "BN_Tail_04",
+  "Bip01",
+  "Bip01_Head",
+  "Bip01_HeadNub",
+  "Bip01_L_Calf",
+  "Bip01_L_Clavicle",
+  "Bip01_L_Finger0",
+  "Bip01_L_Finger0Nub",
+  "Bip01_L_Foot",
+  "Bip01_L_Forearm",
+  "Bip01_L_Hand",
+  "Bip01_L_HorseLink",
+  "Bip01_L_Thigh",
+  "Bip01_L_Toe0",
+  "Bip01_L_Toe0Nub",
+  "Bip01_L_UpperArm",
+  "Bip01_Neck",
+  "Bip01_Neck1",
+  "Bip01_Neck2",
+  "Bip01_Pelvis",
+  "Bip01_R_Calf",
+  "Bip01_R_Clavicle",
+  "Bip01_R_Finger0",
+  "Bip01_R_Finger0Nub",
+  "Bip01_R_Foot",
+  "Bip01_R_Forearm",
+  "Bip01_R_Hand",
+  "Bip01_R_HorseLink",
+  "Bip01_R_Thigh",
+  "Bip01_R_Toe0",
+  "Bip01_R_Toe0Nub",
+  "Bip01_R_UpperArm",
+  "Bip01_Spine",
+  "Bip01_Spine1",
+  "Bip01_Spine2",
+  "C_ctrl",
+  "Handle",
+  "Hips",
+  "Saddle"
+ ],
+ "Cat": [
+  "BN_Beard_L",
+  "BN_Beard_R",
+  "BN_Ear_L",
+  "BN_Ear_R",
+  "BN_Mouth",
+  "BN_Tail_01",
+  "BN_Tail_02",
+  "BN_Tail_03",
+  "BN_Tail_04",
+  "BN_Thouge_01",
+  "BN_Thouge_02",
+  "Bip01_Head",
+  "Bip01_HeadNub",
+  "Bip01_L_Calf",
+  "Bip01_L_Clavicle",
+  "Bip01_L_Finger0",
+  "Bip01_L_Finger0Nub",
+  "Bip01_L_Foot",
+  "Bip01_L_Forearm",
+  "Bip01_L_Hand",
+  "Bip01_L_HorseLink",
+  "Bip01_L_Thigh",
+  "Bip01_L_Toe0",
+  "Bip01_L_Toe0Nub",
+  "Bip01_L_UpperArm",
+  "Bip01_Neck",
+  "Bip01_Neck1",
+  "Bip01_Pelvis",
+  "Bip01_R_Calf",
+  "Bip01_R_Clavicle",
+  "Bip01_R_Finger0",
+  "Bip01_R_Finger0Nub",
+  "Bip01_R_Foot",
+  "Bip01_R_Forearm",
+  "Bip01_R_Hand",
+  "Bip01_R_HorseLink",
+  "Bip01_R_Thigh",
+  "Bip01_R_Toe0",
+  "Bip01_R_Toe0Nub",
+  "Bip01_R_UpperArm",
+  "Bip01_Spine",
+  "Bip01_Spine1",
+  "Bip01_Spine2",
+  "Hips"
+ ],
+ "Centipede": [
+  "BN_Calf_L_01",
+  "BN_Calf_L_02",
+  "BN_Calf_L_03",
+  "BN_Calf_R_01",
+  "BN_Calf_R_02",
+  "BN_Calf_R_03",
+  "BN_Foot_L01",
+  "BN_Foot_L_02",
+  "BN_Foot_L_03",
+  "BN_Foot_R_01",
+  "BN_Foot_R_02",
+  "BN_Foot_R_03",
+  "BN_Piers_L_01",
+  "BN_Piers_L_03",
+  "BN_Piers_L_04",
+  "BN_Piers_L_05",
+  "BN_Piers_L_06",
+  "BN_Piers_R_03",
+  "BN_Piers_R_04",
+  "BN_Piers_R_05",
+  "BN_Piers_R_06",
+  "BN_Pliers_L_02",
+  "BN_Pliers_R_01",
+  "BN_Pliers_R_02",
+  "BN_Shall_L_01",
+  "BN_Shall_L_02",
+  "BN_Shall_L_03",
+  "BN_Shall_R_01",
+  "BN_Shall_R_02",
+  "BN_Shall_R_03",
+  "BN_Tail_01",
+  "BN_Tail_02",
+  "BN_Tail_03",
+  "BN_Tail_04",
+  "BN_Tail_L_01",
+  "BN_Tail_L_02",
+  "BN_Tail_R_01",
+  "BN_Tail_R_02",
+  "BN_Thigh_L_01",
+  "BN_Thigh_L_02",
+  "BN_Thigh_L_03",
+  "BN_Thigh_R_01",
+  "BN_Thigh_R_02",
+  "BN_Thigh_R_03",
+  "BN_Toe01_L_01",
+  "BN_Toe01_R_01",
+  "BN_Toe0_L_01",
+  "BN_Toe0_R_01",
+  "BN_UpperArm_L_01",
+  "BN_UpperArm_R_01",
+  "BN__Forearm_L_01",
+  "BN__Forearm_R_01",
+  "Bip01_Head",
+  "Bip01_HeadNub",
+  "Bip01_L_Calf",
+  "Bip01_L_Clavicle",
+  "Bip01_L_Finger0",
+  "Bip01_L_Finger0Nub",
+  "Bip01_L_Foot",
+  "Bip01_L_Forearm",
+  "Bip01_L_Hand",
+  "Bip01_L_Thigh",
+  "Bip01_L_Toe0",
+  "Bip01_L_Toe01",
+  "Bip01_L_Toe0Nub",
+  "Bip01_L_UpperArm",
+  "Bip01_Neck1",
+  "Bip01_Neck2",
+  "Bip01_Pelvis",
+  "Bip01_R_Calf",
+  "Bip01_R_Clavicle",
+  "Bip01_R_Finger0",
+  "Bip01_R_Finger0Nub",
+  "Bip01_R_Foot",
+  "Bip01_R_Forearm",
+  "Bip01_R_Hand",
+  "Bip01_R_Thigh",
+  "Bip01_R_Toe0",
+  "Bip01_R_Toe01",
+  "Bip01_R_Toe0Nub",
+  "Bip01_R_UpperArm",
+  "Bip01_Spine",
+  "Bip01_Spine1",
+  "Hips"
+ ],
+ "Chicken": [
+  "BN_Finger_L_01",
+  "BN_Finger_L_02",
+  "BN_Finger_R_01",
+  "BN_Finger_R_02",
+  "BN_Mouth_01",
+  "BN_Tail_01",
+  "BN_Tail_02",
+  "BN_Tail_03",
+  "Bip01_Head",
+  "Bip01_HeadNub",
+  "Bip01_L_Calf",
+  "Bip01_L_Foot",
+  "Bip01_L_HorseLink",
+  "Bip01_L_Thigh",
+  "Bip01_L_Toe0",
+  "Bip01_L_Toe0Nub",
+  "Bip01_L_Toe1",
+  "Bip01_L_Toe1Nub",
+  "Bip01_L_Toe2",
+  "Bip01_L_Toe2Nub",
+  "Bip01_L_Toe3",
+  "Bip01_L_Toe3Nub",
+  "Bip01_Neck",
+  "Bip01_Neck1",
+  "Bip01_Neck2",
+  "Bip01_Pelvis",
+  "Bip01_R_Calf",
+  "Bip01_R_Foot",
+  "Bip01_R_HorseLink",
+  "Bip01_R_Thigh",
+  "Bip01_R_Toe0",
+  "Bip01_R_Toe0Nub",
+  "Bip01_R_Toe1",
+  "Bip01_R_Toe1Nub",
+  "Bip01_R_Toe2",
+  "Bip01_R_Toe2Nub",
+  "Bip01_R_Toe3",
+  "Bip01_R_Toe3Nub",
+  "Bip01_Spine",
+  "Bip01_Spine1",
+  "Hips"
+ ],
+ "Comodoa": [
+  "BN_Eyebrow_L",
+  "BN_Eyebrow_R",
+  "BN_Jaw",
+  "BN_Jaw01",
+  "BN_Tail01",
+  "BN_Tail02",
+  "BN_Tail03",
+  "BN_Tail04",
+  "BN_dorsal01",
+  "BN_dorsal02",
+  "BN_dorsal03",
+  "BN_ponitail",
+  "Bip01_Head",
+  "Bip01_HeadNub",
+  "Bip01_L_Calf",
+  "Bip01_L_Clavicle",
+  "Bip01_L_Finger0",
+  "Bip01_L_Finger0Nub",
+  "Bip01_L_Finger1",
+  "Bip01_L_Finger1Nub",
+  "Bip01_L_Finger2",
+  "Bip01_L_Finger2Nub",
+  "Bip01_L_Foot",
+  "Bip01_L_Forearm",
+  "Bip01_L_Hand",
+  "Bip01_L_HorseLink",
+  "Bip01_L_Thigh",
+  "Bip01_L_Toe0",
+  "Bip01_L_Toe0Nub",
+  "Bip01_L_Toe1",
+  "Bip01_L_Toe1Nub",
+  "Bip01_L_Toe2",
+  "Bip01_L_Toe2Nub",
+  "Bip01_L_UpperArm",
+  "Bip01_Neck",
+  "Bip01_Neck1",
+  "Bip01_Pelvis",
+  "Bip01_Ponytail1",
+  "Bip01_Ponytail1Nub",
+  "Bip01_Ponytail2",
+  "Bip01_Ponytail2Nub",
+  "Bip01_R_Calf",
+  "Bip01_R_Clavicle",
+  "Bip01_R_Finger0",
+  "Bip01_R_Finger0Nub",
+  "Bip01_R_Finger1",
+  "Bip01_R_Finger1Nub",
+  "Bip01_R_Finger2",
+  "Bip01_R_Finger2Nub",
+  "Bip01_R_Foot",
+  "Bip01_R_Forearm",
+  "Bip01_R_Hand",
+  "Bip01_R_HorseLink",
+  "Bip01_R_Thigh",
+  "Bip01_R_Toe0",
+  "Bip01_R_Toe0Nub",
+  "Bip01_R_Toe1",
+  "Bip01_R_Toe1Nub",
+  "Bip01_R_Toe2",
+  "Bip01_R_Toe2Nub",
+  "Bip01_R_UpperArm",
+  "Bip01_Spine",
+  "Bip01_Spine1",
+  "Bip01_Spine2",
+  "Hips"
+ ],
+ "Coyote": [
+  "BN_Ear_L_01",
+  "BN_Ear_R_01",
+  "BN_Mouth_01",
+  "BN_Tail_01",
+  "BN_Tail_02",
+  "BN_Tail_03",
+  "Bip01_Head",
+  "Bip01_HeadNub",
+  "Bip01_L_Calf",
+  "Bip01_L_Clavicle",
+  "Bip01_L_Finger0",
+  "Bip01_L_Finger01",
+  "Bip01_L_Finger0Nub",
+  "Bip01_L_Foot",
+  "Bip01_L_Forearm",
+  "Bip01_L_Hand",
+  "Bip01_L_HorseLink",
+  "Bip01_L_Thigh",
+  "Bip01_L_Toe0",
+  "Bip01_L_Toe0Nub",
+  "Bip01_L_UpperArm",
+  "Bip01_Neck",
+  "Bip01_Neck1",
+  "Bip01_Pelvis",
+  "Bip01_R_Calf",
+  "Bip01_R_Clavicle",
+  "Bip01_R_Finger0",
+  "Bip01_R_Finger01",
+  "Bip01_R_Finger0Nub",
+  "Bip01_R_Foot",
+  "Bip01_R_Forearm",
+  "Bip01_R_Hand",
+  "Bip01_R_HorseLink",
+  "Bip01_R_Thigh",
+  "Bip01_R_Toe0",
+  "Bip01_R_Toe0Nub",
+  "Bip01_R_UpperArm",
+  "Bip01_Spine",
+  "Bip01_Spine1",
+  "Bip01_Spine2",
+  "Hips"
+ ],
+ "Crab": [
+  "BN_Arm_L_01",
+  "BN_Arm_L_02",
+  "BN_Arm_L_03",
+  "BN_Arm_L_04",
+  "BN_Arm_R_01",
+  "BN_Arm_R_02",
+  "BN_Arm_R_03",
+  "BN_Arm_R_04",
+  "BN_Bip01_Pelvis",
+  "BN_Eye_L_01",
+  "BN_Eye_L_02",
+  "BN_Eye_L_03",
+  "BN_Eye_L_04",
+  "BN_Eye_R_01",
+  "BN_Eye_R_02",
+  "BN_Eye_R_03",
+  "BN_Eye_R_04",
+  "BN_Leg_L_05Nub",
+  "BN_Leg_L_07",
+  "BN_Leg_L_08",
+  "BN_Leg_L_09",
+  "BN_Leg_L_10",
+  "BN_Leg_L_10Nub",
+  "BN_Leg_L_11",
+  "BN_Leg_L_12",
+  "BN_Leg_L_13",
+  "BN_Leg_L_14",
+  "BN_Leg_L_15",
+  "BN_Leg_L_15Nub",
+  "BN_Leg_R_05Nub",
+  "BN_Leg_R_07",
+  "BN_Leg_R_08",
+  "BN_Leg_R_09",
+  "BN_Leg_R_10",
+  "BN_Leg_R_10Nub",
+  "BN_Leg_R_11",
+  "BN_Leg_R_12",
+  "BN_Leg_R_13",
+  "BN_Leg_R_14",
+  "BN_Leg_R_15",
+  "BN_Leg_R_15Nub",
+  "BN_leg_L_01",
+  "BN_leg_L_02",
+  "BN_leg_L_03",
+  "BN_leg_L_04",
+  "BN_leg_L_05",
+  "BN_leg_L_06",
+  "BN_leg_R_01",
+  "BN_leg_R_02",
+  "BN_leg_R_03",
+  "BN_leg_R_04",
+  "BN_leg_R_05",
+  "BN_leg_R_06",
+  "Hips"
+ ],
+ "Cricket": [
+  "BN_Feeler_L_01",
+  "BN_Feeler_L_02",
+  "BN_Feeler_L_03",
+  "BN_Feeler_L_04",
+  "BN_Feeler_L_05",
+  "BN_Feeler_L_06",
+  "BN_Feeler_L_07",
+  "BN_Feeler_L_08",
+  "BN_Feeler_R_01",
+  "BN_Feeler_R_02",
+  "BN_Feeler_R_03",
+  "BN_Feeler_R_04",
+  "BN_Feeler_R_05",
+  "BN_Feeler_R_06",
+  "BN_Feeler_R_07",
+  "BN_Feeler_R_08",
+  "BN_Mouth_01",
+  "BN_Tail_01",
+  "BN_Tail_02",
+  "BN_Wings_01",
+  "BN_Wings_02",
+  "BN_leg_L_01",
+  "BN_leg_L_02",
+  "BN_leg_L_03",
+  "BN_leg_L_04",
+  "BN_leg_R_01",
+  "BN_leg_R_02",
+  "BN_leg_R_03",
+  "BN_leg_R_04",
+  "Bip01_Head",
+  "Bip01_HeadNub",
+  "Bip01_L_Calf",
+  "Bip01_L_Clavicle",
+  "Bip01_L_Foot",
+  "Bip01_L_Forearm",
+  "Bip01_L_Hand",
+  "Bip01_L_Thigh",
+  "Bip01_L_Toe0",
+  "Bip01_L_Toe0Nub",
+  "Bip01_L_UpperArm",
+  "Bip01_Neck",
+  "Bip01_Pelvis",
+  "Bip01_R_Calf",
+  "Bip01_R_Clavicle",
+  "Bip01_R_Foot",
+  "Bip01_R_Forearm",
+  "Bip01_R_Hand",
+  "Bip01_R_Thigh",
+  "Bip01_R_Toe0",
+  "Bip01_R_Toe0Nub",
+  "Bip01_R_UpperArm",
+  "Bip01_Spine",
+  "Bip01_Spine1",
+  "Hips"
+ ],
+ "Crocodile": [
+  "BN_Jaw",
+  "BN_Tail_01",
+  "BN_Tail_02",
+  "BN_Tail_03",
+  "BN_Tail_04",
+  "BN_Tail_05",
+  "BN_lip_L",
+  "BN_lip_R",
+  "Bip01_Head",
+  "Bip01_HeadNub",
+  "Bip01_L_Calf",
+  "Bip01_L_Clavicle",
+  "Bip01_L_Finger0",
+  "Bip01_L_Finger0Nub",
+  "Bip01_L_Foot",
+  "Bip01_L_Forearm",
+  "Bip01_L_Hand",
+  "Bip01_L_Thigh",
+  "Bip01_L_Toe0",
+  "Bip01_L_Toe0Nub",
+  "Bip01_L_UpperArm",
+  "Bip01_Neck",
+  "Bip01_Neck1",
+  "Bip01_Pelvis",
+  "Bip01_R_Calf",
+  "Bip01_R_Clavicle",
+  "Bip01_R_Finger0",
+  "Bip01_R_Finger0Nub",
+  "Bip01_R_Foot",
+  "Bip01_R_Forearm",
+  "Bip01_R_Hand",
+  "Bip01_R_Thigh",
+  "Bip01_R_Toe0",
+  "Bip01_R_Toe0Nub",
+  "Bip01_R_UpperArm",
+  "Bip01_Spine",
+  "Bip01_Spine1",
+  "Bip01_Spine2",
+  "Hips"
+ ],
+ "Crow": [
+  "ECR1",
+  "Hips",
+  "N_ALL",
+  "Null",
+  "Skin",
+  "_00",
+  "_01",
+  "_02",
+  "_03",
+  "_04",
+  "_05",
+  "_06",
+  "_07",
+  "_08",
+  "_09",
+  "_10",
+  "_11",
+  "_12",
+  "_13",
+  "_14",
+  "_15",
+  "_16",
+  "_17",
+  "_18",
+  "_19",
+  "_20",
+  "_21",
+  "_22",
+  "_23"
+ ],
+ "Deer": [
+  "ElkJaw",
+  "ElkLEar",
+  "ElkLFemur",
+  "ElkLFrontHoof",
+  "ElkLHumerus",
+  "ElkLLargeCannon",
+  "ElkLMetacarpus",
+  "ElkLPhalangesManus",
+  "ElkLPhalanxPrima",
+  "ElkLRadius",
+  "ElkLRearHoof",
+  "ElkLScapula",
+  "ElkLTibia",
+  "ElkL_UpperLip",
+  "ElkMaleLEye01",
+  "ElkMaleREye",
+  "ElkNeck1",
+  "ElkNeck2",
+  "ElkNeck3",
+  "ElkNeck4",
+  "ElkPelvis",
+  "ElkREar",
+  "ElkRFemur",
+  "ElkRFrontHoof",
+  "ElkRHumerus",
+  "ElkRLargeCannon",
+  "ElkRMetacarpus",
+  "ElkRPhalangesManus",
+  "ElkRPhalanxPrima",
+  "ElkRRadius",
+  "ElkRRearHoof",
+  "ElkRScapula",
+  "ElkRTibia",
+  "ElkR_UpperLip",
+  "ElkRibcage",
+  "ElkScull",
+  "ElkScullBase",
+  "ElkSpine1",
+  "ElkSpine2",
+  "ElkSpine3",
+  "ElkTail1",
+  "ElkTail2",
+  "Hips",
+  "NPC_Root__Root_",
+  "Skin",
+  "Skin_10",
+  "Skin_12",
+  "Skin_13",
+  "Skin_15",
+  "Skin_16",
+  "Skin_18",
+  "Skin_19",
+  "Skin_21",
+  "Skin_212",
+  "Skin_22",
+  "Skin_24",
+  "Skin_25",
+  "Skin_60",
+  "Skin_73",
+  "Skin_9"
+ ],
+ "Dog": [
+  "Bip01_Head",
+  "Bip01_Head1_Jaw",
+  "Bip01_Head2_Eyeleds",
+  "Bip01_Head_JawNub",
+  "Bip01_Head_Muzzle",
+  "Bip01_L_Calf",
+  "Bip01_L_Clavicle",
+  "Bip01_L_Finger0",
+  "Bip01_L_Finger01",
+  "Bip01_L_Foot",
+  "Bip01_L_Forearm",
+  "Bip01_L_Hand",
+  "Bip01_L_Thigh",
+  "Bip01_L_Toe0",
+  "Bip01_L_Toe01",
+  "Bip01_L_Toe02",
+  "Bip01_L_UpperArm",
+  "Bip01_Neck",
+  "Bip01_Neck1",
+  "Bip01_Neck2",
+  "Bip01_Pelvis",
+  "Bip01_Ponytail1",
+  "Bip01_Ponytail11",
+  "Bip01_Ponytail2",
+  "Bip01_Ponytail21",
+  "Bip01_Ponytail31",
+  "Bip01_Ponytail32",
+  "Bip01_Ponytail3Nub",
+  "Bip01_R_Calf",
+  "Bip01_R_Clavicle",
+  "Bip01_R_Finger0",
+  "Bip01_R_Finger01",
+  "Bip01_R_Foot",
+  "Bip01_R_Forearm",
+  "Bip01_R_Hand",
+  "Bip01_R_Thigh",
+  "Bip01_R_Toe0",
+  "Bip01_R_Toe01",
+  "Bip01_R_Toe02",
+  "Bip01_R_UpperArm",
+  "Bip01_Spine",
+  "Bip01_Spine0",
+  "Bip01_Spine0_Tail",
+  "Bip01_Spine0_Tail1",
+  "Bip01_Spine0_Tail2",
+  "Bip01_Spine0_Tail3",
+  "Bip01_Spine0_Tail4",
+  "Bip01_Spine1",
+  "Bip01_Spine2",
+  "Bip01_Spine3",
+  "Dog",
+  "EyesBlue",
+  "EyesBlue_2",
+  "Hips",
+  "Mouth",
+  "Skin",
+  "Skin_2",
+  "Skin_3",
+  "Tunge",
+  "_Bip01_Head11_TungeControler",
+  "_Bip01_Ponytail3_tunge"
+ ],
+ "Dog2": [
+  "Bip01_Head",
+  "Bip01_Head1_Jaw",
+  "Bip01_Head2_Eyeleds",
+  "Bip01_Head_JawNub",
+  "Bip01_Head_Muzzle",
+  "Bip01_L_Calf",
+  "Bip01_L_Clavicle",
+  "Bip01_L_Finger0",
+  "Bip01_L_Finger01",
+  "Bip01_L_Foot",
+  "Bip01_L_Forearm",
+  "Bip01_L_Hand",
+  "Bip01_L_Thigh",
+  "Bip01_L_Toe0",
+  "Bip01_L_Toe01",
+  "Bip01_L_Toe02",
+  "Bip01_L_UpperArm",
+  "Bip01_Neck",
+  "Bip01_Neck1",
+  "Bip01_Neck2",
+  "Bip01_Pelvis",
+  "Bip01_Ponytail1",
+  "Bip01_Ponytail11",
+  "Bip01_Ponytail2",
+  "Bip01_Ponytail21",
+  "Bip01_Ponytail31",
+  "Bip01_Ponytail32",
+  "Bip01_Ponytail3Nub",
+  "Bip01_R_Calf",
+  "Bip01_R_Clavicle",
+  "Bip01_R_Finger0",
+  "Bip01_R_Finger01",
+  "Bip01_R_Foot",
+  "Bip01_R_Forearm",
+  "Bip01_R_Hand",
+  "Bip01_R_Thigh",
+  "Bip01_R_Toe0",
+  "Bip01_R_Toe01",
+  "Bip01_R_Toe02",
+  "Bip01_R_UpperArm",
+  "Bip01_Spine",
+  "Bip01_Spine0",
+  "Bip01_Spine0_Tail",
+  "Bip01_Spine0_Tail1",
+  "Bip01_Spine0_Tail2",
+  "Bip01_Spine0_Tail3",
+  "Bip01_Spine0_Tail4",
+  "Bip01_Spine1",
+  "Bip01_Spine2",
+  "Bip01_Spine3",
+  "Dog",
+  "EyesBlue",
+  "EyesBlue_2",
+  "Hips",
+  "Skin",
+  "Skin_1",
+  "Skin_10",
+  "Skin_105",
+  "Skin_11",
+  "Skin_12",
+  "Skin_126",
+  "Skin_13",
+  "Skin_14",
+  "Skin_147",
+  "Skin_15",
+  "Skin_16",
+  "Skin_168",
+  "Skin_17",
+  "Skin_18",
+  "Skin_189",
+  "Skin_19",
+  "Skin_2",
+  "Skin_20",
+  "Skin_2010",
+  "Skin_21",
+  "Skin_22",
+  "Skin_2211",
+  "Skin_23",
+  "Skin_24",
+  "Skin_2412",
+  "Skin_25",
+  "Skin_26",
+  "Skin_2613",
+  "Skin_27",
+  "Skin_28",
+  "Skin_2814",
+  "Skin_29",
+  "Skin_3",
+  "Skin_30",
+  "Skin_3015",
+  "Skin_31",
+  "Skin_32",
+  "Skin_3216",
+  "Skin_33",
+  "Skin_336",
+  "Skin_34",
+  "Skin_3417",
+  "Skin_35",
+  "Skin_36",
+  "Skin_3618",
+  "Skin_38",
+  "Skin_4",
+  "Skin_40",
+  "Skin_401",
+  "Skin_42",
+  "Skin_44",
+  "Skin_46",
+  "Skin_48",
+  "Skin_5",
+  "Skin_50",
+  "Skin_52",
+  "Skin_54",
+  "Skin_56",
+  "Skin_58",
+  "Skin_6",
+  "Skin_60",
+  "Skin_62",
+  "Skin_623",
+  "Skin_64",
+  "Skin_66",
+  "Skin_68",
+  "Skin_7",
+  "Skin_70",
+  "Skin_72",
+  "Skin_74",
+  "Skin_8",
+  "Skin_84",
+  "Skin_9",
+  "Tunge",
+  "_Bip01_Head11_TungeControler",
+  "_Bip01_Ponytail3_tunge"
+ ],
+ "Dragon": [
+  "BN_FBeard01",
+  "BN_FBeard02",
+  "BN_Feelers01",
+  "BN_Feelers02",
+  "BN_Feelers03",
+  "BN_Feelers04",
+  "BN_Feelers05",
+  "BN_Feelers06",
+  "BN_Feelers07",
+  "BN_Feelers08",
+  "BN_LBeard01",
+  "BN_LBeard02",
+  "BN_LBeard03",
+  "BN_LEyeball",
+  "BN_LWing01",
+  "BN_LWing02",
+  "BN_LWing03",
+  "BN_LWing04",
+  "BN_LWing11",
+  "BN_LWing12",
+  "BN_LWing13",
+  "BN_LWing14",
+  "BN_LWing21",
+  "BN_LWing22",
+  "BN_LWing31",
+  "BN_LWing32",
+  "BN_LWing33",
+  "BN_LWing41",
+  "BN_LWing42",
+  "BN_RBeard01",
+  "BN_RBeard02",
+  "BN_RBeard03",
+  "BN_REyeball",
+  "BN_RWing01",
+  "BN_RWing02",
+  "BN_RWing03",
+  "BN_RWing04",
+  "BN_RWing11",
+  "BN_RWing12",
+  "BN_RWing13",
+  "BN_RWing14",
+  "BN_RWing21",
+  "BN_RWing22",
+  "BN_RWing31",
+  "BN_RWing32",
+  "BN_RWing33",
+  "BN_RWing41",
+  "BN_Tail01",
+  "BN_Tail02",
+  "BN_Tail03",
+  "BN_Tail04",
+  "BN_Tail05",
+  "BN_Tail06",
+  "BN_Tongue01",
+  "BN_Tongue02",
+  "BN_Tongue03",
+  "BN__RWing42",
+  "Bip01_Head",
+  "Bip01_HeadNub",
+  "Bip01_Jaw",
+  "Bip01_L_Calf",
+  "Bip01_L_Clavicle",
+  "Bip01_L_Finger0",
+  "Bip01_L_Finger01",
+  "Bip01_L_Finger02",
+  "Bip01_L_Finger0Nub",
+  "Bip01_L_Finger1",
+  "Bip01_L_Finger11",
+  "Bip01_L_Finger12",
+  "Bip01_L_Finger1Nub",
+  "Bip01_L_Finger2",
+  "Bip01_L_Finger21",
+  "Bip01_L_Finger22",
+  "Bip01_L_Finger2Nub",
+  "Bip01_L_Foot",
+  "Bip01_L_Forearm",
+  "Bip01_L_Hand",
+  "Bip01_L_HorseLink",
+  "Bip01_L_Thigh",
+  "Bip01_L_Toe0",
+  "Bip01_L_Toe01",
+  "Bip01_L_Toe0Nub",
+  "Bip01_L_Toe1",
+  "Bip01_L_Toe11",
+  "Bip01_L_Toe1Nub",
+  "Bip01_L_Toe2",
+  "Bip01_L_Toe21",
+  "Bip01_L_Toe2Nub",
+  "Bip01_L_UpperArm",
+  "Bip01_Neck",
+  "Bip01_Neck1",
+  "Bip01_Neck2",
+  "Bip01_Neck3",
+  "Bip01_Pelvis",
+  "Bip01_Ponytail1Nub",
+  "Bip01_R_Calf",
+  "Bip01_R_Clavicle",
+  "Bip01_R_Finger0",
+  "Bip01_R_Finger01",
+  "Bip01_R_Finger02",
+  "Bip01_R_Finger0Nub",
+  "Bip01_R_Finger1",
+  "Bip01_R_Finger11",
+  "Bip01_R_Finger12",
+  "Bip01_R_Finger1Nub",
+  "Bip01_R_Finger2",
+  "Bip01_R_Finger21",
+  "Bip01_R_Finger22",
+  "Bip01_R_Finger2Nub",
+  "Bip01_R_Foot",
+  "Bip01_R_Forearm",
+  "Bip01_R_Hand",
+  "Bip01_R_HorseLink",
+  "Bip01_R_Thigh",
+  "Bip01_R_Toe0",
+  "Bip01_R_Toe01",
+  "Bip01_R_Toe0Nub",
+  "Bip01_R_Toe1",
+  "Bip01_R_Toe11",
+  "Bip01_R_Toe1Nub",
+  "Bip01_R_Toe2",
+  "Bip01_R_Toe21",
+  "Bip01_R_Toe2Nub",
+  "Bip01_R_UpperArm",
+  "Bip01_Spine",
+  "Bip01_Spine1",
+  "Bip01_Xtra01Nub",
+  "Bip01_Xtra02Nub",
+  "Bip01_Xtra03Nub",
+  "Bip01_Xtra04Nub",
+  "Bip01_Xtra04OppNub",
+  "Bip01_Xtra05Nub",
+  "Bip01_Xtra05OppNub",
+  "Bip01_Xtra06Nub",
+  "Bip01_Xtra06OppNub",
+  "Bip01_Xtra07Nub",
+  "Bip01_Xtra07OppNub",
+  "Bip01_Xtra08Nub",
+  "Bip01_Xtra08OppNub",
+  "Bip01_Xtra_Neck01",
+  "Bip01_Xtra_Neck02",
+  "Bip01_Xtra_Spine",
+  "Hips"
+ ],
+ "Eagle": [
+  "BN_Jaw",
+  "BN_Tai_01",
+  "BN_Tai_L_01",
+  "BN_Tai_L_02",
+  "BN_Tai_R_01",
+  "BN_Tai_R_02",
+  "BN_Toe_L_00",
+  "BN_Toe_L_01",
+  "BN_Toe_L_10",
+  "BN_Toe_L_11",
+  "BN_Toe_L_20",
+  "BN_Toe_L_21",
+  "BN_Toe_L_30",
+  "BN_Toe_L_31",
+  "BN_Toe_R_00",
+  "BN_Toe_R_01",
+  "BN_Toe_R_10",
+  "BN_Toe_R_11",
+  "BN_Toe_R_20",
+  "BN_Toe_R_21",
+  "BN_Toe_R_30",
+  "BN_Toe_R_31",
+  "BN_Wing_L_01",
+  "BN_Wing_L_02",
+  "BN_Wing_L_03",
+  "BN_Wing_L_04",
+  "BN_Wing_L_05",
+  "BN_Wing_L_06",
+  "BN_Wing_R_01",
+  "BN_Wing_R_02",
+  "BN_Wing_R_03",
+  "BN_Wing_R_04",
+  "BN_Wing_R_05",
+  "BN_Wing_R_06",
+  "Bip01_Head",
+  "Bip01_L_Calf",
+  "Bip01_L_Foot",
+  "Bip01_L_HorseLink",
+  "Bip01_L_Thigh",
+  "Bip01_L_Toe0",
+  "Bip01_Neck",
+  "Bip01_Neck1",
+  "Bip01_Neck2",
+  "Bip01_Pelvis",
+  "Bip01_R_Calf",
+  "Bip01_R_Foot",
+  "Bip01_R_HorseLink",
+  "Bip01_R_Thigh",
+  "Bip01_R_Toe0",
+  "Bip01_Spine",
+  "Bip01_Spine1",
+  "Hips"
+ ],
+ "Elephant": [
+  "AN_NPC_MOB_Elephant_A01_SK_GRN",
+  "BN_Ear_L_01",
+  "BN_Ear_L_02",
+  "BN_Ear_R_01",
+  "BN_Ear_R_02",
+  "BN_Eyebrow_L",
+  "BN_Eyebrow_R",
+  "BN_Mouth_01",
+  "BN_Nose_01",
+  "BN_Nose_02",
+  "BN_Nose_03",
+  "BN_Nose_04",
+  "BN_Nose_05",
+  "BN_Nose_06",
+  "BN_Tail_01",
+  "BN_Tail_02",
+  "BN_Tail_03",
+  "BN_Tail_04",
+  "Bip01_Head",
+  "Bip01_L_Calf",
+  "Bip01_L_Clavicle",
+  "Bip01_L_Foot",
+  "Bip01_L_Forearm",
+  "Bip01_L_Hand",
+  "Bip01_L_Thigh",
+  "Bip01_L_Toe0",
+  "Bip01_L_UpperArm",
+  "Bip01_Neck",
+  "Bip01_Pelvis",
+  "Bip01_R_Calf",
+  "Bip01_R_Clavicle",
+  "Bip01_R_Foot",
+  "Bip01_R_Forearm",
+  "Bip01_R_Hand",
+  "Bip01_R_Thigh",
+  "Bip01_R_Toe0",
+  "Bip01_R_UpperArm",
+  "Bip01_Spine",
+  "Bip01_Spine1",
+  "Bip01_Spine2",
+  "Hips",
+  "Skin"
+ ],
+ "FireAnt": [
+  "Bip01_Head",
+  "Bip01_Head_Brain",
+  "Bip01_L_Arm_Nub",
+  "Bip01_L_Calf_Mid",
+  "Bip01_L_Calf_Rear",
+  "Bip01_L_Foot_Mid",
+  "Bip01_L_Foot_Rear",
+  "Bip01_L_ForeArm",
+  "Bip01_L_Hand",
+  "Bip01_L_Leg_Mid_Nub",
+  "Bip01_L_Leg_Rear_Nub",
+  "Bip01_L_Thigh_Mid",
+  "Bip01_L_Thigh_Rear",
+  "Bip01_L_UpperArm",
+  "Bip01_Neck1",
+  "Bip01_Pelvis",
+  "Bip01_Ponytail11L_Antenna",
+  "Bip01_Ponytail12L_Antenna3",
+  "Bip01_Ponytail1_L_Antenna",
+  "Bip01_Ponytail21_R_Antenna2",
+  "Bip01_Ponytail22R_Antenna3",
+  "Bip01_Ponytail2_R_Antenna1",
+  "Bip01_Ponytail3L_Mandible_",
+  "Bip01_Ponytail4R_Mandible",
+  "Bip01_R_Arm_Nub",
+  "Bip01_R_Calf_Mid",
+  "Bip01_R_Calf_Rear",
+  "Bip01_R_Foot_Mid",
+  "Bip01_R_Foot_Rear",
+  "Bip01_R_ForeArm",
+  "Bip01_R_Hand",
+  "Bip01_R_Leg_Mid_Nub",
+  "Bip01_R_Leg_Rear_Nub",
+  "Bip01_R_Thigh_Mid",
+  "Bip01_R_Thigh_Rear",
+  "Bip01_R_UpperArm",
+  "Bip01_Spine",
+  "Bip01_Tail",
+  "Bip01_Tail01",
+  "Bip01_Tail02",
+  "Bip01_Tail03",
+  "Bip01_Tail_Nub",
+  "Dummy01_HeadFire_",
+  "Hips",
+  "ProjectileNode_Fire"
+ ],
+ "Flamingo": [
+  "BN_Forearm_L_01",
+  "BN_Forearm_L_02",
+  "BN_Forearm_L_03",
+  "BN_Forearm_L_04",
+  "BN_Forearm_R_01",
+  "BN_Forearm_R_02",
+  "BN_Forearm_R_03",
+  "BN_Forearm_R_04",
+  "BN_Mouth_01",
+  "BN_Tail_01",
+  "BN_Tail_L_01",
+  "BN_Tail_R_01",
+  "Bip01_Head",
+  "Bip01_L_Calf",
+  "Bip01_L_Foot",
+  "Bip01_L_HorseLink",
+  "Bip01_L_Thigh",
+  "Bip01_L_Toe0",
+  "Bip01_L_Toe01",
+  "Bip01_L_Toe1",
+  "Bip01_L_Toe11",
+  "Bip01_L_Toe2",
+  "Bip01_L_Toe21",
+  "Bip01_Neck",
+  "Bip01_Neck1",
+  "Bip01_Neck2",
+  "Bip01_Neck3",
+  "Bip01_Neck4",
+  "Bip01_Pelvis",
+  "Bip01_R_Calf",
+  "Bip01_R_Foot",
+  "Bip01_R_HorseLink",
+  "Bip01_R_Thigh",
+  "Bip01_R_Toe0",
+  "Bip01_R_Toe1",
+  "Bip01_R_Toe2",
+  "Bip01_Spine",
+  "Bip01_Spine1",
+  "Bone02",
+  "Bone03",
+  "Hips"
+ ],
+ "Fox": [
+  "AN_NPC_MOB_FoxA_A01_SK_LTS",
+  "BN_Ear_L_01",
+  "BN_Ear_R_01",
+  "BN_Mouth_01",
+  "BN_Tail_01",
+  "BN_Tail_02",
+  "BN_Tail_03",
+  "Bip01_Head",
+  "Bip01_HeadNub",
+  "Bip01_L_Calf",
+  "Bip01_L_Clavicle",
+  "Bip01_L_Finger0",
+  "Bip01_L_Finger01",
+  "Bip01_L_Finger0Nub",
+  "Bip01_L_Foot",
+  "Bip01_L_Forearm",
+  "Bip01_L_Hand",
+  "Bip01_L_HorseLink",
+  "Bip01_L_Thigh",
+  "Bip01_L_Toe0",
+  "Bip01_L_Toe0Nub",
+  "Bip01_L_UpperArm",
+  "Bip01_Neck",
+  "Bip01_Neck1",
+  "Bip01_Pelvis",
+  "Bip01_R_Calf",
+  "Bip01_R_Clavicle",
+  "Bip01_R_Finger0",
+  "Bip01_R_Finger01",
+  "Bip01_R_Finger0Nub",
+  "Bip01_R_Foot",
+  "Bip01_R_Forearm",
+  "Bip01_R_Hand",
+  "Bip01_R_HorseLink",
+  "Bip01_R_Thigh",
+  "Bip01_R_Toe0",
+  "Bip01_R_Toe0Nub",
+  "Bip01_R_UpperArm",
+  "Bip01_Spine",
+  "Bip01_Spine1",
+  "Hips",
+  "Skin"
+ ],
+ "Gazelle": [
+  "BN_Ear_L_01",
+  "BN_Ear_L_02",
+  "BN_Ear_R_01",
+  "BN_Ear_R_02",
+  "BN_Eye_L_01",
+  "BN_Eye_R_01",
+  "BN_Mouth_01",
+  "BN_Tail_01",
+  "BN_Tail_02",
+  "Bip01_Head",
+  "Bip01_HeadNub",
+  "Bip01_L_Calf",
+  "Bip01_L_Clavicle",
+  "Bip01_L_Finger0",
+  "Bip01_L_Finger0Nub",
+  "Bip01_L_Foot",
+  "Bip01_L_Forearm",
+  "Bip01_L_Hand",
+  "Bip01_L_HorseLink",
+  "Bip01_L_Thigh",
+  "Bip01_L_Toe0",
+  "Bip01_L_Toe0Nub",
+  "Bip01_L_UpperArm",
+  "Bip01_Neck",
+  "Bip01_Neck1",
+  "Bip01_Pelvis",
+  "Bip01_R_Calf",
+  "Bip01_R_Clavicle",
+  "Bip01_R_Finger0",
+  "Bip01_R_Finger0Nub",
+  "Bip01_R_Foot",
+  "Bip01_R_Forearm",
+  "Bip01_R_Hand",
+  "Bip01_R_HorseLink",
+  "Bip01_R_Thigh",
+  "Bip01_R_Toe0",
+  "Bip01_R_Toe0Nub",
+  "Bip01_R_UpperArm",
+  "Bip01_Spine",
+  "Bip01_Spine1",
+  "Bip01_Spine2",
+  "Hips"
+ ],
+ "Giantbee": [
+  "BN_Calf_L_01",
+  "BN_Calf_L_02",
+  "BN_Calf_R_01",
+  "BN_Calf_R_02",
+  "BN_Clip_L_01",
+  "BN_Clip_R_01",
+  "BN_Foot_L_01",
+  "BN_Foot_L_02",
+  "BN_Foot_R_01",
+  "BN_Foot_R_02",
+  "BN_Shall_L_01",
+  "BN_Shall_L_02",
+  "BN_Shall_L_03",
+  "BN_Shall_L_04",
+  "BN_Shall_L_05",
+  "BN_Shall_L_06",
+  "BN_Shall_R_01",
+  "BN_Shall_R_02",
+  "BN_Shall_R_03",
+  "BN_Shall_R_04",
+  "BN_Shall_R_05",
+  "BN_Shall_R_06",
+  "BN_Thigh_L_01",
+  "BN_Thigh_L_02",
+  "BN_Thigh_R_01",
+  "BN_Thigh_R_02",
+  "BN_Wing_L_01",
+  "BN_Wing_L_02",
+  "BN_Wing_R_01",
+  "BN_Wing_R_02",
+  "Bip01_Head",
+  "Bip01_HeadNub",
+  "Bip01_L_Calf",
+  "Bip01_L_Foot",
+  "Bip01_L_Thigh",
+  "Bip01_L_Toe0",
+  "Bip01_L_Toe0Nub",
+  "Bip01_Neck",
+  "Bip01_Pelvis",
+  "Bip01_R_Calf",
+  "Bip01_R_Foot",
+  "Bip01_R_Thigh",
+  "Bip01_R_Toe0",
+  "Bip01_R_Toe0Nub",
+  "Bip01_Spine",
+  "Bip01_Tail",
+  "Bip01_Tail1",
+  "Bip01_Tail2",
+  "Bip01_Tail3",
+  "Bip01_Tail4",
+  "Bip01_TailNub",
+  "Hips"
+ ],
+ "Goat": [
+  "BN_Mouth_01",
+  "BN_Tail_01",
+  "BN_Tail_02",
+  "BN__UpperArm_L_01",
+  "BN__UpperArm_R_01",
+  "Bip01_Head",
+  "Bip01_L_Calf",
+  "Bip01_L_Clavicle",
+  "Bip01_L_Finger0",
+  "Bip01_L_Foot",
+  "Bip01_L_Forearm",
+  "Bip01_L_Hand",
+  "Bip01_L_HorseLink",
+  "Bip01_L_Thigh",
+  "Bip01_L_Toe0",
+  "Bip01_L_UpperArm",
+  "Bip01_Neck",
+  "Bip01_Neck1",
+  "Bip01_Pelvis",
+  "Bip01_R_Calf",
+  "Bip01_R_Clavicle",
+  "Bip01_R_Finger0",
+  "Bip01_R_Foot",
+  "Bip01_R_Forearm",
+  "Bip01_R_Hand",
+  "Bip01_R_HorseLink",
+  "Bip01_R_Thigh",
+  "Bip01_R_Toe0",
+  "Bip01_R_UpperArm",
+  "Bip01_Spine",
+  "Bip01_Spine1",
+  "Hips",
+  "Null"
+ ],
+ "Hamster": [
+  "BN_Beard_L",
+  "BN_Beard_R",
+  "BN_Ear_L",
+  "BN_Ear_R",
+  "BN_Hair_L",
+  "BN_Hair_R",
+  "BN_Mascara_L",
+  "BN_Mascara_R",
+  "BN_Mouth",
+  "BN_Tail",
+  "Bip01_Head",
+  "Bip01_HeadNub",
+  "Bip01_L_Calf",
+  "Bip01_L_Clavicle",
+  "Bip01_L_Finger0",
+  "Bip01_L_Finger0Nub",
+  "Bip01_L_Foot",
+  "Bip01_L_Forearm",
+  "Bip01_L_Hand",
+  "Bip01_L_HorseLink",
+  "Bip01_L_Thigh",
+  "Bip01_L_Toe0",
+  "Bip01_L_Toe0Nub",
+  "Bip01_L_UpperArm",
+  "Bip01_Neck",
+  "Bip01_Pelvis",
+  "Bip01_R_Calf",
+  "Bip01_R_Clavicle",
+  "Bip01_R_Finger0",
+  "Bip01_R_Finger0Nub",
+  "Bip01_R_Foot",
+  "Bip01_R_Forearm",
+  "Bip01_R_Hand",
+  "Bip01_R_HorseLink",
+  "Bip01_R_Thigh",
+  "Bip01_R_Toe0",
+  "Bip01_R_Toe0Nub",
+  "Bip01_R_UpperArm",
+  "Bip01_Spine",
+  "Bip01_Spine1",
+  "Bip01_Spine2",
+  "Hips"
+ ],
+ "HermitCrab": [
+  "BN_Body_01",
+  "BN_Body_02",
+  "BN_Crab_pincers_L_01",
+  "BN_Crab_pincers_L_02",
+  "BN_Crab_pincers_L_03",
+  "BN_Crab_pincers_L_04",
+  "BN_Crab_pincers_R_01",
+  "BN_Crab_pincers_R_02",
+  "BN_Crab_pincers_R_03",
+  "BN_Crab_pincers_R_04",
+  "BN_Eye_L_01",
+  "BN_Eye_R_01",
+  "BN_Head",
+  "BN_Leg_L_07",
+  "BN_Leg_L_08",
+  "BN_Leg_L_09",
+  "BN_Leg_L_10",
+  "BN_Leg_L_11",
+  "BN_Leg_L_12",
+  "BN_Leg_L_13",
+  "BN_Leg_L_14",
+  "BN_Leg_L_15",
+  "BN_Leg_R_07",
+  "BN_Leg_R_08",
+  "BN_Leg_R_09",
+  "BN_Leg_R_10",
+  "BN_Leg_R_11",
+  "BN_Leg_R_12",
+  "BN_Leg_R_13",
+  "BN_Leg_R_14",
+  "BN_Leg_R_15",
+  "BN_Piers_L_01",
+  "BN_Piers_L_02",
+  "BN_Piers_L_03",
+  "BN_Piers_R_01",
+  "BN_Piers_R_02",
+  "BN_Piers_R_03",
+  "BN_Shell",
+  "BN_Tentacles_L_01",
+  "BN_Tentacles_L_02",
+  "BN_Tentacles_L_03",
+  "BN_Tentacles_L_04",
+  "BN_Tentacles_L_05",
+  "BN_Tentacles_L_06",
+  "BN_Tentacles_L_07",
+  "BN_Tentacles_L_08",
+  "BN_Tentacles_R_01",
+  "BN_Tentacles_R_02",
+  "BN_Tentacles_R_03",
+  "BN_Tentacles_R_04",
+  "BN_Tentacles_R_05",
+  "BN_Tentacles_R_06",
+  "BN_Tentacles_R_07",
+  "BN_Tentacles_R_08",
+  "BN_leg_L_01",
+  "BN_leg_L_02",
+  "BN_leg_L_03",
+  "BN_leg_L_04",
+  "BN_leg_L_05",
+  "BN_leg_L_06",
+  "BN_leg_R_01",
+  "BN_leg_R_02",
+  "BN_leg_R_03",
+  "BN_leg_R_04",
+  "BN_leg_R_05",
+  "BN_leg_R_06",
+  "Hips"
+ ],
+ "Hippopotamus": [
+  "BN_Downbody",
+  "BN_Ear_L",
+  "BN_Ear_R",
+  "BN_Eye_L",
+  "BN_Eye_R",
+  "BN_Jaw",
+  "BN_Tail_01",
+  "BN_Tail_02",
+  "BN_Tail_03",
+  "Bip01_Head",
+  "Bip01_HeadNub",
+  "Bip01_L_Calf",
+  "Bip01_L_Clavicle",
+  "Bip01_L_Finger0",
+  "Bip01_L_Finger0Nub",
+  "Bip01_L_Foot",
+  "Bip01_L_Forearm",
+  "Bip01_L_Hand",
+  "Bip01_L_HorseLink",
+  "Bip01_L_Thigh",
+  "Bip01_L_Toe0",
+  "Bip01_L_Toe0Nub",
+  "Bip01_L_UpperArm",
+  "Bip01_Neck",
+  "Bip01_Pelvis",
+  "Bip01_R_Calf",
+  "Bip01_R_Clavicle",
+  "Bip01_R_Finger0",
+  "Bip01_R_Finger0Nub",
+  "Bip01_R_Foot",
+  "Bip01_R_Forearm",
+  "Bip01_R_Hand",
+  "Bip01_R_HorseLink",
+  "Bip01_R_Thigh",
+  "Bip01_R_Toe0",
+  "Bip01_R_Toe0Nub",
+  "Bip01_R_UpperArm",
+  "Bip01_Spine",
+  "Bip01_Spine1",
+  "Bip01_Spine2",
+  "Hips"
+ ],
+ "Horse": [
+  "BN_Eyebrow_L",
+  "BN_Eyebrow_R",
+  "BN_Halter_L_01",
+  "BN_Halter_L_02",
+  "BN_Halter_R_01",
+  "BN_Halter_R_02",
+  "BN_Reins_01",
+  "BN_Reins_02",
+  "BN_Reins_03",
+  "BN_Reins_04",
+  "BN_Reins_05",
+  "BN_Reins_06",
+  "BN_Tail_01",
+  "BN_Tail_02",
+  "BN_Tail_03",
+  "BN_Tail_04",
+  "BN_Tail_05",
+  "BN_center",
+  "BN_hair01_01",
+  "BN_hair01_02",
+  "BN_hair02_01",
+  "BN_hair02_02",
+  "BN_hair02_03",
+  "BN_hair03_01",
+  "BN_hair03_02",
+  "BN_hair03_03",
+  "BN_hair04_01",
+  "BN_hair04_02",
+  "BN_hair04_03",
+  "Bip01",
+  "Bip01_Head",
+  "Bip01_HeadNub",
+  "Bip01_Jaw",
+  "Bip01_L_Calf",
+  "Bip01_L_Clavicle",
+  "Bip01_L_Finger0",
+  "Bip01_L_Finger0Nub",
+  "Bip01_L_Foot",
+  "Bip01_L_Forearm",
+  "Bip01_L_Hand",
+  "Bip01_L_HorseLink",
+  "Bip01_L_Thigh",
+  "Bip01_L_Toe0",
+  "Bip01_L_Toe0Nub",
+  "Bip01_L_UpperArm",
+  "Bip01_Neck",
+  "Bip01_Neck1",
+  "Bip01_Pelvis",
+  "Bip01_Ponytail1Nub",
+  "Bip01_R_Calf",
+  "Bip01_R_Clavicle",
+  "Bip01_R_Ear_01",
+  "Bip01_R_Finger0",
+  "Bip01_R_Finger0Nub",
+  "Bip01_R_Foot",
+  "Bip01_R_Forearm",
+  "Bip01_R_Hand",
+  "Bip01_R_HorseLink",
+  "Bip01_R_Thigh",
+  "Bip01_R_Toe0",
+  "Bip01_R_Toe0Nub",
+  "Bip01_R_UpperArm",
+  "Bip01_Spine",
+  "Bip01_Spine1",
+  "Bip01_Spine2",
+  "Bip01_Xtra01",
+  "Bip01_Xtra01Nub",
+  "Bip01_Xtra02",
+  "Bip01_Xtra02Nub",
+  "Bip01_Xtra03Nub",
+  "Bip01_Xtra04Nub",
+  "Bip01_Xtra05Nub",
+  "Bip01_Xtra06Nub",
+  "Bip01__L_Ear_01",
+  "C_ctrl",
+  "Handle",
+  "Hips",
+  "IK_Chain01",
+  "Saddle"
+ ],
+ "Hound": [
+  "BN_Chin_01",
+  "BN_Ear_L_01",
+  "BN_Ear_R_01",
+  "BN_Eyelid_L_01",
+  "BN_Eyelid_R_01",
+  "BN_Mouth_L_01",
+  "BN_Mouth_R_01",
+  "BN_Nose_01",
+  "BN_Tail_01",
+  "BN_Tongue_01",
+  "BN_Tongue_02",
+  "BN_Tongue_03",
+  "Bip01_Head",
+  "Bip01_HeadNub",
+  "Bip01_L_Calf",
+  "Bip01_L_Clavicle",
+  "Bip01_L_Finger0",
+  "Bip01_L_Finger0Nub",
+  "Bip01_L_Foot",
+  "Bip01_L_Forearm",
+  "Bip01_L_Hand",
+  "Bip01_L_HorseLink",
+  "Bip01_L_Thigh",
+  "Bip01_L_Toe0",
+  "Bip01_L_Toe0Nub",
+  "Bip01_L_UpperArm",
+  "Bip01_Neck",
+  "Bip01_Neck1",
+  "Bip01_Pelvis",
+  "Bip01_R_Calf",
+  "Bip01_R_Clavicle",
+  "Bip01_R_Finger0",
+  "Bip01_R_Finger0Nub",
+  "Bip01_R_Foot",
+  "Bip01_R_Forearm",
+  "Bip01_R_Hand",
+  "Bip01_R_HorseLink",
+  "Bip01_R_Thigh",
+  "Bip01_R_Toe0",
+  "Bip01_R_Toe0Nub",
+  "Bip01_R_UpperArm",
+  "Bip01_Spine",
+  "Bip01_Spine1",
+  "Bip01_Spine2",
+  "Hips"
+ ],
+ "Isopetra": [
+  "BN_Feeler_L_01",
+  "BN_Feeler_L_02",
+  "BN_Feeler_L_03",
+  "BN_Feeler_L_04",
+  "BN_Feeler_L_05",
+  "BN_Feeler_R_01",
+  "BN_Feeler_R_02",
+  "BN_Feeler_R_03",
+  "BN_Feeler_R_04",
+  "BN_Feeler_R_05",
+  "BN_Mouth_L_01",
+  "BN_Mouth_R_01",
+  "BN_Tail_01",
+  "BN_Tail_02",
+  "BN_Tail_03",
+  "BN_leg_L_01",
+  "BN_leg_L_02",
+  "BN_leg_L_03",
+  "BN_leg_L_04",
+  "BN_leg_L_05",
+  "BN_leg_L_06",
+  "BN_leg_R_01",
+  "BN_leg_R_02",
+  "BN_leg_R_03",
+  "BN_leg_R_04",
+  "BN_leg_R_05",
+  "BN_leg_R_06",
+  "Bip01_Head",
+  "Bip01_HeadNub",
+  "Bip01_L_Calf",
+  "Bip01_L_Clavicle",
+  "Bip01_L_Finger0",
+  "Bip01_L_Finger01",
+  "Bip01_L_Finger02",
+  "Bip01_L_Finger0Nub",
+  "Bip01_L_Foot",
+  "Bip01_L_Forearm",
+  "Bip01_L_Hand",
+  "Bip01_L_HorseLink",
+  "Bip01_L_Thigh",
+  "Bip01_L_Toe0",
+  "Bip01_L_Toe01",
+  "Bip01_L_Toe0Nub",
+  "Bip01_L_UpperArm",
+  "Bip01_Neck",
+  "Bip01_Pelvis",
+  "Bip01_R_Calf",
+  "Bip01_R_Clavicle",
+  "Bip01_R_Finger0",
+  "Bip01_R_Finger01",
+  "Bip01_R_Finger02",
+  "Bip01_R_Finger0Nub",
+  "Bip01_R_Foot",
+  "Bip01_R_Forearm",
+  "Bip01_R_Hand",
+  "Bip01_R_HorseLink",
+  "Bip01_R_Thigh",
+  "Bip01_R_Toe0",
+  "Bip01_R_Toe01",
+  "Bip01_R_Toe0Nub",
+  "Bip01_R_UpperArm",
+  "Bip01_Spine",
+  "Hips"
+ ],
+ "Jaguar": [
+  "BN_Beard_L_01",
+  "BN_Beard_R_01",
+  "BN_Ear_L_01",
+  "BN_Ear_R_01",
+  "BN_Eye_L_01",
+  "BN_Eye_R_01",
+  "BN_Mouth_0",
+  "BN_Tail_01",
+  "BN_Tail_02",
+  "BN_Tail_03",
+  "BN_Tail_04",
+  "BN_Tongue_01",
+  "BN_Tongue_02",
+  "Bip01_Head",
+  "Bip01_HeadNub",
+  "Bip01_L_Calf",
+  "Bip01_L_Clavicle",
+  "Bip01_L_Finger0",
+  "Bip01_L_Finger0Nub",
+  "Bip01_L_Foot",
+  "Bip01_L_Forearm",
+  "Bip01_L_Hand",
+  "Bip01_L_HorseLink",
+  "Bip01_L_Thigh",
+  "Bip01_L_Toe0",
+  "Bip01_L_Toe0Nub",
+  "Bip01_L_UpperArm",
+  "Bip01_Neck",
+  "Bip01_Neck1",
+  "Bip01_Pelvis",
+  "Bip01_R_Calf",
+  "Bip01_R_Clavicle",
+  "Bip01_R_Finger0",
+  "Bip01_R_Finger0Nub",
+  "Bip01_R_Foot",
+  "Bip01_R_Forearm",
+  "Bip01_R_Hand",
+  "Bip01_R_HorseLink",
+  "Bip01_R_Thigh",
+  "Bip01_R_Toe0",
+  "Bip01_R_Toe0Nub",
+  "Bip01_R_UpperArm",
+  "Bip01_Spine",
+  "Bip01_Spine1",
+  "Bip01_Spine2",
+  "Hips"
+ ],
+ "Jaws": [
+  "Hips",
+  "N_ALL",
+  "_00",
+  "_01",
+  "_02",
+  "_03",
+  "_04",
+  "_05",
+  "_06",
+  "_07",
+  "_08",
+  "_09",
+  "_10",
+  "_11",
+  "_12",
+  "_13",
+  "_14",
+  "_15"
+ ],
+ "KingCobra": [
+  "BN_Head_01",
+  "BN_Mouth_01",
+  "BN_Spine_01",
+  "BN_Spine_02",
+  "BN_Spine_03",
+  "BN_Tail_01",
+  "BN_Tail_02",
+  "BN_Tail_03",
+  "BN_Tail_04",
+  "BN_Tail_05",
+  "BN_Tail_06",
+  "BN_Tail_07",
+  "BN_Tongue_01",
+  "BN_Tongue_02",
+  "BN__Neck_01",
+  "BN__Neck_02",
+  "BN__Neck_L_01",
+  "BN__Neck_R_01",
+  "Hips"
+ ],
+ "Leapord": [
+  "BN_Beard_L_01",
+  "BN_Beard_R_01",
+  "BN_Ear_L_01",
+  "BN_Ear_R_01",
+  "BN_Eye_L_01",
+  "BN_Eye_R_01",
+  "BN_Mane_01",
+  "BN_Mane_02",
+  "BN_Mane_R_01",
+  "BN_Mane_R_02",
+  "BN_Mouth_0",
+  "BN_Tail_01",
+  "BN_Tail_02",
+  "BN_Tail_03",
+  "BN_Tail_04",
+  "Bip01_Head",
+  "Bip01_HeadNub",
+  "Bip01_L_Calf",
+  "Bip01_L_Clavicle",
+  "Bip01_L_Finger0",
+  "Bip01_L_Finger0Nub",
+  "Bip01_L_Foot",
+  "Bip01_L_Forearm",
+  "Bip01_L_Hand",
+  "Bip01_L_HorseLink",
+  "Bip01_L_Thigh",
+  "Bip01_L_Toe0",
+  "Bip01_L_Toe0Nub",
+  "Bip01_L_UpperArm",
+  "Bip01_Neck",
+  "Bip01_Neck1",
+  "Bip01_Pelvis",
+  "Bip01_R_Calf",
+  "Bip01_R_Clavicle",
+  "Bip01_R_Finger0",
+  "Bip01_R_Finger0Nub",
+  "Bip01_R_Foot",
+  "Bip01_R_Forearm",
+  "Bip01_R_Hand",
+  "Bip01_R_HorseLink",
+  "Bip01_R_Thigh",
+  "Bip01_R_Toe0",
+  "Bip01_R_Toe0Nub",
+  "Bip01_R_UpperArm",
+  "Bip01_Spine",
+  "Bip01_Spine1",
+  "Bip01_Spine2",
+  "Hips"
+ ],
+ "Lion": [
+  "BN_Mouth_01",
+  "BN_Tail_01",
+  "BN_Tail_02",
+  "BN_Tail_03",
+  "BN_Tail_04",
+  "Bip01_Head",
+  "Bip01_L_Calf",
+  "Bip01_L_Clavicle",
+  "Bip01_L_Finger0",
+  "Bip01_L_Foot",
+  "Bip01_L_Forearm",
+  "Bip01_L_Hand",
+  "Bip01_L_HorseLink",
+  "Bip01_L_Thigh",
+  "Bip01_L_Toe0",
+  "Bip01_L_UpperArm",
+  "Bip01_Neck",
+  "Bip01_Neck1",
+  "Bip01_Pelvis",
+  "Bip01_R_Calf",
+  "Bip01_R_Clavicle",
+  "Bip01_R_Finger0",
+  "Bip01_R_Foot",
+  "Bip01_R_Forearm",
+  "Bip01_R_Hand",
+  "Bip01_R_HorseLink",
+  "Bip01_R_Thigh",
+  "Bip01_R_Toe0",
+  "Bip01_R_UpperArm",
+  "Bip01_Spine",
+  "Bip01_Spine1",
+  "Hips"
+ ],
+ "Lynx": [
+  "BN_Beard_L_01",
+  "BN_Beard_R_01",
+  "BN_Ear_L_01",
+  "BN_Ear_L_02",
+  "BN_Ear_R_01",
+  "BN_Ear_R_02",
+  "BN_Mouth_01",
+  "Bip01_Head",
+  "Bip01_HeadNub",
+  "Bip01_L_Calf",
+  "Bip01_L_Clavicle",
+  "Bip01_L_Finger0",
+  "Bip01_L_Finger0Nub",
+  "Bip01_L_Foot",
+  "Bip01_L_Forearm",
+  "Bip01_L_Hand",
+  "Bip01_L_HorseLink",
+  "Bip01_L_Thigh",
+  "Bip01_L_Toe0",
+  "Bip01_L_Toe0Nub",
+  "Bip01_L_UpperArm",
+  "Bip01_Neck",
+  "Bip01_Pelvis",
+  "Bip01_R_Calf",
+  "Bip01_R_Clavicle",
+  "Bip01_R_Finger0",
+  "Bip01_R_Finger0Nub",
+  "Bip01_R_Foot",
+  "Bip01_R_Forearm",
+  "Bip01_R_Hand",
+  "Bip01_R_HorseLink",
+  "Bip01_R_Thigh",
+  "Bip01_R_Toe0",
+  "Bip01_R_Toe0Nub",
+  "Bip01_R_UpperArm",
+  "Bip01_Spine",
+  "Bip01_Spine1",
+  "Bip01_Spine2",
+  "Hips"
+ ],
+ "Mammoth": [
+  "BN_Ear_L_01",
+  "BN_Ear_R_01",
+  "BN_Eyebrow_L",
+  "BN_Eyebrow_R",
+  "BN_Fur_01",
+  "BN_Fur_02",
+  "BN_Fur_03",
+  "BN_Mouth_01",
+  "BN_Nose_01",
+  "BN_Nose_02",
+  "BN_Nose_03",
+  "BN_Nose_04",
+  "BN_Nose_05",
+  "BN_Nose_06",
+  "BN_Nose_07",
+  "BN_Tail_01",
+  "BN_Tail_02",
+  "BN_Tail_03",
+  "BN_Tail_04",
+  "Bip01_Head",
+  "Bip01_L_Calf",
+  "Bip01_L_Clavicle",
+  "Bip01_L_Foot",
+  "Bip01_L_Forearm",
+  "Bip01_L_Hand",
+  "Bip01_L_Thigh",
+  "Bip01_L_Toe0",
+  "Bip01_L_UpperArm",
+  "Bip01_Neck",
+  "Bip01_Pelvis",
+  "Bip01_R_Calf",
+  "Bip01_R_Clavicle",
+  "Bip01_R_Foot",
+  "Bip01_R_Forearm",
+  "Bip01_R_Hand",
+  "Bip01_R_Thigh",
+  "Bip01_R_Toe0",
+  "Bip01_R_UpperArm",
+  "Bip01_Spine",
+  "Bip01_Spine1",
+  "Bip01_Spine2",
+  "Hips"
+ ],
+ "Monkey": [
+  "BN_Beard_L",
+  "BN_Beard_R",
+  "BN_Lip_01",
+  "BN_Lip_02",
+  "BN_Mouth",
+  "BN_Tail_01",
+  "BN_Tail_02",
+  "BN_Tail_03",
+  "BN_Tail_04",
+  "BN_Tail_05",
+  "BN_Tail_06",
+  "BN_Tail_07",
+  "BN_eyelid_L",
+  "BN_eyelid_R",
+  "Bip01_Head",
+  "Bip01_HeadNub",
+  "Bip01_L_Calf",
+  "Bip01_L_Clavicle",
+  "Bip01_L_Finger0",
+  "Bip01_L_Finger01",
+  "Bip01_L_Finger02",
+  "Bip01_L_Finger0Nub",
+  "Bip01_L_Finger1",
+  "Bip01_L_Finger11",
+  "Bip01_L_Finger12",
+  "Bip01_L_Finger1Nub",
+  "Bip01_L_Finger2",
+  "Bip01_L_Finger21",
+  "Bip01_L_Finger22",
+  "Bip01_L_Finger2Nub",
+  "Bip01_L_Finger3",
+  "Bip01_L_Finger31",
+  "Bip01_L_Finger32",
+  "Bip01_L_Finger3Nub",
+  "Bip01_L_Foot",
+  "Bip01_L_Forearm",
+  "Bip01_L_Hand",
+  "Bip01_L_Thigh",
+  "Bip01_L_Toe0",
+  "Bip01_L_Toe01",
+  "Bip01_L_Toe0Nub",
+  "Bip01_L_Toe1",
+  "Bip01_L_Toe11",
+  "Bip01_L_Toe1Nub",
+  "Bip01_L_Toe2",
+  "Bip01_L_Toe21",
+  "Bip01_L_Toe2Nub",
+  "Bip01_L_UpperArm",
+  "Bip01_Neck",
+  "Bip01_Pelvis",
+  "Bip01_R_Calf",
+  "Bip01_R_Clavicle",
+  "Bip01_R_Finger0",
+  "Bip01_R_Finger01",
+  "Bip01_R_Finger02",
+  "Bip01_R_Finger0Nub",
+  "Bip01_R_Finger1",
+  "Bip01_R_Finger11",
+  "Bip01_R_Finger12",
+  "Bip01_R_Finger1Nub",
+  "Bip01_R_Finger2",
+  "Bip01_R_Finger21",
+  "Bip01_R_Finger22",
+  "Bip01_R_Finger2Nub",
+  "Bip01_R_Finger3",
+  "Bip01_R_Finger31",
+  "Bip01_R_Finger32",
+  "Bip01_R_Finger3Nub",
+  "Bip01_R_Foot",
+  "Bip01_R_Forearm",
+  "Bip01_R_Hand",
+  "Bip01_R_Thigh",
+  "Bip01_R_Toe0",
+  "Bip01_R_Toe01",
+  "Bip01_R_Toe0Nub",
+  "Bip01_R_Toe1",
+  "Bip01_R_Toe11",
+  "Bip01_R_Toe1Nub",
+  "Bip01_R_Toe2",
+  "Bip01_R_Toe21",
+  "Bip01_R_Toe2Nub",
+  "Bip01_R_UpperArm",
+  "Bip01_Spine",
+  "Bip01_Spine1",
+  "Bip01_Spine2",
+  "Hips",
+  "Monkey_A01",
+  "Skin"
+ ],
+ "Ostrich": [
+  "BN_Eye_L_01",
+  "BN_Eye_R_01",
+  "BN_Forearm_L_01",
+  "BN_Forearm_L_02",
+  "BN_Forearm_L_03",
+  "BN_Forearm_L_04",
+  "BN_Forearm_L_05",
+  "BN_Forearm_L_06",
+  "BN_Forearm_L_07",
+  "BN_Forearm_L_08",
+  "BN_Forearm_R_01",
+  "BN_Forearm_R_02",
+  "BN_Forearm_R_03",
+  "BN_Forearm_R_04",
+  "BN_Forearm_R_05",
+  "BN_Forearm_R_06",
+  "BN_Forearm_R_07",
+  "BN_Forearm_R_08",
+  "BN_Mouth_01",
+  "BN_Tail_01",
+  "BN_Tail_02",
+  "BN_Tail_03",
+  "BN_Tail_04",
+  "Bip01_Head",
+  "Bip01_HeadNub",
+  "Bip01_L_Calf",
+  "Bip01_L_Foot",
+  "Bip01_L_HorseLink",
+  "Bip01_L_Thigh",
+  "Bip01_L_Toe0",
+  "Bip01_L_Toe01",
+  "Bip01_L_Toe0Nub",
+  "Bip01_L_Toe1",
+  "Bip01_L_Toe11",
+  "Bip01_L_Toe1Nub",
+  "Bip01_Neck",
+  "Bip01_Neck1",
+  "Bip01_Neck2",
+  "Bip01_Neck3",
+  "Bip01_Neck4",
+  "Bip01_Pelvis",
+  "Bip01_R_Calf",
+  "Bip01_R_Foot",
+  "Bip01_R_HorseLink",
+  "Bip01_R_Thigh",
+  "Bip01_R_Toe0",
+  "Bip01_R_Toe01",
+  "Bip01_R_Toe0Nub",
+  "Bip01_R_Toe1",
+  "Bip01_R_Toe11",
+  "Bip01_R_Toe1Nub",
+  "Bip01_Spine",
+  "Bip01_Spine1",
+  "Hips"
+ ],
+ "Parrot": [
+  "BN_Eye_L_01",
+  "BN_Eye_L_02",
+  "BN_Eye_R_01",
+  "BN_Eye_R_02",
+  "BN_Fur_01",
+  "BN_Fur_02",
+  "BN_Fur_03",
+  "BN_Fur_04",
+  "BN_Fur_05",
+  "BN_Jaw",
+  "BN_Tail_01",
+  "BN_Tail_02",
+  "BN_Tail_03",
+  "BN_Tail_04",
+  "BN_Tail_05",
+  "BN_Tail_06",
+  "BN_Tail_07",
+  "BN_Wing_L_01",
+  "BN_Wing_L_02",
+  "BN_Wing_L_03",
+  "BN_Wing_L_04",
+  "BN_Wing_L_05",
+  "BN_Wing_L_06",
+  "BN_Wing_L_07",
+  "BN_Wing_R_01",
+  "BN_Wing_R_02",
+  "BN_Wing_R_03",
+  "BN_Wing_R_04",
+  "BN_Wing_R_05",
+  "BN_Wing_R_06",
+  "BN_Wing_R_07",
+  "Bip01_Head",
+  "Bip01_HeadNub",
+  "Bip01_L_Calf",
+  "Bip01_L_Foot",
+  "Bip01_L_HorseLink",
+  "Bip01_L_Thigh",
+  "Bip01_L_Toe0",
+  "Bip01_L_Toe01",
+  "Bip01_L_Toe0Nub",
+  "Bip01_L_Toe1",
+  "Bip01_L_Toe11",
+  "Bip01_L_Toe1Nub",
+  "Bip01_L_Toe2",
+  "Bip01_L_Toe21",
+  "Bip01_L_Toe2Nub",
+  "Bip01_L_Toe3",
+  "Bip01_L_Toe31",
+  "Bip01_L_Toe3Nub",
+  "Bip01_Neck",
+  "Bip01_Neck1",
+  "Bip01_Pelvis",
+  "Bip01_R_Calf",
+  "Bip01_R_Foot",
+  "Bip01_R_HorseLink",
+  "Bip01_R_Thigh",
+  "Bip01_R_Toe0",
+  "Bip01_R_Toe01",
+  "Bip01_R_Toe0Nub",
+  "Bip01_R_Toe1",
+  "Bip01_R_Toe11",
+  "Bip01_R_Toe1Nub",
+  "Bip01_R_Toe2",
+  "Bip01_R_Toe21",
+  "Bip01_R_Toe2Nub",
+  "Bip01_R_Toe3",
+  "Bip01_R_Toe31",
+  "Bip01_R_Toe3Nub",
+  "Bip01_Spine",
+  "Bip01_Spine1",
+  "Hips"
+ ],
+ "Parrot2": [
+  "BN_Eye_L_01",
+  "BN_Eye_L_02",
+  "BN_Eye_R_02",
+  "BN_Jaw",
+  "BN_Tail_01",
+  "BN_Tail_02",
+  "BN_Tail_03",
+  "BN_Tail_04",
+  "BN_Tail_05",
+  "BN_Wing_L_01",
+  "BN_Wing_L_02",
+  "BN_Wing_L_03",
+  "BN_Wing_L_04",
+  "BN_Wing_L_05",
+  "BN_Wing_L_06",
+  "BN_Wing_L_07",
+  "BN_Wing_R_01",
+  "BN_Wing_R_02",
+  "BN_Wing_R_03",
+  "BN_Wing_R_04",
+  "BN_Wing_R_05",
+  "BN_Wing_R_06",
+  "BN_Wing_R_07",
+  "Bip01_Head",
+  "Bip01_HeadNub",
+  "Bip01_L_Calf",
+  "Bip01_L_Foot",
+  "Bip01_L_HorseLink",
+  "Bip01_L_Thigh",
+  "Bip01_L_Toe0",
+  "Bip01_L_Toe01",
+  "Bip01_L_Toe0Nub",
+  "Bip01_L_Toe1",
+  "Bip01_L_Toe11",
+  "Bip01_L_Toe1Nub",
+  "Bip01_L_Toe2",
+  "Bip01_L_Toe21",
+  "Bip01_L_Toe2Nub",
+  "Bip01_L_Toe3",
+  "Bip01_L_Toe31",
+  "Bip01_L_Toe3Nub",
+  "Bip01_Neck",
+  "Bip01_Neck1",
+  "Bip01_Pelvis",
+  "Bip01_R_Calf",
+  "Bip01_R_Foot",
+  "Bip01_R_HorseLink",
+  "Bip01_R_Thigh",
+  "Bip01_R_Toe0",
+  "Bip01_R_Toe01",
+  "Bip01_R_Toe0Nub",
+  "Bip01_R_Toe1",
+  "Bip01_R_Toe11",
+  "Bip01_R_Toe1Nub",
+  "Bip01_R_Toe2",
+  "Bip01_R_Toe21",
+  "Bip01_R_Toe2Nub",
+  "Bip01_R_Toe3",
+  "Bip01_R_Toe31",
+  "Bip01_R_Toe3Nub",
+  "Bip01_Spine",
+  "Bip01_Spine1",
+  "Hips"
+ ],
+ "Pigeon": [
+  "Hips",
+  "LeftArm",
+  "LeftForeArm",
+  "LeftLeg",
+  "RightArm",
+  "RightForeArm",
+  "RightLeg",
+  "Spine",
+  "Tail01"
+ ],
+ "Pirrana": [
+  "Hips",
+  "N_ALL",
+  "ago",
+  "atama",
+  "eraL",
+  "eraR",
+  "harabireL",
+  "harabireR",
+  "kosi",
+  "locator",
+  "munabireL",
+  "munabireR",
+  "mune",
+  "obire",
+  "obireA",
+  "obireB",
+  "sebire",
+  "shippoA",
+  "shippoB",
+  "shiribire",
+  "shiribireA",
+  "shirihireB"
+ ],
+ "PolarBear": [
+  "BN_Ear_L",
+  "BN_Ear_R",
+  "BN_Eye_L",
+  "BN_Eye_R",
+  "BN_Mouth",
+  "BN_Tail_01",
+  "BN_Toe_L",
+  "BN_Toe_R",
+  "BN_Tongue_01",
+  "BN_Tongue_02",
+  "Bip01_Head",
+  "Bip01_HeadNub",
+  "Bip01_L_Calf",
+  "Bip01_L_Clavicle",
+  "Bip01_L_Finger0",
+  "Bip01_L_Finger0Nub",
+  "Bip01_L_Foot",
+  "Bip01_L_Forearm",
+  "Bip01_L_Hand",
+  "Bip01_L_Thigh",
+  "Bip01_L_Toe0",
+  "Bip01_L_Toe0Nub",
+  "Bip01_L_UpperArm",
+  "Bip01_Neck",
+  "Bip01_Neck1",
+  "Bip01_Pelvis",
+  "Bip01_R_Calf",
+  "Bip01_R_Clavicle",
+  "Bip01_R_Finger0",
+  "Bip01_R_Finger0Nub",
+  "Bip01_R_Foot",
+  "Bip01_R_Forearm",
+  "Bip01_R_Hand",
+  "Bip01_R_Thigh",
+  "Bip01_R_Toe0",
+  "Bip01_R_Toe0Nub",
+  "Bip01_R_UpperArm",
+  "Bip01_Spine",
+  "Bip01_Spine1",
+  "Bip01_Spine2",
+  "Hips"
+ ],
+ "PolarBearB": [
+  "BN_Ear_L",
+  "BN_Ear_R",
+  "BN_Eye_L",
+  "BN_Eye_R",
+  "BN_Mouth",
+  "BN_P",
+  "BN_Tail",
+  "BN_Tongue_01",
+  "BN_Tongue_02",
+  "Bip01_Head",
+  "Bip01_HeadNub",
+  "Bip01_L_Calf",
+  "Bip01_L_Clavicle",
+  "Bip01_L_Finger0",
+  "Bip01_L_Finger0Nub",
+  "Bip01_L_Foot",
+  "Bip01_L_Forearm",
+  "Bip01_L_Hand",
+  "Bip01_L_Thigh",
+  "Bip01_L_Toe0",
+  "Bip01_L_Toe0Nub",
+  "Bip01_L_UpperArm",
+  "Bip01_Neck",
+  "Bip01_Pelvis",
+  "Bip01_R_Calf",
+  "Bip01_R_Clavicle",
+  "Bip01_R_Finger0",
+  "Bip01_R_Finger0Nub",
+  "Bip01_R_Foot",
+  "Bip01_R_Forearm",
+  "Bip01_R_Hand",
+  "Bip01_R_Thigh",
+  "Bip01_R_Toe0",
+  "Bip01_R_Toe0Nub",
+  "Bip01_R_UpperArm",
+  "Bip01_Spine",
+  "Bip01_Spine1",
+  "Bip01_Spine2",
+  "Hips"
+ ],
+ "Pteranodon": [
+  "Hips",
+  "jt_ClawBack2_L",
+  "jt_ClawBack2_R",
+  "jt_ClawBack_L",
+  "jt_ClawBack_R",
+  "jt_ClawInner2_L",
+  "jt_ClawInner2_R",
+  "jt_ClawInner_L",
+  "jt_ClawInner_R",
+  "jt_ClawMiddle2_L",
+  "jt_ClawMiddle2_R",
+  "jt_ClawMiddle_L",
+  "jt_ClawMiddle_R",
+  "jt_ClawOutter2_L",
+  "jt_ClawOutter2_R",
+  "jt_ClawOutter_L",
+  "jt_ClawOutter_R",
+  "jt_Cog_C",
+  "jt_ElbowBack_L",
+  "jt_ElbowBack_R",
+  "jt_Elbow_L",
+  "jt_Elbow_R",
+  "jt_Eye_L",
+  "jt_Eye_R",
+  "jt_Foot_L",
+  "jt_Foot_R",
+  "jt_Head_C",
+  "jt_Hips_C",
+  "jt_Jaw_C",
+  "jt_Knee_L",
+  "jt_Knee_R",
+  "jt_Neck1_C",
+  "jt_Neck2_C",
+  "jt_Neck3_C",
+  "jt_Shoulder_L",
+  "jt_Shoulder_R",
+  "jt_Spine1_C",
+  "jt_Spine2_C",
+  "jt_Thigh_L",
+  "jt_Thigh_R",
+  "jt_WristBack_L",
+  "jt_WristBack_R",
+  "jt_Wrist_L",
+  "jt_Wrist_R"
+ ],
+ "Puppy": [
+  "BN_Ear_L_01",
+  "BN_Ear_R_01",
+  "BN_Mouth_01",
+  "BN_Tail_01",
+  "BN_Tail_02",
+  "BN_Tail_03",
+  "BN_Tongue_01",
+  "BN_Tongue_02",
+  "Bip01_Head",
+  "Bip01_HeadNub",
+  "Bip01_L_Calf",
+  "Bip01_L_Clavicle",
+  "Bip01_L_Finger0",
+  "Bip01_L_Finger0Nub",
+  "Bip01_L_Foot",
+  "Bip01_L_Forearm",
+  "Bip01_L_Hand",
+  "Bip01_L_HorseLink",
+  "Bip01_L_Thigh",
+  "Bip01_L_Toe0",
+  "Bip01_L_Toe0Nub",
+  "Bip01_L_UpperArm",
+  "Bip01_Neck",
+  "Bip01_Neck1",
+  "Bip01_Pelvis",
+  "Bip01_R_Calf",
+  "Bip01_R_Clavicle",
+  "Bip01_R_Finger0",
+  "Bip01_R_Finger0Nub",
+  "Bip01_R_Foot",
+  "Bip01_R_Forearm",
+  "Bip01_R_Hand",
+  "Bip01_R_HorseLink",
+  "Bip01_R_Thigh",
+  "Bip01_R_Toe0",
+  "Bip01_R_Toe0Nub",
+  "Bip01_R_UpperArm",
+  "Bip01_Spine",
+  "Bip01_Spine1",
+  "Hips"
+ ],
+ "Raindeer": [
+  "BN_Ear_L_01",
+  "BN_Ear_R_01",
+  "BN_Mouth_01",
+  "BN_Tail_01",
+  "Bip01_Head",
+  "Bip01_HeadNub",
+  "Bip01_L_Calf",
+  "Bip01_L_Clavicle",
+  "Bip01_L_Finger0",
+  "Bip01_L_Finger0Nub",
+  "Bip01_L_Foot",
+  "Bip01_L_Forearm",
+  "Bip01_L_Hand",
+  "Bip01_L_HorseLink",
+  "Bip01_L_Thigh",
+  "Bip01_L_Toe0",
+  "Bip01_L_Toe0Nub",
+  "Bip01_L_UpperArm",
+  "Bip01_Neck",
+  "Bip01_Neck1",
+  "Bip01_Pelvis",
+  "Bip01_R_Calf",
+  "Bip01_R_Clavicle",
+  "Bip01_R_Finger0",
+  "Bip01_R_Finger0Nub",
+  "Bip01_R_Foot",
+  "Bip01_R_Forearm",
+  "Bip01_R_Hand",
+  "Bip01_R_HorseLink",
+  "Bip01_R_Thigh",
+  "Bip01_R_Toe0",
+  "Bip01_R_Toe0Nub",
+  "Bip01_R_UpperArm",
+  "Bip01_Spine",
+  "Bip01_Spine1",
+  "Hips"
+ ],
+ "Raptor": [
+  "BN_Jaw",
+  "BN_Nose",
+  "Bip01_Head",
+  "Bip01_HeadNub",
+  "Bip01_L_Calf",
+  "Bip01_L_Foot",
+  "Bip01_L_HorseLink",
+  "Bip01_L_Thigh",
+  "Bip01_L_Toe0",
+  "Bip01_L_Toe0Nub",
+  "Bip01_Neck",
+  "Bip01_Neck1",
+  "Bip01_Neck2",
+  "Bip01_Neck3",
+  "Bip01_Pelvis",
+  "Bip01_R_Calf",
+  "Bip01_R_Foot",
+  "Bip01_R_HorseLink",
+  "Bip01_R_Thigh",
+  "Bip01_R_Toe0",
+  "Bip01_R_Toe0Nub",
+  "Bip01_Spine",
+  "Bip01_Spine1",
+  "Bip01_Spine2",
+  "Bip01_Tail",
+  "Bip01_Tail1",
+  "Bip01_Tail2",
+  "Bip01_Tail3",
+  "Bip01_TailNub",
+  "Bn_Feather_01",
+  "Bn_Feather_02",
+  "Bn_Feather_03",
+  "Bn_Feather_04",
+  "Bn_Feather_05",
+  "Bn_Feather_06",
+  "Hips"
+ ],
+ "Raptor2": [
+  "Hips",
+  "jt_Ankle_L",
+  "jt_Ankle_R",
+  "jt_Clavicle_L",
+  "jt_Clavicle_R",
+  "jt_ClawInner_L",
+  "jt_ClawInner_R",
+  "jt_ClawMiddle_L",
+  "jt_ClawMiddle_R",
+  "jt_ClawOutter_L",
+  "jt_ClawOutter_R",
+  "jt_Elbow_L",
+  "jt_Elbow_R",
+  "jt_Eye_L",
+  "jt_Eye_R",
+  "jt_FingerInner_L",
+  "jt_FingerInner_R",
+  "jt_FingerMiddle_L",
+  "jt_FingerMiddle_R",
+  "jt_FingerOutter_L",
+  "jt_FingerOutter_R",
+  "jt_Foot_L",
+  "jt_Foot_R",
+  "jt_HandClawInner_L",
+  "jt_HandClawInner_R",
+  "jt_HandClawMiddle_L",
+  "jt_HandClawMiddle_R",
+  "jt_HandClawOutter_L",
+  "jt_HandClawOutter_R",
+  "jt_Head_C",
+  "jt_Hip_L",
+  "jt_Hip_R",
+  "jt_Hips_C",
+  "jt_Jaw_C",
+  "jt_Knee_L",
+  "jt_Knee_R",
+  "jt_Neck1_C",
+  "jt_Neck2_C",
+  "jt_Neck3_C",
+  "jt_Shoulder_L",
+  "jt_Shoulder_R",
+  "jt_Spine1_C",
+  "jt_Spine2_C",
+  "jt_Tail1_C",
+  "jt_Tail2_C",
+  "jt_Tail3_C",
+  "jt_Tail4_C",
+  "jt_Tail5_C",
+  "jt_Tail6_C",
+  "jt_ThighMuscle_L",
+  "jt_ThighMuscle_R",
+  "jt_Thigh_L",
+  "jt_Thigh_R",
+  "jt_ToeInner_L",
+  "jt_ToeInner_R",
+  "jt_ToeMiddle_L",
+  "jt_ToeMiddle_R",
+  "jt_ToeOutter_L",
+  "jt_ToeOutter_R",
+  "jt_Tongue1_C",
+  "jt_Tongue2_C",
+  "jt_Wrist_L",
+  "jt_Wrist_R"
+ ],
+ "Raptor3": [
+  "Hips",
+  "jt_Ankle_L",
+  "jt_Ankle_R",
+  "jt_Clavicle_L",
+  "jt_Clavicle_R",
+  "jt_ClawInner_L",
+  "jt_ClawInner_R",
+  "jt_ClawMiddle_L",
+  "jt_ClawMiddle_R",
+  "jt_ClawOutter_L",
+  "jt_ClawOutter_R",
+  "jt_Cog_C",
+  "jt_Elbow_L",
+  "jt_Elbow_R",
+  "jt_EyeBall_L",
+  "jt_EyeBall_R",
+  "jt_FingerInner_L",
+  "jt_FingerInner_R",
+  "jt_FingerMiddle_L",
+  "jt_FingerMiddle_R",
+  "jt_FingerOutter_L",
+  "jt_FingerOutter_R",
+  "jt_Foot_L",
+  "jt_Foot_R",
+  "jt_HandClawInner_L",
+  "jt_HandClawInner_R",
+  "jt_HandClawMiddle_L",
+  "jt_HandClawMiddle_R",
+  "jt_HandClawOutter_L",
+  "jt_HandClawOutter_R",
+  "jt_Head_C",
+  "jt_Hip_L",
+  "jt_Hip_R",
+  "jt_Hips_C",
+  "jt_Jaw_C",
+  "jt_Knee_L",
+  "jt_Knee_R",
+  "jt_Neck1_C",
+  "jt_Neck2_C",
+  "jt_Neck3_C",
+  "jt_Shoulder_L",
+  "jt_Shoulder_R",
+  "jt_Spine1_C",
+  "jt_Spine2_C",
+  "jt_Tail1_C",
+  "jt_Tail2_C",
+  "jt_Tail3_C",
+  "jt_Tail4_C",
+  "jt_Tail5_C",
+  "jt_Tail6_C",
+  "jt_ThighMuscle_L",
+  "jt_ThighMuscle_R",
+  "jt_Thigh_L",
+  "jt_Thigh_R",
+  "jt_ToeInner_L",
+  "jt_ToeInner_R",
+  "jt_ToeMiddle_L",
+  "jt_ToeMiddle_R",
+  "jt_ToeOutter_L",
+  "jt_ToeOutter_R",
+  "jt_Tongue1_C",
+  "jt_Tongue2_C",
+  "jt_Wrist_L",
+  "jt_Wrist_R"
+ ],
+ "Rat": [
+  "Head",
+  "Hips",
+  "LeftArm",
+  "LeftFoot",
+  "LeftForeArm",
+  "LeftHand",
+  "LeftLeg",
+  "LeftUpLeg",
+  "RightArm",
+  "RightFoot",
+  "RightForeArm",
+  "RightHand",
+  "RightLeg",
+  "RightUpLeg",
+  "Spine",
+  "Tail01",
+  "Tail02",
+  "Trajectory"
+ ],
+ "Rhino": [
+  "BN_Down",
+  "BN_Downbody",
+  "BN_Ear_L",
+  "BN_Ear_R",
+  "BN_Jaw",
+  "BN_Tail_01",
+  "BN_Tail_02",
+  "BN_Tail_03",
+  "BN_Tongue_01",
+  "BN_Tongue_02",
+  "BN_eyelid_L",
+  "BN_eyelid_R",
+  "Bip01_Head",
+  "Bip01_HeadNub",
+  "Bip01_L_Calf",
+  "Bip01_L_Clavicle",
+  "Bip01_L_Finger0",
+  "Bip01_L_Finger0Nub",
+  "Bip01_L_Foot",
+  "Bip01_L_Forearm",
+  "Bip01_L_Hand",
+  "Bip01_L_HorseLink",
+  "Bip01_L_Thigh",
+  "Bip01_L_Toe0",
+  "Bip01_L_Toe0Nub",
+  "Bip01_L_UpperArm",
+  "Bip01_Neck",
+  "Bip01_Pelvis",
+  "Bip01_R_Calf",
+  "Bip01_R_Clavicle",
+  "Bip01_R_Finger0",
+  "Bip01_R_Finger0Nub",
+  "Bip01_R_Foot",
+  "Bip01_R_Forearm",
+  "Bip01_R_Hand",
+  "Bip01_R_HorseLink",
+  "Bip01_R_Thigh",
+  "Bip01_R_Toe0",
+  "Bip01_R_Toe0Nub",
+  "Bip01_R_UpperArm",
+  "Bip01_Spine",
+  "Bip01_Spine1",
+  "Bip01_Spine2",
+  "Hips"
+ ],
+ "Roach": [
+  "Bip01_Head",
+  "Bip01_L_Calf01",
+  "Bip01_L_Calf11",
+  "Bip01_L_Clavicle",
+  "Bip01_L_Foot01",
+  "Bip01_L_Foot11",
+  "Bip01_L_Forearm",
+  "Bip01_L_Thigh01",
+  "Bip01_L_Thigh11",
+  "Bip01_L_UpperArm",
+  "Bip01_Neck",
+  "Bip01_Pelvis",
+  "Bip01_Ponytail_L01",
+  "Bip01_Ponytail_L02",
+  "Bip01_Ponytail_L03",
+  "Bip01_Ponytail_L11",
+  "Bip01_Ponytail_R01",
+  "Bip01_Ponytail_R02",
+  "Bip01_Ponytail_R03",
+  "Bip01_Ponytail_R11",
+  "Bip01_R_Calf01",
+  "Bip01_R_Calf11",
+  "Bip01_R_Clavicle",
+  "Bip01_R_Foot01",
+  "Bip01_R_Foot11",
+  "Bip01_R_Forearm",
+  "Bip01_R_Thigh01",
+  "Bip01_R_Thigh11",
+  "Bip01_R_UpperArm",
+  "Bip01_Spine",
+  "Bip01_Spine1",
+  "Bip01_Spine1_LWing",
+  "Bip01_Spine1_RWing",
+  "Bip01_Tail",
+  "Bip01_Tail1",
+  "Bone02",
+  "Bone03",
+  "Bone04",
+  "Bone08",
+  "Bone16",
+  "Bone17",
+  "Bone18",
+  "Bone22",
+  "Bone26",
+  "Bone30",
+  "Hips"
+ ],
+ "SabreToothTiger": [
+  "Hips",
+  "MagicEffectsNode",
+  "Null",
+  "SabreCat",
+  "SabreCat_LeftEye",
+  "SabreCat_RightEye",
+  "SabrecatMane",
+  "Sabrecat_Finger4_LF04_",
+  "Sabrecat_Finger4_RF04_",
+  "Sabrecat_HeadEyeLid__HELB_",
+  "Sabrecat_HeadLeftEar_LEar_",
+  "Sabrecat_HeadRightEar_REar_",
+  "Sabrecat_Head_EyeLid_HELT_",
+  "Sabrecat_Head_Head__LChk_",
+  "Sabrecat_Head_LM01_",
+  "Sabrecat_Head_RM01_",
+  "Sabrecat_Head__Head_",
+  "Sabrecat_Head__LEye_",
+  "Sabrecat_Head__RChk_",
+  "Sabrecat_Head__REye_",
+  "Sabrecat_Head_jaw_",
+  "Sabrecat_LeftCalf_LClf_",
+  "Sabrecat_LeftClavicle_LClv_",
+  "Sabrecat_LeftFinger0_LF00_",
+  "Sabrecat_LeftFinger0_LF01_",
+  "Sabrecat_LeftFinger1_LF10_",
+  "Sabrecat_LeftFinger1_LF11_",
+  "Sabrecat_LeftFinger2_LF20_",
+  "Sabrecat_LeftFinger2_LF21_",
+  "Sabrecat_LeftFinger3_RF30_",
+  "Sabrecat_LeftFinger3_RF31_",
+  "Sabrecat_LeftFoot_LFot_",
+  "Sabrecat_LeftForearm_LFar_",
+  "Sabrecat_LeftHand_LHnd_",
+  "Sabrecat_LeftThigh_LThi_",
+  "Sabrecat_LeftToe0_LT00_",
+  "Sabrecat_LeftToe0_LT01_",
+  "Sabrecat_LeftTwistBone_LFTB_",
+  "Sabrecat_LeftUpperArm_LUar_",
+  "Sabrecat_Neck_Nek0_",
+  "Sabrecat_Neck_Nek1_",
+  "Sabrecat_Neck_Nek2_",
+  "Sabrecat_Ribcage_Spn1_",
+  "Sabrecat_Ribcage_Spn4_",
+  "Sabrecat_RightCalf_RClf_",
+  "Sabrecat_RightClavicle_RClv_",
+  "Sabrecat_RightFinger0_RF00_",
+  "Sabrecat_RightFinger0_RF01_",
+  "Sabrecat_RightFinger1_RF10_",
+  "Sabrecat_RightFinger1_RF11_",
+  "Sabrecat_RightFinger2_RF20_",
+  "Sabrecat_RightFinger2_RF21_",
+  "Sabrecat_RightFinger3_RF30_",
+  "Sabrecat_RightFinger3_RF31_",
+  "Sabrecat_RightFoot_RFot_",
+  "Sabrecat_RightForearm_RFar_",
+  "Sabrecat_RightHand_RHnd_",
+  "Sabrecat_RightThigh_RThi_",
+  "Sabrecat_RightToe0_RT00_",
+  "Sabrecat_RightToe0_RT01_",
+  "Sabrecat_RightTwistBone_RFTB_",
+  "Sabrecat_RightUpperArm_RUar_",
+  "Sabrecat_Spine_Spn0_",
+  "Sabrecat_Spine_Spn1_",
+  "Sabrecat_Spine_Spn2_",
+  "Sabrecat_Spine_Spn3_",
+  "Sabrecat_Tail0_Tal0_",
+  "Sabrecat_Tail1_Tal1_",
+  "Sabrecat_Tail2_Tal2_",
+  "Sabrecat__pelv_",
+  "Skin",
+  "Skin_2",
+  "Skin_3",
+  "Skin_4"
+ ],
+ "SandMouse": [
+  "BN_Beard_L",
+  "BN_Beard_R",
+  "BN_Ear_L",
+  "BN_Ear_R",
+  "BN_Mouth_01",
+  "BN_Tail_01",
+  "BN_Tail_02",
+  "BN_Tail_03",
+  "BN_Tail_04",
+  "BN_Tail_05",
+  "Bip01_Head",
+  "Bip01_HeadNub",
+  "Bip01_L_Calf",
+  "Bip01_L_Clavicle",
+  "Bip01_L_Foot",
+  "Bip01_L_Forearm",
+  "Bip01_L_Hand",
+  "Bip01_L_HorseLink",
+  "Bip01_L_Thigh",
+  "Bip01_L_Toe0",
+  "Bip01_L_Toe0Nub",
+  "Bip01_L_UpperArm",
+  "Bip01_Neck",
+  "Bip01_Pelvis",
+  "Bip01_R_Calf",
+  "Bip01_R_Clavicle",
+  "Bip01_R_Foot",
+  "Bip01_R_Forearm",
+  "Bip01_R_Hand",
+  "Bip01_R_HorseLink",
+  "Bip01_R_Thigh",
+  "Bip01_R_Toe0",
+  "Bip01_R_Toe0Nub",
+  "Bip01_R_UpperArm",
+  "Bip01_Spine",
+  "Bip01_Spine1",
+  "Bip01_Spine2",
+  "Hips"
+ ],
+ "Scorpion": [
+  "Bip01_L_Calf",
+  "Bip01_L_Calf_1",
+  "Bip01_L_Calf_2",
+  "Bip01_L_Calf_3",
+  "Bip01_L_Clavicle",
+  "Bip01_L_Finger0",
+  "Bip01_L_FootNub_1",
+  "Bip01_L_FootNub_2",
+  "Bip01_L_FootNub_3",
+  "Bip01_L_FootNub_4",
+  "Bip01_L_Foot_1",
+  "Bip01_L_Foot_2",
+  "Bip01_L_Foot_3",
+  "Bip01_L_Foot_4",
+  "Bip01_L_Forearm",
+  "Bip01_L_Hand",
+  "Bip01_L_Thigh1_1",
+  "Bip01_L_Thigh1_2",
+  "Bip01_L_Thigh1_3",
+  "Bip01_L_Thigh1_4",
+  "Bip01_L_Thigh_1",
+  "Bip01_L_Thigh_2",
+  "Bip01_L_Thigh_3",
+  "Bip01_L_Thigh_4",
+  "Bip01_L_UpperArm",
+  "Bip01_Neck1",
+  "Bip01_Pelvis",
+  "Bip01_R_Calf_1",
+  "Bip01_R_Calf_2",
+  "Bip01_R_Calf_3",
+  "Bip01_R_Calf_4",
+  "Bip01_R_Clavicle",
+  "Bip01_R_Finger0",
+  "Bip01_R_FootNub_1",
+  "Bip01_R_FootNub_2",
+  "Bip01_R_FootNub_3",
+  "Bip01_R_FootNub_4",
+  "Bip01_R_Foot_1",
+  "Bip01_R_Foot_2",
+  "Bip01_R_Foot_3",
+  "Bip01_R_Foot_4",
+  "Bip01_R_Forearm",
+  "Bip01_R_Hand",
+  "Bip01_R_Thigh1_1",
+  "Bip01_R_Thigh1_2",
+  "Bip01_R_Thigh1_3",
+  "Bip01_R_Thigh1_4",
+  "Bip01_R_Thigh_1",
+  "Bip01_R_Thigh_2",
+  "Bip01_R_Thigh_3",
+  "Bip01_R_Thigh_4",
+  "Bip01_R_UpperArm",
+  "Bip01_Spine",
+  "Bip01_SpineL",
+  "Bip01_SpineR",
+  "Bip01_Tail",
+  "Bip01_Tail1",
+  "Bip01_Tail2",
+  "Bip01_Tail3",
+  "Bip01_Tail4",
+  "Bip01_Tail5",
+  "Bip01_Tail6",
+  "Bip01_TailNub",
+  "Hips"
+ ],
+ "Scorpion2": [
+  "Hips",
+  "jt_BigMandibleMid_L",
+  "jt_BigMandibleMid_R",
+  "jt_BigMandible_L",
+  "jt_BigMandible_R",
+  "jt_Cog_C",
+  "jt_FangsMid_L",
+  "jt_FangsMid_R",
+  "jt_Fangs_L",
+  "jt_Fangs_R",
+  "jt_FrontLeg1_L",
+  "jt_FrontLeg1_R",
+  "jt_FrontLeg2_L",
+  "jt_FrontLeg2_R",
+  "jt_FrontLeg3_L",
+  "jt_FrontLeg3_R",
+  "jt_FrontLeg4End_L",
+  "jt_FrontLeg4End_R",
+  "jt_Head_C",
+  "jt_HindLeg1_L",
+  "jt_HindLeg1_R",
+  "jt_HindLeg2_L",
+  "jt_HindLeg2_R",
+  "jt_HindLeg3_L",
+  "jt_HindLeg3_R",
+  "jt_HindLeg4End_L",
+  "jt_HindLeg4End_R",
+  "jt_Hips_C",
+  "jt_LowerMandibleMid_L",
+  "jt_LowerMandibleMid_R",
+  "jt_LowerMandible_L",
+  "jt_LowerMandible_R",
+  "jt_MiddleLeg1_L",
+  "jt_MiddleLeg1_R",
+  "jt_MiddleLeg2_L",
+  "jt_MiddleLeg2_R",
+  "jt_MiddleLeg3_L",
+  "jt_MiddleLeg3_R",
+  "jt_MiddleLeg4End_L",
+  "jt_MiddleLeg4End_R",
+  "jt_Tail01_C",
+  "jt_Tail01x_C",
+  "jt_Tail02_C",
+  "jt_Tail02x_C",
+  "jt_Tail03_C",
+  "jt_Tail03x_C",
+  "jt_Tail04_C",
+  "jt_Tail04x_C",
+  "jt_Tail05_C",
+  "jt_Tail05x_C",
+  "jt_Tail06_C",
+  "jt_Tail06x_C",
+  "jt_Tail07_C",
+  "jt_Tail07x_C",
+  "jt_Tail08_C",
+  "jt_Tail08x_C",
+  "jt_Tail09_C",
+  "jt_Tail09x_C",
+  "jt_Tail10_C"
+ ],
+ "Skunk": [
+  "BN_Fur_L_01",
+  "BN_Fur_L_02",
+  "BN_Fur_L_03",
+  "BN_Fur_R_01",
+  "BN_Fur_R_02",
+  "BN_Fur_R_03",
+  "BN_Mouth_01",
+  "BN_Tail_01",
+  "BN_Tail_02",
+  "BN_Tail_03",
+  "BN_Tail_04",
+  "Bip01_Head",
+  "Bip01_HeadNub",
+  "Bip01_L_Calf",
+  "Bip01_L_Clavicle",
+  "Bip01_L_Foot",
+  "Bip01_L_Forearm",
+  "Bip01_L_Hand",
+  "Bip01_L_Thigh",
+  "Bip01_L_Toe0",
+  "Bip01_L_Toe0Nub",
+  "Bip01_L_UpperArm",
+  "Bip01_Neck",
+  "Bip01_Pelvis",
+  "Bip01_R_Calf",
+  "Bip01_R_Clavicle",
+  "Bip01_R_Foot",
+  "Bip01_R_Forearm",
+  "Bip01_R_Hand",
+  "Bip01_R_Thigh",
+  "Bip01_R_Toe0",
+  "Bip01_R_Toe0Nub",
+  "Bip01_R_UpperArm",
+  "Bip01_Spine",
+  "Bip01_Spine1",
+  "Hips"
+ ],
+ "Spider": [
+  "ArmLClaw",
+  "ArmLCollarbone",
+  "ArmL_01_",
+  "ArmL_02_",
+  "ArmRClaw",
+  "ArmRCollarbone",
+  "ArmR_01_",
+  "ArmR_02_",
+  "FangL_00_",
+  "FangL_01_",
+  "FangL_02_",
+  "FangR_00_",
+  "FangR_01_",
+  "FangR_02_",
+  "Hips",
+  "L_Jaw_",
+  "Leg_L_00_",
+  "Leg_L_01_",
+  "Leg_L_02_",
+  "Leg_L_03_",
+  "Leg_L_04_",
+  "Leg_L_10_",
+  "Leg_L_11_",
+  "Leg_L_12_",
+  "Leg_L_13_",
+  "Leg_L_14_",
+  "Leg_L_20_",
+  "Leg_L_21_",
+  "Leg_L_22_",
+  "Leg_L_23_",
+  "Leg_L_24_",
+  "Leg_L_30_",
+  "Leg_L_31_",
+  "Leg_L_32_",
+  "Leg_L_33_",
+  "Leg_L_34_",
+  "Leg_R_00_",
+  "Leg_R_01_",
+  "Leg_R_02_",
+  "Leg_R_03_",
+  "Leg_R_04_",
+  "Leg_R_10_",
+  "Leg_R_11_",
+  "Leg_R_12_",
+  "Leg_R_13_",
+  "Leg_R_14_",
+  "Leg_R_20_",
+  "Leg_R_21_",
+  "Leg_R_22_",
+  "Leg_R_23_",
+  "Leg_R_24_",
+  "Leg_R_30_",
+  "Leg_R_31_",
+  "Leg_R_32_",
+  "Leg_R_33_",
+  "Leg_R_34_",
+  "NPC_Head__Head_",
+  "NPC_L_MagicNode__LMag_",
+  "R_Jaw_",
+  "Tail1",
+  "Tail2",
+  "Tail3",
+  "_LToe0_",
+  "_LToe1_",
+  "_LToe2_",
+  "_LToe3_",
+  "_RToe0_",
+  "_RToe1_",
+  "_RToe2_",
+  "_RToe3_",
+  "_body_"
+ ],
+ "SpiderG": [
+  "BN_Mouth_L_01",
+  "BN_Mouth_L_02",
+  "BN_Mouth_L_03",
+  "BN_Mouth_L_04",
+  "BN_Mouth_L_05",
+  "BN_Mouth_R_01",
+  "BN_Mouth_R_02",
+  "BN_Mouth_R_03",
+  "BN_Mouth_R_04",
+  "BN_Mouth_R_05",
+  "BN_Tail_01",
+  "BN_Tail_02",
+  "BN_hand_L_01",
+  "BN_hand_L_02",
+  "BN_hand_L_03",
+  "BN_hand_L_04",
+  "BN_hand_L_05",
+  "BN_hand_R_01",
+  "BN_hand_R_02",
+  "BN_hand_R_03",
+  "BN_hand_R_04",
+  "BN_hand_R_05",
+  "BN_leg_L_01",
+  "BN_leg_L_02",
+  "BN_leg_L_03",
+  "BN_leg_L_04",
+  "BN_leg_L_05",
+  "BN_leg_R_01",
+  "BN_leg_R_02",
+  "BN_leg_R_03",
+  "BN_leg_R_04",
+  "BN_leg_R_05",
+  "Bip01_Head",
+  "Bip01_HeadNub",
+  "Bip01_L_Calf",
+  "Bip01_L_Clavicle",
+  "Bip01_L_Finger0",
+  "Bip01_L_Finger0Nub",
+  "Bip01_L_Foot",
+  "Bip01_L_Forearm",
+  "Bip01_L_Hand",
+  "Bip01_L_Thigh",
+  "Bip01_L_Toe0",
+  "Bip01_L_Toe01",
+  "Bip01_L_Toe0Nub",
+  "Bip01_L_UpperArm",
+  "Bip01_Neck",
+  "Bip01_Pelvis",
+  "Bip01_R_Calf",
+  "Bip01_R_Clavicle",
+  "Bip01_R_Finger0",
+  "Bip01_R_Finger0Nub",
+  "Bip01_R_Foot",
+  "Bip01_R_Forearm",
+  "Bip01_R_Hand",
+  "Bip01_R_Thigh",
+  "Bip01_R_Toe0",
+  "Bip01_R_Toe01",
+  "Bip01_R_Toe0Nub",
+  "Bip01_R_UpperArm",
+  "Bip01_Spine",
+  "Hips"
+ ],
+ "Stego": [
+  "BN_Jaw",
+  "BN_L_Lip",
+  "BN_R_Lip",
+  "BN_Tail_01",
+  "BN_Tail_02",
+  "BN_Tail_03",
+  "BN_Tail_04",
+  "BN_Tail_05",
+  "BN_Tone",
+  "Bip01_Head",
+  "Bip01_HeadNub",
+  "Bip01_L_Calf",
+  "Bip01_L_Clavicle",
+  "Bip01_L_Finger0",
+  "Bip01_L_Finger0Nub",
+  "Bip01_L_Foot",
+  "Bip01_L_Forearm",
+  "Bip01_L_Hand",
+  "Bip01_L_Thigh",
+  "Bip01_L_Toe0",
+  "Bip01_L_Toe0Nub",
+  "Bip01_L_UpperArm",
+  "Bip01_Neck",
+  "Bip01_Neck1",
+  "Bip01_Neck2",
+  "Bip01_Pelvis",
+  "Bip01_R_Calf",
+  "Bip01_R_Clavicle",
+  "Bip01_R_Finger0",
+  "Bip01_R_Finger0Nub",
+  "Bip01_R_Foot",
+  "Bip01_R_Forearm",
+  "Bip01_R_Hand",
+  "Bip01_R_Thigh",
+  "Bip01_R_Toe0",
+  "Bip01_R_Toe0Nub",
+  "Bip01_R_UpperArm",
+  "Bip01_Spine",
+  "Bip01_Spine1",
+  "Bip01_Spine2",
+  "Hips"
+ ],
+ "Trex": [
+  "Hips",
+  "jt_Ankle_L",
+  "jt_Ankle_R",
+  "jt_Clavicle_L",
+  "jt_Clavicle_R",
+  "jt_ClawInner_L",
+  "jt_ClawInner_R",
+  "jt_ClawMiddle_L",
+  "jt_ClawMiddle_R",
+  "jt_ClawOutter_L",
+  "jt_ClawOutter_R",
+  "jt_Cog_C",
+  "jt_Elbow_L",
+  "jt_Elbow_R",
+  "jt_Eye_L",
+  "jt_Eye_R",
+  "jt_FingerInner_L",
+  "jt_FingerInner_R",
+  "jt_FingerOutter_L",
+  "jt_FingerOutter_R",
+  "jt_Foot_L",
+  "jt_Foot_R",
+  "jt_HandClawInner_L",
+  "jt_HandClawInner_R",
+  "jt_HandClawOutter_L",
+  "jt_HandClawOutter_R",
+  "jt_Head_C",
+  "jt_Hip_L",
+  "jt_Hip_R",
+  "jt_Hips_C",
+  "jt_Jaw_C",
+  "jt_Knee_L",
+  "jt_Knee_R",
+  "jt_Neck1_C",
+  "jt_Neck2_C",
+  "jt_Neck3_C",
+  "jt_NeckMuscle_C",
+  "jt_Shoulder_L",
+  "jt_Shoulder_R",
+  "jt_Spine1_C",
+  "jt_Spine2_C",
+  "jt_Tail1_C",
+  "jt_Tail2_C",
+  "jt_Tail3_C",
+  "jt_Tail4_C",
+  "jt_Tail5_C",
+  "jt_Tail6_C",
+  "jt_ThighMuscle_L",
+  "jt_ThighMuscle_R",
+  "jt_Thigh_L",
+  "jt_Thigh_R",
+  "jt_ToeInner_L",
+  "jt_ToeInner_R",
+  "jt_ToeMiddle_L",
+  "jt_ToeMiddle_R",
+  "jt_ToeOutter_L",
+  "jt_ToeOutter_R",
+  "jt_Tongue1_C",
+  "jt_Tongue2_C",
+  "jt_Wrist_L",
+  "jt_Wrist_R"
+ ],
+ "Tricera": [
+  "BN_Eye_L",
+  "BN_Eye_R",
+  "BN_Mouth",
+  "BN_Tail_01",
+  "BN_Tail_02",
+  "BN_Tail_03",
+  "BN_Tail_04",
+  "Bip01_Head",
+  "Bip01_L_Calf",
+  "Bip01_L_Clavicle",
+  "Bip01_L_Foot",
+  "Bip01_L_Forearm",
+  "Bip01_L_Hand",
+  "Bip01_L_HorseLink",
+  "Bip01_L_Thigh",
+  "Bip01_L_Toe0",
+  "Bip01_L_UpperArm",
+  "Bip01_Neck",
+  "Bip01_Pelvis",
+  "Bip01_R_Calf",
+  "Bip01_R_Clavicle",
+  "Bip01_R_Foot",
+  "Bip01_R_Forearm",
+  "Bip01_R_Hand",
+  "Bip01_R_HorseLink",
+  "Bip01_R_Thigh",
+  "Bip01_R_Toe0",
+  "Bip01_R_UpperArm",
+  "Bip01_Spine",
+  "Bip01_Spine1",
+  "Bip01_Spine2",
+  "Hips"
+ ],
+ "Tukan": [
+  "ESI1_Body",
+  "Hips",
+  "L_hiji",
+  "L_kata",
+  "L_momo",
+  "MESH",
+  "N_ALL",
+  "R_hiji",
+  "R_kata",
+  "R_momo",
+  "ago",
+  "body01",
+  "hara",
+  "kao",
+  "kosi",
+  "locator",
+  "mune",
+  "o"
+ ],
+ "Turtle": [
+  "BN_Chin_01",
+  "BN_Head_01",
+  "BN_Neck_01",
+  "BN_Neck_02",
+  "BN_Tail_01",
+  "BN_Tail_02",
+  "Bip01_Head",
+  "Bip01_HeadNub",
+  "Bip01_L_Calf",
+  "Bip01_L_Clavicle",
+  "Bip01_L_Finger0",
+  "Bip01_L_Finger01",
+  "Bip01_L_Finger0Nub",
+  "Bip01_L_Finger1",
+  "Bip01_L_Finger11",
+  "Bip01_L_Finger1Nub",
+  "Bip01_L_Foot",
+  "Bip01_L_Forearm",
+  "Bip01_L_Hand",
+  "Bip01_L_Thigh",
+  "Bip01_L_Toe0",
+  "Bip01_L_Toe01",
+  "Bip01_L_Toe0Nub",
+  "Bip01_L_Toe1",
+  "Bip01_L_Toe11",
+  "Bip01_L_Toe1Nub",
+  "Bip01_L_UpperArm",
+  "Bip01_Neck",
+  "Bip01_Pelvis",
+  "Bip01_R_Calf",
+  "Bip01_R_Clavicle",
+  "Bip01_R_Finger0",
+  "Bip01_R_Finger01",
+  "Bip01_R_Finger0Nub",
+  "Bip01_R_Finger1",
+  "Bip01_R_Finger11",
+  "Bip01_R_Finger1Nub",
+  "Bip01_R_Foot",
+  "Bip01_R_Forearm",
+  "Bip01_R_Hand",
+  "Bip01_R_Thigh",
+  "Bip01_R_Toe0",
+  "Bip01_R_Toe01",
+  "Bip01_R_Toe0Nub",
+  "Bip01_R_Toe1",
+  "Bip01_R_Toe11",
+  "Bip01_R_Toe1Nub",
+  "Bip01_R_UpperArm",
+  "Bip01_Spine",
+  "Hips"
+ ],
+ "Tyranno": [
+  "Bip01_Head",
+  "Bip01_HeadNub",
+  "Bip01_L_Calf",
+  "Bip01_L_Clavicle",
+  "Bip01_L_Finger0",
+  "Bip01_L_Finger01",
+  "Bip01_L_Finger0Nub",
+  "Bip01_L_Foot",
+  "Bip01_L_Forearm",
+  "Bip01_L_Hand",
+  "Bip01_L_HorseLink",
+  "Bip01_L_Thigh",
+  "Bip01_L_Toe0",
+  "Bip01_L_Toe01",
+  "Bip01_L_Toe0Nub",
+  "Bip01_L_Toe1",
+  "Bip01_L_Toe11",
+  "Bip01_L_Toe1Nub",
+  "Bip01_L_Toe2",
+  "Bip01_L_Toe21",
+  "Bip01_L_Toe2Nub",
+  "Bip01_L_UpperArm",
+  "Bip01_Neck",
+  "Bip01_Neck1",
+  "Bip01_Pelvis",
+  "Bip01_Ponytail1",
+  "Bip01_Ponytail11",
+  "Bip01_Ponytail1Nub",
+  "Bip01_R_Calf",
+  "Bip01_R_Clavicle",
+  "Bip01_R_Finger0",
+  "Bip01_R_Finger01",
+  "Bip01_R_Finger0Nub",
+  "Bip01_R_Foot",
+  "Bip01_R_Forearm",
+  "Bip01_R_Hand",
+  "Bip01_R_HorseLink",
+  "Bip01_R_Thigh",
+  "Bip01_R_Toe0",
+  "Bip01_R_Toe01",
+  "Bip01_R_Toe0Nub",
+  "Bip01_R_Toe1",
+  "Bip01_R_Toe11",
+  "Bip01_R_Toe1Nub",
+  "Bip01_R_Toe2",
+  "Bip01_R_Toe21",
+  "Bip01_R_Toe2Nub",
+  "Bip01_R_UpperArm",
+  "Bip01_Spine",
+  "Bip01_Spine1",
+  "Bip01_Tail",
+  "Bip01_Tail1",
+  "Bip01_Tail2",
+  "Bip01_Tail3",
+  "Bip01_Tail4",
+  "Bip01_TailNub",
+  "Bip01_Xtra01",
+  "Bip01_Xtra0102",
+  "Bip01_Xtra0103",
+  "Bip01_Xtra01Nub",
+  "Bip01_Xtra02",
+  "Bip01_Xtra02Nub",
+  "Bip01_Xtra02Opp",
+  "Bip01_Xtra02OppNub",
+  "Bip01_Xtra03",
+  "Bip01_Xtra03Nub",
+  "Bip01_Xtra03Opp",
+  "Bip01_Xtra03OppNub",
+  "Hips"
+ ]
+}

animation_frames.json

@@ -0,0 +1,1099 @@
+{
+ "Alligator-Big_Mouth.fbx": 136,
+ "Alligator-Bite_1.fbx": 136,
+ "Alligator-Bite_2.fbx": 154,
+ "Alligator-Bite_3.fbx": 97,
+ "Alligator-Bite_4.fbx": 115,
+ "Alligator-Bite_5.fbx": 115,
+ "Alligator-Bite_6.fbx": 201,
+ "Alligator-Bite_7.fbx": 190,
+ "Alligator-Catch.fbx": 121,
+ "Alligator-Dash.fbx": 138,
+ "Alligator-Dash_2.fbx": 201,
+ "Alligator-Dead_Up.fbx": 58,
+ "Alligator-Die.fbx": 238,
+ "Alligator-Die_Loop.fbx": 60,
+ "Alligator-Shake.fbx": 115,
+ "Alligator-Stand_Idle.fbx": 90,
+ "Alligator-Throw.fbx": 130,
+ "Alligator-Throw_2.fbx": 70,
+ "Alligator-Walk_1.fbx": 231,
+ "Alligator-Walk_2.fbx": 331,
+ "Alligator-Walk_3.fbx": 217,
+ "Anaconda-Attack.fbx": 121,
+ "Anaconda-Bite.fbx": 80,
+ "Anaconda-Bite_2.fbx": 84,
+ "Anaconda-Die.fbx": 151,
+ "Anaconda-Hiss.fbx": 109,
+ "Anaconda-Idle.fbx": 201,
+ "Anaconda-Idle_2.fbx": 301,
+ "Anaconda-Rise.fbx": 135,
+ "Anaconda-Rise_2.fbx": 91,
+ "Anaconda-Run.fbx": 69,
+ "Anaconda-Sneaky.fbx": 300,
+ "Anaconda-Spin.fbx": 160,
+ "Anaconda-Strike.fbx": 140,
+ "Anaconda-Strike_2.fbx": 90,
+ "Anaconda-Struck_Die.fbx": 151,
+ "Anaconda-Tired.fbx": 152,
+ "Anaconda-Twist_Rattle.fbx": 220,
+ "Anaconda-Walk_Slow.fbx": 151,
+ "Ant-Attack.fbx": 72,
+ "Ant-Cleaning.fbx": 151,
+ "Ant-Die.fbx": 202,
+ "Ant-Die_2.fbx": 31,
+ "Ant-Die_Loop.fbx": 60,
+ "Ant-Die_Up.fbx": 61,
+ "Ant-Idle.fbx": 150,
+ "Ant-Idle_2.fbx": 79,
+ "Ant-Idle_3.fbx": 120,
+ "Ant-Jump_Forward.fbx": 90,
+ "Ant-Knocked_Back.fbx": 69,
+ "Ant-March.fbx": 31,
+ "Ant-Shake.fbx": 91,
+ "Ant-Sting.fbx": 90,
+ "Ant-Sting_2.fbx": 79,
+ "Ant-Throw.fbx": 121,
+ "Ant-Walk.fbx": 70,
+ "Bat-Attack_Bite.fbx": 60,
+ "Bat-Float.fbx": 40,
+ "Bat-Fly.fbx": 54,
+ "Bat-Fly_Glide.fbx": 60,
+ "Bat-Fly_Loop.fbx": 60,
+ "Bat-Kick.fbx": 72,
+ "Bat-Knocked_Back.fbx": 94,
+ "Bat-Looking.fbx": 180,
+ "Bat-Slow_Fly.fbx": 130,
+ "Bat-Walk.fbx": 40,
+ "Bear-Angery_Swat.fbx": 24,
+ "Bear-Back_Up.fbx": 59,
+ "Bear-Bear_Run.fbx": 19,
+ "Bear-Bite.fbx": 19,
+ "Bear-Catch_Fish.fbx": 24,
+ "Bear-Feast.fbx": 46,
+ "Bear-Fish_Bite.fbx": 24,
+ "Bear-Get_Up.fbx": 101,
+ "Bear-Ground_Paw.fbx": 101,
+ "Bear-Growl.fbx": 61,
+ "Bear-Idle.fbx": 91,
+ "Bear-Idle_Pant.fbx": 61,
+ "Bear-Jump_Bite.fbx": 37,
+ "Bear-Lay_Down.fbx": 72,
+ "Bear-Rise_Roar.fbx": 115,
+ "Bear-Running_Bear.fbx": 19,
+ "Bear-Slow_Walk.fbx": 51,
+ "Bear-Stalking.fbx": 51,
+ "Bear-Stand.fbx": 89,
+ "Bear-Swat_Left.fbx": 29,
+ "Bear-Swat_Right.fbx": 29,
+ "Bear-Tip_Left.fbx": 40,
+ "Bear-Trot.fbx": 22,
+ "Bear-Trotting.fbx": 22,
+ "Bear-Turn_180.fbx": 65,
+ "Bear-Turn_Left.fbx": 65,
+ "Bear-Wake_Up.fbx": 51,
+ "Bear-Walk_Forward.fbx": 51,
+ "Bear-Wet_Shake.fbx": 50,
+ "Bird-Attack.fbx": 61,
+ "Bird-Attack_2.fbx": 61,
+ "Bird-Attack_3.fbx": 87,
+ "Bird-Attack_4.fbx": 91,
+ "Bird-Circle_Land.fbx": 241,
+ "Bird-Fallen.fbx": 126,
+ "Bird-Falling.fbx": 106,
+ "Bird-Floater.fbx": 121,
+ "Bird-Fly_Fast.fbx": 24,
+ "Bird-Fly_Loop.fbx": 49,
+ "Bird-Fly_Slow.fbx": 40,
+ "Bird-Flying.fbx": 45,
+ "Bird-Ground_Flap.fbx": 91,
+ "Bird-Idle_Loop.fbx": 130,
+ "Bird-Lander.fbx": 93,
+ "Bird-Look_Right.fbx": 151,
+ "Bird-Slow_Look.fbx": 79,
+ "Bird-Take_Off.fbx": 61,
+ "BrownBear-Attack.fbx": 103,
+ "BrownBear-Attack_2.fbx": 90,
+ "BrownBear-Attack_3.fbx": 81,
+ "BrownBear-Charge.fbx": 100,
+ "BrownBear-Death_Loop.fbx": 60,
+ "BrownBear-Eat_Fish.fbx": 241,
+ "BrownBear-Falling.fbx": 151,
+ "BrownBear-Idle.fbx": 139,
+ "BrownBear-Limp.fbx": 150,
+ "BrownBear-Limping.fbx": 43,
+ "BrownBear-Ready.fbx": 79,
+ "BrownBear-Rise.fbx": 61,
+ "BrownBear-Rise_Attack.fbx": 91,
+ "BrownBear-Rise_Swat.fbx": 160,
+ "BrownBear-Run_Loop.fbx": 46,
+ "BrownBear-Scratch_Ear.fbx": 220,
+ "BrownBear-Sit_Clean.fbx": 220,
+ "BrownBear-Sleepy.fbx": 130,
+ "BrownBear-Slow_Walk.fbx": 109,
+ "BrownBear-Twitching.fbx": 51,
+ "BrownBear-Walk_Loop.fbx": 100,
+ "Buffalo-Alert_Idle.fbx": 201,
+ "Buffalo-Angry_Antlers.fbx": 121,
+ "Buffalo-Attack.fbx": 90,
+ "Buffalo-Attack_1.fbx": 90,
+ "Buffalo-Charged_Up.fbx": 70,
+ "Buffalo-Cud.fbx": 301,
+ "Buffalo-Die.fbx": 171,
+ "Buffalo-Fall.fbx": 121,
+ "Buffalo-Get_Up.fbx": 52,
+ "Buffalo-Ground_Loop.fbx": 60,
+ "Buffalo-Hoof_Scrape.fbx": 121,
+ "Buffalo-Idle.fbx": 130,
+ "Buffalo-Jump.fbx": 120,
+ "Buffalo-Lowered_Head.fbx": 100,
+ "Buffalo-Run_Loop.fbx": 40,
+ "Buffalo-Shot.fbx": 61,
+ "Buffalo-Sleep_Up.fbx": 301,
+ "Buffalo-Walk_Loop.fbx": 100,
+ "Buzzard-Attack_1.fbx": 70,
+ "Buzzard-Attack_2.fbx": 79,
+ "Buzzard-Attack_3.fbx": 70,
+ "Buzzard-Die_1.fbx": 100,
+ "Buzzard-Dying.fbx": 100,
+ "Buzzard-Fly_Loop.fbx": 139,
+ "Buzzard-Slow_Fly.fbx": 60,
+ "Buzzard-Slow_Loop.fbx": 49,
+ "Buzzard-Slowto_Land.fbx": 70,
+ "Buzzard-Soaring.fbx": 34,
+ "Camel-Bite.fbx": 100,
+ "Camel-Buck.fbx": 60,
+ "Camel-Down_Loop.fbx": 60,
+ "Camel-Fall.fbx": 40,
+ "Camel-Idle_Loop.fbx": 201,
+ "Camel-Lay_Down.fbx": 145,
+ "Camel-Mope.fbx": 120,
+ "Camel-Restless.fbx": 139,
+ "Camel-Run.fbx": 61,
+ "Camel-Run_Fast.fbx": 40,
+ "Camel-Scrape_Hoof.fbx": 231,
+ "Camel-Slow_Walk.fbx": 120,
+ "Camel-Specail.fbx": 166,
+ "Camel-Stand_Up.fbx": 60,
+ "Camel-Stop_Walk.fbx": 60,
+ "Camel-Trot.fbx": 60,
+ "Camel-Wild_1.fbx": 100,
+ "Camel-Yell.fbx": 90,
+ "Cat-Idle_Purr.fbx": 501,
+ "Cat-Lick_Clean_Idle.fbx": 501,
+ "Cat-Stretch_Yawn_Idle.fbx": 501,
+ "Cat-Walk.fbx": 90,
+ "Centipede-Attack.fbx": 90,
+ "Centipede-Attack_1.fbx": 90,
+ "Centipede-Attack_2.fbx": 121,
+ "Centipede-Die.fbx": 141,
+ "Centipede-Idle.fbx": 115,
+ "Centipede-Idle_2.fbx": 150,
+ "Centipede-Idle_3.fbx": 115,
+ "Centipede-Rearing.fbx": 201,
+ "Centipede-Run.fbx": 46,
+ "Centipede-Walk.fbx": 90,
+ "Chicken-Egg_Laying.fbx": 201,
+ "Chicken-Idle_Pecking.fbx": 201,
+ "Chicken-Walk.fbx": 90,
+ "Comodoa-Attack_1.fbx": 60,
+ "Comodoa-Attack_2.fbx": 60,
+ "Comodoa-Attack_3.fbx": 165,
+ "Comodoa-Die.fbx": 106,
+ "Comodoa-Idle.fbx": 241,
+ "Comodoa-Idle_2.fbx": 115,
+ "Comodoa-Run.fbx": 37,
+ "Comodoa-Walk.fbx": 199,
+ "Comodoa-Yawn.fbx": 351,
+ "Coyote-Attack_1.fbx": 72,
+ "Coyote-Attack_2.fbx": 72,
+ "Coyote-Attack_3.fbx": 91,
+ "Coyote-Die.fbx": 96,
+ "Coyote-Howling.fbx": 220,
+ "Coyote-Idle.fbx": 201,
+ "Coyote-Restless.fbx": 181,
+ "Coyote-Running.fbx": 37,
+ "Coyote-Sniffing.fbx": 64,
+ "Coyote-Walking.fbx": 75,
+ "Crab-Attack_1.fbx": 72,
+ "Crab-Attack_3.fbx": 90,
+ "Crab-Attack_4.fbx": 72,
+ "Crab-Defeated.fbx": 166,
+ "Crab-Die.fbx": 100,
+ "Crab-Eat.fbx": 121,
+ "Crab-Hit_Back.fbx": 106,
+ "Crab-Strafe.fbx": 100,
+ "Crab-Walk.fbx": 30,
+ "Cricket-Attack_1.fbx": 160,
+ "Cricket-Attack_2.fbx": 100,
+ "Cricket-Attack_3.fbx": 90,
+ "Cricket-Attack_4.fbx": 151,
+ "Cricket-Burrough.fbx": 70,
+ "Cricket-Die.fbx": 121,
+ "Cricket-Idle.fbx": 100,
+ "Cricket-Idle_Pissed.fbx": 91,
+ "Cricket-Look_Around.fbx": 245,
+ "Cricket-Out_Of_Ground.fbx": 66,
+ "Cricket-Running.fbx": 30,
+ "Cricket-Walking.fbx": 76,
+ "Crocodile-Attack.fbx": 75,
+ "Crocodile-Bite.fbx": 75,
+ "Crocodile-Bounce.fbx": 31,
+ "Crocodile-Die.fbx": 139,
+ "Crocodile-Get_Up.fbx": 61,
+ "Crocodile-Heavy_Breathe.fbx": 90,
+ "Crocodile-Idle.fbx": 220,
+ "Crocodile-Normal_Breath.fbx": 120,
+ "Crocodile-Running.fbx": 34,
+ "Crocodile-Sleep_Loop.fbx": 60,
+ "Crocodile-Tail_Whip.fbx": 105,
+ "Crocodile-Yawning.fbx": 220,
+ "Crow-Ascend.fbx": 49,
+ "Crow-Attack.fbx": 85,
+ "Crow-Attack_2.fbx": 42,
+ "Crow-Fly_Start.fbx": 10,
+ "Crow-Glide.fbx": 58,
+ "Crow-Idle.fbx": 245,
+ "Crow-Idle_Flap.fbx": 100,
+ "Crow-Land_Flap.fbx": 111,
+ "Crow-Peck_Eat.fbx": 250,
+ "Crow-Take_Off.fbx": 25,
+ "Deer-Backing.fbx": 37,
+ "Deer-Bleat.fbx": 80,
+ "Deer-Buck_Shy.fbx": 28,
+ "Deer-Charge.fbx": 35,
+ "Deer-Come_Down.fbx": 31,
+ "Deer-Gallop.fbx": 19,
+ "Deer-Get_Up.fbx": 80,
+ "Deer-Get_Up_Again.fbx": 80,
+ "Deer-Grazing.fbx": 301,
+ "Deer-Idle.fbx": 201,
+ "Deer-Idle_Ear_Flik.fbx": 250,
+ "Deer-Rear_Up.fbx": 52,
+ "Deer-Rutting.fbx": 59,
+ "Deer-Squirly.fbx": 37,
+ "Deer-Take_Off.fbx": 37,
+ "Deer-Trot.fbx": 21,
+ "Deer-Turn_Left.fbx": 31,
+ "Deer-Walk_Back.fbx": 31,
+ "Deer-Walk_Call.fbx": 40,
+ "Deer-Walk_Forward.fbx": 31,
+ "Dog-Attack.fbx": 56,
+ "Dog-Back_Away.fbx": 61,
+ "Dog-Bark_Jump.fbx": 37,
+ "Dog-Barking.fbx": 100,
+ "Dog-Bite_Arm.fbx": 45,
+ "Dog-Floor_Rise_Left.fbx": 101,
+ "Dog-Floor_Rise_Right.fbx": 101,
+ "Dog-Frightened.fbx": 40,
+ "Dog-Galloping.fbx": 46,
+ "Dog-Grab.fbx": 45,
+ "Dog-Hit_Left.fbx": 26,
+ "Dog-Hit_Right.fbx": 26,
+ "Dog-Investigate_Loop.fbx": 182,
+ "Dog-Leash_Attack.fbx": 31,
+ "Dog-Leash_Hot.fbx": 32,
+ "Dog-Limp_Loop.fbx": 81,
+ "Dog-Look_Left.fbx": 70,
+ "Dog-Look_Right.fbx": 81,
+ "Dog-PAnting.fbx": 40,
+ "Dog-Paddle.fbx": 61,
+ "Dog-Retreat.fbx": 21,
+ "Dog-Rise.fbx": 21,
+ "Dog-Run_Frisbee.fbx": 42,
+ "Dog-Running.fbx": 46,
+ "Dog-SNiffed.fbx": 25,
+ "Dog-Scratch_Right.fbx": 81,
+ "Dog-Single_Bark.fbx": 43,
+ "Dog-Sit.fbx": 126,
+ "Dog-Snarling.fbx": 61,
+ "Dog-Stare.fbx": 64,
+ "Dog-Swim.fbx": 61,
+ "Dog-Swim_Fast.fbx": 61,
+ "Dog-Swim_Left.fbx": 61,
+ "Dog-Swim_Right.fbx": 61,
+ "Dog-Turn_Left.fbx": 28,
+ "Dog-Turn_Right.fbx": 28,
+ "Dog-Wag.fbx": 16,
+ "Dog-Walk.fbx": 81,
+ "Dog-Walk_Backwards_Loop.fbx": 81,
+ "Dog-Walk_Loop.fbx": 81,
+ "Dog-Wine.fbx": 81,
+ "Dog-Woof.fbx": 100,
+ "Dog2-Arm_Bite.fbx": 45,
+ "Dog2-Attack.fbx": 56,
+ "Dog2-Back_Off.fbx": 61,
+ "Dog2-Bark.fbx": 100,
+ "Dog2-Bark_2.fbx": 43,
+ "Dog2-Bite_Arm_Shake.fbx": 45,
+ "Dog2-Bite_Jump.fbx": 32,
+ "Dog2-Get_Up.fbx": 101,
+ "Dog2-Growl.fbx": 40,
+ "Dog2-Idle_Breathe.fbx": 40,
+ "Dog2-Leash_Jump.fbx": 31,
+ "Dog2-Look_Left.fbx": 70,
+ "Dog2-Look_Right.fbx": 81,
+ "Dog2-Paddle.fbx": 61,
+ "Dog2-Ready.fbx": 61,
+ "Dog2-Run_Fast.fbx": 46,
+ "Dog2-Run_Jump.fbx": 42,
+ "Dog2-Scratch.fbx": 81,
+ "Dog2-Sense.fbx": 81,
+ "Dog2-Shake.fbx": 25,
+ "Dog2-Sit.fbx": 126,
+ "Dog2-Slow_Tail.fbx": 64,
+ "Dog2-Sniffing.fbx": 182,
+ "Dog2-Swim.fbx": 61,
+ "Dog2-Swim_Idle.fbx": 61,
+ "Dog2-Swim_Turn.fbx": 61,
+ "Dog2-Swim_Turn_2.fbx": 61,
+ "Dog2-Turn_Left.fbx": 28,
+ "Dog2-Turn_Right.fbx": 28,
+ "Dog2-Wag.fbx": 16,
+ "Dog2-Walk_Backward.fbx": 81,
+ "Dog2-Walk_Limp.fbx": 81,
+ "Dog2-Walk_Loop.fbx": 81,
+ "Dog2-Walk_Normal.fbx": 81,
+ "Dog2-Woof.fbx": 100,
+ "Dragon-Attack.fbx": 121,
+ "Dragon-Attack_2.fbx": 121,
+ "Dragon-Attack_3.fbx": 182,
+ "Dragon-Die.fbx": 181,
+ "Dragon-Fly.fbx": 331,
+ "Dragon-Idle.fbx": 301,
+ "Dragon-Idle_2.fbx": 141,
+ "Dragon-Idle_3.fbx": 331,
+ "Dragon-Slow_Fly.fbx": 301,
+ "Eagle-Egg_Steal.fbx": 90,
+ "Eagle-Float_Down.fbx": 40,
+ "Eagle-Floatt_Up.fbx": 60,
+ "Eagle-Fly_Loop.fbx": 36,
+ "Eagle-Glide_Loop.fbx": 54,
+ "Eagle-Idle_Nest.fbx": 201,
+ "Eagle-Landing.fbx": 91,
+ "Eagle-Ride_Wind.fbx": 75,
+ "Eagle-Shot.fbx": 91,
+ "Eagle-Strike_1.fbx": 72,
+ "Eagle-Strike_2.fbx": 72,
+ "Eagle-Take_Off.fbx": 66,
+ "Elephant-Attack_1.fbx": 75,
+ "Elephant-Attack_2.fbx": 75,
+ "Elephant-Die.fbx": 178,
+ "Elephant-Down_In.fbx": 61,
+ "Elephant-Down_Loop.fbx": 60,
+ "Elephant-Down_Out.fbx": 121,
+ "Elephant-Firing.fbx": 91,
+ "Elephant-Idle_1.fbx": 201,
+ "Elephant-Idle_2.fbx": 201,
+ "Elephant-Idle_3.fbx": 100,
+ "Elephant-Passout.fbx": 121,
+ "Elephant-Run.fbx": 60,
+ "Elephant-Walk.fbx": 120,
+ "FireAnt-Angry.fbx": 34,
+ "FireAnt-Annoyed.fbx": 31,
+ "FireAnt-Back_Up.fbx": 40,
+ "FireAnt-Bite.fbx": 34,
+ "FireAnt-Creep.fbx": 34,
+ "FireAnt-Feel.fbx": 40,
+ "FireAnt-Fight_Off.fbx": 40,
+ "FireAnt-Forward_March.fbx": 61,
+ "FireAnt-Gesture.fbx": 31,
+ "FireAnt-Hit.fbx": 76,
+ "FireAnt-Hungry.fbx": 40,
+ "FireAnt-Idle.fbx": 201,
+ "FireAnt-Jump.fbx": 34,
+ "FireAnt-Left.fbx": 25,
+ "FireAnt-Right.fbx": 24,
+ "FireAnt-Rip.fbx": 40,
+ "FireAnt-Rip_Flesh.fbx": 42,
+ "FireAnt-Rip_Flesh_2.fbx": 40,
+ "FireAnt-Roar.fbx": 160,
+ "FireAnt-Snap.fbx": 40,
+ "FireAnt-Turn_Left.fbx": 60,
+ "FireAnt-Turn_Right.fbx": 61,
+ "FireAnt-Up_From_Down.fbx": 40,
+ "FireAnt-Up_From_Down_2.fbx": 40,
+ "Flamingo-Bend_Idle.fbx": 201,
+ "Flamingo-One_Leg_Bent.fbx": 201,
+ "Flamingo-Sleep.fbx": 201,
+ "Flamingo-Walk.fbx": 79,
+ "Fox-Attack_1.fbx": 60,
+ "Fox-Attack_2.fbx": 60,
+ "Fox-Attack_3.fbx": 90,
+ "Fox-Attack_4.fbx": 72,
+ "Fox-Die.fbx": 81,
+ "Fox-Die_2.fbx": 85,
+ "Fox-Idle_1.fbx": 70,
+ "Fox-Idle_2.fbx": 120,
+ "Fox-Idle_3.fbx": 300,
+ "Fox-Idle_4.fbx": 250,
+ "Fox-Idle_5.fbx": 351,
+ "Fox-Run.fbx": 34,
+ "Fox-Walk.fbx": 70,
+ "Gazelle-Alert.fbx": 301,
+ "Gazelle-Attack.fbx": 60,
+ "Gazelle-Attack_1.fbx": 120,
+ "Gazelle-Fall.fbx": 91,
+ "Gazelle-Head_Poke.fbx": 60,
+ "Gazelle-Idle.fbx": 201,
+ "Gazelle-Idle_Ready.fbx": 79,
+ "Gazelle-Run.fbx": 30,
+ "Gazelle-Walk.fbx": 79,
+ "Giantbee-Attack.fbx": 72,
+ "Giantbee-Attack_2.fbx": 72,
+ "Giantbee-Attack_3.fbx": 105,
+ "Giantbee-Attack_4.fbx": 90,
+ "Giantbee-Die.fbx": 111,
+ "Giantbee-Die_2.fbx": 111,
+ "Giantbee-Fly.fbx": 79,
+ "Giantbee-Idle.fbx": 103,
+ "Giantbee-Idle_2.fbx": 40,
+ "Goat-Attack.fbx": 72,
+ "Goat-Bleat.fbx": 69,
+ "Goat-Die.fbx": 81,
+ "Goat-Head_Butt.fbx": 79,
+ "Goat-Head_Butt_2.fbx": 79,
+ "Goat-Hoof_Scrape.fbx": 151,
+ "Goat-Idle.fbx": 120,
+ "Goat-Jump_Knock.fbx": 111,
+ "Goat-Run.fbx": 36,
+ "Goat-Walk.fbx": 72,
+ "Hamster-Idle.fbx": 130,
+ "Hamster-Roll_Attack.fbx": 109,
+ "Hamster-Run.fbx": 22,
+ "Hamster-Sniff.fbx": 301,
+ "Hamster-Walk.fbx": 49,
+ "HermitCrab-Die.fbx": 85,
+ "HermitCrab-Eat.fbx": 201,
+ "HermitCrab-Expire.fbx": 81,
+ "HermitCrab-Fighting.fbx": 120,
+ "HermitCrab-Knocked_Back.fbx": 85,
+ "HermitCrab-Knocked_Out.fbx": 76,
+ "HermitCrab-Out_Of_Ground.fbx": 100,
+ "HermitCrab-Pinchers.fbx": 49,
+ "HermitCrab-Sand_Burrough.fbx": 81,
+ "HermitCrab-Sleep.fbx": 220,
+ "HermitCrab-Slow_Walk.fbx": 100,
+ "HermitCrab-Walk.fbx": 31,
+ "Hippopotamus-Attack.fbx": 100,
+ "Hippopotamus-Attack_2.fbx": 100,
+ "Hippopotamus-Attack_3.fbx": 151,
+ "Hippopotamus-Attack_4.fbx": 121,
+ "Hippopotamus-Die.fbx": 151,
+ "Hippopotamus-Idle.fbx": 121,
+ "Hippopotamus-Idle_2.fbx": 90,
+ "Hippopotamus-Run.fbx": 40,
+ "Hippopotamus-Walk.fbx": 81,
+ "Hippopotamus-Yawn.fbx": 181,
+ "Horse-Attack.fbx": 145,
+ "Horse-Back_Up.fbx": 40,
+ "Horse-Bucking.fbx": 139,
+ "Horse-Dying.fbx": 168,
+ "Horse-Feet_Up.fbx": 139,
+ "Horse-Get_Up.fbx": 55,
+ "Horse-Hoof_Scrape.fbx": 245,
+ "Horse-Hoof_Scrape_2.fbx": 121,
+ "Horse-Idle.fbx": 261,
+ "Horse-Idle_3.fbx": 121,
+ "Horse-Idle_Ears.fbx": 400,
+ "Horse-In_Air.fbx": 81,
+ "Horse-Jump_Land.fbx": 68,
+ "Horse-Jumping.fbx": 100,
+ "Horse-Knocked_Back.fbx": 31,
+ "Horse-Land_Run.fbx": 61,
+ "Horse-Lone_Ranger.fbx": 156,
+ "Horse-Lying.fbx": 40,
+ "Horse-Rearing.fbx": 94,
+ "Horse-Rearing_2.fbx": 121,
+ "Horse-Restless.fbx": 105,
+ "Horse-Restless_2.fbx": 210,
+ "Horse-Restless_3.fbx": 201,
+ "Horse-Run_Jump.fbx": 121,
+ "Horse-Run_Loop.fbx": 31,
+ "Horse-Run_To_Stop.fbx": 61,
+ "Horse-Slow_Idle.fbx": 100,
+ "Horse-Slow_Walk.fbx": 85,
+ "Hound-Attack.fbx": 75,
+ "Hound-Bark_1.fbx": 75,
+ "Hound-Barking.fbx": 139,
+ "Hound-Die.fbx": 141,
+ "Hound-Die_Loop.fbx": 60,
+ "Hound-Get_Up.fbx": 61,
+ "Hound-Hit.fbx": 31,
+ "Hound-Idle.fbx": 120,
+ "Hound-Ready_2.fbx": 70,
+ "Hound-Restless.fbx": 201,
+ "Hound-Run_Loop.fbx": 31,
+ "Hound-Sniff.fbx": 121,
+ "Hound-Walk_Loop.fbx": 79,
+ "Isopetra-Attack.fbx": 60,
+ "Isopetra-Attack_2.fbx": 60,
+ "Isopetra-Attack_3.fbx": 108,
+ "Isopetra-Die.fbx": 121,
+ "Isopetra-Idle.fbx": 49,
+ "Isopetra-Idle_2.fbx": 100,
+ "Isopetra-Idle_3.fbx": 201,
+ "Isopetra-Run.fbx": 31,
+ "Isopetra-Walk.fbx": 51,
+ "Jaguar-Attack.fbx": 117,
+ "Jaguar-Attack_1.fbx": 72,
+ "Jaguar-Attack_2.fbx": 72,
+ "Jaguar-Die_1.fbx": 106,
+ "Jaguar-Die_2.fbx": 31,
+ "Jaguar-Get_Up.fbx": 61,
+ "Jaguar-Idle.fbx": 120,
+ "Jaguar-Lie_Idle.fbx": 60,
+ "Jaguar-Low.fbx": 109,
+ "Jaguar-Run.fbx": 34,
+ "Jaguar-Sit.fbx": 301,
+ "Jaguar-Stancing.fbx": 75,
+ "Jaguar-Walk.fbx": 61,
+ "Jaws-Bite_Left.fbx": 71,
+ "Jaws-Bite_Right.fbx": 71,
+ "Jaws-Dead.fbx": 63,
+ "Jaws-Dead_Loop.fbx": 181,
+ "Jaws-Swim.fbx": 61,
+ "Jaws-Swim_180.fbx": 71,
+ "Jaws-Swim_At.fbx": 31,
+ "Jaws-Swim_Left.fbx": 61,
+ "Jaws-Swim_Right.fbx": 61,
+ "KingCobra-Attack.fbx": 145,
+ "KingCobra-Attack_2.fbx": 90,
+ "KingCobra-Bite.fbx": 72,
+ "KingCobra-Circle_Bite.fbx": 130,
+ "KingCobra-Get_Up.fbx": 100,
+ "KingCobra-Idle.fbx": 100,
+ "KingCobra-Idle_Loop.fbx": 281,
+ "KingCobra-Killed.fbx": 76,
+ "KingCobra-Run.fbx": 39,
+ "KingCobra-Steady.fbx": 121,
+ "KingCobra-Walk.fbx": 199,
+ "KingCobra-Walk_Fast.fbx": 100,
+ "Leapord-Attack.fbx": 82,
+ "Leapord-Bite.fbx": 82,
+ "Leapord-Death.fbx": 31,
+ "Leapord-Die.fbx": 111,
+ "Leapord-Die_Loop.fbx": 60,
+ "Leapord-Graze.fbx": 301,
+ "Leapord-Growl.fbx": 90,
+ "Leapord-Idle.fbx": 201,
+ "Leapord-Jump_Up.fbx": 61,
+ "Leapord-Pounce.fbx": 100,
+ "Leapord-Pounce_Swipe.fbx": 121,
+ "Leapord-Run.fbx": 36,
+ "Leapord-Sick.fbx": 120,
+ "Leapord-Walk.fbx": 100,
+ "Lion-Attack.fbx": 72,
+ "Lion-Death_Idle.fbx": 60,
+ "Lion-Die.fbx": 111,
+ "Lion-Die_2.fbx": 31,
+ "Lion-Get_Up.fbx": 60,
+ "Lion-Growl.fbx": 79,
+ "Lion-Jump_Bite.fbx": 72,
+ "Lion-Leap_Bite.fbx": 91,
+ "Lion-Run.fbx": 40,
+ "Lion-Slow_Idle.fbx": 180,
+ "Lion-Sniff.fbx": 139,
+ "Lion-Swatting.fbx": 121,
+ "Lion-Walk.fbx": 109,
+ "Lion-Yawn.fbx": 280,
+ "Lynx-Attack.fbx": 60,
+ "Lynx-Attack_2.fbx": 60,
+ "Lynx-Attack_3.fbx": 79,
+ "Lynx-Die.fbx": 92,
+ "Lynx-Die_2.fbx": 31,
+ "Lynx-Die_Loop.fbx": 60,
+ "Lynx-Idle.fbx": 160,
+ "Lynx-Idle_2.fbx": 121,
+ "Lynx-Idle_3.fbx": 75,
+ "Lynx-Jump.fbx": 90,
+ "Lynx-Run.fbx": 33,
+ "Lynx-Stand.fbx": 61,
+ "Lynx-Walk.fbx": 90,
+ "Mammoth-Bellow.fbx": 351,
+ "Mammoth-Death_Loop.fbx": 60,
+ "Mammoth-Die.fbx": 181,
+ "Mammoth-Die_2.fbx": 70,
+ "Mammoth-Gesture.fbx": 120,
+ "Mammoth-Get_Up.fbx": 100,
+ "Mammoth-Idle.fbx": 160,
+ "Mammoth-Idle_2.fbx": 150,
+ "Mammoth-Rise.fbx": 121,
+ "Mammoth-Run.fbx": 90,
+ "Mammoth-Side_Swipe.fbx": 115,
+ "Mammoth-Walk.fbx": 150,
+ "Monkey-Attack_1.fbx": 60,
+ "Monkey-Attack_2.fbx": 60,
+ "Monkey-Attack_3.fbx": 121,
+ "Monkey-Attack_4.fbx": 117,
+ "Monkey-B01_Die.fbx": 81,
+ "Monkey-B01_Idle.fbx": 301,
+ "Monkey-B02_Attack.fbx": 130,
+ "Monkey-B02_Die.fbx": 100,
+ "Monkey-B02_Idle.fbx": 250,
+ "Monkey-Die.fbx": 111,
+ "Monkey-Idle_1.fbx": 90,
+ "Monkey-Idle_2.fbx": 121,
+ "Monkey-Idle_3.fbx": 301,
+ "Monkey-Run.fbx": 40,
+ "Monkey-Walk.fbx": 61,
+ "Ostrich-Attack.fbx": 70,
+ "Ostrich-Attack_2.fbx": 70,
+ "Ostrich-Attack_3.fbx": 100,
+ "Ostrich-Attack_4.fbx": 94,
+ "Ostrich-Die.fbx": 91,
+ "Ostrich-Idle.fbx": 90,
+ "Ostrich-Idle_2.fbx": 121,
+ "Ostrich-Idle_3.fbx": 331,
+ "Ostrich-Run.fbx": 40,
+ "Ostrich-Walk.fbx": 61,
+ "Parrot-Attack.fbx": 181,
+ "Parrot-Circle_Fly.fbx": 235,
+ "Parrot-Die.fbx": 106,
+ "Parrot-Die_2.fbx": 78,
+ "Parrot-Die_3.fbx": 85,
+ "Parrot-Fly.fbx": 30,
+ "Parrot-Hover.fbx": 34,
+ "Parrot-Idle.fbx": 201,
+ "Parrot-Idle_2.fbx": 301,
+ "Parrot-Land.fbx": 91,
+ "Parrot-Preen.fbx": 181,
+ "Parrot-Rise.fbx": 61,
+ "Parrot-Walk.fbx": 46,
+ "Parrot2-Idle.fbx": 201,
+ "Parrot2-Idle_Clean.fbx": 202,
+ "Parrot2-Land.fbx": 301,
+ "Pigeon-Circle.fbx": 100,
+ "Pigeon-Cooing.fbx": 31,
+ "Pigeon-Fly_Loop.fbx": 10,
+ "Pigeon-Idle.fbx": 81,
+ "Pigeon-Idle_Loop.fbx": 301,
+ "Pigeon-Land.fbx": 66,
+ "Pigeon-Left.fbx": 81,
+ "Pigeon-Peck.fbx": 70,
+ "Pigeon-Right.fbx": 81,
+ "Pigeon-Take_Off.fbx": 28,
+ "Pigeon-Walk.fbx": 25,
+ "Pirrana-Biting.fbx": 60,
+ "Pirrana-Biting_2.fbx": 45,
+ "Pirrana-Dead_Float.fbx": 121,
+ "Pirrana-Dead_Float_2.fbx": 100,
+ "Pirrana-Dive_In.fbx": 61,
+ "Pirrana-Flopping.fbx": 45,
+ "Pirrana-Mid_Swim.fbx": 97,
+ "Pirrana-Rise_Top.fbx": 61,
+ "Pirrana-Swim.fbx": 97,
+ "Pirrana-Swim_Jump.fbx": 100,
+ "PolarBear-Attack.fbx": 100,
+ "PolarBear-Attack_2.fbx": 90,
+ "PolarBear-Attack_3.fbx": 150,
+ "PolarBear-Die.fbx": 111,
+ "PolarBear-Idle.fbx": 79,
+ "PolarBear-Idle_2.fbx": 181,
+ "PolarBear-Idle_3.fbx": 301,
+ "PolarBear-Run.fbx": 37,
+ "PolarBear-Walk.fbx": 70,
+ "PolarBearB-B_Idle_3.fbx": 181,
+ "PolarBearB-Fall.fbx": 84,
+ "PolarBearB-Get_Up.fbx": 181,
+ "PolarBearB-Idle.fbx": 90,
+ "PolarBearB-Idle_2.fbx": 121,
+ "PolarBearB-Play.fbx": 120,
+ "PolarBearB-Run.fbx": 42,
+ "PolarBearB-Walk.fbx": 61,
+ "Pteranodon-Arc_Left.fbx": 46,
+ "Pteranodon-Arc_Right.fbx": 46,
+ "Pteranodon-Death.fbx": 70,
+ "Pteranodon-Death_2.fbx": 40,
+ "Pteranodon-Fancy.fbx": 79,
+ "Pteranodon-Flapergasted.fbx": 46,
+ "Pteranodon-Fly_Loop.fbx": 91,
+ "Pteranodon-Glide_Scream.fbx": 73,
+ "Pteranodon-Hit.fbx": 46,
+ "Pteranodon-Hit_2.fbx": 46,
+ "Pteranodon-Lander.fbx": 79,
+ "Pteranodon-Scream_Fly.fbx": 73,
+ "Puppy-Idle_Energetic.fbx": 501,
+ "Puppy-Idle_Lay_Down.fbx": 501,
+ "Puppy-Run.fbx": 31,
+ "Puppy-Walk.fbx": 70,
+ "Raindeer-Attack.fbx": 91,
+ "Raindeer-Attack_2.fbx": 91,
+ "Raindeer-Attack_3.fbx": 120,
+ "Raindeer-Die.fbx": 91,
+ "Raindeer-Idle.fbx": 115,
+ "Raindeer-Run.fbx": 40,
+ "Raindeer-Stance.fbx": 91,
+ "Raindeer-Walk.fbx": 61,
+ "Raindeer-Yell.fbx": 211,
+ "Raptor-Attack.fbx": 79,
+ "Raptor-Die.fbx": 100,
+ "Raptor-Fast_Walk.fbx": 44,
+ "Raptor-Head_Smash.fbx": 91,
+ "Raptor-Idle.fbx": 274,
+ "Raptor-Idle_2.fbx": 201,
+ "Raptor-Leg_Scratch.fbx": 301,
+ "Raptor-Roar.fbx": 139,
+ "Raptor-Slow_Walk.fbx": 79,
+ "Raptor-Yawn.fbx": 301,
+ "Raptor2-Breathe_Idle.fbx": 76,
+ "Raptor2-Clean.fbx": 85,
+ "Raptor2-Die.fbx": 88,
+ "Raptor2-Die_2_Get_Up.fbx": 106,
+ "Raptor2-Die_Get_Up.fbx": 123,
+ "Raptor2-Eat.fbx": 67,
+ "Raptor2-Eat_Grass.fbx": 205,
+ "Raptor2-Egg_Tend.fbx": 220,
+ "Raptor2-Fall.fbx": 142,
+ "Raptor2-Fall_Get_Up.fbx": 190,
+ "Raptor2-Fence_Climb_Fall.fbx": 166,
+ "Raptor2-Idle.fbx": 226,
+ "Raptor2-Idle_Alert.fbx": 76,
+ "Raptor2-Idle_Bite_Apple.fbx": 205,
+ "Raptor2-Idle_Curious.fbx": 304,
+ "Raptor2-Idle_Forward.fbx": 226,
+ "Raptor2-Idle_Left.fbx": 226,
+ "Raptor2-Idle_Look_Left.fbx": 226,
+ "Raptor2-Idle_Look_Right.fbx": 226,
+ "Raptor2-Idle_Right.fbx": 226,
+ "Raptor2-Jump_Spin_Run.fbx": 97,
+ "Raptor2-Left_Head_Run.fbx": 109,
+ "Raptor2-Left_Run_Bite.fbx": 64,
+ "Raptor2-Reverse_Run.fbx": 61,
+ "Raptor2-Right_Head_Run.fbx": 52,
+ "Raptor2-Right_Run_Bite.fbx": 64,
+ "Raptor2-Run.fbx": 61,
+ "Raptor2-Run_Fall.fbx": 139,
+ "Raptor2-Run_Jump.fbx": 151,
+ "Raptor2-Run_Jump_Bite.fbx": 178,
+ "Raptor2-Run_Jump_Fall.fbx": 160,
+ "Raptor2-Run_Jump_Land_Back.fbx": 118,
+ "Raptor2-Run_Jump_Roll.fbx": 160,
+ "Raptor2-Run_Scream_Jump.fbx": 157,
+ "Raptor2-Run_To_Stop_Roar.fbx": 64,
+ "Raptor2-Run_To_Stop_Roar_2.fbx": 97,
+ "Raptor2-Spin_Run.fbx": 76,
+ "Raptor2-Stride.fbx": 49,
+ "Raptor2-Walk.fbx": 145,
+ "Raptor3-Attack_Right.fbx": 82,
+ "Raptor3-Bark_Forward.fbx": 82,
+ "Raptor3-Left_Puke.fbx": 82,
+ "Raptor3-Mean_Left.fbx": 112,
+ "Raptor3-Mean_Right.fbx": 112,
+ "Raptor3-Roar_Forward.fbx": 112,
+ "Raptor3-Roar_Left.fbx": 112,
+ "Raptor3-Roar_Right.fbx": 112,
+ "Raptor3-Run.fbx": 55,
+ "Raptor3-Step_Left.fbx": 112,
+ "Raptor3-Step_Right.fbx": 112,
+ "Raptor3-Step_Roar.fbx": 112,
+ "Raptor3-Yell.fbx": 112,
+ "Rat-Alert_Run.fbx": 107,
+ "Rat-Clean.fbx": 55,
+ "Rat-Eat.fbx": 133,
+ "Rat-Itch.fbx": 55,
+ "Rat-Scamper.fbx": 15,
+ "Rat-Trottle.fbx": 16,
+ "Rhino-Attack.fbx": 79,
+ "Rhino-Attack_2.fbx": 79,
+ "Rhino-Attack_3.fbx": 130,
+ "Rhino-Die.fbx": 160,
+ "Rhino-Idle.fbx": 139,
+ "Rhino-Idle_2.fbx": 201,
+ "Rhino-Idle_3.fbx": 301,
+ "Rhino-Run.fbx": 49,
+ "Rhino-Walk.fbx": 81,
+ "Roach-Bristle.fbx": 31,
+ "Roach-Fall.fbx": 19,
+ "Roach-Hop.fbx": 21,
+ "Roach-Left.fbx": 19,
+ "Roach-Move.fbx": 40,
+ "Roach-Scurry.fbx": 14,
+ "Roach-Shake.fbx": 31,
+ "Roach-Smelling.fbx": 100,
+ "Roach-Turn_Left.fbx": 20,
+ "Roach-Turn_Right.fbx": 20,
+ "Roach-Uppity.fbx": 27,
+ "SabreToothTiger-180RIght.fbx": 70,
+ "SabreToothTiger-180_Flip.fbx": 22,
+ "SabreToothTiger-45_Turn_Left.fbx": 35,
+ "SabreToothTiger-Agitated.fbx": 46,
+ "SabreToothTiger-Attack.fbx": 31,
+ "SabreToothTiger-Back_Up.fbx": 50,
+ "SabreToothTiger-Backing.fbx": 41,
+ "SabreToothTiger-Begg.fbx": 101,
+ "SabreToothTiger-Bite.fbx": 55,
+ "SabreToothTiger-Cage_Bat.fbx": 80,
+ "SabreToothTiger-Cowering.fbx": 41,
+ "SabreToothTiger-Cowering_2.fbx": 55,
+ "SabreToothTiger-Eating.fbx": 100,
+ "SabreToothTiger-Get_Up.fbx": 36,
+ "SabreToothTiger-Get_Up_2.fbx": 31,
+ "SabreToothTiger-Get_Up_Mad.fbx": 116,
+ "SabreToothTiger-Growling.fbx": 111,
+ "SabreToothTiger-Layout.fbx": 61,
+ "SabreToothTiger-Leaper.fbx": 31,
+ "SabreToothTiger-Left_Turn.fbx": 35,
+ "SabreToothTiger-Mean.fbx": 41,
+ "SabreToothTiger-Paw_Swatting.fbx": 66,
+ "SabreToothTiger-Pissed_Off.fbx": 36,
+ "SabreToothTiger-Pissed_Off_2.fbx": 36,
+ "SabreToothTiger-Raged.fbx": 80,
+ "SabreToothTiger-Roaring.fbx": 51,
+ "SabreToothTiger-Run.fbx": 23,
+ "SabreToothTiger-Sit.fbx": 31,
+ "SabreToothTiger-Sitting.fbx": 101,
+ "SabreToothTiger-Sitting_2.fbx": 101,
+ "SabreToothTiger-Slow_180.fbx": 70,
+ "SabreToothTiger-Snap.fbx": 61,
+ "SabreToothTiger-Spin_180.fbx": 29,
+ "SabreToothTiger-Stablize.fbx": 31,
+ "SabreToothTiger-Stalker.fbx": 44,
+ "SabreToothTiger-Start_Left.fbx": 22,
+ "SabreToothTiger-Start_Walk.fbx": 25,
+ "SabreToothTiger-Swat_Lft.fbx": 36,
+ "SabreToothTiger-Swim.fbx": 44,
+ "SabreToothTiger-Tired_Yawn.fbx": 31,
+ "SabreToothTiger-Trot.fbx": 36,
+ "SabreToothTiger-Turn_Left.fbx": 25,
+ "SabreToothTiger-Warning.fbx": 111,
+ "SandMouse-Attack.fbx": 90,
+ "SandMouse-Attack_2.fbx": 91,
+ "SandMouse-Die.fbx": 93,
+ "SandMouse-Die_2.fbx": 78,
+ "SandMouse-Die_3.fbx": 100,
+ "SandMouse-Dig_In.fbx": 94,
+ "SandMouse-Dig_Out.fbx": 91,
+ "SandMouse-Idle.fbx": 322,
+ "SandMouse-Idle_2.fbx": 220,
+ "SandMouse-Idle_3.fbx": 190,
+ "SandMouse-Idle_4.fbx": 301,
+ "SandMouse-Run.fbx": 21,
+ "SandMouse-Walk.fbx": 49,
+ "Scorpion-Agitated.fbx": 25,
+ "Scorpion-Attack_1.fbx": 46,
+ "Scorpion-Back_Up.fbx": 40,
+ "Scorpion-Defend.fbx": 241,
+ "Scorpion-Idle_Loop.fbx": 101,
+ "Scorpion-Recoil.fbx": 31,
+ "Scorpion-Recoil_2.fbx": 31,
+ "Scorpion-Slow_Forward.fbx": 80,
+ "Scorpion-Stinger.fbx": 31,
+ "Scorpion-Stretch_Arms.fbx": 100,
+ "Scorpion-Turn_Left.fbx": 31,
+ "Scorpion-Turn_Right.fbx": 31,
+ "Scorpion-Walk_Forward.fbx": 38,
+ "Scorpion2-Attack_Retreat.fbx": 91,
+ "Scorpion2-Back_Confused.fbx": 70,
+ "Scorpion2-Back_Up.fbx": 55,
+ "Scorpion2-Backing_Crazy.fbx": 55,
+ "Scorpion2-Belly_Death.fbx": 196,
+ "Scorpion2-Belly_Death_1.fbx": 40,
+ "Scorpion2-Bite_Attack.fbx": 70,
+ "Scorpion2-Bite_Grab.fbx": 160,
+ "Scorpion2-Blasted_Death.fbx": 55,
+ "Scorpion2-Death.fbx": 346,
+ "Scorpion2-Death_2.fbx": 184,
+ "Scorpion2-Flipped.fbx": 40,
+ "Scorpion2-Guns.fbx": 61,
+ "Scorpion2-Hasppy_Fangs.fbx": 49,
+ "Scorpion2-Hit_And_Sorr.fbx": 175,
+ "Scorpion2-Jump_Sting.fbx": 70,
+ "Scorpion2-Limp_Alive.fbx": 55,
+ "Scorpion2-Lunge_Forward.fbx": 67,
+ "Scorpion2-On_Back_Dying.fbx": 121,
+ "Scorpion2-Pissed_Fangs.fbx": 97,
+ "Scorpion2-Rising_Walk.fbx": 55,
+ "Scorpion2-Run_Attack.fbx": 49,
+ "Scorpion2-Run_To_Attrack.fbx": 46,
+ "Scorpion2-Settle_Back.fbx": 79,
+ "Scorpion2-Slide_Back.fbx": 49,
+ "Scorpion2-Slow_Idle.fbx": 97,
+ "Scorpion2-Stand_Attack.fbx": 76,
+ "Scorpion2-Stand_Ready.fbx": 55,
+ "Scorpion2-Standing_Run.fbx": 49,
+ "Scorpion2-Steady_Walk.fbx": 49,
+ "Scorpion2-Sting_Kill.fbx": 55,
+ "Scorpion2-Sting_Kill_2.fbx": 61,
+ "Scorpion2-Sting_Ya.fbx": 70,
+ "Scorpion2-Sting_Ya_YA.fbx": 61,
+ "Scorpion2-Strafe_Left.fbx": 49,
+ "Scorpion2-Strafe_Right.fbx": 49,
+ "Scorpion2-Walk_And_Rise.fbx": 40,
+ "Scorpion2-Walk_Forward.fbx": 55,
+ "Scorpion2-Wild_Death.fbx": 70,
+ "Skunk-Die.fbx": 85,
+ "Skunk-Idle.fbx": 79,
+ "Skunk-Idle_2.fbx": 120,
+ "Skunk-Idle_3.fbx": 181,
+ "Skunk-Run.fbx": 30,
+ "Skunk-Spray.fbx": 121,
+ "Skunk-Walk.fbx": 61,
+ "Spider-Attack_1.fbx": 35,
+ "Spider-Attack_2.fbx": 46,
+ "Spider-Attack_4.fbx": 46,
+ "Spider-Attack_5.fbx": 50,
+ "Spider-Attack_Left.fbx": 36,
+ "Spider-Attack_Right.fbx": 36,
+ "Spider-Back_Rear.fbx": 31,
+ "Spider-Backit_Up.fbx": 43,
+ "Spider-Barking.fbx": 37,
+ "Spider-Fangy.fbx": 301,
+ "Spider-Gliding.fbx": 91,
+ "Spider-Hurt.fbx": 151,
+ "Spider-Injured_Walk.fbx": 31,
+ "Spider-Jump.fbx": 46,
+ "Spider-LandinHAir.fbx": 31,
+ "Spider-Landing.fbx": 19,
+ "Spider-Rearing.fbx": 50,
+ "Spider-Retreat.fbx": 31,
+ "Spider-Retreat_Injured.fbx": 31,
+ "Spider-Retreat_Slow.fbx": 91,
+ "Spider-Riser.fbx": 35,
+ "Spider-Rising.fbx": 31,
+ "Spider-Run_Left.fbx": 31,
+ "Spider-Scary.fbx": 31,
+ "Spider-Scramble.fbx": 91,
+ "Spider-Slow_Idle.fbx": 151,
+ "Spider-Travel_Web.fbx": 49,
+ "Spider-Walk_Left.fbx": 31,
+ "Spider-Walk_Loop.fbx": 31,
+ "Spider-Walker.fbx": 31,
+ "Spider-Weaver.fbx": 49,
+ "Spider-Weaving.fbx": 70,
+ "SpiderG-Attack.fbx": 120,
+ "SpiderG-Attack_2.fbx": 120,
+ "SpiderG-Attack_3.fbx": 180,
+ "SpiderG-Attack_4.fbx": 160,
+ "SpiderG-Attack_5.fbx": 195,
+ "SpiderG-Attack_6.fbx": 175,
+ "SpiderG-Attack_7.fbx": 141,
+ "SpiderG-Burrough.fbx": 85,
+ "SpiderG-Come_Out.fbx": 70,
+ "SpiderG-Die.fbx": 274,
+ "SpiderG-Fangs.fbx": 270,
+ "SpiderG-Idle.fbx": 79,
+ "SpiderG-Idle_2.fbx": 199,
+ "SpiderG-Idle_3.fbx": 241,
+ "SpiderG-Retreat.fbx": 181,
+ "SpiderG-Run.fbx": 40,
+ "SpiderG-Shiver.fbx": 75,
+ "SpiderG-Walk.fbx": 91,
+ "Stego-Attack.fbx": 72,
+ "Stego-Attack_2.fbx": 72,
+ "Stego-Attack_3.fbx": 111,
+ "Stego-Fall.fbx": 151,
+ "Stego-Idle.fbx": 90,
+ "Stego-Idle_2.fbx": 151,
+ "Stego-Run.fbx": 60,
+ "Stego-Shake.fbx": 201,
+ "Stego-Slow_Walk.fbx": 121,
+ "Stego-Tail_Whip.fbx": 141,
+ "Trex-Big_Roar_Step.fbx": 136,
+ "Trex-Bite_90_Left.fbx": 89,
+ "Trex-Bite_90_Right.fbx": 81,
+ "Trex-Bite_Close_Left.fbx": 81,
+ "Trex-Bite_Close_Right.fbx": 67,
+ "Trex-Bite_Step_Back_Forward.fbx": 53,
+ "Trex-Chase_Bite.fbx": 53,
+ "Trex-Chase_Bite_Left.fbx": 53,
+ "Trex-Chase_Bite_Right.fbx": 81,
+ "Trex-Chase_Head_Butt_Left.fbx": 81,
+ "Trex-Chase_Roar.fbx": 136,
+ "Trex-Chase_Roar_Left.fbx": 136,
+ "Trex-Chase_Roar_Right.fbx": 136,
+ "Trex-Climb_Down.fbx": 121,
+ "Trex-Climb_Up.fbx": 123,
+ "Trex-Death.fbx": 40,
+ "Trex-Death_Short.fbx": 181,
+ "Trex-Head_Butt_Left.fbx": 77,
+ "Trex-Hit_Head_1.fbx": 151,
+ "Trex-Hit_Head_2.fbx": 64,
+ "Trex-Hit_Head_3.fbx": 64,
+ "Trex-Hit_Leg.fbx": 73,
+ "Trex-Hit_Leg_2.fbx": 76,
+ "Trex-Hit_Torso_Left.fbx": 79,
+ "Trex-Hit_Torso_Right.fbx": 79,
+ "Trex-Human_Bite.fbx": 123,
+ "Trex-Human_Kill.fbx": 75,
+ "Trex-Human_Shake.fbx": 153,
+ "Trex-Idle_Attack.fbx": 79,
+ "Trex-Idle_Attack_To_Run_Left.fbx": 57,
+ "Trex-Idle_Attack_To_Run_Right.fbx": 57,
+ "Trex-Idle_Investigae_Out.fbx": 75,
+ "Trex-Idle_Investigate.fbx": 85,
+ "Trex-Idle_Investigate_Loop.fbx": 171,
+ "Trex-Idle_Sneeze.fbx": 301,
+ "Trex-Idle_To_Run.fbx": 57,
+ "Trex-Kill_Long.fbx": 316,
+ "Trex-Long_Death.fbx": 556,
+ "Trex-Look_Forward.fbx": 118,
+ "Trex-Look_Forward_2.fbx": 118,
+ "Trex-Look_Left.fbx": 118,
+ "Trex-Look_Right.fbx": 118,
+ "Trex-Mama_Cave_Bite.fbx": 82,
+ "Trex-Mama_Cave_Bite_Loop.fbx": 76,
+ "Trex-Mama_Cave_Bite_Out.fbx": 123,
+ "Trex-Roar.fbx": 130,
+ "Trex-Roar_Left.fbx": 130,
+ "Trex-Roar_Right.fbx": 130,
+ "Trex-Run_Head_Butt_Right.fbx": 65,
+ "Trex-Run_Head_Loop.fbx": 79,
+ "Trex-Run_Head_Low.fbx": 77,
+ "Trex-Run_Head_Low_2.fbx": 77,
+ "Trex-Run_To_Stop.fbx": 45,
+ "Trex-Sprint_Head_Left.fbx": 97,
+ "Trex-Sprint_Head_Right.fbx": 97,
+ "Trex-Sprint_Loop.fbx": 81,
+ "Trex-Step_Back.fbx": 85,
+ "Trex-Stunned.fbx": 316,
+ "Trex-Turn_180_Look.fbx": 82,
+ "Trex-Turn_180_Right.fbx": 82,
+ "Trex-Turn_180_Turn_Right.fbx": 82,
+ "Trex-Turn_90_Left.fbx": 52,
+ "Trex-Turn_90_Right.fbx": 52,
+ "Trex-Walk_Back.fbx": 160,
+ "Trex-Walk_Bite.fbx": 82,
+ "Trex-Walk_Head_Low.fbx": 111,
+ "Trex-Walk_Left_Bite.fbx": 82,
+ "Trex-Walk_Loop.fbx": 97,
+ "Trex-Walk_Right_Bite.fbx": 82,
+ "Trex-Walk_Slow_Loop.fbx": 166,
+ "Tricera-Attack.fbx": 85,
+ "Tricera-Attack_2.fbx": 100,
+ "Tricera-Attack_3.fbx": 130,
+ "Tricera-Attack_4.fbx": 121,
+ "Tricera-Fall.fbx": 151,
+ "Tricera-Idle.fbx": 109,
+ "Tricera-Nose_Dirt.fbx": 201,
+ "Tricera-Run.fbx": 61,
+ "Tricera-Walk.fbx": 130,
+ "Tukan-Fly.fbx": 46,
+ "Tukan-Fly_Forward.fbx": 70,
+ "Tukan-Fly_Loop.fbx": 13,
+ "Tukan-Idle_Look.fbx": 55,
+ "Tukan-Shake.fbx": 49,
+ "Tukan-Slow_Down.fbx": 19,
+ "Tukan-Sqwak.fbx": 81,
+ "Tukan-Wing_Scratch.fbx": 64,
+ "Turtle-Attack.fbx": 91,
+ "Turtle-Attack_2.fbx": 160,
+ "Turtle-Attack_3.fbx": 181,
+ "Turtle-Hide.fbx": 157,
+ "Turtle-Idle.fbx": 100,
+ "Turtle-Idle_2.fbx": 160,
+ "Turtle-Onback.fbx": 148,
+ "Turtle-Run.fbx": 49,
+ "Turtle-Walk.fbx": 120,
+ "Turtle-Yawn.fbx": 300,
+ "Tyranno-Attack.fbx": 81,
+ "Tyranno-Attack_2.fbx": 76,
+ "Tyranno-Fall.fbx": 76,
+ "Tyranno-Head_Butt.fbx": 91,
+ "Tyranno-Idle.fbx": 91,
+ "Tyranno-Idle_2.fbx": 91,
+ "Tyranno-Roar.fbx": 151,
+ "Tyranno-Run.fbx": 76,
+ "Tyranno-Tail_Whip.fbx": 91,
+ "Tyranno-Walk.fbx": 145
+}

excluded.csv

@@ -0,0 +1,2 @@
+file,group,reason
+Truebone_Z-OO/Crocodile/CrocodileALL.fbx,Crocodile,not a binary FBX

scripts/README.md

@@ -0,0 +1,75 @@
+# Scripts
+
+```
+scripts/
+  pipeline/     the build steps, run in order
+  probes/       format readers — each parses BVH or binary FBX on its own
+```
+
+Pure Python 3 with no dependencies; step 5 additionally downloads from the Hugging Face Hub.
+Everything in `probes/` is importable on its own, and `pipeline/` puts those probes to work.
+
+Nothing in here re-exports a file. `animation/` is built by selecting and renaming, so a clip is a
+hardlink of one in `Truebone_Z-OO/` — a round trip through an editor would rebuild the rest pose from
+the first frame of the take and move the root bones. Sixteen clips are no longer hardlinks,
+because three probes repaired them by editing the binary node tree in place: the four `Cat` clips
+and all twelve `KingCobra` clips. Each writes a temporary file and renames it, so the source keeps
+its own inode and its bytes.
+
+## pipeline/
+
+```bash
+cd scripts
+python3 pipeline/build_dataset.py         # 1. index the download -> ../clips.csv
+python3 pipeline/normalize.py             # 2. name every clip    -> ../clips.csv
+python3 pipeline/build_animation.py       # 3. one file per motion-> ../animation/
+python3 pipeline/build_metadata.py        # 4. measure animation/ -> ../animation.csv, ../species.csv
+python3 pipeline/build_prompts.py         # 5. attach captions    -> ../animation_prompts.json
+```
+
+Step 5 is optional and stands apart from the rest: it is the only step that pulls from a third
+party, and what it pulls is CC-BY-NC-4.0.
+
+Each step reads what the one before it wrote, and each can be re-run on its own.
+
+| script | purpose |
+|---|---|
+| `build_dataset.py` | Walks `../Truebone_Z-OO/`, probes every BVH and FBX, writes `clips.csv`, and hardlinks the indexed files and their textures into `../Truebone_Z-OO/`. Files that fail to parse land in `excluded.csv`. |
+| `normalize.py` | Names every source FBX that carries motion `<Species>-<Action>.fbx` and fills the `normalized_name` column in `clips.csv`. Creates no files. Holds the naming rules — species aliases, compound words, canonical casing, Mixamo-style actions. |
+| `build_animation.py` | Builds `../animation/`: drops each group's combined `ALL` file and its `TPOSE` rest pose, removes the clips the source exported twice, hardlinks the rest. A file carrying more than one take is reported, never rewritten. |
+| `build_prompts.py` | Downloads the [T2M4LVO](https://huggingface.co/datasets/1Konny/t2m4lvo-truebones-zoo) captions and attaches them to `../animation/` through `clips.csv`, writing `../animation_prompts.json` — one `short`/`original` sentence per clip, in the Mixamo file's shape. `--full` adds all four lengths, seven phrasings and the alternative object labels. Resolves each caption to the phrasing that names the species — the source lists seven object labels alphabetically, so index 0 is usually the most generic one, not the animal. |
+| `build_metadata.py` | Measures `../animation/` into `animation.csv`, `species.csv`, `animation_frames.json` and `animation_bones.json`, and maps every row of `clips.csv` onto the clip that carries its motion (`animation_file`, `status`). |
+
+## probes/
+
+Each reads the file format itself and runs standalone from the command line.
+
+| script | purpose |
+|---|---|
+| `bvh_probe.py` | BVH `HIERARCHY` and `MOTION` headers: joints, end sites, tree depth, frames, frame time, fps, duration, root, joint names. Stops before the motion rows. |
+| `fbx_probe.py` | Binary FBX node tree: version, joints, keyframes, fps and duration measured off the key times, the topmost animated joint, joint names. |
+| `fbx_takes.py` | Enumerates a file's `AnimationStack` objects and each one's time span — the only way to tell a single clip from a combined timeline. |
+| `fbx_stacks.py` | Which of those stacks actually carry animation. Four files pair the real motion with an empty `Take 001` left by a C4D export; counting stacks calls them two-take, following the connections shows one action and one empty shell. |
+| `fbx_motion.py` | Whether a clip moves at all: decodes the curves and reports the widest value range. Used to keep T-poses and model-only exports out of the clip set. |
+| `fbx_fingerprint.py` | Per-curve value ranges — a cheap first pass for spotting repeated motions. |
+| `fbx_curves.py` | Decodes curve values and compares two clips frame by frame, to confirm what the range test only suggests. |
+| `fbx_rig.py` | Bone-length fingerprint, for checking that a species' clips share one skeleton. |
+| `fbx_anomaly.py` | Flags sudden jumps in a curve — first-frame pops, gimbal reparameterizations, broken frames. |
+| `fbx_check.py` | Structural integrity: header, node tree, truncation. |
+| `fbx_embed_texture.py` | Grafts an embedded texture into an FBX that only references one externally. Parses the node tree, inserts one `Video/Content` node copied verbatim from a donor of the same species, and re-serializes with recomputed offsets — every node record holds an absolute end offset, so an insertion shifts everything after it. Gated on a byte-identical no-edit round trip, and writes through a temporary file so hardlinked sources are left alone. Used once, for the four `Cat` clips. |
+| `fbx_graft_mesh.py` | Grafts a mesh and its skin from a donor FBX into one exported without geometry. Moves `Geometry::Mesh`, `Model::Mesh`, `Deformer::Skin`, its `Cluster`s and `Pose::BindPose` across on fresh uids, re-points every connection that referenced the donor's bones, materials or textures at the target's own by name, and drops the target's orphan deformers. Also collapses a `Texture → LayeredTexture → Material` chain to the direct connection importers look for. `--bind` decides whose bind pose — whose rest pose, as an importer shows it — the repaired clip ends up with: `donor` (the default) adopts the donor's, which is what keeps a species' clips sharing one rest pose; `self` keeps the target's own and re-poses the grafted mesh to match; a path takes a third file's. Same round-trip gate and same temporary-file write as `fbx_embed_texture.py`. `--inspect` reports what geometry and skin any file holds. Used once, for `KingCobra-Walk.fbx`. |
+| `fbx_strip_variant.py` | Keeps one colourway of a mesh that ships several stacked on top of each other. Drops the other materials' polygons, renumbers the surviving vertices and follows them through every array that indexes them — normals and colours per vertex, UV indices per polygon vertex, the material array per polygon, and each skin cluster's indices and weights — then removes the materials, textures and embedded images nothing references any more. Where one image exists as two `Video` objects and the pixels hang off the slot being removed, they are moved onto the surviving one first. The material is named rather than indexed, because the two KingCobra export batches connect the same materials in opposite orders. `--list` shows what variants a file carries. Used once, for the twelve `KingCobra` clips. |
+| `fbx_align_material.py` | Gives a clip's materials the same settings its siblings use. Matches materials by name and moves only the values inside `Properties70`, keeping each file's own property type strings, shading model and textures; a property the reference lacks is removed, one only the reference has is added. `--diff` reports what differs without writing. Used once, for `KingCobra-Walk.fbx`, whose `ReflectionFactor` made Blender import it at `Metallic` 0.0 while every other clip in the library imports at 1.0. |
+
+```bash
+python3 probes/fbx_probe.py       ../animation/Cat-Walk.fbx
+python3 probes/fbx_graft_mesh.py  --inspect ../animation/*.fbx
+python3 probes/fbx_takes.py       ../Truebone_Z-OO/Lynx/LynxALL.fbx
+python3 probes/bvh_probe.py       ../Truebone_Z-OO/Cat/CAT_Walk.bvh
+python3 probes/fbx_curves.py      ../animation/Crab-Attack_1.fbx ../animation/Crab-Attack_3.fbx
+```
+
+The two header probes skip the motion payload, so indexing the whole 2.8 GB library takes about
+twenty seconds. The curve-level tools decompress the payload and are correspondingly slower.
+
+

scripts/pipeline/build_animation.py

@@ -0,0 +1,156 @@
+#!/usr/bin/env python3
+"""Build ../animation/: one flat folder, one file per distinct motion.
+
+Files are named `<Species>-<Action>.fbx`, so the species travels with the file
+rather than living in a directory: `Cat-Walk.fbx`, `Trex-Big_Roar_Step.fbx`.
+The action never contains a hyphen, so `name.split("-", 1)` recovers both parts.
+
+Every file here holds exactly one animation take, so a clip is a motion and
+nothing else.
+
+Starts from the names `normalize.py` recorded in `clips.csv` and drops two
+kinds of redundancy:
+
+1. `ALL.fbx`, the combined take that repeats every clip in its group, and
+   `TPOSE.fbx`, the rest pose. Both are recognised by name, not by amplitude:
+   most T-poses are perfectly flat and are dropped earlier as static, but one
+   (`Tukan`) drifts by a degree or two and would otherwise pass for a clip. A
+   threshold cannot separate the two — a genuine `Die_Loop` or `Sleep_Loop`
+   moves no more than that drifting T-pose does — but the name settles it, since
+   `TPOSE` is a reserved marker in `normalize.py` and never names a motion.
+2. Clips that are the same motion exported twice. The source ships some groups
+   in two batches — `Gazelle-Run.fbx` alongside a bare `run.fbx`, `PolarBearB-Idle.fbx`
+   alongside `B idle 1.fbx` — and the second batch is often mislabelled
+   (`die.fbx` actually holds the Fall motion). Candidates are found by comparing
+   each animation curve's value range, then confirmed frame by frame, because
+   the range test alone pairs up distinct motions that happen to span the same
+   extents.
+
+Which twin survives is decided in three steps. The shorter clip wins, since the
+longer one carries a static tail. On a tie the clip from the group's primary
+batch wins — the batch whose filenames carry the species prefix — because the
+second batch is the one that abbreviates and, in several groups, mislabels. On
+a tie there too the lower ordinal wins, so a group keeps `Attack_1` rather than
+`Attack_2`.
+
+Nothing here is re-exported. Every clip is a hardlink straight into
+`Truebone_Z-OO/`, byte for byte, so the set costs almost no extra disk and no
+clip carries a rig that a round trip through an editor has altered. A source file holding more than
+one take is reported rather than repaired, and a take that exists only inside a
+group's combined file stays there — `Lynx/Idle4` is the one such case.
+"""
+import csv, os, re, shutil, sys
+HERE = os.path.dirname(os.path.abspath(__file__))
+SCRIPTS = os.path.dirname(HERE)
+ROOT = os.path.dirname(SCRIPTS)
+sys.path[:0] = [HERE, os.path.join(SCRIPTS, "probes")]
+from fbx_fingerprint import probe as fingerprint
+from fbx_takes import probe as takes
+from fbx_curves import same_motion
+from normalize import infer_aliases, norm_species, _base_species, _alnum, RESERVED
+from fbx_stacks import takes_with_motion
+
+DST = os.path.join(ROOT, "animation")
+
+
+def secondary_batch(rows):
+    """The clip names whose source filename does not carry the species prefix.
+
+    Groups shipped in two batches name them differently: `Gazelle-HeadPoke.fbx`
+    against a bare `atk 1.fbx`, `POLARBEARB-Idle.fbx` against `B idle 1.fbx`.
+    The prefixed batch is the primary one — the other abbreviates and, in
+    several groups, mislabels. Used only to break ties between exact duplicates.
+    """
+    alias = infer_aliases(rows)
+    out = set()
+    for r in rows:
+        if not r.get("normalized_name"):
+            continue
+        sp = norm_species(r["group"])
+        stem = _alnum(os.path.splitext(os.path.basename(r["file"]))[0])
+        cands = [_alnum(sp), _alnum(_base_species(sp))]
+        a = alias.get((sp, r["format"]))
+        if a:
+            cands.append(a)
+        if not any(c and stem.startswith(c) for c in cands):
+            out.add(r["normalized_name"])
+    return out
+
+
+def main():
+    rows = list(csv.DictReader(open(os.path.join(ROOT, "clips.csv"))))
+    os.makedirs(DST, exist_ok=True)
+    kept = []
+    for r in sorted(rows, key=lambda r: r["file"]):
+        name = r.get("normalized_name")
+        if not name:
+            continue
+        if os.path.splitext(name)[0].split("-", 1)[1] in RESERVED:
+            continue
+        t = os.path.join(DST, name)
+        if not os.path.exists(t):
+            try: os.link(os.path.join(ROOT, r["file"]), t)
+            except OSError: shutil.copy2(os.path.join(ROOT, r["file"]), t)
+        kept.append(t)
+    print("linked %d clips (%s excluded)" % (len(kept), ", ".join(sorted(RESERVED))))
+
+    groups = {}
+    for p in kept:
+        r = fingerprint(p)
+        mv = tuple(sorted((a, b) for a, b in r["ranges"] if b - a > 1e-6))
+        if mv:
+            species = os.path.basename(p).split("-", 1)[0]
+            groups.setdefault((species, mv), []).append(p)
+
+    second = secondary_batch(rows)
+
+    def rank(p):
+        action = os.path.splitext(os.path.basename(p))[0].split("-", 1)[1]
+        m = re.search(r"_(\d+)$", action)
+        return (takes(p)["total_sec"], os.path.basename(p) in second,
+                int(m.group(1)) if m else 1, action, os.path.getsize(p))
+
+    removed = 0
+    for files in groups.values():
+        if len(files) < 2:
+            continue
+        files.sort(key=rank)
+        keep = files[0]
+        for other in files[1:]:
+            ok, _ = same_motion(keep, other)
+            if ok:
+                os.remove(other); removed += 1
+                print("  duplicate of %s: removed %s"
+                      % (os.path.relpath(keep, ROOT), os.path.relpath(other, ROOT)))
+    print("removed %d duplicates -> %d files" % (removed, len(kept) - removed))
+
+    # One action per clip is a property of the source, not something imposed here.
+    # Reported, never repaired: rewriting a file would mean re-exporting it, and a
+    # round trip through an editor rebuilds the rest pose from the first frame and
+    # quietly moves the root bones.
+    #
+    # Counting stacks is not the same as counting actions. Four files pair the real
+    # motion with an empty `Take 001` left behind by a C4D export — a stack with no
+    # curves under it at all — so what matters is how many stacks carry animation.
+    multi, shells = [], []
+    for f in sorted(os.listdir(DST)):
+        p = os.path.join(DST, f)
+        n_stacks = takes(p)["num_takes"]
+        n_real = takes_with_motion(p)
+        if n_real > 1:
+            multi.append((f, n_real))
+        elif n_stacks > n_real:
+            shells.append((f, n_stacks - n_real))
+    if multi:
+        print("WARNING: %d clip(s) carry more than one action:" % len(multi))
+        for f, n in multi:
+            print("   %-34s %d actions" % (f, n))
+    else:
+        print("every clip holds exactly one action")
+    if shells:
+        print("(%d also carry an empty leftover stack: %s)"
+              % (len(shells), ", ".join(f for f, _ in shells)))
+
+
+if __name__ == "__main__":
+    main()

scripts/pipeline/build_dataset.py

@@ -0,0 +1,79 @@
+#!/usr/bin/env python3
+"""Index the source library: one row per motion file in `Truebone_Z-OO/`.
+
+Step 1. Walks the original download in place, probes every BVH and FBX, and
+writes `clips.csv`. Nothing is copied: `Truebone_Z-OO/` is the download exactly
+as it shipped and stays the one copy of it, with `fbx/` and `animation/`
+hardlinked to it further down the pipeline. Files that fail to parse are listed
+in `excluded.csv` and left out.
+
+Skeleton and timeline come from the file headers, but `has_motion` does not: a
+clip can carry ninety keyframes that all hold the same pose, so the curves are
+decoded and their ranges measured. That is what makes this step take minutes
+rather than seconds, and it is what keeps every T-pose out of `fbx/`.
+
+    build_dataset.py -> normalize.py -> build_animation.py -> build_metadata.py
+"""
+import csv, os, re, sys, time
+HERE = os.path.dirname(os.path.abspath(__file__))
+SCRIPTS = os.path.dirname(HERE)
+ROOT = os.path.dirname(SCRIPTS)
+sys.path[:0] = [HERE, os.path.join(SCRIPTS, "probes")]
+from bvh_probe import probe as bvh_probe
+from fbx_probe import probe as fbx_probe
+from fbx_motion import probe as motion_probe
+
+SRC_DIR = "Truebone_Z-OO"                       # the download, inside the repo
+SRC = sys.argv[1] if len(sys.argv) > 1 else os.path.join(ROOT, SRC_DIR)
+
+CLIP_COLS=["file","group","format","clip_name","num_joints","frames","fps","duration_sec",
+           "root_joint","fbx_version","probe_error","has_motion"]
+
+def main():
+    groups=sorted(d for d in os.listdir(SRC) if os.path.isdir(os.path.join(SRC,d)))
+    rows=[]; excluded=[]; t0=time.time()
+    for g in groups:
+        gdir=os.path.join(SRC,g)
+        for dp,dn,fn in os.walk(gdir):
+            for f in sorted(fn):
+                ext=os.path.splitext(f)[1].lower()
+                if ext not in (".bvh",".fbx"): continue
+                p=os.path.join(dp,f)
+                rel=os.path.relpath(p,SRC)
+                r={"file":SRC_DIR+"/"+rel.replace(os.sep,"/"),"group":g,
+                   "format":ext[1:],"clip_name":os.path.splitext(f)[0],
+                   "num_joints":"","frames":"","fps":"","duration_sec":"",
+                   "root_joint":"","fbx_version":"","probe_error":"","has_motion":""}
+                try:
+                    if ext==".bvh":
+                        b=bvh_probe(p,motion=True)
+                        r.update(num_joints=b["num_joints"],frames=b["frames"],fps=b["fps"],
+                                 duration_sec=b["duration_sec"],root_joint=b["root"],
+                                 has_motion=str(b["has_motion"]).lower())
+                    else:
+                        x=fbx_probe(p)
+                        m=motion_probe(p)
+                        r.update(num_joints=x["num_joints"],frames=x["keyframes"],
+                                 fps=x["fps"] or "",duration_sec=x["duration_sec"] or "",
+                                 root_joint=x["root_joint"],fbx_version=x["fbx_version"],
+                                 has_motion=str(not (m["static"] or m["no_curves"])).lower())
+                except Exception as e:
+                    r["probe_error"]=str(e)[:80]
+                    excluded.append({"file":r["file"],"group":g,"reason":str(e)[:100]}); continue
+                if ext==".bvh" and int(r["frames"] or 0) < 2:
+                    excluded.append({"file":r["file"],"group":g,
+                                     "reason":"truncated: %s frame(s)"%r["frames"]}); continue
+                rows.append(r)
+        print("  %-18s %d files  %.0fs"%(g,sum(1 for x in rows if x["group"]==g),time.time()-t0),flush=True)
+
+    with open(os.path.join(ROOT,"clips.csv"),"w",newline="",encoding="utf-8") as fh:
+        w=csv.DictWriter(fh,fieldnames=CLIP_COLS); w.writeheader(); w.writerows(rows)
+    print("clips.csv  ->",len(rows),"rows")
+
+    if excluded:
+        with open(os.path.join(ROOT,"excluded.csv"),"w",newline="",encoding="utf-8") as fh:
+            w=csv.DictWriter(fh,fieldnames=["file","group","reason"]); w.writeheader(); w.writerows(excluded)
+        print("excluded.csv ->",len(excluded),"rows (unparseable files skipped)")
+    print("%.0fs"%(time.time()-t0))
+
+if __name__=="__main__": main()

scripts/pipeline/build_metadata.py

@@ -0,0 +1,234 @@
+#!/usr/bin/env python3
+"""Index ../animation/ and map every source clip onto it.
+
+`animation/` is the dataset: one FBX per distinct motion, each holding exactly
+one take. Everything reported about the library is measured there, so this
+script writes the two tables that describe it —
+
+    animation.csv          one row per clip in animation/
+    species.csv            one row per species, aggregated from animation.csv
+    animation_frames.json  clip -> frame count
+    animation_bones.json   species -> its joint names
+
+— and fills two columns in `clips.csv` that say, for every file in `Truebone_Z-OO/`,
+which animation clip carries its motion and why it is not itself in the set:
+
+    animation_file  the clip in animation/ that holds this motion
+    status          linked | mirror | duplicate | combined | combined_only | static | orphan
+
+A source clip is `linked` when animation/ holds that exact file, `mirror` when
+it is the BVH export of a clip already there, `duplicate` when the source shipped
+the same motion twice under two names, `combined` for a group's `ALL` file,
+`static` when it carries no motion at all (every T-pose, plus model-only
+exports), and `orphan` for a rig that belongs to no group.
+
+`combined_only` marks the one motion the library ships with no standalone FBX of
+its own — `Lynx/Idle4`, which exists as a BVH and as a take inside `LynxALL.fbx`
+and nowhere else. Cutting it out would mean re-exporting it, and a round trip
+through an editor rebuilds the rest pose from the first frame, so the clip would
+no longer share its species' skeleton. It stays where the source put it.
+
+Source clips are matched to animation clips by name first, then by content:
+same species and the same length to within a frame, confirmed curve by curve for
+FBX. That second pass is what pairs the BVH exports, whose names do not always
+agree with their FBX twins (`__BearRun.bvh` against `BEAR-BearRun.fbx`).
+"""
+import collections, csv, json, os, sys
+
+HERE = os.path.dirname(os.path.abspath(__file__))
+SCRIPTS = os.path.dirname(HERE)
+ROOT = os.path.dirname(SCRIPTS)
+sys.path[:0] = [HERE, os.path.join(SCRIPTS, "probes")]
+from fbx_probe import probe as fbx_probe
+from fbx_takes import probe as takes_probe
+from fbx_stacks import takes_with_motion
+from fbx_curves import same_motion
+import normalize as N
+
+ANIM = os.path.join(ROOT, "animation")
+
+ANIM_COLS = ["file", "species", "action", "take", "num_takes", "num_actions", "num_joints", "root_joint",
+             "frames", "fps", "duration_sec", "fbx_version", "bytes", "num_source_files"]
+SPECIES_COLS = ["species", "num_clips", "num_joints", "rig_variants", "root_joint",
+                "total_frames", "total_duration_sec", "mean_duration_sec", "num_textures",
+                "source_fbx", "source_bvh", "has_combined_all", "has_tpose"]
+
+
+def index_animation(clip_joints):
+    rows = []
+    for f in sorted(os.listdir(ANIM)):
+        if not f.endswith(".fbx"):
+            continue
+        p = os.path.join(ANIM, f)
+        species, action = os.path.splitext(f)[0].split("-", 1)
+        x, t = fbx_probe(p), takes_probe(p)
+        clip_joints[f] = x["joints"]
+        rows.append({
+            "file": "animation/" + f, "species": species, "action": action,
+            "take": t["takes"][0][0] if t["takes"] else "", "num_takes": t["num_takes"],
+            "num_actions": takes_with_motion(p),
+            "num_joints": x["num_joints"], "root_joint": x["root_joint"],
+            "frames": x["keyframes"], "fps": x["fps"], "duration_sec": x["duration_sec"],
+            "fbx_version": x["fbx_version"], "bytes": os.path.getsize(p),
+            "num_source_files": 0,
+        })
+    return rows
+
+
+def normalized_names(clips):
+    """(species, action) for every source row, under the naming rules of normalize.py."""
+    rows = sorted(clips, key=lambda r: r["file"])
+    alias = N.infer_aliases(rows)
+    prelim = [N.norm_action(os.path.splitext(os.path.basename(r["file"]))[0],
+                            r["group"], alias, r["format"]) for r in rows]
+    canon = N.canonical_case(prelim)
+    return {r["file"]: (N.norm_species(r["group"]), N.mixamo_style(canon[a.lower()]))
+            for r, a in zip(rows, prelim)}
+
+
+def main():
+    clip_joints = {}
+    anim = index_animation(clip_joints)
+    by_name = {(r["species"], r["action"]): r for r in anim}
+    by_species = collections.defaultdict(list)
+    for r in anim:
+        by_species[r["species"]].append(r)
+
+    clips = list(csv.DictReader(open(os.path.join(ROOT, "clips.csv"))))
+    names = normalized_names(clips)
+    # build_dataset.py leaves fps/duration/root empty for FBX rows because its
+    # first pass reads headers only. Fill them here, where the key times are
+    # decoded anyway.
+    for r in clips:
+        if r["format"] != "fbx" or r["fps"]:
+            continue
+        try:
+            x = fbx_probe(os.path.join(ROOT, r["file"]))
+        except Exception:
+            continue
+        r["fps"] = x["fps"] or ""
+        r["duration_sec"] = x["duration_sec"] or ""
+        r["root_joint"] = x["root_joint"]
+
+    unmatched = []
+    for r in clips:
+        sp, act = names[r["file"]]
+        r["animation_file"], r["status"] = "", ""
+        # The exact file animation/ holds. `normalized_name` is not always
+        # `<species>-<action>.fbx`: three clips carry a `_2` suffix so that two
+        # names differing only in case can coexist on this filesystem.
+        if r.get("normalized_name"):
+            target = "animation/" + r["normalized_name"]
+            if os.path.exists(os.path.join(ROOT, target)):
+                r["animation_file"], r["status"] = target, "linked"
+                continue
+        if r["file"] in N.EXCLUDE_SOURCES:
+            r["status"] = "orphan"; continue
+        # Order matters: 21 groups ship a bind-pose model named after the species
+        # alone, which normalizes to `ALL` but holds no take at all.
+        # A T-pose is a rest pose whatever its curves say — one of them drifts by
+        # a degree over its 60 frames, which is motion by measurement and nothing
+        # by intent — so the name decides here, not `has_motion`.
+        if r["has_motion"] != "true" or act == "TPOSE":
+            r["status"] = "static"; continue
+        if act == "ALL":
+            r["status"] = "combined"; continue
+        # Same motion under another name, or the BVH twin of an FBX already in the
+        # set: same species, same length to within a frame. Several candidates are
+        # ranked by how close the action names are, and an FBX match is confirmed
+        # curve by curve before it is accepted.
+        want = int(r["frames"] or 0)
+        cands = [a for a in by_species.get(sp, []) if abs(a["frames"] - want) <= 1]
+        if (sp, act) in by_name:
+            cands = [by_name[(sp, act)]] + [c for c in cands if c is not by_name[(sp, act)]]
+        hit = ""
+        for c in cands:
+            if r["format"] == "fbx":
+                ok, _ = same_motion(os.path.join(ROOT, r["file"]), os.path.join(ROOT, c["file"]))
+                if not ok:
+                    continue
+            hit = c["file"]; break
+        if hit:
+            r["animation_file"] = hit
+            r["status"] = "mirror" if r["format"] == "bvh" else "duplicate"
+        else:
+            r["status"] = "combined_only"
+            unmatched.append((r["file"], sp, act, want))
+
+    counts = collections.Counter(r["animation_file"] for r in clips if r["animation_file"])
+    for a in anim:
+        a["num_source_files"] = counts.get(a["file"], 0)
+
+    tex, src_fbx, src_bvh, tpose, comb = (collections.Counter() for _ in range(5))
+    for r in clips:
+        sp, act = names[r["file"]]
+        (src_fbx if r["format"] == "fbx" else src_bvh)[sp] += 1
+        if act == "TPOSE": tpose[sp] += 1
+        if r["status"] == "combined": comb[sp] += 1
+    for dp, dn, fn in os.walk(os.path.join(ROOT, "Truebone_Z-OO")):
+        for f in fn:
+            if os.path.splitext(f)[1].lower() in (".jpg", ".jpeg", ".png", ".tga"):
+                tex[N.norm_species(os.path.relpath(dp, os.path.join(ROOT, "Truebone_Z-OO")).split(os.sep)[0])] += 1
+
+    species = []
+    for sp in sorted(by_species):
+        cs = by_species[sp]
+        dur = sum(c["duration_sec"] for c in cs)
+        joints = sorted({c["num_joints"] for c in cs})
+        roots = sorted({c["root_joint"] for c in cs})
+        variants = len({tuple(clip_joints[c["file"].split("/")[-1]]) for c in cs})
+        species.append({
+            "species": sp, "num_clips": len(cs), "rig_variants": variants,
+            "num_joints": joints[0] if len(joints) == 1 else "|".join(map(str, joints)),
+            "root_joint": roots[0] if len(roots) == 1 else "|".join(roots),
+            "total_frames": sum(c["frames"] for c in cs),
+            "total_duration_sec": round(dur, 3),
+            "mean_duration_sec": round(dur / len(cs), 3),
+            "num_textures": tex.get(sp, 0),
+            "source_fbx": src_fbx.get(sp, 0), "source_bvh": src_bvh.get(sp, 0),
+            "has_combined_all": str(comb.get(sp, 0) > 0).lower(),
+            "has_tpose": str(tpose.get(sp, 0) > 0).lower(),
+        })
+
+    def write(name, cols, rows):
+        with open(os.path.join(ROOT, name), "w", newline="", encoding="utf-8") as fh:
+            w = csv.DictWriter(fh, fieldnames=cols, extrasaction="ignore")
+            w.writeheader(); w.writerows(rows)
+        print("%-16s -> %d rows" % (name, len(rows)))
+
+    # The two per-clip sidecars, shaped like the Mixamo set's: a flat map from
+    # filename to one value, sorted by key.
+    frames = {r["file"].split("/")[-1]: r["frames"] for r in anim}
+    # A species' joint list is the one its clips most often have — a real rig, not
+    # a pooled vocabulary. Pooling looked tidier but produced a list that matched
+    # no actual file: `Monkey` clips carry 88 joints each and the union ran to 91,
+    # because every clip names the container node of the mesh variant it was
+    # exported with (`Monkey_A01` against `Monkey_B02`).
+    seen = collections.defaultdict(collections.Counter)
+    for r in anim:
+        seen[r["species"]][tuple(clip_joints[r["file"].split("/")[-1]])] += 1
+    bones = {sp: list(c.most_common(1)[0][0]) for sp, c in seen.items()}
+    def dump(name, obj):
+        with open(os.path.join(ROOT, name), "w", encoding="utf-8") as fh:
+            json.dump(obj, fh, indent=1, ensure_ascii=False)
+        print("%-22s -> %d keys" % (name, len(obj)))
+    dump("animation_frames.json", {k: frames[k] for k in sorted(frames)})
+    dump("animation_bones.json", {k: sorted(bones[k]) for k in sorted(bones)})
+
+    write("animation.csv", ANIM_COLS, anim)
+    write("species.csv", SPECIES_COLS, species)
+    cols = [c for c in clips[0] if c not in ("animation_file", "status")] + ["animation_file", "status"]
+    write("clips.csv", cols, clips)
+
+    st = collections.Counter(r["status"] for r in clips)
+    print("\nstatus:", dict(st))
+    print("animation clips with no source row:",
+          sum(1 for a in anim if a["num_source_files"] == 0),
+          [a["file"] for a in anim if a["num_source_files"] == 0])
+    print("source clips with motion and no clip of their own:", len(unmatched))
+    for u in unmatched[:20]:
+        print("   ", u)
+
+
+if __name__ == "__main__":
+    main()

scripts/pipeline/build_prompts.py

@@ -0,0 +1,192 @@
+"""Build animation_prompts.json: a text prompt for every clip in animation/.
+
+Step 5, optional. Pulls the human-written captions of T2M4LVO — the annotation
+set from *How to Move Your Dragon* (ICML 2025), which describes Truebones
+motions but ships no motion data — and attaches them to this dataset's clips.
+
+    https://huggingface.co/datasets/1Konny/t2m4lvo-truebones-zoo
+
+Captions are keyed by the original Truebones filename, so `clips.csv` is what
+makes the join exact: source path -> animation clip. 1,088 of the 1,099 clips
+get a prompt; the rest are written out with nulls rather than dropped.
+
+Organised like `animation_prompts.json` in the Mixamo set: a flat map from
+filename to a small flat record, sorted by key, with absent fields left out
+rather than set to null. Which source file was annotated is not repeated here —
+`clips.csv` already maps every path in `Truebone_Z-OO/` onto its clip.
+
+One prompt per clip — the source's `short` length and `original` phrasing, in
+the wording that names the species. The source also carries three longer
+lengths, six further phrasings, and each sentence rewritten with six more
+general object labels; `--full` adds all of that to the same file for anyone
+who wants it as caption augmentation.
+
+T2M4LVO does not describe nine of the clips — most of them near-motionless
+idles, which is what an annotator skips. Those carry a caption written here
+instead and are marked `prompt_source: "inferred"` so they can be filtered out.
+They are not human annotations and should not be evaluated as if they were.
+
+Each was written from two things: a rendered strip of the clip, and a per-frame
+profile of the posed skeleton — every joint's world-space path length over the
+whole timeline, split into six spans so the order of events is visible. The
+profile is measured on the posed rig rather than read off the rotation curves,
+because an Euler channel wrapping from 180 to -180 reads as an enormous move
+while the bone barely turns, and several of these clips are quiet enough for that
+artefact to dominate. Phrasing follows the same species' existing captions, and each names at
+most two things: the pose the animal holds and the one part that moves most.
+
+T2M4LVO is CC-BY-NC-4.0: non-commercial use only, which is narrower than the
+rest of this repository.
+"""
+import collections, csv, difflib, json, os, re, sys
+from huggingface_hub import snapshot_download
+
+HERE = os.path.dirname(os.path.abspath(__file__))
+SCRIPTS = os.path.dirname(HERE)
+ROOT = os.path.dirname(SCRIPTS)
+
+CAPTIONS_REPO = "1Konny/t2m4lvo-truebones-zoo"
+# Written from rendered frames, not by an annotator watching playback. Kept in
+# the source so a rebuild reproduces them; `prompt_source` marks them apart.
+INFERRED = {
+    "Ant-Idle_3.fbx":
+        "An ant stands in place, working its mandibles.",
+    "Centipede-Idle_3.fbx":
+        "A centipede stays on the ground, stirring its legs.",
+    "Cricket-Idle.fbx":
+        "A cricket stands still, slowly sweeping its antennae.",
+    "Cricket-Idle_Pissed.fbx":
+        "A cricket bristles in place, whipping its antennae.",
+    "Fox-Idle_2.fbx":
+        "A fox stands still, gently swaying its tail.",
+    "Hound-Idle.fbx":
+        "A hound stands at attention, almost motionless.",
+    "KingCobra-Steady.fbx":
+        "A king cobra holds still, flicking its tongue out midway.",
+    "KingCobra-Walk.fbx":
+        "A king cobra winds its body and tail from side to side.",
+    "Trex-Look_Forward.fbx":
+        "A tyrannosaurus rex stands facing forward, swinging its tail.",
+}
+
+LEVELS = ("short", "mid", "long", "long_rich")
+STYLES = ("original", "synonyms", "structure", "voice", "detail", "action", "figurative")
+alnum = lambda s: re.sub(r"[^A-Za-z0-9]", "", s).upper()
+
+
+def slot_of(js, level, style):
+    """Index of the sentence that names the actual species, not the alphabetically-first label."""
+    pat = re.compile(r"\b%s\b" % re.escape(js["object_name"].strip().lower()))
+    hit = [i for i, s in enumerate(js["captions"][level][style]) if pat.search(s.lower())]
+    if len(hit) != 1:                       # synonyms/figurative swap the noun ~1-5% of the time
+        hit = [i for i, s in enumerate(js["captions"][level]["original"]) if pat.search(s.lower())]
+    return hit[0]
+
+
+def name_variants(sentences, i):
+    """The seven object labels the same sentence is written with.
+
+    All seven differ only in the noun phrase, so each is diffed word-wise against
+    the one naming the species — whose label is known — and the first replaced
+    span is the label. Diffing rather than taking a common prefix keeps names of
+    different word counts intact (`hoofed mammal`) and copes with sentences that
+    name the animal twice (`a deer ... pushed back by another deer`), where a
+    prefix/suffix cut would swallow the whole middle.
+    """
+    ref = sentences[i].split()
+    out = []
+    for k, s in enumerate(sentences):
+        if k == i:
+            out.append(" ".join(ref[1:]).split(" ")[0] if False else None)
+            continue
+        w = s.split()
+        blocks = [b for b in difflib.SequenceMatcher(None, ref, w).get_opcodes()
+                  if b[0] == "replace"]
+        label = " ".join(w[blocks[0][3]:blocks[0][4]]).strip(" ,.") if blocks else ""
+        # `A deer` against `An animal` differs in the article too, so the diff
+        # block can start one word early; the article is not part of the label.
+        out.append(re.sub(r"^(?:an?|the)\s+", "", label, flags=re.I))
+    # the species sentence keeps the label already known for it
+    out[i] = None
+    return out
+
+
+def main():
+    CAP = os.path.join(snapshot_download(CAPTIONS_REPO, repo_type="dataset",
+                                         allow_patterns=["captions/**"]), "captions")
+    clips = list(csv.DictReader(open(os.path.join(ROOT, "clips.csv"))))
+    src_index = {(alnum(os.path.basename(os.path.dirname(r["file"]))),
+                  alnum(os.path.splitext(os.path.basename(r["file"]))[0])): r
+                 for r in clips if r["format"] == "fbx"}
+
+    # caption file -> the animation clip it describes, via clips.csv
+    hits = collections.defaultdict(list)
+    for dp, dn, fn in os.walk(CAP):
+        for f in sorted(fn):
+            if not f.endswith(".json"):
+                continue
+            row = src_index.get((alnum(os.path.basename(dp)), alnum(f[:-5])))
+            if row and row["animation_file"]:      # skips ALL files and the one T-pose caption
+                hits[os.path.basename(row["animation_file"])].append(
+                    (os.path.join(dp, f), row["file"]))
+
+    out = {}
+    for f in sorted(os.listdir(os.path.join(ROOT, "animation"))):
+        if not f.endswith(".fbx"):
+            continue
+        species = f[:-4].split("-", 1)[0]
+        entry = {"species": species, "action": f[:-4].split("-", 1)[1],
+                 "object_name": None, "orientation": None, "prompt": None,
+                 "prompts": None, "object_name_variants": None,
+                 "source_fbx": [], "source_caption": []}
+        for path, srcfbx in hits.get(f, []):
+            js = json.load(open(path))
+            entry["source_caption"].append("captions/" + os.path.relpath(path, CAP))
+            entry["source_fbx"].append(srcfbx)
+            if entry["prompt"]:                    # a second annotation of the same motion
+                entry.setdefault("alt_prompts", []).append(
+                    js["captions"]["short"]["original"][slot_of(js, "short", "original")])
+                continue
+            entry["object_name"] = js["object_name"]
+            entry["orientation"] = js["orientation"]
+            entry["prompts"] = {lv: {st: js["captions"][lv][st][slot_of(js, lv, st)]
+                                     for st in STYLES} for lv in LEVELS}
+            entry["prompt"] = entry["prompts"]["short"]["original"]
+            v = name_variants(js["captions"]["short"]["original"], slot_of(js, "short", "original"))
+            v[v.index(None)] = js["object_name"].strip().lower()
+            entry["object_name_variants"] = v
+        out[f] = entry
+
+    full = "--full" in sys.argv
+    slim = {}
+    for k in sorted(out):
+        v = out[k]
+        rec = {}
+        if not v["prompt"] and k in INFERRED:
+            rec["prompt"] = INFERRED[k]
+            rec["prompt_source"] = "inferred"
+        elif v["prompt"]:
+            rec["object_name"] = v["object_name"]
+            rec["prompt"] = v["prompt"]
+            rec["prompt_source"] = "t2m4lvo"
+            if v.get("alt_prompts"):
+                rec["alt_prompt"] = v["alt_prompts"][0]
+            if full:
+                rec["object_name_variants"] = v["object_name_variants"]
+                rec["prompts"] = v["prompts"]
+        slim[k] = dict(sorted(rec.items()))
+
+    dst = os.path.join(ROOT, "animation_prompts.json")
+    json.dump(slim, open(dst, "w"), indent=1, ensure_ascii=False)
+    have = [k for k, v in slim.items() if v]
+    inf = [k for k, v in slim.items() if v.get("prompt_source") == "inferred"]
+    print("clips: %d | with a prompt: %d (%d inferred) | without: %d"
+          % (len(slim), len(have), len(inf), len(slim) - len(have)))
+    print("second annotation:", sum(1 for v in slim.values() if "alt_prompt" in v))
+    print("mode: %s" % ("full - all 4 levels x 7 styles" if full else "short/original only"))
+    print("written: %s  %.2f MB" % (dst, os.path.getsize(dst) / 1e6))
+    print("\nno prompt:", [k for k, v in slim.items() if not v])
+
+
+if __name__ == "__main__":
+    main()

scripts/pipeline/normalize.py

@@ -0,0 +1,280 @@
+#!/usr/bin/env python3
+"""Name every source motion uniformly, and record the name in clips.csv.
+
+    <Species>-<Action>.fbx
+
+Step 2. Creates no files: it fills the `normalized_name` column, and
+`build_animation.py` is what puts those names on disk. Naming rule: the species
+travels with the file rather than living in a directory, and the action never
+contains a hyphen, so `name.split("-", 1)` recovers both parts.
+Spaces, source hyphens and stray punctuation become underscores and runs of
+underscores collapse, leaving names that are safe as identifiers, in shell
+globs and on any filesystem.
+
+    Trex/T-Rex-Big roar step.fbx  ->  Trex-Big_Roar_Step.fbx
+    Dog-2/DOG-Attack.fbx          ->  Dog2-Attack.fbx
+
+A species prefix already present in the source name is stripped so it is not
+repeated. Folders whose files are named after something else — an abbreviation,
+a synonym, or a misspelling — are handled by inferring each folder's dominant
+filename prefix from the data rather than by string-matching the folder name. Files are hardlinked, so this costs no extra disk; `Truebone_Z-OO/` keeps the
+original layout and names, and `clips.csv` carries both paths.
+"""
+import collections, csv, os, re, sys
+
+HERE = os.path.dirname(os.path.abspath(__file__))
+SCRIPTS = os.path.dirname(HERE)
+ROOT = os.path.dirname(SCRIPTS)
+sys.path[:0] = [HERE, os.path.join(SCRIPTS, "probes")]
+
+from fbx_motion import probe as motion_probe
+
+
+def _alnum(s):
+    return re.sub(r"[^A-Za-z0-9]", "", s).upper()
+
+
+def norm_species(group):
+    """Species names are joined straight through: `Dog-2` -> `Dog2`."""
+    return re.sub(r"[^A-Za-z0-9]", "", group)
+
+
+def _base_species(sp):
+    """`Scorpion2` -> `Scorpion`, `SpiderG` -> `Spider`: drop a trailing variant marker."""
+    b = re.sub(r"\d+$", "", sp)
+    if len(b) > 4 and b[-1].isupper() and b[-2].islower():
+        b = b[:-1]
+    return b
+
+
+def _eat(s, prefix):
+    """Drop as many alphanumeric characters from the front of s as prefix has."""
+    i = cnt = 0
+    while i < len(s) and cnt < len(prefix):
+        if s[i].isalnum(): cnt += 1
+        i += 1
+    return s[i:]
+
+
+def infer_aliases(rows, min_share=0.6, min_len=3):
+    """Per (species, format), the prefix its filenames actually use.
+
+    Folder names do not always match what is inside them: `Leapord/` holds
+    `Leopard-*.fbx`, `Jaws/` holds `Shark-*.fbx`, `SabreToothTiger/` holds
+    `SABREALL-*.fbx`. String-matching the folder name cannot catch synonyms,
+    abbreviations or misspellings, so the dominant leading token is taken from
+    the files themselves. A trailing `ALL` is left off the alias so that variant
+    marker survives into the action, and aliases shorter than `min_len` are
+    ignored so single-letter markers (`PolarBearB`, `Giantbee`) are not eaten.
+    """
+    by = {}
+    for r in rows:
+        key = (norm_species(r["group"]), r["format"])
+        stem = os.path.splitext(os.path.basename(r["file"]))[0].lstrip("_")
+        by.setdefault(key, []).append(stem)
+    alias = {}
+    for key, stems in by.items():
+        toks = [re.split(r"[\s\-_]+", s)[0] for s in stems if s]
+        if not toks:
+            continue
+        top, n = collections.Counter(toks).most_common(1)[0]
+        if n / len(toks) < min_share:
+            continue
+        a = _alnum(top)
+        if a.endswith("ALL") and len(a) > 4:
+            a = a[:-3]
+        sp = _alnum(key[0])
+        if len(a) >= min_len and a != sp and not a.startswith(sp):
+            alias[key] = a
+    return alias
+
+
+def norm_action(stem, group, alias=None, fmt=None):
+    """Strip a repeated species prefix, then normalize what is left.
+
+    The full species name is tried first, then the base name, so a group whose
+    files are named after the base (`Scorpion-Back Up.fbx` inside `Scorpion-2/`)
+    does not end up with the species twice. Matching consumes characters rather
+    than whole tokens, so a variant marker fused to the species survives:
+    `AlligatorALL-BigMouth` keeps its `ALL`.
+    """
+    s = stem.strip().lstrip("_")
+    sp = norm_species(group)
+    cands = [_alnum(sp), _alnum(_base_species(sp))]
+    if alias:
+        a = alias.get((sp, fmt))
+        if a:
+            cands.append(a)
+    cands += EXTRA_ALIASES.get(sp, [])
+    for cand in cands:
+        if cand and _alnum(s).startswith(cand):
+            s = _eat(s, cand); break
+    s = re.sub(r"[\s\-]+", "_", s)
+    s = re.sub(r"[^A-Za-z0-9_]", "_", s)
+    # A name that is nothing but the species belongs to that group's combined file,
+    # the same role `<Species>ALL.fbx` plays elsewhere, so it lands on ALL too.
+    s = re.sub(r"_+", "_", s).strip("_") or "ALL"
+    # The `ALL` export marker is only meaningful on the combined take, which has
+    # no action of its own. On a single clip it says nothing, so drop it there.
+    m = re.match(r"^[Aa][Ll][Ll]_(.+)$", s)
+    s = m.group(1) if m else s
+    for pat, rep in WORD_FIXES.get(norm_species(group), []):
+        s = re.sub(pat, rep, s)
+    return s
+
+
+RESERVED = {"ALL", "TPOSE"}
+
+# Spelling variants the dominant-prefix inference cannot see, because they occur
+# on a single file while a different spelling dominates the folder. `Pirrana/`
+# holds eleven `Piranna-*.fbx` plus one `PirhannaALL.fbx` — a third spelling of
+# the same species. Fuzzy matching was tried and rejected: at an edit distance
+# loose enough to catch this, it also swallowed the real action `Shiver` in
+# `SpiderG/`. Listed explicitly instead.
+EXTRA_ALIASES = {"Pirrana": ["PIRHANNA"]}
+
+# Groups whose combined ALL file spells an action out while the standalone clips
+# abbreviate it. Folding the abbreviation into the full word makes the two agree,
+# so `ALL` lists exactly the clips the folder holds. Scoped per group: `Gazelle`
+# is left alone because it ships `Attack_1` and `Atk_1` as separate motions, and
+# `Monkey` because its ALL diverges for other reasons besides spelling.
+WORD_FIXES = {
+    # Matched case-insensitively: the source spells it `atk 1.fbx` in lower case,
+    # and capitalisation only happens further down the pipeline.
+    "Elephant": [(r"(?<![A-Za-z])[Aa][Tt][Kk](?![A-Za-z])", "Attack")],
+    "Fox":      [(r"(?<![A-Za-z])[Aa][Tt][Kk](?![A-Za-z])", "Attack")],
+    "Monkey":   [(r"(?<![A-Za-z])[Aa][Tt][Kk](?![A-Za-z])", "Attack")],
+}
+
+# Source files deliberately left out of fbx/. `Bird/Bird.fbx` rigs a second,
+# unrelated bird: 36 joints over 390 vertices with `Bone*` names, against the
+# 62 joints over 2,173 vertices with `BN_*` names used by every other Bird clip.
+# It shares no bone name with any of the 74 groups and appears in no BVH, so it
+# is an orphan model rather than a variant, and keeping it would break the one-
+# skeleton-per-species-folder assumption.
+EXCLUDE_SOURCES = {"Truebone_Z-OO/Bird/Bird.fbx"}
+
+# Compound words the source ran together with no camel-case boundary to split on
+# (`Roarforward`, `Walkbackward`). Automatic word segmentation against a
+# vocabulary built from the library both missed cases and produced false splits
+# (`Layout` -> `Lay_out`), so these are listed explicitly instead. Group context
+# resolved the odd ones: `Flamingo-OneLEgBEnt` is a flamingo on one leg.
+COMPOUNDS = {
+    "Injuredwalk": "Injured_Walk", "Landflap": "Land_Flap",
+    "Leashjump": "Leash_Jump", "MeanLEft": "Mean_Left",
+    "OneLEgBEnt": "One_Leg_Bent", "Roarforward": "Roar_Forward",
+    "Runleft": "Run_Left", "Slowtail": "Slow_Tail",
+    "Startwalk": "Start_Walk", "Swimturn": "Swim_Turn",
+    "Twistrattle": "Twist_Rattle", "WalkSLow": "Walk_Slow",
+    "Walkbackward": "Walk_Backward", "Walkleft": "Walk_Left",
+}
+
+
+def mixamo_style(action):
+    """Underscore-separated words, each capitalised, trailing variant as `_2`.
+
+    Matches the convention used by the Mixamo animation set: `Bite_Arm_Shake`,
+    `Walk_Loop`, `Attack_1`. Word boundaries are taken from camel case and from
+    letter/digit transitions. A split that would leave a one-character fragment
+    is skipped, so source typos and variant codes are not mangled — `180RIght`
+    (a misspelling of Right) and `CarrionC_A02` stay intact rather than becoming
+    `180_R_Ight` and `Carrion_C_A_02`. The `ALL` and `TPOSE` markers are left uppercase.
+    """
+    if action in RESERVED:
+        return action
+    if action in COMPOUNDS:
+        return COMPOUNDS[action]
+    words = []
+    for seg in action.split("_"):
+        if not seg:
+            continue
+        t = seg
+        t = re.sub(r"(?<=[a-z0-9])(?=[A-Z])", "\x00", t)
+        t = re.sub(r"(?<=[A-Z])(?=[A-Z][a-z])", "\x00", t)
+        t = re.sub(r"(?<=[A-Za-z])(?=\d)", "\x00", t)
+        t = re.sub(r"(?<=\d)(?=[A-Za-z])", "\x00", t)
+        parts = [p for p in t.split("\x00") if p]
+        if len(seg) > 2 and any(len(p) == 1 and p.isalpha() for p in parts):
+            parts = [seg]
+        words += parts
+    return "_".join(w[0].upper() + w[1:] for w in words) or action
+
+
+def canonical_case(actions):
+    """One spelling per action across the whole library.
+
+    Source casing is inconsistent — `TPOSE`/`Tpose`, `Idle`/`IDLE`/`idle`,
+    `WalkLoop`/`walkloop` all occur. For each action the most frequent spelling
+    wins, which keeps well-formed internal capitals (`WalkLoop`, not
+    `Walkloop`). An all-caps spelling is left alone so markers like `ALL` and
+    `TPOSE` stay markers; anything else gets its first letter capitalised so no
+    lowercase-only names survive.
+    """
+    counts = collections.defaultdict(collections.Counter)
+    for a in actions:
+        counts[a.lower()][a] += 1
+    canon = {}
+    for key, variants in counts.items():
+        best = sorted(variants.items(), key=lambda kv: (-kv[1], kv[0]))[0][0]
+        if not best.isupper() and best and best[0].islower():
+            best = best[0].upper() + best[1:]
+        canon[key] = best
+    return canon
+
+
+def main():
+    rows = list(csv.DictReader(open(os.path.join(ROOT, "clips.csv"))))
+    rows.sort(key=lambda r: r["file"])          # deterministic disambiguation order
+    alias = infer_aliases(rows)
+    taken, made, renamed = set(), {"bvh": 0, "fbx": 0}, []
+    prelim = []
+    for r in rows:
+        stem = os.path.splitext(os.path.basename(r["file"]))[0]
+        prelim.append(norm_action(stem, r["group"], alias, r["format"]))
+    canon = canonical_case(prelim)
+
+    for r, raw_act in zip(rows, prelim):
+        r["normalized_name"] = ""
+        if r["format"] != "fbx":          # bvh is not part of the clip set
+            continue
+        if r["file"] in EXCLUDE_SOURCES:
+            continue
+        # Skip FBX that carry no motion at all: keyframes whose values never
+        # change (including every TPOSE) and files with no animation curves.
+        try:
+            m = motion_probe(os.path.join(ROOT, r["file"]))
+            if m["static"] or m["no_curves"]:
+                continue
+        except Exception:
+            pass
+        sp = norm_species(r["group"])
+        act = mixamo_style(canon[raw_act.lower()])
+        name = "%s-%s.fbx" % (sp, act)
+        # macOS/Windows filesystems are case-insensitive: `Gazelle-run.fbx` and
+        # `Gazelle-Run.fbx` are the same path there, so compare case-folded and
+        # give the later file a numeric suffix instead of silently losing it.
+        n = 2
+        while name.lower() in taken:
+            name = "%s-%s_%d.fbx" % (sp, act, n); n += 1
+            if n == 3: renamed.append(name)
+        taken.add(name.lower())
+        r["normalized_name"] = name
+        made["fbx"] += 1
+
+    # `normalized_file` is what this column used to be called, back when the
+    # names were also written out as an `fbx/` tree; drop it if an older
+    # clips.csv is being re-normalized in place.
+    cols = [c for c in rows[0] if c not in ("normalized_name", "normalized_file")]
+    cols.insert(1, "normalized_name")
+    for r in rows:
+        r.pop("normalized_file", None)
+    with open(os.path.join(ROOT, "clips.csv"), "w", newline="", encoding="utf-8") as fh:
+        w = csv.DictWriter(fh, fieldnames=cols); w.writeheader(); w.writerows(rows)
+
+    print("named %d clips | case-disambiguated: %d" % (made["fbx"], len(renamed)))
+    for x in renamed[:10]:
+        print("   suffixed:", os.path.basename(x))
+
+
+if __name__ == "__main__":
+    main()

scripts/probes/bvh_probe.py

@@ -0,0 +1,76 @@
+#!/usr/bin/env python3
+"""Parse a BVH file's HIERARCHY and MOTION headers.
+
+Only the header is read — motion rows are skipped — so probing a whole library
+costs almost nothing. Pass `motion=True` to also scan the rows and report whether
+any channel actually changes: a clip can carry 91 frames that all hold the same
+pose, and every T-pose does.
+"""
+import os, re, sys
+
+def probe(path, motion=False):
+    joints, ends, root = [], 0, None
+    frames, frame_time = 0, 0.0
+    depth, max_depth = 0, 0
+    in_motion = False
+    has_motion = False
+    with open(path, "r", encoding="utf-8", errors="replace") as f:
+        for line in f:
+            s = line.strip()
+            if not in_motion:
+                if s.startswith("ROOT "):
+                    root = s[5:].strip(); joints.append(root)
+                elif s.startswith("JOINT "):
+                    joints.append(s[6:].strip())
+                elif s.startswith("End Site"):
+                    ends += 1
+                elif s == "{":
+                    depth += 1; max_depth = max(max_depth, depth)
+                elif s == "}":
+                    depth -= 1
+                elif s == "MOTION":
+                    in_motion = True
+            else:
+                if s.startswith("Frames:"):
+                    try: frames = int(s.split(":", 1)[1])
+                    except ValueError: pass
+                elif s.lower().startswith("frame time"):
+                    try: frame_time = float(s.split(":", 1)[1])
+                    except ValueError: pass
+                    if not motion:
+                        break                  # header done; skip the motion rows
+                    lo = hi = None
+                    for row in f:
+                        try:
+                            vals = [float(x) for x in row.split()]
+                        except ValueError:
+                            continue
+                        if not vals:
+                            continue
+                        if lo is None:
+                            lo, hi = list(vals), list(vals)
+                        else:
+                            n = min(len(lo), len(vals))
+                            for i in range(n):
+                                if vals[i] < lo[i]: lo[i] = vals[i]
+                                if vals[i] > hi[i]: hi[i] = vals[i]
+                    has_motion = bool(lo) and max(h - l for l, h in zip(lo, hi)) > 1e-6
+                    break
+    fps = round(1.0 / frame_time, 3) if frame_time > 0 else 0.0
+    out = {
+        "root": root or "", "num_joints": len(joints), "num_end_sites": ends,
+        "max_depth": max_depth, "frames": frames,
+        "frame_time": round(frame_time, 6), "fps": fps,
+        "duration_sec": round(frames * frame_time, 4) if frame_time > 0 else 0.0,
+        "joint_names": "|".join(joints)[:400],
+    }
+    if motion:
+        out["has_motion"] = has_motion
+    return out
+
+if __name__ == "__main__":
+    for p in sys.argv[1:]:
+        r = probe(p)
+        print("%-34s joints=%-4d frames=%-5d fps=%-5s %.2fs root=%s" % (
+            os.path.basename(p), r["num_joints"], r["frames"], r["fps"],
+            r["duration_sec"], r["root"]))

scripts/probes/fbx_align_material.py

@@ -0,0 +1,117 @@
+#!/usr/bin/env python3
+"""Give a clip's materials the same settings its siblings use.
+
+    fbx_align_material.py --diff <reference> <fbx>...       what differs
+    fbx_align_material.py --from <reference> <fbx>...       align, in place
+
+Materials are matched by name, and only the values inside `Properties70` move —
+the property's own type strings, the shading model, the textures and everything
+outside the material are left alone. A property the reference does not have is
+removed; one only the reference has is added.
+
+This exists for `KingCobra-Walk.fbx`, whose material block is anomalous in the
+same way the rest of that file was. It is the only clip in the library that sets
+`ReflectionFactor`, and Blender reads that property as the Principled `Metallic`
+input: with it absent the importer defaults to 1.0, so the clip came in at 0.0
+while its eleven siblings — and every other clip in the library — came in at 1.0.
+The visible result was a paler, greyer snake. Four more properties differed
+alongside it (`Shininess`, `ShininessExponent`, `Specular`, `SpecularColor`),
+with no effect in Blender but no reason to keep them apart either.
+
+Aligning to a sibling rather than writing `ReflectionFactor` into the other 1,096
+clips keeps the library uniform without baking one renderer's default for an
+unspecified property into the data.
+
+Correctness gate: with no edits the serializer must reproduce its input byte for
+byte. Writes through a temporary file and renames it into place.
+"""
+import os, sys
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+from fbx_graft_mesh import parse, serialize, objects, clean, sval, Node
+
+
+def props_of(node):
+    p70 = next((ch for ch in node.children if ch.name == b"Properties70"), None)
+    return p70, {} if p70 is None else {
+        clean(pn.props[0][1]): pn for pn in p70.children if pn.props}
+
+
+def materials(tree):
+    return {clean(n): node for u, (c, n, s, node) in objects(tree).items()
+            if c == b"Material"}
+
+
+def value(pn):
+    return tuple(round(v, 6) if isinstance(v, float) else v
+                 for v in (sval(x) for x in pn.props[4:]))
+
+
+def diff(ref_path, path):
+    ref, cur = materials(parse(ref_path)), materials(parse(path))
+    out = []
+    for name, node in sorted(cur.items()):
+        if name not in ref: continue
+        _, a = props_of(node)
+        _, b = props_of(ref[name])
+        for k in sorted(set(a) | set(b)):
+            va = value(a[k]) if k in a else None
+            vb = value(b[k]) if k in b else None
+            if va != vb: out.append((name, k, va, vb))
+    return out
+
+
+def align(ref_path, path):
+    t = parse(path)
+    ref = materials(parse(ref_path))
+    changed = []
+    for name, node in materials(t).items():
+        if name not in ref: continue
+        p70, a = props_of(node)
+        _, b = props_of(ref[name])
+        if p70 is None: continue
+        for k in sorted(set(a) | set(b)):
+            va = value(a[k]) if k in a else None
+            vb = value(b[k]) if k in b else None
+            if va == vb: continue
+            if k not in b:
+                p70.children.remove(a[k]); changed.append((name, k, va, "删除"))
+            elif k not in a:
+                cp = Node(b"P"); cp.props = list(b[k].props)
+                p70.children.append(cp); changed.append((name, k, "新增", vb))
+            else:
+                # keep this file's own type strings, take the reference's values
+                a[k].props = a[k].props[:4] + list(b[k].props[4:])
+                changed.append((name, k, va, vb))
+    data = serialize(t)
+    tmp = path + ".tmp"
+    with open(tmp, "wb") as fh: fh.write(data)
+    os.replace(tmp, path)
+    return changed, len(data)
+
+
+def main(argv):
+    if len(argv) < 3 or argv[0] not in ("--diff", "--from"):
+        print(__doc__); return 2
+    mode, ref, targets = argv[0], argv[1], argv[2:]
+    for p in targets:
+        if serialize(parse(p)) != open(p, "rb").read():
+            print("拒绝执行：%s 无法字节级往返" % p); return 1
+        if mode == "--diff":
+            d = diff(ref, p)
+            print("%s  vs  %s" % (os.path.basename(p), os.path.basename(ref)))
+            for name, k, va, vb in d:
+                print("    %-34s %-20s %-22s → %s" % (name, k, va, vb))
+            if not d: print("    材质属性已一致")
+        else:
+            before = os.path.getsize(p)
+            ch, size = align(ref, p)
+            print("%s  ←  %s" % (os.path.basename(p), os.path.basename(ref)))
+            for name, k, va, vb in ch:
+                print("    %-20s %-22s → %s" % (k, str(va)[:22], vb))
+            print("    %d → %d 字节" % (before, size))
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main(sys.argv[1:]))

scripts/probes/fbx_anomaly.py

@@ -0,0 +1,102 @@
+#!/usr/bin/env python3
+"""Look for discontinuities in an FBX's animation curves.
+
+Reports the largest frame-to-frame step in each curve, relative to how that
+curve normally moves. Rotation tracks are stored in degrees and wrap at ±180,
+so a 179° -> -179° step is a 2° move, not a 358° one; those are unwrapped first,
+otherwise nearly every turning clip looks broken.
+
+A curve is called discontinuous when its biggest step is large in absolute terms
+and also several times the *second* largest step. Fast but smooth motion has many
+comparable steps, so nothing stands out; a teleport or a snapped pose produces one
+isolated spike. Comparing against a percentile instead fails here, because most
+curves barely move and their percentile sits at ~0, making every ratio explode.
+"""
+import os, struct, sys, zlib
+
+SCALAR = {"Y": 2, "C": 1, "I": 4, "F": 4, "D": 8, "L": 8}
+ELEM   = {"f": 4, "d": 8, "l": 8, "i": 4, "b": 1}
+FMT    = {"f": "f", "d": "d", "l": "q", "i": "i", "b": "b"}
+
+
+def _curves(path):
+    d = open(path, "rb").read()
+    if d[:21] != b"Kaydara FBX Binary  \x00":
+        raise ValueError("not a binary FBX")
+    u64 = struct.unpack("<I", d[23:27])[0] >= 7500
+    N = 25 if u64 else 13
+    out = []
+
+    def rp(p, want):
+        t = chr(d[p]); s = p; p += 1
+        if t in SCALAR: p += SCALAR[t]; return p, None
+        if t in ELEM:
+            n, enc, cl = struct.unpack("<III", d[p:p+12]); p += 12
+            body = cl if enc else n * ELEM[t]
+            raw = d[p:p+body]; p += body
+            if want and n:
+                try:
+                    if enc: raw = zlib.decompress(raw)
+                    return p, struct.unpack("<%d%s" % (n, FMT[t]), raw[:n*ELEM[t]])
+                except Exception: return p, None
+            return p, None
+        if t in "SR":
+            ln = struct.unpack("<I", d[p:p+4])[0]; p += 4 + ln; return p, None
+        raise ValueError("bad prop")
+
+    def rn(p):
+        if u64: e, np_, pl = struct.unpack("<QQQ", d[p:p+24]); q = p+24
+        else:   e, np_, pl = struct.unpack("<III", d[p:p+12]); q = p+12
+        if e == 0 and np_ == 0 and pl == 0: return p + N
+        nl = d[q]; q += 1; nm = d[q:q+nl]; q += nl
+        p = q; want = nm == b"KeyValueFloat"; v = None
+        for _ in range(np_):
+            p, x = rp(p, want)
+            if x is not None: v = x
+        if want and v: out.append(v)
+        while p < e:
+            if d[p:p+N] == b"\x00"*N: p += N; break
+            p = rn(p)
+        return e
+
+    p = 27
+    while p < len(d) - 160:
+        if d[p:p+N] == b"\x00"*N: break
+        p = rn(p)
+    return out
+
+
+def probe(path, abs_min=45.0, ratio=4.0):
+    worst = 0.0; worst_ratio = 0.0; bad = 0; n = 0
+    for c in _curves(path):
+        if len(c) < 3: continue
+        rng = max(c) - min(c)
+        if rng <= 1e-6: continue
+        n += 1
+        degrees = rng > 20.0            # rotation tracks span tens of degrees
+        deltas = []
+        for i in range(1, len(c)):
+            dv = c[i] - c[i-1]
+            if degrees and abs(dv) > 180.0:
+                dv -= 360.0 if dv > 0 else -360.0      # unwrap
+            deltas.append(abs(dv))
+        if not deltas: continue
+        s = sorted(deltas, reverse=True)
+        mx = s[0]; second = s[1] if len(s) > 1 else 0.0
+        r = mx / second if second > 1e-9 else (float("inf") if mx > abs_min else 0.0)
+        if mx > worst: worst = mx
+        if r != float("inf") and r > worst_ratio: worst_ratio = r
+        if mx >= abs_min and r >= ratio: bad += 1
+    return {"curves": n, "max_step": round(worst, 3),
+            "max_ratio": round(worst_ratio, 1), "discontinuous_curves": bad}
+
+
+if __name__ == "__main__":
+    for f in sys.argv[1:]:
+        try:
+            r = probe(f)
+            print("%-34s curves=%-4d max_step=%-9.2f ratio=%-7.1f bad=%d" % (
+                os.path.basename(f), r["curves"], r["max_step"], r["max_ratio"],
+                r["discontinuous_curves"]))
+        except Exception as e:
+            print("%-34s ERROR %s" % (os.path.basename(f), str(e)[:50]))

scripts/probes/fbx_check.py

@@ -0,0 +1,87 @@
+#!/usr/bin/env python3
+"""Integrity check for binary FBX.
+
+Beyond "does it parse": walks the whole node tree and verifies the walk lands in
+the footer region, which catches truncated or padded files that a shallow parse
+would accept. Also reports skeleton and geometry presence so empty shells show up.
+"""
+import os, struct, sys
+
+SCALAR = {"Y": 2, "C": 1, "I": 4, "F": 4, "D": 8, "L": 8}
+ELEM   = {"f": 4, "d": 8, "l": 8, "i": 4, "b": 1}
+
+
+def check(path):
+    size = os.path.getsize(path)
+    r = {"size": size, "ok": False, "reason": "", "version": None,
+         "joints": 0, "meshes": 0, "verts": 0, "curves": 0, "end_gap": None}
+    if size == 0:
+        r["reason"] = "zero bytes"; return r
+    d = open(path, "rb").read()
+    if d[:21] != b"Kaydara FBX Binary  \x00":
+        r["reason"] = "bad magic (not a binary FBX)"; return r
+    r["version"] = struct.unpack("<I", d[23:27])[0]
+    u64 = r["version"] >= 7500
+    NREC = 25 if u64 else 13
+    joints = set(); meshes = 0; verts = 0; curves = 0
+
+    def rd_prop(p):
+        t = chr(d[p]); s = p; p += 1
+        if t in SCALAR: p += SCALAR[t]; return p, (t, d[s+1:p], None)
+        if t in ELEM:
+            n, enc, clen = struct.unpack("<III", d[p:p+12]); p += 12
+            p += clen if enc else n * ELEM[t]
+            return p, (t, None, n)
+        if t in "SR":
+            ln = struct.unpack("<I", d[p:p+4])[0]; p += 4
+            v = d[p:p+ln]; p += ln
+            return p, (t, v, None)
+        raise ValueError("bad property type %r at %d" % (t, s))
+
+    def rd_node(p, depth=0):
+        nonlocal meshes, verts, curves
+        if depth > 64: raise ValueError("node nesting too deep")
+        if p + (24 if u64 else 12) > len(d): raise ValueError("header past EOF")
+        if u64: end, nprop, plen = struct.unpack("<QQQ", d[p:p+24]); q = p+24
+        else:   end, nprop, plen = struct.unpack("<III", d[p:p+12]); q = p+12
+        if end == 0 and nprop == 0 and plen == 0: return p + NREC
+        if end > len(d): raise ValueError("node end offset past EOF")
+        nl = d[q]; q += 1; name = d[q:q+nl]; q += nl
+        p = q; props = []
+        for _ in range(nprop):
+            p, pr = rd_prop(p); props.append(pr)
+        if name == b"Model" and len(props) >= 3 and props[2][1] in (b"LimbNode", b"Root"):
+            joints.add(props[1][1])
+        elif name == b"Geometry": meshes += 1
+        elif name == b"Vertices" and props and props[0][2]: verts += props[0][2] // 3
+        elif name == b"AnimationCurve": curves += 1
+        while p < end:
+            if d[p:p+NREC] == b"\x00" * NREC: p += NREC; break
+            p = rd_node(p, depth + 1)
+        return end
+
+    try:
+        p = 27
+        while p < len(d) - 160:
+            if d[p:p+NREC] == b"\x00" * NREC: p += NREC; break
+            p = rd_node(p)
+    except Exception as e:
+        r["reason"] = "parse: %s" % str(e)[:70]; return r
+    r.update(joints=len(joints), meshes=meshes, verts=verts, curves=curves,
+             end_gap=len(d) - p)
+    if r["end_gap"] < 0:
+        r["reason"] = "walk ran past EOF"; return r
+    if r["end_gap"] > 4096:
+        r["reason"] = "%d trailing bytes unparsed (truncated or padded)" % r["end_gap"]; return r
+    if not joints and not meshes:
+        r["reason"] = "no skeleton and no geometry"; return r
+    r["ok"] = True
+    return r
+
+
+if __name__ == "__main__":
+    for f in sys.argv[1:]:
+        r = check(f)
+        print("%-38s %-4s v%-5s joints=%-4d mesh=%-3d verts=%-8d curves=%-6d %s" % (
+            os.path.basename(f), "OK" if r["ok"] else "BAD", r["version"],
+            r["joints"], r["meshes"], r["verts"], r["curves"], r["reason"]))

scripts/probes/fbx_curves.py

@@ -0,0 +1,60 @@
+"""Decode FBX animation curve values and compare two clips frame by frame.
+
+Range or amplitude comparisons pair up motions that merely span the same
+extents; matching the actual key values settles it.
+"""
+import os, struct, sys, zlib
+SCALAR={"Y":2,"C":1,"I":4,"F":4,"D":8,"L":8}; ELEM={"f":4,"d":8,"l":8,"i":4,"b":1}
+FMT={"f":"f","d":"d","l":"q","i":"i","b":"b"}
+def curves(path):
+    d=open(path,'rb').read(); u64=struct.unpack("<I",d[23:27])[0]>=7500
+    N=25 if u64 else 13; out=[]
+    def rp(p,want):
+        t=chr(d[p]); s=p; p+=1
+        if t in SCALAR: p+=SCALAR[t]; return p,None
+        if t in ELEM:
+            n,enc,cl=struct.unpack("<III",d[p:p+12]); p+=12
+            body=cl if enc else n*ELEM[t]; raw=d[p:p+body]; p+=body
+            if want and n:
+                try:
+                    if enc: raw=zlib.decompress(raw)
+                    return p,struct.unpack("<%d%s"%(n,FMT[t]),raw[:n*ELEM[t]])
+                except Exception: return p,None
+            return p,None
+        if t in "SR":
+            ln=struct.unpack("<I",d[p:p+4])[0]; p+=4+ln; return p,None
+        raise ValueError
+    def rn(p):
+        if u64: e,np_,pl=struct.unpack("<QQQ",d[p:p+24]); q=p+24
+        else: e,np_,pl=struct.unpack("<III",d[p:p+12]); q=p+12
+        if e==0 and np_==0 and pl==0: return p+N
+        nl=d[q]; q+=1; nm=d[q:q+nl]; q+=nl; p=q; want=nm==b"KeyValueFloat"; v=None
+        for _ in range(np_):
+            p,x=rp(p,want)
+            if x is not None: v=x
+        if want and v: out.append(v)
+        while p<e:
+            if d[p:p+N]==b"\x00"*N: p+=N; break
+            p=rn(p)
+        return e
+    p=27
+    while p<len(d)-160:
+        if d[p:p+N]==b"\x00"*N: break
+        p=rn(p)
+    return out
+def same_motion(a,b,eps=1e-4):
+    ca,cb=curves(a),curves(b)
+    ma=[c for c in ca if max(c)-min(c)>1e-6]; mb=[c for c in cb if max(c)-min(c)>1e-6]
+    if len(ma)!=len(mb): return False,"moving curves %d vs %d"%(len(ma),len(mb))
+    ka=sorted(ma,key=lambda c:(len(c),c[0])); kb=sorted(mb,key=lambda c:(len(c),c[0]))
+    matched=0
+    for x,y in zip(ka,kb):
+        n=min(len(x),len(y))
+        if n and all(abs(x[i]-y[i])<eps for i in range(n)): matched+=1
+    return matched==len(ka), "%d/%d curves identical frame by frame"%(matched,len(ka))
+if __name__=="__main__":
+    for i in range(1,len(sys.argv),2):
+        a,b=sys.argv[i],sys.argv[i+1]
+        ok,msg=same_motion(a,b)
+        print("  %-26s vs %-26s  %s  (%s)"%(os.path.basename(a),os.path.basename(b),
+              "same motion" if ok else "different", msg))

scripts/probes/fbx_embed_texture.py

@@ -0,0 +1,170 @@
+#!/usr/bin/env python3
+"""Graft an embedded texture into a binary FBX that references one externally.
+
+    fbx_embed_texture.py --selftest <fbx>...          byte-identical round trip
+    fbx_embed_texture.py --donor <fbx> <fbx>...       copy the donor's Video/Content
+                                                      into each target, in place
+
+Truebones embeds its textures in the FBX itself — 73 of the 74 species carry the
+pixels in a `Video/Content` property, so a clip renders correctly wherever it is
+opened. `Cat` is the exception: its four standalone clips were exported without
+"embed media", so they carry only a `RelativeFilename` pointing at a `Cat.fbm/`
+directory that does not exist. They render untextured from `animation/`, whose
+flat layout puts no image anywhere the importer's search can reach.
+
+The fix is not a re-export, which would rebuild the rig. The file is parsed into
+its node tree, one `Content` node is inserted into `Video`, and the tree is
+re-serialized with recomputed offsets — every node record stores an absolute end
+offset, so an insertion shifts everything after it. Nothing else is touched.
+
+The `Content` node is copied verbatim from a donor file of the same species that
+does have it (`Cat-ALL.fbx`), rather than synthesised, so the property encoding
+and node framing are known-good rather than guessed.
+
+Correctness gate: with no edits the serializer must reproduce its input byte for
+byte (`--selftest`). Some nodes carry a trailing null record despite having no
+children; that is tracked per node so round trips stay exact.
+
+Writes through a temporary file and renames it into place. Every clip here is a
+hardlink of one in `Truebone_Z-OO/`, and writing to such a path writes through to
+the original.
+"""
+import os, struct, sys
+
+ELEM = {'f':4,'d':8,'l':8,'i':4,'b':1}
+SCALAR = {"Y":2,"C":1,"I":4,"F":4,"D":8,"L":8}
+
+
+class Node:
+    __slots__ = ("name","props","children","nullrec")
+    def __init__(s, name): s.name=name; s.props=[]; s.children=[]; s.nullrec=False
+
+
+def parse(path):
+    d=open(path,'rb').read()
+    assert d[:21]==b"Kaydara FBX Binary  \x00", "not a binary FBX"
+    version=struct.unpack("<I",d[23:27])[0]; u64=version>=7500
+    NREC=25 if u64 else 13
+
+    def rd_prop(p):
+        t=chr(d[p]); s=p; p+=1
+        if t in SCALAR:
+            p+=SCALAR[t]; return p,(t,d[s+1:p])
+        if t in ELEM:
+            length,enc,clen=struct.unpack("<III",d[p:p+12]); hdr=d[p:p+12]; p+=12
+            body=clen if enc else length*ELEM[t]
+            data=d[p:p+body]; p+=body
+            return p,(t,hdr+data)
+        if t in "SR":
+            ln=struct.unpack("<I",d[p:p+4])[0]; p+=4
+            data=d[p:p+ln]; p+=ln
+            return p,(t,data)
+        raise ValueError("bad prop type %r @%d"%(t,s))
+
+    def is_null(p): return p+NREC<=len(d) and d[p:p+NREC]==b"\x00"*NREC
+
+    def rd_node(p):
+        if u64: end,nprop,plen=struct.unpack("<QQQ",d[p:p+24]); q=p+24
+        else:   end,nprop,plen=struct.unpack("<III",d[p:p+12]); q=p+12
+        if end==0 and nprop==0 and plen==0: return None,p+NREC
+        nl=d[q]; q+=1; name=d[q:q+nl]; q+=nl
+        n=Node(name); p=q
+        for _ in range(nprop):
+            p,pr=rd_prop(p); n.props.append(pr)
+        while p<end:
+            if is_null(p): n.nullrec=True; p+=NREC; break
+            c,p2=rd_node(p)
+            if c is None: n.nullrec=True; p=p2; break
+            n.children.append(c); p=p2
+        return n,end
+
+    p=27; top=[]; tnull=False
+    while p<len(d):
+        if is_null(p): tnull=True; p+=NREC; break
+        n,p2=rd_node(p)
+        if n is None: tnull=True; p=p2; break
+        top.append(n); p=p2
+    return {"header":d[:27],"u64":u64,"top":top,"footer":d[p:],
+            "toplevel_null":tnull,"orig":d,"version":version}
+
+
+def pbytes(t,pay):
+    if t in "SR": return t.encode()+struct.pack("<I",len(pay))+pay
+    return t.encode()+pay
+
+def nsize(n,u64):
+    NREC=25 if u64 else 13
+    sz=NREC+len(n.name)
+    sz+=sum(len(pbytes(t,p)) for t,p in n.props)
+    sz+=sum(nsize(c,u64) for c in n.children)
+    if n.nullrec: sz+=NREC
+    return sz
+
+def wnode(out,n,u64):
+    NREC=25 if u64 else 13
+    props=b"".join(pbytes(t,p) for t,p in n.props)
+    end=len(out)+nsize(n,u64)
+    out += struct.pack("<QQQ",end,len(n.props),len(props)) if u64 else \
+           struct.pack("<III",end,len(n.props),len(props))
+    out += bytes([len(n.name)])+n.name+props
+    for c in n.children: wnode(out,c,u64)
+    if n.nullrec: out+=b"\x00"*NREC
+
+def serialize(t):
+    out=bytearray(t["header"])
+    for n in t["top"]: wnode(out,n,t["u64"])
+    if t["toplevel_null"]: out+=b"\x00"*(25 if t["u64"] else 13)
+    out+=t["footer"]
+    return bytes(out)
+
+
+def walk(nodes):
+    for n in nodes:
+        yield n
+        for x in walk(n.children): yield x
+
+def donor_content(path):
+    """The `Content` node of the donor's `Video`, with its raw payload."""
+    t=parse(path)
+    for n in walk(t["top"]):
+        if n.name!=b"Video": continue
+        for c in n.children:
+            if c.name==b"Content" and c.props and c.props[0][0]=="R" and len(c.props[0][1])>64:
+                return c
+    raise SystemExit("donor has no Video/Content: "+path)
+
+def graft(path, content):
+    """Insert a copy of `content` into every Video node that lacks one."""
+    t=parse(path); added=0
+    for n in walk(t["top"]):
+        if n.name!=b"Video": continue
+        if any(c.name==b"Content" for c in n.children): continue
+        c=Node(b"Content"); c.props=list(content.props); c.nullrec=content.nullrec
+        # sits after RelativeFilename, which is where every embedding export puts it
+        idx=max((i for i,ch in enumerate(n.children)
+                 if ch.name in (b"RelativeFilename", b"Filename")), default=len(n.children)-1)
+        n.children.insert(idx+1, c); added+=1
+    return added, serialize(t)
+
+
+if __name__=="__main__":
+    a=sys.argv[1:]
+    if a and a[0]=="--selftest":
+        ok=True
+        for f in a[1:]:
+            t=parse(f); same=serialize(t)==t["orig"]; ok&=same
+            print("  %-30s identical=%s  (%d bytes)"%(os.path.basename(f),same,len(t["orig"])))
+        sys.exit(0 if ok else 1)
+    if a and a[0]=="--donor":
+        content=donor_content(a[1])
+        print("donor blob: %d bytes"%len(content.props[0][1]))
+        for f in a[2:]:
+            t=parse(f)
+            assert serialize(t)==t["orig"], "round trip failed, refusing to edit "+f
+            n,data=graft(f, content)
+            tmp=f+".tmp"
+            open(tmp,"wb").write(data)
+            os.replace(tmp, f)          # replaces the name, leaves other hardlinks alone
+            print("  %-30s +%d Content  %d -> %d bytes"%(os.path.basename(f),n,len(t["orig"]),len(data)))
+        sys.exit(0)
+    sys.exit(__doc__)

scripts/probes/fbx_fingerprint.py

@@ -0,0 +1,70 @@
+#!/usr/bin/env python3
+"""Motion fingerprint of a binary FBX: the per-curve value ranges.
+
+Two exports of the same motion that differ only by a trailing hold share every
+curve's (min, max) pair, while genuinely different motions do not. Comparing the
+whole multiset is far stricter than comparing a single peak-to-peak figure,
+which can coincide by chance.
+"""
+import os, struct, sys, zlib
+
+SCALAR = {"Y": 2, "C": 1, "I": 4, "F": 4, "D": 8, "L": 8}
+ELEM   = {"f": 4, "d": 8, "l": 8, "i": 4, "b": 1}
+FMT    = {"f": "f", "d": "d", "l": "q", "i": "i", "b": "b"}
+
+
+def probe(path, nd=3):
+    d = open(path, "rb").read()
+    if d[:21] != b"Kaydara FBX Binary  \x00":
+        raise ValueError("not a binary FBX")
+    u64 = struct.unpack("<I", d[23:27])[0] >= 7500
+    NREC = 25 if u64 else 13
+    curves = []
+
+    def rd_prop(p, want):
+        t = chr(d[p]); s = p; p += 1
+        if t in SCALAR: p += SCALAR[t]; return p, None
+        if t in ELEM:
+            n, enc, clen = struct.unpack("<III", d[p:p+12]); p += 12
+            body = clen if enc else n * ELEM[t]
+            raw = d[p:p+body]; p += body
+            if want and n:
+                try:
+                    if enc: raw = zlib.decompress(raw)
+                    return p, struct.unpack("<%d%s" % (n, FMT[t]), raw[:n*ELEM[t]])
+                except Exception: return p, None
+            return p, None
+        if t in "SR":
+            ln = struct.unpack("<I", d[p:p+4])[0]; p += 4 + ln; return p, None
+        raise ValueError("bad prop %r" % t)
+
+    def rd_node(p):
+        if u64: end, nprop, plen = struct.unpack("<QQQ", d[p:p+24]); q = p+24
+        else:   end, nprop, plen = struct.unpack("<III", d[p:p+12]); q = p+12
+        if end == 0 and nprop == 0 and plen == 0: return p + NREC
+        nl = d[q]; q += 1; name = d[q:q+nl]; q += nl
+        p = q; want = name == b"KeyValueFloat"; vals = None
+        for _ in range(nprop):
+            p, v = rd_prop(p, want)
+            if v is not None: vals = v
+        if want and vals:
+            curves.append((round(min(vals), nd), round(max(vals), nd), len(vals)))
+        while p < end:
+            if d[p:p+NREC] == b"\x00"*NREC: p += NREC; break
+            p = rd_node(p)
+        return end
+
+    p = 27
+    while p < len(d) - 160:
+        if d[p:p+NREC] == b"\x00"*NREC: break
+        p = rd_node(p)
+    ranges = tuple(sorted((a, b) for a, b, _ in curves))     # ignores key counts
+    return {"num_curves": len(curves), "ranges": ranges,
+            "keys": tuple(sorted(c for _, _, c in curves))}
+
+
+if __name__ == "__main__":
+    for f in sys.argv[1:]:
+        r = probe(f)
+        print("%-30s curves=%-5d fingerprint=%s" % (
+            os.path.basename(f), r["num_curves"], hash(r["ranges"])))

scripts/probes/fbx_graft_mesh.py

@@ -0,0 +1,507 @@
+#!/usr/bin/env python3
+"""Graft a mesh and its skin from a donor FBX into one that was exported without geometry.
+
+    fbx_graft_mesh.py --selftest <fbx>...              byte-identical round trip
+    fbx_graft_mesh.py --inspect <fbx>...               what geometry/skin a file holds
+    fbx_graft_mesh.py --donor <donor> [--bind X] <target>   graft, in place
+
+`--bind` decides whose bind pose — whose rest pose, as an importer will show it —
+the repaired clip ends up with. `donor` (the default) adopts the donor's, which is
+what keeps a species' clips sharing one rest pose; `self` keeps the target's own,
+re-posing the grafted mesh to match; a path takes a third file's.
+
+`KingCobra-Walk.fbx` is the one clip in this dataset with no geometry: the export
+dropped `Geometry::Mesh` and `Model::Mesh` while keeping the skeleton, the
+animation curves, the materials and the embedded textures. Its two `Deformer::Skin`
+objects survived as orphans, and they index a 1110-vertex mesh that exists in no
+file — every other KingCobra clip carries the same 2220-vertex mesh instead. The
+orphan skin is therefore unrecoverable, and the fix is to bring in a sibling's
+complete geometry-plus-skin package.
+
+That is sound because the two rigs are the same skeleton: identical bone names,
+identical parenting, and identical `PreRotation` on all 19 bones. The donor's
+bind *posture* differs, but a skin cluster stores
+`Transform = MeshGlobal_bind · inverse(TransformLink)`, which resolves a vertex
+into the bone's own local frame and so cancels the posture it was bound in. The
+deformation is then reconstructed from whatever world matrix the target's own
+animation gives each bone, frame by frame.
+
+What moves: `Geometry::Mesh`, `Model::Mesh`, `Deformer::Skin`, its `Cluster`s and
+`Pose::BindPose`. What is deleted: the target's orphan skins and clusters. Every
+copied object gets a fresh uid, and connections that point at the donor's bones,
+materials or textures are re-pointed at the target's own by name — nothing about
+the target's skeleton, curves or embedded pixels is touched.
+
+Correctness gate: with no edits the serializer must reproduce its input byte for
+byte (`--selftest`), the same gate `fbx_embed_texture.py` uses.
+
+Writes through a temporary file and renames it into place. Clips here are
+hardlinks of files in `Truebone_Z-OO/`, and writing to such a path writes through
+to the original; `os.replace` swaps the name and leaves the source alone.
+"""
+import collections, math, os, struct, sys, zlib
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+from fbx_embed_texture import parse, serialize, Node, ELEM, SCALAR
+
+
+# ---------------------------------------------------------------- properties
+
+def sval(pr):
+    t, pay = pr
+    if t in "SR": return pay
+    return {"L": "<q", "I": "<i", "D": "<d", "F": "<f", "Y": "<h"}.get(t) and \
+           struct.unpack({"L": "<q", "I": "<i", "D": "<d", "F": "<f", "Y": "<h"}[t], pay)[0]
+
+def uid_prop(uid):
+    return ("L", struct.pack("<q", uid))
+
+def clean(name):
+    return name.decode("utf-8", "replace").split("\x00")[0]
+
+
+# ---------------------------------------------------------------- tree access
+
+def top(tree, name):
+    for n in tree["top"]:
+        if n.name == name: return n
+    return None
+
+def objects(tree):
+    """uid -> (class, name, subtype, node)"""
+    o = top(tree, b"Objects"); out = {}
+    if not o: return out
+    for ch in o.children:
+        if len(ch.props) >= 3:
+            out[sval(ch.props[0])] = (ch.name, sval(ch.props[1]), sval(ch.props[2]), ch)
+    return out
+
+def connections(tree):
+    c = top(tree, b"Connections")
+    return [] if not c else [tuple(sval(x) for x in ch.props) for ch in c.children]
+
+def copy_node(n):
+    c = Node(n.name)
+    c.props = list(n.props)
+    c.nullrec = n.nullrec
+    c.children = [copy_node(x) for x in n.children]
+    return c
+
+
+# ---------------------------------------------------------------- inspection
+
+def inspect(path):
+    t = parse(path); o = objects(t)
+    verts = polys = 0
+    for uid, (cls, nm, sub, node) in o.items():
+        if cls == b"Geometry":
+            for ch in node.children:
+                if ch.name == b"Vertices":
+                    length = struct.unpack("<I", ch.props[0][1][:4])[0]; verts = length // 3
+                if ch.name == b"PolygonVertexIndex":
+                    polys = struct.unpack("<I", ch.props[0][1][:4])[0]
+    census = collections.Counter((clean(cls), clean(sub)) for cls, _, sub, _ in
+                                 ((c, n, s, x) for c, n, s, x in o.values()))
+    return {"verts": verts, "poly_indices": polys,
+            "geometry": census[("Geometry", "Mesh")],
+            "model_mesh": census[("Model", "Mesh")],
+            "limbs": census[("Model", "LimbNode")],
+            "skins": census[("Deformer", "Skin")],
+            "clusters": census[("Deformer", "Cluster")],
+            "bindpose": census[("Pose", "BindPose")]}
+
+
+# ---------------------------------------------------------------- arrays
+
+FMT = {"d": ("d", 8), "f": ("f", 4), "i": ("i", 4), "l": ("q", 8), "b": ("b", 1)}
+
+def rd_array(pr):
+    t, pay = pr
+    n, enc, clen = struct.unpack("<III", pay[:12])
+    body = pay[12:]
+    if enc: body = zlib.decompress(body)
+    f, sz = FMT[t]
+    return list(struct.unpack("<%d%s" % (n, f), body[:n * sz])), enc
+
+def wr_array(t, vals, enc=1):
+    """An array property: `(length, encoding, byte count)` then the payload.
+
+    The third header field must carry the payload's byte count even when the data
+    is stored uncompressed — readers take it as the number of bytes to consume,
+    not as a compressed-only field. Writing 0 there produces a file that this
+    module still round-trips happily and that Blender refuses to open.
+    """
+    f, sz = FMT[t]
+    raw = struct.pack("<%d%s" % (len(vals), f), *vals)
+    if enc:
+        raw = zlib.compress(raw)
+    return (t, struct.pack("<III", len(vals), 1 if enc else 0, len(raw)) + raw)
+
+
+# ---------------------------------------------------------------- rebinding
+
+def _mat(vals):
+    """FBX stores a 4x4 as 16 doubles with the translation last — row-vector layout."""
+    return [vals[i * 4:i * 4 + 4] for i in range(4)]
+
+def _mul(a, b):
+    return [[sum(a[i][k] * b[k][j] for k in range(4)) for j in range(4)] for i in range(4)]
+
+def _inv(m):
+    """Gauss-Jordan; these are affine but may carry scale, so invert generally."""
+    n = 4
+    a = [row[:] + [1.0 if i == j else 0.0 for j in range(n)] for i, row in enumerate(m)]
+    for c in range(n):
+        p = max(range(c, n), key=lambda r: abs(a[r][c]))
+        if abs(a[p][c]) < 1e-14: raise ValueError("singular matrix")
+        a[c], a[p] = a[p], a[c]
+        d = a[c][c]
+        a[c] = [x / d for x in a[c]]
+        for r in range(n):
+            if r == c: continue
+            f = a[r][c]
+            if f: a[r] = [x - f * y for x, y in zip(a[r], a[c])]
+    return [row[n:] for row in a]
+
+def _flat(m):
+    return [x for row in m for x in row]
+
+
+def bind_pose_of(path):
+    """`{bone name: TransformLink}` — where each bone stood when the mesh was bound."""
+    t = parse(path); o = objects(t)
+    kids = collections.defaultdict(list)
+    for con in connections(t):
+        if con[0] == b"OO": kids[con[2]].append(con[1])
+    out = {}
+    for u, (c, n, s, node) in o.items():
+        if c != b"Deformer" or s != b"Cluster": continue
+        bone = next((clean(o[k][1]) for k in kids[u]
+                     if k in o and o[k][0] == b"Model"), None)
+        g = {ch.name: ch for ch in node.children}
+        if bone and b"TransformLink" in g and bone not in out:
+            out[bone] = _mat(rd_array(g[b"TransformLink"].props[0])[0])
+    return out
+
+
+def rebind(tt, tl_target, log):
+    """Re-pose the grafted mesh into the target's own bind pose.
+
+    The mesh arrives bound in the donor's posture, and an importer that reads the
+    bind matrices will show the donor's rest pose rather than this clip's. The two
+    are different postures of the same skeleton, so the mesh can be moved between
+    them by the skin itself: evaluate it at the target's bind pose and rebind there.
+
+    A cluster stores `Transform = MeshGlobal_bind · inverse(TransformLink)`, so with
+    `K_i = Transform_i · TransformLink_target_i · inverse(MeshGlobal)` every vertex
+    becomes `v' = Σ w_i · v · K_i` and the cluster matrices follow. Weights here sum
+    to exactly 1 per vertex, so the blend is affine and needs no normalising.
+    """
+    to = objects(tt)
+    geo = [node for u, (c, n, s, node) in to.items() if c == b"Geometry"]
+    if not geo: return False
+    geo = geo[0]
+    clusters = []
+    kids = collections.defaultdict(list)
+    for con in connections(tt):
+        if con[0] == b"OO": kids[con[2]].append(con[1])
+    for u, (c, n, s, node) in to.items():
+        if c != b"Deformer" or s != b"Cluster": continue
+        bone = next((clean(to[k][1]) for k in kids[u]
+                     if k in to and to[k][0] == b"Model"), None)
+        g = {ch.name: ch for ch in node.children}
+        if bone is None or b"TransformLink" not in g: continue
+        clusters.append((bone, node, g))
+
+    missing = [b for b, _, _ in clusters if b not in tl_target]
+    if missing:
+        log.append("目标自身缺 %d 根骨骼的绑定矩阵，保留供体绑定姿势" % len(missing))
+        return False
+
+    # MeshGlobal is Transform · TransformLink, identical for every cluster
+    b0, _, g0 = clusters[0]
+    mesh_global = _mul(_mat(rd_array(g0[b"Transform"].props[0])[0]),
+                       _mat(rd_array(g0[b"TransformLink"].props[0])[0]))
+    inv_mg = _inv(mesh_global)
+
+    K = {}
+    for bone, node, g in clusters:
+        tf = _mat(rd_array(g[b"Transform"].props[0])[0])
+        K[bone] = _mul(_mul(tf, tl_target[bone]), inv_mg)
+
+    verts, venc = rd_array(next(ch for ch in geo.children
+                                if ch.name == b"Vertices").props[0])
+    nv = len(verts) // 3
+    acc = [[0.0, 0.0, 0.0] for _ in range(nv)]
+    nacc = [[0.0, 0.0, 0.0] for _ in range(nv)]
+
+    nrm_node = None
+    for ch in geo.children:
+        if ch.name != b"LayerElementNormal": continue
+        mapping = next((clean(cc.props[0][1]) for cc in ch.children
+                        if cc.name == b"MappingInformationType"), "")
+        if mapping == "ByVertice":
+            nrm_node = next((cc for cc in ch.children if cc.name == b"Normals"), None)
+    normals = rd_array(nrm_node.props[0])[0] if nrm_node else None
+
+    for bone, node, g in clusters:
+        idx = rd_array(g[b"Indexes"].props[0])[0]
+        wts = rd_array(g[b"Weights"].props[0])[0]
+        k = K[bone]
+        # normals are directions: rotate by the inverse transpose of the 3x3
+        it = _inv([row[:3] + [0.0] for row in k[:3]] + [[0.0, 0.0, 0.0, 1.0]])
+        nk = [[it[j][i] for j in range(3)] for i in range(3)]
+        for i, w in zip(idx, wts):
+            x, y, z = verts[3 * i], verts[3 * i + 1], verts[3 * i + 2]
+            for j in range(3):
+                acc[i][j] += w * (x * k[0][j] + y * k[1][j] + z * k[2][j] + k[3][j])
+            if normals:
+                a, b_, c_ = normals[3 * i], normals[3 * i + 1], normals[3 * i + 2]
+                for j in range(3):
+                    nacc[i][j] += w * (a * nk[0][j] + b_ * nk[1][j] + c_ * nk[2][j])
+
+    moved = max(math.dist((verts[3*i], verts[3*i+1], verts[3*i+2]), acc[i])
+                for i in range(nv))
+    for ch in geo.children:
+        if ch.name == b"Vertices":
+            ch.props[0] = wr_array("d", [c for v in acc for c in v], venc)
+    if normals:
+        out = []
+        for v in nacc:
+            L = math.sqrt(sum(c * c for c in v)) or 1.0
+            out += [c / L for c in v]
+        nrm_node.props[0] = wr_array("d", out, rd_array(nrm_node.props[0])[1])
+
+    for bone, node, g in clusters:
+        tl = tl_target[bone]
+        g[b"TransformLink"].props[0] = wr_array("d", _flat(tl), 0)
+        g[b"Transform"].props[0] = wr_array("d", _flat(_mul(mesh_global, _inv(tl))), 0)
+
+    log.append("重绑定到本片自身的绑定姿势：%d 根骨骼，顶点最大位移 %.4f" % (len(clusters), moved))
+    return True
+
+
+# ---------------------------------------------------------------- the graft
+
+MOVE = {(b"Geometry", b"Mesh"), (b"Model", b"Mesh"),
+        (b"Deformer", b"Skin"), (b"Deformer", b"Cluster"), (b"Pose", b"BindPose")}
+
+def graft(donor_path, target_path, dry=False, bind="donor"):
+    dt, tt = parse(donor_path), parse(target_path)
+    do, to = objects(dt), objects(tt)
+    tobj, tcon = top(tt, b"Objects"), top(tt, b"Connections")
+    log = []
+
+    # 1. drop the target's orphan skins and clusters, keeping their bind pose
+    #    — the clusters index a mesh that no longer exists, but `TransformLink`
+    #    records where this clip's own bones stood at bind, which the graft must
+    #    preserve or an importer will show the donor's rest pose instead.
+    had_pose = any(c == b"Pose" for c, _, _, _ in to.values())
+    tkids = collections.defaultdict(list)
+    for con in connections(tt):
+        if con[0] == b"OO": tkids[con[2]].append(con[1])
+    tl_target = {}
+    for u, (c, n, s, node) in to.items():
+        if c != b"Deformer" or s != b"Cluster": continue
+        bone = next((clean(to[k][1]) for k in tkids[u]
+                     if k in to and to[k][0] == b"Model"), None)
+        g = {ch.name: ch for ch in node.children}
+        if bone and b"TransformLink" in g and bone not in tl_target:
+            tl_target[bone] = _mat(rd_array(g[b"TransformLink"].props[0])[0])
+    if bind == "donor":
+        tl_target = {}                      # adopt the donor's bind pose wholesale
+    elif bind != "self":
+        tl_target = bind_pose_of(bind)      # a third file's, e.g. the species' own
+    if tl_target:
+        log.append("目标绑定姿势来源 %s：%d 根骨骼" %
+                   ("本片自身" if bind == "self" else os.path.basename(bind), len(tl_target)))
+    else:
+        log.append("采用供体的绑定姿势（与供体所属的物种基准一致）")
+
+    orphan = {u for u, (c, n, s, _) in to.items()
+              if c == b"Deformer" and s in (b"Skin", b"Cluster")}
+    if orphan:
+        tobj.children = [ch for ch in tobj.children
+                         if not (len(ch.props) >= 3 and sval(ch.props[0]) in orphan)]
+        tcon.children = [ch for ch in tcon.children
+                         if not ({sval(ch.props[1]), sval(ch.props[2])} & orphan)]
+        log.append("删除孤儿 %d 个 Deformer 及其连接" % len(orphan))
+
+    # 2. name-indexed lookup into the target, for re-pointing --------------
+    by_name = collections.defaultdict(dict)
+    for u, (c, n, s, _) in to.items():
+        by_name[c][clean(n)] = u
+
+    # 3. copy the donor's geometry package in, with fresh uids -------------
+    nxt = max(list(to) + list(do)) + 1000
+    remap, moved = {}, []
+    for u, (c, n, s, node) in sorted(do.items()):
+        if (c, s) in MOVE:
+            remap[u] = nxt; nxt += 1
+            moved.append((u, c, n, s, node))
+    for u, c, n, s, node in moved:
+        cp = copy_node(node)
+        cp.props[0] = uid_prop(remap[u])
+        tobj.children.append(cp)
+    log.append("移入 %d 个对象: %s" % (len(moved), ", ".join(
+        "%s::%s" % (clean(c), clean(s)) for _, c, _, s, _ in moved[:3]) + " …"))
+
+    # 4. re-point the donor's bind pose at the target's own nodes ----------
+    dropped_pose = 0
+    for u, c, n, s, node in moved:
+        if (c, s) != (b"Pose", b"BindPose"): continue
+        cp = [x for x in tobj.children if sval(x.props[0]) == remap[u]][0]
+        keep = []
+        for pn in cp.children:
+            if pn.name != b"PoseNode": keep.append(pn); continue
+            ref = next((ch for ch in pn.children if ch.name == b"Node"), None)
+            new = ref and translate(sval(ref.props[0]), do, remap, by_name)
+            if new is None: dropped_pose += 1; continue
+            ref.props[0] = uid_prop(new); keep.append(pn)
+        cp.children = keep
+        for ch in cp.children:                       # NbPoseNodes must follow
+            if ch.name == b"Properties70": continue
+            if ch.name == b"NbPoseNodes":
+                ch.props[0] = ("I", struct.pack("<i", sum(
+                    1 for x in cp.children if x.name == b"PoseNode")))
+
+    # 5. copy the donor's connections, translating both endpoints ---------
+    added = skipped = 0
+    for con in connections(dt):
+        kind, cu, pu = con[0], con[1], con[2]
+        if not ({cu, pu} & set(remap)): continue        # nothing to do with the graft
+        a = translate(cu, do, remap, by_name)
+        b = translate(pu, do, remap, by_name)
+        if a is None or b is None: skipped += 1; continue
+        n = Node(b"C")
+        n.props = [("S", kind), uid_prop(a), uid_prop(b)]
+        if len(con) > 3: n.props.append(("S", con[3]))
+        tcon.children.append(n); added += 1
+    log.append("接入 %d 条连接（%d 条无对应端点已跳过，弃用 PoseNode %d 个）"
+               % (added, skipped, dropped_pose))
+
+    # 6. put the mesh back into this clip's own bind pose
+    if tl_target:
+        rebind(tt, tl_target, log)
+    if not had_pose and tl_target:
+        # the donor's BindPose records the donor's posture; once the mesh has been
+        # moved somewhere else it is wrong, and this clip shipped without one anyway
+        gone = {u for u, (c, n, s, _) in objects(tt).items() if c == b"Pose"}
+        if gone:
+            tobj.children = [ch for ch in tobj.children
+                             if not (len(ch.props) >= 3 and sval(ch.props[0]) in gone)]
+            tcon.children = [ch for ch in tcon.children
+                             if not ({sval(ch.props[1]), sval(ch.props[2])} & gone)]
+            log.append("丢弃供体 BindPose %d 个（本片原本没有，且它记的是供体姿势）" % len(gone))
+
+    # 7. collapse the LayeredTexture indirection so importers find the pixels
+    n_add, n_lay = collapse_layered(tt)
+    if n_lay:
+        log.append("压平 %d 个 LayeredTexture，改为 %d 条 Texture→Material 直连" % (n_lay, n_add))
+
+    # 8. keep Definitions counts honest -----------------------------------
+    defs = top(tt, b"Definitions")
+    if defs:
+        want = collections.Counter()
+        for u, (c, n, s, _) in objects(tt).items(): want[c] += 1
+        for ch in defs.children:
+            if ch.name != b"ObjectType": continue
+            k = sval(ch.props[0])
+            if k in want:
+                for cc in ch.children:
+                    if cc.name == b"Count":
+                        cc.props[0] = ("I", struct.pack("<i", want[k]))
+        for ch in defs.children:
+            if ch.name == b"Count":
+                ch.props[0] = ("I", struct.pack("<i", sum(want.values())))
+
+    if dry: return log, None
+    data = serialize(tt)
+    tmp = target_path + ".tmp"
+    with open(tmp, "wb") as fh: fh.write(data)
+    os.replace(tmp, target_path)          # replaces the name; other hardlinks survive
+    return log, len(data)
+
+
+def collapse_layered(tt):
+    """Rewire `Texture -> Material` directly, dropping the `LayeredTexture` level.
+
+    This clip routes its textures `Video -> Texture -> LayeredTexture -> Material`.
+    That is legal FBX, but importers that only look for a texture connected straight
+    to a material property see an untextured mesh — the pixels load and go unused.
+    It is the only file in the dataset wired this way; the other 1,096 connect
+    `Texture -> Material` directly, which is what this reproduces.
+    """
+    to, tcon, tobj = objects(tt), top(tt, b"Connections"), top(tt, b"Objects")
+    layered = {u for u, (c, n, s, _) in to.items() if c == b"LayeredTexture"}
+    if not layered: return 0, 0
+    feed = {}                                   # LayeredTexture uid -> Texture uid
+    for con in connections(tt):
+        if con[0] == b"OO" and con[2] in layered and to.get(con[1], (b"",))[0] == b"Texture":
+            feed[con[2]] = con[1]
+    kept, added = [], 0
+    for ch in tcon.children:
+        p = [sval(x) for x in ch.props]
+        if not ({p[1], p[2]} & layered):
+            kept.append(ch); continue
+        if p[1] in layered and len(p) > 3 and to.get(p[2], (b"",))[0] == b"Material" \
+           and p[1] in feed:
+            n = Node(b"C")
+            n.props = [("S", p[0]), uid_prop(feed[p[1]]), uid_prop(p[2]), ("S", p[3])]
+            kept.append(n); added += 1
+    tcon.children = kept
+    tobj.children = [ch for ch in tobj.children
+                     if not (len(ch.props) >= 3 and sval(ch.props[0]) in layered)]
+    return added, len(layered)
+
+
+def translate(uid, do, remap, by_name):
+    """A donor uid, as it should be referred to inside the target."""
+    if uid == 0: return 0                       # scene root
+    if uid in remap: return remap[uid]          # object we just moved
+    ent = do.get(uid)
+    if not ent: return None
+    cls, nm, sub, _ = ent
+    return by_name.get(cls, {}).get(clean(nm))  # the target's own by name
+
+
+# ---------------------------------------------------------------- cli
+
+def main(argv):
+    if not argv or argv[0] not in ("--selftest", "--donor", "--inspect"):
+        print(__doc__); return 2
+    mode, rest = argv[0], argv[1:]
+
+    if mode == "--selftest":
+        bad = 0
+        for p in rest:
+            same = serialize(parse(p)) == open(p, "rb").read()
+            print("%-6s %s" % ("ok" if same else "DIFF", p)); bad += not same
+        return 1 if bad else 0
+
+    if mode == "--inspect":
+        for p in rest:
+            i = inspect(p)
+            print("%-34s verts %-6d idx %-6d geom %d meshnode %d limbs %-3d skin %d cluster %-3d bindpose %d"
+                  % (os.path.basename(p), i["verts"], i["poly_indices"], i["geometry"],
+                     i["model_mesh"], i["limbs"], i["skins"], i["clusters"], i["bindpose"]))
+        return 0
+
+    bind = "donor"
+    if "--bind" in rest:
+        i = rest.index("--bind"); bind = rest[i + 1]; rest = rest[:i] + rest[i + 2:]
+    donor, targets = rest[0], rest[1:]
+    for t in targets:
+        for p in (donor, t):
+            if serialize(parse(p)) != open(p, "rb").read():
+                print("拒绝执行：%s 无法字节级往返" % p); return 1
+        before = os.path.getsize(t)
+        log, size = graft(donor, t, bind=bind)
+        print("%s  ←  %s" % (t, donor))
+        for line in log: print("    " + line)
+        print("    %d → %d 字节" % (before, size))
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main(sys.argv[1:]))

scripts/probes/fbx_motion.py

@@ -0,0 +1,89 @@
+#!/usr/bin/env python3
+"""Decide whether a binary FBX actually contains motion.
+
+Keyframe *count* says nothing: a clip can carry 91 keys that all hold the same
+value. This decodes the `KeyValueFloat` arrays of every animation curve (FBX
+stores them zlib-compressed) and reports the largest peak-to-peak range found.
+A file whose every curve is flat is static.
+"""
+import os, struct, sys, zlib
+
+SCALAR = {"Y": 2, "C": 1, "I": 4, "F": 4, "D": 8, "L": 8}
+ELEM   = {"f": 4, "d": 8, "l": 8, "i": 4, "b": 1}
+FMT    = {"f": "f", "d": "d", "l": "q", "i": "i", "b": "b"}
+
+
+def probe(path, eps=1e-6):
+    d = open(path, "rb").read()
+    if d[:21] != b"Kaydara FBX Binary  \x00":
+        raise ValueError("not a binary FBX")
+    version = struct.unpack("<I", d[23:27])[0]
+    u64 = version >= 7500
+    NREC = 25 if u64 else 13
+    curves = []          # (name, peak-to-peak range, n)
+
+    def rd_prop(p, want_values):
+        t = chr(d[p]); s = p; p += 1
+        if t in SCALAR:
+            p += SCALAR[t]; return p, (t, d[s + 1:p])
+        if t in ELEM:
+            n, enc, clen = struct.unpack("<III", d[p:p + 12]); p += 12
+            body = clen if enc else n * ELEM[t]
+            raw = d[p:p + body]; p += body
+            vals = None
+            if want_values and n:
+                try:
+                    if enc: raw = zlib.decompress(raw)
+                    vals = struct.unpack("<%d%s" % (n, FMT[t]), raw[:n * ELEM[t]])
+                except Exception:
+                    vals = None
+            return p, (t, vals, n)
+        if t in "SR":
+            ln = struct.unpack("<I", d[p:p + 4])[0]; p += 4
+            v = d[p:p + ln]; p += ln
+            return p, (t, v)
+        raise ValueError("bad prop %r" % t)
+
+    def rd_node(p):
+        if u64: end, nprop, plen = struct.unpack("<QQQ", d[p:p + 24]); q = p + 24
+        else:   end, nprop, plen = struct.unpack("<III", d[p:p + 12]); q = p + 12
+        if end == 0 and nprop == 0 and plen == 0:
+            return p + NREC
+        nl = d[q]; q += 1; name = d[q:q + nl]; q += nl
+        p = q
+        want = name == b"KeyValueFloat"
+        props = []
+        for _ in range(nprop):
+            p, pr = rd_prop(p, want); props.append(pr)
+        if want and props and len(props[0]) == 3 and props[0][1]:
+            v = props[0][1]
+            curves.append((max(v) - min(v), len(v)))
+        while p < end:
+            if d[p:p + NREC] == b"\x00" * NREC: p += NREC; break
+            p = rd_node(p)
+        return end
+
+    p = 27
+    while p < len(d) - 160:
+        if d[p:p + NREC] == b"\x00" * NREC: break
+        p = rd_node(p)
+
+    ranges = [r for r, _ in curves]
+    return {
+        "num_curves": len(curves),
+        "max_range": max(ranges) if ranges else 0.0,
+        "moving_curves": sum(1 for r in ranges if r > eps),
+        "static": bool(ranges) and max(ranges) <= eps,
+        "no_curves": not ranges,
+    }
+
+
+if __name__ == "__main__":
+    for f in sys.argv[1:]:
+        try:
+            r = probe(f)
+            print("%-40s curves=%-5d moving=%-5d max_range=%-12.6g %s" % (
+                os.path.basename(f), r["num_curves"], r["moving_curves"],
+                r["max_range"], "STATIC" if r["static"] else ("NO_CURVES" if r["no_curves"] else "")))
+        except Exception as e:
+            print("%-40s ERROR %s" % (os.path.basename(f), str(e)[:50]))

scripts/probes/fbx_probe.py

@@ -0,0 +1,158 @@
+#!/usr/bin/env python3
+"""Read a binary FBX (Kaydara 7.x): skeleton, animation length and root joint.
+
+Walks the node tree, collecting LimbNode/Root models as joints and the longest
+KeyTime track as the timeline, then reads the `Connections` block to find which
+joint sits at the top of the hierarchy. Frame rate is measured from the key
+times themselves rather than assumed. Self-contained; no external deps.
+"""
+import os, struct, sys, zlib
+
+SCALAR = {"Y": 2, "C": 1, "I": 4, "F": 4, "D": 8, "L": 8}
+ELEM   = {"f": 4, "d": 8, "l": 8, "i": 4, "b": 1}
+FBX_KTIME = 46186158000            # ktime units per second
+
+
+def _parse(path):
+    d = open(path, "rb").read()
+    if d[:21] != b"Kaydara FBX Binary  \x00":
+        raise ValueError("not a binary FBX")
+    version = struct.unpack("<I", d[23:27])[0]
+    u64 = version >= 7500
+    NREC = 25 if u64 else 13
+    joints, keytimes = [], []        # joints: (uid, name); keytimes: (n, type, slice)
+    models, links = {}, []           # every Model uid -> name; child -> parent edges
+    animated = []                    # object-property edges: curve node -> the model it drives
+
+    def rd_prop(p):
+        t = chr(d[p]); s = p; p += 1
+        if t in SCALAR:
+            p += SCALAR[t]; return p, (t, d[s + 1:p])
+        if t in ELEM:
+            length, enc, clen = struct.unpack("<III", d[p:p + 12]); p += 12
+            body = clen if enc else length * ELEM[t]
+            start = p; p += body
+            return p, (t, b"", length, (start, body, enc))
+        if t in "SR":
+            ln = struct.unpack("<I", d[p:p + 4])[0]; p += 4
+            val = d[p:p + ln]; p += ln
+            return p, (t, val)
+        raise ValueError("bad prop %r" % t)
+
+    def rd_node(p):
+        if u64: end, nprop, plen = struct.unpack("<QQQ", d[p:p + 24]); q = p + 24
+        else:   end, nprop, plen = struct.unpack("<III", d[p:p + 12]); q = p + 12
+        if end == 0 and nprop == 0 and plen == 0:
+            return p + NREC
+        nl = d[q]; q += 1; name = d[q:q + nl]; q += nl
+        p = q; props = []
+        for _ in range(nprop):
+            p, pr = rd_prop(p); props.append(pr)
+        if name == b"Model" and len(props) >= 3:
+            uid = struct.unpack("<q", props[0][1])[0] if props[0][0] == "L" else 0
+            nm = props[1][1].split(b"\x00\x01")[0].decode("utf-8", "replace")
+            models[uid] = nm
+            if props[2][1] in (b"LimbNode", b"Root"):
+                joints.append((uid, nm))
+        elif name == b"KeyTime" and props and len(props[0]) == 4:
+            keytimes.append((props[0][2], props[0][0], props[0][3]))
+        elif name == b"C" and len(props) >= 3 and props[0][1] in (b"OO", b"OP"):
+            try:
+                a = struct.unpack("<q", props[1][1])[0]
+                b = struct.unpack("<q", props[2][1])[0]
+            except (struct.error, TypeError):
+                return end
+            (links if props[0][1] == b"OO" else animated).append((a, b))
+        while p < end:
+            if d[p:p + NREC] == b"\x00" * NREC: p += NREC; break
+            p = rd_node(p)
+        return end
+
+    p = 27
+    while p < len(d) - 160:
+        if d[p:p + NREC] == b"\x00" * NREC: break
+        p = rd_node(p)
+    return d, version, joints, keytimes, links, animated
+
+
+ELEM_FMT = {"f": "f", "d": "d", "l": "q", "i": "i", "b": "b"}
+
+
+def _timeline(d, keytimes):
+    """Frames and frame rate, read off the longest key-time track.
+
+    The track is decoded rather than counted so the spacing is measured: every
+    clip in this library keys on a strict 1/30 s grid, and a clip that did not
+    would report its own rate instead of inheriting an assumed one.
+    """
+    if not keytimes:
+        return 0, 0.0
+    n, t, (start, body, enc) = max(keytimes, key=lambda k: k[0])
+    raw = d[start:start + body]
+    try:
+        if enc:
+            raw = zlib.decompress(raw)
+        vals = struct.unpack("<%d%s" % (n, ELEM_FMT[t]), raw[:n * ELEM[t]])
+    except Exception:
+        return n, 0.0
+    steps = sorted({vals[i + 1] - vals[i] for i in range(len(vals) - 1)})
+    step = steps[0] if steps else 0
+    return n, round(FBX_KTIME / step, 3) if step else 0.0
+
+
+def probe(path):
+    d, version, joints, keytimes, links, animated = _parse(path)
+    frames, fps = _timeline(d, keytimes)
+    # The exporter types every node in the hierarchy as a `LimbNode`, mesh and
+    # null containers included, so the topmost one is often `Null` or `U3DMesh 1`
+    # rather than a bone. The root reported is instead the highest joint that
+    # actually carries animation — the node a retargeter would drive — with the
+    # largest subtree breaking ties. `joint_names` carries the full list.
+    ids = {uid for uid, _ in joints}
+    parent, children = {}, {}
+    for child, par in links:
+        if child in ids and child not in parent:
+            parent[child] = par
+            children.setdefault(par, []).append(child)
+
+    def subtree(uid, seen=None):
+        seen = seen or set()
+        if uid in seen:
+            return 0
+        seen.add(uid)
+        return 1 + sum(subtree(c, seen) for c in children.get(uid, ()))
+
+    def depth(uid, seen=None):
+        seen = seen or set()
+        d = 0
+        while uid in parent and uid not in seen:
+            seen.add(uid); uid = parent[uid]; d += 1
+        return d
+
+    driven = {par for _, par in animated} & ids
+    pool = driven or ids
+    roots = sorted(((uid, nm) for uid, nm in joints if uid in pool),
+                   key=lambda t: (depth(t[0]), -subtree(t[0])))
+    names = [nm for _, nm in joints]
+    return {
+        "fbx_version": version,
+        "num_joints": len(set(names)),
+        "keyframes": frames,
+        "fps": fps,
+        "duration_sec": round((frames - 1) / fps, 4) if fps and frames > 1 else 0.0,
+        "root_joint": roots[0][1] if roots else "",
+        "num_animated": len(driven),
+        "joints": sorted(set(names)),
+        "joint_names": "|".join(sorted(set(names)))[:400],
+    }
+
+
+if __name__ == "__main__":
+    for p in sys.argv[1:]:
+        try:
+            r = probe(p)
+            print("%-34s ver=%s joints=%-4d keys=%-5d %-5s fps  %.2fs  root=%s" % (
+                os.path.basename(p), r["fbx_version"], r["num_joints"],
+                r["keyframes"], r["fps"], r["duration_sec"], r["root_joint"]))
+        except Exception as e:
+            print("%-34s ERROR %s" % (os.path.basename(p), str(e)[:60]))

scripts/probes/fbx_rig.py

@@ -0,0 +1,74 @@
+#!/usr/bin/env python3
+"""Rig fingerprint of a binary FBX: joint names plus their rest offsets.
+
+Joint count alone cannot tell two skeletons apart — two rigs can share a count
+and still differ in proportions. Each joint's `Lcl Translation` is its offset
+from its parent, i.e. the bone vector, so the (name, offset) set pins down both
+topology and bone lengths.
+"""
+import math, os, struct, sys
+
+SCALAR = {"Y": 2, "C": 1, "I": 4, "F": 4, "D": 8, "L": 8}
+ELEM   = {"f": 4, "d": 8, "l": 8, "i": 4, "b": 1}
+
+
+def probe(path, nd=3):
+    d = open(path, "rb").read()
+    if d[:21] != b"Kaydara FBX Binary  \x00":
+        raise ValueError("not a binary FBX")
+    version = struct.unpack("<I", d[23:27])[0]
+    u64 = version >= 7500
+    NREC = 25 if u64 else 13
+    bones = {}
+
+    def rd_prop(p):
+        t = chr(d[p]); s = p; p += 1
+        if t in SCALAR:
+            p += SCALAR[t]; return p, (t, d[s + 1:p])
+        if t in ELEM:
+            n, enc, clen = struct.unpack("<III", d[p:p + 12]); p += 12
+            p += clen if enc else n * ELEM[t]
+            return p, (t, None)
+        if t in "SR":
+            ln = struct.unpack("<I", d[p:p + 4])[0]; p += 4
+            v = d[p:p + ln]; p += ln
+            return p, (t, v)
+        raise ValueError("bad prop %r" % t)
+
+    def rd_node(p, cur=None):
+        if u64: end, nprop, plen = struct.unpack("<QQQ", d[p:p + 24]); q = p + 24
+        else:   end, nprop, plen = struct.unpack("<III", d[p:p + 12]); q = p + 12
+        if end == 0 and nprop == 0 and plen == 0:
+            return p + NREC
+        nl = d[q]; q += 1; name = d[q:q + nl]; q += nl
+        p = q; props = []
+        for _ in range(nprop):
+            p, pr = rd_prop(p); props.append(pr)
+        mine = cur
+        if name == b"Model" and len(props) >= 3 and props[2][1] in (b"LimbNode", b"Root"):
+            mine = props[1][1].split(b"\x00\x01")[0].decode("utf-8", "replace")
+            bones.setdefault(mine, (0.0, 0.0, 0.0))
+        elif name == b"P" and cur is not None and props and props[0][1] == b"Lcl Translation":
+            vals = [struct.unpack("<d", v)[0] for t, v in props if t == "D" and v and len(v) == 8]
+            if len(vals) >= 3:
+                bones[cur] = tuple(vals[-3:])
+        while p < end:
+            if d[p:p + NREC] == b"\x00" * NREC: p += NREC; break
+            p = rd_node(p, mine)
+        return end
+
+    p = 27
+    while p < len(d) - 160:
+        if d[p:p + NREC] == b"\x00" * NREC: break
+        p = rd_node(p)
+    sig = tuple(sorted((n, round(x, nd), round(y, nd), round(z, nd))
+                       for n, (x, y, z) in bones.items()))
+    total = sum(math.sqrt(x * x + y * y + z * z) for _, (x, y, z) in bones.items())
+    return {"num_joints": len(bones), "signature": sig, "bone_length_sum": round(total, 3)}
+
+
+if __name__ == "__main__":
+    for f in sys.argv[1:]:
+        r = probe(f)
+        print("%-34s joints=%-4d bone_len_sum=%-12.3f" % (
+            os.path.basename(f), r["num_joints"], r["bone_length_sum"]))

scripts/probes/fbx_stacks.py

@@ -0,0 +1,86 @@
+"""Per-take motion: which `AnimationStack` in an FBX actually carries animation.
+
+`fbx_takes.py` counts the stacks; this says which of them hold anything. The two
+disagree on four files in this library, where a C4D export left an empty second
+stack named `Take 001` beside the real motion — no layers with curves under it,
+nothing to play. Counting stacks calls those files two-take; following the
+connections shows they hold one action and one empty shell.
+
+Walks `Connections` from each stack down through its layers and curve nodes to
+the curves themselves, then reports how many of those curves move.
+"""
+import struct, sys, zlib, collections
+SCALAR={"Y":2,"C":1,"I":4,"F":4,"D":8,"L":8}; ELEM={"f":4,"d":8,"l":8,"i":4,"b":1}
+FMT={"f":"f","d":"d","l":"q","i":"i","b":"b"}
+
+def analyse(path):
+    d=open(path,"rb").read(); u64=struct.unpack("<I",d[23:27])[0]>=7500; N=25 if u64 else 13
+    obj={}; conn=[]; curve_vals={}
+    def rp(p,want):
+        t=chr(d[p]); s=p; p+=1
+        if t in SCALAR: p+=SCALAR[t]; return p,(t,d[s+1:p])
+        if t in ELEM:
+            n,enc,cl=struct.unpack("<III",d[p:p+12]); p+=12
+            body=cl if enc else n*ELEM[t]; raw=d[p:p+body]; p+=body
+            if want and n:
+                try:
+                    if enc: raw=zlib.decompress(raw)
+                    return p,(t,struct.unpack("<%d%s"%(n,FMT[t]),raw[:n*ELEM[t]]))
+                except Exception: return p,(t,None)
+            return p,(t,None)
+        if t in "SR":
+            ln=struct.unpack("<I",d[p:p+4])[0]; p+=4; v=d[p:p+ln]; p+=ln; return p,(t,v)
+        raise ValueError(t)
+    def rn(p,owner=None):
+        if u64: e,np_,pl=struct.unpack("<QQQ",d[p:p+24]); q=p+24
+        else:   e,np_,pl=struct.unpack("<III",d[p:p+12]); q=p+12
+        if e==0 and np_==0 and pl==0: return p+N
+        nl=d[q]; q+=1; nm=d[q:q+nl]; q+=nl; p=q
+        want = nm==b"KeyValueFloat"; props=[]
+        for _ in range(np_):
+            p,x=rp(p,want); props.append(x)
+        mine=owner
+        if nm in (b"AnimationStack",b"AnimationLayer",b"AnimationCurveNode",b"AnimationCurve") and len(props)>=2:
+            uid=struct.unpack("<q",props[0][1])[0]
+            obj[uid]=(nm.decode(), props[1][1].split(b"\x00\x01")[0].decode("utf8","replace"))
+            mine=uid
+        elif nm==b"C" and len(props)>=3:
+            try: conn.append((props[0][1], struct.unpack("<q",props[1][1])[0], struct.unpack("<q",props[2][1])[0]))
+            except Exception: pass
+        elif want and props and props[0][1]:
+            v=props[0][1]
+            if owner is not None: curve_vals[owner]=max(v)-min(v)
+        while p<e:
+            if d[p:p+N]==b"\x00"*N: p+=N; break
+            p=rn(p,mine)
+        return e
+    p=27
+    while p<len(d)-160:
+        if d[p:p+N]==b"\x00"*N: break
+        p=rn(p)
+    kids=collections.defaultdict(list)
+    for kind,child,parent in conn: kids[parent].append(child)
+    out=[]
+    for uid,(t,name) in obj.items():
+        if t!="AnimationStack": continue
+        curves=[]
+        for lay in [c for c in kids[uid] if obj.get(c,("",""))[0]=="AnimationLayer"]:
+            for cn in [c for c in kids[lay] if obj.get(c,("",""))[0]=="AnimationCurveNode"]:
+                for cv in [c for c in kids[cn] if obj.get(c,("",""))[0]=="AnimationCurve"]:
+                    if cv in curve_vals: curves.append(curve_vals[cv])
+        moving=[r for r in curves if r>1e-6]
+        out.append((name, len(curves), len(moving), max(curves) if curves else 0.0))
+    return out
+
+def takes_with_motion(path):
+    """How many of the file's stacks actually carry a curve."""
+    return sum(1 for _, ncurves, _, _ in analyse(path) if ncurves)
+
+
+if __name__=="__main__":
+    import os
+    for f in sys.argv[1:]:
+        print(os.path.basename(f))
+        for name,n,mv,mx in analyse(f):
+            print("   take %-24s curves=%-4d moving=%-4d max_range=%.4f%s"
+                  %(name,n,mv,mx,"   <- empty" if not n else ""))

scripts/probes/fbx_strip_variant.py

@@ -0,0 +1,276 @@
+#!/usr/bin/env python3
+"""Keep one colourway of a mesh that ships several stacked on top of each other.
+
+    fbx_strip_variant.py --list <fbx>...              what variants a file carries
+    fbx_strip_variant.py --keep A01 <fbx>...          drop every other one, in place
+
+`KingCobra` is the one model in this library whose mesh is two co-located copies of
+the same surface, one per material — the game asset shipped two colourways of the
+same mob, and the export merged both variant meshes into a single object instead of
+keeping them separable. Every vertex of one copy sits within 0.0002 of a vertex of
+the other, their normals agree to 1.0000, and they share a UV layout, so the two
+surfaces coincide exactly: a renderer has to pick one, and which one it picks is
+draw order. That is z-fighting, and it is why the same species renders brown from
+one batch of clips and dark red from the other.
+
+Keeping one variant removes the coincident surfaces and halves the mesh. The
+material to keep is named, not indexed, because the two export batches connect the
+same two materials to the mesh in opposite orders — `A01` is material 1 in the
+`Cobra-*` files and material 0 in `run`/`walk fast`.
+
+Polygons of the other material are dropped, the surviving vertices are renumbered,
+and every array that indexes them follows: normals and vertex colours (per vertex),
+UV indices (per polygon vertex), the material array (per polygon) and each skin
+cluster's indices and weights. The materials, textures and embedded images that
+nothing references any more are removed with them. Nothing touches the skeleton,
+the curves or the bind matrices.
+
+Correctness gate: with no edits the serializer must reproduce its input byte for
+byte, and the kept vertices must still carry weights summing to 1. Writes through a
+temporary file and renames it into place, so a hardlinked source keeps its bytes.
+"""
+import collections, os, struct, sys
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+from fbx_graft_mesh import (parse, serialize, Node, objects, connections, clean,
+                            sval, top, rd_array, wr_array, uid_prop)
+
+
+def geometry_of(tree):
+    for u, (c, n, s, node) in objects(tree).items():
+        if c == b"Geometry": return node
+    return None
+
+
+def material_order(tree):
+    """Material names in the order they connect to the mesh — the index the
+    per-polygon material array refers to."""
+    o = objects(tree)
+    mesh = {u for u, (c, n, s, _) in o.items() if c == b"Model" and s == b"Mesh"}
+    out = []
+    for con in connections(tree):
+        if con[0] == b"OO" and con[2] in mesh and con[1] in o and o[con[1]][0] == b"Material":
+            out.append((clean(o[con[1]][1]), con[1]))
+    return out
+
+
+def layer_field(node, name):
+    return next((ch for ch in node.children if ch.name == name), None)
+
+
+def variants(path):
+    t = parse(path)
+    geo = geometry_of(t)
+    if geo is None: return None
+    order = material_order(t)
+    V = rd_array(layer_field(geo, b"Vertices").props[0])[0]
+    pvi = rd_array(layer_field(geo, b"PolygonVertexIndex").props[0])[0]
+    lem = layer_field(geo, b"LayerElementMaterial")
+    mats = rd_array(layer_field(lem, b"Materials").props[0])[0] if lem else [0]
+    polys, cur = [], []
+    for i in pvi:
+        cur.append(-i - 1 if i < 0 else i)
+        if i < 0: polys.append(cur); cur = []
+    grp = collections.defaultdict(set)
+    for p, m in zip(polys, mats if len(mats) == len(polys) else [0] * len(polys)):
+        grp[m].update(p)
+    return {"verts": len(V) // 3, "polys": len(polys), "materials": order,
+            "groups": {m: len(v) for m, v in grp.items()}}
+
+
+def strip(path, keep_sub, dry=False):
+    t = parse(path)
+    geo = geometry_of(t)
+    if geo is None: raise ValueError("no geometry")
+    order = material_order(t)
+    hit = [i for i, (nm, _) in enumerate(order) if keep_sub in nm]
+    if len(hit) != 1:
+        raise ValueError("%r matches %d materials: %s" %
+                         (keep_sub, len(hit), [n for n, _ in order]))
+    keep_i = hit[0]
+    keep_uid = order[keep_i][1]
+    log = ["保留材质 %s（索引 %d）" % (order[keep_i][0], keep_i)]
+
+    V, venc = rd_array(layer_field(geo, b"Vertices").props[0])
+    pvi_node = layer_field(geo, b"PolygonVertexIndex")
+    pvi, pienc = rd_array(pvi_node.props[0])
+    lem = layer_field(geo, b"LayerElementMaterial")
+    mats, menc = rd_array(layer_field(lem, b"Materials").props[0])
+
+    polys, pvpos, cur, cpos = [], [], [], []
+    for k, i in enumerate(pvi):
+        cur.append(-i - 1 if i < 0 else i); cpos.append(k)
+        if i < 0: polys.append(cur); pvpos.append(cpos); cur, cpos = [], []
+    if len(mats) != len(polys): raise ValueError("material array is not per polygon")
+
+    keep_poly = [k for k, m in enumerate(mats) if m == keep_i]
+    if not keep_poly: raise ValueError("that material covers no polygon")
+    kv = sorted({v for k in keep_poly for v in polys[k]})
+    vmap = {v: i for i, v in enumerate(kv)}
+    keep_pv = [p for k in keep_poly for p in pvpos[k]]
+    log.append("多边形 %d → %d，顶点 %d → %d" % (len(polys), len(keep_poly), len(V) // 3, len(kv)))
+
+    new_pvi = []
+    for k in keep_poly:
+        idx = [vmap[v] for v in polys[k]]
+        new_pvi += idx[:-1] + [-idx[-1] - 1]
+    layer_field(geo, b"Vertices").props[0] = wr_array(
+        "d", [V[3 * v + j] for v in kv for j in range(3)], venc)
+    pvi_node.props[0] = wr_array("i", new_pvi, pienc)
+    layer_field(lem, b"Materials").props[0] = wr_array("i", [0] * len(keep_poly), menc)
+
+    # every other layer element, by how it is mapped
+    for ch in geo.children:
+        if not ch.name.startswith(b"LayerElement") or ch.name == b"LayerElementMaterial":
+            continue
+        mapping = next((clean(cc.props[0][1]) for cc in ch.children
+                        if cc.name == b"MappingInformationType"), "")
+        for cc in ch.children:
+            if not (cc.props and cc.props[0][0] in "dfil"): continue
+            if cc.name.endswith(b"Index"):
+                if mapping == "ByPolygonVertex":
+                    a, e = rd_array(cc.props[0])
+                    cc.props[0] = wr_array("i", [a[p] for p in keep_pv], e)
+                continue
+            a, e = rd_array(cc.props[0])
+            if mapping == "ByVertice":
+                w = len(a) // (len(V) // 3)
+                cc.props[0] = wr_array(cc.props[0][0],
+                                       [a[w * v + j] for v in kv for j in range(w)], e)
+            elif mapping == "ByPolygonVertex" and len(a) == len(pvi):
+                cc.props[0] = wr_array(cc.props[0][0], [a[p] for p in keep_pv], e)
+
+    # skin clusters follow the surviving vertices
+    o = objects(t)
+    dropped = 0
+    for u, (c, n, s, node) in o.items():
+        if c != b"Deformer" or s != b"Cluster": continue
+        gi = layer_field(node, b"Indexes"); gw = layer_field(node, b"Weights")
+        if not gi: continue
+        idx, ie = rd_array(gi.props[0]); wt, we = rd_array(gw.props[0])
+        pair = [(vmap[i], w) for i, w in zip(idx, wt) if i in vmap]
+        dropped += len(idx) - len(pair)
+        gi.props[0] = wr_array("i", [p[0] for p in pair], ie)
+        gw.props[0] = wr_array("d", [p[1] for p in pair], we)
+    log.append("蒙皮索引丢弃 %d 条（属于被剥离的那套）" % dropped)
+
+    # drop the materials nothing uses now, then the textures and images they held
+    tobj, tcon = top(t, b"Objects"), top(t, b"Connections")
+    before_n = len(objects(t))
+    dead = {uid for nm, uid in order if uid != keep_uid}
+    tcon.children = [ch for ch in tcon.children
+                     if not ({sval(ch.props[1]), sval(ch.props[2])} & dead)]
+    tobj.children = [ch for ch in tobj.children
+                     if not (len(ch.props) >= 3 and sval(ch.props[0]) in dead)]
+
+    # A texture is alive only if a surviving material still reaches it. These files
+    # also connect every texture straight to the mesh node, a legacy edge that says
+    # nothing about which material uses it, so reachability is walked from the
+    # materials rather than taken from "appears in some connection".
+    o = objects(t)
+    feeds = collections.defaultdict(list)
+    for con in connections(t):
+        feeds[con[2]].append(con[1])
+    alive, stack = set(), [u for u, (c, n, s, _) in o.items() if c == b"Material"]
+    while stack:
+        u = stack.pop()
+        for src in feeds.get(u, []):
+            if src in alive or src not in o: continue
+            if o[src][0] in (b"Texture", b"LayeredTexture", b"Video"):
+                alive.add(src); stack.append(src)
+    dead = {u for u, (c, n, s, _) in o.items()
+            if c in (b"Texture", b"LayeredTexture", b"Video") and u not in alive}
+
+    # One image can appear as two `Video` objects with the same filename, only one
+    # of which carries pixels — here the shared normal map, whose bytes hang off the
+    # slot of the variant being removed while the surviving slot points at an empty
+    # shell. Move the pixels across before the shell's twin is deleted, or the kept
+    # colourway loses a map it had.
+    def content_of(node):
+        return next((ch for ch in node.children if ch.name == b"Content"), None)
+    def filename_of(node):
+        for key in (b"RelativeFilename", b"Filename"):
+            ch = next((c for c in node.children if c.name == key), None)
+            if ch and ch.props:
+                return clean(ch.props[0][1]).replace("\\", "/").rsplit("/", 1)[-1]
+        return None
+    pixels = {}
+    for u, (c, n, sub, node) in o.items():
+        if c != b"Video": continue
+        ct = content_of(node)
+        if ct and ct.props and len(ct.props[0][1]) > 64:
+            pixels.setdefault(filename_of(node), ct)
+    rescued = 0
+    for u, (c, n, sub, node) in o.items():
+        if c != b"Video" or u in dead: continue
+        ct = content_of(node)
+        if ct and ct.props and len(ct.props[0][1]) > 64: continue
+        donor = pixels.get(filename_of(node))
+        if donor is None: continue
+        if ct is not None:
+            ct.props = list(donor.props)
+        else:
+            cp = Node(b"Content"); cp.props = list(donor.props)
+            node.children.insert(len(node.children) - 1, cp)
+        rescued += 1
+    if rescued:
+        log.append("补回 %d 张贴图的像素（像素挂在被剥离那套的槽位上）" % rescued)
+
+    if dead:
+        tcon.children = [ch for ch in tcon.children
+                         if not ({sval(ch.props[1]), sval(ch.props[2])} & dead)]
+        tobj.children = [ch for ch in tobj.children
+                         if not (len(ch.props) >= 3 and sval(ch.props[0]) in dead)]
+    log.append("移除 %d 个对象（材质、及只有它用的贴图与内嵌图像）" %
+               (before_n - len(objects(t))))
+
+    defs = top(t, b"Definitions")
+    if defs:
+        want = collections.Counter(c for c, _, _, _ in objects(t).values())
+        for ch in defs.children:
+            if ch.name == b"ObjectType" and sval(ch.props[0]) in want:
+                for cc in ch.children:
+                    if cc.name == b"Count":
+                        cc.props[0] = ("I", struct.pack("<i", want[sval(ch.props[0])]))
+            elif ch.name == b"Count":
+                ch.props[0] = ("I", struct.pack("<i", sum(want.values())))
+
+    if dry: return log, None
+    data = serialize(t)
+    tmp = path + ".tmp"
+    with open(tmp, "wb") as fh: fh.write(data)
+    os.replace(tmp, path)
+    return log, len(data)
+
+
+def main(argv):
+    if not argv or argv[0] not in ("--list", "--keep", "--selftest"):
+        print(__doc__); return 2
+    mode = argv[0]
+    if mode == "--selftest":
+        bad = 0
+        for p in argv[1:]:
+            same = serialize(parse(p)) == open(p, "rb").read()
+            print("%-6s %s" % ("ok" if same else "DIFF", p)); bad += not same
+        return 1 if bad else 0
+    if mode == "--list":
+        for p in argv[1:]:
+            v = variants(p)
+            print("%-30s 顶点 %-6d 多边形 %-6d" % (os.path.basename(p), v["verts"], v["polys"]))
+            for i, (nm, _) in enumerate(v["materials"]):
+                print("      索引 %d  %-42s %d 顶点" % (i, nm, v["groups"].get(i, 0)))
+        return 0
+    keep, targets = argv[1], argv[2:]
+    for p in targets:
+        if serialize(parse(p)) != open(p, "rb").read():
+            print("拒绝执行：%s 无法字节级往返" % p); return 1
+        before = os.path.getsize(p)
+        log, size = strip(p, keep)
+        print(os.path.basename(p))
+        for line in log: print("    " + line)
+        print("    %d → %d 字节" % (before, size))
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main(sys.argv[1:]))

scripts/probes/fbx_takes.py

@@ -0,0 +1,87 @@
+#!/usr/bin/env python3
+"""Count animation takes in a binary FBX and read each take's time span.
+
+An FBX may hold several `AnimationStack` objects — one per take. Keyframe counts
+cannot reveal this; the stacks have to be enumerated. Each stack's LocalStart /
+LocalStop live in its Properties70 block, in FBX ktime units.
+"""
+import os, struct, sys
+
+SCALAR = {"Y": 2, "C": 1, "I": 4, "F": 4, "D": 8, "L": 8}
+ELEM   = {"f": 4, "d": 8, "l": 8, "i": 4, "b": 1}
+KTIME  = 46186158000
+
+
+def probe(path):
+    d = open(path, "rb").read()
+    if d[:21] != b"Kaydara FBX Binary  \x00":
+        raise ValueError("not a binary FBX")
+    version = struct.unpack("<I", d[23:27])[0]
+    u64 = version >= 7500
+    NREC = 25 if u64 else 13
+    stacks = []          # (name, seconds)
+    layers = 0
+
+    def rd_prop(p):
+        t = chr(d[p]); s = p; p += 1
+        if t in SCALAR:
+            p += SCALAR[t]
+            return p, (t, d[s + 1:p])
+        if t in ELEM:
+            n, enc, clen = struct.unpack("<III", d[p:p + 12]); p += 12
+            p += clen if enc else n * ELEM[t]
+            return p, (t, None)
+        if t in "SR":
+            ln = struct.unpack("<I", d[p:p + 4])[0]; p += 4
+            v = d[p:p + ln]; p += ln
+            return p, (t, v)
+        raise ValueError("bad prop %r" % t)
+
+    def rd_node(p, stack=None):
+        nonlocal layers
+        if u64: end, nprop, plen = struct.unpack("<QQQ", d[p:p + 24]); q = p + 24
+        else:   end, nprop, plen = struct.unpack("<III", d[p:p + 12]); q = p + 12
+        if end == 0 and nprop == 0 and plen == 0:
+            return p + NREC
+        nl = d[q]; q += 1; name = d[q:q + nl]; q += nl
+        p = q; props = []
+        for _ in range(nprop):
+            p, pr = rd_prop(p); props.append(pr)
+        mine = stack
+        if name == b"AnimationStack" and len(props) >= 2:
+            nm = props[1][1] or b""
+            mine = [nm.split(b"\x00\x01")[0].decode("utf-8", "replace"), 0.0]
+            stacks.append(mine)
+        elif name == b"AnimationLayer":
+            layers += 1
+        elif name == b"P" and stack is not None and props:
+            key = props[0][1]
+            if key in (b"LocalStop", b"LocalStart"):
+                for t, v in props:
+                    if t == "L" and v is not None and len(v) == 8:
+                        val = struct.unpack("<q", v)[0]
+                        if key == b"LocalStop":
+                            stack[1] = max(stack[1], val / KTIME)
+        while p < end:
+            if d[p:p + NREC] == b"\x00" * NREC: p += NREC; break
+            p = rd_node(p, mine)
+        return end
+
+    p = 27
+    while p < len(d) - 160:
+        if d[p:p + NREC] == b"\x00" * NREC: break
+        p = rd_node(p)
+    return {"num_takes": len(stacks), "num_layers": layers,
+            "takes": [(n, round(s, 3)) for n, s in stacks],
+            "total_sec": round(sum(s for _, s in stacks), 3)}
+
+
+if __name__ == "__main__":
+    for f in sys.argv[1:]:
+        try:
+            r = probe(f)
+            print("%-34s takes=%-4d layers=%-4d total=%.2fs  %s" % (
+                os.path.basename(f), r["num_takes"], r["num_layers"], r["total_sec"],
+                [n for n, _ in r["takes"]][:4]))
+        except Exception as e:
+            print("%-34s ERROR %s" % (os.path.basename(f), str(e)[:50]))

species.csv

@@ -0,0 +1,75 @@
+species,num_clips,num_joints,rig_variants,root_joint,total_frames,total_duration_sec,mean_duration_sec,num_textures,source_fbx,source_bvh,has_combined_all,has_tpose
+Alligator,21,29,1,EAL1_2,3144,104.1,4.957,6,23,22,true,true
+Anaconda,18,31,1,Null,2706,89.6,4.978,9,19,18,true,false
+Ant,17,41,1,Hips,1567,51.667,3.039,10,19,18,true,true
+Bat,10,48,1,Hips,790,26.0,2.6,6,11,11,true,true
+Bear,29,76,1,Hips,1488,48.633,1.677,5,31,30,true,true
+Bird,18,62,1,Hips,1657,54.633,3.035,8,24,18,true,false
+BrownBear,21,39,1,Hips,2425,80.133,3.816,6,23,22,true,true
+Buffalo,18,43,1,Hips,2250,74.4,4.133,10,23,19,true,true
+Buzzard,10,62,1,Hips,771,25.367,2.537,4,12,11,true,true
+Camel,18,51,1,Hips,1853,61.167,3.398,4,19,18,true,false
+Cat,4,44,1,Hips,1593,52.967,13.242,2,6,5,true,true
+Centipede,10,84,1,Hips,1159,38.3,3.83,3,12,11,true,true
+Chicken,3,41,1,Hips,492,16.3,5.433,2,5,4,true,true
+Comodoa,9,65,1,Hips,1334,44.167,4.907,4,11,10,true,true
+Coyote,10,41,1,Hips,1109,36.634,3.663,4,13,11,true,true
+Crab,9,54,1,Hips,857,28.267,3.141,5,12,11,true,true
+Cricket,12,54,1,Hips,1300,42.933,3.578,3,14,12,true,false
+Crocodile,12,39,1,Hips,1230,40.6,3.383,3,14,13,false,true
+Crow,10,29,1,Null,975,32.167,3.217,5,12,11,true,true
+Deer,20,60,1,NPC_Root__Root_,1481,48.7,2.435,3,22,21,true,true
+Dog,42,61,1,Hips,2532,83.0,1.976,0,44,43,true,false
+Dog2,35,131,1,Hips,2254,73.967,2.113,8,37,36,true,true
+Dragon,9,143,1,Hips,2010,66.7,7.411,3,12,10,true,true
+Eagle,12,52,1,Hips,948,31.2,2.6,5,15,13,true,true
+Elephant,13,42,1,Hips,1464,48.367,3.721,5,15,15,true,true
+FireAnt,24,45,1,Hips,1268,41.467,1.728,1,26,25,true,true
+Flamingo,4,41,1,Hips,682,22.6,5.65,2,6,5,true,true
+Fox,13,42,1,Hips,1643,54.334,4.18,6,17,15,true,true
+Gazelle,9,42,1,Hips,1021,33.733,3.748,4,21,10,true,true
+Giantbee,9,52,1,Hips,783,25.8,2.867,8,13,10,true,true
+Goat,10,33,1,Null,870,28.667,2.867,12,11,10,true,false
+Hamster,5,42,1,Hips,611,20.2,4.04,3,7,6,true,true
+HermitCrab,12,67,1,Hips,1229,40.567,3.381,5,15,14,true,true
+Hippopotamus,10,41,1,Hips,1136,37.533,3.753,4,13,11,true,true
+Horse,28,79,1,Hips,3500,115.733,4.133,6,31,29,true,true
+Hound,13,45,1,Hips,1204,39.7,3.054,7,15,14,true,true
+Isopetra,9,63,1,Hips,781,25.733,2.859,4,13,10,true,true
+Jaguar,13,46,1,Hips,1219,40.2,3.092,4,15,14,true,true
+Jaws,9,18,1,N_ALL,671,22.067,2.452,4,11,0,true,true
+KingCobra,12,19|20,2,Hips|Null,1453,48.033,4.003,5,14,10,true,true
+Leapord,14,48,1,Hips,1496,49.4,3.529,4,16,15,true,true
+Lion,14,32,1,Hips,1445,47.7,3.407,4,16,15,true,false
+Lynx,13,39,1,Hips,1012,33.3,2.562,4,16,15,true,true
+Mammoth,12,42,1,Hips,1668,55.2,4.6,4,15,13,true,true
+Monkey,15,88,4,B01_die|Hips,1944,64.3,4.287,9,19,13,true,false
+Ostrich,10,54,1,Hips,1068,35.267,3.527,4,13,11,true,true
+Parrot,13,71,1,Hips,1630,53.9,4.146,6,17,14,true,true
+Parrot2,3,63,1,Hips,704,23.367,7.789,2,5,4,true,true
+Pigeon,11,9,1,Hips,874,28.767,2.615,1,14,12,true,true
+Pirrana,10,22,1,Hips,787,25.9,2.59,2,13,12,true,true
+PolarBear,9,41,1,Hips,1119,37.0,4.111,5,12,10,true,true
+PolarBearB,8,39,1,Hips,880,29.067,3.633,5,17,8,true,true
+Pteranodon,12,44,1,Hips,735,24.1,2.008,0,13,12,true,false
+Puppy,4,40,1,Hips,1103,36.633,9.158,2,6,5,true,true
+Raindeer,9,36,1,Hips,911,30.067,3.341,4,11,10,true,true
+Raptor,10,36,1,Hips,1609,53.3,5.33,3,12,11,true,true
+Raptor2,39,63,1,Hips,5411,179.067,4.591,4,41,40,true,true
+Raptor3,13,64,1,Hips,1309,43.2,3.323,0,15,14,true,true
+Rat,6,18,1,Hips,381,12.5,2.083,2,8,6,true,false
+Rhino,9,44,1,Hips,1219,40.333,4.481,2,11,10,true,true
+Roach,11,46,1,Hips,342,11.033,1.003,3,13,12,true,true
+SabreToothTiger,43,74,1,Hips,2279,74.533,1.733,3,45,44,true,false
+SandMouse,13,38,1,Hips,1740,57.567,4.428,5,18,14,true,true
+Scorpion,13,64,1,Hips,826,27.1,2.085,2,15,14,true,true
+Scorpion2,39,59,1,Hips,3171,104.4,2.677,0,41,40,true,false
+Skunk,7,36,1,Hips,677,22.333,3.19,4,11,8,true,true
+Spider,32,71,1,Hips,1864,61.067,1.908,0,34,33,true,true
+SpiderG,18,62,1,Hips,2696,89.267,4.959,6,22,19,true,true
+Stego,10,41,1,Hips,1170,38.667,3.867,2,12,11,true,true
+Trex,70,61,1,jt_Cog_C,7708,254.6,3.637,0,72,71,true,false
+Tricera,9,32,1,Hips,1088,35.967,3.996,6,11,10,true,true
+Tukan,8,18,1,Hips,397,12.967,1.621,3,10,9,true,true
+Turtle,10,50,1,Hips,1466,48.533,4.853,9,12,11,true,true
+Tyranno,10,69,1,Hips,969,31.967,3.197,3,12,11,true,true