@volter/blender-engine 0.1.131 → 0.1.133

package/browser/blender-engine.mts

@@ -129,6 +129,7 @@ export interface BlenderEngineOptions {
  * answered as a whole frame is.
  */
 export interface SessionAsk {
+  evaluation?: 'render';
   checkpoint?: string;
   frame?: unknown;
   hold?: unknown;

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 }
@@ -179,6 +182,9 @@ export interface FileListSnapshot {
 }
 
 export interface CaptureRequest {
+  /** Geometry was exported from the render engine's RENDER depsgraph. It belongs
+   * to this capture alone and must never replace the live viewport frame. */
+  evaluation?: 'render';
   /** A viewport screenshot's bound, the longer side of a square frame.
    *  Absent on a render, which states its exact pixel dimensions instead. */
   size?: number;

package/browser/runtime.ts

@@ -33,7 +33,7 @@ type Request = DistributiveOmit<WorkerRequest, 'id'>;
 
 export interface BlenderRuntimeOptions {
   /** Stage one verified mesh/image without replacing the displayed frame. */
-  stage?(part: { session: string; revision: number; abort?: boolean; mesh?: string; image?: string; piece?: unknown }): Promise<void> | void;
+  stage?(part: { session: string; revision: number; evaluation?: 'render'; abort?: boolean; mesh?: string; image?: string; piece?: unknown }): Promise<void> | void;
   /** Operation-only diagnostics, never request payloads. The optional observer
    * must not affect work, even if it throws. End calls balance overlapping work. */
   work?(label: string): () => void;
@@ -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. */
@@ -645,7 +652,7 @@ export class BlenderRuntime {
   }
 
   readonly #frameStream = new FrameStreamReader();
-  #stagedIdentity: { session: string; revision: number } | null = null;
+  #stagedIdentity: { session: string; revision: number; evaluation?: 'render' } | null = null;
   #discardStagedFrame(): void {
     this.#frameStream.reset();
     const part = this.#stagedIdentity; this.#stagedIdentity = null;
@@ -661,13 +668,13 @@ export class BlenderRuntime {
         try {
           const decoded = await this.#frameStream.accept(reply.chunk);
           if (decoded) {
-            const value = decoded.value as ({ op: 'stage'; session: string; revision: number } | Omit<Extract<WorkerReply, { op: 'present' }>, 'id'>);
+            const value = decoded.value as ({ op: 'stage'; session: string; revision: number; evaluation?: 'render' } | Omit<Extract<WorkerReply, { op: 'present' }>, 'id'>);
             if (value.op === 'present') {
               await this.#receive({ ...value, id: reply.id } as WorkerReply);
               return;
             }
             if (value.op !== 'stage' || !this.#options.stage) throw new Error('The presenter does not support staged Blender frames');
-            this.#stagedIdentity = { session: value.session, revision: value.revision };
+            this.#stagedIdentity = { session: value.session, revision: value.revision, ...(value.evaluation ? { evaluation: value.evaluation } : {}) };
             await this.#options.stage(value);
           }
           this.#worker.postMessage({ op: 'present-result', id: reply.id } satisfies WorkerRequest);
@@ -708,7 +715,7 @@ export class BlenderRuntime {
       // true the moment the frame arrives. A presenter that refuses the frame
       // has not un-modelled it.
       const frame = reply.frame as { session?: unknown; revision?: unknown } | null;
-      if (typeof frame?.session === 'string' && typeof frame.revision === 'number')
+      if (reply.capture?.evaluation !== 'render' && typeof frame?.session === 'string' && typeof frame.revision === 'number')
         this.#presented = { session: frame.session, revision: frame.revision };
       const end = this.#work('presenting worker frame');
       try {

package/browser/session.py

@@ -1085,7 +1085,10 @@ def material_graph(material):
     if surface is None or surface.bl_idname not in _GRAPH_SURFACES:
         return None
     sockets = [surface.inputs[name] for name in _GRAPH_SURFACES[surface.bl_idname]]
-    if not any(_links_into(s) for s in sockets):
+    # Emission reflects no light even when its inputs are constants. The
+    # reduced MeshPhysicalMaterial otherwise adds diffuse/specular response
+    # to it (including a black Emission used as an unlit control).
+    if surface.bl_idname != "ShaderNodeEmission" and not any(_links_into(s) for s in sockets):
         return None
     # The door is quiet about a material whose graph ships, so a linked input
     # the graph does not carry is named here.
@@ -1480,7 +1483,7 @@ class Session:
 
     # -- the export
 
-    def _export(self):
+    def _export(self, depsgraph=None):
         """THE EXPORT IS THE C++ DOOR (`bpy_web_export.cc`).
 
         One call evaluates the scene, walks the depsgraph's own update record
@@ -1497,14 +1500,14 @@ class Session:
         bones and the active vertex group's weights (`_armatures`,
         `_weights`). All per-scene, none of them geometry.
         """
-        scene = bpy.context.scene
+        scene = depsgraph.scene if depsgraph is not None else bpy.context.scene
         graphs = material_graphs(scene)
         _mark("export:graphs")
         # An IMAGE EMPTY's picture travels with the graphs' images: the overlay draws it
         # (`overlay_empty.hh` `image_sync`).
         empty_images = {obj.data.name for obj in scene.objects
                         if obj.type == "EMPTY" and obj.empty_display_type == "IMAGE" and obj.data is not None}
-        options = {"session": self.session, "evaluate": True, "known": self._known, "instance_sources": True,
+        options = {"session": self.session, "evaluate": depsgraph is None, "known": self._known, "instance_sources": True,
                    "graph_materials": sorted(graphs),
                    "graph_images": sorted({i for g in graphs.values() for i in g["images"]} | empty_images),
                    "graph_generated": sorted(n for n, g in graphs.items() if g["generated"])}
@@ -1563,7 +1566,7 @@ class Session:
         # A MANUAL TEXTURE SPACE, which Generated coordinates map through; the
         # automatic one is the evaluated bounds the presenter already holds.
         if graphs:
-            depsgraph = bpy.context.evaluated_depsgraph_get()
+            depsgraph = depsgraph if depsgraph is not None else bpy.context.evaluated_depsgraph_get()
             # BY NAME THROUGH ONE MAP: `scene.objects.get` searches the collection linearly, so a
             # lookup per row was quadratic -- measured on the Stoneguard file (11,702 rows): 11,343
             # calls, 14.4 s of every present.
@@ -1598,7 +1601,8 @@ class Session:
                     "roughness": float(material.roughness),
                     "metallic": float(material.metallic),
                 }
-        frame["instances"] = _depsgraph_placements(frame, bpy.context.evaluated_depsgraph_get())
+        graph = depsgraph if depsgraph is not None else bpy.context.evaluated_depsgraph_get()
+        frame["instances"] = _depsgraph_placements(frame, graph)
         frame["world"] = draw_world(scene)
         frame["cameras"] = {
             obj.name: draw_camera(obj) for obj in scene.objects if obj.type == "CAMERA"
@@ -1610,7 +1614,7 @@ class Session:
         render = scene.render
         frame["camera_view"] = {
             "scene_camera": scene.camera.name if scene.camera is not None else None,
-            "view_layer_cameras": [o.name for o in bpy.context.view_layer.objects if o.type == "CAMERA"],
+            "view_layer_cameras": [o.name for o in graph.view_layer.objects if o.type == "CAMERA"],
             "aspect": (render.resolution_x * render.pixel_aspect_x) / max(render.resolution_y * render.pixel_aspect_y, 1e-6),
         }
         # THE 3D CURSOR, `Scene.cursor`: where Blender's own "to 3D Cursor"
@@ -1620,7 +1624,7 @@ class Session:
         frame["cursor"] = [[float(v) for v in row] for row in scene.cursor.matrix]
         # THE OVERLAYS, after the door's frame stands: `_weights` reads the
         # mesh's own revision out of it (see there), so it cannot run before.
-        view_layer = bpy.context.view_layer
+        view_layer = graph.view_layer
         # THE VIEWPORT'S SUBJECT LINE and the units its grid step is named in: Blender composes
         # both from the scene, so they come from here (`_subject_line`).
         frame["subject"] = _subject_line(scene, view_layer)
@@ -1665,12 +1669,12 @@ class Session:
             self._known.clear()
             return self._present(capture)
 
-    def _present(self, capture=None):
+    def _present(self, capture=None, depsgraph=None):
         known = dict(self._known)
         _mark("present:before")
-        frame = self._export()
+        frame = self._export(depsgraph)
         _mark("present:exported")
-        pulled = self._pull(frame)
+        pulled = self._pull(frame, render=depsgraph is not None)
         _mark("present:pulled")
         self._drop_unreachable_textures(frame)
         # WHAT THIS FRAME SHIPPED, for the session's own accounting: the ids
@@ -1729,7 +1733,7 @@ class Session:
         self._reconcile_with_presenter(answer, frame)
         return answer
 
-    def _pull(self, frame):
+    def _pull(self, frame, render=False):
         """THE PULL, one datablock at a time, as Hydra's render delegate pulls each prim's data
         during Sync after the scene index's notice (`HydraSceneIndex::populate`). The door named
         the changed meshes and pictures as deferred; the worker first copies the frame's own
@@ -1743,9 +1747,9 @@ class Session:
         anything was pulled; the worker then presents the frame with its pieces."""
         meshes = [key for key, mesh in frame["meshes"].items() if mesh.get("deferred")]
         images = [name for name, image in frame["images"].items() if image.get("deferred")]
-        if not meshes and not images:
+        if not meshes and not images and not render:
             return False
-        _asked({"hold": frame})
+        _asked({"hold": frame, **({"evaluation": "render"} if render else {})})
         options = {"buffer_path": EXPORT_BUFFER_PATH} if EXPORT_BUFFER_PATH else {}
         for kind, keys, door in (("mesh", meshes, _blender_web.export_mesh),
                                  ("image", images, _blender_web.export_image)):
@@ -1765,6 +1769,20 @@ class Session:
                 _asked({kind: key, "piece": piece[kind]})
         return True
 
+    def photograph(self, depsgraph, capture):
+        """Render evaluation owns different geometry and visibility than a viewport.
+        Keep its native revisions, deferred pulls and presenter separate for the
+        entire blocking capture, and restore the authoring export in finally."""
+        if not hasattr(_blender_web, "begin_render_export"):
+            raise RuntimeError("This Blender artifact has no render-evaluated export; update the artifact and its corresponding source")
+        _blender_web.begin_render_export(depsgraph)
+        try:
+            rendering = Session()
+            rendering.session = "%s:render:%d" % (self.session, time.time_ns())
+            return rendering._present({**capture, "evaluation": "render"}, depsgraph)
+        finally:
+            _blender_web.end_render_export()
+
     def _send_encoded_image(self, key, deferred):
         """A PICTURE AS ITS FILE'S OWN BYTES, when that is exactly what the frame would carry.
 
@@ -2336,8 +2354,8 @@ def _photograph(depsgraph, width, height, linear=False):
     # result is what a render leaves, and it holds scene-linear pixels.
     if linear:
         render["linear"] = True
-    answer = SESSION.present(
-        {"position": position, "target": target, "up": up, "render": render}
+    answer = SESSION.photograph(
+        depsgraph, {"position": position, "target": target, "up": up, "render": render}
     )
     if not isinstance(answer, dict) or "base64" not in answer:
         raise RuntimeError("The renderer did not answer with a photograph")
@@ -4823,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.
 
@@ -4892,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,
@@ -5433,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-graph-material.ts

@@ -14,6 +14,7 @@
  * built from the mesh's texture space (`orcoAttribute`).
  */
 import * as THREE from 'three';
+import {ISLAND_RANDOM_ATTRIBUTE} from './blender-island-random';
 import {presenterChanged} from './blender-presenter-change';
 import {attributeVarying, type CompiledGraph, rampTexture, uvVarying} from './blender-node-graph';
 import {graphAttributeName} from './blender-runtime-geometry';
@@ -458,7 +459,7 @@ varying vec3 vBlenderObjectNormal;
 varying vec3 vBlenderWorldPosition;
 varying vec3 vBlenderWorldNormal;
 varying vec3 vBlenderOrco;
-${compiled.attributes.map(n => `varying vec4 ${attributeVarying(n)};`).join('\n')}
+${compiled.attributes.map(n => `${n===ISLAND_RANDOM_ATTRIBUTE?'flat ':''}varying vec4 ${attributeVarying(n)};`).join('\n')}
 ${compiled.uvs.map(n => `varying vec2 ${uvVarying(n)};`).join('\n')}`;
   const attributes = compiled.attributes.map(n => `attribute vec4 ${graphAttributeName(n)};`).join('\n');
   shader.vertexShader = `attribute vec3 blenderOrco;\n${attributes}\n${varyings}\n${shader.vertexShader}`.replace(

package/browser/three/blender-island-random.ts

@@ -0,0 +1,41 @@
+/* SPDX-FileCopyrightText: 2011-2022 Blender Foundation
+ * SPDX-License-Identifier: Apache-2.0 */
+/** Cycles' attr_create_random_per_island, util/disjoint_set.h and
+ * util/hash.h (Blender Foundation, Apache-2.0). Connectivity uses the
+ * evaluated mesh's STORED edge order and union-by-rank representative,
+ * including loose edges. It is independent of draw/UV/normal splitting. */
+export const ISLAND_RANDOM_ATTRIBUTE='.cycles.random_per_island';
+
+function hashUint(value:number):number {
+  let a=(0xdeadbeef+17+value)>>>0,b=(0xdeadbeef+17)>>>0,c=b;
+  const rotate=(x:number,n:number)=>(x<<n)|(x>>>(32-n));
+  c=((c^b)-rotate(b,14))>>>0;a=((a^c)-rotate(c,11))>>>0;
+  b=((b^a)-rotate(a,25))>>>0;c=((c^b)-rotate(b,16))>>>0;
+  a=((a^c)-rotate(c,4))>>>0;b=((b^a)-rotate(a,14))>>>0;
+  c=((c^b)-rotate(b,24))>>>0;
+  // Native converts uint to float BEFORE the float reciprocal/multiply.
+  return Math.fround(Math.fround(c)*Math.fround(1/Math.fround(0xffffffff)));
+}
+
+export function cyclesIslandRandom(vertexCount:number,edges:Iterable<readonly [number,number]>):Float32Array {
+  const parents=Uint32Array.from({length:vertexCount},(_,i)=>i),ranks=new Uint8Array(vertexCount);
+  const find=(x:number):number=>{
+    let root=x;while(parents[root]!==root)root=parents[root]!;
+    while(parents[x]!==root){const parent=parents[x]!;parents[x]=root;x=parent;}
+    return root;
+  };
+  for(const [x,y] of edges) {
+    if(x<0 || y<0 || x>=vertexCount || y>=vertexCount || !Number.isInteger(x) || !Number.isInteger(y))
+      throw new Error('Island connectivity references a missing Blender vertex');
+    let a=find(x),b=find(y);if(a===b)continue;
+    if(ranks[a]!<ranks[b]!)[a,b]=[b,a];
+    parents[b]=a;if(ranks[a]===ranks[b])ranks[a]=ranks[a]!+1;
+  }
+  const result=new Float32Array(vertexCount);
+  for(let i=0;i<vertexCount;i++)result[i]=hashUint(find(i));
+  return result;
+}
+
+export function* storedMeshEdges(edges:Uint32Array):Iterable<readonly [number,number]> {
+  for(let i=0;i<edges.length;i+=2)yield [edges[i]!,edges[i+1]!];
+}

package/browser/three/blender-node-graph.ts

@@ -25,6 +25,7 @@ import * as THREE from 'three';
 import {z} from 'zod';
 import {BLENDER_NODE_GLSL, BLENDER_NODE_GLSL_PRELUDE} from './blender-node-glsl.generated';
 import {graphAttributeName} from './blender-runtime-geometry';
+import {ISLAND_RANDOM_ATTRIBUTE} from './blender-island-random';
 
 const scalar = z.number().finite();
 const gpuType = z.enum(['float', 'vec2', 'vec3', 'vec4']);
@@ -436,6 +437,13 @@ class Compiler {
     if (!node) throw new Error(`The graph links to ${key}, which it does not carry`);
     if (node.type === 'ShaderNodeParticleInfo' && node.outputs[index]?.id !== 'Random')
       throw new Error(`Particle Info output ${node.outputs[index]?.id ?? index} is not compiled by the presenter`);
+    // EEVEE's node_geometry returns zero here; reference rendering uses
+    // Cycles' evaluated per-island attribute instead. Keep it face constant.
+    if(node.type==='ShaderNodeNewGeometry' && node.outputs[index]?.id==='Random Per Island') {
+      this.s.attributes.add(ISLAND_RANDOM_ATTRIBUTE);
+      this.s.structure.push(['cycles-island',key,index]);
+      return convert(`${attributeVarying(ISLAND_RANDOM_ATTRIBUTE)}.x`,'float',to);
+    }
     const outputs = this.node(key, node);
     const output = outputs[index];
     if (!output) throw new Error(`${key} has no output ${index}`);

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

@@ -19,6 +19,7 @@ import * as THREE from 'three';
 import { customCornerNormals, type Normal } from './blender-corner-normals';
 import { ATTRIBUTE_LAYOUT, type MeshColumns } from './blender-frame-columns';
 import { triangulatePolygon } from './blender-triangulate';
+import {cyclesIslandRandom,ISLAND_RANDOM_ATTRIBUTE,storedMeshEdges} from './blender-island-random';
 
 type MeshData = {
   v: [number, number, number][];
@@ -43,7 +44,8 @@ export interface DrawArrays {
   uvLayers?: {name: string; data: Float32Array}[] | undefined;
   /** The mesh's generic attribute layers a material's Attribute or Color
    *  Attribute node can read, four floats per drawn vertex as EEVEE loads them
-   *  (`graphAttributeLayers`). */
+   *  (`graphAttributeLayers`). The derived Cycles island layer stores one
+   *  scalar per drawn vertex rather than an authored float4. */
   attributeLayers?: {name: string; data: Float32Array}[] | undefined;
   /** Per drawn vertex, a deformed mesh's Generated coordinates (0..1), or
    *  null when the positions are undeformed and orco derives from them. */
@@ -275,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));
@@ -294,7 +296,11 @@ export function geometryFromDrawArrays(
   }
   geometry.userData['blenderUvChannels'] = channels;
   for (const layer of arrays.attributeLayers ?? [])
-    geometry.setAttribute(graphAttributeName(layer.name), new THREE.BufferAttribute(layer.data, 4));
+    // Engine-derived island values use one float, while ordinary Blender
+    // material attributes retain EEVEE's float4 storage. Snapshots preserve
+    // the same name/stride, without inventing an authored mesh attribute.
+    geometry.setAttribute(graphAttributeName(layer.name), new THREE.BufferAttribute(layer.data,
+      layer.name===ISLAND_RANDOM_ATTRIBUTE?1:4));
   geometry.userData['blenderAttributes'] = (arrays.attributeLayers ?? []).map(layer => layer.name);
   if (arrays.orco) {
     geometry.setAttribute('blenderOrco', new THREE.BufferAttribute(arrays.orco, 3));
@@ -419,7 +425,7 @@ function drawNativeColumns(c: MeshColumns, hash: string): DrawArrays {
 
 /** The worker's door: the mesh store's columns, drawn into buffers. */
 export function drawArraysFromColumns(c: MeshColumns, hash: string): DrawArrays {
-  if (c.cornerTri && c.cornerNormal) return drawNativeColumns(c, hash);
+  if (c.cornerTri && c.cornerNormal) return withIslandRandom(drawNativeColumns(c, hash),c.co.length/3,storedMeshEdges(c.edge));
   const nv = c.co.length / 3;
   const maps = c.attributes.filter((a) => a.type === 'FLOAT2' && a.domain === 'CORNER');
   const mapName = c.renderUv ?? c.activeUv ?? maps[0]?.name;
@@ -482,7 +488,15 @@ export function drawArraysFromColumns(c: MeshColumns, hash: string): DrawArrays
     attributeLayers: graphAttributeLayers(c.attributes, data => data as ArrayLike<number>),
   };
   if (map && ATTRIBUTE_LAYOUT.FLOAT2.size !== 2) throw new Error('FLOAT2 layout');
-  return { ...drawCore(view), hash };
+  return {...withIslandRandom(drawCore(view),nv,edges),hash};
+}
+
+function withIslandRandom<T extends Omit<DrawArrays,'hash'>>(arrays:T,vertexCount:number,
+  edges:Iterable<readonly [number,number]>):T {
+  const native=cyclesIslandRandom(vertexCount,edges);
+  const data=Float32Array.from(arrays.sourceVertex,vertex=>native[vertex]!);
+  arrays.attributeLayers=[...(arrays.attributeLayers??[]),{name:ISLAND_RANDOM_ATTRIBUTE,data}];
+  return arrays;
 }
 
 /** The boundary JSON door. */
@@ -546,5 +560,8 @@ export function drawRuntimeGeometry(data: MeshData): THREE.BufferGeometry {
     attributeLayers: graphAttributeLayers(data.attributes ?? [],
       values => (Array.from(values) as (number | number[])[]).flat()),
   };
-  return geometryFromDrawArrays(drawCore(view));
+  // Native frames always supply stored edges. Legacy JSON without that
+  // order retains its old unsupported zero input rather than guessing IDs.
+  const arrays=drawCore(view);
+  return geometryFromDrawArrays(view.edges?withIslandRandom(arrays,vertices.length,view.edges):arrays);
 }

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,
@@ -2421,6 +2429,40 @@ export class BlenderRuntimeView {
     };
   }
 
+  /** Build a render-evaluated frame without ever publishing it to a viewport. */
+  static forPhotograph(): BlenderRuntimeView {
+    const view = new BlenderRuntimeView();
+    view.photograph = true;
+    return view;
+  }
+
+  /** Transfer this render-only view to its capture owner. Its resources are
+   * already independent, so a second geometry/texture copy is unnecessary. */
+  takeCaptureSnapshot(): ReturnType<BlenderRuntimeView['captureSnapshot']> {
+    if (!this.photograph || !this.frame) throw new Error('A render-evaluated frame is required');
+    const source = this.frame;
+    const effect = this.createWorldVolumePass();
+    let disposed = false;
+    return {
+      effect, root: this.root, session: source.session, revision: source.revision,
+      prepare: camera => {
+        if (disposed) throw new Error('Blender capture snapshot is disposed');
+        return this.setRendered(true, camera);
+      },
+      prepareDraw: (renderer, camera) => {
+        if (disposed) throw new Error('Blender capture snapshot is disposed');
+        return this.prepareDraw(camera, { interactive: false, height: renderer.domElement.height, renderer });
+      },
+      dispose: () => {
+        if (disposed) return;
+        disposed = true;
+        effect?.dispose();
+        this.dispose();
+        this.root.removeFromParent();
+      },
+    };
+  }
+
   createWorldVolumePass(): WorldVolumePass | undefined {
     const medium = worldMedium(this.frame?.world);
     return medium ? new WorldVolumePass(medium) : undefined;

package/browser/three/presenter.ts

@@ -90,6 +90,22 @@ export function createPresenter(options: PresenterOptions = {}): Presenter {
     frame: unknown,
     description: unknown,
     capture?: CaptureRequest,
+  ): Promise<PresentAnswer> {
+    if (capture?.evaluation === 'render') {
+      const detached = BlenderRuntimeView.forPhotograph();
+      const captureScene = new THREE.Scene();
+      view.root.updateWorldMatrix(true, false);
+      detached.root.matrix.copy(view.root.matrixWorld);
+      captureScene.add(detached.root);
+      try { return await presentFrame(detached, captureScene, frame, description, capture); }
+      finally { detached.dispose(); detached.root.removeFromParent(); }
+    }
+    return presentFrame(view, scene, frame, description, capture);
+  }
+
+  async function presentFrame(
+    view: BlenderRuntimeView, scene: THREE.Scene, frame: unknown, description: unknown,
+    capture?: CaptureRequest,
   ): Promise<PresentAnswer> {
     const applied = view.applyFrame(frame) as { held?: unknown } | null | undefined;
     const held =
@@ -169,6 +185,7 @@ export function createPresenter(options: PresenterOptions = {}): Presenter {
           renderer.setClearColor(0, 0);
         }
         try {
+          view.prepareDraw(camera, { interactive: false, height, renderer });
           renderer.render(scene, camera);
         } finally {
           scene.background = background;

package/browser/volter_three.py

@@ -212,7 +212,7 @@ def _world(scene):
     }
 
 
-def _export():
+def _export(depsgraph):
     """The C++ door's frame, with what the door does not describe merged in.
 
     `known` is ALWAYS EMPTY: this process keeps no record of what a presenter
@@ -221,7 +221,7 @@ def _export():
     """
     options = {
         "session": SESSION,
-        "evaluate": True,
+        "evaluate": False,
         "known": {},
         "buffer_path": EXPORT_BUFFER_PATH,
     }
@@ -236,7 +236,7 @@ def _export():
     _REVISION[0] += 1
     frame["session"] = SESSION
     frame["revision"] = _REVISION[0]
-    scene = bpy.context.scene
+    scene = depsgraph.scene
     frame["world"] = _world(scene)
     frame["volumes"] = {}
     # THE INSPECTION OVERLAYS ARE THE EDITOR'S, and a render hides them anyway.
@@ -249,8 +249,14 @@ def _export():
     return frame
 
 
-def _present(capture):
-    answer = ask({"frame": _export(), "capture": capture})
+def _present(depsgraph, capture):
+    if not hasattr(_blender_web, "begin_render_export"):
+        raise RuntimeError("This Blender artifact has no render-evaluated export")
+    _blender_web.begin_render_export(depsgraph)
+    try:
+        answer = ask({"frame": _export(depsgraph), "capture": {**capture, "evaluation": "render"}})
+    finally:
+        _blender_web.end_render_export()
     if isinstance(answer, dict) and answer.get("error"):
         raise RuntimeError(answer["error"])
     return answer
@@ -334,7 +340,7 @@ def _photograph(depsgraph, width, height, linear=False):
     if linear:
         render["linear"] = True
     answer = _present(
-        {"position": position, "target": target, "up": up, "render": render}
+        depsgraph, {"position": position, "target": target, "up": up, "render": render}
     )
     if not isinstance(answer, dict) or "base64" not in answer:
         raise RuntimeError("The renderer did not answer with a photograph")

package/browser/worker.ts

@@ -116,6 +116,7 @@ interface Copied {
   description: unknown;
 }
 interface PendingFrame {
+  evaluation?: 'render';
   session: string;
   revision: number;
   columns: Map<number, Copied>;
@@ -270,7 +271,7 @@ async function startBlender(project: string, document?: string): Promise<unknown
   const started = await startBlenderEngine({
     project,
     log,
-    ask: async ({ frame, hold, mesh, image, piece, present, capture, saveDue, checkpoint }) => {
+    ask: async ({ frame, hold, mesh, image, piece, present, capture, saveDue, checkpoint, evaluation }) => {
       if (typeof checkpoint === 'string') { await loadCheckpoint?.(checkpoint); return {}; }
       if (!holder.engine) throw new Error('The Blender session presented before it started');
       // Save once after the whole command, never during a partial frame.
@@ -286,8 +287,8 @@ async function startBlender(project: string, document?: string): Promise<unknown
       // gets the whole frame at `present`.
       if (hold !== undefined) {
         const identity = hold as { session: string; revision: number };
-        pending = { session: identity.session, revision: identity.revision, columns: await copyColumns(arena, hold), meshes: new Map(), images: new Map() };
-        await streamToTab({ op: 'stage', session: identity.session, revision: identity.revision });
+        pending = { ...(evaluation ? { evaluation } : {}), session: identity.session, revision: identity.revision, columns: await copyColumns(arena, hold), meshes: new Map(), images: new Map() };
+        await streamToTab({ op: 'stage', evaluation, session: identity.session, revision: identity.revision });
         return {};
       }
       if (mesh !== undefined || image !== undefined) {
@@ -312,7 +313,7 @@ async function startBlender(project: string, document?: string): Promise<unknown
             description: await describeFrame(arena, piece),
           };
         }
-        await streamToTab({ op: 'stage', session: pending.session, revision: pending.revision,
+        await streamToTab({ op: 'stage', evaluation: pending.evaluation, session: pending.session, revision: pending.revision,
           ...(mesh !== undefined ? { mesh } : { image }), piece: copied.typed });
         // Keep only the manifest and digest; the presenter already built this
         // resource, and the next pull may overwrite the engine arena.
@@ -805,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.131",
+  "version": "0.1.133",
   "publishConfig": {
     "access": "public"
   },

package/wasm/BUNDLE.json

@@ -1,9 +1,9 @@
 {
   "blender": "5.2.0 LTS",
-  "source": "434072350c0577eb155068d5a1b62bb45daf19f9",
+  "source": "5a3cb1250fc1fd7df59e3ff823949c06e52d9422",
   "upstream": "fbe6228777e7d9afefcd61a413844e790ae75db7",
   "sourceRepository": "https://github.com/volter-ai/blender",
-  "sourceRecipe": "https://github.com/volter-ai/blender/blob/434072350c0577eb155068d5a1b62bb45daf19f9/build_files/emscripten/RELEASE.md",
+  "sourceRecipe": "https://github.com/volter-ai/blender/blob/5a3cb1250fc1fd7df59e3ff823949c06e52d9422/build_files/emscripten/RELEASE.md",
   "factoryEngine": "BLENDER_EEVEE",
   "files": {
     "blender_browser.js": "raw",
@@ -16,8 +16,8 @@
       "sha256": "d818e8d746bc62ebf810206ac564d2dc75dc645b3121f4a3919d13ecef11e419"
     },
     "blender_browser.wasm": {
-      "bytes": 86344416,
-      "sha256": "f5b988d30a9f29708254bc84600f7b88d9c9eb41af904b84c9f398d5c41595e4"
+      "bytes": 86351436,
+      "sha256": "d4c3a8002cb1686f3c5299e28bcbb356934bbe910f2485b2572032b115cf67bd"
     },
     "blender_browser.data": {
       "bytes": 52699590,
@@ -30,8 +30,8 @@
       "sha256": "d818e8d746bc62ebf810206ac564d2dc75dc645b3121f4a3919d13ecef11e419"
     },
     "blender_browser.wasm.br": {
-      "bytes": 18611942,
-      "sha256": "b415a2fce0f2d2f796a2a3362b38420df063866898cc04c61d4604c5caf13e0d"
+      "bytes": 18605311,
+      "sha256": "97e3bc2c772e9fd6da5a3e28086c1ee1dfd62b35ebdeb127a413b4bd5904031f"
     },
     "blender_browser.data.br": {
       "bytes": 8056485,
@@ -42,9 +42,9 @@
       "sha256": "4085e9336266cf66f061d4d5c962a5929cc96d5732c746b5c13ea05cd104a75b"
     }
   },
-  "note": "Stoneguard c7/c14/c15 engine. Emscripten 6.0.5, Release -O3 objects and -O2 link. Portable native arm64 matrix reciprocal plus fused generic OpenSubdiv stencil and patch accumulation; bodice four-stage comparison 28/28 arrays exact. Full-scene comparison and memory scope recorded in provenance/stoneguard-memory.json. Historical battery absent; no full-battery or hosted acceptance claim. Rebuilt from the public instance-source commit with the same Emscripten 6.0.5, Release -O3 objects and -O2 link. All 6287 drawable Lone Monk placements resolve to 26 native source objects and 24 deferred mesh resources. Live raster rendering still differs from native Cycles; no full-scene visual parity claim. Rebuilt from the public evaluated-geometry identity commit with the same Emscripten 6.0.5 Release recipe. Distinct Array/Mirror/deformation outputs no longer borrow another object’s geometry. Native linked-input sharing and every deferred probe vertex are checked independently. Live raster illumination remains unoccluded environment lighting and differs substantially from native Cycles; no visual parity claim.",
+  "note": "Emscripten 6.0.5, Release -O3 objects and -O2 link, retained public build recipe and dependency licenses. Scoped render-evaluated export preserves render-only geometry and render-specific modifier results without replacing the viewport export state. Prior geometry identity and memory fixes remain. Full-scene Three versus Cycles rendering parity remains incomplete.",
   "callTrampoline": "CPython 3.13.13 is compiled with PY_CALL_TRAMPOLINE for Blender CPython slot arity casts. This applies to CPython dispatch, not arbitrary indirect calls.",
   "engineIds": "The session preserves the compiled native CYCLES engine. VOLTER_THREE selects the explicit raster presenter; BLENDER_EEVEE and BLENDER_WORKBENCH remain presentation engines.",
-  "exportDoor": "The source-owned bpy_web_export.cc exports Principled physical inputs, normal images, eight named UV layers and evaluated corner normals, and takes graph_materials/graph_images/graph_generated (a graph-drawn shader mix reduced to the one Principled BSDF it reaches, graph images at the door revisions with every UDIM tile, orco for deformed meshes whose graph reads Generated coordinates). A frame can defer its changed meshes and pictures (defer) for the caller to pull one at a time (export_mesh, export_image), each call freeing the previous one's columns and a picture it decoded; an undo step keeps the revisions when Blender kept the depsgraph (session_undo); Blender's CPU subdivision descriptor is released once a mesh is read; the memory door reports malloc in-use and free. Datablock revisions are keyed by session_uid. writefile.cc writes one copy of the document per save in the browser build. CPU evaluators adopt stencil tables without cloning; browser subdivision descriptors are released immediately after CPU tessellation/deformation. Native evaluated corner triangles accompany corner normals. Consumed local conversion stencils are released before later UV channels are constructed. Caller-thread file-read, evaluated-object and subdivision checkpoints provide backpressure for resumable startup. Shared geometry revisions advance once per frame. Existing synchronous export remains available. Optional instance_sources exports stable evaluated collection and particle source meshes, including excluded library meshes and converted curves. Frame-local instance_geometry tokens verify Python placement metadata against the exported geometry and are consumed before presentation. Geometry resource identity preserves implicit input storage only for unmodified geometry and separates evaluated modifier/deformation outputs. Object and mesh resource keys have independent namespaces.",
+  "exportDoor": "The source-owned bpy_web_export.cc exports Principled physical inputs, normal images, eight named UV layers and evaluated corner normals, and takes graph_materials/graph_images/graph_generated (a graph-drawn shader mix reduced to the one Principled BSDF it reaches, graph images at the door revisions with every UDIM tile, orco for deformed meshes whose graph reads Generated coordinates). A frame can defer its changed meshes and pictures (defer) for the caller to pull one at a time (export_mesh, export_image), each call freeing the previous one's columns and a picture it decoded; an undo step keeps the revisions when Blender kept the depsgraph (session_undo); Blender's CPU subdivision descriptor is released once a mesh is read; the memory door reports malloc in-use and free. Datablock revisions are keyed by session_uid. writefile.cc writes one copy of the document per save in the browser build. CPU evaluators adopt stencil tables without cloning; browser subdivision descriptors are released immediately after CPU tessellation/deformation. Native evaluated corner triangles accompany corner normals. Consumed local conversion stencils are released before later UV channels are constructed. Caller-thread file-read, evaluated-object and subdivision checkpoints provide backpressure for resumable startup. Shared geometry revisions advance once per frame. Existing synchronous export remains available. Optional instance_sources exports stable evaluated collection and particle source meshes, including excluded library meshes and converted curves. Frame-local instance_geometry tokens verify Python placement metadata against the exported geometry and are consumed before presentation. Geometry resource identity preserves implicit input storage only for unmodified geometry and separates evaluated modifier/deformation outputs. Object and mesh resource keys have independent namespaces. Scoped begin_render_export/end_render_export reads the render engine depsgraph and isolates viewport revision, undo, deferred resource and image watcher state. Geometry resource identity preserves implicit input storage only for unmodified geometry and separates evaluated modifier/deformation outputs. Object and mesh resource keys have independent namespaces.",
   "preloadedPayload": "releasePreloadedFileData releases the JS preload buffer after session ready. The measured working payload exclusions are retained."
 }