three/examples/jsm/tsl/display/RecurrentDenoiseNode.js

JavaScript 3D library

import { abs, atan, bool, convertToTexture, cos, cross, Discard, dot, EPSILON, exp, float, Fn, getScreenPosition, getViewPosition, If, int, log, Loop, luminance, mat2, max, mix, nodeObject, NodeUpdateType, normalize, passTexture, PI, property, reflect, sin, smoothstep, sqrt, tan, texture, uniform, unpackRGBToNormal, uv, vec2, vec3, vec4 } from 'three/tsl';
import { HalfFloatType, MathUtils, Matrix4, NodeMaterial, QuadMesh, RendererUtils, RenderTarget, TempNode, Vector2 } from 'three/webgpu';
import { bindAnalyticNoise } from '../utils/RNoise.js';
import { ENV_RAY_LENGTH_THRESHOLD } from '../utils/SpecularHelpers.js';

const _quadMesh = /*@__PURE__*/ new QuadMesh();
const _size = /*@__PURE__*/ new Vector2();

let _rendererState;

const KERNEL_SAMPLES = 8;
const NOISE_ROTATION_SEED = 83;
const WORLD_RADIUS_SCALE = 0.1;

const AO_EDGE_STOPPING_BIAS = 0.05;
const AGGRESSIVITY_RADIUS_MIN = 0.001;
const DIFFUSE_CHROMA_WEIGHT = 2.0;
// Neighborhood luma coefficient-of-variation thresholds for gating the temporal inverse-luminance
// (firefly) suppression: below MIN the region is treated as flicker-free, above MAX as noisy.
const FLICKER_COV_GATE_MIN = 0.1;
const FLICKER_COV_GATE_MAX = 2;

/**
 * Golden-angle Vogel disk offset.
 *
 * @tsl
 */
const vogelDisk = Fn( ( [ i, radius ] ) => {

	const sampleCount = 8;
	const theta = i.add( 0.5 ).mul( 2.399827721492203 );
	const r = radius.mul( sqrt( i.add( 0.5 ).div( sampleCount ) ) );
	return vec2( cos( theta ), sin( theta ) ).mul( r );

} ).setLayout( {
	name: 'vogelDisk',
	type: 'vec2',
	inputs: [
		{ name: 'i', type: 'float' },
		{ name: 'radius', type: 'float' }
	]
} );

/**
 * Chromatic color-similarity distance between two linear base colors (albedo).
 *
 * @tsl
 */
const diffuseColorDistance = Fn( ( [ a, b, compressLuma ] ) => {

	const toYCoCg = ( c ) => vec3(
		dot( c, vec3( 0.25, 0.5, 0.25 ) ),
		c.r.sub( c.b ),
		c.g.sub( c.r.add( c.b ).mul( 0.5 ) )
	);

	const ya = toYCoCg( a );
	const yb = toYCoCg( b );

	// `compressLuma` (0/1) range-compresses the luma term with log(1+L) so a fixed lumaPhi gives
	// scale-invariant differences across the HDR range. 0 leaves luma linear (used for LDR albedo).
	const compress = ( L ) => mix( L, log( L.add( 1 ) ), compressLuma );

	const dLuma = abs( compress( ya.x ).sub( compress( yb.x ) ) );
	const dChroma = vec2( ya.y.sub( yb.y ), ya.z.sub( yb.z ) ).length();

	return dLuma.add( dChroma.mul( DIFFUSE_CHROMA_WEIGHT ) );

} ).setLayout( {
	name: 'diffuseColorDistance',
	type: 'float',
	inputs: [
		{ name: 'a', type: 'vec3' },
		{ name: 'b', type: 'vec3' },
		{ name: 'compressLuma', type: 'float' }
	]
} );

const _temporalWeight = Fn( ( [ x, strength ] ) => float( 1 ).div( x.pow( strength ) ) ).setLayout( {
	name: 'temporalWeight',
	type: 'float',
	inputs: [
		{ name: 'x', type: 'float' },
		{ name: 'strength', type: 'float' }
	]
} );

/**
 * Temporal accumulation variance factor in `[0, 1]`. Higher values mean more history confidence.
 *
 * @tsl
 */
const getTemporalVarianceFactor = Fn( ( [ frameNum, strength ] ) => {

	return _temporalWeight( frameNum, strength ).max( 0.05 );

} ).setLayout( {
	name: 'getTemporalVarianceFactor',
	type: 'float',
	inputs: [
		{ name: 'frameNum', type: 'float' },
		{ name: 'strength', type: 'float' }
	]
} );

