@gnsx/three 0.185.16 → 0.186.0

package/examples/jsm/tsl/display/DepthOfFieldNode.js

@@ -1,5 +1,5 @@
 import { TempNode, NodeMaterial, NodeUpdateType, RenderTarget, Vector2, HalfFloatType, RedFormat, QuadMesh, RendererUtils } from '@gnsx/three/webgpu';
-import { convertToTexture, nodeObject, Fn, uniform, smoothstep, step, texture, max, uniformArray, outputStruct, property, vec4, vec3, uv, Loop, min, mix, float } from '@gnsx/three/tsl';
+import { convertToTexture, nodeObject, Fn, uniform, smoothstep, step, texture, max, uniformArray, outputStruct, property, vec4, vec3, uv, Loop, min, mix, float, context } from '@gnsx/three/tsl';
 import { gaussianBlur } from './GaussianBlurNode.js';
 
 const _quadMesh = /*@__PURE__*/ new QuadMesh();
@@ -190,6 +190,14 @@ class DepthOfFieldNode extends TempNode {
 		 */
 		this._CoCTextureNode = texture( this._CoCRT.texture );
 
+		/**
+		 * The Gaussian blur node used to blur the near field's circle of confusion.
+		 *
+		 * @private
+		 * @type {GaussianBlurNode}
+		 */
+		this._CoCBlurNode = gaussianBlur( this._CoCTextureNode, 1, 2 );
+
 		/**
 		 * The result of the blur64 pass as a texture node.
 		 *
@@ -351,6 +359,8 @@ class DepthOfFieldNode extends TempNode {
 	 */
 	setup( builder ) {
 
+		const sharedContext = context( builder.getSharedContext() );
+
 		const kernels = this._generateKernels();
 
 		// CoC, near and far fields
@@ -372,13 +382,14 @@ class DepthOfFieldNode extends TempNode {
 
 		} );
 
-		this._CoCMaterial.colorNode = CoC().context( builder.getSharedContext() );
+		this._CoCMaterial.contextNode = sharedContext;
+		this._CoCMaterial.colorNode = CoC();
 		this._CoCMaterial.outputNode = outputNode;
 		this._CoCMaterial.needsUpdate = true;
 
 		// blurred CoC for near field
 
-		this._CoCBlurredMaterial.colorNode = gaussianBlur( this._CoCTextureNode, 1, 2 );
+		this._CoCBlurredMaterial.colorNode = this._CoCBlurNode;
 		this._CoCBlurredMaterial.needsUpdate = true;
 
 		// bokeh 64 blur pass
@@ -408,7 +419,8 @@ class DepthOfFieldNode extends TempNode {
 
 		} );
 
-		this._blur64Material.fragmentNode = blur64().context( builder.getSharedContext() );
+		this._blur64Material.contextNode = sharedContext;
+		this._blur64Material.fragmentNode = blur64();
 		this._blur64Material.needsUpdate = true;
 
 		// bokeh 16 blur pass
@@ -437,7 +449,8 @@ class DepthOfFieldNode extends TempNode {
 
 		} );
 
-		this._blur16Material.fragmentNode = blur16().context( builder.getSharedContext() );
+		this._blur16Material.contextNode = sharedContext;
+		this._blur16Material.fragmentNode = blur16();
 		this._blur16Material.needsUpdate = true;
 
 		// composite
@@ -466,7 +479,8 @@ class DepthOfFieldNode extends TempNode {
 
 		} );
 
-		this._compositeMaterial.fragmentNode = composite().context( builder.getSharedContext() );
+		this._compositeMaterial.contextNode = sharedContext;
+		this._compositeMaterial.fragmentNode = composite();
 		this._compositeMaterial.needsUpdate = true;
 
 		return this._textureNode;
