@volter/blender-engine 0.1.18 → 0.1.20

package/browser/session.py

@@ -1898,7 +1898,7 @@ def _vertical_extent(cam, width, height):
     return math.degrees(2.0 * math.atan(extent / (2.0 * float(cam.lens))))
 
 
-def _photograph(depsgraph, width, height):
+def _photograph(depsgraph, width, height, linear=False):
     """three.js IS the renderer: the render is a photograph of the scene the
     engine holds, taken through the scene's own camera at `scene.render`'s
     exact resolution. `bpy.ops.render.render` semantics are the contract."""
@@ -1946,13 +1946,17 @@ def _photograph(depsgraph, width, height):
     # refused BY NAME on the other side (`blender-runtime-host.ts`).
     if look not in ("None", "AgX - Base Contrast"):
         render["look"] = look
+    # The capture's scene-referred frame rides along when asked for: a render
+    # 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}
     )
     if not isinstance(answer, dict) or "base64" not in answer:
         raise RuntimeError("The renderer did not answer with a photograph")
     _assert_photographed_from(answer.get("camera"), position, target, up)
-    return base64.b64decode(answer["base64"]), render
+    return base64.b64decode(answer["base64"]), render, answer
 
 
 def _assert_photographed_from(reported, position, target, up):
@@ -2013,19 +2017,54 @@ class VolterRenderEngine(bpy.types.RenderEngine):
         width = max(1, int(scene.render.resolution_x * scale))
         height = max(1, int(scene.render.resolution_y * scale))
         try:
-            png, _render = _photograph(depsgraph, width, height)
+            png, _render, answer = _photograph(depsgraph, width, height, linear=True)
         except Exception as error:  # noqa: BLE001 - reported to Blender as a render error
             self.report({"ERROR"}, str(error))
             return
-        path = os.path.join(ROOT, "render-%d.png" % int(time.time() * 1000))
-        with open(path, "wb") as fh:
-            fh.write(png)
         result = self.begin_result(0, 0, width, height)
         try:
-            result.layers[0].load_from_file(path)
-        except (RuntimeError, AttributeError) as error:
+            _fill_result(self, result, answer, png, width, height)
+        except (RuntimeError, AttributeError, ValueError) as error:
             self.report({"ERROR"}, "Render result could not take the photograph: %s" % error)
         self.end_result(result)
+
+
+def _fill_result(engine, result, answer, png, width, height):
+    """THE RENDER RESULT HOLDS SCENE-LINEAR PIXELS, and Blender runs the scene's
+    view transform over them wherever it shows or saves one (`write_still`, the
+    Image Editor), as it does over Cycles'. The photograph's PNG is the display
+    image -- the transform already ran -- so loading it put every render
+    through AgX or Filmic twice. Measured 2026-09-28 by the model editor's
+    render view: a background 53 against the viewport's 59, a shadow's blue 2
+    against 7. The same capture's linear frame goes in instead: half floats,
+    RGBA, bottom row first, which is Blender's own row order. Linear 0.005,
+    0.05, 0.5 and 4.0 then save under AgX as 8, 58, 170 and 234 (the PNG
+    path saved 3, 53, 160 and 190), and under Standard as 15, 64, 188 and 255,
+    as the PNG path did.
+
+    A renderer that sends no linear frame gets the old path, and says so."""
+    linear = answer.get("linearBase64") if isinstance(answer, dict) else None
+    if linear and answer.get("linearWidth") == width and answer.get("linearHeight") == height:
+        import numpy
+
+        pixels = numpy.frombuffer(base64.b64decode(linear), dtype=numpy.float16)
+        if pixels.size != width * height * 4:
+            raise ValueError(
+                "the linear frame holds %d values for a %dx%d render" % (pixels.size, width, height)
+            )
+        result.layers[0].passes["Combined"].rect.foreach_set(pixels.astype(numpy.float32))
+        return
+    engine.report(
+        {"WARNING"},
+        "The renderer sent no scene-linear frame; the render result is its display image, "
+        "which the view transform will run over again",
+    )
+    path = os.path.join(ROOT, "render-%d.png" % int(time.time() * 1000))
+    with open(path, "wb") as fh:
+        fh.write(png)
+    try:
+        result.layers[0].load_from_file(path)
+    finally:
         try:
             os.unlink(path)
         except OSError:

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

