@volter/editor-threejs 0.5.192 → 0.5.193

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@volter/editor-threejs",
   "author": "Volter AI, Inc.",
-  "version": "0.5.192",
+  "version": "0.5.193",
   "publishConfig": {
     "access": "public"
   },
@@ -135,12 +135,12 @@
     "serving": "./dist-node/serving.mjs"
   },
   "dependencies": {
-    "@volter/editor-project": "0.5.192",
+    "@volter/editor-project": "0.5.193",
     "@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.193",
     "postprocessing": "6.38.3",
     "quarks.core": "0.16.0",
     "@fortawesome/free-solid-svg-icons": "^7.2.0"

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);