@volter/editor-threejs 0.5.210 → 0.5.212

package/src/kit/authoring/object3d-document-session.ts

@@ -1,9 +1,15 @@
-import { createPerformanceProfiler } from '@volter/sdk/kit/performance-profiler';
-import { resetViewPresentation, setViewPresentation, type ViewportXray } from '@volter/sdk/kit/viewport-presentation';
-import { invalidateStages } from '@volter/sdk/kit/stage-invalidation';
+import { resetViewPresentation, setViewPresentation, type ViewportXray } from '@volter/sdk/viewport-presentation';
+import { invalidateStages } from '@volter/sdk/stage-invalidation';
 import type { AuthoringAdapter } from '@volter/project/adapter';
 import { viewportCaptureOutputPass } from '@volter/editor-threejs/capture/output-pass';
 import { resolveSceneLinearSize } from '@volter/editor-threejs/capture/linear-resolve';
+import {
+  jitterProjection,
+  PHOTOGRAPH_SAMPLE_CAP,
+  PhotographAccumulation,
+  type PhotographSampling,
+} from '@volter/editor-threejs/capture/photograph-sampling';
+import { FullScreenQuad } from 'three/addons/postprocessing/Pass.js';
 import { contentWorldBounds } from '@volter/editor-threejs/viewport/content-bounds';
 import { setUserData } from '@volter/editor-threejs/ecs/user-data';
 import {
@@ -17,10 +23,10 @@ import { DepthDrawMaterials } from '../../render/depth-draw-materials';
 import type { DocumentDisplayTransform } from '../../render/document-display-transform';
 import { threeObject } from '../../adapter/three-contract';
 import { axisViewName, cameraPresetDirection, type ModelCameraPreset } from '../asset-workflow/model-inspection';
-import { activeKeymapNavigation } from '@volter/sdk/kit/keymap-presets';
-import { editorConsole } from '@volter/sdk/kit/editor-console';
+import { editorHost } from '@volter/sdk/host';
+import { editorConsole } from '@volter/sdk/editor-console';
 import { type EditorViewport } from '../editor-viewport';
-import { nativeSelectionColors, subscribeNativeSelectionTheme } from '@volter/sdk/kit/native-selection-style';
+import { nativeSelectionColors, subscribeNativeSelectionTheme } from '@volter/sdk/native-selection-style';
 import { BoneSelectionHighlight } from '../three-viewport/bone-selection-highlight';
 import { perspectiveDistanceToFitBox } from '../three-viewport/camera-fit';
 import {
@@ -31,7 +37,7 @@ import {
 } from '../three-viewport/selection-outline';
 import { styleEditorSkeletonHelper } from '../three-viewport/skeleton-helper';
 import { isEditorViewportShadingTarget } from '../viewport-shading-boundary';
-import { setAuthoringSelection } from '@volter/sdk/kit/authoring/consumer-actions';
+import { setAuthoringSelection } from '@volter/sdk/authoring/consumer-actions';
 import type { ToolCameraView, ToolCameraViewSource } from '../../object3d-contributions';
 
 export type Object3DDocumentViewMode = ViewportShadingMode | 'uv' | 'vertex-colors';
@@ -68,7 +74,7 @@ interface CameraFlight {
   elapsed: number;
   theta: number;
   phi: number;
-  settle: ((outcome: DocumentLookOutcome) => void) | null;
+  settle: (outcome: DocumentLookOutcome) => void;
 }
 
 /**
@@ -80,12 +86,10 @@ interface CameraFlight {
  */
 const TOPOLOGY_EDGE_THRESHOLD_DEGREES = 1;
 
-/** OrbitControls' own poles-excluded range; orbiting past them flips the view. */
-/** How long a presented-frame request waits on the host's draw loop before it
- *  gives the chrome door back `null` (see `requestPresentedFrame`). Two frames
- *  at 30fps is a loop that is running; longer means it is not. */
+/** Maximum wait for the host draw loop before requestPresentedFrame returns null. */
 const PRESENTED_FRAME_WAIT_MS = 700;
 
+/** OrbitControls' own poles-excluded range; orbiting past them flips the view. */
 const MIN_POLAR = 1e-3;
 const MAX_POLAR = Math.PI - 1e-3;
 
@@ -112,15 +116,14 @@ const INITIAL_PRESENTATION: Object3DDocumentPresentationState = {
   bounds: false,
 };
 
+/** The wire of an unselected object in the wireframe overlay: dark on the light clay body. */
+const TOPOLOGY_WIRE_COLOR = 0x11161d;
+
 /**
  * Live presentation controls for one native Object3D document. The model
  * graph remains truth; this session owns only editor chrome and diagnostics.
  */
-/** The wire of an unselected object in the wireframe overlay: dark on the light clay body. */
-const TOPOLOGY_WIRE_COLOR = 0x11161d;
-
 export class Object3DDocumentSession {
-  readonly profiler = createPerformanceProfiler();
   private readonly shading = new ViewportShadingRenderer();
   private readonly depthDrawMaterials = new DepthDrawMaterials();
   private readonly helpers: THREE.Object3D[] = [];
@@ -166,12 +169,75 @@ export class Object3DDocumentSession {
    *  shape (square by default, `{width, height}` when a caller asks for one)
    *  while the live camera's aspect is the panel's. */
   private captureAspect: number | null = null;
-  /** The camera a capture door was handed, for the duration of that capture.
-   *  A BLENDER RENDER IS NOT THE MODELING VIEWPORT: it photographs the scene
-   *  through the scene's OWN camera, which has nothing to do with where the
-   *  person is looking — see `blender-runtime-host.ts`. Before this existed the
-   *  only way to photograph from another camera was to move the viewport onto
-   *  it and move it back, which is why that code had a restore dance at all. */
+  /** Target pixels per output pixel, non-null ONLY inside {@link captureImage}, which draws at
+   *  twice the photograph's size and reduces. */
+  private capturePixelScale: number | null = null;
+
+  /** Target pixels per output pixel of the draw being made: the photograph's supersampling
+   *  inside a capture, the device pixel ratio on screen. What a pixel-wide effect (Blender's
+   *  object outline) spans. */
+  drawPixelScale(): number {
+    return this.capturePixelScale ?? this.renderer.getPixelRatio();
+  }
+
+  /** The draw being made is {@link captureImage}'s photograph. */
+  photographing(): boolean {
+    return this.capturePixelScale !== null;
+  }
+
+  /** How a photograph of each draw mode is anti-aliased, when the document states it
+   *  (`PhotographSampling`): Blender's Solid by Workbench's own accumulation, its Rendered by
+   *  EEVEE's film. A mode with none is drawn at twice the photograph's size and reduced. */
+  private photographSampling: Partial<Record<Object3DDocumentViewMode, PhotographSampling>> | null = null;
+  setPhotographSampling(sampling: Partial<Record<Object3DDocumentViewMode, PhotographSampling>> | null): void {
+    if (this.photographSampling === sampling) return;
+    this.photographSampling = sampling;
+    // The live view accumulates by the same sampling; what it gathered under the old is dropped.
+    this.live?.dispose();
+    this.live = null;
+  }
+
+  /** Accumulate the document’s viewport samples across unchanged redraws. Navigation, edits and resize reset the sum; release live targets while hidden and retain the finished display-encoded image after completion. */
+  private live: LiveAccumulation | null = null;
+  /** A failure inside the live accumulation is reported once per session. */
+  private liveFailureReported = false;
+
+  /** The sampling the live view accumulates by in the current mode, or null (drawn plain). */
+  private liveSampling(): PhotographSampling | null {
+    const mode = this.state.mode;
+    if (mode === 'uv' || mode === 'vertex-colors') return null;
+    return this.photographSampling?.[mode] ?? null;
+  }
+
+  /** The live view has samples still to draw while nothing changes: the host keeps drawing. */
+  accumulating(): boolean {
+    const sampling = this.liveSampling();
+    if (!sampling) return false;
+    const live = this.live;
+    if (!live || live.sampling !== sampling) return true;
+    return !live.failed && live.next < live.count;
+  }
+
+  /** The stage is hidden: the live accumulation's targets go (it starts over when next shown). */
+  releaseLive(): void {
+    this.live?.dispose();
+    this.live = null;
+  }
+
+  /** The sub-pixel move of the sample being drawn, in a sampled photograph or the live view's accumulation. */
+  private captureJitter: { readonly offset: readonly [number, number]; readonly width: number; readonly height: number } | null = null;
+  /** Which sample of a sampled photograph is being drawn (0 for any other draw). */
+  private captureSample = 0;
+  /** The backdrop a sampled photograph leaves out of its samples, to lay its drawing over. */
+  private captureBackdrop: THREE.Color | null = null;
+
+  /** The sample being drawn: 0 on screen and in an unsampled photograph. A host reports a
+   *  photograph's draw once, on its first sample. */
+  photographSampleIndex(): number {
+    return this.captureSample;
+  }
+  /** The camera used for the current capture. Blender renders use the scene camera while
+   * the modeling viewport keeps its own view. */
   private cameraOverride: THREE.Camera | null = null;
   /** The document's cameras a camera view can look through (`ToolObject3DAuthoringProps.cameraView`). */
   private cameraViewSource: ToolCameraViewSource | null = null;
@@ -221,12 +287,10 @@ export class Object3DDocumentSession {
     readonly scene: THREE.Scene,
     readonly renderer: THREE.WebGLRenderer,
     readonly viewport: EditorViewport,
-    private authoring?: AuthoringAdapter,
+    private authoring: AuthoringAdapter,
     /** Asset Lab renders its neutral stage in editor chrome behind an alpha
      *  canvas; other document hosts may retain a real Three background. */
-    private neutralBackground: THREE.Color | THREE.Texture | null = new THREE.Color(0x20242a),
-    /** When set, Frame and view presets fit this box instead of the root AABB. */
-    private readonly frameBox: THREE.Box3 | null = null,
+    private neutralBackground: THREE.Color | THREE.Texture | null,
   ) {
     this.unsubscribeSelectionTheme = subscribeNativeSelectionTheme(
       renderer.domElement,
@@ -250,14 +314,14 @@ export class Object3DDocumentSession {
   private readonly axisView = (): boolean => {
     this.leaveCameraView(false);
     this.settleFlight('superseded');
-    if (activeKeymapNavigation().autoPerspective) this.setProjection('orthographic');
+    if (editorHost().keyboard.navigation().autoPerspective) this.setProjection('orthographic');
     return true;
   };
 
   /** Auto Perspective, where the keymap states it (`KeymapNavigation.autoPerspective`): a rotate
    *  that starts from an orthographic view still down an axis draws in perspective. */
   private readonly autoPerspective = (): void => {
-    if (!activeKeymapNavigation().autoPerspective || this.cameraView() !== null) return;
+    if (!editorHost().keyboard.navigation().autoPerspective || this.cameraView() !== null) return;
     if (this.state.projection !== 'orthographic') return;
     const camera = this.viewport.camera;
     const offset = camera.position.clone().sub(this.viewport.orbitControls.target);
@@ -319,12 +383,12 @@ export class Object3DDocumentSession {
   }
 
   private resolveFrameBounds(subject: 'selection' | 'all' = 'selection'): THREE.Box3 {
-    const selection = subject === 'all' ? [] : (this.authoring?.selection?.get() ?? []);
+    const selection = subject === 'all' ? [] : (this.authoring.selection?.get() ?? []);
     if (selection.length > 0) {
       const selected = new THREE.Box3();
       let found = false;
       for (const id of selection) {
-        const object = this.authoring ? threeObject(this.authoring.hierarchy, id) : null;
+        const object = threeObject(this.authoring.hierarchy, id);
         if (!object) continue;
         const bounds = contentWorldBounds(object);
         if (bounds.isEmpty()) continue;
@@ -333,15 +397,14 @@ export class Object3DDocumentSession {
       }
       if (found) return selected;
     }
-    if (this.frameBox && !this.frameBox.isEmpty()) return this.frameBox;
     return contentWorldBounds(this.root);
   }
 
   /**
-   * Frame the subject: the selection if there is one, else this document's
-   * frame box, else the whole root; `subject: 'all'` passes over the
-   * selection (Blender's View All). `fit` scales the fitted distance — 1 is
-   * the tight fit the toolbar's Frame button has always used, >1 pulls back.
+   * Frame the subject: the selection if there is one, else the whole root.
+   * `subject: 'all'` passes over selection (Blender's View All).
+   * `fit` scales the fitted distance — 1 is
+   * the toolbar's tight fit, >1 pulls back.
    */
   frame(fit = 1, subject: 'selection' | 'all' = 'selection'): boolean {
     this.leaveCameraView(false);
@@ -358,7 +421,7 @@ export class Object3DDocumentSession {
         positions += geometry.getAttribute('position')?.count ?? 0;
       });
       editorConsole.warn(
-        `frame: nothing to frame — root "${this.root.name}" (${this.root.children.length} children, ${meshes} meshes, ${positions} positions), selection ${JSON.stringify(this.authoring?.selection?.get() ?? [])}, frameBox ${this.frameBox ? (this.frameBox.isEmpty() ? 'empty' : 'set') : 'none'}`,
+        `frame: nothing to frame — root "${this.root.name}" (${this.root.children.length} children, ${meshes} meshes, ${positions} positions), selection ${JSON.stringify(this.authoring.selection?.get() ?? [])}`,
         'document',
       );
       return false;
@@ -446,6 +509,8 @@ export class Object3DDocumentSession {
       spherical.radius > 1e-4
         ? spherical.radius
         : Math.max(this.resolveFrameBounds().getSize(new THREE.Vector3()).length(), 1);
+    let settle!: CameraFlight['settle'];
+    const settled = new Promise<DocumentLookOutcome>((resolve) => { settle = resolve; });
     const flight: CameraFlight = {
       pivot,
       radius,
@@ -460,12 +525,9 @@ export class Object3DDocumentSession {
       elapsed: 0,
       theta: spherical.theta,
       phi: spherical.phi,
-      settle: null,
+      settle,
     };
     this.flight = flight;
-    const settled = new Promise<DocumentLookOutcome>((resolve) => {
-      flight.settle = resolve;
-    });
     // A zero-length move is still a move: apply it now so the pose is correct
     // even on a surface whose next frame never comes.
     this.applyFlightPose(flight, 0);
@@ -529,27 +591,27 @@ export class Object3DDocumentSession {
       elevation: Math.PI / 2 - flight.phi,
       seconds: Math.min(flight.elapsed, flight.duration),
     };
-    flight.settle?.(cancelledBy === null ? ended : { ...ended, cancelledBy });
+    flight.settle(cancelledBy === null ? ended : { ...ended, cancelledBy });
   }
 
   select(ids: readonly string[]): void {
     invalidateStages();
-    if (this.authoring) setAuthoringSelection(this.authoring, [...ids]);
+    setAuthoringSelection(this.authoring, [...ids]);
   }
 
   selection(): string[] {
-    return [...(this.authoring?.selection?.get() ?? [])];
+    return [...(this.authoring.selection?.get() ?? [])];
   }
 
   idForObject(object: THREE.Object3D): string | null {
-    return this.authoring?.hierarchy.idForObject3D?.(object) ?? null;
+    return this.authoring.hierarchy.idForNativeObject?.(object) ?? null;
   }
 
   /** Keep native hierarchy selection legible in this document's one viewport. */
   syncSelectionPresentation(): void {
     invalidateStages();
-    const selected = (this.authoring?.selection?.get() ?? [])
-      .map((id) => (this.authoring ? threeObject(this.authoring.hierarchy, id) : null))
+    const selected = (this.authoring.selection?.get() ?? [])
+      .map((id) => threeObject(this.authoring.hierarchy, id))
       .filter((object): object is THREE.Object3D => object !== null);
     this.selectedObjects = selected;
     if (this.selectionOutline) {
@@ -581,14 +643,14 @@ export class Object3DDocumentSession {
   }
 
   frameSelection(): boolean {
-    return this.frameIds(this.authoring?.selection?.get() ?? []);
+    return this.frameIds(this.authoring.selection?.get() ?? []);
   }
 
   frameIds(ids: readonly string[]): boolean {
     this.leaveCameraView(false);
     this.settleFlight('superseded');
     const objects = ids
-      .map((id) => (this.authoring ? threeObject(this.authoring.hierarchy, id) : null))
+      .map((id) => threeObject(this.authoring.hierarchy, id))
       .filter((object): object is THREE.Object3D => object !== null);
     if (objects.length === 0) return false;
     if (objects.every((object) => (object as THREE.Bone).isBone)) {
@@ -599,18 +661,7 @@ export class Object3DDocumentSession {
     return true;
   }
 
-  /**
-   * An AXIS view is ORTHOGRAPHIC, the way Blender's numpad 1/3/7 are: the
-   * reference frame for numpad 1 (`modeling-front-ortho.png`) says so in its
-   * own view text, "Front Orthographic". Ours left the stage in perspective,
-   * so a front view still showed the cube's side faces converging.
-   *
-   * `isometric` is the perspective preset (it is the stage's 3/4 opening
-   * direction, not an axis) and stays perspective. Both callers of this door
-   * already separate the two: the relay's `view-preset` maps its own
-   * `perspective` onto `isometric`, and the document toolbar's view menu
-   * carries the projection pair as its own second group — so nothing here
-   * reads an axis preset expecting perspective.
+  /** Axis presets use orthographic projection; isometric uses the stage's perspective opening.
    *
    * The pose is still solved against the PERSPECTIVE camera, because the
    * session's orthographic camera is derived from that pose every frame
@@ -734,9 +785,12 @@ export class Object3DDocumentSession {
     const pose = through.locked
       ? `${free.position.toArray().join(',')}|${free.quaternion.toArray().join(',')}`
       : '';
-    const key = `${through.camera}|${region.width}|${region.height}|${through.zoom}|${through.offset.join(',')}|${pose}`;
+    // THE SCENE'S CAMERA AS IT IS NOW, as Blender's camera view looks through `scene.camera`, which
+    // the Timeline's markers switch as the film plays; a LOCKED view keeps the camera it moves
+    const camera = through.locked ? through.camera : (source.camera() ?? through.camera);
+    const key = `${camera}|${region.width}|${region.height}|${through.zoom}|${through.offset.join(',')}|${pose}`;
     if (this.viewMemo?.key === key) return this.viewMemo.view;
-    const seen = source.view(through.camera, region, through.zoom, through.offset);
+    const seen = source.view(camera, region, through.zoom, through.offset);
     const view =
       seen && through.locked
         ? {
@@ -956,7 +1010,7 @@ export class Object3DDocumentSession {
       const leftAxis =
         axisViewName(through.left.position.clone().sub(through.left.target), through.left.up) !== null;
       const projection =
-        activeKeymapNavigation().autoPerspective && leftAxis ? 'perspective' : through.left.projection;
+        editorHost().keyboard.navigation().autoPerspective && leftAxis ? 'perspective' : through.left.projection;
       this.state = { ...this.state, projection };
     }
     viewport.camera.lookAt(viewport.orbitControls.target);
@@ -1116,8 +1170,7 @@ export class Object3DDocumentSession {
    * `wireframe` flag, which draws each RENDERABLE triangle — so a quad shows
    * its triangulation diagonal and a modeller reads noise where they expect
    * face flow. On the Asset Lab document viewport, where the mesh IS the
-   * subject, the mode instead draws neutral clay bodies (so wires behind the
-   * form are correctly occluded) under an edge overlay built with
+   * subject, the mode draws neutral clay bodies under a depth-test-free edge overlay built with
    * `EdgesGeometry`: coplanar diagonals fall out, quads read as quads.
    *
    * The overlay is editor chrome — tagged `editorHelper`, so picking, bakes
@@ -1135,11 +1188,8 @@ export class Object3DDocumentSession {
       if (!mesh.isMesh || !mesh.geometry) return;
       const line = new THREE.LineSegments(
         new THREE.EdgesGeometry(mesh.geometry, TOPOLOGY_EDGE_THRESHOLD_DEGREES),
-        // Dark on the light clay body, and DEPTH-TEST OFF. An edge sits
-        // exactly on the surface it bounds, so a depth-tested line stipples
-        // itself away in z-fighting — photographed and read before this was
-        // written. Off is also the truer read: Blender's wireframe shading
-        // shows the far side too, and the far side is half the topology.
+        // Draw dark wire edges without depth testing: coplanar lines would z-fight, and wireframe
+        // shading includes the far-side topology.
         new THREE.LineBasicMaterial({
           color: TOPOLOGY_WIRE_COLOR,
           toneMapped: false,
@@ -1258,7 +1308,7 @@ export class Object3DDocumentSession {
 
   resetPresentation(): void {
     invalidateStages();
-    // Lighting, backdrop and tone are the view's presentation (`kit/viewport-presentation`).
+    // Lighting, backdrop and tone are the view's presentation (`@volter/sdk/viewport-presentation`).
     resetViewPresentation(this.documentId);
     this.clearDiagnosticPresentation();
     this.state = INITIAL_PRESENTATION;
@@ -1275,11 +1325,9 @@ export class Object3DDocumentSession {
    *
    * The host keeps the document's own `THREE.Scene` nested inside the session's
    * rendered scene and mirrors the world dressing (environment, fog, their
-   * intensities/rotations, background) outward. That mirror used to live in the
-   * host's per-frame `animate`, so an offscreen photograph taken between two
-   * viewport ticks drew whatever the LAST tick happened to mirror — a sky set
-   * synchronously before the capture was simply missing from it. Registering it
-   * here puts `renderViewport` and `captureImage` on one path.
+   * intensities/rotations, background) outward. In a per-frame `animate` an
+   * offscreen photograph taken between two viewport ticks would miss a sky set
+   * just before the capture. Registering it here puts `renderViewport` and `captureImage` on one path.
    *
    * The host owns the step and clears it in its own teardown; the session only
    * holds the reference.
@@ -1288,26 +1336,7 @@ export class Object3DDocumentSession {
     this.beforeRender = step;
   }
 
-  /**
-   * THE PRESENTED FRAME — the stage exactly as the person is seeing it,
-   * including everything drawn OVER the document's own render: the
-   * orientation compass (`EditorViewport.renderViewCube`) above all.
-   *
-   * Why this is not {@link captureImage}: that door is an offscreen
-   * re-render of the document's content, for thumbnails and asset previews,
-   * and it deliberately draws the subject alone. The chrome door's promise is
-   * the opposite one — "photograph the editor as the person sees it" — and
-   * routing it through `captureImage` made the door LIE about this stage: the
-   * compass renders every frame into the default framebuffer (measured: the
-   * call is reached, `_threeSurfaceShowing` true, 24 objects, target=screen)
-   * and never appeared in a single chrome frame.
-   *
-   * The canvas has no `preserveDrawingBuffer`, so the only place its pixels
-   * can be read is inside the frame that drew them — which is why the host
-   * serves the request at the end of its own `animate`
-   * ({@link servePresentedFrame}), the same shape the ingest lane's
-   * `LiveSession.snapshotFrame` uses.
-   */
+  /** Capture the presented stage, including its orientation compass, at the end of animate through servePresentedFrame. captureImage separately renders document content offscreen for previews. */
   private presentedFrameWaiters: Array<(frame: HTMLCanvasElement | null) => void> = [];
   /** True while a host render loop is servicing {@link servePresentedFrame}. */
   private presentsFrames = false;
@@ -1334,8 +1363,8 @@ export class Object3DDocumentSession {
         resolve(frame);
       };
       this.presentedFrameWaiters.push(once);
-      // A stage that draws on change draws for this request.
-      invalidateStages();
+      // A stage that draws on change draws for this request (`needsFrame`); it is not a change
+      // to the picture, so the stages are not invalidated (a live accumulation goes on).
       setTimeout(() => once(null), PRESENTED_FRAME_WAIT_MS);
     });
   }
@@ -1372,6 +1401,16 @@ export class Object3DDocumentSession {
   render(renderSolid: (camera: THREE.Camera) => void, interactive = false): void {
     const finishDraw = this.beforeRender?.(interactive);
     const restoreDepthDraw = this.depthDrawMaterials.bind(this.renderer);
+    // A sampled photograph's jitter moves the projection of the camera the scene is drawn with,
+    // AFTER the source prepared its draw (shadow fits stay put), and stays on through the source's
+    // own finishing passes (Blender's outline is drawn per sample).
+    const jitter = this.captureJitter;
+    const jittered: { restore: (() => void) | null } = { restore: null };
+    const unjittered = renderSolid;
+    renderSolid = (camera) => {
+      if (jitter && !jittered.restore) jittered.restore = jitterProjection(camera, jitter.offset, jitter.width, jitter.height);
+      unjittered(camera);
+    };
     try {
       this.boneSelectionHighlight?.update();
       const camera = this.camera();
@@ -1406,8 +1445,7 @@ export class Object3DDocumentSession {
           }
           return;
         }
-        // Clay bodies, not the triangle-wireframe swap: the overlay IS the wire,
-        // and the solid form behind it is what occludes the far side.
+        // Draw clay bodies beneath the edge overlay, including far-side wires.
         this.shading.render(
           this.scene,
           'clay',
@@ -1419,14 +1457,30 @@ export class Object3DDocumentSession {
       this.shading.render(this.scene, mode, () => renderSolid(camera), isEditorViewportShadingTarget);
     } finally {
       restoreDepthDraw();
-      finishDraw?.();
+      try {
+        finishDraw?.();
+      } finally {
+        jittered.restore?.();
+      }
     }
   }
 
-  /** Visible authoring draw with the editor-only native selection silhouette. */
-  renderViewport(deltaSeconds = 0, interactive = false): void {
+  /** Visible authoring draw with the editor-only native selection silhouette. `still`: nothing
+   *  has changed since the host's last drawn frame, so the live accumulation goes on; `revision`
+   *  names the state of the content the host drew it at. */
+  renderViewport(deltaSeconds = 0, interactive = false, still = false, revision = ''): void {
     this.advanceLook(deltaSeconds);
     this.ensureComposer();
+    const sampling = this.liveSampling();
+    if (sampling && still && this.flight === null) {
+      if (this.renderLiveFrame(sampling, revision)) return;
+      // The sum is not yet better than the ordinary frame (or failed): the ordinary frame, at full
+      // detail, without starting the sum over.
+      interactive = false;
+    } else {
+      // Something changed: this frame is drawn plain, and the next still one starts over.
+      this.live?.restart();
+    }
     const transform = this.materialDisplayTransform();
     if (transform) {
       const size = this.renderer.getDrawingBufferSize(new THREE.Vector2());
@@ -1461,6 +1515,104 @@ export class Object3DDocumentSession {
     }, interactive);
   }
 
+  /**
+   * One more sample of the live accumulation, and the picture so far on screen once it is at least
+   * as good as the ordinary frame; once every sample is in, the finished picture again (a redraw
+   * with nothing changed: a presented-frame request). A sample is drawn as a photograph's is
+   * (`captureImage`): the projection moved by its offset after the source prepared its draw, a flat
+   * backdrop left out and merged under the sum. Answers false when the caller is to draw the
+   * ordinary frame instead.
+   */
+  private renderLiveFrame(sampling: PhotographSampling, revision: string): boolean {
+    const size = this.renderer.getDrawingBufferSize(new THREE.Vector2());
+    let live = this.live;
+    if (!live || live.sampling !== sampling || live.width !== size.x || live.height !== size.y) {
+      live?.dispose();
+      live = this.live = new LiveAccumulation(sampling, size.x, size.y);
+    }
+    if (live.failed) return false;
+    // A sum drawn under another state of the content is neither added to nor shown.
+    if (live.next > 0 && live.revision !== revision) live.restart();
+    const transform = this.materialDisplayTransform();
+    const previous = this.renderer.getRenderTarget();
+    try {
+      if (live.next < live.count) {
+        const index = live.next;
+        const { accumulation, sampleTarget } = live.working(this.renderer);
+        if (index === 0) {
+          accumulation.clear(this.renderer);
+          live.backdrop = null;
+          live.revision = revision;
+        }
+        const offset = accumulation.offsets[index]!;
+        const mergeBackdrop = sampling.backdropMerge && !transform && this.renderer.toneMapping === THREE.NoToneMapping;
+        // The first still frame draws the shadow maps for what it shows; the rest reuse them.
+        const shadowsUpdate = this.renderer.shadowMap.autoUpdate;
+        this.renderer.shadowMap.autoUpdate = shadowsUpdate && index === 0;
+        this.captureBackdrop = null;
+        this.captureJitter = {
+          offset: [offset[0] * sampling.projectionScale, offset[1] * sampling.projectionScale],
+          width: size.x, height: size.y,
+        };
+        try {
+          this.renderer.setRenderTarget(sampleTarget);
+          this.renderCapture(
+            (camera) => this.renderLinearScene(camera, sampleTarget),
+            false,
+            mergeBackdrop && (index === 0 || live.backdrop !== null),
+          );
+        } finally {
+          this.captureJitter = null;
+          this.renderer.shadowMap.autoUpdate = shadowsUpdate;
+        }
+        if (index === 0) live.backdrop = this.captureBackdrop;
+        this.captureBackdrop = null;
+        accumulation.add(this.renderer, sampleTarget.texture, offset);
+        live.next = index + 1;
+        const drawing = accumulation.resolve(this.renderer);
+        if (live.next < live.count) {
+          if (live.next < live.showFrom) return false;
+          this.presentLiveSum(live, drawing, transform, previous);
+          return true;
+        }
+        // Complete: the picture as shown is kept and the working targets go.
+        this.presentLiveSum(live, drawing, transform, live.finishedTarget());
+        live.releaseWorking();
+      }
+      if (!live.finished) return false;
+      live.blitFinished(this.renderer, previous);
+      return true;
+    } catch (error) {
+      // An accumulation that fails ends: the ordinary frame from here on, until something changes.
+      live.failed = true;
+      live.releaseWorking();
+      if (!this.liveFailureReported) {
+        this.liveFailureReported = true;
+        editorConsole.warn(
+          `live view: the accumulation failed and the view draws without it until it changes — ${
+            error instanceof Error ? error.message : String(error)}`,
+          'document',
+        );
+      }
+      return false;
+    } finally {
+      this.renderer.setRenderTarget(previous);
+    }
+  }
+
+  /** The resolved sum through the view (merged over its backdrop, or the display transform, or
+   *  the output pass) into `target` (null: the canvas). */
+  private presentLiveSum(
+    live: LiveAccumulation,
+    drawing: THREE.WebGLRenderTarget,
+    transform: DocumentDisplayTransform | null,
+    target: THREE.WebGLRenderTarget | null,
+  ): void {
+    if (live.backdrop) live.working(this.renderer).accumulation.merge(this.renderer, drawing, live.backdrop, target);
+    else if (transform) transform.render(this.renderer, drawing, target, false);
+    else viewportCaptureOutputPass(false).render(this.renderer, target as THREE.WebGLRenderTarget, drawing, 0, false);
+  }
+
   resize(width: number, height: number): void {
     invalidateStages();
     this.renderWidth = Math.max(1, width);
@@ -1468,15 +1620,25 @@ export class Object3DDocumentSession {
     this.composer?.setSize(this.renderWidth, this.renderHeight);
   }
 
-  private renderCapture(renderSolid: (camera: THREE.Camera) => void, transparent: boolean): void {
+  private renderCapture(
+    renderSolid: (camera: THREE.Camera) => void,
+    transparent: boolean,
+    /**
+     * Retain a flat-color backdrop separately for composition beneath accumulated samples. Read it
+     * after the host mirrors the current dressing into the scene.
+     */
+    leaveColorBackdrop = false,
+  ): void {
     this.render((camera) => {
-      if (!transparent) {
-        renderSolid(camera);
-        return;
-      }
       // Apply after the host mirrors its world into this scene. Environment
       // lighting stays intact; only the camera background is omitted.
       const background = this.scene.background;
+      const leaveBackdrop = !transparent && leaveColorBackdrop && (background as THREE.Color | null)?.isColor === true;
+      if (!transparent && !leaveBackdrop) {
+        renderSolid(camera);
+        return;
+      }
+      if (leaveBackdrop) this.captureBackdrop = (background as THREE.Color).clone();
       const clearColor = this.renderer.getClearColor(new THREE.Color());
       const clearAlpha = this.renderer.getClearAlpha();
       try {
@@ -1491,18 +1653,9 @@ export class Object3DDocumentSession {
   }
 
   /**
-   * Fresh offscreen capture through this document's own renderer and
-   * diagnostic pipeline. This does not depend on preserveDrawingBuffer and
-   * therefore remains truthful after the visible canvas has presented.
-   *
-   * A NUMBER is a square of that size — the default shape, and the right one
-   * for an unstaged look at a model. `{width, height}` renders the buffer AND
-   * the camera at that aspect, so a video-shaped look comes back already
-   * shaped instead of square-and-cropped. Whatever the shape, the camera is
-   * matched to the BUFFER for the duration: rendering the panel's aspect
-   * through a square buffer is what photographed a cube as a tall thin prism
-   * on a 3.05:1 document panel, through the one look instrument an agent has.
-   * The visible viewport is never touched.
+   * Capture offscreen through this document’s renderer and diagnostic pipeline without
+   * preserveDrawingBuffer. A number requests a square; width and height request a matching camera
+   * aspect and buffer for the capture duration. Keep the visible viewport unchanged.
    */
   captureImage(
     size:
@@ -1521,8 +1674,12 @@ export class Object3DDocumentSession {
     if (!Number.isFinite(requestedHeight) || requestedHeight < 1) return null;
     const outputWidth = Math.min(2048, Math.round(requestedWidth));
     const outputHeight = Math.min(2048, Math.round(requestedHeight));
-    const renderWidth = outputWidth * 2;
-    const renderHeight = outputHeight * 2;
+    const mode = this.state.mode;
+    const sampling = (mode !== 'uv' && mode !== 'vertex-colors' ? this.photographSampling?.[mode] : undefined) ?? null;
+    // A sampled photograph is drawn at its own size, once per sample; otherwise at twice it.
+    const scale = sampling ? 1 : 2;
+    const renderWidth = outputWidth * scale;
+    const renderHeight = outputHeight * scale;
     // Three disables material tone mapping on ordinary render targets. A
     // byte target clips lit surfaces to white before display conversion can
     // recover them. Keep HDR values, then use the same output resolve as the
@@ -1533,28 +1690,84 @@ export class Object3DDocumentSession {
     const transform = this.materialDisplayTransform();
     const target = new THREE.WebGLRenderTarget(transform ? outputWidth : renderWidth, transform ? outputHeight : renderHeight);
     let resolved: THREE.WebGLRenderTarget | null = null;
+    const accumulation = sampling ? new PhotographAccumulation(sampling, outputWidth, outputHeight, this.renderer) : null;
     const previousTarget = this.renderer.getRenderTarget();
     const perspective = this.viewport.camera;
     const previousAspect = perspective.aspect;
     try {
       this.captureAspect = outputWidth / outputHeight;
+      this.capturePixelScale = scale;
       const override = typeof size === 'number' ? undefined : size.camera;
       if (override) this.cameraOverride = override;
       else {
         perspective.aspect = outputWidth / outputHeight;
         perspective.updateProjectionMatrix();
       }
-      this.renderer.setRenderTarget(sceneTarget);
-      this.renderCapture(
-        (camera) => this.renderSolidForCapture(camera, sceneTarget, renderWidth, renderHeight),
-        typeof size !== 'number' && size.transparent === true,
-      );
-      const straightAlpha = typeof size !== 'number' && size.transparent === true;
-      if (transform) {
-        resolved = resolveSceneLinearSize(this.renderer, sceneTarget, outputWidth, outputHeight);
-        transform.render(this.renderer, resolved, target, straightAlpha);
+      const transparentCapture = typeof size !== 'number' && size.transparent === true;
+      let merged = false;
+      if (accumulation && sampling) {
+        // The composer's buffers take the photograph's size once, not once per sample.
+        const sizedComposer = this.sizeComposerForCapture(renderWidth, renderHeight);
+        // The shadow maps the first sample drew serve them all: the jitter moves only the
+        // projection, after the source fitted its shadows to the unmoved camera.
+        const shadowsUpdate = this.renderer.shadowMap.autoUpdate;
+        try {
+          // Merged over its backdrop after the samples, as Blender's viewport does: each sample is
+          // drawn with none when the backdrop is a flat colour (an opaque photograph of a
+          // transparent drawing is laid over it below). The first sample decides; the rest follow.
+          // The merge writes the display encoding itself; under a tone-mapping renderer the
+          // drawing goes through the output pass as any other.
+          const mergeBackdrop = sampling.backdropMerge && !transparentCapture && !transform &&
+            this.renderer.toneMapping === THREE.NoToneMapping;
+          this.captureBackdrop = null;
+          accumulation.clear(this.renderer);
+          accumulation.offsets.forEach((offset, index) => {
+            this.captureSample = index;
+            this.renderer.shadowMap.autoUpdate = shadowsUpdate && index === 0;
+            this.captureJitter = {
+              offset: [offset[0] * sampling.projectionScale, offset[1] * sampling.projectionScale],
+              width: renderWidth, height: renderHeight,
+            };
+            this.renderer.setRenderTarget(sceneTarget);
+            this.renderCapture(
+              (camera) => this.renderSolidForCapture(camera, sceneTarget, renderWidth, renderHeight, sizedComposer),
+              transparentCapture,
+              mergeBackdrop && (index === 0 || this.captureBackdrop !== null),
+            );
+            this.captureJitter = null;
+            accumulation.add(this.renderer, sceneTarget.texture, offset);
+          });
+          const drawing = accumulation.resolve(this.renderer);
+          if (mergeBackdrop && this.captureBackdrop) {
+            accumulation.merge(this.renderer, drawing, this.captureBackdrop, target);
+            merged = true;
+          }
+          resolved = null;
+          if (!merged) {
+            if (transform) transform.render(this.renderer, drawing, target, transparentCapture);
+            else viewportCaptureOutputPass(transparentCapture).render(this.renderer, target, drawing, 0, false);
+            merged = true;
+          }
+        } finally {
+          this.captureSample = 0;
+          this.renderer.shadowMap.autoUpdate = shadowsUpdate;
+          if (sizedComposer) this.restoreComposerAfterCapture(sizedComposer);
+        }
+      } else {
+        this.renderer.setRenderTarget(sceneTarget);
+        this.renderCapture(
+          (camera) => this.renderSolidForCapture(camera, sceneTarget, renderWidth, renderHeight),
+          transparentCapture,
+        );
+      }
+      const straightAlpha = transparentCapture;
+      if (!merged) {
+        if (transform) {
+          resolved = resolveSceneLinearSize(this.renderer, sceneTarget, outputWidth, outputHeight);
+          transform.render(this.renderer, resolved, target, straightAlpha);
+        }
+        else viewportCaptureOutputPass(straightAlpha).render(this.renderer, target, sceneTarget, 0, false);
       }
-      else viewportCaptureOutputPass(straightAlpha).render(this.renderer, target, sceneTarget, 0, false);
 
       const rowBytes = target.width * 4;
       const pixels = new Uint8Array(rowBytes * target.height);
@@ -1580,6 +1793,10 @@ export class Object3DDocumentSession {
       return output.toDataURL('image/png');
     } finally {
       this.captureAspect = null;
+      this.capturePixelScale = null;
+      this.captureJitter = null;
+      this.captureBackdrop = null;
+      accumulation?.dispose();
       this.cameraOverride = null;
       perspective.aspect = previousAspect;
       perspective.updateProjectionMatrix();
@@ -1612,6 +1829,8 @@ export class Object3DDocumentSession {
     if (this.selectionOutline)
       releaseThreeSelectionOutline(this.renderer, this.selectionOutline, this.selectionOutlinePass);
     this.composer?.dispose();
+    this.live?.dispose();
+    this.live = null;
     this.displayTarget?.dispose();
     this.displayTarget = null;
     this.displayTransform = null;
@@ -1631,34 +1850,8 @@ export class Object3DDocumentSession {
     this.helpers.push(helper);
   }
 
-  /**
-   * THE LAZY DOOR for `postprocessing` (~200 kB of passes and shaders).
-   *
-   * The composer exists for ONE feature — the editor-owned selection
-   * silhouette; `syncComposerOutput` hands the screen back to the plain scene
-   * pass whenever nothing is outlined — so the library belongs with the first
-   * frame of this document, not with the module that draws it. Everything an
-   * Asset Lab document does before that first frame (mount, adopt, frame the
-   * content) is untouched by it.
-   *
-   * Called from every `renderViewport`, so it must be cheap and re-entrant:
-   * `composerLoading` keeps exactly one import in flight, and the continuation
-   * re-checks `disposed` because a document can close mid-load.
-   */
-  /**
-   * WHETHER THIS DOCUMENT DRAWS THE SELECTION SILHOUETTE AT ALL — a LIVE
-   * switch, not just a construction-time one.
-   *
-   * Two callers turn it off, for different reasons. The inspector's preview
-   * lane shows a subject with nothing selectable inside it, so it never needs
-   * the pass — or the effect it would build per selection — and says so once.
-   * A modeling document says so whenever it is in EDIT mode: Blender draws no
-   * object outline there (`modeling-edit-all.png`), and the silhouette
-   * otherwise follows the hierarchy selection straight through the mode
-   * change. That second caller flips it while the composer is already built,
-   * so turning it off must drop the outline the composer is currently drawing
-   * — gating construction alone leaves the frame exactly as it was.
-   */
+  /** Enable the selection silhouette. Preview-only subjects and Edit mode
+   * disable it; changing this also clears any already-built outline. */
   get selectionOutlineEnabled(): boolean {
     return this.selectionOutlineWanted;
   }
@@ -1673,7 +1866,6 @@ export class Object3DDocumentSession {
   }
   private selectionOutlineWanted = true;
 
-  /** Whether the view draws its selected objects' origins (`overlays.selection.origins`). */
   /** The view's X-ray for its current draw mode (`ViewportModePresentation.xray`). */
   private xray: ViewportXray = { enabled: false, alpha: 1 };
 
@@ -1683,6 +1875,7 @@ export class Object3DDocumentSession {
     invalidateStages();
   }
 
+  /** Whether the view draws selected-object origins (`overlays.selection.origins`). */
   set selectionOriginsEnabled(value: boolean) {
     if (value === (this.selectionOrigins !== null)) return;
     if (value) {
@@ -1696,6 +1889,8 @@ export class Object3DDocumentSession {
     }
   }
 
+  /** Lazily import and construct the selection-outline composer. Keep one
+   * import in flight and discard its result if the document closes. */
   private ensureComposer(): void {
     if (!this.selectionOutlineWanted) return;
     if (this.composer || this.composerLoading || this.disposed) return;
@@ -1735,35 +1930,15 @@ export class Object3DDocumentSession {
       });
   }
 
-  /**
-   * EffectComposer marks the last added pass as the screen output. Disabling
-   * that pass without transferring screen ownership to the scene pass leaves
-   * the unoutlined frame stranded in the composer's offscreen buffer. Keep
-   * selection responsible only for the outline, never for whether the asset
-   * itself reaches the canvas.
-   */
-  /**
-   * Draw the scene FOR A PHOTOGRAPH into `target` the way the screen sees it:
-   * through the outline pass when a selection silhouette is on (the outline is
-   * a pass, absent from a plain draw — a capture without it lied about the
-   * screen), the plain draw otherwise.
-   *
-   * The two passes are driven DIRECTLY rather than through `composer.render()`,
-   * because neither of the composer's own doors says where a frame landed:
-   * `EffectComposer.render` ping-pongs LOCAL variables and never reassigns
-   * `inputBuffer`/`outputBuffer`, and `CopyPass.render` ignores its
-   * `outputBuffer` argument entirely (it always writes to its own render
-   * target, 1x1 unless the composer sized it). Going through them wrote the
-   * photograph nowhere — every capture of a selected object came back empty.
-   * A pass's own contract is exact: `RenderPass` draws the scene into the
-   * `inputBuffer` it is handed, `EffectPass` reads that and writes the
-   * `outputBuffer` it is handed — so hand the outline pass the capture target.
-   */
+  /** Capture through the current scene and outline passes. Resize only the
+   * composer's offscreen buffers, then restore their live dimensions. */
   private renderSolidForCapture(
     camera: THREE.Camera,
     target: THREE.WebGLRenderTarget,
     width: number,
     height: number,
+    /** The composer is already at the photograph's size (a sampled photograph sized it once). */
+    sized: { readonly width: number; readonly height: number } | null = null,
   ): void {
     const composer = this.composer;
     const outlined = (this.selectionOutline?.selection.size ?? 0) > 0;
@@ -1771,6 +1946,14 @@ export class Object3DDocumentSession {
       this.renderLinearScene(camera, target);
       return;
     }
+    if (sized) {
+      try {
+        this.renderLinearScene(camera, target);
+      } finally {
+        this.renderer.setRenderTarget(target);
+      }
+      return;
+    }
     const previousSize = this.renderer.getDrawingBufferSize(new THREE.Vector2());
     try {
       this.resizeComposerBuffers(width, height);
@@ -1782,6 +1965,21 @@ export class Object3DDocumentSession {
     }
   }
 
+  /** A sampled photograph's composer sizing, once for all its samples; null when the capture
+   *  does not draw through the composer (nothing is outlined). */
+  private sizeComposerForCapture(width: number, height: number): { readonly width: number; readonly height: number } | null {
+    const outlined = (this.selectionOutline?.selection.size ?? 0) > 0;
+    if (!this.composer || !outlined || !this.sceneRenderPass || !this.selectionOutlinePass) return null;
+    const previous = this.renderer.getDrawingBufferSize(new THREE.Vector2());
+    this.resizeComposerBuffers(width, height);
+    return { width: previous.x, height: previous.y };
+  }
+
+  private restoreComposerAfterCapture(previous: { readonly width: number; readonly height: number }): void {
+    this.resizeComposerBuffers(previous.width, previous.height);
+    this.syncComposerOutput();
+  }
+
   /** Offscreen sizing must not call EffectComposer.setSize: it also resizes
    * the renderer's visible canvas, clearing the frame a human is watching. */
   private resizeComposerBuffers(width: number, height: number): void {
@@ -1823,6 +2021,7 @@ export class Object3DDocumentSession {
     }
   }
 
+  /** Route screen output through the outline pass only while it has a selection. */
   private syncComposerOutput(): void {
     const outlined = (this.selectionOutline?.selection.size ?? 0) > 0;
     if (this.sceneRenderPass) this.sceneRenderPass.renderToScreen = !outlined;
@@ -1945,30 +2144,7 @@ export class Object3DDocumentSession {
   }
 }
 
-// Compatibility for existing internal callers/tests; lookup-only consumers
-// import the registry directly so they do not pull this implementation graph.
-export {
-  __resetObject3DDocumentSessionsForTest,
-  allObject3DDocumentSessions,
-  object3DDocumentSession,
-  object3DDocumentSessionsVersion,
-  registerObject3DDocumentSession,
-  subscribeObject3DDocumentSessions,
-} from './object3d-document-session-registry';
 
-/**
- * OBJECT ORIGINS: a dot at the origin of each selected object, drawn over everything at a fixed
- * pixel size — Blender's "Origins" overlay (`overlays.selection.origins` in
- * `@volter/sdk/kit/viewport-presentation`). Blender draws it one pixel wider than its
- * Object Origin Size (default 6; `overlay_instance.cc`: `obcenter_dia + 1`) with a one-pixel
- * dark rim, and in the active object's
- * colour for the active object; the kit's rule for the active colour stands in for that: a lone
- * selected object is shown in the look's active colour, several in its selection colour, the
- * same rule the outline follows.
- *
- * The positions are read from each object's world matrix as the frame is drawn, so a dot follows
- * a drag without the selection having to change.
- */
 /** Blender's drawn origin diameter at the default Object Origin Size, in CSS pixels. three
  *  scales a point's size by the pixel ratio itself (`WebGLMaterials.refreshUniformsPoints`). */
 const ORIGIN_SIZE_PX = 7;
@@ -1995,6 +2171,8 @@ function originDotTexture(): THREE.Texture {
   return dotTexture;
 }
 
+/** Draw selected-object origins at a fixed pixel size, using each object's
+ * current world matrix and the active/selection colors. */
 class SelectionOrigins extends THREE.Points<THREE.BufferGeometry, THREE.PointsMaterial> {
   private objects: readonly THREE.Object3D[] = [];
   private readonly origin = new THREE.Vector3();
@@ -2056,3 +2234,88 @@ class SelectionOrigins extends THREE.Points<THREE.BufferGeometry, THREE.PointsMa
     this.material.dispose();
   }
 }
+
+/**
+ * The live view's accumulation (`Object3DDocumentSession.renderLiveFrame`). Its working targets
+ * (the sample, the sum) are half precision, made on the first sample and freed when the sum is
+ * complete; the finished picture is kept display-encoded, 4 bytes a pixel.
+ */
+class LiveAccumulation {
+  /** The next sample to draw: 0 starts over, `count` is done. */
+  next = 0;
+  /** The content revision the sum was begun at. */
+  revision: string | null = null;
+  /** The flat backdrop the samples leave out, to merge the sum over; null when drawn in. */
+  backdrop: THREE.Color | null = null;
+  /** The finished picture as shown, once every sample is in. */
+  finished: THREE.WebGLRenderTarget | null = null;
+  /** A failure ended the accumulation; cleared by the next change. */
+  failed = false;
+  readonly count: number;
+  /** The sum is shown from this many samples on; the ordinary frame before. */
+  readonly showFrom: number;
+  private accumulation: PhotographAccumulation | null = null;
+  private sampleTarget: THREE.WebGLRenderTarget | null = null;
+  private readonly copy = new FullScreenQuad(new THREE.RawShaderMaterial({
+    name: 'Live view finished picture', glslVersion: THREE.GLSL3, depthTest: false, depthWrite: false,
+    blending: THREE.NoBlending, uniforms: { picture: { value: null } },
+    vertexShader: `precision highp float; in vec3 position; in vec2 uv; out vec2 vUv;
+      void main(){vUv=uv;gl_Position=vec4(position,1.0);}`,
+    fragmentShader: `precision highp float; uniform sampler2D picture; in vec2 vUv; out vec4 outputColor;
+      void main(){outputColor=texelFetch(picture, ivec2(vUv * vec2(textureSize(picture, 0))), 0);}`,
+  }));
+
+  constructor(readonly sampling: PhotographSampling, readonly width: number, readonly height: number) {
+    this.count = Math.min(sampling.offsets.length, PHOTOGRAPH_SAMPLE_CAP);
+    this.showFrom = Math.min(this.count, Math.max(1, sampling.liveFrom ?? this.count));
+  }
+
+  /** The working targets, made on demand. */
+  working(renderer: THREE.WebGLRenderer): { accumulation: PhotographAccumulation; sampleTarget: THREE.WebGLRenderTarget } {
+    this.accumulation ??= new PhotographAccumulation(this.sampling, this.width, this.height, renderer, 'half');
+    this.sampleTarget ??= new THREE.WebGLRenderTarget(this.width, this.height, { type: THREE.HalfFloatType });
+    return { accumulation: this.accumulation, sampleTarget: this.sampleTarget };
+  }
+
+  finishedTarget(): THREE.WebGLRenderTarget {
+    this.finished ??= new THREE.WebGLRenderTarget(this.width, this.height, { depthBuffer: false });
+    return this.finished;
+  }
+
+  blitFinished(renderer: THREE.WebGLRenderer, target: THREE.WebGLRenderTarget | null): void {
+    if (!this.finished) return;
+    (this.copy.material as THREE.RawShaderMaterial).uniforms['picture']!.value = this.finished.texture;
+    const autoClear = renderer.autoClear;
+    renderer.setRenderTarget(target);
+    renderer.autoClear = false;
+    try {
+      this.copy.render(renderer);
+    } finally {
+      renderer.autoClear = autoClear;
+    }
+  }
+
+  /** A change: the next still frame begins a new sum. */
+  restart(): void {
+    this.next = 0;
+    this.revision = null;
+    this.failed = false;
+    this.finished?.dispose();
+    this.finished = null;
+  }
+
+  releaseWorking(): void {
+    this.accumulation?.dispose();
+    this.accumulation = null;
+    this.sampleTarget?.dispose();
+    this.sampleTarget = null;
+  }
+
+  dispose(): void {
+    this.releaseWorking();
+    this.finished?.dispose();
+    this.finished = null;
+    this.copy.material.dispose();
+    this.copy.dispose();
+  }
+}