/**
 * World-space frustum height at `viewZ`. Algorithm originally from REBLUR (NRD).
 * `tanHalfFovY` is `tan( verticalFov / 2 )`, hoisted by the caller since it is loop-invariant.
 *
 * @tsl
 */
const computeFrustumSize = Fn( ( [ viewZ, tanHalfFovY ] ) => {

	return float( 2 ).mul( viewZ ).mul( tanHalfFovY );

} ).setLayout( {
	name: 'computeFrustumSize',
	type: 'float',
	inputs: [
		{ name: 'viewZ', type: 'float' },
		{ name: 'tanHalfFovY', type: 'float' }
	]
} );

/**
 * Maps world-space SSR ray length to `[0, 1]`. Environment rays (`worldRayLength == 0`) map to `1`.
 * Algorithm originally from REBLUR (NRD).
 *
 * @tsl
 */
const computeHitDistFactor = Fn( ( [ worldRayLength, viewZ, tanHalfFovY ] ) => {

	const frustumSize = computeFrustumSize( viewZ, tanHalfFovY );
	const factor = worldRayLength.div( frustumSize.max( 1e-6 ) ).clamp( 0, 1 );

	return factor;

} ).setLayout( {
	name: 'computeHitDistFactor',
	type: 'float',
	inputs: [
		{ name: 'worldRayLength', type: 'float' },
		{ name: 'viewZ', type: 'float' },
		{ name: 'tanHalfFovY', type: 'float' }
	]
} );

/**
 * Maps an AO factor for edge-stopping comparisons.
 *
 * @tsl
 */
const mapAo = Fn( ( [ aoVal ] ) => aoVal.pow( 0.1 ) );

/**
 * Specular dominant direction — smooth surfaces lean toward reflection, rough toward normal.
 *
 * @tsl
 */
const getSpecularDominantDirection = Fn( ( [ N, V, roughness ] ) => {

	return normalize( mix( N, reflect( V.negate(), N ), roughness.oneMinus() ) );

} ).setLayout( {
	name: 'getSpecularDominantDirection',
	type: 'vec3',
	inputs: [
		{ name: 'N', type: 'vec3' },
		{ name: 'V', type: 'vec3' },
		{ name: 'roughness', type: 'float' }
	]
} );

/**
 * GGX inverse-CDF: half-angle tangent enclosing `percent` of the specular lobe volume.
 * `roughness` is perceptual (alpha = roughness²).
 *
 * @tsl
 */
const specularLobeTanHalfAngle = Fn( ( [ roughness, percent ] ) => {

	const alpha = roughness.mul( roughness );
	return alpha.mul( sqrt( percent.div( float( 1 ).sub( percent ).max( 1e-6 ) ) ) );

} ).setLayout( {
	name: 'specularLobeTanHalfAngle',
	type: 'float',
	inputs: [
		{ name: 'roughness', type: 'float' },
		{ name: 'percent', type: 'float' }
	]
} );

const EXP_WEIGHT_SCALE = 4;
const NORMAL_ENCODING_ERROR = 1.5 / 255;

/**
 * Loop-invariant part of the adaptive normal edge-stopping weight: the Gaussian falloff
 * constant `2·EXP_WEIGHT_SCALE / lobeHalfAngle²`. `roughness`/`aggressivity`/`invNormalPhi`
 * are constant across the kernel, so this is hoisted out of the tap loop and evaluated once
 * per pixel. Lobe half-angle from REBLUR (NRD).
 *
 * @tsl
 */
const lobeNormalFalloff = Fn( ( [ roughness, aggressivity, invNormalPhi ] ) => {

	const percent = mix( invNormalPhi.pow2(), float( 0 ), aggressivity.sqrt() ).clamp( 0.1, 0.99 );
	const tanHalfAngle = specularLobeTanHalfAngle( roughness, percent );
	const lobeHalfAngle = max( atan( tanHalfAngle ), float( NORMAL_ENCODING_ERROR ) );

	const invHalfAngle = float( 1 ).div( lobeHalfAngle );
	return invHalfAngle.mul( invHalfAngle ).mul( 2 * EXP_WEIGHT_SCALE );

} ).setLayout( {
	name: 'lobeNormalFalloff',
	type: 'float',
	inputs: [
		{ name: 'roughness', type: 'float' },
		{ name: 'aggressivity', type: 'float' },
		{ name: 'invNormalPhi', type: 'float' }
	]
} );

/**
 * Adaptive lobe normal edge-stopping weight
 *
 * Evaluated entirely in cosine space: with `angle² ≈ 2(1 − cosθ)`, the original
 * `exp( −SCALE·angle/halfAngle )` becomes a Gaussian `exp( falloff·(cosθ − 1) )`, so a
 * single `exp` replaces the per-tap `acos`. Matches the original at the half-angle for
 * narrow lobes and is slightly more permissive for wide (diffuse) ones.
 *
 * @tsl
 */
