@volter/editor-blender 0.1.21 → 0.1.22

package/contributions/blender-header-menus.tsx

@@ -16,12 +16,11 @@
  * 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
+ * `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 a second 3D viewport beside the model, set up that way
+ * (`blender-runtime.document.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.
  *
@@ -58,7 +57,7 @@ import {
   runBlenderObjectOperator,
 } from './blender-outliner-authoring';
 import { blenderOutlinerVersion, subscribeBlenderOutliner } from './blender-outliner-model';
-import { renderViewSplit, setRenderViewSplit, subscribeRenderViewSplit } from '../src/render-view-split';
+import { areaSplit, setAreaSplit, subscribeAreaSplit } from '../src/area-split';
 
 type MenuId = 'view' | 'select' | 'add' | 'object';
 
@@ -266,8 +265,8 @@ export function BlenderObjectModeHeader({
   const addRef = useRef<HTMLDivElement>(null);
   const objectRef = useRef<HTMLDivElement>(null);
   const split = useSyncExternalStore(
-    subscribeRenderViewSplit,
-    () => (documentId === undefined ? false : renderViewSplit(documentId)),
+    subscribeAreaSplit,
+    () => (documentId === undefined ? false : areaSplit(documentId)),
     () => false,
   );
   const handle = blenderOutlinerHandle(documentId);
@@ -350,17 +349,17 @@ 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). */}
+      {/* VIEW ▸ AREA — `INFO_MT_area`'s split and close, for the second 3D viewport 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}
+            title={split ? 'This area is already split.' : undefined}
             onSelect={() => {
               setOpen(null);
-              if (documentId !== undefined) setRenderViewSplit(documentId, true);
+              if (documentId !== undefined) setAreaSplit(documentId, true);
             }}
           >
             Vertical Split
@@ -372,7 +371,7 @@ export function BlenderObjectModeHeader({
             title={split ? undefined : 'There is no second area to close.'}
             onSelect={() => {
               setOpen(null);
-              if (documentId !== undefined) setRenderViewSplit(documentId, false);
+              if (documentId !== undefined) setAreaSplit(documentId, false);
             }}
           >
             Close Area

package/contributions/blender-outliner-authoring.ts

@@ -83,6 +83,7 @@ import {
   blenderOutlinerVersion,
   blenderPresentedView,
   onBlenderFrame,
+  type PresentedView,
   refreshBlenderOutliner,
   showBlenderOutliner,
   subscribeBlenderOutliner,
@@ -219,18 +220,19 @@ export interface BlenderOutlinerHandle {
 const liveOutliners = new Set<BlenderOutlinerHandle>();
 
 /**
- * The Outliner handle for a document, for the header that draws over it.
+ * The Outliner handle for a document, for the header that draws over it: the one its own stage
+ * made (a stage's adapter names its document `object3d-document:<id>`).
  *
- * The fallback when no handle names that document is the SINGLE live one, and
- * it is sound rather than lax: the Blender engine is one session bound to one
- * `.blend` at a time (`blender-runtime-host.ts`'s `bindModelDocument`), so a
- * second Model document with its own Outliner over the same engine is not a
- * state this package can be in. With two, a document that cannot name itself
- * answers null rather than guessing.
+ * The fallback when no handle names that document is ANY live one, and it is sound rather than
+ * lax: the Blender engine is one session bound to one `.blend` at a time
+ * (`blender-runtime-host.ts`'s `bindModelDocument`), so every live handle is an Outliner of that
+ * one engine's tree, whether it is the Model document's area or the area split beside it
+ * (`blender-runtime.document.tsx`), and a header's menus act on the engine by name.
  */
 export function blenderOutlinerHandle(documentId?: string): BlenderOutlinerHandle | null {
-  for (const handle of liveOutliners) if (handle.documentId === documentId) return handle;
-  return liveOutliners.size === 1 ? [...liveOutliners][0]! : null;
+  for (const handle of liveOutliners)
+    if (handle.documentId === documentId || handle.documentId === `object3d-document:${documentId}`) return handle;
+  return liveOutliners.values().next().value ?? null;
 }
 
 /** The transform of a subject this adapter does not own. `TransformProvider.get`
@@ -971,9 +973,16 @@ const EXCLUDED_REASON =
   'This collection is excluded from the view layer (LayerCollection.exclude), so its viewport ' +
   'visibility is not what is hiding it. Clear the Exclude checkbox on this row first.';
 
-export const createBlenderOutlinerAuthoring: ToolObject3DDocumentAuthoringFactory = ({
-  defaultAdapter,
-}) => {
+/**
+ * THE OUTLINER AUTHORING FOR A STAGE DRAWING `presented`: the rows are Blender's either way, and
+ * the view is where a row meets the three object its stage picks, outlines and moves. The Model
+ * document's own area draws the published view ({@link createBlenderOutlinerAuthoring}); a split
+ * area draws a follower of it (`BlenderRuntimeView.follow`, `blender-render-view.tsx`).
+ */
+export function blenderOutlinerAuthoringFor(
+  presented: () => PresentedView | null,
+): ToolObject3DDocumentAuthoringFactory {
+  return ({ defaultAdapter }) => {
   const listeners = new Set<() => void>();
   /**
    * THE ENGINE'S SELECTION, CACHED IN ROW IDS — never a second selection.
@@ -1008,7 +1017,7 @@ export const createBlenderOutlinerAuthoring: ToolObject3DDocumentAuthoringFactor
    *  spaces meet (see the header). */
   const objectForRow = (id: string): THREE.Object3D | null => {
     const row = rows().get(id);
-    const view = blenderPresentedView();
+    const view = presented();
     if (row === undefined || view === null) return null;
     if (row.type === 'TSE_VIEW_COLLECTION_BASE') return view.root;
     return row.object === undefined ? null : view.objectForBlenderName(row.object);
@@ -1017,7 +1026,7 @@ export const createBlenderOutlinerAuthoring: ToolObject3DDocumentAuthoringFactor
   /** The row for a presented OBJECT: its address is the object's own, so this
    *  is a map lookup rather than a walk. */
   const rowIdForObject = (object: THREE.Object3D): string | null => {
-    const view = blenderPresentedView();
+    const view = presented();
     if (view === null) return null;
     for (const row of rows().values())
       if (isObjectRow(row) && view.objectForBlenderName(row.object) === object) return row.id;
@@ -1403,7 +1412,7 @@ export const createBlenderOutlinerAuthoring: ToolObject3DDocumentAuthoringFactor
     endEdit: async (id): Promise<WriteAck | undefined> => {
       const object = gestureObjects.get(id) ?? objectFor(id);
       gestureObjects.delete(id);
-      const view = blenderPresentedView();
+      const view = presented();
       if (object === null) return undefined;
       const started = gestureStart.get(object);
       gestureStart.delete(object);
@@ -1748,3 +1757,6 @@ export const createBlenderOutlinerAuthoring: ToolObject3DDocumentAuthoringFactor
     },
   };
 };
+}
+
+export const createBlenderOutlinerAuthoring = blenderOutlinerAuthoringFor(blenderPresentedView);

package/contributions/blender-outliner-model.ts

@@ -28,7 +28,7 @@ import {
  *  typed for the same reason `blender-properties-model.ts` narrows it: the
  *  document that published it and the reader are two modules meeting over one
  *  object, and `@volter/editor-blender` holds no host import. */
-interface PresentedView {
+export interface PresentedView {
   readonly root: THREE.Object3D;
   subscribeFrames(listener: () => void): () => void;
   objectForBlenderName(name: string): THREE.Object3D | null;

package/contributions/blender-runtime.document.tsx

@@ -26,19 +26,31 @@
 
 // How the `model` stage this document builds behaves (its starting presentation).
 import { blenderViewFieldOfView } from '../src/presentation';
-import { blenderModelView } from '@volter/blender-engine/browser/three/blender-runtime-view';
+import {
+  type BlenderRuntimeView,
+  blenderModelView,
+} from '@volter/blender-engine/browser/three/blender-runtime-view';
 import type { ToolContributionProps, ToolDocumentToolbar } from '@volter/editor-sdk/contributions';
 import { editorHost } from '@volter/editor-sdk/host';
+import {
+  documentViewport,
+  documentViewportsVersion,
+  subscribeDocumentViewports,
+} from '@volter/editor-sdk/kit/document-viewports';
 import {
   DOCUMENT_STUDIO_PRESET,
+  setViewPresentation,
   subscribeViewportPresentation,
   viewPresentation,
+  viewPresentationSnapshot,
 } from '@volter/editor-sdk/kit/viewport-presentation';
 import {
   type MouseEvent as ReactMouseEvent,
   type PointerEvent as ReactPointerEvent,
+  Suspense,
   useCallback,
   useEffect,
+  useMemo,
   useRef,
   useState,
   useSyncExternalStore,
@@ -46,11 +58,15 @@ import {
 import * as THREE from 'three';
 import { bindModelDocument, blenderExecute, openModelDocumentBlend } from '../host/blender-runtime-host';
 import { BlenderObjectModeHeader } from './blender-header-menus';
-import { createBlenderOutlinerAuthoring } from './blender-outliner-authoring';
+import { blenderOutlinerAuthoringFor, 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 { areaSplit, subscribeAreaSplit } from '../src/area-split';
 import { onViewportStages, viewportStages } from '@volter/editor-threejs/viewport-door';
+import {
+  object3DDocumentSession,
+  subscribeObject3DDocumentSessions,
+} from '@volter/editor-threejs/kit/authoring/object3d-document-session-registry';
+import type { ToolObject3DAuthoringProps } from '@volter/editor-threejs/object3d-contributions';
 
 export const point = 'workspace.document';
 export const title = 'Blender Model';
@@ -96,51 +112,68 @@ export const inspectorBuiltins: readonly string[] = [];
 // Timeline binds a skeleton into the same presented graph and there is exactly
 // one set of presented objects (`blender-runtime-skin.ts`).
 const view = blenderModelView;
-/** THE SUBJECT LINE'S FRAME IS THE ONE ON SCREEN: the skin's playhead, which during playback
- *  runs ahead of `frame_current` (written once, on pause), as Blender's own `(frame)` does. */
-const subjectOfView = () => {
-  const playhead = blenderSkin.playhead();
-  return view.subjectLine(playhead === null ? null : Math.floor(playhead));
-};
-const gridScale = (worldPerDevicePixel: number) => view.gridUnitName(worldPerDevicePixel);
-/** BLENDER'S CAMERA VIEW (`blender-runtime-camera-view.ts`): which camera, and how it fits. */
-const cameraView = {
-  camera: () => view.cameraViewCamera(),
-  zoom: view.cameraViewZoom,
-  pan: view.cameraViewPan,
-  showing: (camera: string | null) => view.setCameraViewShowing(camera),
-  // A LOCKED camera view moves the camera (`ED_view3d_camera_lock_sync`: its scale kept); the
-  // navigation's end is the one step Blender's history records.
-  setPose: (
-    camera: string,
-    position: readonly [number, number, number],
-    quaternion: readonly [number, number, number, number],
-    final: boolean,
-  ) => {
-    const { location, rotation } = view.blenderPose(position, quaternion);
-    return blenderExecute(
-      'from mathutils import Matrix, Quaternion, Vector\n' +
-        `import bpy\nobject = bpy.data.objects[${JSON.stringify(camera)}]\n` +
-        `object.matrix_world = Matrix.LocRotScale(Vector((${location.join(', ')})), ` +
-        `Quaternion((${rotation.join(', ')})), object.matrix_world.to_scale())`,
-      final,
-      'Lock Camera to View',
-    ).then(
-      (answer) => {
-        if (answer.error !== null)
-          editorHost().console.error(`Blender refused the camera's pose: ${answer.error}`, 'blender-camera');
+type AreaView = BlenderRuntimeView;
+
+/** What an area's stage reads from the view it draws, made once per view. */
+interface AreaReads {
+  readonly subject: () => string | null;
+  readonly gridScale: (worldPerDevicePixel: number) => string | null;
+  readonly cameraView: NonNullable<ToolObject3DAuthoringProps['cameraView']>;
+}
+const areaReads = new WeakMap<AreaView, AreaReads>();
+function readsOf(view: AreaView): AreaReads {
+  let reads = areaReads.get(view);
+  if (reads) return reads;
+  reads = {
+    /** THE SUBJECT LINE'S FRAME IS THE ONE ON SCREEN: the skin's playhead, which during playback
+     *  runs ahead of `frame_current` (written once, on pause), as Blender's own `(frame)` does. */
+    subject: () => {
+      const playhead = blenderSkin.playhead();
+      return view.subjectLine(playhead === null ? null : Math.floor(playhead));
+    },
+    gridScale: (worldPerDevicePixel: number) => view.gridUnitName(worldPerDevicePixel),
+    /** BLENDER'S CAMERA VIEW (`blender-runtime-camera-view.ts`): which camera, and how it fits. */
+    cameraView: {
+      camera: () => view.cameraViewCamera(),
+      zoom: view.cameraViewZoom,
+      pan: view.cameraViewPan,
+      showing: (camera: string | null) => view.setCameraViewShowing(camera),
+      // A LOCKED camera view moves the camera (`ED_view3d_camera_lock_sync`: its scale kept); the
+      // navigation's end is the one step Blender's history records.
+      setPose: (
+        camera: string,
+        position: readonly [number, number, number],
+        quaternion: readonly [number, number, number, number],
+        final: boolean,
+      ) => {
+        const { location, rotation } = view.blenderPose(position, quaternion);
+        return blenderExecute(
+          'from mathutils import Matrix, Quaternion, Vector\n' +
+            `import bpy\nobject = bpy.data.objects[${JSON.stringify(camera)}]\n` +
+            `object.matrix_world = Matrix.LocRotScale(Vector((${location.join(', ')})), ` +
+            `Quaternion((${rotation.join(', ')})), object.matrix_world.to_scale())`,
+          final,
+          'Lock Camera to View',
+        ).then(
+          (answer) => {
+            if (answer.error !== null)
+              editorHost().console.error(`Blender refused the camera's pose: ${answer.error}`, 'blender-camera');
+          },
+          (error: unknown) =>
+            editorHost().console.error(`The camera's pose was not written to Blender: ${String(error)}`, 'blender-camera'),
+        );
       },
-      (error: unknown) =>
-        editorHost().console.error(`The camera's pose was not written to Blender: ${String(error)}`, 'blender-camera'),
-    );
-  },
-  view: (
-    camera: string,
-    region: { readonly width: number; readonly height: number },
-    zoom: number,
-    offset: readonly [number, number],
-  ) => view.cameraView(camera, region, zoom, offset),
-};
+      view: (
+        camera: string,
+        region: { readonly width: number; readonly height: number },
+        zoom: number,
+        offset: readonly [number, number],
+      ) => view.cameraView(camera, region, zoom, offset),
+    },
+  };
+  areaReads.set(view, reads);
+  return reads;
+}
 
 export default function BlenderModelDocument(props: ToolContributionProps) {
   const { active, document, documentId, notify, publishContext } = props;
@@ -190,12 +223,108 @@ export default function BlenderModelDocument(props: ToolContributionProps) {
   return <BlenderModelViewport {...props} />;
 }
 
-function BlenderModelViewport({
+/**
+ * THE MODEL DOCUMENT'S AREA: one 3D viewport, and the whole screen unless the area is split
+ * (View ▸ Area ▸ Vertical Split, `src/area-split.ts`). Split, the second area is the same
+ * viewport over a follower of the presented view (`BlenderRuntimeView.follow`), opened as
+ * Blender's standard always-on render preview is set up: Rendered shading, through the scene
+ * camera. Each area has its own stage, shading, navigation and camera view; the model, its
+ * selection and its history are the document's.
+ */
+function BlenderModelViewport(props: ToolContributionProps) {
+  const { documentId } = props;
+  const split = useSyncExternalStore(
+    subscribeAreaSplit,
+    () => (documentId ? areaSplit(documentId) : false),
+    () => false,
+  );
+  const [follower, setFollower] = useState<ReturnType<AreaView['follow']> | null>(null);
+  useEffect(() => {
+    if (!split || !documentId) return;
+    // The area's shading is its CHOICE, the door a shading cell uses, made before its stage binds
+    // so the stage's session takes it; an area whose shading was already chosen keeps it.
+    const secondId = `${documentId}#area-2`;
+    if (viewPresentationSnapshot(secondId).drawMode === undefined)
+      setViewPresentation(secondId, { drawMode: 'rendered' });
+    const second = view.follow();
+    setFollower(second);
+    return () => {
+      setFollower(null);
+      second.dispose();
+    };
+  }, [split, documentId]);
+  if (!documentId) return null;
+  const second = split ? follower : null;
+  // SPLIT, THE TWO AREAS SHARE THE SLOT the stage alone fills otherwise: each stage's root bleeds
+  // 12 px past its positioned parent (`inset: -12px`), so each area is that parent inset by 12,
+  // and the two stand 2 px apart, Blender's gap between areas. Unsplit, both wrappers are
+  // `contents` and the one stage is placed as it always was.
+  const area = { position: 'relative', flex: '1 1 0', minWidth: 0, margin: 12 } as const;
+  return (
+    <div style={second ? { position: 'absolute', inset: -12, display: 'flex', gap: 2 } : { display: 'contents' }}>
+      <div style={second ? area : { display: 'contents' }}>
+        <BlenderViewportArea {...props} view={view} main />
+      </div>
+      {second && (
+        <div style={{ ...area, marginTop: 24 + AREA_HEADER }} data-testid="blender-second-area">
+          <BlenderViewportArea {...props} documentId={`${documentId}#area-2`} view={second.view} main={false} />
+          <SecondAreaChrome documentId={documentId} areaId={`${documentId}#area-2`} notify={props.notify} />
+        </div>
+      )}
+    </div>
+  );
+}
+
+/**
+ * THE SECOND AREA'S OWN HEADER, as each of Blender's areas has one: the editor menus (their
+ * View ▸ Area ▸ Close Area closes this area), then THIS area's view, shading and helpers, the
+ * header controls its own stage registered, so its shading cells change this area and not the
+ * other.
+ */
+/** The height of an area's own header row: the document strip's (`volter-dock-document-toolbar`). */
+const AREA_HEADER = 26;
+
+function SecondAreaChrome({
+  documentId,
+  areaId,
+  notify,
+}: {
+  readonly documentId: string;
+  readonly areaId: string;
+  readonly notify: ToolContributionProps['notify'];
+}) {
+  useSyncExternalStore(subscribeDocumentViewports, documentViewportsVersion, documentViewportsVersion);
+  const HeaderControls = documentViewport(areaId)?.HeaderControls;
+  return (
+    <>
+      {HeaderControls && (
+        <div
+          className="volter-dock-document-toolbar"
+          data-testid={`document-header:${areaId}`}
+          style={{ position: 'absolute', top: -12 - AREA_HEADER, height: AREA_HEADER, left: -12, right: -12 }}
+        >
+          {/* Blender's area header opens on the same editor menus; they act on the document. */}
+          <div className="volter-dock-document-toolbar-own">
+            <BlenderObjectModeHeader documentId={documentId} notify={notify} />
+          </div>
+          <Suspense fallback={null}>
+            <HeaderControls documentId={areaId} />
+          </Suspense>
+        </div>
+      )}
+    </>
+  );
+}
+
+function BlenderViewportArea({
   active,
   document,
   documentId,
   surfaces,
-}: ToolContributionProps) {
+  view,
+  main,
+}: ToolContributionProps & { readonly view: AreaView; readonly main: boolean }) {
+  const reads = readsOf(view);
   const build = useCallback(
     () => ({
       root: view.root,
@@ -211,7 +340,7 @@ function BlenderModelViewport({
       },
       dispose() {},
     }),
-    [],
+    [view],
   );
   const blend = document?.source?.path;
   // Re-read on the engine's frames, the skin's publications and every drawn frame of this stage
@@ -235,15 +364,38 @@ function BlenderModelViewport({
         stopFrame?.();
       };
     },
-    [documentId],
+    [documentId, view],
   );
-  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,
+  const subject = useSyncExternalStore(subscribeSubject, reads.subject);
+  // THE SECOND AREA'S ROWS MEET ITS OWN GRAPH: the same Outliner, over the view this stage draws.
+  const authoring = useMemo(
+    () => (main ? createBlenderOutlinerAuthoring : blenderOutlinerAuthoringFor(() => view)),
+    [main, view],
   );
+  /**
+   * THE SECOND AREA OPENS AS BLENDER'S RENDER PREVIEW IS SET UP: Rendered shading (chosen as the
+   * area is made, `BlenderModelViewport`) and looking through the scene camera
+   * (`view3d.view_camera`), entered once the stage stands and there is a camera to look through.
+   * Afterwards it is an ordinary area: leaving the camera view or changing the shading is the
+   * person's.
+   */
+  useEffect(() => {
+    if (main || !documentId) return;
+    let entered = false;
+    const enter = (): void => {
+      if (entered) return;
+      const session = object3DDocumentSession(documentId);
+      if (session === null || view.cameraViewCamera() === null) return;
+      entered = session.toggleCameraView();
+    };
+    enter();
+    const stopSessions = subscribeObject3DDocumentSessions(enter);
+    const stopFrames = view.subscribeFrames(enter);
+    return () => {
+      stopSessions();
+      stopFrames();
+    };
+  }, [main, documentId, view]);
   /**
    * THE INSPECTION OVERLAYS ARE HELPERS, and the Helpers menu owns them
    * (WORK.md §Blender in the tab is Blender, "Inspection parity", I4).
@@ -273,7 +425,7 @@ function BlenderModelViewport({
       const stage = viewportStages().find((one) => one.documentId === documentId);
       for (const { kind } of groups) stage?.setHelper(kind, null);
     };
-  }, [documentId]);
+  }, [documentId, view]);
   /**
    * ATTACH THE SKIN TO THIS STAGE'S TRANSPORT.
    *
@@ -286,7 +438,8 @@ function BlenderModelViewport({
    * notification rather than assuming an order.
    */
   useEffect(() => {
-    if (!documentId) return;
+    // The skin poses the presented view's graph; a follower's has no skeleton bound.
+    if (!documentId || !main) return;
     const { transport } = editorHost();
     let detach: (() => void) | null = null;
     const attach = (): void => {
@@ -301,7 +454,7 @@ function BlenderModelViewport({
       stop();
       detach?.();
     };
-  }, [documentId]);
+  }, [documentId, main]);
   /**
    * BLENDER'S RENDERED SHADING IS THE SCENE'S OWN LIGHT. When this stage's view lights by the
    * `scene` (the Rendered shading cell, or the Lighting row's Scene), the presenter holds the viewport
@@ -343,7 +496,7 @@ function BlenderModelViewport({
       view.holdRendered(null);
       view.setWorkbench(false);
     };
-  }, [documentId]);
+  }, [documentId, view]);
   /**
    * SHIFT+RIGHT-CLICK PLACES THE 3D CURSOR, Blender's own chord for
    * `view3d.cursor3d` (`blender_default.py`, `params.cursor_set_event`). The
@@ -403,15 +556,8 @@ 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={split ? { position: 'relative', flex: '1 1 0', minWidth: 0, margin: 12 } : { display: 'contents' }}
+      style={{ display: 'contents' }}
       onPointerDownCapture={onPointerDownCapture}
       onPointerUpCapture={onPointerUpCapture}
       onPointerCancelCapture={dropCursorPress}
@@ -426,8 +572,8 @@ function BlenderModelViewport({
       // THE OVERLAY'S SUBJECT AND GRID LINES ARE BLENDER'S: the engine composes the subject from
       // the scene (`session.py` `_subject_line`) and names the grid's step in the scene's units.
       {...(subject === null ? {} : { subject })}
-      gridScale={gridScale}
-      cameraView={cameraView}
+      gridScale={reads.gridScale}
+      cameraView={reads.cameraView}
       build={build}
       audit={false}
       // ON A MODEL DOCUMENT THE HIERARCHY IS BLENDER'S OUTLINER, for the same
@@ -438,7 +584,7 @@ function BlenderModelViewport({
       // provider; the default adapter it delegates to still answers everything
       // about the presentation (WORK.md §Blender in the tab is Blender,
       // "Inspection parity", I3).
-      authoring={createBlenderOutlinerAuthoring}
+      authoring={authoring}
       cameraDirection={[0.8187, 0.4458, 0.3617]}
       // FOR A FILE THAT SAVED NO 3D VIEW: Blender's factory Modeling direction, standing back
       // three fits.
@@ -477,7 +623,5 @@ function BlenderModelViewport({
       }}
     />
     </div>
-    {split && <BlenderRenderView />}
-    </div>
   );
 }

package/host/blender-runtime-host.ts

@@ -192,9 +192,8 @@ async function displayPhotograph(
 
 /**
  * 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.
+ * view transform. `assertCurrent` throws when the caller's snapshot went stale while the
+ * lighting was prepared.
  */
 export async function photographSnapshot(
   scene: THREE.Scene,
@@ -250,125 +249,6 @@ export async function photographSnapshot(
   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';
 
 /**

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.21",
+  "version": "0.1.22",
   "publishConfig": {
     "access": "public"
   },
@@ -69,14 +69,14 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "1.30.0",
-    "@volter/blender-engine": "0.1.19",
-    "@volter/editor-threejs": "0.5.81",
+    "@volter/blender-engine": "0.1.20",
+    "@volter/editor-threejs": "0.5.82",
     "zod": "^4.3.6"
   },
   "peerDependencies": {
-    "@volter/editor-sdk": "0.5.81",
-    "@volter/editor-live": "0.5.81",
-    "@volter/editor-project": "0.5.81",
+    "@volter/editor-sdk": "0.5.82",
+    "@volter/editor-live": "0.5.82",
+    "@volter/editor-project": "0.5.82",
     "react": "^19.0.0",
     "three": "^0.180.0",
     "vite": "^6.4.3"

package/src/{render-view-split.ts → area-split.ts}

@@ -1,11 +1,11 @@
 /**
- * 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`.
+ * WHETHER A MODEL DOCUMENT'S AREA IS SPLIT into two 3D viewports side by side (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 STORAGE_PREFIX = 'volter.blender.area-split:';
 const listeners = new Set<() => void>();
 const split = new Map<string, boolean>();
 
@@ -17,7 +17,7 @@ function stored(documentId: string): boolean {
   }
 }
 
-export function renderViewSplit(documentId: string): boolean {
+export function areaSplit(documentId: string): boolean {
   let value = split.get(documentId);
   if (value === undefined) {
     value = stored(documentId);
@@ -26,8 +26,8 @@ export function renderViewSplit(documentId: string): boolean {
   return value;
 }
 
-export function setRenderViewSplit(documentId: string, value: boolean): void {
-  if (renderViewSplit(documentId) === value) return;
+export function setAreaSplit(documentId: string, value: boolean): void {
+  if (areaSplit(documentId) === value) return;
   split.set(documentId, value);
   try {
     if (value) globalThis.localStorage?.setItem(STORAGE_PREFIX + documentId, '1');
@@ -38,7 +38,7 @@ export function setRenderViewSplit(documentId: string, value: boolean): void {
   for (const listener of [...listeners]) listener();
 }
 
-export function subscribeRenderViewSplit(listener: () => void): () => void {
+export function subscribeAreaSplit(listener: () => void): () => void {
   listeners.add(listener);
   return () => {
     listeners.delete(listener);

package/contributions/blender-render-view.tsx

@@ -1,151 +0,0 @@
-/**
- * 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>
-  );
-}