@volter/blender-engine 0.1.133 → 0.1.134

package/browser/protocol.ts

@@ -68,20 +68,11 @@ export type WorkerRequest =
    *  Given no `object`, the view layer's active object answers. READ ONLY:
    *  pinning, unwrapping and selecting are edits. */
   | { id: number; op: 'uv-layout'; object?: string; uvLayer?: string }
-  /** ONE MESH'S SKIN BINDING (`session.py`'s `rna_rig`) — the armature's bones
-   *  with their rest AND bind matrices, plus up to four weighted influences
-   *  per Blender vertex as base64 typed-array bytes. The BIND pose is the
-   *  pose the exported columns were evaluated at, which is what lets three.js
-   *  own playback without Blender's frame ever moving. READ ONLY. */
-  | { id: number; op: 'rig'; object?: string }
   /** ONE ACTION AS A THREE.JS CLIP (`session.py`'s `rna_action_clip`) — per
    *  bone, the LOCAL transform at every integer frame of the action's range,
    *  plus the scene's frame range/fps and the summary row's key columns.
    *  READ ONLY: keying, moving a key and setting a range are edits. */
   | { id: number; op: 'action-clip'; object?: string; bake?: boolean; action?: string }
-  /** EVERY ARMATURE AND THE ACTIONS THAT CAN PLAY ON IT (`session.py`'s `rna_armature_actions`):
-   *  each action that animates one of its pose bones, assigned or not. READ ONLY. */
-  | { id: number; op: 'armature-actions' }
   /** ONE RESTRICTION COLUMN, written (`session.py`'s `outliner_set`). A column
    *  Blender draws on no row of that type is refused by name. */
   | { id: number; op: 'outliner-set'; path: string; column: string; value: boolean }

package/browser/rna.ts

@@ -527,79 +527,6 @@ export interface BlenderUvLayout {
   } | null;
 }
 