const lobeNormalWeight = Fn( ( [ viewNormal, nNormalV, lobeFalloff ] ) => {

	const cosA = dot( viewNormal, nNormalV );

	return exp( cosA.sub( 1 ).mul( lobeFalloff ) );

} ).setLayout( {
	name: 'lobeNormalWeight',
	type: 'float',
	inputs: [
		{ name: 'viewNormal', type: 'vec3' },
		{ name: 'nNormalV', type: 'vec3' },
		{ name: 'lobeFalloff', type: 'float' }
	]
} );

/**
 * View-space plane distance between two surface points (edge-stopping geometry term).
 *
 * @tsl
 */
const planeDistance = Fn( ( [ position, nPosition, normal ] ) => {

	return abs( dot( position.sub( nPosition ), normal ) );

} ).setLayout( {
	name: 'planeDistance',
	type: 'float',
	inputs: [
		{ name: 'position', type: 'vec3' },
		{ name: 'nPosition', type: 'vec3' },
		{ name: 'normal', type: 'vec3' },
	]
} );

/**
 * Inverse-luminance temporal blend with optional adaptive trust (Karis-style).
 *
 * @tsl
 */
const karisTemporalBlend = Fn( ( [ denoisedRgb, denoisedRaw, a, flickerSuppression, adaptiveTrust, nbhdMeanLuma, nbhdStddevLuma ] ) => {

	const localCoV = nbhdStddevLuma.div( nbhdMeanLuma.max( 1e-4 ) );
	const trustSuppress = localCoV.mul( adaptiveTrust ).mul( a.oneMinus() ).clamp( 0, 0.9 );
	const aTrust = a.mul( trustSuppress.oneMinus() );

	// In flicker-free neighborhoods, back off the inverse-luminance weighting so valid bright highlights
	// keep their energy. Scaled by adaptiveTrust so the default (0) path is unchanged.
	const noisy = smoothstep( FLICKER_COV_GATE_MIN, FLICKER_COV_GATE_MAX, localCoV );
	const effFlicker = flickerSuppression.mul( mix( adaptiveTrust.oneMinus(), float( 1 ), noisy ) );

	const wHist = float( 1 ).sub( aTrust ).div( luminance( denoisedRgb ).mul( effFlicker ).mul( 10 ).add( 1 ) );
	const wRaw = aTrust.div( luminance( denoisedRaw ).mul( effFlicker ).mul( 10 ).add( 1 ) );
	return denoisedRgb.mul( wHist ).add( denoisedRaw.mul( wRaw ) ).div( wHist.add( wRaw ).max( EPSILON ) );

} ).setLayout( {
	name: 'karisTemporalBlend',
	type: 'vec3',
	inputs: [
		{ name: 'denoisedRgb', type: 'vec3' },
		{ name: 'denoisedRaw', type: 'vec3' },
		{ name: 'a', type: 'float' },
		{ name: 'flickerSuppression', type: 'float' },
		{ name: 'adaptiveTrust', type: 'float' },
		{ name: 'nbhdMeanLuma', type: 'float' },
		{ name: 'nbhdStddevLuma', type: 'float' }
	]
} );

const toTextureNode = ( value ) => {

	if ( value === null ) return null;

	if ( value.isTexture === true ) return texture( value );

	return convertToTexture( value.getTextureNode?.() ?? value );

};

/**
 * @typedef {'diffuse'|'specular'} DenoiseMode
 */

/**
 * @typedef {'raylength'|'ao'|'none'} DenoiseAlphaSource
 */

/**
 * @typedef {Object} RecurrentDenoiseNodeOptions
 * @property {?Node<float>} [depth=null] - Scene depth buffer for view-space edge stopping.
 * @property {?Node<vec3>} [normal=null] - View-space normals for geometric edge stopping.
 * @property {?Node<vec4>} [metalRoughness=null] - Roughness/metalness G-buffer for specular edge stopping.
 * @property {?Node<vec4>} [diffuse=null] - Scene base color (albedo) G-buffer for chromatic edge stopping.
 * @property {?Node<vec4>} [raw=null] - Unfiltered input (e.g. raw SSR/SSGI) for secondary sampling and temporal blend.
 * @property {DenoiseMode} [mode='diffuse'] - Denoising kernel type.
 * @property {boolean} [accumulate=true] - When `true`, temporally blend the spatially-denoised result
 * (Karis-style) and write frame weight to alpha for feedback loops. When `false`, only spatial filtering is applied.
 */

