@volter/blender-engine 0.1.132 → 0.1.133

package/browser/protocol.ts

@@ -78,7 +78,10 @@ export type WorkerRequest =
    *  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 }
+  | { 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/runtime.ts

@@ -423,15 +423,22 @@ export class BlenderRuntime {
    *  false` answers the header and the summary row's key columns without the
    *  sampled tracks, which is what a Timeline that only needs to DRAW asks
    *  for. */
-  async actionClip(options?: { object?: string; bake?: boolean }): Promise<BlenderActionClip> {
+  async actionClip(options?: { object?: string; bake?: boolean; action?: string }): Promise<BlenderActionClip> {
     await this.#ready();
     return (await this.#request({
       op: 'action-clip',
       ...(options?.object === undefined ? {} : { object: options.object }),
       ...(options?.bake === undefined ? {} : { bake: options.bake }),
+      ...(options?.action === undefined ? {} : { action: options.action }),
     })) 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
    *  name rather than written somewhere near it. */

package/browser/session.py

@@ -4841,7 +4841,51 @@ def _summary_objects():
     return out
 
 
-def rna_action_clip(object_name=None, bake=True):
+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.
 
@@ -4910,13 +4954,32 @@ def rna_action_clip(object_name=None, bake=True):
         # when the subject below turns out to be nothing at all.
         "summary": _summary_objects(),
     }
-    if arm_obj is None or arm_obj.animation_data is None or arm_obj.animation_data.action is None:
+    adt = arm_obj.animation_data if arm_obj is not None else None
+    assigned = adt.action if adt is not None else None
+    if arm_obj is None or (assigned is None and not action_name):
         header["reason"] = ("Nothing here carries an action: the Timeline draws the scene range "
                             "and an empty summary row, which is Blender's own empty state.")
         return header
-    adt = arm_obj.animation_data
-    action = adt.action
-    slot = getattr(adt, "action_slot", None)
+    action = assigned
+    slot = getattr(adt, "action_slot", None) if adt is not None else None
+    if action_name and (assigned is None or action_name != assigned.name):
+        # A NAMED ACTION, assigned or not (a game's clip library: Idle, Run, Attack side by side):
+        # baked against this armature WITHOUT assigning it, so the file is untouched. Its curves
+        # are its first channelbag's (no slot of this object chooses among them).
+        action = bpy.data.actions.get(action_name)
+        if action is None:
+            raise ValueError("The engine holds no action named %r" % (action_name,))
+        # THE SLOT FOR THIS ARMATURE, as Blender would pick it on assignment: the one whose
+        # identifier names this object (`OB<name>`), else the only object slot. A layered action
+        # with several object slots and none for this armature has no right answer; its first
+        # object slot is used and said in the reason.
+        slots = [one for one in getattr(action, "slots", ()) if getattr(one, "target_id_type", "OBJECT") == "OBJECT"]
+        slot = next((one for one in slots if getattr(one, "identifier", "") == "OB" + arm_obj.name), None)
+        if slot is None and slots:
+            slot = slots[0]
+            if len(slots) > 1:
+                header["reason"] = ("%r has %d object slots and none named for %r; the first, %r, is played."
+                                    % (action.name, len(slots), arm_obj.name, getattr(slot, "identifier", "?")))
     curves, shape = _action_channelbag(action, getattr(slot, "handle", None))
     header.update({
         "action": action.name,
@@ -5451,7 +5514,9 @@ def _dispatch(request):
     if op == "rig":
         return rna_rig(request.get("object"))
     if op == "action-clip":
-        return rna_action_clip(request.get("object"), request.get("bake", True))
+        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-geometry.ts

@@ -277,7 +277,7 @@ export function graphAttributeName(name: string): string {
 }
 
 export function geometryFromDrawArrays(
-  arrays: Omit<DrawArrays, 'hash' | 'sourceVertex'> & { sourceVertex?: Uint32Array },
+  arrays: Omit<DrawArrays, 'hash' | 'sourceVertex'> & { sourceVertex?: Uint32Array | undefined },
 ): THREE.BufferGeometry {
   const geometry = new THREE.BufferGeometry();
   geometry.setAttribute('position', new THREE.BufferAttribute(arrays.positions, 3));

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

@@ -147,6 +147,8 @@ const drawArraysSchema = z
         })
         .strict(),
     ),
+    /** The draw's vertex map (`DrawArrays.sourceVertex`), kept by a copy that plays (skins bind over it). */
+    sourceVertex: z.instanceof(Uint32Array).optional(),
     hash: z.string(),
   })
   .strict();
@@ -2248,7 +2250,7 @@ export class BlenderRuntimeView {
   /** Everything this view holds, as ONE self-contained frame another view can be built from:
    *  every mesh's resident geometry and every resident image, with no reference to what a
    *  receiver already holds. */
-  private fullFrame(): Frame {
+  private fullFrame(options: { sourceVertices?: boolean } = {}): Frame {
     const source = this.frame;
     if (!source) throw new Error('Blender capture requires a presented frame');
     // Inspection overlays are not render content. In particular weight-paint
@@ -2290,6 +2292,12 @@ export class BlenderRuntimeView {
           count: group.count,
           materialIndex: group.materialIndex ?? 0,
         })),
+        // A COPY THAT PLAYS keeps the draw's vertex map: Play binds skins over it (a Blender
+        // vertex's weights expand onto its drawn vertices through it), where a render snapshot
+        // needs none.
+        ...(options.sourceVertices && geometry.getAttribute('blenderVertex')
+          ? { sourceVertex: new Uint32Array((geometry.getAttribute('blenderVertex') as THREE.BufferAttribute).array) }
+          : {}),
       };
     }
     for (const [id, { signature }] of this.volumes)
@@ -2368,7 +2376,7 @@ export class BlenderRuntimeView {
    */
   detach(): { readonly view: BlenderRuntimeView; dispose(): void } {
     const detached = new BlenderRuntimeView();
-    if (this.frame) detached.applyFrame(this.fullFrame());
+    if (this.frame) detached.applyFrame(this.fullFrame({ sourceVertices: true }));
     let disposed = false;
     return {
       view: detached,

package/browser/worker.ts

@@ -806,7 +806,10 @@ async function handle(request: WorkerRequest): Promise<unknown> {
         op: 'action-clip',
         ...(request.object === undefined ? {} : { object: request.object }),
         ...(request.bake === undefined ? {} : { bake: request.bake }),
+        ...(request.action === undefined ? {} : { action: request.action }),
       });
+    case 'armature-actions':
+      return ask({ op: 'armature-actions' });
     case 'outliner-set':
       return ask({
         op: 'outliner-set',

package/package.json

@@ -2,7 +2,7 @@
   "name": "@volter/blender-engine",
   "author": "Volter AI, Inc.",
   "license": "GPL-3.0-or-later",
-  "version": "0.1.132",
+  "version": "0.1.133",
   "publishConfig": {
     "access": "public"
   },