rayzee 7.10.2 → 7.11.0

package/src/Stages/EdgeFilter.js

@@ -1,23 +1,52 @@
-import { Fn, vec4, float, int, uint, ivec2, uvec2, uniform,
-	If, dot, max, abs, mix, pow, step,
+import { Fn, vec3, vec4, float, int, uint, ivec2, uvec2, uniform,
+	If, dot, max, mix, pow, sqrt, select,
 	textureLoad, textureStore, localId, workgroupId } from 'three/tsl';
 import { RenderTarget, TextureNode, StorageTexture } from 'three/webgpu';
-import { HalfFloatType, RGBAFormat, NearestFilter, Box2, Vector2 } from 'three';
+import { FloatType, RGBAFormat, LinearFilter, Box2, Vector2 } from 'three';
 import { RenderStage, StageExecutionMode } from '../Pipeline/RenderStage.js';
-import { REC709_LUMINANCE_COEFFICIENTS } from '../TSL/Common.js';
-import { MAX_STORAGE_TEXTURE_SIZE } from '../EngineDefaults.js';
+import { luminance } from '../TSL/Common.js';
+import { ALBEDO_EPS, MAX_STORAGE_TEXTURE_SIZE } from '../EngineDefaults.js';
+
+// NormalDepth writes depth ≈ 65504 for miss (env/background) rays. This sits below
+// the sentinel and above any real ray distance, so it's a clean hit/miss flag.
+const MISS_THRESHOLD = 6e4;
+
+// NaN/±Inf guard on demodulated lighting: dividing color by a near-zero albedo can
+// blow up, and one poisoned tap would smear through the à-trous passes. Per-channel:
+// NaN (x≠x) → 0, ±Inf clamped to a bounded HDR range. Ceiling matches ASVGF/Variance
+// (1e7); the FloatType ping-pong textures hold it without HalfFloat's 65k clip.
+const sanitize1 = ( x ) => select( x.equal( x ), x, float( 0.0 ) ).clamp( 0.0, 1e7 );
+const sanitizeRGB = ( c ) => vec3( sanitize1( c.x ), sanitize1( c.y ), sanitize1( c.z ) );
+
+// 5×5 à-trous kernel weights (B3-spline / Gaussian approx, Σ = 1.0).
+const ATROUS_KERNEL = [
+	1.0 / 256.0, 4.0 / 256.0, 6.0 / 256.0, 4.0 / 256.0, 1.0 / 256.0,
+	4.0 / 256.0, 16.0 / 256.0, 24.0 / 256.0, 16.0 / 256.0, 4.0 / 256.0,
+	6.0 / 256.0, 24.0 / 256.0, 36.0 / 256.0, 24.0 / 256.0, 6.0 / 256.0,
+	4.0 / 256.0, 16.0 / 256.0, 24.0 / 256.0, 16.0 / 256.0, 4.0 / 256.0,
+	1.0 / 256.0, 4.0 / 256.0, 6.0 / 256.0, 4.0 / 256.0, 1.0 / 256.0,
+];
 
 /**
  * WebGPU Edge-Aware Filtering Stage (Compute Shader).
  *
- * 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.
+ * A spatial-only SVGF à-trous denoiser (Dammertz 2010 + Schied 2017 edge-stops)
+ * that runs directly on the progressively-accumulated frame — no temporal
+ * reprojection, motion vectors, or history buffers, so it is free of the
+ * ghosting/lag artefacts of the ASVGF chain. Intended for static-camera
+ * progressive rendering where a light, artefact-free spatial filter is wanted.
  *
- * Reads:     pathtracer:color (or asvgf:output / bilateralFiltering:output)
- *            and pathtracer:normalDepth
+ * Pipeline per frame:
+ *   1. Demodulate: lighting = color / albedo (miss rays use a neutral albedo so
+ *      bright HDR sky neither overflows the divide nor gets zeroed on remodulate).
+ *   2. À-trous: `iterations` ping-pong passes with step size 2^i over a dense
+ *      5×5 Gaussian kernel, growing the effective footprint to tens of pixels.
+ *      Edge-stops: variance-guided luminance σ (from variance:output), a
+ *      shading-normal cone, and a scale-invariant relative depth gate.
+ *   3. Remodulate + strength blend on the final pass.
+ *
+ * Reads:     pathtracer:color, pathtracer:normalDepth, pathtracer:shadingNormal,
+ *            pathtracer:albedo, variance:output
  * Publishes: edgeFiltering:output
  * Mode:      PER_CYCLE
  */
@@ -32,45 +61,58 @@ export class EdgeFilter extends RenderStage {
 
 		this.renderer = renderer;
 
-		// 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 );
+		// filterStrength: final blend, 0 = raw color, 1 = fully filtered.
+		// phiLuminance: variance-scaled luminance edge-stop (bigger = more blending).
+		// phiNormal:    normal cone exponent (bigger = tighter, preserves more edges).
+		// phiDepth:     RELATIVE depth tolerance (fraction of ray distance, scale-invariant).
+		this.filterStrength = uniform( options.filterStrength ?? 1.0 );
+		this.phiLuminance = uniform( options.phiLuminance ?? 4.0 );
+		this.phiNormal = uniform( options.phiNormal ?? 64.0 );
+		this.phiDepth = uniform( options.phiDepth ?? 0.1 );
+		this.iterations = options.atrousIterations ?? options.edgeAtrousIterations ?? 5;
+
+		this.stepSizeU = uniform( 1, 'int' );
+		this.isLastIterationU = uniform( 0, 'int' );
 		this.resW = uniform( options.width || 1 );
 		this.resH = uniform( options.height || 1 );
 
-		this._iterations = 0;
-
-		this._inputTexNode = new TextureNode();
+		// Input texture nodes (RenderTarget-backed — safe to bind pre-compile).
+		this._colorTexNode = new TextureNode();
 		this._ndTexNode = new TextureNode();
+		this._snTexNode = new TextureNode();
+		this._albedoTexNode = new TextureNode();
+		this._varTexNode = new TextureNode();
+
+		// À-trous read node: defaults to EmptyTexture at compile time so the WGSL
+		// codegen emits the `level` parameter required for later StorageTexture reads.
+		this._readTexNode = new TextureNode();
 
-		// Pre-allocate StorageTexture at max — defensive against three.js #33061
-		// (TSL compute pipeline re-compile returns zeros after resize).
 		const w = options.width || 1;
 		const h = options.height || 1;
 
-		this._outputStorageTex = new StorageTexture( MAX_STORAGE_TEXTURE_SIZE, MAX_STORAGE_TEXTURE_SIZE );
-		this._outputStorageTex.type = HalfFloatType;
-		this._outputStorageTex.format = RGBAFormat;
-		this._outputStorageTex.minFilter = NearestFilter;
-		this._outputStorageTex.magFilter = NearestFilter;
+		// Pre-allocate StorageTextures at max — defensive against three.js #33061
+		// (TSL compute pipeline keeps a stale GPUTextureView after setSize()).
+		// LinearFilter required for textureLoad codegen on StorageTextures.
+		this._demodTex = this._makeStorageTex(); // demodulated lighting (pre-pass output)
+		this._storageTexA = this._makeStorageTex(); // à-trous ping
+		this._storageTexB = this._makeStorageTex(); // à-trous pong
 
 		this._srcRegion = new Box2( new Vector2( 0, 0 ), new Vector2( 0, 0 ) );
 
+		// Active-size RT published downstream (UV-sampled); the over-allocated
+		// StorageTexture must not be published — UV sampling reads the wrong region.
+		// FloatType to match the storage textures so copyTextureToTexture is format-compatible.
 		this.outputTarget = new RenderTarget( w, h, {
-			type: HalfFloatType,
+			type: FloatType,
 			format: RGBAFormat,
-			minFilter: NearestFilter,
-			magFilter: NearestFilter,
+			minFilter: LinearFilter,
+			magFilter: LinearFilter,
 			depthBuffer: false,
 			stencilBuffer: false
 		} );
 
+		this._compiled = false;
+
 		this._dispatchX = Math.ceil( w / 16 );
 		this._dispatchY = Math.ceil( h / 16 );
 
@@ -78,17 +120,88 @@ export class EdgeFilter extends RenderStage {
 
 	}
 
+	_makeStorageTex() {
+
+		// FloatType: demodulated lighting on dark materials (color / 0.01) exceeds
+		// HalfFloat's 65k cap on HDR — same reason ASVGF's ping-pong is FloatType.
+		const tex = new StorageTexture( MAX_STORAGE_TEXTURE_SIZE, MAX_STORAGE_TEXTURE_SIZE );
+		tex.type = FloatType;
+		tex.format = RGBAFormat;
+		tex.minFilter = LinearFilter;
+		tex.magFilter = LinearFilter;
+		return tex;
+
+	}
+
 	_buildCompute() {
 
-		const inputTex = this._inputTexNode;
+		this._computeDemod = this._buildDemod();
+		// One à-trous node per ping-pong write direction.
+		this._computeAtrousA = this._buildAtrous( this._storageTexA );
+		this._computeAtrousB = this._buildAtrous( this._storageTexB );
+
+	}
+
+	// Demodulate pass: lighting = color / albedo, written to _demodTex.
+	_buildDemod() {
+
+		const colorTex = this._colorTexNode;
+		const ndTex = this._ndTexNode;
+		const albedoTex = this._albedoTexNode;
+		const demodTex = this._demodTex;
+		const resW = this.resW;
+		const resH = this.resH;
+
+		const WG_SIZE = 16;
+
+		const computeFn = Fn( () => {
+
+			const gx = int( workgroupId.x ).mul( WG_SIZE ).add( int( localId.x ) );
+			const gy = int( workgroupId.y ).mul( WG_SIZE ).add( int( localId.y ) );
+
+			If( gx.lessThan( int( resW ) ).and( gy.lessThan( int( resH ) ) ), () => {
+
+				const coord = ivec2( gx, gy );
+				const color = textureLoad( colorTex, coord ).xyz;
+				const depth = textureLoad( ndTex, coord ).w;
+				const isHit = depth.lessThan( float( MISS_THRESHOLD ) );
+
+				// Miss rays (env/background) have black aux albedo — dividing by it would
+				// overflow HalfFloat on bright HDR sky and remodulate back to zero. Use a
+				// neutral albedo of 1 for misses so the demod/remod round-trip is identity.
+				const albedo = textureLoad( albedoTex, coord ).xyz;
+				const demodAlbedo = select( isHit, max( albedo, vec3( ALBEDO_EPS ) ), vec3( 1.0 ) );
+
+				const lighting = sanitizeRGB( color.div( demodAlbedo ) );
+
+				textureStore( demodTex, uvec2( uint( gx ), uint( gy ) ), vec4( lighting, 1.0 ) ).toWriteOnly();
+
+			} );
+
+		} );
+
+		return computeFn().compute(
+			[ this._dispatchX, this._dispatchY, 1 ],
+			[ WG_SIZE, WG_SIZE, 1 ]
+		);
+
+	}
+
+	// À-trous pass over demodulated lighting, writing to `writeStorageTex`.
+	_buildAtrous( writeStorageTex ) {
+
+		const readTex = this._readTexNode;
+		const colorTex = this._colorTexNode;
 		const ndTex = this._ndTexNode;
-		const outputStorageTex = this._outputStorageTex;
+		const snTex = this._snTexNode;
+		const albedoTex = this._albedoTexNode;
+		const varTex = this._varTexNode;
 		const filterStrength = this.filterStrength;
-		const decaySpeed = this.strengthDecaySpeed;
-		const threshold = this.edgeThreshold;
+		const phiLuminance = this.phiLuminance;
 		const phiNormal = this.phiNormal;
 		const phiDepth = this.phiDepth;
-		const iterCount = this.iterationCount;
+		const stepSize = this.stepSizeU;
+		const isLastIterationU = this.isLastIterationU;
 		const resW = this.resW;
 		const resH = this.resH;
 
@@ -102,65 +215,68 @@ export class EdgeFilter extends RenderStage {
 			If( gx.lessThan( int( resW ) ).and( gy.lessThan( int( resH ) ) ), () => {
 
 				const coord = ivec2( gx, gy );
-				const center = textureLoad( inputTex, coord ).xyz;
-				const centerLum = dot( center, REC709_LUMINANCE_COEFFICIENTS );
-
-				// NormalDepth writes (0,0,0, 65504) 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. Threshold
-				// sits below the 65504 sentinel (and above any real depth).
-				const MISS_THRESHOLD = 6e4;
+
+				const centerLighting = textureLoad( readTex, coord ).xyz;
+				const centerLum = luminance( centerLighting );
 				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();
+				// Shading (bump-perturbed) normal so normal/bump detail isn't collapsed.
+				const centerNormal = textureLoad( snTex, coord ).xyz.mul( 2.0 ).sub( 1.0 );
+				const centerIsHitBool = centerDepth.lessThan( float( MISS_THRESHOLD ) );
+				const centerIsHit = select( centerIsHitBool, float( 1.0 ), float( 0.0 ) );
 
-				const effectiveStrength = filterStrength.sub( iterCount.mul( decaySpeed ) ).clamp( 0.0, 1.0 );
+				const centerAlbedo = textureLoad( albedoTex, coord ).xyz;
+				const demodAlbedo = select( centerIsHitBool, max( centerAlbedo, vec3( ALBEDO_EPS ) ), vec3( 1.0 ) );
+				const centerAlbedoLum = max( luminance( demodAlbedo ), float( ALBEDO_EPS ) );
 
-				const colorSum = center.toVar();
-				const weightSum = float( 1.0 ).toVar();
+				// Variance-guided luminance σ (SVGF). .z = temporal, .w = spatial variance;
+				// max() falls back to the spatial estimate as temporal collapses on a
+				// converging accumulation buffer. Dividing by albedoLum rescales the
+				// modulated-space variance into demodulated space (std ∝ 1/albedo).
+				const vSample = textureLoad( varTex, coord );
+				const variance = max( vSample.z, vSample.w );
+				const sigmaL = phiLuminance.mul( sqrt( max( variance, float( 0.0 ) ) ) )
+					.div( centerAlbedoLum ).add( float( 0.0001 ) );
 
-				const dirs = [
-					[ 1, 0 ], [ 0, 1 ], [ - 1, 0 ], [ 0, - 1 ],
-					[ 1, 1 ], [ - 1, 1 ], [ - 1, - 1 ], [ 1, - 1 ],
-				];
+				const colorSum = vec3( 0.0 ).toVar();
+				const weightSum = float( 0.0 ).toVar();
 
-				for ( const [ dx, dy ] of dirs ) {
+				for ( let iy = 0; iy < 5; iy ++ ) {
 
-					for ( const dist of [ 1, 2 ] ) {
+					for ( let ix = 0; ix < 5; ix ++ ) {
 
-						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 sCoord = ivec2( sx, sy );
+						const dx = ix - 2;
+						const dy = iy - 2;
+						const kw = ATROUS_KERNEL[ iy * 5 + ix ];
 
-						const sColor = textureLoad( inputTex, sCoord ).xyz;
-						const sLum = dot( sColor, REC709_LUMINANCE_COEFFICIENTS );
+						const sx = gx.add( stepSize.mul( dx ) ).clamp( int( 0 ), int( resW ).sub( 1 ) );
+						const sy = gy.add( stepSize.mul( dy ) ).clamp( int( 0 ), int( resH ).sub( 1 ) );
+						const sCoord = ivec2( sx, sy );
 
+						const sLighting = textureLoad( readTex, sCoord ).xyz;
+						const sLum = luminance( sLighting );
 						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 sNormal = textureLoad( snTex, sCoord ).xyz.mul( 2.0 ).sub( 1.0 );
+						const sampleIsHit = select( sDepth.lessThan( float( MISS_THRESHOLD ) ), float( 1.0 ), float( 0.0 ) );
 
-						const lumW = abs( centerLum.sub( sLum ) ).div( max( threshold, float( 0.001 ) ) ).negate().exp();
+						const lumW = centerLum.sub( sLum ).abs().div( sigmaL ).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 to +inf → inf*0 = NaN.
+						const normW = pow( dot( centerNormal, sNormal ).clamp( 0.0, 1.0 ), phiNormal );
+						// Relative depth tolerance → scale-invariant across scene sizes.
+						const depW = centerDepth.sub( sDepth ).abs()
+							.div( max( centerDepth.mul( phiDepth ), float( 0.001 ) ) ).negate().exp();
 
 						const bothHit = centerIsHit.mul( sampleIsHit );
 						const bothMiss = centerIsHit.oneMinus().mul( sampleIsHit.oneMinus() );
 						const sameKind = bothHit.add( bothMiss );
 
-						// 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.
+						// Geometric weights are only meaningful for hit-vs-hit pairs.
 						const geomW = mix( float( 1.0 ), normW.mul( depW ), bothHit );
+						const w = float( kw ).mul( lumW ).mul( geomW ).mul( sameKind );
 
-						const distWeight = float( 1.0 ).div( float( dist ).add( 0.5 ) );
-						const w = lumW.mul( geomW ).mul( sameKind ).mul( distWeight );
-
-						colorSum.addAssign( sColor.mul( w ) );
+						colorSum.addAssign( sLighting.mul( w ) );
 						weightSum.addAssign( w );
 
 					}
@@ -168,28 +284,22 @@ export class EdgeFilter extends RenderStage {
 				}
 
 				const filtered = colorSum.div( max( weightSum, float( 0.0001 ) ) );
-				const finalColor = mix( center, filtered, effectiveStrength );
-
-				// Firefly clamp on output luminance.
-				const finalLum = dot( finalColor, REC709_LUMINANCE_COEFFICIENTS );
-				const clampedColor = finalColor.toVar();
-				If( finalLum.greaterThan( 10.0 ), () => {
 
-					clampedColor.assign( finalColor.mul( float( 10.0 ).div( finalLum ) ) );
+				// Final pass: remodulate by albedo and blend against the raw color by
+				// filterStrength. Inner passes stay in demodulated space.
+				const isLast = isLastIterationU.equal( int( 1 ) );
+				const rawColor = textureLoad( colorTex, coord ).xyz;
+				const remodded = filtered.mul( demodAlbedo );
+				const finalModulated = mix( rawColor, remodded, filterStrength );
+				const output = isLast.select( finalModulated, filtered );
 
-				} );
-
-				textureStore(
-					outputStorageTex,
-					uvec2( uint( gx ), uint( gy ) ),
-					vec4( clampedColor, 1.0 )
-				).toWriteOnly();
+				textureStore( writeStorageTex, uvec2( uint( gx ), uint( gy ) ), vec4( output, 1.0 ) ).toWriteOnly();
 
 			} );
 
 		} );
 
-		this._computeNode = computeFn().compute(
+		return computeFn().compute(
 			[ this._dispatchX, this._dispatchY, 1 ],
 			[ WG_SIZE, WG_SIZE, 1 ]
 		);
@@ -200,29 +310,31 @@ export class EdgeFilter extends RenderStage {
 
 		if ( ! this.enabled ) return;
 
-		const inputTex = context.getTexture( 'asvgf:output' )
-			|| context.getTexture( 'bilateralFiltering:output' )
-			|| context.getTexture( 'pathtracer:color' );
-
+		const colorTex = context.getTexture( 'pathtracer:color' );
 		const ndTex = context.getTexture( 'pathtracer:normalDepth' );
+		// Fall back to geometric normalDepth if the mapped normal isn't published.
+		const snTex = context.getTexture( 'pathtracer:shadingNormal' ) || ndTex;
+		const albedoTex = context.getTexture( 'pathtracer:albedo' );
+		const varTex = context.getTexture( 'variance:output' );
 
-		// Without the G-buffer there's no edge guidance — pass input through
-		// rather than producing a uniform blur.
-		if ( ! inputTex || ! ndTex ) {
+		// The SVGF filter needs color + geometry + albedo + variance. Without the full
+		// set there's no edge/variance guidance — pass the input through rather than
+		// producing an unguided blur.
+		if ( ! colorTex || ! ndTex || ! albedoTex || ! varTex ) {
 
-			if ( inputTex ) context.setTexture( 'edgeFiltering:output', inputTex );
+			if ( colorTex ) context.setTexture( 'edgeFiltering:output', colorTex );
 			return;
 
 		}
 
 		if ( context.getState( 'interactionMode' ) ) {
 
-			context.setTexture( 'edgeFiltering:output', inputTex );
+			context.setTexture( 'edgeFiltering:output', colorTex );
 			return;
 
 		}
 
-		const img = inputTex.image;
+		const img = colorTex.image;
 		if ( img && img.width > 0 && img.height > 0 ) {
 
 			if ( img.width !== this.outputTarget.width ||
@@ -234,18 +346,56 @@ export class EdgeFilter extends RenderStage {
 
 		}
 
-		this._inputTexNode.value = inputTex;
+		this._colorTexNode.value = colorTex;
 		this._ndTexNode.value = ndTex;
+		this._snTexNode.value = snTex;
+		this._albedoTexNode.value = albedoTex;
+		this._varTexNode.value = varTex;
+
+		// First-frame compile while _readTexNode still holds EmptyTexture — codegen
+		// then emits textureLoad with the level parameter the runtime requires for
+		// non-zero StorageTexture reads. The throwaway dispatches also initialise the
+		// ping-pong textures. _readTexNode must NOT be assigned before this.
+		if ( ! this._compiled ) {
+
+			this.renderer.compute( this._computeDemod );
+			this.renderer.compute( this._computeAtrousA );
+			this.renderer.compute( this._computeAtrousB );
+			this._compiled = true;
+
+		}
 
-		this._iterations ++;
-		this.iterationCount.value = this._iterations;
+		// 1. Demodulate → _demodTex.
+		this.renderer.compute( this._computeDemod );
 
-		this.renderer.compute( this._computeNode );
+		// 2. À-trous iterations: step 2^i, ping-pong write direction. First pass reads
+		//    _demodTex; the last pass remodulates + strength-blends.
+		let readTex = this._demodTex;
+		let writeNode = this._computeAtrousA;
+		let nextWriteNode = this._computeAtrousB;
+
+		for ( let i = 0; i < this.iterations; i ++ ) {
+
+			this.stepSizeU.value = 1 << i;
+			this.isLastIterationU.value = ( i === this.iterations - 1 ) ? 1 : 0;
+			this._readTexNode.value = readTex;
+
+			this.renderer.compute( writeNode );
+
+			readTex = ( writeNode === this._computeAtrousA )
+				? this._storageTexA
+				: this._storageTexB;
+
+			const tmp = writeNode;
+			writeNode = nextWriteNode;
+			nextWriteNode = tmp;
+
+		}
 
-		// Copy out of the over-allocated StorageTexture into the right-sized
-		// RenderTarget; downstream stages can sample the latter.
+		// Copy the final result out of the over-allocated StorageTexture into the
+		// active-size RenderTarget; downstream stages UV-sample the latter.
 		this._srcRegion.max.set( this.outputTarget.width, this.outputTarget.height );
-		this.renderer.copyTextureToTexture( this._outputStorageTex, this.outputTarget.texture, this._srcRegion );
+		this.renderer.copyTextureToTexture( readTex, this.outputTarget.texture, this._srcRegion );
 
 		context.setTexture( 'edgeFiltering:output', this.outputTarget.texture );
 
@@ -261,35 +411,35 @@ export class EdgeFilter extends RenderStage {
 
 		if ( ! params ) return;
 		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.phiLuminance !== undefined ) this.phiLuminance.value = params.phiLuminance;
 		if ( params.phiNormal !== undefined ) this.phiNormal.value = params.phiNormal;
 		if ( params.phiDepth !== undefined ) this.phiDepth.value = params.phiDepth;
+		if ( params.atrousIterations !== undefined ) this.iterations = params.atrousIterations;
 
 	}
 
-	// Free the 2048² StorageTexture when disabled; three.js re-creates it on the next dispatch
-	// after re-enable, and reset() clears the iteration history. See ASVGF.releaseGPUMemory.
+	// Free the 2048² StorageTextures when disabled; three.js re-creates them on the next dispatch
+	// after re-enable (no temporal state to re-anchor). See ASVGF.releaseGPUMemory.
 	releaseGPUMemory() {
 
-		this._outputStorageTex?.dispose();
+		this._demodTex?.dispose();
+		this._storageTexA?.dispose();
+		this._storageTexB?.dispose();
 		// Render-res RT texture (dispose .texture, not the RT — RT.dispose() doesn't free it here).
 		this.context?.removeTexture( 'edgeFiltering:output' );
 		this.outputTarget?.texture?.dispose();
-		this.reset();
 
 	}
 
 	reset() {
 
-		this._iterations = 0;
-		this.iterationCount.value = 0;
+		// No per-frame or temporal state — variance guidance is owned by the Variance stage.
 
 	}
 
 	setSize( width, height ) {
 
-		// StorageTexture stays at its max allocation (see constructor).
+		// StorageTextures stay at their max allocation (see constructor).
 		this.outputTarget.setSize( width, height );
 		this.outputTarget.texture.needsUpdate = true;
 		this.resW.value = width;
@@ -297,17 +447,28 @@ export class EdgeFilter extends RenderStage {
 
 		this._dispatchX = Math.ceil( width / 16 );
 		this._dispatchY = Math.ceil( height / 16 );
-		this._computeNode.dispatchSize = [ this._dispatchX, this._dispatchY, 1 ];
+		const size = [ this._dispatchX, this._dispatchY, 1 ];
+		this._computeDemod.dispatchSize = size;
+		this._computeAtrousA.dispatchSize = size;
+		this._computeAtrousB.dispatchSize = size;
 
 	}
 
 	dispose() {
 
-		this._computeNode?.dispose();
-		this._outputStorageTex?.dispose();
+		this._computeDemod?.dispose();
+		this._computeAtrousA?.dispose();
+		this._computeAtrousB?.dispose();
+		this._demodTex?.dispose();
+		this._storageTexA?.dispose();
+		this._storageTexB?.dispose();
 		this.outputTarget?.dispose();
-		this._inputTexNode?.dispose();
+		this._colorTexNode?.dispose();
 		this._ndTexNode?.dispose();
+		this._snTexNode?.dispose();
+		this._albedoTexNode?.dispose();
+		this._varTexNode?.dispose();
+		this._readTexNode?.dispose();
 
 	}
 

package/src/TSL/Clearcoat.js

@@ -2,6 +2,7 @@ import {
 	Fn,
 	vec3,
 	float,
+	dot,
 	normalize,
 	reflect,
 	max,
@@ -10,10 +11,10 @@ import {
 
 import { struct } from './patches.js';
 
-import { DotProducts } from './Struct.js';
-import { PI, MIN_CLEARCOAT_ROUGHNESS, computeDotProducts } from './Common.js';
-import { DistributionGGX } from './MaterialProperties.js';
-import { ImportanceSampleGGX, ImportanceSampleCosine } from './MaterialSampling.js';
+import { AnisoFrame, DotProducts } from './Struct.js';
+import { PI, MIN_CLEARCOAT_ROUGHNESS, computeDotProductsAniso, anisoTangentFrame } from './Common.js';
+import { DistributionGGX, computeAnisoAlphas, calculateVNDFPDFAniso } from './MaterialProperties.js';
+import { ImportanceSampleGGX, ImportanceSampleCosine, sampleGGXVNDFAniso } from './MaterialSampling.js';
 import { evaluateLayeredBRDF } from './MaterialEvaluation.js';
 import { RandomValue } from './Random.js';
 
@@ -62,8 +63,20 @@ export const sampleClearcoat = Fn( ( [
 
 	} ).ElseIf( rand.lessThan( clearcoatWeight.add( specularWeight ) ), () => {
 
-		// Sample base specular
-		H.assign( ImportanceSampleGGX( { N, roughness: baseRoughness, Xi: randomSample } ) );
+		// Sample base specular (anisotropic VNDF when anisotropy > 0)
+		If( material.anisotropy.greaterThan( 0.0 ), () => {
+
+			const f = AnisoFrame.wrap( anisoTangentFrame( N, material.anisotropyRotation ) );
+			const localV = vec3( dot( V, f.Ta ), dot( V, f.Ba ), dot( V, N ) );
+			const a = computeAnisoAlphas( material.roughness, material.anisotropy );
+			const localH = sampleGGXVNDFAniso( { V: localV, alphaX: a.x, alphaY: a.y, Xi: randomSample } );
+			H.assign( f.Ta.mul( localH.x ).add( f.Ba.mul( localH.y ) ).add( N.mul( localH.z ) ) );
+
+		} ).Else( () => {
+
+			H.assign( ImportanceSampleGGX( { N, roughness: baseRoughness, Xi: randomSample } ) );
+
+		} );
 		L.assign( reflect( V.negate(), H ) );
 
 	} ).Else( () => {
@@ -74,12 +87,23 @@ export const sampleClearcoat = Fn( ( [
 
 	} );
 
-	// Calculate dot products
-	const dots = DotProducts.wrap( computeDotProducts( N, V, L ) );
+	// Calculate dot products (aniso-aware: also projects onto the anisotropy frame)
+	const dots = DotProducts.wrap( computeDotProductsAniso( N, V, L, material ) );
 
-	// Calculate individual PDFs
+	// Calculate individual PDFs. Clearcoat layer is always isotropic; the base specular
+	// matches its sampler — VNDF-aniso when anisotropy>0, else the half-vector GGX pdf.
 	const clearcoatPDF = DistributionGGX( dots.NoH, clearcoatRoughness ).mul( dots.NoH ).div( float( 4.0 ).mul( dots.VoH ) ).mul( clearcoatWeight );
-	const specularPDF = DistributionGGX( dots.NoH, baseRoughness ).mul( dots.NoH ).div( float( 4.0 ).mul( dots.VoH ) ).mul( specularWeight );
+	const specularPDF = float( 0.0 ).toVar();
+	If( material.anisotropy.greaterThan( 0.0 ), () => {
+
+		const a = computeAnisoAlphas( material.roughness, material.anisotropy );
+		specularPDF.assign( calculateVNDFPDFAniso( a.x, a.y, dots.NoH, dots.ToH, dots.BoH, dots.NoV, dots.ToV, dots.BoV ).mul( specularWeight ) );
+
+	} ).Else( () => {
+
+		specularPDF.assign( DistributionGGX( dots.NoH, baseRoughness ).mul( dots.NoH ).div( float( 4.0 ).mul( dots.VoH ) ).mul( specularWeight ) );
+
+	} );
 	const diffusePDF = dots.NoL.div( PI ).mul( diffuseWeight );
 
 	// Combined PDF using MIS