rayzee 5.7.0 → 5.8.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rayzee",
-  "version": "5.7.0",
+  "version": "5.8.0",
   "type": "module",
   "description": "Real-time WebGPU path tracing engine built on Three.js",
   "main": "dist/rayzee.umd.js",

package/src/EngineDefaults.js

@@ -90,8 +90,8 @@ export const ENGINE_DEFAULTS = {
 	directionalLightPosition: [ 1, 1, 1 ],
 	directionalLightAngle: 0.0,
 
-	pixelEdgeSharpness: 0.75,
-	edgeSharpenSpeed: 0.05,
+	filterStrength: 0.75,
+	strengthDecaySpeed: 0.05,
 	edgeThreshold: 1.0,
 
 	enableOIDN: false,
@@ -115,7 +115,7 @@ export const ENGINE_DEFAULTS = {
 	debugVisScale: 100,
 
 	// Denoising strategy
-	denoiserStrategy: 'edgeaware',
+	denoiserStrategy: 'none',
 
 	enableASVGF: false,
 	asvgfTemporalAlpha: 0.1,

package/src/PathTracerApp.js

@@ -1,4 +1,4 @@
-import { WebGPURenderer, RectAreaLightNode } from 'three/webgpu';
+import { WebGPURenderer, RectAreaLightNode, LinearSRGBColorSpace, SRGBColorSpace } from 'three/webgpu';
 import { texture as _tslTexture, cubeTexture as _tslCubeTexture } from 'three/tsl';
 import {
 	ACESFilmicToneMapping, Scene, EventDispatcher, TimestampQuery
@@ -16,7 +16,7 @@ import { AdaptiveSampling } from './Stages/AdaptiveSampling.js';
 import { EdgeFilter } from './Stages/EdgeFilter.js';
 import { AutoExposure } from './Stages/AutoExposure.js';
 import { SSRC } from './Stages/SSRC.js';
-import { Display } from './Stages/Display.js';
+import { Compositor } from './Stages/Compositor.js';
 import { RenderPipeline } from './Pipeline/RenderPipeline.js';
 import { CompletionTracker } from './Pipeline/CompletionTracker.js';
 import { ENGINE_DEFAULTS as DEFAULT_STATE, FINAL_RENDER_CONFIG, PREVIEW_RENDER_CONFIG } from './EngineDefaults.js';
@@ -286,7 +286,7 @@ export class PathTracerApp extends EventDispatcher {
 				if ( this._needsDisplayRefresh ) {
 
 					this._needsDisplayRefresh = false;
-					this.stages.display.render( this.pipeline.context );
+					this.stages.compositor.render( this.pipeline.context );
 					this._renderHelperOverlay();
 
 				}
@@ -775,7 +775,7 @@ export class PathTracerApp extends EventDispatcher {
 		// Apply all settings to stages in one shot
 		timer.start( 'Apply settings' );
 		this.settings.applyAll();
-		this.stages.display.setTransparentBackground( this.settings.get( 'transparentBackground' ) );
+		this.stages.compositor.setTransparentBackground( this.settings.get( 'transparentBackground' ) );
 		timer.end( 'Apply settings' );
 
 		timer.print();
@@ -1006,10 +1006,10 @@ export class PathTracerApp extends EventDispatcher {
 
 		if ( usePostProcess ) return dm.denoiserCanvas;
 
-		// Re-render display stage so the WebGPU canvas has valid content
-		if ( this.stages.display && this.pipeline?.context ) {
+		// Re-render compositor stage so the WebGPU canvas has valid content
+		if ( this.stages.compositor && this.pipeline?.context ) {
 
-			this.stages.display.render( this.pipeline.context );
+			this.stages.compositor.render( this.pipeline.context );
 
 		}
 
@@ -1208,6 +1208,8 @@ export class PathTracerApp extends EventDispatcher {
 
 		RectAreaLightNode.setLTC( RectAreaLightTexturesLib.init() );
 
+		this.renderer.workingColorSpace = SRGBColorSpace;
+		this.renderer.outputColorSpace = SRGBColorSpace;
 		this.renderer.toneMapping = ACESFilmicToneMapping;
 		this.renderer.toneMappingExposure = 1.0;
 		this.renderer.setPixelRatio( 1.0 );
@@ -1261,7 +1263,7 @@ export class PathTracerApp extends EventDispatcher {
 		this.pipeline.addStage( this.stages.adaptiveSampling );
 		this.pipeline.addStage( this.stages.edgeFilter );
 		this.pipeline.addStage( this.stages.autoExposure );
-		this.pipeline.addStage( this.stages.display );
+		this.pipeline.addStage( this.stages.compositor );
 
 		const initRenderW = this.canvas.clientWidth || 1;
 		const initRenderH = this.canvas.clientHeight || 1;
@@ -1367,10 +1369,13 @@ export class PathTracerApp extends EventDispatcher {
 		// Bind settings to pipeline stages
 		this.settings.bind( {
 			stages: this.stages,
+			renderer: this.renderer,
 			resetCallback: () => this.reset(),
 			reconcileCompletion: () => this._reconcileCompletion(),
 		} );
 
+		this.renderer.toneMappingExposure = this.settings.get( 'exposure' ) ?? 1.0;
+
 		// Resize handling
 		this.onResize();
 		this.resizeHandler = () => this.onResize();
@@ -1474,8 +1479,7 @@ export class PathTracerApp extends EventDispatcher {
 		this.stages.edgeFilter = new EdgeFilter( this.renderer, { enabled: false } );
 		this.stages.autoExposure = new AutoExposure( this.renderer, { enabled: DEFAULT_STATE.autoExposure ?? false } );
 
-		this.stages.display = new Display( this.renderer, {
-			exposure: ( DEFAULT_STATE.autoExposure ) ? 1.0 : ( this.settings.get( 'exposure' ) ?? 1.0 ),
+		this.stages.compositor = new Compositor( this.renderer, {
 			saturation: this.settings.get( 'saturation' ) ?? DEFAULT_STATE.saturation,
 		} );
 
@@ -1497,7 +1501,7 @@ export class PathTracerApp extends EventDispatcher {
 				edgeFilter: this.stages.edgeFilter,
 				ssrc: this.stages.ssrc,
 				autoExposure: this.stages.autoExposure,
-				display: this.stages.display,
+				compositor: this.stages.compositor,
 			},
 			pipeline: this.pipeline,
 			getExposure: () => this.settings.get( 'exposure' ) ?? 1.0,

package/src/RenderSettings.js

@@ -104,16 +104,16 @@ export class RenderSettings extends EventDispatcher {
 	 * Wires internal references. Called by PathTracerApp after init().
 	 *
 	 * @param {Object} params
-	 * @param {Object} params.stages           - Pipeline stages { pathTracer, display, autoExposure, ... }
+	 * @param {Object} params.stages           - Pipeline stages { pathTracer, compositor, autoExposure, ... }
 	 * @param {Function} params.resetCallback   - Called to reset accumulation
 	 * @param {Function} [params.reconcileCompletion] - Called when completion limits change
 	 */
-	bind( { stages, resetCallback, reconcileCompletion } ) {
+	bind( { stages, renderer, resetCallback, reconcileCompletion } ) {
 
 		this._pathTracer = stages.pathTracer;
 		this._resetCallback = resetCallback;
 		this._delegates = {};
-		this._handlers = this._buildHandlers( stages, reconcileCompletion );
+		this._handlers = this._buildHandlers( stages, renderer, reconcileCompletion );
 
 	}
 
@@ -121,22 +121,24 @@ export class RenderSettings extends EventDispatcher {
 	 * Builds handler functions for multi-stage settings that can't
 	 * be routed with a simple uniform forward.
 	 */
-	_buildHandlers( stages, reconcileCompletion ) {
+	_buildHandlers( stages, renderer, reconcileCompletion ) {
 
 		return {
 
 			handleTransparentBackground: ( value ) => {
 
 				stages.pathTracer?.setUniform( 'transparentBackground', value );
-				stages.display?.setTransparentBackground( value );
+				stages.compositor?.setTransparentBackground( value );
 
 			},
 
 			handleExposure: ( value ) => {
 
-				if ( ! stages.autoExposure?.enabled ) {
+				// Three.js applies toneMappingExposure inside the tone-mapping branch,
+				// so this has no effect when renderer.toneMapping === NoToneMapping.
+				if ( ! stages.autoExposure?.enabled && renderer ) {
 
-					stages.display?.setExposure( value );
+					renderer.toneMappingExposure = value;
 
 				}
 
@@ -144,7 +146,7 @@ export class RenderSettings extends EventDispatcher {
 
 			handleSaturation: ( value ) => {
 
-				stages.display?.setSaturation( value );
+				stages.compositor?.setSaturation( value );
 
 			},
 

package/src/Stages/Compositor.js

@@ -0,0 +1,101 @@
+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';
+
+/**
+ * Compositor — Terminal pipeline stage.
+ *
+ * Selects the latest upstream texture via a priority fallback chain, applies
+ * a saturation grade, sets alpha, and hands the linear HDR result to the
+ * renderer's output pass (tone mapping + sRGB gamma happen there).
+ *
+ * Exposure is not applied here — `renderer.toneMappingExposure` owns it,
+ * and Three.js applies it inside the tone-mapping branch of the output pass
+ * (so it has no effect when `renderer.toneMapping === NoToneMapping`).
+ */
+export class Compositor extends RenderStage {
+
+	constructor( renderer, options = {} ) {
+
+		super( 'Compositor', {
+			...options,
+			executionMode: StageExecutionMode.ALWAYS
+		} );
+
+		this.renderer = renderer;
+
+		// 1.0 = neutral; >1 boosts to compensate for ACES/AgX desaturation.
+		this.saturation = uniform( options.saturation ?? 1.0 );
+
+		this._transparentBackground = uniform( 0, 'int' );
+
+		// TextureNode reused across frames — only `.value` mutates, shader doesn't recompile.
+		this._sourceTexNode = new TextureNode();
+
+		const texSample = this._sourceTexNode.sample( uv() );
+
+		const luma = dot( texSample.xyz, REC709_LUMINANCE_COEFFICIENTS );
+		const gradedColor = mix( vec3( luma ), texSample.xyz, this.saturation );
+
+		const outputAlpha = select( this._transparentBackground, texSample.w, 1.0 );
+
+		this.compositorMaterial = new MeshBasicNodeMaterial();
+		this.compositorMaterial.colorNode = vec4( gradedColor, outputAlpha );
+		this.compositorMaterial.blending = NoBlending;
+
+		this.compositorQuad = new QuadMesh( this.compositorMaterial );
+
+	}
+
+	/**
+	 * Later stages in the chain take priority; `pathtracer:color` is the
+	 * baseline fallback that is always present.
+	 */
+	_resolveSourceTexture( 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 sourceTexture = this._resolveSourceTexture( context );
+		if ( ! sourceTexture ) return;
+
+		this._sourceTexNode.value = sourceTexture;
+
+		this.renderer.setRenderTarget( null );
+		this.compositorQuad.render( this.renderer );
+
+	}
+
+	setSaturation( value ) {
+
+		this.saturation.value = value;
+
+	}
+
+	setTransparentBackground( enabled ) {
+
+		this._transparentBackground.value = enabled ? 1 : 0;
+
+	}
+
+	dispose() {
+
+		this._sourceTexNode?.dispose();
+		this.compositorMaterial?.dispose();
+		// QuadMesh extends Mesh — no dispose method; material already released above.
+		this.compositorQuad = null;
+
+	}
+
+}

package/src/Stages/EdgeFilter.js

@@ -1,27 +1,24 @@
-import { Fn, vec3, vec4, float, int, uint, ivec2, uvec2, uniform,
-	If, dot, max, abs, mix,
+import { Fn, vec4, float, int, uint, ivec2, uvec2, uniform,
+	If, dot, max, abs, mix, pow, step,
 	textureLoad, textureStore, localId, workgroupId } from 'three/tsl';
 import { RenderTarget, TextureNode, StorageTexture } from 'three/webgpu';
 import { HalfFloatType, RGBAFormat, NearestFilter, Box2, Vector2 } from 'three';
 import { RenderStage, StageExecutionMode } from '../Pipeline/RenderStage.js';
+import { REC709_LUMINANCE_COEFFICIENTS } from '../TSL/Common.js';
 
 /**
- * WebGPU Edge-Aware Filtering Stage (Compute Shader)
+ * WebGPU Edge-Aware Filtering Stage (Compute Shader).
  *
- * Edge-preserving temporal filtering with progressive edge sharpening.
- * Uses a large directional sampling kernel for edge-guided smoothing,
- * then a smaller kernel for edge-detail refinement.
+ * Geometry-guided bilateral filter (8-dir × 2-dist kernel). Edge weights
+ * combine luminance, surface normal, and ray distance — see Dammertz 2010
+ * "Edge-Avoiding À-Trous" for the structure. Strength decays over iterations
+ * so the filter is strongest on early frames and fades as accumulation
+ * converges. Single-pass; no temporal reuse.
  *
- * Features:
- *   - Scene-adaptive: aggressive filtering for dynamic, progressive for static
- *   - Edge sharpening increases over iterations
- *   - Fast path during interaction mode (direct copy, no filtering cost)
- *   - Firefly reduction for high-luminance outliers
- *
- * Execution: PER_CYCLE
- *
- * Textures published:  edgeFiltering:output
- * Textures read:       asvgf:output (fallback: pathtracer:color)
+ * Reads:     pathtracer:color (or asvgf:output / bilateralFiltering:output)
+ *            and pathtracer:normalDepth
+ * Publishes: edgeFiltering:output
+ * Mode:      PER_CYCLE
  */
 export class EdgeFilter extends RenderStage {
 
@@ -34,25 +31,25 @@ export class EdgeFilter extends RenderStage {
 
 		this.renderer = renderer;
 
-		// Parameters
-		this.pixelEdgeSharpness = uniform( options.pixelEdgeSharpness ?? 0.75 );
-		this.edgeSharpenSpeed = uniform( options.edgeSharpenSpeed ?? 0.05 );
+		// filterStrength: 0 = passthrough, 1 = fully filtered.
+		// strengthDecaySpeed: per-iteration falloff toward passthrough.
+		// edgeThreshold: luminance σ. phiNormal: dot(n,n) exponent. phiDepth: depth σ.
+		this.filterStrength = uniform( options.filterStrength ?? 0.75 );
+		this.strengthDecaySpeed = uniform( options.strengthDecaySpeed ?? 0.05 );
 		this.edgeThreshold = uniform( options.edgeThreshold ?? 1.0 );
+		this.phiNormal = uniform( options.phiNormal ?? 128.0 );
+		this.phiDepth = uniform( options.phiDepth ?? 1.0 );
 		this.iterationCount = uniform( 0.0 );
 		this.resW = uniform( options.width || 1 );
 		this.resH = uniform( options.height || 1 );
 
-		// Internal counter
 		this._iterations = 0;
 
-		// Input texture node
 		this._inputTexNode = new TextureNode();
+		this._ndTexNode = new TextureNode();
 
-		// Output StorageTexture (compute writes here)
-		// Pre-allocated at max size — NEVER resize/dispose after this.
-		// Kept as a defensive pattern: bug #32969 (setSize bind-group staleness)
-		// was fixed in r184 (PR #33028), but #33061 (TSL compute pipeline
-		// re-compile returns zeros) is still open.
+		// Pre-allocate StorageTexture at max — defensive against three.js #33061
+		// (TSL compute pipeline re-compile returns zeros after resize).
 		const MAX_STORAGE_SIZE = 2048;
 		const w = options.width || 1;
 		const h = options.height || 1;
@@ -63,10 +60,8 @@ export class EdgeFilter extends RenderStage {
 		this._outputStorageTex.minFilter = NearestFilter;
 		this._outputStorageTex.magFilter = NearestFilter;
 
-		// Reusable Box2 for srcRegion in copyTextureToTexture
 		this._srcRegion = new Box2( new Vector2( 0, 0 ), new Vector2( 0, 0 ) );
 
-		// Output RenderTarget (readable copy for downstream stages)
 		this.outputTarget = new RenderTarget( w, h, {
 			type: HalfFloatType,
 			format: RGBAFormat,
@@ -76,7 +71,6 @@ export class EdgeFilter extends RenderStage {
 			stencilBuffer: false
 		} );
 
-		// Dispatch dimensions
 		this._dispatchX = Math.ceil( w / 16 );
 		this._dispatchY = Math.ceil( h / 16 );
 
@@ -87,10 +81,13 @@ export class EdgeFilter extends RenderStage {
 	_buildCompute() {
 
 		const inputTex = this._inputTexNode;
+		const ndTex = this._ndTexNode;
 		const outputStorageTex = this._outputStorageTex;
-		const sharpness = this.pixelEdgeSharpness;
-		const sharpenSpeed = this.edgeSharpenSpeed;
+		const filterStrength = this.filterStrength;
+		const decaySpeed = this.strengthDecaySpeed;
 		const threshold = this.edgeThreshold;
+		const phiNormal = this.phiNormal;
+		const phiDepth = this.phiDepth;
 		const iterCount = this.iterationCount;
 		const resW = this.resW;
 		const resH = this.resH;
@@ -104,41 +101,64 @@ export class EdgeFilter extends RenderStage {
 
 			If( gx.lessThan( int( resW ) ).and( gy.lessThan( int( resH ) ) ), () => {
 
-				const center = textureLoad( inputTex, ivec2( gx, gy ) ).xyz;
-				const centerLum = dot( center, vec3( 0.2126, 0.7152, 0.0722 ) );
+				const coord = ivec2( gx, gy );
+				const center = textureLoad( inputTex, coord ).xyz;
+				const centerLum = dot( center, REC709_LUMINANCE_COEFFICIENTS );
 
-				// Progressive edge sharpening factor
-				const edgeFactor = sharpness.add( iterCount.mul( sharpenSpeed ) ).clamp( 0.0, 0.95 );
+				// NormalDepth writes (0,0,0, 1e6) for miss rays. Decoded normal
+				// (-1,-1,-1) is non-unit and explodes pow(dot, phi); use the depth
+				// sentinel as a 0/1 hit flag and zero out cross-kind weights.
+				const MISS_THRESHOLD = 1e5;
+				const centerND = textureLoad( ndTex, coord );
+				const centerNormal = centerND.xyz.mul( 2.0 ).sub( 1.0 );
+				const centerDepth = centerND.w;
+				const centerIsHit = step( float( MISS_THRESHOLD ), centerDepth ).oneMinus();
+
+				const effectiveStrength = filterStrength.sub( iterCount.mul( decaySpeed ) ).clamp( 0.0, 1.0 );
 
-				// Sample 8-direction cross pattern for edge-aware filtering
-				// 8 directions x 2 distances + centre
 				const colorSum = center.toVar();
 				const weightSum = float( 1.0 ).toVar();
 
-				// Directions: right, up, left, down, and diagonals
 				const dirs = [
 					[ 1, 0 ], [ 0, 1 ], [ - 1, 0 ], [ 0, - 1 ],
 					[ 1, 1 ], [ - 1, 1 ], [ - 1, - 1 ], [ 1, - 1 ],
 				];
 
-				// Sample along each direction at distances 1, 2
 				for ( const [ dx, dy ] of dirs ) {
 
 					for ( const dist of [ 1, 2 ] ) {
 
 						const sx = gx.add( dx * dist ).clamp( int( 0 ), int( resW ).sub( 1 ) );
 						const sy = gy.add( dy * dist ).clamp( int( 0 ), int( resH ).sub( 1 ) );
-						const sColor = textureLoad( inputTex, ivec2( sx, sy ) ).xyz;
-						const sLum = dot( sColor, vec3( 0.2126, 0.7152, 0.0722 ) );
+						const sCoord = ivec2( sx, sy );
+
+						const sColor = textureLoad( inputTex, sCoord ).xyz;
+						const sLum = dot( sColor, REC709_LUMINANCE_COEFFICIENTS );
+
+						const sND = textureLoad( ndTex, sCoord );
+						const sNormal = sND.xyz.mul( 2.0 ).sub( 1.0 );
+						const sDepth = sND.w;
+						const sampleIsHit = step( float( MISS_THRESHOLD ), sDepth ).oneMinus();
+
+						const lumW = abs( centerLum.sub( sLum ) ).div( max( threshold, float( 0.001 ) ) ).negate().exp();
+
+						const bothHit = centerIsHit.mul( sampleIsHit );
+						const bothMiss = centerIsHit.oneMinus().mul( sampleIsHit.oneMinus() );
+						const sameKind = bothHit.add( bothMiss );
 
-						// Luminance-based edge weight
-						const lumDiff = abs( centerLum.sub( sLum ) );
-						const edgeWeight = lumDiff.div( max( threshold, float( 0.001 ) ) ).negate().exp();
+						// Clamp dot to [0,1] before pow — miss-ray normals decode to
+						// non-unit (-1,-1,-1) with dot=3, which would saturate pow(.,phi)
+						// to +inf and poison downstream via inf*0 = NaN.
+						const cosTheta = dot( centerNormal, sNormal ).clamp( 0.0, 1.0 );
+						const normW = pow( cosTheta, phiNormal );
+						const depW = abs( centerDepth.sub( sDepth ) ).div( max( phiDepth, float( 0.001 ) ) ).negate().exp();
+
+						// Geometric weights only meaningful for hit-vs-hit pairs.
+						const geomW = mix( float( 1.0 ), normW.mul( depW ), bothHit );
 
-						// Distance falloff
 						const distWeight = float( 1.0 ).div( float( dist ).add( 0.5 ) );
+						const w = lumW.mul( geomW ).mul( sameKind ).mul( distWeight );
 
-						const w = edgeWeight.mul( distWeight );
 						colorSum.addAssign( sColor.mul( w ) );
 						weightSum.addAssign( w );
 
@@ -147,12 +167,10 @@ export class EdgeFilter extends RenderStage {
 				}
 
 				const filtered = colorSum.div( max( weightSum, float( 0.0001 ) ) );
+				const finalColor = mix( center, filtered, effectiveStrength );
 
-				// Blend between filtered and original based on edge sharpening factor
-				const finalColor = mix( filtered, center, edgeFactor );
-
-				// Firefly suppression for very high luminance
-				const finalLum = dot( finalColor, vec3( 0.2126, 0.7152, 0.0722 ) );
+				// Firefly clamp on output luminance.
+				const finalLum = dot( finalColor, REC709_LUMINANCE_COEFFICIENTS );
 				const clampedColor = finalColor.toVar();
 				If( finalLum.greaterThan( 10.0 ), () => {
 
@@ -181,23 +199,28 @@ export class EdgeFilter extends RenderStage {
 
 		if ( ! this.enabled ) return;
 
-		// Resolve input with fallback chain
 		const inputTex = context.getTexture( 'asvgf:output' )
 			|| context.getTexture( 'bilateralFiltering:output' )
 			|| context.getTexture( 'pathtracer:color' );
 
-		if ( ! inputTex ) return;
+		const ndTex = context.getTexture( 'pathtracer:normalDepth' );
+
+		// Without the G-buffer there's no edge guidance — pass input through
+		// rather than producing a uniform blur.
+		if ( ! inputTex || ! ndTex ) {
+
+			if ( inputTex ) context.setTexture( 'edgeFiltering:output', inputTex );
+			return;
+
+		}
 
-		// Fast path during interaction mode — direct copy
-		const interactionMode = context.getState( 'interactionMode' );
-		if ( interactionMode ) {
+		if ( context.getState( 'interactionMode' ) ) {
 
 			context.setTexture( 'edgeFiltering:output', inputTex );
 			return;
 
 		}
 
-		// Auto-size
 		const img = inputTex.image;
 		if ( img && img.width > 0 && img.height > 0 ) {
 
@@ -210,23 +233,20 @@ export class EdgeFilter extends RenderStage {
 
 		}
 
-		// Update input texture
 		this._inputTexNode.value = inputTex;
+		this._ndTexNode.value = ndTex;
 
-		// Update iteration count for progressive sharpening
 		this._iterations ++;
 		this.iterationCount.value = this._iterations;
 
-		// Dispatch compute
 		this.renderer.compute( this._computeNode );
 
-		// Copy StorageTexture → RenderTarget for downstream readability
-		// Use Box2 srcRegion since StorageTexture is pre-allocated at max size
+		// Copy out of the over-allocated StorageTexture into the right-sized
+		// RenderTarget; downstream stages can sample the latter.
 		this._srcRegion.min.set( 0, 0 );
 		this._srcRegion.max.set( this.outputTarget.width, this.outputTarget.height );
 		this.renderer.copyTextureToTexture( this._outputStorageTex, this.outputTarget.texture, this._srcRegion );
 
-		// Publish RenderTarget texture (NOT StorageTexture)
 		context.setTexture( 'edgeFiltering:output', this.outputTarget.texture );
 
 	}
@@ -240,9 +260,11 @@ export class EdgeFilter extends RenderStage {
 	updateUniforms( params ) {
 
 		if ( ! params ) return;
-		if ( params.pixelEdgeSharpness !== undefined ) this.pixelEdgeSharpness.value = params.pixelEdgeSharpness;
-		if ( params.edgeSharpenSpeed !== undefined ) this.edgeSharpenSpeed.value = params.edgeSharpenSpeed;
+		if ( params.filterStrength !== undefined ) this.filterStrength.value = params.filterStrength;
+		if ( params.strengthDecaySpeed !== undefined ) this.strengthDecaySpeed.value = params.strengthDecaySpeed;
 		if ( params.edgeThreshold !== undefined ) this.edgeThreshold.value = params.edgeThreshold;
+		if ( params.phiNormal !== undefined ) this.phiNormal.value = params.phiNormal;
+		if ( params.phiDepth !== undefined ) this.phiDepth.value = params.phiDepth;
 
 	}
 
@@ -255,15 +277,12 @@ export class EdgeFilter extends RenderStage {
 
 	setSize( width, height ) {
 
-		// Only resize the RenderTarget — StorageTexture stays at max allocation
-		// (see constructor note: pre-allocation is a defensive pattern, retained
-		// after r184 fixed #32969, because #33061 is still open.)
+		// StorageTexture stays at its max allocation (see constructor).
 		this.outputTarget.setSize( width, height );
 		this.outputTarget.texture.needsUpdate = true;
 		this.resW.value = width;
 		this.resH.value = height;
 
-		// Update dispatch dimensions
 		this._dispatchX = Math.ceil( width / 16 );
 		this._dispatchY = Math.ceil( height / 16 );
 		this._computeNode.dispatchSize = [ this._dispatchX, this._dispatchY, 1 ];
@@ -276,6 +295,7 @@ export class EdgeFilter extends RenderStage {
 		this._outputStorageTex?.dispose();
 		this.outputTarget?.dispose();
 		this._inputTexNode?.dispose();
+		this._ndTexNode?.dispose();
 
 	}