@@ -520,6 +534,8 @@ class DepthOfFieldNode extends TempNode {
 	 */
 	dispose() {
 
+		super.dispose();
+
 		this._CoCRT.dispose();
 		this._CoCBlurredRT.dispose();
 		this._blur64RT.dispose();
@@ -533,6 +549,8 @@ class DepthOfFieldNode extends TempNode {
 		this._blur16Material.dispose();
 		this._compositeMaterial.dispose();
 
+		this._CoCBlurNode.dispose();
+
 	}
 
 }

package/examples/jsm/tsl/display/DotScreenNode.js

@@ -1,5 +1,5 @@
 import { TempNode } from '@gnsx/three/webgpu';
-import { nodeObject, Fn, uv, uniform, vec2, vec3, sin, cos, add, vec4, screenSize } from '@gnsx/three/tsl';
+import { nodeObject, Fn, uv, vec2, vec3, sin, cos, add, vec4, screenSize } from '@gnsx/three/tsl';
 
 /**
  * Post processing node for creating dot-screen effect.
@@ -19,8 +19,8 @@ class DotScreenNode extends TempNode {
 	 * Constructs a new dot screen node.
 	 *
 	 * @param {Node} inputNode - The node that represents the input of the effect.
-	 * @param {number} [angle=1.57] - The rotation of the effect in radians.
-	 * @param {number} [scale=1] - The scale of the effect. A higher value means smaller dots.
+	 * @param {number|Node<float>} [angle=1.57] - The rotation of the effect in radians.
+	 * @param {number|Node<float>} [scale=1] - The scale of the effect. A higher value means smaller dots.
 	 */
 	constructor( inputNode, angle = 1.57, scale = 1 ) {
 
@@ -34,18 +34,18 @@ class DotScreenNode extends TempNode {
 		this.inputNode = inputNode;
 
 		/**
-		 * A uniform node that represents the rotation of the effect in radians.
+		 * The rotation of the effect in radians.
 		 *
-		 * @type {UniformNode<float>}
+		 * @type {Node<float>}
 		 */
-		this.angle = uniform( angle );
+		this.angle = nodeObject( angle );
 
 		/**
-		 * A uniform node that represents the scale of the effect. A higher value means smaller dots.
+		 * The scale of the effect. A higher value means smaller dots.
 		 *
-		 * @type {UniformNode<float>}
+		 * @type {Node<float>}
 		 */
-		this.scale = uniform( scale );
+		this.scale = nodeObject( scale );
 
 	}
 
@@ -97,8 +97,8 @@ export default DotScreenNode;
  * @tsl
  * @function
  * @param {Node<vec4>} node - The node that represents the input of the effect.
- * @param {number} [angle=1.57] - The rotation of the effect in radians.
- * @param {number} [scale=1] - The scale of the effect. A higher value means smaller dots.
+ * @param {number|Node<float>} [angle=1.57] - The rotation of the effect in radians.
+ * @param {number|Node<float>} [scale=1] - The scale of the effect. A higher value means smaller dots.
  * @returns {DotScreenNode}
  */
 export const dotScreen = ( node, angle, scale ) => new DotScreenNode( nodeObject( node ), angle, scale );

package/examples/jsm/tsl/display/FSR1Node.js

@@ -1,5 +1,5 @@
 import { HalfFloatType, RenderTarget, Vector2, NodeMaterial, RendererUtils, QuadMesh, TempNode, NodeUpdateType } from '@gnsx/three/webgpu';
-import { Fn, float, vec2, vec3, vec4, ivec2, int, uv, floor, fract, abs, max, min, clamp, saturate, sqrt, select, exp2, nodeObject, passTexture, textureSize, textureLoad, convertToTexture } from '@gnsx/three/tsl';
+import { Fn, float, vec2, vec3, vec4, ivec2, int, uv, floor, fract, abs, max, min, clamp, saturate, sqrt, select, exp2, nodeObject, passTexture, textureSize, textureLoad, convertToTexture, context } from '@gnsx/three/tsl';
 
 const _quadMesh = /*@__PURE__*/ new QuadMesh();
 const _size = /*@__PURE__*/ new Vector2();
@@ -423,15 +423,17 @@ class FSR1Node extends TempNode {
 
 		//
 
-		const context = builder.getSharedContext();
+		const sharedContext = context( builder.getSharedContext() );
 
 		const easuMaterial = this._easuMaterial || ( this._easuMaterial = new NodeMaterial() );
-		easuMaterial.fragmentNode = easu().context( context );
+		easuMaterial.contextNode = sharedContext;
+		easuMaterial.fragmentNode = easu();
 		easuMaterial.name = 'FSR1_EASU';
 		easuMaterial.needsUpdate = true;
 
 		const rcasMaterial = this._rcasMaterial || ( this._rcasMaterial = new NodeMaterial() );
-		rcasMaterial.fragmentNode = rcas().context( context );
+		rcasMaterial.contextNode = sharedContext;
+		rcasMaterial.fragmentNode = rcas();
 		rcasMaterial.name = 'FSR1_RCAS';
 		rcasMaterial.needsUpdate = true;
 
@@ -452,6 +454,8 @@ class FSR1Node extends TempNode {
 	 */
 	dispose() {
 
+		super.dispose();
+
 		this._easuRT.dispose();
 		this._rcasRT.dispose();
 

package/examples/jsm/tsl/display/GTAONode.js

@@ -1,11 +1,12 @@
 import { DataTexture, RenderTarget, RepeatWrapping, Vector2, Vector3, TempNode, QuadMesh, NodeMaterial, RendererUtils, RedFormat } from '@gnsx/three/webgpu';
-import { reference, logarithmicDepthToViewZ, viewZToPerspectiveDepth, getNormalFromDepth, getScreenPosition, getViewPosition, nodeObject, Fn, float, NodeUpdateType, uv, uniform, Loop, vec2, vec3, vec4, int, dot, max, min, pow, abs, If, textureSize, sin, cos, PI, texture, passTexture, mat3, add, normalize, mul, cross, div, mix, acos, clamp } from '@gnsx/three/tsl';
+import { reference, logarithmicDepthToViewZ, viewZToPerspectiveDepth, getNormalFromDepth, getViewPosition, getScreenPositionFromClip, nodeObject, Fn, float, NodeUpdateType, uv, uniform, Loop, vec2, vec3, vec4, int, dot, max, min, pow, abs, If, textureSize, sin, cos, PI, texture, passTexture, mat3, normalize, cross, mix, acos, clamp, interleavedGradientNoise, screenCoordinate, rand, context } from '@gnsx/three/tsl';
 
 const _quadMesh = /*@__PURE__*/ new QuadMesh();
 const _size = /*@__PURE__*/ new Vector2();
 
 // From Activision GTAO paper: https://www.activision.com/cdn/research/s2016_pbs_activision_occlusion.pptx
 const _temporalRotations = [ 60, 300, 180, 240, 120, 0 ];
+const _spatialOffsets = [ 0, 0.5, 0.25, 0.75 ];
 
 let _rendererState;
 
@@ -14,20 +15,30 @@ let _rendererState;
  * ```js
  * const renderPipeline = new THREE.RenderPipeline( renderer );
  *
- * const scenePass = pass( scene, camera );
- * scenePass.setMRT( mrt( {
- * 	output: output,
- * 	normal: normalView
+ * // pre-pass for normals and depth
+ *
+ * const prePass = pass( scene, camera );
+ * prePass.setMRT( mrt( {
+ * 	output: normalView
  * } ) );
  *
- * const scenePassColor = scenePass.getTextureNode( 'output' );
- * const scenePassNormal = scenePass.getTextureNode( 'normal' );
- * const scenePassDepth = scenePass.getTextureNode( 'depth' );
+ * const prePassNormal = prePass.getTextureNode();
+ * const prePassDepth = prePass.getTextureNode( 'depth' );
+ *
+ * // scene pass
+ *
+ * const scenePass = pass( scene, camera );
+ *
+ * // ao
  *
- * const aoPass = ao( scenePassDepth, scenePassNormal, camera );
+ * const aoPass = ao( prePassDepth, prePassNormal, camera );
  * const aoPassOutput = aoPass.getTextureNode();
  *
- * renderPipeline.outputNode = scenePassColor.mul( vec4( vec3( aoPassOutput.r ), 1 ) );
+ * // apply the ambient occlusion to the scene
+ *
+ * scenePass.contextNode = builtinAOContext( aoPassOutput.sample( screenUV ).r );
+ *
+ * renderPipeline.outputNode = scenePass;
  * ```
  *
  * Reference: [Practical Real-Time Strategies for Accurate Indirect Occlusion](https://www.activision.com/cdn/research/Practical_Real_Time_Strategies_for_Accurate_Indirect_Occlusion_NEW%20VERSION_COLOR.pdf).
@@ -72,9 +83,7 @@ class GTAONode extends TempNode {
 
 		// WITH_GENESYS
 		/**
-		 * Optional node that marks pixels where GTAO should run. This is sampled only
-		 * for the center pixel, allowing neighbor depth taps to use the raw depth
-		 * texture without repeating an auxiliary validity texture fetch.
+		 * Optional center-pixel validity node, sampled once before GTAO ray marching.
 		 *
 		 * @type {?Node<float>}
 		 * @default null
@@ -120,9 +129,7 @@ class GTAONode extends TempNode {
 
 		// WITH_GENESYS
 		/**
-		 * Maximum screen-space radius in pixels. Clamps the projected world-space
-		 * radius when the camera is close to surfaces so sample UVs stay local and
-		 * avoid texture-cache thrashing (Activision GTAO guidance).
+		 * Max projected AO radius in pixels; clamps near-camera sample stride.
 		 *
 		 * @type {UniformNode<float>}
 		 * @default 64
@@ -130,14 +137,6 @@ class GTAONode extends TempNode {
 		this.maxScreenRadius = uniform( 64 );
 		// !WITH_GENESYS
 
-		/**
-		 * The resolution of the effect. Can be scaled via
-		 * `resolutionScale`.
-		 *
-		 * @type {UniformNode<vec2>}
-		 */
-		this.resolution = uniform( new Vector2() );
-
 		/**
 		 * The thickness of the ambient occlusion.
 		 *
@@ -146,17 +145,16 @@ class GTAONode extends TempNode {
 		this.thickness = uniform( 1 );
 
 		/**
-		 * Another option to tweak the occlusion. The recommended range is
-		 * `[1,2]` for attenuating the AO.
+		 * @deprecated since r186. The new distance model "Quadratic Ray Stepping"
+		 * does not need it anymore.
 		 *
 		 * @type {UniformNode<float>}
 		 */
 		this.distanceExponent = uniform( 1 );
 
 		/**
-		 * The distance fall off value of the ambient occlusion.
-		 * A lower value leads to a larger AO effect. The value
-		 * should lie in the range `[0,1]`.
+		 * @deprecated since r186. The new distance model "Quadratic Ray Stepping"
+		 * does not need it anymore.
 		 *
 		 * @type {UniformNode<float>}
 		 */
@@ -174,6 +172,8 @@ class GTAONode extends TempNode {
 		 * A higher value results in better quality but also
 		 * in a more expensive runtime behavior.
 		 *
+		 * Note: Changing this member triggers a shader recompilation.
+		 *
 		 * @type {UniformNode<float>}
 		 */
 		this.samples = uniform( 16 );
@@ -192,13 +192,29 @@ class GTAONode extends TempNode {
 		 */
 		this.useTemporalFiltering = false;
 
+		/**
+		 * The resolution of the effect. Can be scaled via `resolutionScale`.
+		 *
+		 * @private
+		 * @type {UniformNode<vec2>}
+		 */
+		this._resolution = uniform( new Vector2() );
+
+		/**
+		 * The internal noise texture used by the AO.
+		 *
+		 * @private
+		 * @type {DataTexture}
+		 */
+		this._noiseTexture = generateMagicSquareNoise();
+
 		/**
 		 * The node represents the internal noise texture used by the AO.
 		 *
 		 * @private
 		 * @type {TextureNode}
 		 */
-		this._noiseNode = texture( generateMagicSquareNoise() );
+		this._noiseNode = texture( this._noiseTexture );
 
 		/**
 		 * Represents the projection matrix of the scene's camera.
@@ -240,6 +256,48 @@ class GTAONode extends TempNode {
 		 */
 		this._temporalDirection = uniform( 0 );
 
+		/**
+		 * Temporal offset added to the initial ray step.
+		 *
+		 * @private
+		 * @type {UniformNode<float>}
+		 */
+		this._temporalOffset = uniform( 0 );
+
+		/**
+		 * Resolution scale uniform.
+		 *
+		 * @private
+		 * @type {UniformNode<float>}
+		 */
+		this._resolutionScale = uniform( 0 );
+
+		/**
+		 * The TSL function that computes the AO. Required for rebuild.
+		 *
+		 * @private
+		 * @type {?Function}
+		 * @default null
+		 */
+		this._ao = null;
+
+		/**
+		 * The sample count currently baked into the shader.
+		 *
+		 * @private
+		 * @type {number}
+		 */
+		this._currentSamples = - 1;
+
+		/**
+		 * The shared builder context.  Required for rebuild.
+		 *
+		 * @private
+		 * @type {?Object}
+		 * @default null
+		 */
+		this._sharedContext = null;
+
 		/**
 		 * The material that is used to render the effect.
 		 *
@@ -281,7 +339,8 @@ class GTAONode extends TempNode {
 		width = Math.round( this.resolutionScale * width );
 		height = Math.round( this.resolutionScale * height );
 
-		this.resolution.value.set( width, height );
+		this._resolutionScale.value = this.resolutionScale;
+		this._resolution.value.set( width, height );
 		this._aoRenderTarget.setSize( width, height );
 
 	}
@@ -304,10 +363,24 @@ class GTAONode extends TempNode {
 			const frameId = frame.frameId;
 
 			this._temporalDirection.value = _temporalRotations[ frameId % 6 ] / 360;
+			this._temporalOffset.value = _spatialOffsets[ frameId % 4 ];
 
 		} else {
 
 			this._temporalDirection.value = 0;
+			this._temporalOffset.value = 1;
+
+		}
+
+		// rebuild the material if the sample count has changed
+
+		if ( this.samples.value !== this._currentSamples ) {
+
+			this._currentSamples = this.samples.value;
+
+			this._material.contextNode = context( this._sharedContext );
+			this._material.fragmentNode = this._ao();
+			this._material.needsUpdate = true;
 
 		}
 
@@ -344,9 +417,7 @@ class GTAONode extends TempNode {
 
 		const uvNode = uv();
 
-		const sampleDepth = ( uv ) => {
-
-			const depth = this.depthNode.sample( uv ).r;
+		const linearizeDepth = ( depth ) => {
 
 			if ( builder.renderer.logarithmicDepthBuffer === true ) {
 
@@ -360,12 +431,25 @@ class GTAONode extends TempNode {
 
 		};
 
+		const sampleDepth = ( uv ) => linearizeDepth( this.depthNode.sample( uv ).r );
+
+		const sampleCenterDepth = ( uv ) => {
+
+			// Sidestep the nearest-rounding during depth access for the unjittered center pixel to avoid banding
+
+			const g = this.depthNode.gather().sample( uv );
+			const depth = min( min( g.x, g.y ), min( g.z, g.w ) );
+
+			return linearizeDepth( depth );
+
+		};
+
 		const sampleNoise = ( uv ) => this._noiseNode.sample( uv );
 		const sampleNormal = ( uv ) => ( this.normalNode !== null ) ? this.normalNode.sample( uv ).rgb.normalize() : getNormalFromDepth( uv, this.depthNode.value, this._cameraProjectionMatrixInverse );
 
-		const ao = Fn( () => {
+		this._ao = Fn( () => {
 
-			const depth = sampleDepth( uvNode ).toVar();
+			const depth = this._resolutionScale.lessThan( 1 ).select( sampleCenterDepth( uvNode ), sampleDepth( uvNode ) ).toConst();
 
 			// WITH_GENESYS
 			if ( this.validityNode !== null ) {
@@ -377,24 +461,26 @@ class GTAONode extends TempNode {
 
 			depth.greaterThanEqual( 1.0 ).discard();
 
-			const viewPosition = getViewPosition( uvNode, depth, this._cameraProjectionMatrixInverse ).toVar();
-			const viewNormal = sampleNormal( uvNode ).toVar();
+			const viewPosition = getViewPosition( uvNode, depth, this._cameraProjectionMatrixInverse ).toConst();
+			const viewNormal = sampleNormal( uvNode ).toConst();
 
+			const clipPosition = this._cameraProjectionMatrix.mul( vec4( viewPosition, 1.0 ) ).toConst();
 			// WITH_GENESYS
 			// Clamp world radius so its screen footprint never exceeds maxScreenRadius
 			// pixels. Without this, near-camera surfaces project a huge UV stride and
 			// the depth/normal taps thrash the texture cache.
-			const probeScreen = getScreenPosition( viewPosition.add( vec3( this.radius, 0.0, 0.0 ) ), this._cameraProjectionMatrix );
-			const centerScreen = getScreenPosition( viewPosition, this._cameraProjectionMatrix );
-			const screenRadiusPx = abs( probeScreen.x.sub( centerScreen.x ) ).mul( this.resolution.x );
+			const probeClip = this._cameraProjectionMatrix.mul( vec4( viewPosition.add( vec3( this.radius, 0.0, 0.0 ) ), 1.0 ) );
+			const screenRadiusPx = abs( getScreenPositionFromClip( probeClip ).x.sub( getScreenPositionFromClip( clipPosition ).x ) ).mul( this._resolution.x );
 			const radiusScale = min( float( 1.0 ), this.maxScreenRadius.div( max( screenRadiusPx, float( 1e-4 ) ) ) );
-			const radiusToUse = this.radius.mul( radiusScale );
+			const radius = this.radius.mul( radiusScale );
 			// !WITH_GENESYS
-			// const radiusToUse = this.radius;
+			// const radius = this.radius;
+			const invRadius = radius.reciprocal().toConst();
+			const viewDir = normalize( viewPosition.xyz.negate() ).toConst();
 
 			const noiseResolution = textureSize( this._noiseNode, 0 );
 			let noiseUv = vec2( uvNode.x, uvNode.y.oneMinus() );
-			noiseUv = noiseUv.mul( this.resolution.div( noiseResolution ) );
+			noiseUv = noiseUv.mul( this._resolution.div( noiseResolution ) );
 
 			const noiseTexel = sampleNoise( noiseUv );
 			const randomVec = noiseTexel.xyz.mul( 2.0 ).sub( 1.0 );
@@ -402,80 +488,99 @@ class GTAONode extends TempNode {
 			const bitangent = vec3( tangent.y.mul( - 1.0 ), tangent.x, 0.0 );
 			const kernelMatrix = mat3( tangent, bitangent, vec3( 0.0, 0.0, 1.0 ) );
 
-			// WITH_GENESYS
-			// A clamped radius covers less screen space, so proportionally reduce the
-			// sample budget as well. Keeping all samples only changes tap locality and
-			// does not address the near-camera shader cost.
-			const samplesToUse = min( this.samples, max( float( 6 ), this.samples.mul( radiusScale ) ) ).toVar();
-			const DIRECTIONS = samplesToUse.lessThan( 30 ).select( 3, 5 ).toVar();
-			const STEPS = add( samplesToUse, DIRECTIONS.sub( 1 ) ).div( DIRECTIONS ).toVar();
-			// !WITH_GENESYS
-			// const DIRECTIONS = this.samples.lessThan( 30 ).select( 3, 5 ).toVar();
-			// const STEPS = add( this.samples, DIRECTIONS.sub( 1 ) ).div( DIRECTIONS ).toVar();
+			// The sample count is baked into the shader so loop unrolling works
+
+			const SAMPLES = this.samples.value;
+			const DIRECTIONS = SAMPLES < 30 ? 3 : 5;
+			const STEPS = Math.ceil( SAMPLES / DIRECTIONS );
+			const invSteps = 1 / STEPS;
 
 			const ao = float( 0 ).toVar();
 
 			// Each iteration analyzes one vertical "slice" of the 3D space around the fragment.
 
-			Loop( { start: int( 0 ), end: DIRECTIONS, type: 'int', condition: '<' }, ( { i } ) => {
+			// Per-step phase jitter for spatio-temporal decorrelation.
+			const noiseJitterIdx = this._temporalDirection.mul( 0.02 );
+			const stepJitter = interleavedGradientNoise( screenCoordinate.add( this._temporalOffset ) ).add( rand( uvNode.add( noiseJitterIdx ).mul( 2 ).sub( 1 ) ) );
+
+			Loop( { start: int( 0 ), end: int( DIRECTIONS ), type: 'int', condition: '<' }, ( { i } ) => {
 
-				const angle = float( i ).div( float( DIRECTIONS ) ).mul( PI ).add( this._temporalDirection ).toVar();
-				const sampleDir = vec4( cos( angle ), sin( angle ), 0., add( 0.5, mul( 0.5, noiseTexel.w ) ) );
-				sampleDir.xyz = normalize( kernelMatrix.mul( sampleDir.xyz ) );
+				const angle = float( i ).div( DIRECTIONS ).mul( PI ).add( this._temporalDirection ).toConst();
+				const sampleDir = kernelMatrix.mul( vec3( cos( angle ), sin( angle ), 0 ) ).toConst();
+				const clipDirRadius = this._cameraProjectionMatrix.mul( vec4( sampleDir, 0.0 ) ).mul( radius ).toConst();
 
-				const viewDir = normalize( viewPosition.xyz.negate() ).toVar();
-				const sliceBitangent = normalize( cross( sampleDir.xyz, viewDir ) ).toVar();
-				const sliceTangent = cross( sliceBitangent, viewDir ).toVar();
+				const sliceBitangent = normalize( cross( sampleDir, viewDir ) ).toConst();
+				const sliceTangent = cross( sliceBitangent, viewDir ).toConst();
 
 				// Project the view normal onto the slice plane (remove component along sliceBitangent).
 				// The unnormalized length is the foreshortening weight applied at slice integration.
 				// (Activision GTAO paper, Section 3.2 "Per-pixel sampling".)
-				const projNRaw = viewNormal.sub( sliceBitangent.mul( dot( viewNormal, sliceBitangent ) ) ).toVar();
-				const projNLen = projNRaw.length().toVar();
-				const projN = projNRaw.div( max( projNLen, float( 0.0001 ) ) ).toVar();
+				const projNRaw = viewNormal.sub( sliceBitangent.mul( dot( viewNormal, sliceBitangent ) ) ).toConst();
+				const projNLen = projNRaw.length().toConst();
+				const projN = projNRaw.div( max( projNLen, float( 0.0001 ) ) ).toConst();
 
 				// γ — angle of projN within the slice plane, signed by the tangent direction.
-				const nSin = dot( projN, sliceTangent ).toVar();
-				const nCos = clamp( dot( projN, viewDir ), 0, 1 ).toVar();
+				const nSin = dot( projN, sliceTangent ).toConst();
+				const nCos = clamp( dot( projN, viewDir ), 0, 1 ).toConst();
 				const signNSin = nSin.greaterThanEqual( 0 ).select( float( 1 ), float( - 1 ) );
-				const angleN = signNSin.mul( acos( nCos ) ).toVar();
+				const angleN = signNSin.mul( acos( nCos ) ).toConst();
 
-				const tangentToNormalInSlice = cross( projN, sliceBitangent ).toVar();
-				const cosHorizons = vec2( dot( viewDir, tangentToNormalInSlice ), dot( viewDir, tangentToNormalInSlice.negate() ) ).toVar();
+				const tangentToNormalInSlice = cross( projN, sliceBitangent ).toConst();
+				const cosHorizon = dot( viewDir, tangentToNormalInSlice ).toConst();
+				const cosHorizons = vec2( cosHorizon, cosHorizon.negate() ).toVar();
 
 				// For each slice, the inner loop performs ray marching to find the horizons.
 
-				Loop( { end: STEPS, type: 'int', name: 'j', condition: '<' }, ( { j } ) => {
+				Loop( { end: int( STEPS ), type: 'int', name: 'j', condition: '<' }, ( { j } ) => {
 
-					const sampleViewOffset = sampleDir.xyz.mul( radiusToUse ).mul( sampleDir.w ).mul( pow( div( float( j ).add( 1.0 ), float( STEPS ) ), this.distanceExponent ) );
+					// Quadratic step distribution ( sampleDist = t² ) concentrates samples in the
+					// near-field. (Blender's Eevee adaptation)
+					const t = float( j ).add( 1.0 ).add( stepJitter ).mul( invSteps ).toConst();
+					const sampleDist = t.mul( t );
+					const clipOffset = clipDirRadius.mul( sampleDist ).toConst();
 
 					// The loop marches in two opposite directions (x and y) along the slice's line to find the horizon on both sides.
 
 					// x
 
-					const sampleScreenPositionX = getScreenPosition( viewPosition.add( sampleViewOffset ), this._cameraProjectionMatrix ).toVar();
-					const sampleDepthX = sampleDepth( sampleScreenPositionX ).toVar();
-					const sampleSceneViewPositionX = getViewPosition( sampleScreenPositionX, sampleDepthX, this._cameraProjectionMatrixInverse ).toVar();
-					const viewDeltaX = sampleSceneViewPositionX.sub( viewPosition ).toVar();
+					const sampleScreenPositionX = getScreenPositionFromClip( clipPosition.add( clipOffset ) ).toConst();
+					const sampleDepthX = sampleDepth( sampleScreenPositionX ).toConst();
+					const sampleSceneViewPositionX = getViewPosition( sampleScreenPositionX, sampleDepthX, this._cameraProjectionMatrixInverse ).toConst();
+					const viewDeltaX = sampleSceneViewPositionX.sub( viewPosition ).toConst();
+					const lenX = viewDeltaX.length().toConst();
+
+					// Manual normalize guards against zero-length delta.
+					const sHX = dot( viewDir, viewDeltaX ).div( max( lenX, float( 0.0001 ) ) );
+
+					// Sphere falloff: ( dist / radius )² fades the sample's horizon contribution
+					// back toward the prior horizon as it approaches the radius boundary.
+					// (squared variant of the paper's near-field attenuation;
+					// Activision GTAO paper, Section 4.3 "Bounding the sampling area")
+					const distFacX = min( lenX.mul( invRadius ), 1 );
+					const distFacSqX = distFacX.mul( distFacX );
 
 					If( abs( viewDeltaX.z ).lessThan( this.thickness ), () => {
 
-						const sampleCosHorizon = dot( viewDir, normalize( viewDeltaX ) );
-						cosHorizons.x.addAssign( max( 0, mul( sampleCosHorizon.sub( cosHorizons.x ), mix( 1.0, float( 2.0 ).div( float( j ).add( 2 ) ), this.distanceFallOff ) ) ) );
+						cosHorizons.x.assign( mix( max( cosHorizons.x, sHX ), cosHorizons.x, distFacSqX ) );
 
 					} );
 
 					// y
 
-					const sampleScreenPositionY = getScreenPosition( viewPosition.sub( sampleViewOffset ), this._cameraProjectionMatrix ).toVar();
-					const sampleDepthY = sampleDepth( sampleScreenPositionY ).toVar();
-					const sampleSceneViewPositionY = getViewPosition( sampleScreenPositionY, sampleDepthY, this._cameraProjectionMatrixInverse ).toVar();
-					const viewDeltaY = sampleSceneViewPositionY.sub( viewPosition ).toVar();
+					const sampleScreenPositionY = getScreenPositionFromClip( clipPosition.sub( clipOffset ) ).toConst();
+					const sampleDepthY = sampleDepth( sampleScreenPositionY ).toConst();
+					const sampleSceneViewPositionY = getViewPosition( sampleScreenPositionY, sampleDepthY, this._cameraProjectionMatrixInverse ).toConst();
+					const viewDeltaY = sampleSceneViewPositionY.sub( viewPosition ).toConst();
+					const lenY = viewDeltaY.length().toConst();
+
+					const sHY = dot( viewDir, viewDeltaY ).div( max( lenY, float( 0.0001 ) ) );
+
+					const distFacY = min( lenY.mul( invRadius ), 1 );
+					const distFacSqY = distFacY.mul( distFacY );
 
 					If( abs( viewDeltaY.z ).lessThan( this.thickness ), () => {
 
-						const sampleCosHorizon = dot( viewDir, normalize( viewDeltaY ) );
-						cosHorizons.y.addAssign( max( 0, mul( sampleCosHorizon.sub( cosHorizons.y ), mix( 1.0, float( 2.0 ).div( float( j ).add( 2 ) ), this.distanceFallOff ) ) ) );
+						cosHorizons.y.assign( mix( max( cosHorizons.y, sHY ), cosHorizons.y, distFacSqY ) );
 
 					} );
 
@@ -490,8 +595,8 @@ class GTAONode extends TempNode {
 				// −T side of the slice and −sampleDir samples (cosHorizons.y) on the +T side.
 				// γ is signed by +T (sliceTangent), so hPos must read from cosHorizons.y.
 
-				const hPos = acos( cosHorizons.y ).toVar();
-				const hNeg = acos( cosHorizons.x ).negate().toVar();
+				const hPos = acos( cosHorizons.y ).toConst();
+				const hNeg = acos( cosHorizons.x ).negate().toConst();
 
 				const termPos = cos( hPos.mul( 2 ).sub( angleN ) ).negate().add( nCos ).add( hPos.mul( 2 ).mul( nSin ) );
 				const termNeg = cos( hNeg.mul( 2 ).sub( angleN ) ).negate().add( nCos ).add( hNeg.mul( 2 ).mul( nSin ) );
@@ -509,7 +614,11 @@ class GTAONode extends TempNode {
 
 		} );
 
-		this._material.fragmentNode = ao().context( builder.getSharedContext() );
+		this._sharedContext = builder.getSharedContext();
+		this._currentSamples = this.samples.value;
+
+		this._material.contextNode = context( builder.getSharedContext() );
+		this._material.fragmentNode = this._ao();
 		this._material.needsUpdate = true;
 
 		//
@@ -524,8 +633,12 @@ class GTAONode extends TempNode {
 	 */
 	dispose() {
 
+		super.dispose();
+
 		this._aoRenderTarget.dispose();
 
+		this._noiseTexture.dispose();
+
 		this._material.dispose();
 
 	}