@volter/blender-engine 0.1.133 → 0.1.135

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

@@ -528,95 +528,29 @@ export interface BlenderUvLayout {
 }
 
 /**
- * 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.
+ * ONE F-CURVE of {@link BlenderActionClip}, whole: one component (`index`) of one of a bone's
+ * channels (`location`, `rotation_quaternion` as w,x,y,z, `rotation_euler`, `rotation_axis_angle`
+ * as angle,x,y,z, `scale`), with everything `fcurve_eval_keyframes` reads to evaluate it.
  */
-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[];
+export interface BlenderClipTrack extends BlenderClipCurve {
+  readonly bone: string;
+  readonly property: 'location' | 'rotation_quaternion' | 'rotation_euler' | 'rotation_axis_angle' | 'scale';
+  readonly index: number;
 }
 
-/**
- * ONE TRACK of {@link BlenderActionClip}: a bone's LOCAL `position`,
- * `quaternion` or `scale` sampled at every integer frame.
- *
- * `constant` says the door found every sample equal to the first and shipped
- * two keys instead of N — which is most of a rig, most of the time.
- */
-export interface BlenderClipTrack {
-  readonly bone: string;
-  readonly property: 'position' | 'quaternion' | 'scale';
-  readonly stride: number;
-  readonly count: number;
-  readonly constant: boolean;
-  /** Float32 seconds, `count` of them, zero at `clipStart`. */
-  readonly timeBase64: string;
-  /** Float32, `count * stride`. */
-  readonly valueBase64: string;
+/** An F-Curve's body: everything Blender evaluates it from, wherever it lives. */
+export interface BlenderClipCurve {
+  /** `FCurve.extrapolation`: `CONSTANT` or `LINEAR`. */
+  readonly extrapolation: string;
+  /** Per key, how the segment after it interpolates: 0 constant, 1 linear, 2 Bezier. */
+  readonly interpolation: readonly number[];
+  /** Float32, six per key: `co`, `handle_left`, `handle_right` (frame, value each). */
+  readonly keysBase64: string;
+  /** A Cycles modifier: [mode before, cycles before, mode after, cycles after]; mode 0 none,
+   *  1 repeat, 2 repeat with offset, 3 mirror. */
+  readonly cycles?: readonly [number, number, number, number];
+  /** What this curve does in Blender that is not played (an easing type, another modifier). */
+  readonly unsupported?: readonly string[];
 }
 
 /** One column of the Timeline's summary row: a frame at which SOMETHING is
@@ -689,9 +623,18 @@ export interface BlenderActionClip {
   readonly tracks: readonly BlenderClipTrack[];
   readonly clipStart?: number;
   readonly clipEnd?: number;
+  /** The range Blender places the action over NLA strips in: its keys, null on a side a Cycles
+   *  modifier repeats into. */
+  readonly keysStart?: number | null;
+  readonly keysEnd?: number | null;
+  /** Blender repeats it past its range (Cycles modifiers on its curves, or `use_cyclic`). */
+  readonly cyclic?: boolean;
   readonly duration?: number;
   readonly sampled?: number;
   /** Bones the action names that the armature does not have. */
   readonly unplayedBones?: readonly string[];
+  /** What the action keys besides bone channels (the object's own transform, a property),
+   *  which plays only in Blender. */
+  readonly unsupported?: readonly string[];
   readonly reason?: string;
 }

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