@volter/editor-blender 0.1.18 → 0.1.20

package/contributions/blender-header-menus.tsx

@@ -8,20 +8,22 @@
  * draws four menu words in Object Mode, in this order: **View**
  * (`:1153`), **Select** (`:1166`, `VIEW3D_MT_select_object`), **Add**
  * (`:1169`, `VIEW3D_MT_add`) and **Object** (`:1210`, `VIEW3D_MT_object`).
- * Three of them are here.
+ * All four are here.
  *
- * VIEW IS NOT DRAWN, and that is a placement decision rather than an omission.
- * Its rows that this editor has are the CAMERA VIEW rows — Front / Right / Top
- * / Perspective 3/4, and the Perspective–Orthographic pair — and they are
- * already a menu in THIS SAME HEADER STRIP: the host draws
- * `Object3DDocumentToolbar` at the strip's trailing edge for every document
- * with a 3D session, which is exactly where Blender's viewport header carries
- * them too (`DocumentHeaderStrip`'s own note). A View menu here would be the
- * same control twice in one row, which is the defect the rule about a control
- * having ONE home exists to prevent. Every other row of Blender's View menu —
- * the sidebar and tool-shelf toggles, local view, the view-point and
- * view-axis submenus, Frame Selected, Viewport Render — is either a control
- * this unit does not act on or one that already has its own home in the strip.
+ * VIEW CARRIES ITS AREA ROWS AND NOTHING ELSE. Its camera-view rows — Front / Right / Top /
+ * Perspective 3/4, and the Perspective–Orthographic pair — are already a menu in THIS SAME HEADER
+ * STRIP: the host draws `Object3DDocumentToolbar` at the strip's trailing edge for every document
+ * with a 3D session, which is exactly where Blender's viewport header carries them too
+ * (`DocumentHeaderStrip`'s own note), so repeating them here would be the same control twice in
+ * one row. What View owns that no other control does is **Area** (`VIEW3D_MT_view`'s
+ * `layout.menu("INFO_MT_area")`, `space_view3d.py:1520`; `space_info.py`'s
+ * `INFO_MT_area`): the split that puts a second area beside
+ * this one. Blender's standard way to watch the render while modeling is exactly that — split the
+ * viewport and set the new area to Rendered shading through the camera — so Vertical Split opens
+ * the Render view beside the model (`blender-render-view.tsx`) and Close Area closes it. The other
+ * rows of `INFO_MT_area` (Horizontal Split, the new-window, maximize and fullscreen toggles) and
+ * the rest of View — the sidebar and tool-shelf toggles, local view, the view-point and view-axis
+ * submenus, Frame Selected, Viewport Render — are not drawn.
  *
  * WHAT IS DRAWN IS WHAT ACTS. A row Blender draws that this unit does not act
  * on is simply not here — never a row that opens a dialog we do not have, and
@@ -56,8 +58,9 @@ import {
   runBlenderObjectOperator,
 } from './blender-outliner-authoring';
 import { blenderOutlinerVersion, subscribeBlenderOutliner } from './blender-outliner-model';
+import { renderViewSplit, setRenderViewSplit, subscribeRenderViewSplit } from '../src/render-view-split';
 
-type MenuId = 'select' | 'add' | 'object';
+type MenuId = 'view' | 'select' | 'add' | 'object';
 
 /**
  * BLENDER'S OWN ROWS for the three transform submenus of `VIEW3D_MT_object`,
@@ -258,9 +261,15 @@ export function BlenderObjectModeHeader({
   useSyncExternalStore(subscribeBlenderOutliner, blenderOutlinerVersion, blenderOutlinerVersion);
   const [open, setOpen] = useState<MenuId | null>(null);
   const rootRef = useRef<HTMLDivElement>(null);
+  const viewRef = useRef<HTMLDivElement>(null);
   const selectRef = useRef<HTMLDivElement>(null);
   const addRef = useRef<HTMLDivElement>(null);
   const objectRef = useRef<HTMLDivElement>(null);
+  const split = useSyncExternalStore(
+    subscribeRenderViewSplit,
+    () => (documentId === undefined ? false : renderViewSplit(documentId)),
+    () => false,
+  );
   const handle = blenderOutlinerHandle(documentId);
   // NOTHING RATHER THAN A DEAD BAR: with no Outliner published for this
   // document there is no subject for any of these rows, and a menu of rows
@@ -341,6 +350,35 @@ export function BlenderObjectModeHeader({
       data-testid="blender-object-mode-menus"
       ref={rootRef}
     >
+      {/* VIEW ▸ AREA — `INFO_MT_area`'s split and close, for the Render view beside the model
+          (this file's header). */}
+      <MenuWord id="view" open={open} setOpen={setOpen} anchorRef={viewRef}>
+        <MenuSubmenu label="Area" data-testid="blender-view-area">
+          <MenuItem
+            data-testid="blender-area-vertical-split"
+            disabled={split || documentId === undefined}
+            title={split ? 'The Render view is already beside this area.' : undefined}
+            onSelect={() => {
+              setOpen(null);
+              if (documentId !== undefined) setRenderViewSplit(documentId, true);
+            }}
+          >
+            Vertical Split
+          </MenuItem>
+          <MenuSeparator />
+          <MenuItem
+            data-testid="blender-area-close"
+            disabled={!split}
+            title={split ? undefined : 'There is no second area to close.'}
+            onSelect={() => {
+              setOpen(null);
+              if (documentId !== undefined) setRenderViewSplit(documentId, false);
+            }}
+          >
+            Close Area
+          </MenuItem>
+        </MenuSubmenu>
+      </MenuWord>
       {/* SELECT — `VIEW3D_MT_select_object`, `space_view3d.py:1713-1715`. The
           three rows are `object.select_all` with action SELECT / DESELECT /
           INVERT, and they act on THE PANEL'S selection rather than running that

package/contributions/blender-render-view.tsx

@@ -0,0 +1,151 @@
+/**
+ * THE RENDER VIEW — the area a person splits beside the modeling viewport (View ▸ Area ▸ Vertical
+ * Split) to watch the render while they model: Blender's standard always-on render preview, a 3D
+ * viewport in Rendered shading looking through the scene camera.
+ *
+ * In Blender that area runs the scene's render engine live. Here three.js IS the render engine,
+ * so the area shows the render's own photograph (`renderSceneCamera`, which takes it where
+ * `bpy.ops.render.render` does), re-taken whenever the engine presents a new frame and whenever
+ * the area changes size. It is the render, not a viewport lit like one: what this area shows is
+ * what F12 would write, at this area's size.
+ *
+ * It re-renders on FRAMES, not on every presenter change: a snapshot's own texture decodes and
+ * program links announce themselves on the same global signal (`blender-presenter-change.ts`),
+ * so listening there would have each render request the next one forever, and the snapshot
+ * already waits for its own work before it is photographed.
+ */
+import { blenderModelView } from '@volter/blender-engine/browser/three/blender-runtime-view';
+import { useEffect, useRef, useState } from 'react';
+import { renderSceneCamera, type SceneCameraRender } from '../host/blender-runtime-host';
+
+const view = blenderModelView;
+
+/** Blender 5.2's default theme: the 3D View's `back`, and its overlay text. */
+const BACKGROUND = '#3d3d3d';
+const TEXT = '#ffffff';
+
+export function BlenderRenderView() {
+  const areaRef = useRef<HTMLDivElement>(null);
+  const [shown, setShown] = useState<SceneCameraRender | null>(null);
+  const [rendering, setRendering] = useState(false);
+
+  useEffect(() => {
+    const area = areaRef.current;
+    if (!area) return;
+    let disposed = false;
+    let dirty = false;
+    let running = false;
+    // ONE RENDER AT A TIME, and the latest request wins: a frame that lands mid-render marks the
+    // area dirty and is rendered next, so a drag shows its end state rather than a queue.
+    const run = async (): Promise<void> => {
+      if (running) return;
+      running = true;
+      setRendering(true);
+      try {
+        while (dirty && !disposed) {
+          dirty = false;
+          const scale = globalThis.devicePixelRatio || 1;
+          const region = {
+            width: Math.max(1, Math.round(area.clientWidth * scale)),
+            height: Math.max(1, Math.round(area.clientHeight * scale)),
+          };
+          let result: SceneCameraRender;
+          try {
+            result = await renderSceneCamera(view, region);
+          } catch (error) {
+            result = { kind: 'refused', reason: error instanceof Error ? error.message : String(error) };
+          }
+          if (!disposed) setShown(result);
+        }
+      } finally {
+        running = false;
+        if (!disposed) setRendering(false);
+      }
+    };
+    const invalidate = (): void => {
+      dirty = true;
+      void run();
+    };
+    const stopFrames = view.subscribeFrames(invalidate);
+    const resize = new ResizeObserver(invalidate);
+    resize.observe(area);
+    invalidate();
+    return () => {
+      disposed = true;
+      stopFrames();
+      resize.disconnect();
+    };
+  }, []);
+
+  return (
+    <div
+      ref={areaRef}
+      data-testid="blender-render-view"
+      aria-label="Render view"
+      style={{
+        position: 'relative',
+        flex: '1 1 0',
+        minWidth: 0,
+        // The split's wrapper bleeds 12 px past the slot as the stage does; the top 12 sit under
+        // the header strip, so this area starts where the stage's own corner text does.
+        marginTop: 12,
+        background: BACKGROUND,
+        overflow: 'hidden',
+      }}
+    >
+      {shown?.kind === 'image' && (
+        <img
+          src={shown.url}
+          alt="The scene camera's render"
+          data-testid="blender-render-view-image"
+          style={{
+            position: 'absolute',
+            inset: 0,
+            width: '100%',
+            height: '100%',
+            objectFit: 'contain',
+          }}
+        />
+      )}
+      {shown?.kind === 'refused' && (
+        <div
+          role="status"
+          data-testid="blender-render-view-refusal"
+          style={{
+            position: 'absolute',
+            inset: 0,
+            display: 'flex',
+            alignItems: 'center',
+            justifyContent: 'center',
+            padding: 16,
+            textAlign: 'center',
+            color: TEXT,
+            opacity: 0.8,
+            fontSize: 12,
+          }}
+        >
+          {shown.reason}
+        </div>
+      )}
+      {/* THE VIEW'S NAME, Blender's own for a camera view (`view3d_get_name`: Camera Perspective or
+          Camera Orthographic), and while a render is running, that it is. */}
+      <div
+        style={{
+          position: 'absolute',
+          top: 6,
+          left: 8,
+          color: TEXT,
+          fontSize: 11,
+          lineHeight: '14px',
+          textShadow: '0 0 2px #000, 0 0 2px #000',
+          pointerEvents: 'none',
+        }}
+      >
+        {shown?.kind === 'image' && (
+          <div>{shown.projection === 'orthographic' ? 'Camera Orthographic' : 'Camera Perspective'}</div>
+        )}
+        {rendering && <div data-testid="blender-render-view-rendering">Rendering…</div>}
+      </div>
+    </div>
+  );
+}

package/contributions/blender-runtime.document.tsx

@@ -48,6 +48,8 @@ import { bindModelDocument, blenderExecute, openModelDocumentBlend } from '../ho
 import { BlenderObjectModeHeader } from './blender-header-menus';
 import { createBlenderOutlinerAuthoring } from './blender-outliner-authoring';
 import { blenderSkin } from './blender-runtime-skin';
+import { BlenderRenderView } from './blender-render-view';
+import { renderViewSplit, subscribeRenderViewSplit } from '../src/render-view-split';
 import { onViewportStages, viewportStages } from '@volter/editor-threejs/viewport-door';
 
 export const point = 'workspace.document';
@@ -236,6 +238,12 @@ function BlenderModelViewport({
     [documentId],
   );
   const subject = useSyncExternalStore(subscribeSubject, subjectOfView);
+  // VIEW ▸ AREA ▸ VERTICAL SPLIT: the Render view beside the model (`blender-render-view.tsx`).
+  const split = useSyncExternalStore(
+    subscribeRenderViewSplit,
+    () => (documentId ? renderViewSplit(documentId) : false),
+    () => false,
+  );
   /**
    * THE INSPECTION OVERLAYS ARE HELPERS, and the Helpers menu owns them
    * (WORK.md §Blender in the tab is Blender, "Inspection parity", I4).
@@ -395,8 +403,15 @@ function BlenderModelViewport({
   if (!documentId) return null;
   const Surface = surfaces.Object3DAuthoring;
   return (
+    // SPLIT, THE TWO AREAS SHARE THE SLOT the stage alone fills otherwise: the stage's own root
+    // bleeds 12 px past its positioned parent (`inset: -12px`), so the modeling area is that
+    // parent inset by 12 and the Render view starts 2 px past the stage's bleed, Blender's gap
+    // between areas. Unsplit, both wrappers are `contents` and the stage is placed as before.
+    <div
+      style={split ? { position: 'absolute', inset: -12, display: 'flex', gap: 2 } : { display: 'contents' }}
+    >
     <div
-      style={{ display: 'contents' }}
+      style={split ? { position: 'relative', flex: '1 1 0', minWidth: 0, margin: 12 } : { display: 'contents' }}
       onPointerDownCapture={onPointerDownCapture}
       onPointerUpCapture={onPointerUpCapture}
       onPointerCancelCapture={dropCursorPress}
@@ -462,5 +477,7 @@ function BlenderModelViewport({
       }}
     />
     </div>
+    {split && <BlenderRenderView />}
+    </div>
   );
 }

package/host/blender-runtime-host.ts

@@ -33,6 +33,7 @@ import {
   type CaptureRequest,
   type PresentAnswer,
 } from '@volter/blender-engine/browser';
+import type { RenderRequest } from '@volter/blender-engine/browser/protocol';
 import type {
   BlenderActionClip,
   BlenderNodeTree,
@@ -189,6 +190,185 @@ async function displayPhotograph(
   return answer;
 }
 
+/**
+ * THE PHOTOGRAPH ITSELF: a prepared snapshot, through `renderCamera`, resolved by the scene's own
+ * view transform. `bpy.ops.render.render` and the Render view beside the viewport
+ * (`blender-render-view.tsx`) both take their pictures here, so the two cannot disagree.
+ * `assertCurrent` throws when the caller's snapshot went stale while the lighting was prepared.
+ */
+export async function photographSnapshot(
+  scene: THREE.Scene,
+  renderCamera: THREE.Camera,
+  snapshot: ReturnType<BlenderRuntimeView['captureSnapshot']>,
+  render: RenderRequest,
+  assertCurrent: () => void = () => {},
+): Promise<{ base64: string; mimeType: string }> {
+  // THE SCENE'S OWN VIEW TRANSFORM, for the duration of the photograph.
+  // Blender states one (`view_settings.view_transform`, AgX by default) and
+  // three.js has a curve of the same name, so the render is tone mapped the
+  // way the scene asks rather than the way the modeling viewport prefers —
+  // without this, every lit pixel differs by the gap between two unrelated
+  // curves and no difference in the image can be attributed to anything
+  // else. Python refuses a transform with no curve here, so the map is total.
+  const mappings: Record<string, THREE.ToneMapping> = {
+    none: THREE.NoToneMapping,
+    agx: THREE.AgXToneMapping,
+    neutral: THREE.NeutralToneMapping,
+    filmic: THREE.NoToneMapping,
+  };
+  await snapshot.prepare(renderCamera);
+  assertCurrent();
+  const captureOptions = {
+    effect: snapshot.effect,
+    width: render.width,
+    height: render.height,
+    transparent: render.transparent === true,
+    toneMapping: mappings[render.toneMapping] ?? THREE.AgXToneMapping,
+    exposure: render.exposure,
+  };
+  // BLENDER'S OWN VIEW TRANSFORM, off the linear frame. three's AgX is
+  // Filament's approximation and lands 23 to 48 levels of 255 away from
+  // Blender (42 at middle grey); the config's actual transform is a 57^3
+  // LUT over a log allocation, and a LOOK grades in a log space with two
+  // LUT inversions in it. Neither is reachable from resolved bytes, and
+  // both are reachable from the half-float target `captureImage` already
+  // allocates -- so an AgX render reads that and runs
+  // `blender-agx.ts`, which is verified byte-for-byte against OCIO.
+  // AND WHENEVER THE SCENE-REFERRED FRAME IS WANTED, whatever the
+  // transform: `captureImage` answers with resolved bytes and nothing
+  // else, so a Standard render asked for an EXR — or asked to be
+  // composited — has no linear frame in it at all. Reading the
+  // half-float target is the only path that has one.
+  const display =
+    render.toneMapping === 'agx' || render.toneMapping === 'filmic' || render.linear === true
+      ? await displayPhotograph(captureSceneLinear(scene, renderCamera, captureOptions), render)
+      : null;
+  assertCurrent();
+  if (display) return display;
+  const dataUrl = captureSceneImage(scene, renderCamera, captureOptions);
+  if (!dataUrl) throw new Error('Blender render could not capture its image');
+  return { base64: dataUrl.slice(dataUrl.indexOf(',') + 1), mimeType: 'image/png' };
+}
+
+/** What the Render view shows: the scene camera's picture, or the render's reason there is none. */
+export type SceneCameraRender =
+  | {
+      readonly kind: 'image';
+      readonly url: string;
+      readonly width: number;
+      readonly height: number;
+      readonly projection: 'perspective' | 'orthographic';
+    }
+  | { readonly kind: 'refused'; readonly reason: string };
+
+/** `session.py::_photograph`'s names for the view transforms the renderer has a curve for. */
+const VIEW_TRANSFORMS: Record<string, RenderRequest['toneMapping']> = {
+  Standard: 'none',
+  AgX: 'agx',
+  Filmic: 'filmic',
+  'Khronos PBR Neutral': 'neutral',
+};
+/** The Render view's longest side, in device pixels: a preview, not the output resolution. */
+const RENDER_VIEW_MAXIMUM_EDGE = 1600;
+
+/**
+ * THE RENDER, LIVE: Blender's Rendered shading seen through the scene camera, the view a person
+ * splits beside the modeling viewport to watch the render while they model. In Blender that area
+ * runs the scene's render engine in the viewport; here three.js is the render engine, so this
+ * takes the render's own photograph (`photographSnapshot`, the one `bpy.ops.render.render` takes)
+ * of the view's current revision, through the camera a camera view looks through, with the
+ * scene's own view transform, look, exposure and film transparency, `session.py::_photograph`'s
+ * reading of `scene.view_settings` transcribed. It is fitted to `region` (device pixels) at the
+ * render's own shape. Nothing it does is recorded: no Render Result, no history, no engine call
+ * but the RNA reads of the scene's colour management.
+ */
+export async function renderSceneCamera(
+  view: BlenderRuntimeView,
+  region: { readonly width: number; readonly height: number },
+): Promise<SceneCameraRender> {
+  const refused = (reason: string): SceneCameraRender => ({ kind: 'refused', reason });
+  const camera = view.cameraViewCamera();
+  // The sentence this editor's render gives for the same scene (`session.py::_photograph`).
+  const noCamera = 'The scene has no camera, so there is nothing to render';
+  if (camera === null) return refused(noCamera);
+  // The render's shape: on a square region the camera's frame spans the fitted side.
+  const probe = view.cameraView(camera, { width: 1000, height: 1000 }, 1, [0, 0]);
+  if (probe === null) return refused(noCamera);
+  const aspect = probe.frame.width / probe.frame.height;
+  const scale = Math.min(1, RENDER_VIEW_MAXIMUM_EDGE / Math.max(region.width, region.height));
+  const fitted = Math.min(region.width, region.height * aspect) * scale;
+  const width = Math.max(1, Math.round(fitted));
+  const height = Math.max(1, Math.round(fitted / aspect));
+  const through = view.cameraView(camera, { width, height }, 1, [0, 0]);
+  if (through === null) return refused(noCamera);
+
+  const context = await blenderRnaContext();
+  if (context === null) return refused('Blender is starting');
+  const [viewSettings, renderSettings] = await Promise.all([
+    blenderRna(`${context.scene}.view_settings`),
+    blenderRna(`${context.scene}.render`),
+  ]);
+  const read = (struct: BlenderRnaView | null, identifier: string): unknown =>
+    struct?.kind === 'struct'
+      ? struct.groups.flatMap((group) => group.rows).find((row) => row.identifier === identifier)?.value
+      : undefined;
+  const transform = String(read(viewSettings, 'view_transform'));
+  const toneMapping = VIEW_TRANSFORMS[transform];
+  if (toneMapping === undefined) return refused(`Blender view transform ${transform} has no curve in the renderer`);
+  const look = String(read(viewSettings, 'look') ?? 'None');
+  const exposure = Number(read(viewSettings, 'exposure') ?? 0);
+  const render: RenderRequest = {
+    width,
+    height,
+    fov: 0,
+    toneMapping,
+    exposure: 2 ** (Number.isFinite(exposure) ? exposure : 0),
+    orthographic: through.projection === 'orthographic',
+    transparent: read(renderSettings, 'film_transparent') === true,
+    ...(look === 'None' || look === 'AgX - Base Contrast' ? {} : { look }),
+  };
+
+  const snapshot = view.captureSnapshot();
+  try {
+    const scene = new THREE.Scene();
+    scene.add(snapshot.root);
+    scene.updateMatrixWorld(true);
+    // The render's clipping, fitted to this snapshot from the camera's eye as a render's is.
+    const eye = new THREE.Vector3(...through.position);
+    const bounds = contentWorldBounds(snapshot.root).getBoundingSphere(new THREE.Sphere());
+    const { near, far } = fitClipPlanes(eye.distanceTo(bounds.center), bounds.radius);
+    // THE CAMERA VIEW'S WINDOW, lens shift included (`blenderCameraView`), as the projection.
+    const { left, right, top, bottom } = through.window;
+    let renderCamera: THREE.Camera;
+    if (through.projection === 'orthographic') {
+      renderCamera = new THREE.OrthographicCamera(left, right, top, bottom, near, far);
+    } else {
+      const perspective = new THREE.PerspectiveCamera(
+        THREE.MathUtils.radToDeg(2 * Math.atan((top - bottom) / 2)),
+        (right - left) / (top - bottom),
+        near,
+        far,
+      );
+      perspective.projectionMatrix.makePerspective(left * near, right * near, top * near, bottom * near, near, far);
+      perspective.projectionMatrixInverse.copy(perspective.projectionMatrix).invert();
+      renderCamera = perspective;
+    }
+    renderCamera.position.copy(eye);
+    renderCamera.quaternion.set(...through.quaternion);
+    renderCamera.updateMatrixWorld(true);
+    const picture = await photographSnapshot(scene, renderCamera, snapshot, render);
+    return {
+      kind: 'image',
+      url: `data:${picture.mimeType};base64,${picture.base64}`,
+      width,
+      height,
+      projection: through.projection,
+    };
+  } finally {
+    snapshot.dispose();
+  }
+}
+
 export const BLENDER_RUNTIME_DOCUMENT_ID = 'document:blender:runtime';
 
 /**
@@ -959,58 +1139,8 @@ export function blenderRuntime(): BlenderRuntime {
             orthographic: render.orthographic,
           },
         });
-        // THE SCENE'S OWN VIEW TRANSFORM, for the duration of the photograph.
-        // Blender states one (`view_settings.view_transform`, AgX by default) and
-        // three.js has a curve of the same name, so the render is tone mapped the
-        // way the scene asks rather than the way the modeling viewport prefers —
-        // without this, every lit pixel differs by the gap between two unrelated
-        // curves and no difference in the image can be attributed to anything
-        // else. Python refuses a transform with no curve here, so the map is total.
-        const mappings: Record<string, THREE.ToneMapping> = {
-          none: THREE.NoToneMapping,
-          agx: THREE.AgXToneMapping,
-          neutral: THREE.NeutralToneMapping,
-          filmic: THREE.NoToneMapping,
-        };
-        await snapshot.prepare(renderCamera);
-        assertBinding();
-        const captureOptions = {
-          effect: snapshot.effect,
-          width: render.width,
-          height: render.height,
-          transparent: render.transparent === true,
-          toneMapping: mappings[render.toneMapping] ?? THREE.AgXToneMapping,
-          exposure: render.exposure,
-        };
-        // BLENDER'S OWN VIEW TRANSFORM, off the linear frame. three's AgX is
-        // Filament's approximation and lands 23 to 48 levels of 255 away from
-        // Blender (42 at middle grey); the config's actual transform is a 57^3
-        // LUT over a log allocation, and a LOOK grades in a log space with two
-        // LUT inversions in it. Neither is reachable from resolved bytes, and
-        // both are reachable from the half-float target `captureImage` already
-        // allocates -- so an AgX render reads that and runs
-        // `blender-agx.ts`, which is verified byte-for-byte against OCIO.
-        // AND WHENEVER THE SCENE-REFERRED FRAME IS WANTED, whatever the
-        // transform: `captureImage` answers with resolved bytes and nothing
-        // else, so a Standard render asked for an EXR — or asked to be
-        // composited — has no linear frame in it at all. Reading the
-        // half-float target is the only path that has one.
-        const display =
-          render.toneMapping === 'agx' || render.toneMapping === 'filmic' || render.linear === true
-            ? await displayPhotograph(
-                captureSceneLinear(scene, renderCamera, captureOptions),
-                render,
-              )
-            : null;
-        assertBinding();
-        if (display) return answer({ ...display, camera: photographedFrom });
-        const dataUrl = captureSceneImage(scene, renderCamera, captureOptions);
-        if (!dataUrl) throw new Error('Blender render could not capture its image');
-        return answer({
-          base64: dataUrl.slice(dataUrl.indexOf(',') + 1),
-          mimeType: 'image/png',
-          camera: photographedFrom,
-        });
+        const display = await photographSnapshot(scene, renderCamera, snapshot, render, assertBinding);
+        return answer({ ...display, camera: photographedFrom });
       } finally {
         photographing = false;
         lifetime.signal.removeEventListener('abort', snapshot.dispose);

package/package.json

@@ -2,7 +2,7 @@
   "name": "@volter/editor-blender",
   "author": "Volter AI, Inc.",
   "license": "AGPL-3.0-only AND GPL-3.0-or-later",
-  "version": "0.1.18",
+  "version": "0.1.20",
   "publishConfig": {
     "access": "public"
   },
@@ -69,14 +69,14 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "1.30.0",
-    "@volter/blender-engine": "0.1.16",
-    "@volter/editor-threejs": "0.5.78",
+    "@volter/blender-engine": "0.1.18",
+    "@volter/editor-threejs": "0.5.80",
     "zod": "^4.3.6"
   },
   "peerDependencies": {
-    "@volter/editor-sdk": "0.5.78",
-    "@volter/editor-live": "0.5.78",
-    "@volter/editor-project": "0.5.78",
+    "@volter/editor-sdk": "0.5.80",
+    "@volter/editor-live": "0.5.80",
+    "@volter/editor-project": "0.5.80",
     "react": "^19.0.0",
     "three": "^0.180.0",
     "vite": "^6.4.3"

package/src/render-view-split.ts

@@ -0,0 +1,46 @@
+/**
+ * WHETHER A MODEL DOCUMENT'S AREA IS SPLIT, with the Render view beside the modeling viewport
+ * (View ▸ Area ▸ Vertical Split, `blender-header-menus.tsx`; drawn by
+ * `blender-runtime.document.tsx`). Blender keeps its areas in the file's screen; this editor's
+ * screen is the workbench's, so the split is kept per document on this machine, the way the
+ * workbench keeps its own layout, and never written into the `.blend`.
+ */
+const STORAGE_PREFIX = 'volter.blender.render-view-split:';
+const listeners = new Set<() => void>();
+const split = new Map<string, boolean>();
+
+function stored(documentId: string): boolean {
+  try {
+    return globalThis.localStorage?.getItem(STORAGE_PREFIX + documentId) === '1';
+  } catch {
+    return false;
+  }
+}
+
+export function renderViewSplit(documentId: string): boolean {
+  let value = split.get(documentId);
+  if (value === undefined) {
+    value = stored(documentId);
+    split.set(documentId, value);
+  }
+  return value;
+}
+
+export function setRenderViewSplit(documentId: string, value: boolean): void {
+  if (renderViewSplit(documentId) === value) return;
+  split.set(documentId, value);
+  try {
+    if (value) globalThis.localStorage?.setItem(STORAGE_PREFIX + documentId, '1');
+    else globalThis.localStorage?.removeItem(STORAGE_PREFIX + documentId);
+  } catch {
+    // A page without storage keeps the split for its own life.
+  }
+  for (const listener of [...listeners]) listener();
+}
+
+export function subscribeRenderViewSplit(listener: () => void): () => void {
+  listeners.add(listener);
+  return () => {
+    listeners.delete(listener);
+  };
+}