-/**
- * ONE MESH'S SKIN BINDING (`session.py`'s `rna_rig`) — what a
- * `THREE.SkinnedMesh` needs, and nothing Blender does not carry.
- *
- * WE VISUALIZE WITH THREE.JS, NOT BLENDER (owner rule, 2026-09-20). Blender
- * holds the animation as DATA; three.js plays it. This door and
- * {@link BlenderActionClip} are the whole of what crosses to make that true —
- * once per rig, rather than a depsgraph evaluation and a re-export per frame.
- *
- * THE BIND POSE IS `pose`, NOT `rest`, and that is the load-bearing fact: the
- * export door runs with `evaluate: True`, so the mesh columns the presenter
- * holds are the mesh ALREADY DEFORMED at Blender's current frame. A skeleton
- * bound in that same pose makes the skinning an identity there, so the picture
- * at the bind frame is exactly the frame Blender presented — and Blender's
- * `frame_current` never has to move again for playback.
- *
- * THE INDICES ARE BLENDER VERTEX INDICES. `DrawArrays.sourceVertex` maps a
- * drawn vertex back to its Blender one, and the presenter expands these arrays
- * through it (`blender-runtime-skin.ts`) exactly as I4's weight ramp does.
- */
-export interface BlenderRigBone {
-  readonly name: string;
-  readonly parent: string | null;
-  /** `Bone.matrix_local` — the REST pose in the armature object's space,
-   *  row-major as four rows. Diagnostic here; the bind is `pose`. */
-  readonly rest: readonly (readonly [number, number, number, number])[];
-  /** `PoseBone.matrix` (`pchan->pose_mat`), the same matrix I4's bone overlay
-   *  draws — the BIND pose, in the armature object's space. */
-  readonly pose: readonly (readonly [number, number, number, number])[];
-  readonly length: number;
-  readonly deform: boolean;
-  readonly connected: boolean;
-}
-
-export interface BlenderRigBinding {
-  readonly object: string | null;
-  readonly mesh?: string;
-  readonly armature: string | null;
-  readonly armatureData?: string;
-  readonly bones: readonly BlenderRigBone[];
-  readonly vertexCount: number;
-  /** `scene.frame_current` when the binding was read — the frame the exported
-   *  columns, and therefore the bind pose, belong to. */
-  readonly frame?: number;
-  readonly mode?: string;
-  /** Bones whose pose is a SOLVER's rather than their channels'. The clip is
-   *  derived from the F-Curves alone, so a constrained bone's playback cannot
-   *  reproduce Blender's own answer; the view names them instead of drifting. */
-  readonly constrainedBones?: readonly string[];
-  /** Uint16, `vertexCount * 4`. */
-  readonly skinIndexBase64?: string;
-  /** Float32, `vertexCount * 4`, each vertex's four normalized to sum to one. */
-  readonly skinWeightBase64?: string;
-  readonly maxInfluences?: number;
-  readonly truncatedVertices?: number;
-  readonly unweightedVertices?: number;
-  readonly unmappedGroups?: readonly string[];
-  /** Why there is no binding, when there is none. Never a silent empty. */
-  readonly reason?: string;
-}
-
-/** EVERY SKIN BINDING THE SCENE NEEDS, which is the PRESENTER's question: a
- *  presented frame carries every object at once and the presenter has to know
- *  which of its meshes are `THREE.SkinnedMesh`es before it builds them. With
- *  `named` set, the list is that one mesh. */
-export interface BlenderRig {
-  /** `scene.frame_current` when the bindings were read — the frame the
-   *  exported columns, and therefore every bind pose here, belong to. */
-  readonly frame: number;
-  readonly named: string | null;
-  readonly rigs: readonly BlenderRigBinding[];
-}
-
 /**
  * ONE TRACK of {@link BlenderActionClip}: a bone's LOCAL `position`,
  * `quaternion` or `scale` sampled at every integer frame.

package/browser/runtime.ts

@@ -21,7 +21,6 @@ import type {
   BlenderNodeTree,
   BlenderOutlinerTree,
   BlenderOutlinerWrite,
-  BlenderRig,
   BlenderRnaContext,
   BlenderRnaView,
   BlenderRnaWrite,
@@ -408,16 +407,6 @@ export class BlenderRuntime {
     })) as BlenderUvLayout;
   }
 
-  /** ONE MESH'S SKIN BINDING (`./rna.ts`, `BlenderRig`) — the armature's
-   *  bones and the per-vertex influences a `THREE.SkinnedMesh` needs. Given no
-   *  `object`, the view layer's ACTIVE mesh answers. */
-  async rig(options?: { object?: string }): Promise<BlenderRig> {
-    await this.#ready();
-    return (await this.#request({
-      op: 'rig',
-      ...(options?.object === undefined ? {} : { object: options.object }),
-    })) as BlenderRig;
-  }
 
   /** ONE ACTION AS A THREE.JS CLIP (`./rna.ts`, `BlenderActionClip`). `bake:
    *  false` answers the header and the summary row's key columns without the
@@ -433,11 +422,6 @@ export class BlenderRuntime {
     })) as BlenderActionClip;
   }
 
-  /** Every armature and the actions that can play on it, assigned or not (a game's clip library). */
-  async armatureActions(): Promise<{ armatures: { armature: string; current: string | null; actions: string[]; keys?: string }[]; scene?: { frameCurrent: number; frameStart: number; frameEnd: number; fps: number } }> {
-    await this.#ready();
-    return (await this.#request({ op: 'armature-actions' })) as { armatures: { armature: string; current: string | null; actions: string[]; keys?: string }[]; scene?: { frameCurrent: number; frameStart: number; frameEnd: number; fps: number } };
-  }
 
   /** Write ONE restriction column (the eye, the render camera, a collection's
    *  Exclude). A column Blender draws on no row of that type is refused by

package/browser/session.py

@@ -1372,6 +1372,12 @@ def _armatures(view_layer):
             # `ARM_DRAW_MODE_*` switch, `:906-936`).
             "mode": obj.mode,
             "bones": _armature_bones(obj, locked),
+            # THE ACTION IT PLAYS (`animation_data.action`): what the presenter's mixer plays on
+            # this armature's skeleton, baked through the clip door at the revision the frame's
+            # `actions` names for it.
+            "action": (obj.animation_data.action.name
+                       if obj.animation_data is not None and obj.animation_data.action is not None
+                       else None),
         }
     return armatures
 
@@ -1642,6 +1648,9 @@ class Session:
             "scale_length": float(scene.unit_settings.scale_length),
         }
         frame["armatures"] = _armatures(view_layer)
+        # THE SCENE'S CLOCK beside the frame number: what a Timeline draws and a mixer maps time by.
+        frame["clock"] = {"start": int(scene.frame_start), "end": int(scene.frame_end),
+                          "fps": float(scene.render.fps) / float(scene.render.fps_base or 1.0)}
         frame["weights"] = _weights(scene, view_layer, frame, self._known)
         warnings = list(frame.get("warnings", ()))
         warnings.extend(_WARNINGS)
@@ -4617,31 +4626,6 @@ def _matrix_rows(matrix):
     return [[float(v) for v in row] for row in matrix]
 
 
-def rna_rig(object_name=None):
-    """EVERY SKIN BINDING THE SCENE NEEDS -- or one named mesh's.
-
-    A LIST, not a singleton, and that is what the PRESENTER's question is: a
-    presented frame carries every object at once, and the presenter has to know
-    which of its meshes are `THREE.SkinnedMesh`es before it builds them. Asking
-    per object would be one round trip per mesh; asking by NAME stays available
-    for a `cyclotron eval` that wants to read one.
-    """
-    scene_frame = int(bpy.context.scene.frame_current)
-    if object_name:
-        obj = bpy.data.objects.get(object_name)
-        if obj is None:
-            raise ValueError("The engine holds no object named %r" % (object_name,))
-        subjects = [obj]
-    else:
-        subjects = [obj for obj in bpy.context.view_layer.objects
-                    if obj.type == "MESH" and obj.data is not None
-                    and obj.find_armature() is not None]
-    rigs = []
-    for obj in subjects:
-        _asked({"checkpoint": "rig-object"})
-        rigs.append(_rig_of(obj))
-    return {"frame": scene_frame, "named": object_name, "rigs": rigs}
-
 
 def _rig_of(obj):
     """ONE MESH'S SKIN BINDING: the armature's bones, and up to four weighted
@@ -4841,50 +4825,6 @@ def _summary_objects():
     return out
 
 
-def rna_armature_actions():
-    """EVERY ARMATURE AND THE ACTIONS THAT CAN PLAY ON IT -- what a game picks its clips from.
-
-    An action can play on an armature when it animates at least one of that armature's pose bones
-    (`pose.bones["<name>"]...` on a bone the armature has). Read off each action's F-Curves through
-    `_action_channelbag`, every channelbag, so an action assigned to nothing (a clip library: Idle,
-    Run, Attack beside each other in the file) is offered as well as the one each armature plays now.
-    READ ONLY."""
-    out = []
-    for arm in bpy.data.objects:
-        if arm.type != "ARMATURE" or arm.pose is None:
-            continue
-        bones = {pchan.name for pchan in arm.pose.bones}
-        current = arm.animation_data.action.name if (arm.animation_data and arm.animation_data.action) else None
-        names = []
-        keys, total = 0, 0.0
-        for action in bpy.data.actions:
-            curves = []
-            legacy = getattr(action, "fcurves", None)
-            if legacy is not None:
-                curves = list(legacy)
-            else:
-                for layer in getattr(action, "layers", ()):
-                    for strip in getattr(layer, "strips", ()):
-                        for bag in (getattr(strip, "channelbags", None) or ()):
-                            curves.extend(bag.fcurves)
-            if any((m := _BONE_PATH.match(fc.data_path)) is not None and m.group(1) in bones for fc in curves):
-                names.append(action.name)
-                # A CHEAP SIGNATURE of the keys, so a reader can tell a key edit from no change
-                # without baking: the count and the sum of every key's frame and value.
-                for fc in curves:
-                    for key in fc.keyframe_points:
-                        keys += 1
-                        total += float(key.co[0]) * 7.0 + float(key.co[1])
-        out.append({"armature": arm.name, "current": current, "actions": sorted(names),
-                    "keys": "%d:%.6f" % (keys, total)})
-    scene = bpy.context.scene
-    # THE SCENE'S CLOCK TOO: a reader that skips a re-bind on an unchanged listing must still see
-    # the playhead and range move when an agent sets them.
-    return {"armatures": out, "scene": {"frameCurrent": int(scene.frame_current),
-                                        "frameStart": int(scene.frame_start), "frameEnd": int(scene.frame_end),
-                                        "fps": float(scene.render.fps) / float(scene.render.fps_base or 1.0)}}
-
-
 def rna_action_clip(object_name=None, bake=True, action_name=None):
     """ONE ACTION AS A THREE.JS CLIP: per bone, the LOCAL transform it has at
     every integer frame of the action's own range.
@@ -5248,13 +5188,44 @@ def rna_outliner(selected=None):
             parent_row["children"].append(duplicate)
             mine.append([duplicate, parent_row, parent_collection])
 
+    # THE SELECTION KEEPS ITS ROWS PAST THE PAGE. A row is how the editor
+    # addresses an object -- the viewport's outline and gizmo, the Properties
+    # rail -- so a selected or active object, the caller's or the engine's, keeps
+    # its row and every row above it however far down a long list it sits.
+    # BOUNDED LIKE THE PAGE ITSELF: the active object always, then at most one
+    # page of the selection, so selecting everything cannot turn one read back
+    # into the whole tree the page exists to keep out (Canyon Comet, 1,493
+    # objects selected: 1.77 MB a read uncapped, 142 KB capped).
+    wanted = [active] if active is not None else []
+    wanted += [o.name for o in view_layer.objects if o.select_get(view_layer=view_layer)]
+    wanted += sorted(chosen)
+    kept = set()
+    for name in wanted:
+        if len(kept) > _OUTLINER_PAGE:
+            break
+        kept.add(name)
+    holding = set()
+
+    def hold(row):
+        inside = row.get("struct") == "Object" and row.get("object") in kept
+        for child in row.get("children", []):
+            inside = hold(child) or inside
+        if inside:
+            holding.add(id(row))
+        return inside
+
+    hold(scene_collection)
+
     # Cap the hierarchy's visible child lists, not the collection's flat input.
     # Every parent participates in folding even when its child list needs a page.
     def page_tree(row):
-        children, more = _outliner_page(row.get("children", []))
+        members = row.get("children", [])
+        children, more = _outliner_page(members)
+        beyond = [child for child in members[len(children):] if id(child) in holding]
+        children = children + beyond
         row["children"] = children
-        if more:
-            row["more"] = more
+        if more - len(beyond):
+            row["more"] = more - len(beyond)
         for child in children:
             page_tree(child)
 
@@ -5511,12 +5482,8 @@ def _dispatch(request):
     # THE RIG AND CLIP DOORS (the Timeline): both READS, so neither presents
     # and neither owes a derivation. There is deliberately no writer beside
     # them -- keying, moving a key and setting a range are edits.
-    if op == "rig":
-        return rna_rig(request.get("object"))
     if op == "action-clip":
         return rna_action_clip(request.get("object"), request.get("bake", True), request.get("action"))
-    if op == "armature-actions":
-        return rna_armature_actions()
     if op == "outliner":
         return rna_outliner(request.get("selected"))
     if op == "outliner-set":

package/browser/three/blender-runtime-armature.ts

@@ -61,6 +61,8 @@ export const armatureSchema = z
     showInFront: z.boolean(),
     mode: z.string(),
     bones: z.array(boneSchema),
+    /** `animation_data.action`, the action it plays (`session.py` `_armatures`). */
+    action: z.string().nullable().optional(),
   })
   .strict();
 

