rayzee 8.1.0 → 8.2.0

package/src/PathTracerApp.js

@@ -362,8 +362,12 @@ export class PathTracerApp extends EventDispatcher {
 
 		}
 
+		const cameraMoved = this.needsReset;
 		if ( this.needsReset ) {
 
+			// Before the reset, so the denoising manager's abort sees this frame as part of a move
+			// rather than deciding to hold on the first frame and dropping it on the second.
+			this.stages.pathTracer?.noteViewChanged();
 			this.reset( true );
 			this.needsReset = false;
 
@@ -404,6 +408,23 @@ export class PathTracerApp extends EventDispatcher {
 
 			}
 
+			// A frame traced while a denoise is in flight is never seen: only denoised frames reach
+			// the canvas during a camera move, and the next denoise reads the newest frame anyway.
+			// Tracing it only takes the GPU away from the denoise the viewport is waiting on —
+			// inside a room that turned a 10 ms denoise into 185 ms of wall clock.
+			if ( this.denoisingManager?.skipsTrace() ) {
+
+				// The camera is still being dragged; without this the interaction timeout can
+				// expire inside a long denoise and drop the view out of interaction mode.
+				if ( cameraMoved ) this.stages.pathTracer.enterInteractionMode();
+				// Gizmos and outlines are drawn against the live camera, not the traced frame, so
+				// they would visibly lag the view if they only redrew on the frames that traced.
+				this._renderHelperOverlay();
+				this.dispatchEvent( { type: EngineEvents.FRAME } );
+				return;
+
+			}
+
 			this.pipeline.render();
 
 			if ( ! this.stages.pathTracer.isComplete ) {
@@ -540,7 +561,9 @@ export class PathTracerApp extends EventDispatcher {
 
 		}
 
-		this._abortPostProcess();
+		// Whatever is on screen stays until its replacement is ready, including while the camera
+		// moves: the denoising manager decides, since only it knows something is coming.
+		this._abortPostProcess( { keepDisplay: true } );
 
 		this.completion.reset();
 		this.wake();
@@ -713,6 +736,7 @@ export class PathTracerApp extends EventDispatcher {
 
 		}
 
+		this.denoisingManager?.dropDisplay();
 		this.reset();
 		this.dispatchEvent( { type: 'SceneUnloaded' } );
 
@@ -962,6 +986,9 @@ export class PathTracerApp extends EventDispatcher {
 			this._syncControlsAfterLoad();
 			await this.loadSceneData( { pendingEnvironment: this._beginSceneMetadataEnvironment() } );
 			this.pipeline?.eventBus.emit( 'autoexposure:resetHistory' );
+			// Not held: the first denoise of a new scene lands ~1.1 s after the load (upload and
+			// shader compilation come first), and a second of the previous model reads as a bug.
+			this.denoisingManager?.dropDisplay();
 			this.reset();
 			this.cameraManager.currentCameraIndex = 0;
 			this.dispatchEvent( eventPayload );
@@ -994,6 +1021,7 @@ export class PathTracerApp extends EventDispatcher {
 
 			this._clearAppendedModels();
 			this.assetLoader?.releaseTargetModel();
+			this.denoisingManager?.dropDisplay();
 			this.reset();
 
 		} catch ( cleanupError ) {
@@ -1853,6 +1881,10 @@ export class PathTracerApp extends EventDispatcher {
 		const isProduction = mode === 'production';
 		const config = isProduction ? PRODUCTION_RENDER_CONFIG : INTERACTIVE_RENDER_CONFIG;
 
+		// First, before anything below can wake the loop or resize the renderer: a live-view
+		// refresh landing in the middle of that raced the renderer's own output pass.
+		this.denoisingManager?.setCadenceSuspended( isProduction );
+
 		this.cameraManager.controls.enabled = ! isProduction;
 
 		// Anything with a SETTING_ROUTES entry must go through settings, not setUniform: set() early-returns on
@@ -1935,9 +1967,9 @@ export class PathTracerApp extends EventDispatcher {
 
 	// Aborts any in-flight denoise/upscale and puts the denoiser canvas back at base resolution (the
 	// upscaler leaves it enlarged), so the live canvas is what's on screen again.
-	_abortPostProcess() {
+	_abortPostProcess( { keepDisplay = false } = {} ) {
 
-		this.denoisingManager?.abort( this.canvas );
+		this.denoisingManager?.abort( this.canvas, { keepDisplay } );
 
 		if ( this.denoisingManager?.restoreBaseResolution() ) {
 
@@ -2423,8 +2455,8 @@ export class PathTracerApp extends EventDispatcher {
 	// ═══════════════════════════════════════════════════════════════
 
 	/**
-	 * Returns the canvas element with the final rendered image.
-	 * Chooses the post-processing canvas when denoiser/upscaler are active.
+	 * Returns the canvas element holding the image on screen — denoised, graded and tone-mapped,
+	 * whatever is currently showing. The upscaler is the one thing that paints elsewhere.
 	 * @returns {HTMLCanvasElement|null}
 	 */
 	getCanvas() {
@@ -2432,13 +2464,13 @@ export class PathTracerApp extends EventDispatcher {
 		if ( ! this.renderer?.domElement ) return null;
 
 		const dm = this.denoisingManager;
-		const usePostProcess = ( dm?.denoiser?.enabled || dm?.upscaler?.enabled )
-			&& dm?.denoiserCanvas
-			&& this.stages.pathTracer?.isComplete;
+		const upscaled = dm?.upscaler?.enabled && dm?.upscalerCanvas
+			&& dm.upscalerCanvas.style.display !== 'none';
 
-		if ( usePostProcess ) return dm.denoiserCanvas;
+		if ( upscaled ) return dm.upscalerCanvas;
 
-		// Re-render compositor stage so the WebGPU canvas has valid content
+		// A presented WebGPU canvas only reads back what was drawn immediately before, so draw.
+		// This also puts the denoised picture on it: the Compositor prefers it over the raw render.
 		if ( this.stages.compositor && this.pipeline?.context ) {
 
 			this.stages.compositor.render( this.pipeline.context );
@@ -3261,8 +3293,6 @@ export class PathTracerApp extends EventDispatcher {
 		this.denoisingManager = new DenoisingManager( {
 			renderer: this.renderer,
 			mainCanvas: this.canvas,
-			scene: this.scene,
-			camera: this.cameraManager.camera,
 			stages: {
 				pathTracer: this.stages.pathTracer,
 				normalDepth: this.stages.normalDepth,
@@ -3278,7 +3308,6 @@ export class PathTracerApp extends EventDispatcher {
 			pipeline: this.pipeline,
 			getExposure: () => this.settings.get( 'exposure' ) ?? 1.0,
 			getSaturation: () => this.settings.get( 'saturation' ) ?? 1.0,
-			getTransparentBg: () => this.settings.get( 'transparentBackground' ) ?? false,
 		} );
 
 		this.denoisingManager.setupDenoiser();

package/src/Stages/Compositor.js

@@ -67,6 +67,7 @@ export class Compositor extends RenderStage {
 	_resolveSourceTexture( context ) {
 
 		return context.getTexture( 'bloom:output' )
+			|| context.getTexture( 'oidn:output' )
 			|| context.getTexture( 'edgeFiltering:output' )
 			|| context.getTexture( 'bilateralFiltering:output' )
 			|| context.getTexture( 'asvgf:output' )

package/src/Stages/PathTracerStage.js

@@ -30,6 +30,10 @@ import { createLogger, fmt } from '../utils/Logger.js';
 
 const log = createLogger( 'pathtracer' );
 
+// How long after the last move the view still counts as moving. Matches CameraOptimizer's own
+// settle delay, so the answer does not change when interaction mode is switched off.
+const VIEW_SETTLE_MS = 100;
+
 /**
  * Data layout constants
  */
@@ -163,6 +167,8 @@ export class PathTracerStage extends RenderStage {
 
 		// Track changes for event emission
 		this.cameraChanged = false;
+		// When the view was last moved, for viewIsChanging.
+		this._lastViewChangeAt = - Infinity;
 
 		// Update completion threshold
 		this.updateCompletionThreshold();
@@ -704,6 +710,25 @@ export class PathTracerStage extends RenderStage {
 
 	}
 
+	/**
+	 * Whether the view is being moved right now — the camera or a gizmo — whether or not interaction
+	 * mode is on. Interaction mode answers a narrower question (may quality be reduced) and is a
+	 * switch a host can turn off; what a denoiser needs to know is only whether this frame is about
+	 * to be thrown away by the next move.
+	 */
+	get viewIsChanging() {
+
+		return this.interactionMode || performance.now() - this._lastViewChangeAt < VIEW_SETTLE_MS;
+
+	}
+
+	// Called by the host loop on a frame whose reset came from the view moving.
+	noteViewChanged() {
+
+		this._lastViewChangeAt = performance.now();
+
+	}
+
 	// ===== TEXTURE SETTERS =====
 
 	/**