rayzee 5.7.0 → 5.8.0

package/src/Stages/NormalDepth.js

@@ -95,6 +95,14 @@ export class NormalDepth extends RenderStage {
 		this._bvhStorageNode = null;
 		this._matStorageNode = null;
 
+		// Last-seen attribute identities. PathTracer replaces these in-place
+		// across model load / BVH rebuild; the compute's bind group is locked
+		// to whatever buffer was bound at pipeline compile time, so we rebuild
+		// when any of them swaps to a new object.
+		this._lastTriAttr = null;
+		this._lastBvhAttr = null;
+		this._lastMatAttr = null;
+
 		// Compute node — built once when storage buffers are ready
 		this._computeNode = null;
 		this._computeBuilt = false;
@@ -138,50 +146,59 @@ export class NormalDepth extends RenderStage {
 		const pt = this.pathTracer;
 		if ( ! pt ) return false;
 
-		// Triangle storage
+		const matStorageAttr = pt.materialData.materialStorageAttr;
+
+		// Detect attribute identity swap (PathTracer.setTriangleData /
+		// setBVHData replace the attribute object on growth). The compute
+		// node's bind group is locked to the buffer bound at compile time —
+		// updating the storage node's .value alone leaves the GPU binding
+		// pointing at the now-discarded buffer, so every traversal misses.
+		const triSwapped = pt.triangleStorageAttr && pt.triangleStorageAttr !== this._lastTriAttr;
+		const bvhSwapped = pt.bvhStorageAttr && pt.bvhStorageAttr !== this._lastBvhAttr;
+		const matSwapped = matStorageAttr && matStorageAttr !== this._lastMatAttr;
+
+		if ( triSwapped || bvhSwapped || matSwapped ) {
+
+			// Drop compute + storage nodes so they get rebuilt against the
+			// current buffers. Cheap: this only happens on model load.
+			this._computeNode?.dispose?.();
+			this._computeNode = null;
+			this._computeBuilt = false;
+			this._triStorageNode = null;
+			this._bvhStorageNode = null;
+			this._matStorageNode = null;
+			this._dirty = true;
+
+		}
+
 		if ( pt.triangleStorageAttr && ! this._triStorageNode ) {
 
 			this._triStorageNode = storage(
 				pt.triangleStorageAttr, 'vec4', pt.triangleStorageAttr.count
 			).toReadOnly();
 
-		} else if ( pt.triangleStorageAttr && this._triStorageNode ) {
-
-			// Data changed (new model loaded) — update in-place
-			this._triStorageNode.value = pt.triangleStorageAttr;
-			this._triStorageNode.bufferCount = pt.triangleStorageAttr.count;
-
 		}
 
-		// BVH storage
 		if ( pt.bvhStorageAttr && ! this._bvhStorageNode ) {
 
 			this._bvhStorageNode = storage(
 				pt.bvhStorageAttr, 'vec4', pt.bvhStorageAttr.count
 			).toReadOnly();
 
-		} else if ( pt.bvhStorageAttr && this._bvhStorageNode ) {
-
-			this._bvhStorageNode.value = pt.bvhStorageAttr;
-			this._bvhStorageNode.bufferCount = pt.bvhStorageAttr.count;
-
 		}
 
-		// Material storage
-		const matStorageAttr = pt.materialData.materialStorageAttr;
 		if ( matStorageAttr && ! this._matStorageNode ) {
 
 			this._matStorageNode = storage(
 				matStorageAttr, 'vec4', matStorageAttr.count
 			).toReadOnly();
 
-		} else if ( matStorageAttr && this._matStorageNode ) {
-
-			this._matStorageNode.value = matStorageAttr;
-			this._matStorageNode.bufferCount = matStorageAttr.count;
-
 		}
 
+		this._lastTriAttr = pt.triangleStorageAttr || this._lastTriAttr;
+		this._lastBvhAttr = pt.bvhStorageAttr || this._lastBvhAttr;
+		this._lastMatAttr = matStorageAttr || this._lastMatAttr;
+
 		return !! ( this._triStorageNode && this._bvhStorageNode && this._matStorageNode );
 
 	}

package/src/managers/DenoisingManager.js

@@ -41,7 +41,7 @@ export class DenoisingManager extends EventDispatcher {
 		this.pipeline = pipeline;
 
 		// Stage references — only used internally for orchestration
-		this._stages = stages; // { pathTracer, asvgf, variance, bilateralFilter, adaptiveSampling, edgeFilter, ssrc, autoExposure, display }
+		this._stages = stages; // { pathTracer, asvgf, variance, bilateralFilter, adaptiveSampling, edgeFilter, ssrc, autoExposure, compositor }
 
 		this._getExposure = getExposure;
 		this._getSaturation = getSaturation;
@@ -295,9 +295,8 @@ export class DenoisingManager extends EventDispatcher {
 	}
 
 	/**
-	 * Enables/disables auto-exposure with proper exposure stacking management.
 	 * @param {boolean} enabled
-	 * @param {number}  manualExposure - The manual exposure value to restore when disabling
+	 * @param {number}  manualExposure - Restored to renderer.toneMappingExposure when disabling.
 	 */
 	setAutoExposureEnabled( enabled, manualExposure ) {
 
@@ -306,19 +305,10 @@ export class DenoisingManager extends EventDispatcher {
 
 		s.autoExposure.enabled = enabled;
 
-		if ( enabled ) {
-
-			// Neutralize Display manual exposure to avoid stacking
-			s.display?.setExposure( 1.0 );
-
-		} else {
+		// AutoExposure overwrites renderer.toneMappingExposure each frame; restore manual on disable.
+		if ( ! enabled && this.renderer ) {
 
-			s.display?.setExposure( manualExposure );
-			if ( s.display && this.renderer ) {
-
-				this.renderer.toneMappingExposure = 1.0;
-
-			}
+			this.renderer.toneMappingExposure = manualExposure;
 
 		}
 
@@ -417,10 +407,10 @@ export class DenoisingManager extends EventDispatcher {
 
 		} else {
 
-			// Re-render display stage so WebGPU canvas has valid content
-			if ( this.upscaler?.enabled && this._stages.display && context ) {
+			// Re-render compositor stage so WebGPU canvas has valid content
+			if ( this.upscaler?.enabled && this._stages.compositor && context ) {
 
-				this._stages.display.render( context );
+				this._stages.compositor.render( context );
 
 			}
 

package/src/Stages/Display.js

@@ -1,120 +0,0 @@
-import { vec4, vec3, uv, uniform, select, dot, mix } from 'three/tsl';
-import { MeshBasicNodeMaterial, QuadMesh, TextureNode } from 'three/webgpu';
-import { NoBlending } from 'three';
-import { RenderStage, StageExecutionMode } from '../Pipeline/RenderStage.js';
-import { REC709_LUMINANCE_COEFFICIENTS } from '../TSL/Common.js';
-
-/**
- * Display — Terminal pipeline stage for WebGPU.
- *
- * Reads the final colour texture from the pipeline context (using a
- * priority fallback chain), applies exposure, and renders to screen.
- *
- * When new post-processing stages are added between PathTracer and
- * Display, the fallback chain automatically picks up the latest output
- * without any wiring changes.
- */
-export class Display extends RenderStage {
-
-	constructor( renderer, options = {} ) {
-
-		super( 'Display', {
-			...options,
-			executionMode: StageExecutionMode.ALWAYS
-		} );
-
-		this.renderer = renderer;
-
-		// Exposure uniform — linear multiplier (consistent with auto-exposure)
-		this.exposure = uniform( options.exposure ?? 1.0 );
-
-		// Pre-tonemapping saturation — compensates for ACES/AgX desaturation (1.0 = neutral)
-		this.saturation = uniform( options.saturation ?? 1.0 );
-
-		// Transparent background toggle
-		this._transparentBackground = uniform( 0, 'int' );
-
-		// Updatable texture node — swap .value each frame, no shader recompile
-		this._displayTexNode = new TextureNode();
-
-		const texSample = this._displayTexNode.sample( uv() );
-
-		// Build material once (TSL compiles on first render)
-		const exposed = texSample.xyz.mul( this.exposure );
-
-		// Saturation adjustment (before tonemapping): mix between luminance and color
-		const luma = dot( exposed, REC709_LUMINANCE_COEFFICIENTS );
-		let displayShader = mix( vec3( luma ), exposed, this.saturation );
-
-		// Alpha: pass through source alpha when transparent, otherwise 1.0
-		const outputAlpha = select( this._transparentBackground, texSample.w, 1.0 );
-
-		this.displayMaterial = new MeshBasicNodeMaterial();
-		this.displayMaterial.colorNode = vec4( displayShader, outputAlpha );
-		this.displayMaterial.blending = NoBlending;
-		this.displayMaterial.toneMapped = true;
-
-		this.displayQuad = new QuadMesh( this.displayMaterial );
-
-	}
-
-	/**
-	 * Resolve the best available output texture from the pipeline context.
-	 * Later stages in the chain take priority; pathtracer:color is the
-	 * baseline fallback that is always present.
-	 */
-	_resolveDisplayTexture( context ) {
-
-		return context.getTexture( 'bloom:output' )
-			|| context.getTexture( 'edgeFiltering:output' )
-			|| context.getTexture( 'asvgf:output' )
-			|| context.getTexture( 'ssrc:output' )
-			|| context.getTexture( 'pathtracer:color' );
-
-	}
-
-	render( context ) {
-
-		if ( ! this.enabled ) return;
-
-		const displayTexture = this._resolveDisplayTexture( context );
-
-		if ( ! displayTexture ) return;
-
-		// Swap texture reference (no shader recompilation)
-		this._displayTexNode.value = displayTexture;
-
-		// Render to screen
-		this.renderer.setRenderTarget( null );
-		this.displayQuad.render( this.renderer );
-
-	}
-
-	setExposure( value ) {
-
-		this.exposure.value = value;
-
-	}
-
-	setSaturation( value ) {
-
-		this.saturation.value = value;
-
-	}
-
-	setTransparentBackground( enabled ) {
-
-		this._transparentBackground.value = enabled ? 1 : 0;
-
-	}
-
-	dispose() {
-
-		this._displayTexNode?.dispose();
-		this.displayMaterial?.dispose();
-		// QuadMesh extends Mesh — no dispose method; material already disposed.
-		this.displayQuad = null;
-
-	}
-
-}