package/browser/three/blender-runtime-skeleton.ts

@@ -0,0 +1,204 @@
+/**
+ * THE SKELETONS A FRAME DESCRIBES, and the skinned meshes bound to them.
+ *
+ * WHERE THE SKIN COMES FROM: the export door itself (`bpy_web_export.cc`, `write_skin`). Every mesh
+ * an Armature modifier deforms arrives with a `skin` block: the armature's name, the mesh's vertex
+ * group names and, per EXPORTED vertex, its four strongest groups and their normalized weights. The
+ * frame's `armatures` already name every bone with its parent and its pose matrix
+ * (`PoseBone.matrix`, armature space). So one frame holds everything a skin needs, from one
+ * evaluation, and nothing here reads the engine or guesses whether what it holds is stale: a weight
+ * edit, a modifier added or removed, a new pose, each re-exports the mesh under a new revision (the
+ * door's skin digest moves it) and the skin is rebuilt with the geometry.
+ *
+ * THE BIND IS THE EXPORTED POSE. The exported vertices are already deformed, at the pose the frame
+ * names, so each bone's inverse is that pose's inverse: at Blender's own pose the skinning is an
+ * identity and the picture is exactly the one Blender evaluated. A clip played on the bones
+ * (`AnimationMixer` over `rig().bones`) moves the mesh from there. The inverses come from the
+ * frame's matrices, never from the bones' current transforms, so a bind taken while a clip is
+ * playing is still right.
+ *
+ * AN UNWEIGHTED VERTEX stays where it is, as in Blender: the door gives it the index one past the
+ * groups with weight 1, and that index is a bone at the armature's origin that never moves. A group
+ * no bone is named for weights nothing (it is that same still bone), as it deforms nothing in Blender.
+ */
+import * as THREE from 'three';
+import type { BlenderArmature } from './blender-runtime-armature';
+
+/** The `skin` block of an exported mesh, as the door writes it (typed arrays by the worker). */
+export interface FrameSkin {
+  readonly armature: string;
+  readonly groups: readonly string[];
+  readonly columns: { readonly joints: Uint16Array; readonly weights: Float32Array };
+}
+
+export interface ArmatureRig {
+  /** The armature this rig belongs to, by Blender object name. */
+  readonly armature: string;
+  /** The armature's presented object, which the bones hang under. */
+  readonly object: THREE.Object3D;
+  /** Every bone by Blender's own bone name (unsanitized: a game finds them by those names). */
+  readonly bones: ReadonlyMap<string, THREE.Bone>;
+  /** The action the file assigns this armature (`animation_data.action`), if any. */
+  readonly action: string | null;
+}
+
+interface Rig extends ArmatureRig {
+  readonly root: THREE.Group;
+  readonly still: THREE.Bone;
+  /** Bone names and parents: a change rebuilds the bones. */
+  readonly structure: string;
+  /** The pose matrices last applied, armature space, by bone name. */
+  pose: Map<string, THREE.Matrix4>;
+  poseKey: string;
+  action: string | null;
+}
+
+const matrixOf = (rows: readonly (readonly number[])[]): THREE.Matrix4 =>
+  new THREE.Matrix4().set(...(rows.flat() as Parameters<THREE.Matrix4['set']>));
+
+/** Expand an exported mesh's per-vertex skin onto its DRAWN vertices (`blenderVertex`, the draw's
+ *  map back to Blender's vertices), as the geometry's `skinIndex` and `skinWeight`. */
+export function skinGeometry(geometry: THREE.BufferGeometry, skin: FrameSkin): void {
+  const source = geometry.getAttribute('blenderVertex');
+  if (!source) throw new Error(`A skinned mesh of ${skin.armature} was drawn without its vertex map`);
+  const drawn = source.count;
+  const indices = new Uint16Array(drawn * 4);
+  const weights = new Float32Array(drawn * 4);
+  for (let i = 0; i < drawn; i++) {
+    const vertex = source.getX(i);
+    indices.set(skin.columns.joints.subarray(vertex * 4, vertex * 4 + 4), i * 4);
+    weights.set(skin.columns.weights.subarray(vertex * 4, vertex * 4 + 4), i * 4);
+  }
+  geometry.setAttribute('skinIndex', new THREE.Uint16BufferAttribute(indices, 4));
+  geometry.setAttribute('skinWeight', new THREE.Float32BufferAttribute(weights, 4));
+  geometry.userData['blenderSkin'] = { armature: skin.armature, groups: [...skin.groups] };
+}
+
+export class RuntimeSkeletons {
+  #rigs = new Map<string, Rig>();
+
+  /** The rig of one armature, or null when the frame names none by that name. */
+  rig(armature: string): ArmatureRig | null {
+    return this.#rigs.get(armature) ?? null;
+  }
+
+  rigs(): readonly ArmatureRig[] {
+    return [...this.#rigs.values()];
+  }
+
+  /**
+   * Bring the rigs to this frame: build an armature's bones when it is new or its bones changed,
+   * and pose them as Blender posed them WHEN THAT POSE CHANGED, so a clip a reader is playing is
+   * not reset by a frame that says nothing new about the pose.
+   */
+  apply(armatures: Readonly<Record<string, BlenderArmature>>,
+    objectFor: (name: string) => THREE.Object3D | null): void {
+    for (const [name, rig] of [...this.#rigs]) {
+      const armature = armatures[name];
+      const object = objectFor(name);
+      if (!armature || !object || object !== rig.object) {
+        rig.root.removeFromParent();
+        this.#rigs.delete(name);
+      }
+    }
+    for (const [name, armature] of Object.entries(armatures)) {
+      const object = objectFor(name);
+      if (!object) continue;
+      const structure = armature.bones.map((bone) => `${bone.name}\u0000${bone.parent ?? ''}`).join('\u0001');
+      let rig = this.#rigs.get(name);
+      if (rig && rig.structure !== structure) {
+        rig.root.removeFromParent();
+        rig = undefined;
+      }
+      if (!rig) {
+        const root = new THREE.Group();
+        root.name = `${name}:bones`;
+        const still = new THREE.Bone();
+        still.name = `${name}:still`;
+        root.add(still);
+        const bones = new Map<string, THREE.Bone>();
+        for (const declared of armature.bones) {
+          const bone = new THREE.Bone();
+          bone.name = declared.name;
+          bones.set(declared.name, bone);
+        }
+        for (const declared of armature.bones) {
+          const parent = declared.parent === null ? undefined : bones.get(declared.parent);
+          (parent ?? root).add(bones.get(declared.name)!);
+        }
+        object.add(root);
+        rig = { armature: name, object, root, still, bones, structure, pose: new Map(), poseKey: '', action: null };
+        this.#rigs.set(name, rig);
+      }
+      rig.action = armature.action ?? null;
+      const poseKey = armature.bones.map((bone) => bone.matrix.flat().join(',')).join(';');
+      if (poseKey !== rig.poseKey) {
+        rig.poseKey = poseKey;
+        rig.pose = new Map(armature.bones.map((bone) => [bone.name, matrixOf(bone.matrix)]));
+        RuntimeSkeletons.#pose(rig, armature);
+      }
+    }
+  }
+
+  /** Set every bone's local transform from the frame's armature-space pose matrices. */
+  static #pose(rig: Rig, armature: BlenderArmature): void {
+    for (const declared of armature.bones) {
+      const own = rig.pose.get(declared.name)!;
+      const parent = declared.parent === null ? undefined : rig.pose.get(declared.parent);
+      const local = parent ? parent.clone().invert().multiply(own) : own.clone();
+      const bone = rig.bones.get(declared.name)!;
+      local.decompose(bone.position, bone.quaternion, bone.scale);
+    }
+  }
+
+  /** Put Blender's pose back on an armature's bones, after a reader that played a clip lets go. */
+  restorePose(armature: string): void {
+    const rig = this.#rigs.get(armature);
+    if (!rig) return;
+    for (const [name, own] of rig.pose) {
+      const bone = rig.bones.get(name)!;
+      const parentBone = bone.parent instanceof THREE.Bone && bone.parent !== rig.still ? bone.parent : null;
+      const parent = parentBone ? rig.pose.get(parentBone.name) : undefined;
+      const local = parent ? parent.clone().invert().multiply(own) : own.clone();
+      local.decompose(bone.position, bone.quaternion, bone.scale);
+    }
+  }
+
+  /**
+   * A mesh object's skinned form: a `THREE.SkinnedMesh` over its geometry, bound to its armature's
+   * rig at the pose the frame was exported in. Null when its geometry carries no skin or its
+   * armature is not in the frame (it then draws as the plain, exported mesh: Blender's own pose).
+   * The world matrices must be current (`root.updateMatrixWorld(true)`) before this is called.
+   */
+  bind(mesh: THREE.SkinnedMesh | THREE.Mesh): THREE.SkinnedMesh | null {
+    const skin = mesh.geometry.userData['blenderSkin'] as { armature: string; groups: string[] } | undefined;
+    const rig = skin ? this.#rigs.get(skin.armature) : undefined;
+    if (!skin || !rig) return null;
+    const skinned = (mesh as THREE.SkinnedMesh).isSkinnedMesh ? mesh as THREE.SkinnedMesh
+      : new THREE.SkinnedMesh(mesh.geometry, mesh.material);
+    if (skinned !== mesh) {
+      skinned.name = mesh.name;
+      skinned.matrixAutoUpdate = mesh.matrixAutoUpdate;
+      skinned.matrix.copy(mesh.matrix);
+      skinned.matrix.decompose(skinned.position, skinned.quaternion, skinned.scale);
+      skinned.userData = mesh.userData;
+      // A skin moves past its bind bounds: three computes them from the bind pose.
+      skinned.frustumCulled = false;
+    }
+    const armatureWorld = rig.object.matrixWorld;
+    const bones = [...skin.groups.map((group) => rig.bones.get(group) ?? rig.still), rig.still];
+    const inverses = bones.map((bone) => {
+      const pose = bone === rig.still ? undefined : rig.pose.get(bone.name);
+      const world = pose ? armatureWorld.clone().multiply(pose) : armatureWorld.clone();
+      return world.invert();
+    });
+    mesh.updateWorldMatrix(true, false);
+    skinned.bind(new THREE.Skeleton(bones, inverses), mesh.matrixWorld.clone());
+    return skinned;
+  }
+
+  dispose(): void {
+    for (const rig of this.#rigs.values()) rig.root.removeFromParent();
+    this.#rigs.clear();
+  }
+}