@@ -744,6 +744,8 @@ export class BlenderRuntimeView {
    *  showing". Fired after the frame is applied, so a listener that reads
    *  the graph sees the new one. */
   private readonly frameListeners = new Set<() => void>();
+  /** The views drawing this one's frames in a second area ({@link follow}). */
+  private readonly followers = new Set<BlenderRuntimeView>();
 
   /** Subscribe to frames. Returns the unsubscribe. */
   subscribeFrames(listener: () => void): () => void {
@@ -1867,6 +1869,15 @@ export class BlenderRuntimeView {
     // The model moved: whoever is READING the engine (the Properties sections
     // through the RNA door) re-reads now, with the new graph already standing.
     for (const listener of [...this.frameListeners]) listener();
+    // EVERY FOLLOWER TAKES THE SAME FRAME, and one that cannot (it lacks geometry the frame only
+    // references) is rebuilt from everything this view now holds.
+    for (const follower of this.followers) {
+      try {
+        follower.applyFrame(input);
+      } catch {
+        follower.applyFrame(this.fullFrame());
+      }
+    }
     return { ...this.inspect(), held };
   }
 
@@ -1898,7 +1909,10 @@ export class BlenderRuntimeView {
    * disposable geometry cross this boundary; delta-only frames are sufficient.
    * The caller owns this snapshot and must dispose it on every outcome.
    */
-  captureSnapshot() {
+  /** 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 {
     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
@@ -1976,6 +1990,37 @@ export class BlenderRuntimeView {
         };
       }
     }
+    return frame;
+  }
+
+  /**
+   * A SECOND VIEW OF THE SAME MODEL, for a second area drawing it (Blender's split 3D viewport):
+   * its own graph, because a three.js object has one parent and each area's stage holds its own
+   * root, built from everything this view holds and then handed every frame this one applies, so
+   * the two show one revision. Each view keeps its own shading (Solid in one, Rendered in the
+   * other), its own camera view and its own overlays. Inspection overlays (bones, weights) and a
+   * Timeline pose stay this view's: they are not in a frame another view can be built from.
+   */
+  follow(): { readonly view: BlenderRuntimeView; dispose(): void } {
+    const follower = new BlenderRuntimeView();
+    if (this.frame) follower.applyFrame(this.fullFrame());
+    this.followers.add(follower);
+    let disposed = false;
+    return {
+      view: follower,
+      dispose: () => {
+        if (disposed) return;
+        disposed = true;
+        this.followers.delete(follower);
+        follower.dispose();
+        follower.root.removeFromParent();
+      },
+    };
+  }
+
+  captureSnapshot() {
+    const frame = this.fullFrame();
+    const source = this.frame!;
     const effect = this.createWorldVolumePass();
     const detached = new BlenderRuntimeView();
     detached.photograph = true;

package/browser/volter_three.py

@@ -280,7 +280,7 @@ def _vertical_extent(cam, width, height):
     return math.degrees(2.0 * math.atan(extent / (2.0 * float(cam.lens))))
 
 
-def _photograph(depsgraph, width, height):
+def _photograph(depsgraph, width, height, linear=False):
     """three.js IS the renderer: the render is a photograph of the scene the
     engine holds, taken through the scene's own camera at `scene.render`'s
     exact resolution. `bpy.ops.render.render` semantics are the contract."""
@@ -326,13 +326,17 @@ def _photograph(depsgraph, width, height):
     # view itself -- the same table as no look at all.
     if look not in ("None", "AgX - Base Contrast"):
         render["look"] = look
+    # The capture's scene-referred frame rides along when asked for: a render
+    # result is what a render leaves, and it holds scene-linear pixels.
+    if linear:
+        render["linear"] = True
     answer = _present(
         {"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")
     _assert_photographed_from(answer.get("camera"), position, target, up)
-    return base64.b64decode(answer["base64"]), render
+    return base64.b64decode(answer["base64"]), render, answer
 
 
 def _assert_photographed_from(reported, position, target, up):
@@ -391,19 +395,54 @@ class VolterRenderEngine(bpy.types.RenderEngine):
         width = max(1, int(scene.render.resolution_x * scale))
         height = max(1, int(scene.render.resolution_y * scale))
         try:
-            png, _render = _photograph(depsgraph, width, height)
+            png, _render, answer = _photograph(depsgraph, width, height, linear=True)
         except Exception as error:  # noqa: BLE001 - reported to Blender as a render error
             self.report({"ERROR"}, str(error))
             return
-        path = os.path.join(ROOT, "render-%d.png" % int(time.time() * 1000))
-        with open(path, "wb") as fh:
-            fh.write(png)
         result = self.begin_result(0, 0, width, height)
         try:
-            result.layers[0].load_from_file(path)
-        except (RuntimeError, AttributeError) as error:
+            _fill_result(self, result, answer, png, width, height)
+        except (RuntimeError, AttributeError, ValueError) as error:
             self.report({"ERROR"}, "Render result could not take the photograph: %s" % error)
         self.end_result(result)
+
+
+def _fill_result(engine, result, answer, png, width, height):
+    """THE RENDER RESULT HOLDS SCENE-LINEAR PIXELS, and Blender runs the scene's
+    view transform over them wherever it shows or saves one (`write_still`, the
+    Image Editor), as it does over Cycles'. The photograph's PNG is the display
+    image -- the transform already ran -- so loading it put every render
+    through AgX or Filmic twice. Measured 2026-09-28 by the model editor's
+    render view: a background 53 against the viewport's 59, a shadow's blue 2
+    against 7. The same capture's linear frame goes in instead: half floats,
+    RGBA, bottom row first, which is Blender's own row order. Linear 0.005,
+    0.05, 0.5 and 4.0 then save under AgX as 8, 58, 170 and 234 (the PNG
+    path saved 3, 53, 160 and 190), and under Standard as 15, 64, 188 and 255,
+    as the PNG path did.
+
+    A renderer that sends no linear frame gets the old path, and says so."""
+    linear = answer.get("linearBase64") if isinstance(answer, dict) else None
+    if linear and answer.get("linearWidth") == width and answer.get("linearHeight") == height:
+        import numpy
+
+        pixels = numpy.frombuffer(base64.b64decode(linear), dtype=numpy.float16)
+        if pixels.size != width * height * 4:
+            raise ValueError(
+                "the linear frame holds %d values for a %dx%d render" % (pixels.size, width, height)
+            )
+        result.layers[0].passes["Combined"].rect.foreach_set(pixels.astype(numpy.float32))
+        return
+    engine.report(
+        {"WARNING"},
+        "The renderer sent no scene-linear frame; the render result is its display image, "
+        "which the view transform will run over again",
+    )
+    path = os.path.join(ROOT, "render-%d.png" % int(time.time() * 1000))
+    with open(path, "wb") as fh:
+        fh.write(png)
+    try:
+        result.layers[0].load_from_file(path)
+    finally:
         try:
             os.unlink(path)
         except OSError:

package/package.json

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