/**
 * Post processing node for denoising temporally-accumulated screen-space effects
 * such as SSGI (ambient occlusion / indirect diffuse) and SSR (specular reflections).
 *
 * The denoising kernel is selected at construction time via `mode`:
 * `'diffuse'` (SSGI) or `'specular'` (SSR). The kernel uses a fixed 8-sample Vogel disk.
 *
 * @augments TempNode
 * @three_import import { recurrentDenoise } from 'three/addons/tsl/display/RecurrentDenoiseNode.js';
 */
class RecurrentDenoiseNode extends TempNode {

	static get type() {

		return 'RecurrentDenoiseNode';

	}

	/**
	 * @param {TextureNode} inputTexture - Temporally filtered input to denoise (e.g. TRAA output).
	 * @param {Camera} camera
	 * @param {RecurrentDenoiseNodeOptions} [options={}]
	 */
	constructor( inputTexture, camera, options = {} ) {

		super( 'vec4' );

		const {
			depth = null,
			normal = null,
			metalRoughness = null,
			diffuse = null,
			raw = null,
			mode = 'diffuse',
			accumulate = true,
		} = options;

		this.isRecurrentDenoiseNode = true;
		this.camera = camera;

		/**
		 * Denoising kernel type.
		 *
		 * @type {DenoiseMode}
		 */
		this.mode = mode;

		/**
		 * When `true`, apply temporal blending after spatial denoising. When `false`, output spatially
		 * filtered colour only (alpha is passed through from the input temporal pass).
		 *
		 * @type {boolean}
		 */
		this.accumulate = accumulate;

		this.textureNode = inputTexture;
		this.depthNode = depth !== null ? nodeObject( depth ) : null;
		this.normalNode = normal !== null ? nodeObject( normal ) : null;
		this.rawNode = toTextureNode( raw );
		this.roughnessMetalnessNode = metalRoughness !== null ? nodeObject( metalRoughness ) : null;
		this.diffuseNode = diffuse !== null ? nodeObject( diffuse ) : null;

		this._noiseIndex = uniform( 0 );

		this.lumaPhi = uniform( 5 );
		this.depthPhi = uniform( 5 );
		this.normalPhi = uniform( 5 );
		this.radius = uniform( 5 );
		this.alphaPhi = uniform( 1 );
		this.roughnessPhi = uniform( 100 );
		this.diffusePhi = uniform( 100 );
		this.adapt = uniform( 0.5 );
		this.smoothDisocclusions = uniform( true, 'bool' );
		this.strength = uniform( 0.25 );
		this.maxFrames = uniform( 32 );

		/**
		 * Which channel of the raw texture drives alpha-based edge stopping.
		 * `'raylength'` — alpha encodes SSR ray length; `'ao'` — alpha encodes AO factor;
		 * `'none'` — skip alpha-based edge stopping.
		 *
		 * @type {DenoiseAlphaSource}
		 * @default 'raylength'
		 */
		this.alphaSource = 'raylength';

		this.flickerSuppression = uniform( 1 );
		this.adaptiveTrust = uniform( 0 );

		this.updateBeforeType = NodeUpdateType.FRAME;

		this._resolution = uniform( new Vector2() );
		this._fovY = uniform( MathUtils.degToRad( camera.fov ) );
		this._cameraProjectionMatrixInverse = uniform( new Matrix4().copy( camera.projectionMatrixInverse ) );
		this._cameraProjectionMatrix = uniform( new Matrix4().copy( camera.projectionMatrix ) );
		this._viewMatrix = uniform( new Matrix4().copy( camera.matrixWorldInverse ) );

		this._renderTarget = new RenderTarget( 1, 1, { depthBuffer: false, type: HalfFloatType } );
		this._renderTarget.texture.name = 'RecurrentDenoiseNode.output';

		this._material = new NodeMaterial();
		this._material.name = 'RecurrentDenoise';

		this._textureNode = passTexture( this, this._renderTarget.texture );

	}

	setSize( width, height ) {

		if ( width === null || height === null ) return;

		this._renderTarget.setSize( width, height );
		this._resolution.value.set( width, height );

	}

	getTextureNode() {

		return this._textureNode;

	}

	/**
	 * Returns the internal output render target (e.g. for temporal reprojection/SSGI temporal feedback loops).
	 *
	 * @returns {RenderTarget}
	 */
	getRenderTarget() {

		return this._renderTarget;

	}

