rayzee 7.10.1 → 7.10.3

package/src/managers/DenoisingManager.js

@@ -6,7 +6,7 @@ import { ENGINE_DEFAULTS as DEFAULT_STATE, ASVGF_QUALITY_PRESETS } from '../Engi
 
 /**
  * Orchestrates all denoising, post-processing, and AI upscaling:
- *   - Real-time denoiser strategy switching (ASVGF / SSRC / EdgeAware / None)
+ *   - Real-time denoiser strategy switching (ASVGF / EdgeAware / None)
  *   - OIDN (offline denoise on render completion)
  *   - AI Upscaler
  *   - Auto-exposure coordination
@@ -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, edgeFilter, ssrc, autoExposure, compositor }
+		this._stages = stages; // { pathTracer, asvgf, variance, bilateralFilter, edgeFilter, autoExposure, compositor }
 
 		this._getExposure = getExposure;
 		this._getSaturation = getSaturation;
@@ -222,7 +222,7 @@ export class DenoisingManager extends EventDispatcher {
 
 	/**
 	 * Switches the real-time denoiser strategy.
-	 * @param {string} strategy   - 'none' | 'asvgf' | 'ssrc' | 'edgeaware'
+	 * @param {string} strategy   - 'none' | 'asvgf' | 'edgeaware'
 	 * @param {string} [asvgfPreset] - ASVGF quality preset when strategy is 'asvgf'
 	 */
 	setDenoiserStrategy( strategy, asvgfPreset ) {
@@ -234,7 +234,6 @@ export class DenoisingManager extends EventDispatcher {
 		if ( s.variance ) s.variance.enabled = false;
 		if ( s.bilateralFilter ) s.bilateralFilter.enabled = false;
 		if ( s.edgeFilter ) s.edgeFilter.setFilteringEnabled( false );
-		if ( s.ssrc ) s.ssrc.enabled = false;
 
 		this._clearDenoiserTextures();
 
@@ -248,11 +247,10 @@ export class DenoisingManager extends EventDispatcher {
 				this._applyASVGFPreset( asvgfPreset || 'medium' );
 				break;
 
-			case 'ssrc':
-				if ( s.ssrc ) s.ssrc.enabled = true;
-				break;
-
 			case 'edgeaware':
+				// EdgeAware is a spatial-only SVGF à-trous — it consumes the Variance
+				// stage's per-pixel variance to drive its luminance edge-stop.
+				if ( s.variance ) s.variance.enabled = true;
 				if ( s.edgeFilter ) s.edgeFilter.setFilteringEnabled( true );
 				break;
 
@@ -325,7 +323,7 @@ export class DenoisingManager extends EventDispatcher {
 	 * navigation and frees their textures. Call after any consumer toggle.
 	 *
 	 * MotionVector requires NormalDepth (reads pathtracer:normalDepth) and its
-	 * consumers (ASVGF, SSRC) are a subset of NormalDepth's, so NormalDepth is
+	 * consumers (ASVGF) are a subset of NormalDepth's, so NormalDepth is
 	 * always enabled whenever MotionVector is. Adaptive sampling / Variance / OIDN
 	 * do NOT read these signals, so they don't keep the G-buffer alive.
 	 */
@@ -335,9 +333,9 @@ export class DenoisingManager extends EventDispatcher {
 		const nd = s.normalDepth;
 		const mv = s.motionVector;
 
-		// motionVector:* consumed by ASVGF + SSRC
-		const motionNeeded = !! ( s.asvgf?.enabled || s.ssrc?.enabled );
-		// pathtracer:normalDepth consumed by ASVGF, SSRC, EdgeFilter, BilateralFilter
+		// motionVector:* consumed by ASVGF
+		const motionNeeded = !! ( s.asvgf?.enabled );
+		// pathtracer:normalDepth consumed by ASVGF, EdgeFilter, BilateralFilter
 		const normalNeeded = motionNeeded || !! ( s.edgeFilter?.enabled || s.bilateralFilter?.enabled );
 
 		if ( nd ) {
@@ -366,7 +364,7 @@ export class DenoisingManager extends EventDispatcher {
 		}
 
 		// PathTracer's aux MRT (normalDepth + albedo) is consumed by the real-time denoisers (ASVGF/
-		// BilateralFilter read albedo; ASVGF/SSRC/EdgeFilter read normalDepth) and by OIDN (reads the
+		// BilateralFilter read albedo; ASVGF/EdgeFilter read normalDepth) and by OIDN (reads the
 		// MRT read-targets directly). When none are active the wavefront skips those writes entirely.
 		s.pathTracer?.setAuxGBufferEnabled?.( normalNeeded || !! this.denoiser?.enabled );
 
@@ -374,7 +372,7 @@ export class DenoisingManager extends EventDispatcher {
 		// disabled (lazily re-created on the next dispatch after re-enable). Every strategy/denoiser
 		// toggle funnels through here after the enabled flags above are settled, so this is the one
 		// choke point. dispose() is idempotent, so re-running it for an already-released stage is a no-op.
-		for ( const stage of [ s.asvgf, s.variance, s.bilateralFilter, s.ssrc, s.edgeFilter, nd, mv ] ) {
+		for ( const stage of [ s.asvgf, s.variance, s.bilateralFilter, s.edgeFilter, nd, mv ] ) {
 
 			if ( stage && ! stage.enabled ) stage.releaseGPUMemory?.();
 
@@ -583,13 +581,6 @@ export class DenoisingManager extends EventDispatcher {
 
 	}
 
-	/** Updates SSRC stage parameters. */
-	setSSRCParams( params ) {
-
-		this._stages.ssrc?.updateParameters( params );
-
-	}
-
 	/** Updates edge-aware filtering parameters. */
 	setEdgeAwareParams( params ) {
 
@@ -667,7 +658,7 @@ export class DenoisingManager extends EventDispatcher {
 
 	/**
 	 * Switches strategy with automatic reset (convenience wrapper).
-	 * @param {'none'|'asvgf'|'ssrc'|'edgeaware'} strategy
+	 * @param {'none'|'asvgf'|'edgeaware'} strategy
 	 * @param {string} [asvgfPreset]
 	 */
 	setStrategy( strategy, asvgfPreset ) {
@@ -713,7 +704,7 @@ export class DenoisingManager extends EventDispatcher {
 		const keys = [
 			'asvgf:output', 'asvgf:demodulated', 'asvgf:gradient',
 			'variance:output', 'bilateralFiltering:output',
-			'edgeFiltering:output', 'ssrc:output',
+			'edgeFiltering:output',
 		];
 		keys.forEach( k => ctx.removeTexture( k ) );
 

package/src/Stages/SSRC.js

@@ -1,328 +0,0 @@
-// Screen-Space Radiance Cache (SSRC) Stage
-//
-// Two compute passes per frame:
-//   Pass 1 (Temporal): Reproject previous cache via motion vectors + EMA blend
-//   Pass 2 (Spatial):  8-tap neighbor reuse weighted by normal/depth similarity
-//
-// Execution: PER_CYCLE
-//
-// Events listened: pipeline:reset, camera:moved
-//
-// Textures published:  ssrc:output
-// Textures read:       pathtracer:color, pathtracer:normalDepth, motionVector:screenSpace
-
-import { uniform } from 'three/tsl';
-import { StorageTexture, TextureNode, RenderTarget } from 'three/webgpu';
-import { HalfFloatType, RGBAFormat, NearestFilter, LinearFilter, Box2, Vector2 } from 'three';
-import { RenderStage, StageExecutionMode } from '../Pipeline/RenderStage.js';
-import { buildTemporalPass, buildSpatialPass } from '../TSL/SSRC.js';
-import { MAX_STORAGE_TEXTURE_SIZE } from '../EngineDefaults.js';
-
-export class SSRC extends RenderStage {
-
-	constructor( renderer, options = {} ) {
-
-		super( 'SSRC', {
-			...options,
-			executionMode: StageExecutionMode.PER_CYCLE,
-		} );
-
-		this.renderer = renderer;
-
-		// ─── Uniforms ───
-		this.resW = uniform( 1 );
-		this.resH = uniform( 1 );
-		this.temporalAlpha = uniform( options.temporalAlpha ?? 0.1 );
-		this.phiNormal = uniform( options.phiNormal ?? 128.0 );
-		this.phiDepth = uniform( options.phiDepth ?? 0.5 );
-		this.maxHistory = uniform( options.maxHistory ?? 128.0 );
-		this.spatialRadius = uniform( options.spatialRadius ?? 4, 'int' );
-		this.spatialWeight = uniform( options.spatialWeight ?? 0.4 );
-		// 0 on reset → temporal pass skips cache; incremented each render frame
-		this._framesSinceReset = uniform( 0, 'int' );
-
-		// ─── Input TextureNodes (set from pipeline context each frame) ───
-		this._colorTexNode = new TextureNode();
-		this._ndTexNode = new TextureNode();
-		this._motionTexNode = new TextureNode();
-
-		// ─── Read-side wrappers for ping-pong StorageTextures ───
-		this._readCacheTexNode = new TextureNode(); // prev cache (for temporal pass)
-		this._readPrevNDTexNode = new TextureNode(); // prev normalDepth (for edge-stopping)
-		this._readPass1CacheTexNode = new TextureNode(); // current cache (for spatial pass)
-
-		// ─── StorageTextures (5 total) ───
-		// StorageTextures stay at max alloc — see resize crash fix (three.js #33061).
-		const w = 1, h = 1; // RTs/uniforms resized on first render
-
-		// Ping-pong temporal cache: .rgb = radiance, .w = history count
-		this._cacheTexA = this._createStorageTex( MAX_STORAGE_TEXTURE_SIZE, MAX_STORAGE_TEXTURE_SIZE, NearestFilter );
-		this._cacheTexB = this._createStorageTex( MAX_STORAGE_TEXTURE_SIZE, MAX_STORAGE_TEXTURE_SIZE, NearestFilter );
-
-		// Ping-pong previous-frame normalDepth (for edge-stopping in temporal pass)
-		this._prevNDTexA = this._createStorageTex( MAX_STORAGE_TEXTURE_SIZE, MAX_STORAGE_TEXTURE_SIZE, NearestFilter );
-		this._prevNDTexB = this._createStorageTex( MAX_STORAGE_TEXTURE_SIZE, MAX_STORAGE_TEXTURE_SIZE, NearestFilter );
-
-		// Final output (LinearFilter for Display fragment shader sampling)
-		this._outputTex = this._createStorageTex( MAX_STORAGE_TEXTURE_SIZE, MAX_STORAGE_TEXTURE_SIZE, LinearFilter );
-
-		// Active-region copy target — published downstream (storage tex is over-allocated)
-		this._srcRegion = new Box2( new Vector2( 0, 0 ), new Vector2( 0, 0 ) );
-		this.outputTarget = new RenderTarget( w, h, {
-			type: HalfFloatType,
-			format: RGBAFormat,
-			minFilter: LinearFilter,
-			magFilter: LinearFilter,
-			depthBuffer: false,
-			stencilBuffer: false
-		} );
-
-		// ─── State ───
-		this._currentPingPong = 0; // 0: read B, write A; 1: read A, write B
-		this._dispatchX = 1;
-		this._dispatchY = 1;
-
-		// ─── Compute nodes ───
-		this._buildComputeNodes();
-
-	}
-
-	// ──────────────────────────────────────────────────
-	// Lifecycle
-	// ──────────────────────────────────────────────────
-
-	setupEventListeners() {
-
-		this.on( 'pipeline:reset', () => this._resetCache() );
-		this.on( 'camera:moved', () => this._resetCache() );
-
-	}
-
-	render( context ) {
-
-		if ( ! this.enabled ) {
-
-			context.removeTexture( 'ssrc:output' );
-			return;
-
-		}
-
-		// Auto-resize if render resolution changed
-		const colorTex = context.getTexture( 'pathtracer:color' );
-		if ( colorTex?.image ) {
-
-			const { width, height } = colorTex.image;
-			if ( width !== this.outputTarget.width || height !== this.outputTarget.height ) {
-
-				this.setSize( width, height );
-
-			}
-
-		}
-
-		// Bind current-frame inputs from context
-		const normalDepthTex = context.getTexture( 'pathtracer:normalDepth' );
-		if ( ! normalDepthTex || ! colorTex ) return;
-
-		this._colorTexNode.value = colorTex;
-		this._ndTexNode.value = normalDepthTex;
-
-		const motionTex = context.getTexture( 'motionVector:screenSpace' );
-		if ( motionTex ) this._motionTexNode.value = motionTex;
-
-		// ─── Ping-pong assignment ───
-		// _currentPingPong 0: pass1 reads B, writes A; pass2 reads A
-		// _currentPingPong 1: pass1 reads A, writes B; pass2 reads B
-		const [ readCache, writeCache, readPrevND ] =
-			this._currentPingPong === 0
-				? [ this._cacheTexB, this._cacheTexA, this._prevNDTexB ]
-				: [ this._cacheTexA, this._cacheTexB, this._prevNDTexA ];
-
-		// ─── Pass 1: Temporal ───
-		this._readCacheTexNode.value = readCache;
-		this._readPrevNDTexNode.value = readPrevND;
-
-		// patch the write-side storages by recreating nodes is NOT needed — the pass was built
-		// with the actual StorageTexture references (not TextureNode wrappers), so we swap them
-		// via the ping-pong writeCacheTex / writePrevNDTex references in the closure.
-		// Since TSL captures StorageTexture directly for writes, we must rebuild or use a flag.
-		// Instead we use the swappable-write pattern: build two pass1 nodes (one per write target).
-		this.renderer.compute( this._currentPingPong === 0 ? this._pass1NodeA : this._pass1NodeB );
-
-		// ─── Pass 2: Spatial ───
-		// Spatial pass reads the just-written cache from pass 1
-		this._readPass1CacheTexNode.value = writeCache;
-
-		this.renderer.compute( this._pass2Node );
-
-		// Advance frames-since-reset counter (capped to avoid overflow)
-		this._framesSinceReset.value = Math.min( this._framesSinceReset.value + 1, 9999 );
-
-		// Copy active region out of the over-allocated StorageTexture into the
-		// right-sized RenderTarget; downstream stages UV-sample the latter.
-		this._srcRegion.max.set( this.outputTarget.width, this.outputTarget.height );
-		this.renderer.copyTextureToTexture( this._outputTex, this.outputTarget.texture, this._srcRegion );
-
-		// Publish final output
-		context.setTexture( 'ssrc:output', this.outputTarget.texture );
-
-		// Advance ping-pong
-		this._currentPingPong = 1 - this._currentPingPong;
-
-	}
-
-	// Free the 2048² StorageTextures when disabled; three.js re-creates them on the next dispatch
-	// after re-enable, and reset() clears the temporal cache. See ASVGF.releaseGPUMemory.
-	releaseGPUMemory() {
-
-		this._cacheTexA?.dispose();
-		this._cacheTexB?.dispose();
-		this._prevNDTexA?.dispose();
-		this._prevNDTexB?.dispose();
-		this._outputTex?.dispose();
-		// Render-res RT texture (dispose .texture, not the RT — RT.dispose() doesn't free it here).
-		this.context?.removeTexture( 'ssrc:output' );
-		this.outputTarget?.texture?.dispose();
-		this.reset();
-
-	}
-
-	reset() {
-
-		this._resetCache();
-
-	}
-
-	setSize( width, height ) {
-
-		if ( width < 1 || height < 1 ) return;
-
-		// StorageTextures stay at their max allocation (see constructor).
-		this.outputTarget.setSize( width, height );
-		this.outputTarget.texture.needsUpdate = true;
-
-		this.resW.value = width;
-		this.resH.value = height;
-
-		this._dispatchX = Math.ceil( width / 8 );
-		this._dispatchY = Math.ceil( height / 8 );
-
-		const dispatchSize = [ this._dispatchX, this._dispatchY, 1 ];
-		if ( this._pass1NodeA ) this._pass1NodeA.dispatchSize = dispatchSize;
-		if ( this._pass1NodeB ) this._pass1NodeB.dispatchSize = dispatchSize;
-		if ( this._pass2Node ) this._pass2Node.dispatchSize = dispatchSize;
-
-		this._resetCache();
-
-	}
-
-	dispose() {
-
-		this._pass1NodeA?.dispose();
-		this._pass1NodeB?.dispose();
-		this._pass2Node?.dispose();
-		this._cacheTexA.dispose();
-		this._cacheTexB.dispose();
-		this._prevNDTexA.dispose();
-		this._prevNDTexB.dispose();
-		this._outputTex.dispose();
-		this.outputTarget?.dispose();
-		this._colorTexNode?.dispose();
-		this._ndTexNode?.dispose();
-		this._motionTexNode?.dispose();
-		this._readCacheTexNode?.dispose();
-		this._readPrevNDTexNode?.dispose();
-		this._readPass1CacheTexNode?.dispose();
-
-	}
-
-	updateParameters( params ) {
-
-		if ( params.temporalAlpha !== undefined ) this.temporalAlpha.value = params.temporalAlpha;
-		if ( params.phiNormal !== undefined ) this.phiNormal.value = params.phiNormal;
-		if ( params.phiDepth !== undefined ) this.phiDepth.value = params.phiDepth;
-		if ( params.maxHistory !== undefined ) this.maxHistory.value = params.maxHistory;
-		if ( params.spatialRadius !== undefined ) this.spatialRadius.value = params.spatialRadius;
-		if ( params.spatialWeight !== undefined ) this.spatialWeight.value = params.spatialWeight;
-
-	}
-
-	// ──────────────────────────────────────────────────
-	// Private
-	// ──────────────────────────────────────────────────
-
-	_createStorageTex( w, h, filter ) {
-
-		const tex = new StorageTexture( w, h );
-		tex.type = HalfFloatType;
-		tex.format = RGBAFormat;
-		tex.minFilter = filter;
-		tex.magFilter = filter;
-		return tex;
-
-	}
-
-	_resetCache() {
-
-		this._currentPingPong = 0;
-		this._framesSinceReset.value = 0;
-
-	}
-
-	_buildComputeNodes() {
-
-		const commonArgs = {
-			colorTexNode: this._colorTexNode,
-			ndTexNode: this._ndTexNode,
-			motionTexNode: this._motionTexNode,
-			readCacheTexNode: this._readCacheTexNode,
-			readPrevNDTexNode: this._readPrevNDTexNode,
-			resW: this.resW,
-			resH: this.resH,
-			temporalAlpha: this.temporalAlpha,
-			phiNormal: this.phiNormal,
-			phiDepth: this.phiDepth,
-			maxHistory: this.maxHistory,
-		};
-
-		// Build two temporal nodes — one writing to cacheTexA, one to cacheTexB.
-		// This is required because StorageTexture write targets are fixed at compile time.
-		const pass1FnA = buildTemporalPass( {
-			...commonArgs,
-			writeCacheTex: this._cacheTexA,
-			writePrevNDTex: this._prevNDTexA,
-			framesSinceReset: this._framesSinceReset,
-		} );
-
-		const pass1FnB = buildTemporalPass( {
-			...commonArgs,
-			writeCacheTex: this._cacheTexB,
-			writePrevNDTex: this._prevNDTexB,
-			framesSinceReset: this._framesSinceReset,
-		} );
-
-		const dispatchCount = [ this._dispatchX, this._dispatchY, 1 ];
-		const wgSize = [ 8, 8, 1 ];
-
-		this._pass1NodeA = pass1FnA().compute( dispatchCount, wgSize );
-		this._pass1NodeB = pass1FnB().compute( dispatchCount, wgSize );
-
-		// Spatial pass: reads from _readPass1CacheTexNode (assigned per-frame to the just-written cache)
-		const pass2Fn = buildSpatialPass( {
-			colorTexNode: this._colorTexNode,
-			ndTexNode: this._ndTexNode,
-			readCacheTexNode: this._readPass1CacheTexNode,
-			outputTex: this._outputTex,
-			resW: this.resW,
-			resH: this.resH,
-			spatialRadius: this.spatialRadius,
-			spatialWeight: this.spatialWeight,
-			phiNormal: this.phiNormal,
-			phiDepth: this.phiDepth,
-		} );
-
-		this._pass2Node = pass2Fn().compute( dispatchCount, wgSize );
-
-	}
-
-}