@volter/editor-threejs 0.5.192 → 0.5.194

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@volter/editor-threejs",
   "author": "Volter AI, Inc.",
-  "version": "0.5.192",
+  "version": "0.5.194",
   "publishConfig": {
     "access": "public"
   },
@@ -135,12 +135,12 @@
     "serving": "./dist-node/serving.mjs"
   },
   "dependencies": {
-    "@volter/editor-project": "0.5.192",
+    "@volter/editor-project": "0.5.194",
     "@sparkjsdev/spark": "^2.1.0",
     "three.quarks": "^0.16.0",
     "zod": "^4.3.6",
     "typescript": "5.9.3",
-    "@volter/editor-sdk": "0.5.192",
+    "@volter/editor-sdk": "0.5.194",
     "postprocessing": "6.38.3",
     "quarks.core": "0.16.0",
     "@fortawesome/free-solid-svg-icons": "^7.2.0"

package/src/capture/scene.ts

@@ -12,6 +12,9 @@ export interface SceneCaptureOptions {
   transparent?: boolean;
   toneMapping?: THREE.ToneMapping;
   exposure?: number;
+  /** Caller-owned draw resources for this renderer/camera. The returned
+   * cleanup runs after success or failure, before releasing the renderer. */
+  prepareDraw?: (renderer:THREE.WebGLRenderer,camera:THREE.Camera)=>void|(()=>void);
   /** Integration-owned GPU display resolve, shared with its live viewport. */
   displayTransform?: DocumentDisplayTransform;
   /** Caller-owned scene-linear effect. The input carries a depth texture;
@@ -75,6 +78,7 @@ function capture(
   let display: THREE.WebGLRenderTarget | undefined;
   let displayInput: THREE.WebGLRenderTarget | undefined;
   let completed = false;
+  let finishDraw:(()=>void)|void=undefined;
   try {
     hdr = new THREE.WebGLRenderTarget(renderWidth, renderHeight, { type: THREE.HalfFloatType });
     if (options.effect) hdr.depthTexture = new THREE.DepthTexture(renderWidth, renderHeight);
@@ -86,6 +90,7 @@ function capture(
     renderer.setClearColor(0, options.transparent ? 0 : 1);
     if (options.transparent) scene.background = null;
     renderer.setRenderTarget(hdr);
+    finishDraw=options.prepareDraw?.(renderer,camera);
     renderer.clear();
     renderer.render(scene, camera);
     const resolved = options.effect?.render(renderer, hdr, scene, camera) ?? hdr;
@@ -128,18 +133,20 @@ function capture(
     completed = true;
     return imageUrl;
   } finally {
-    scene.background = previous.background;
-    renderer.setRenderTarget(previous.target);
-    renderer.toneMapping = previous.toneMapping;
-    renderer.toneMappingExposure = previous.exposure;
-    renderer.outputColorSpace = previous.colorSpace;
-    renderer.shadowMap.enabled = previous.shadows;
-    renderer.shadowMap.type = previous.shadowType;
-    renderer.setClearColor(previous.clearColor, previous.clearAlpha);
-    display?.dispose();
-    displayInput?.dispose();
-    hdr?.dispose();
-    lease.release({ discard: !completed });
+    try {finishDraw?.();} finally {
+      scene.background = previous.background;
+      renderer.setRenderTarget(previous.target);
+      renderer.toneMapping = previous.toneMapping;
+      renderer.toneMappingExposure = previous.exposure;
+      renderer.outputColorSpace = previous.colorSpace;
+      renderer.shadowMap.enabled = previous.shadows;
+      renderer.shadowMap.type = previous.shadowType;
+      renderer.setClearColor(previous.clearColor, previous.clearAlpha);
+      display?.dispose();
+      displayInput?.dispose();
+      hdr?.dispose();
+      lease.release({ discard: !completed });
+    }
   }
 }
 

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

@@ -1534,7 +1534,6 @@ export class Object3DDocumentSession {
     const target = new THREE.WebGLRenderTarget(transform ? outputWidth : renderWidth, transform ? outputHeight : renderHeight);
     let resolved: THREE.WebGLRenderTarget | null = null;
     const previousTarget = this.renderer.getRenderTarget();
-    const previousPixelRatio = this.renderer.getPixelRatio();
     const perspective = this.viewport.camera;
     const previousAspect = perspective.aspect;
     try {
@@ -1545,7 +1544,6 @@ export class Object3DDocumentSession {
         perspective.aspect = outputWidth / outputHeight;
         perspective.updateProjectionMatrix();
       }
-      this.renderer.setPixelRatio(1);
       this.renderer.setRenderTarget(sceneTarget);
       this.renderCapture(
         (camera) => this.renderSolidForCapture(camera, sceneTarget, renderWidth, renderHeight),
@@ -1586,21 +1584,11 @@ export class Object3DDocumentSession {
       perspective.aspect = previousAspect;
       perspective.updateProjectionMatrix();
       this.renderer.setRenderTarget(previousTarget);
-      this.renderer.setPixelRatio(previousPixelRatio);
-      // THE COMPOSER IS SIZED AGAIN AT THE DISPLAY'S RATIO. The capture's own draw restores the
-      // composer's size while the ratio is still 1 (`renderSolidForCapture`), and the composer
-      // sizes its buffers from the renderer's drawing buffer: every capture (a selection's
-      // preview takes one) left the view and its outline mask at CSS resolution until the next
-      // resize. Measured on the stage: a crisp outline stating 4 device px drew 10 right after a
-      // selection and 4 after a repaint that resized.
-      this.composer?.setSize(this.renderWidth, this.renderHeight, false);
       target.dispose();
       resolved?.dispose();
       sceneTarget.dispose();
-      // AND THE VIEW IS DRAWN AGAIN. Sizing the composer clears what the view showed, and a stage
-      // that draws on demand had nothing asking it to: on the browser-substrate page every photograph
-      // (Save Screenshot, an agent's get_viewport_screenshot) left the viewport a flat grey until the
-      // pointer next moved over it (measured 2026-09-28: stddev 0 across the view, restored on hover).
+      // Refresh any draw-time state after the offscreen photograph. Neither
+      // renderer pixel ratio nor canvas dimensions change during capture.
       invalidateStages();
     }
   }
@@ -1780,21 +1768,30 @@ export class Object3DDocumentSession {
     const composer = this.composer;
     const outlined = (this.selectionOutline?.selection.size ?? 0) > 0;
     if (!composer || !outlined || !this.sceneRenderPass || !this.selectionOutlinePass) {
-      this.renderer.render(this.scene, camera);
+      this.renderLinearScene(camera, target);
       return;
     }
-    const previousWidth = this.renderWidth;
-    const previousHeight = this.renderHeight;
+    const previousSize = this.renderer.getDrawingBufferSize(new THREE.Vector2());
     try {
-      composer.setSize(width, height, false);
+      this.resizeComposerBuffers(width, height);
       this.renderLinearScene(camera, target);
     } finally {
-      composer.setSize(previousWidth, previousHeight, false);
+      this.resizeComposerBuffers(previousSize.x, previousSize.y);
       this.syncComposerOutput();
       this.renderer.setRenderTarget(target);
     }
   }
 
+  /** 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 {
+    const composer = this.composer;
+    if (!composer) return;
+    composer.inputBuffer.setSize(width, height);
+    composer.outputBuffer.setSize(width, height);
+    for (const pass of composer.passes) pass.setSize(width, height);
+  }
+
   /** Live HDR draw at the renderer's CURRENT size. Resizing the composer with
    * device pixels here would resize the canvas and multiply HiDPI twice on
    * every frame. Only an offscreen photograph changes its sizing. */
@@ -1802,10 +1799,20 @@ export class Object3DDocumentSession {
     const composer = this.composer;
     const outlined = (this.selectionOutline?.selection.size ?? 0) > 0;
     if (!composer || !outlined || !this.sceneRenderPass || !this.selectionOutlinePass) {
+      // EffectComposer disables renderer.autoClear when it is created. This
+      // direct path owns a whole scene frame too, including an unselected HDR
+      // viewport and plain photographs, so it must clear its previous depth.
+      this.renderer.setRenderTarget(target);
+      this.renderer.clear(true, true, false);
       this.renderer.render(this.scene, camera);
       return;
     }
     try {
+      // These passes are driven directly rather than by composer.render().
+      // Update both passes to the drawing camera, including native camera views
+      // and offscreen captures; the composer's previous free camera can differ.
+      composer.setMainScene(this.scene);
+      composer.setMainCamera(camera);
       this.sceneRenderPass.renderToScreen = false;
       this.selectionOutlinePass.renderToScreen = false;
       this.sceneRenderPass.render(this.renderer, composer.inputBuffer, composer.outputBuffer, 0);