	updateBefore( frame ) {

		const { renderer } = frame;

		const drawingBufferSize = renderer.getDrawingBufferSize( _size );
		const width = drawingBufferSize.width;
		const height = drawingBufferSize.height;

		const needsRestart = this._renderTarget.width !== width || this._renderTarget.height !== height;
		this.setSize( width, height );

		this._cameraProjectionMatrix.value.copy( this.camera.projectionMatrix );
		this._cameraProjectionMatrixInverse.value.copy( this.camera.projectionMatrixInverse );
		this._viewMatrix.value.copy( this.camera.matrixWorldInverse );

		if ( this.camera.isPerspectiveCamera ) {

			this._fovY.value = MathUtils.degToRad( this.camera.fov );

		}

		if ( frame.frameId !== undefined ) this._noiseIndex.value = frame.frameId;

		// Denoise renders via an internal _quadMesh, not through the RenderPipeline output graph.
		// Upstream passes (e.g. TemporalReprojectNode) referenced by a PassTextureNode input are
		// otherwise never scheduled, their updateBefore() would not run and this pass would sample
		// a stale/empty render target.
		if ( this.textureNode.isPassTextureNode === true ) frame.updateBeforeNode( this.textureNode.passNode );

		_rendererState = RendererUtils.resetRendererState( renderer, _rendererState );

		if ( needsRestart === true ) {

			renderer.initRenderTarget( this._renderTarget );
			renderer.setRenderTarget( this._renderTarget );
			renderer.clear();
			renderer.setRenderTarget( null );

		}

		renderer.setRenderTarget( this._renderTarget );
		_quadMesh.material = this._material;
		_quadMesh.name = 'RecurrentDenoise';
		_quadMesh.render( renderer );
		renderer.setRenderTarget( null );

		RendererUtils.restoreRendererState( renderer, _rendererState );

	}

	setup( builder ) {

		const sampleAnalyticNoise = bindAnalyticNoise( this._resolution, NOISE_ROTATION_SEED );

		const noiseRotationMatrix = Fn( ( [ r ] ) => {

			const angle = r.mul( 2 ).mul( PI );
			return mat2( cos( angle ), sin( angle ).negate(), sin( angle ), cos( angle ) );

		} );

		const sampleTexture = ( uvCoord ) => texture( this.textureNode, uvCoord ).max( 0 );
		const sampleRaw = ( uvCoord ) => this.rawNode?.sample( uvCoord )?.max( 0 ) ?? vec3( 0 ).max( 0 );
		const sampleDepth = ( uvCoord ) => this.depthNode?.sample( uvCoord )?.x ?? float( 0.5 );
		const sampleNormal = ( uvCoord ) => unpackRGBToNormal( this.normalNode?.sample( uvCoord )?.rgb ?? vec3( 0, 0, 1 ) );
		const sampleRoughnessMetalness = ( uvCoord ) => this.roughnessMetalnessNode?.sample( uvCoord )?.rg ?? vec2( 0, 1 );
		const sampleDiffuse = ( uvCoord ) => this.diffuseNode?.sample( uvCoord )?.rgb ?? vec3( 0 );

		// Neighborhood luma moments for the adaptive-trust (firefly) gating of the temporal blend.
		const getNeighborhoodStats = Fn( ( [ uvCoord, centerSample ] ) => {

			const rlSum = float( 0 ).toVar();
			const rlSumW = float( 0 ).toVar();
			const meanLuma = float( 0 ).toVar();
			const m2Luma = float( 0 ).toVar();
			const lumaCount = float( 0 ).toVar();
			const hasEnvRay = bool( false ).toVar();

			// 4-tap cross (pre-sampled center + 4 axis neighbors) instead of a full 3×3 — about half the fetches.
			// The center tap reuses the caller's already-sampled raw texel.
			const accumulate = ( dx, dy, sample ) => {

				const neighbor = sample !== undefined
					? sample
					: texture( this.rawNode, uvCoord.add( vec2( dx, dy ).div( this._resolution ) ) ).max( 0 ).toConst();

				if ( this.alphaSource === 'raylength' ) {

					const sampleRl = neighbor.a.toVar();
					If( sampleRl.greaterThan( ENV_RAY_LENGTH_THRESHOLD ), () => {

						sampleRl.assign( 0.25 );
						hasEnvRay.assign( true );

					} );
					const w = float( 1 ).div( sampleRl.add( 0.001 ) );
					rlSum.addAssign( sampleRl.mul( w ) );
					rlSumW.addAssign( w );

				}

				If( this.adaptiveTrust.greaterThan( 0 ), () => {

					const nLuma = luminance( neighbor.rgb );
					lumaCount.addAssign( 1 );
					const delta = nLuma.sub( meanLuma ).toConst();
					meanLuma.addAssign( delta.div( lumaCount ) );
					m2Luma.addAssign( delta.mul( nLuma.sub( meanLuma ) ) );

				} );

			};

			accumulate( 0, 0, centerSample );
			accumulate( - 1, 0 );
			accumulate( 1, 0 );
			accumulate( 0, - 1 );
			accumulate( 0, 1 );

			const avgRayLength = this.alphaSource === 'raylength' ? rlSum.div( rlSumW ) : float( 1 );
			const stddevLuma = sqrt( m2Luma.div( lumaCount.max( 1 ) ) );

			// vec3( avgRayLength, meanLuma, stddevLuma )
			return vec4( avgRayLength, meanLuma, stddevLuma, hasEnvRay.toFloat() );

		} ).setLayout( {
			name: 'getNeighborhoodStats',
			type: 'vec4',
			inputs: [
				{ name: 'uvCoord', type: 'vec2' },
				{ name: 'centerSample', type: 'vec4' }
			]
		} );

		const denoiseFn = Fn( ( [ uvCoord ] ) => {

			const result = property( 'vec4' );

			const depth = sampleDepth( uvCoord ).toConst();

			const runDenoise = () => {

				const viewNormal = sampleNormal( uvCoord ).toConst();
				const worldNormal = viewNormal.transformDirection( this._viewMatrix ).toConst();
				const texel = sampleTexture( uvCoord ).max( 0 ).toConst();

				const viewPosition = getViewPosition( uvCoord, depth, this._cameraProjectionMatrixInverse ).toConst();
				const roughnessMetalness = sampleRoughnessMetalness( uvCoord ).toConst();
				const roughness = roughnessMetalness.g;
				const metalness = roughnessMetalness.r;

				const noiseTexel = sampleAnalyticNoise( uvCoord, this._noiseIndex );
				const rotationMatrix = noiseRotationMatrix( noiseTexel.r );

				const frameNum = float( 1 ).div( texel.a );
				const varianceFactor = getTemporalVarianceFactor( frameNum, this.strength.oneMinus() );
				const aggressivity = varianceFactor.oneMinus();

				const raw = sampleRaw( uvCoord ).toConst();

				const viewZ = abs( viewPosition.z );
				const rl = float( 1 ).toVar();
				const nbhdMeanLuma = float( 0 ).toVar();
				const nbhdStddevLuma = float( 0 ).toVar();
				const hasEnvRay = bool( false ).toVar();

				if ( this.alphaSource === 'raylength' ) {

					const stats = getNeighborhoodStats( uvCoord, raw );
					rl.assign( stats.x );
					nbhdMeanLuma.assign( stats.y );
					nbhdStddevLuma.assign( stats.z );
					hasEnvRay.assign( stats.w.greaterThan( 0.5 ) );

				} else {

					If( this.adaptiveTrust.greaterThan( 0 ), () => {

						const stats = getNeighborhoodStats( uvCoord, raw );
						nbhdMeanLuma.assign( stats.y );
						nbhdStddevLuma.assign( stats.z );

					} );

				}

				const tanHalfFovY = this.alphaSource === 'raylength' ? tan( this._fovY.mul( 0.5 ) ).toConst() : null;
				const hitDistFactor = this.alphaSource === 'raylength'
					? computeHitDistFactor( rl, viewZ, tanHalfFovY ).toConst()
					: float( 1 );

				const denoised = texel.rgb.toVar();
				const totalWeight = float( 1 ).toVar();
				const denoisedFrame = frameNum.toVar();
				const totalFrameWeight = float( 1 ).toVar();

				const denoisedRaw = raw.rgb.toVar();
				const totalWeightRaw = float( 1 ).toVar();

				If( raw.rgb.length().lessThan( 0.0001 ), () => {

					denoisedRaw.assign( vec3( 0 ) );
					totalWeightRaw.assign( 0 );

				} );

				const avgAo = this.alphaSource === 'ao' ? raw.a.toConst() : float( 1 );
				const mappedAvgAo = this.alphaSource === 'ao' ? mapAo( avgAo ) : float( 0 );

				const worldRadius = this.radius.mul( WORLD_RADIUS_SCALE ).toVar();

				if ( this.mode === 'specular' ) {

					worldRadius.mulAssign( rl.mul( viewPosition.z.abs() ) );
					worldRadius.mulAssign( roughness.sqrt().max( 0.01 ) );

				} else {

					worldRadius.mulAssign( avgAo.pow( 2 ).mul( viewPosition.z.abs() ) );

				}

				worldRadius.mulAssign( mix( 1, AGGRESSIVITY_RADIUS_MIN, aggressivity ) );

				const T = vec3( 0 ).toVar();
				const B = vec3( 0 ).toVar();

				if ( this.mode === 'specular' ) {

					const V = normalize( viewPosition ).negate();
					const D = getSpecularDominantDirection( viewNormal, V, roughness );
					const R = reflect( D.negate(), viewNormal );
					const Tv = normalize( cross( viewNormal, R ) );
					const Bv = cross( R, Tv );
					const viewAngle = abs( viewNormal.z ).acos().div( float( Math.PI * 0.5 ) ).clamp( 0, 1 );
					const skewFactor = mix( 1.0, roughness, viewAngle );
					T.assign( Tv.mul( skewFactor ) );
					B.assign( Bv );

				} else {

					const up = vec3( 0, 0, 1 );
					const Tv = cross( up, viewNormal ).normalize().toVar();
					If( Tv.length().lessThan( EPSILON ), () => {

						Tv.assign( cross( vec3( 0, 1, 0 ), viewNormal ).normalize() );

					} );
					T.assign( Tv );
					B.assign( cross( viewNormal, Tv ).normalize() );

				}

				T.mulAssign( worldRadius );
				B.mulAssign( worldRadius );

				const centerDiffuse = sampleDiffuse( uvCoord ).toConst();
				const radiusShrink = float( 1 ).toVar();

				// Directional analog of radiusShrink: an accumulated tangent-space shift that skews
				// subsequent taps toward directions that yielded high weight (related geometry).
				const polarBias = vec2( 0 ).toVar();

				const depthWeightScale = this.depthPhi.mul( 500 ).mul( viewNormal.z.abs() ).div( viewPosition.z.abs() );

				// Lobe geometry depends only on per-pixel terms, so compute its falloff constant once here.
				const lobeFalloff = lobeNormalFalloff( roughness, aggressivity, this.normalPhi.oneMinus() ).toConst();

				Loop( { start: int( 0 ), end: int( KERNEL_SAMPLES ), type: 'int', condition: '<', name: 'i' }, ( { i } ) => {

					const baseOffset = vogelDisk( float( i ), 1 ).toVar();
					const sampleDir = baseOffset.normalize().toConst();

					// Blend the tap direction toward the polar bias, then restore the Vogel radius and shrink.
					const skewedDir = mix( sampleDir, polarBias.max( EPSILON ).normalize(), this.adapt.mul( aggressivity )
						.mul( polarBias.dot( polarBias ).greaterThan( 0.001 ).select( 1, 0 ) ) );
					const offset = rotationMatrix.mul( skewedDir.mul( baseOffset.length().mul( radiusShrink ) ) ).toVar();

					// Exact per-sample view-space projection (both paths)
					const sampleViewPos = viewPosition.add( B.mul( offset.x ).add( T.mul( offset.y ) ) );
					const sampleUv = getScreenPosition( sampleViewPos, this._cameraProjectionMatrix ).toVar();
					sampleUv.assign( sampleUv.abs().oneMinus().abs().oneMinus().clamp() );

					const neighborColor = sampleTexture( sampleUv ).max( 0 ).toConst();

					// When no raw texture is bound, sampleRaw falls back to the filtered texture at the same UV.
					const rawNeighborColor = sampleRaw( sampleUv ).max( 0 ).toVar();
					// if ( this.mode === 'diffuse' ) rawNeighborColor.rgb.assign( mix( neighborColor.rgb, rawNeighborColor.rgb, neighborColor.a ) );

					const nDepth = sampleDepth( sampleUv );
					const nViewPosition = getViewPosition( sampleUv, nDepth, this._cameraProjectionMatrixInverse ).toConst();
					const nViewZ = abs( nViewPosition.z ).toConst();

					const kernelDiff = float( 0 ).toVar();

					// Luma edge stopping
					kernelDiff.addAssign( luminance( rawNeighborColor.rgb ).sub( luminance( raw.rgb ) ).abs().mul( this.lumaPhi ).mul( 10 ) );

					// Diffuse edge stopping (only relevant for specular mode)
					if ( this.diffuseNode !== null ) {

						kernelDiff.addAssign( ( diffuseColorDistance( centerDiffuse, sampleDiffuse( sampleUv ), float( 0 ) ).mul( this.diffusePhi ).mul( metalness ) ) );

					}

					// AO edge stopping
					if ( this.alphaSource === 'ao' ) {

						const neighborMappedAo = mapAo( rawNeighborColor.a );
						// We multiply here with aggressivity as well, since early application of aoW yields noise
						const aoW = mappedAvgAo.div( mappedAvgAo.add( neighborMappedAo ).add( AO_EDGE_STOPPING_BIAS ) ).mul( this.alphaPhi ).mul( aggressivity );

						kernelDiff.addAssign( ( aoW ) );


					} else if ( this.alphaSource === 'raylength' ) {

						// Ray length edge stopping

						const neighborHitDistFactor = computeHitDistFactor( rawNeighborColor.a, nViewZ, tanHalfFovY );
						const hdfDiff = hitDistFactor.sub( neighborHitDistFactor ).abs();

						const rayLengthFactor = hdfDiff.mul( this.alphaPhi ).div( viewPosition.z.abs() );

						// Env rays are harder to compare so we accept if this sample is an env ray and there is an env ray in the neighborhood
						kernelDiff.addAssign( rawNeighborColor.a.greaterThan( ENV_RAY_LENGTH_THRESHOLD ).and( hasEnvRay ).select( 1, rayLengthFactor ) );

					}

					// Roughness edge stopping
					if ( this.mode === 'specular' ) kernelDiff.addAssign( ( abs( roughness.sub( sampleRoughnessMetalness( sampleUv ).g ) ).mul( this.roughnessPhi ) ) );

					const nViewNormal = sampleNormal( sampleUv );
					const nWorldNormal = nViewNormal.transformDirection( this._viewMatrix );
					const distToPlane = planeDistance( viewPosition, nViewPosition, viewNormal );

					// Geometric edge stopping (depth and normal)
					const depthDiff = distToPlane.mul( depthWeightScale );
					const normalW = lobeNormalWeight( worldNormal, nWorldNormal, lobeFalloff );

					// Sum every negative-exponent edge-stopping term (kernel + depth/plane, plus the SSR hit-distance term)
					const w = exp( kernelDiff.mul( aggressivity ).add( depthDiff ).negate() ).mul( normalW ).toVar();

					// Feedback to shrink radius based on the weight
					radiusShrink.assign( mix( radiusShrink, w, this.adapt ) );

					// Polar feedback: skew subsequent taps toward high-weight directions (related geometry)
					polarBias.assign( mix( polarBias, sampleDir.mul( w.sub( 0.5 ) ), 0.5 ) );

					// to mitigate the effect of fireflies and high variance in recently disoccluded regions, we weigh by the inverse luminance for the first 5 frames
					w.mulAssign( mix( float( 1 ).div( luminance( rawNeighborColor.rgb ).pow( 2 ).add( 0.01 ) ), 1, frameNum.div( 5 ).min( 1 ) ) );

					denoisedRaw.addAssign( rawNeighborColor.rgb.mul( w ) );
					totalWeightRaw.addAssign( w );

					denoised.addAssign( neighborColor.rgb.mul( w ) );
					totalWeight.addAssign( w );

					// Denoising the alpha (accumulation speed), to get smoother disocclusion transitions
					If( this.smoothDisocclusions, () => {

						const neighborAWeight = neighborColor.a.greaterThan( texel.a ).select( w.mul( 0.33 ), 0 );
						denoisedFrame.addAssign( float( 1 ).div( neighborColor.a ).mul( neighborAWeight ) );
						totalFrameWeight.addAssign( neighborAWeight );

					} );

				} );

				denoised.divAssign( totalWeight.max( EPSILON ) );
				denoised.assign( denoised.max( EPSILON ) );
				denoisedRaw.divAssign( totalWeightRaw.max( EPSILON ) );

				if ( this.accumulate ) {

					const computedFrame = denoisedFrame.div( totalFrameWeight.max( EPSILON ) );
					const a = float( 1 ).div( computedFrame.max( EPSILON ) ).toConst();

					if ( this.rawNode !== null ) {

						const blended = karisTemporalBlend(
							denoised,
							denoisedRaw,
							a,
							this.flickerSuppression,
							this.adaptiveTrust,
							nbhdMeanLuma,
							nbhdStddevLuma
						);

						result.assign( vec4( blended, a ) );

					} else {

						const finalDenoised = mix( denoised, denoisedRaw, a );
						result.assign( vec4( finalDenoised, a ) );

					}

				} else {

					result.assign( vec4( denoised, texel.a ) );

				}

			};

			If( depth.greaterThanEqual( 1.0 ), () => {

				Discard();

			} ).Else( runDenoise );

			return result;

		} );

		this._material.fragmentNode = denoiseFn( uv() ).context( builder.getSharedContext() );
		this._material.needsUpdate = true;

		return this._textureNode;

	}

	dispose() {

		this._renderTarget.dispose();
		this._material.dispose();

	}

}

export default RecurrentDenoiseNode;

/**
 * @tsl
 * @param {Node} inputTexture - Temporally filtered input to denoise (e.g. TRAA output).
 * @param {Camera} camera
 * @param {RecurrentDenoiseNodeOptions} [options={}]
 * @returns {RecurrentDenoiseNode}
 */
export const recurrentDenoise = ( inputTexture, camera, options = {} ) => nodeObject( new RecurrentDenoiseNode(
	toTextureNode( inputTexture ),
	camera,
	options
) );