super-three 0.173.5 → 0.176.0

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

@@ -1,7 +1,5 @@
 import { RenderTarget, Vector2, QuadMesh, NodeMaterial, RendererUtils, TempNode, NodeUpdateType } from 'three/webgpu';
-import { nodeObject, Fn, float, vec4, uv, texture, passTexture, uniform, sign, max, convertToTexture } from 'three/tsl';
-
-/** @module AfterImageNode **/
+import { nodeObject, Fn, float, uv, texture, passTexture, uniform, sign, max, convertToTexture } from 'three/tsl';
 
 const _size = /*@__PURE__*/ new Vector2();
 const _quadMeshComp = /*@__PURE__*/ new QuadMesh();
@@ -25,7 +23,7 @@ class AfterImageNode extends TempNode {
 	 * Constructs a new after image node.
 	 *
 	 * @param {TextureNode} textureNode - The texture node that represents the input of the effect.
-	 * @param {Number} [damp=0.96] - The damping intensity. A higher value means a stronger after image effect.
+	 * @param {number} [damp=0.96] - The damping intensity. A higher value means a stronger after image effect.
 	 */
 	constructor( textureNode, damp = 0.96 ) {
 
@@ -43,10 +41,12 @@ class AfterImageNode extends TempNode {
 		 *
 		 * @type {TextureNode}
 		 */
-		this.textureNodeOld = texture();
+		this.textureNodeOld = texture( null );
 
 		/**
-		 * The damping intensity as a uniform node.
+		 * How quickly the after-image fades. A higher value means the after-image
+		 * persists longer, while a lower value means it fades faster. Should be in
+		 * the range `[0, 1]`.
 		 *
 		 * @type {UniformNode<float>}
 		 */
@@ -82,7 +82,7 @@ class AfterImageNode extends TempNode {
 		 * The `updateBeforeType` is set to `NodeUpdateType.FRAME` since the node renders
 		 * its effect once per frame in `updateBefore()`.
 		 *
-		 * @type {String}
+		 * @type {string}
 		 * @default 'frame'
 		 */
 		this.updateBeforeType = NodeUpdateType.FRAME;
@@ -103,8 +103,8 @@ class AfterImageNode extends TempNode {
 	/**
 	 * Sets the size of the effect.
 	 *
-	 * @param {Number} width - The width of the effect.
-	 * @param {Number} height - The height of the effect.
+	 * @param {number} width - The width of the effect.
+	 * @param {number} height - The height of the effect.
 	 */
 	setSize( width, height ) {
 
@@ -174,27 +174,25 @@ class AfterImageNode extends TempNode {
 
 		//
 
-		const uvNode = textureNode.uvNode || uv();
-
-		textureNodeOld.uvNode = uvNode;
-
-		const sampleTexture = ( uv ) => textureNode.sample( uv );
-
-		const when_gt = Fn( ( [ x_immutable, y_immutable ] ) => {
+		textureNodeOld.uvNode = textureNode.uvNode || uv();
 
-			const y = float( y_immutable ).toVar();
-			const x = vec4( x_immutable ).toVar();
+		const afterImg = Fn( () => {
 
-			return max( sign( x.sub( y ) ), 0.0 );
+			const texelOld = textureNodeOld.sample().toVar();
+			const texelNew = textureNode.sample().toVar();
 
-		} );
+			const threshold = float( 0.1 ).toConst();
 
-		const afterImg = Fn( () => {
+			// m acts as a mask. It's 1 if the previous pixel was "bright enough" (above the threshold) and 0 if it wasn't.
+			const m = max( sign( texelOld.sub( threshold ) ), 0.0 );
 
-			const texelOld = vec4( textureNodeOld );
-			const texelNew = vec4( sampleTexture( uvNode ) );
+			// This is where the after-image fades:
+			//
+			// - If m is 0, texelOld is multiplied by 0, effectively clearing the after-image for that pixel.
+			// - If m is 1, texelOld is multiplied by "damp". Since "damp" is between 0 and 1, this reduces the color value of
+			// texelOld, making it darker and causing it to fade.
+			texelOld.mulAssign( this.damp.mul( m ) );
 
-			texelOld.mulAssign( this.damp.mul( when_gt( texelOld, 0.1 ) ) );
 			return max( texelNew, texelOld );
 
 		} );
@@ -234,9 +232,10 @@ class AfterImageNode extends TempNode {
 /**
  * TSL function for creating an after image node for post processing.
  *
+ * @tsl
  * @function
  * @param {Node<vec4>} node - The node that represents the input of the effect.
- * @param {Number} [damp=0.96] - The damping intensity. A higher value means a stronger after image effect.
+ * @param {number} [damp=0.96] - The damping intensity. A higher value means a stronger after image effect.
  * @returns {AfterImageNode}
  */
 export const afterImage = ( node, damp ) => nodeObject( new AfterImageNode( convertToTexture( node ), damp ) );

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

@@ -2,8 +2,6 @@ import { Matrix3, NodeMaterial } from 'three/webgpu';
 import { clamp, nodeObject, Fn, vec4, uv, uniform, max } from 'three/tsl';
 import StereoCompositePassNode from './StereoCompositePassNode.js';
 
-/** @module AnaglyphPassNode **/
-
 /**
  * A render pass node that creates an anaglyph effect.
  *
@@ -30,7 +28,7 @@ class AnaglyphPassNode extends StereoCompositePassNode {
 		/**
 		 * This flag can be used for type testing.
 		 *
-		 * @type {Boolean}
+		 * @type {boolean}
 		 * @readonly
 		 * @default true
 		 */
@@ -99,6 +97,7 @@ export default AnaglyphPassNode;
 /**
  * TSL function for creating an anaglyph pass node.
  *
+ * @tsl
  * @function
  * @param {Scene} scene - The scene to render.
  * @param {Camera} camera - The camera to render the scene with.

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

@@ -1,8 +1,6 @@
 import { RenderTarget, Vector2, TempNode, QuadMesh, NodeMaterial, RendererUtils } from 'three/webgpu';
 import { nodeObject, Fn, float, NodeUpdateType, uv, passTexture, uniform, convertToTexture, vec2, vec3, Loop, mix, luminance } from 'three/tsl';
 
-/** @module AnamorphicNode **/
-
 const _quadMesh = /*@__PURE__*/ new QuadMesh();
 
 let _rendererState;
@@ -26,7 +24,7 @@ class AnamorphicNode extends TempNode {
 	 * @param {TextureNode} textureNode - The texture node that represents the input of the effect.
 	 * @param {Node<float>} tresholdNode - The threshold is one option to control the intensity and size of the effect.
 	 * @param {Node<float>} scaleNode - Defines the vertical scale of the flares.
-	 * @param {Number} samples - More samples result in larger flares and a more expensive runtime behavior.
+	 * @param {number} samples - More samples result in larger flares and a more expensive runtime behavior.
 	 */
 	constructor( textureNode, tresholdNode, scaleNode, samples ) {
 
@@ -103,7 +101,7 @@ class AnamorphicNode extends TempNode {
 		 * The `updateBeforeType` is set to `NodeUpdateType.FRAME` since the node renders
 		 * its effect once per frame in `updateBefore()`.
 		 *
-		 * @type {String}
+		 * @type {string}
 		 * @default 'frame'
 		 */
 		this.updateBeforeType = NodeUpdateType.FRAME;
@@ -124,8 +122,8 @@ class AnamorphicNode extends TempNode {
 	/**
 	 * Sets the size of the effect.
 	 *
-	 * @param {Number} width - The width of the effect.
-	 * @param {Number} height - The height of the effect.
+	 * @param {number} width - The width of the effect.
+	 * @param {number} height - The height of the effect.
 	 */
 	setSize( width, height ) {
 
@@ -246,11 +244,12 @@ class AnamorphicNode extends TempNode {
 /**
  * TSL function for creating an anamorphic flare effect.
  *
+ * @tsl
  * @function
  * @param {TextureNode} node - The node that represents the input of the effect.
- * @param {Node<float> | Number} [threshold=0.9] - The threshold is one option to control the intensity and size of the effect.
- * @param {Node<float> | Number} [scale=3] - Defines the vertical scale of the flares.
- * @param {Number} [samples=32] - More samples result in larger flares and a more expensive runtime behavior.
+ * @param {Node<float> | number} [threshold=0.9] - The threshold is one option to control the intensity and size of the effect.
+ * @param {Node<float> | number} [scale=3] - Defines the vertical scale of the flares.
+ * @param {number} [samples=32] - More samples result in larger flares and a more expensive runtime behavior.
  * @returns {AnamorphicNode}
  */
 export const anamorphic = ( node, threshold = .9, scale = 3, samples = 32 ) => nodeObject( new AnamorphicNode( convertToTexture( node ), nodeObject( threshold ), nodeObject( scale ), samples ) );

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

@@ -1,10 +1,9 @@
 import { float, Fn, vec3, vec4, min, max, mix, luminance } from 'three/tsl';
 
-/** @module BleachBypass **/
-
 /**
  * Applies a bleach bypass effect to the given color node.
  *
+ * @tsl
  * @function
  * @param {Node<vec4>} color - The color node to apply the sepia for.
  * @param {Node<float>} [opacity=1] - Influences how strong the effect is blended with the original color.

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

@@ -1,8 +1,6 @@
 import { HalfFloatType, RenderTarget, Vector2, Vector3, TempNode, QuadMesh, NodeMaterial, RendererUtils, NodeUpdateType } from 'three/webgpu';
 import { nodeObject, Fn, float, uv, passTexture, uniform, Loop, texture, luminance, smoothstep, mix, vec4, uniformArray, add, int } from 'three/tsl';
 
-/** @module BloomNode **/
-
 const _quadMesh = /*@__PURE__*/ new QuadMesh();
 const _size = /*@__PURE__*/ new Vector2();
 
@@ -55,9 +53,9 @@ class BloomNode extends TempNode {
 	 * Constructs a new bloom node.
 	 *
 	 * @param {Node<vec4>} inputNode - The node that represents the input of the effect.
-	 * @param {Number} [strength=1] - The strength of the bloom.
-	 * @param {Number} [radius=0] - The radius of the bloom.
-	 * @param {Number} [threshold=0] - The luminance threshold limits which bright areas contribute to the bloom effect.
+	 * @param {number} [strength=1] - The strength of the bloom.
+	 * @param {number} [radius=0] - The radius of the bloom.
+	 * @param {number} [threshold=0] - The luminance threshold limits which bright areas contribute to the bloom effect.
 	 */
 	constructor( inputNode, strength = 1, radius = 0, threshold = 0 ) {
 
@@ -118,7 +116,7 @@ class BloomNode extends TempNode {
 		 * The number if blur mips.
 		 *
 		 * @private
-		 * @type {Number}
+		 * @type {number}
 		 */
 		this._nMips = 5;
 
@@ -156,7 +154,7 @@ class BloomNode extends TempNode {
 		 * The material for the composite pass.
 		 *
 		 * @private
-		 * @type {NodeMaterial?}
+		 * @type {?NodeMaterial}
 		 */
 		this._compositeMaterial = null;
 
@@ -164,7 +162,7 @@ class BloomNode extends TempNode {
 		 * The material for the luminance pass.
 		 *
 		 * @private
-		 * @type {NodeMaterial?}
+		 * @type {?NodeMaterial}
 		 */
 		this._highPassFilterMaterial = null;
 
@@ -236,7 +234,7 @@ class BloomNode extends TempNode {
 		 * The `updateBeforeType` is set to `NodeUpdateType.FRAME` since the node renders
 		 * its effect once per frame in `updateBefore()`.
 		 *
-		 * @type {String}
+		 * @type {string}
 		 * @default 'frame'
 		 */
 		this.updateBeforeType = NodeUpdateType.FRAME;
@@ -257,8 +255,8 @@ class BloomNode extends TempNode {
 	/**
 	 * Sets the size of the effect.
 	 *
-	 * @param {Number} width - The width of the effect.
-	 * @param {Number} height - The height of the effect.
+	 * @param {number} width - The width of the effect.
+	 * @param {number} height - The height of the effect.
 	 */
 	setSize( width, height ) {
 
@@ -444,7 +442,7 @@ class BloomNode extends TempNode {
 	 * Create a separable blur material for the given kernel radius.
 	 *
 	 * @param {NodeBuilder} builder - The current node builder.
-	 * @param {Number} kernelRadius - The kernel radius.
+	 * @param {number} kernelRadius - The kernel radius.
 	 * @return {NodeMaterial}
 	 */
 	_getSeparableBlurMaterial( builder, kernelRadius ) {
@@ -459,7 +457,7 @@ class BloomNode extends TempNode {
 
 		//
 
-		const colorTexture = texture();
+		const colorTexture = texture( null );
 		const gaussianCoefficients = uniformArray( coefficients );
 		const invSize = uniform( new Vector2() );
 		const direction = uniform( new Vector2( 0.5, 0.5 ) );
@@ -507,11 +505,12 @@ class BloomNode extends TempNode {
 /**
  * TSL function for creating a bloom effect.
  *
+ * @tsl
  * @function
  * @param {Node<vec4>} node - The node that represents the input of the effect.
- * @param {Number} [strength=1] - The strength of the bloom.
- * @param {Number} [radius=0] - The radius of the bloom.
- * @param {Number} [threshold=0] - The luminance threshold limits which bright areas contribute to the bloom effect.
+ * @param {number} [strength=1] - The strength of the bloom.
+ * @param {number} [radius=0] - The radius of the bloom.
+ * @param {number} [threshold=0] - The luminance threshold limits which bright areas contribute to the bloom effect.
  * @returns {BloomNode}
  */
 export const bloom = ( node, strength, radius, threshold ) => nodeObject( new BloomNode( nodeObject( node ), strength, radius, threshold ) );

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

@@ -2,8 +2,6 @@ import { DataTexture, RepeatWrapping, Vector2, Vector3, TempNode } from 'three/w
 import { texture, getNormalFromDepth, getViewPosition, convertToTexture, nodeObject, Fn, float, NodeUpdateType, uv, uniform, Loop, luminance, vec2, vec3, vec4, uniformArray, int, dot, max, pow, abs, If, textureSize, sin, cos, mat2, PI } from 'three/tsl';
 import { SimplexNoise } from '../../math/SimplexNoise.js';
 
-/** @module DenoiseNode **/
-
 /**
  * Post processing node for denoising data like raw screen-space ambient occlusion output.
  * Denoise can noticeably improve the quality of ambient occlusion but also add quite some
@@ -27,7 +25,7 @@ class DenoiseNode extends TempNode {
 	 *
 	 * @param {TextureNode} textureNode - The texture node that represents the input of the effect (e.g. AO).
 	 * @param {Node<float>} depthNode - A node that represents the scene's depth.
-	 * @param {Node<vec3>?} normalNode - A node that represents the scene's normals.
+	 * @param {?Node<vec3>} normalNode - A node that represents the scene's normals.
 	 * @param {Camera} camera - The camera the scene is rendered with.
 	 */
 	constructor( textureNode, depthNode, normalNode, camera ) {
@@ -53,7 +51,7 @@ class DenoiseNode extends TempNode {
 		 * constructor (because MRT is not available), normals can be automatically
 		 * reconstructed from depth values in the shader.
 		 *
-		 * @type {Node<vec3>?}
+		 * @type {?Node<vec3>}
 		 */
 		this.normalNode = normalNode;
 
@@ -103,7 +101,7 @@ class DenoiseNode extends TempNode {
 		 * The `updateBeforeType` is set to `NodeUpdateType.FRAME` since the node updates
 		 * its internal uniforms once per frame in `updateBefore()`.
 		 *
-		 * @type {String}
+		 * @type {string}
 		 * @default 'frame'
 		 */
 		this.updateBeforeType = NodeUpdateType.FRAME;
@@ -261,9 +259,9 @@ export default DenoiseNode;
 /**
  * Generates denoise samples based on the given parameters.
  *
- * @param {Number} numSamples - The number of samples.
- * @param {Number} numRings - The number of rings.
- * @param {Number} radiusExponent - The radius exponent.
+ * @param {number} numSamples - The number of samples.
+ * @param {number} numRings - The number of rings.
+ * @param {number} radiusExponent - The radius exponent.
  * @return {Array<Vector3>} The denoise samples.
  */
 function generateDenoiseSamples( numSamples, numRings, radiusExponent ) {
@@ -285,7 +283,7 @@ function generateDenoiseSamples( numSamples, numRings, radiusExponent ) {
 /**
  * Generates a default noise texture for the given size.
  *
- * @param {Number} [size=64] - The texture size.
+ * @param {number} [size=64] - The texture size.
  * @return {DataTexture} The generated noise texture.
  */
 function generateDefaultNoise( size = 64 ) {
@@ -323,10 +321,11 @@ function generateDefaultNoise( size = 64 ) {
 /**
  * TSL function for creating a denoise effect.
  *
+ * @tsl
  * @function
  * @param {Node} node - The node that represents the input of the effect (e.g. AO).
  * @param {Node<float>} depthNode - A node that represents the scene's depth.
- * @param {Node<vec3>?} normalNode - A node that represents the scene's normals.
+ * @param {?Node<vec3>} normalNode - A node that represents the scene's normals.
  * @param {Camera} camera - The camera the scene is rendered with.
  * @returns {DenoiseNode}
  */

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

@@ -1,8 +1,6 @@
 import { TempNode, NodeUpdateType } from 'three/webgpu';
 import { convertToTexture, nodeObject, Fn, uv, uniform, vec2, vec4, clamp } from 'three/tsl';
 
-/** @module DepthOfFieldNode **/
-
 /**
  * Post processing node for creating depth of field (DOF) effect.
  *
@@ -76,7 +74,7 @@ class DepthOfFieldNode extends TempNode {
 		 * The `updateBeforeType` is set to `NodeUpdateType.FRAME` since the node updates
 		 * its internal uniforms once per frame in `updateBefore()`.
 		 *
-		 * @type {String}
+		 * @type {string}
 		 * @default 'frame'
 		 */
 		this.updateBeforeType = NodeUpdateType.FRAME;
@@ -187,12 +185,13 @@ export default DepthOfFieldNode;
 /**
  * TSL function for creating a depth-of-field effect (DOF) for post processing.
  *
+ * @tsl
  * @function
  * @param {Node<vec4>} node - The node that represents the input of the effect.
  * @param {Node<float>} viewZNode - Represents the viewZ depth values of the scene.
- * @param {Node<float> | Number} focus - Defines the effect's focus which is the distance along the camera's look direction in world units.
- * @param {Node<float> | Number} aperture - Defines the effect's aperture.
- * @param {Node<float> | Number} maxblur - Defines the effect's maximum blur.
+ * @param {Node<float> | number} focus - Defines the effect's focus which is the distance along the camera's look direction in world units.
+ * @param {Node<float> | number} aperture - Defines the effect's aperture.
+ * @param {Node<float> | number} maxblur - Defines the effect's maximum blur.
  * @returns {DepthOfFieldNode}
  */
 export const dof = ( node, viewZNode, focus = 1, aperture = 0.025, maxblur = 1 ) => nodeObject( new DepthOfFieldNode( convertToTexture( node ), nodeObject( viewZNode ), nodeObject( focus ), nodeObject( aperture ), nodeObject( maxblur ) ) );

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

@@ -1,8 +1,6 @@
 import { TempNode } from 'three/webgpu';
 import { nodeObject, Fn, uv, uniform, vec2, vec3, sin, cos, add, vec4, screenSize } from 'three/tsl';
 
-/** @module DotScreenNode **/
-
 /**
  * Post processing node for creating dot-screen effect.
  *
@@ -20,8 +18,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} [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.
 	 */
 	constructor( inputNode, angle = 1.57, scale = 1 ) {
 
@@ -95,10 +93,11 @@ export default DotScreenNode;
 /**
  * TSL function for creating a dot-screen node for post processing.
  *
+ * @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} [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.
  * @returns {DotScreenNode}
  */
 export const dotScreen = ( node, angle, scale ) => nodeObject( new DotScreenNode( nodeObject( node ), angle, scale ) );

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

@@ -1,8 +1,6 @@
 import { Vector2, TempNode } from 'three/webgpu';
 import { nodeObject, Fn, uniformArray, select, float, NodeUpdateType, uv, dot, clamp, uniform, convertToTexture, smoothstep, bool, vec2, vec3, If, Loop, max, min, Break, abs } from 'three/tsl';
 
-/** @module FXAANode **/
-
 /**
  * Post processing node for applying FXAA. This node requires sRGB input
  * so tone mapping and color space conversion must happen before the anti-aliasing.
@@ -37,7 +35,7 @@ class FXAANode extends TempNode {
 		 * The `updateBeforeType` is set to `NodeUpdateType.FRAME` since the node updates
 		 * its internal uniforms once per frame in `updateBefore()`.
 		 *
-		 * @type {String}
+		 * @type {string}
 		 * @default 'frame'
 		 */
 		this.updateBeforeType = NodeUpdateType.FRAME;
@@ -358,6 +356,7 @@ export default FXAANode;
 /**
  * TSL function for creating a FXAA node for anti-aliasing via post processing.
  *
+ * @tsl
  * @function
  * @param {Node<vec4>} node - The node that represents the input of the effect.
  * @returns {FXAANode}

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

@@ -1,8 +1,6 @@
 import { TempNode } from 'three/webgpu';
 import { rand, Fn, fract, time, uv, clamp, mix, vec4, nodeProxy } from 'three/tsl';
 
-/** @module FilmNode **/
-
 /**
  * Post processing node for creating a film grain effect.
  *
@@ -20,8 +18,8 @@ class FilmNode extends TempNode {
 	 * Constructs a new film node.
 	 *
 	 * @param {Node} inputNode - The node that represents the input of the effect.
-	 * @param {Node<float>?} [intensityNode=null] - A node that represents the effect's intensity.
-	 * @param {Node<vec2>?} [uvNode=null] - A node that allows to pass custom (e.g. animated) uv data.
+	 * @param {?Node<float>} [intensityNode=null] - A node that represents the effect's intensity.
+	 * @param {?Node<vec2>} [uvNode=null] - A node that allows to pass custom (e.g. animated) uv data.
 	 */
 	constructor( inputNode, intensityNode = null, uvNode = null ) {
 
@@ -37,14 +35,16 @@ class FilmNode extends TempNode {
 		/**
 		 * A node that represents the effect's intensity.
 		 *
-		 * @type {Node<float>}
+		 * @type {?Node<float>}
+		 * @default null
 		 */
 		this.intensityNode = intensityNode;
 
 		/**
 		 * A node that allows to pass custom (e.g. animated) uv data.
 		 *
-		 * @type {Node<vec2>}
+		 * @type {?Node<vec2>}
+		 * @default null
 		 */
 		this.uvNode = uvNode;
 
@@ -90,10 +90,11 @@ export default FilmNode;
 /**
  * TSL function for creating a film node for post processing.
  *
+ * @tsl
  * @function
  * @param {Node<vec4>} inputNode - The node that represents the input of the effect.
- * @param {Node<float>?} [intensityNode=null] - A node that represents the effect's intensity.
- * @param {Node<vec2>?} [uvNode=null] - A node that allows to pass custom (e.g. animated) uv data.
+ * @param {?Node<float>} [intensityNode=null] - A node that represents the effect's intensity.
+ * @param {?Node<vec2>} [uvNode=null] - A node that allows to pass custom (e.g. animated) uv data.
  * @returns {FilmNode}
  */
 export const film = /*@__PURE__*/ nodeProxy( FilmNode );

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

@@ -1,8 +1,6 @@
 import { DataTexture, RenderTarget, RepeatWrapping, Vector2, Vector3, TempNode, QuadMesh, NodeMaterial, RendererUtils } from 'three/webgpu';
 import { reference, logarithmicDepthToViewZ, viewZToPerspectiveDepth, getNormalFromDepth, getScreenPosition, getViewPosition, nodeObject, Fn, float, NodeUpdateType, uv, uniform, Loop, vec2, vec3, vec4, int, dot, max, pow, abs, If, textureSize, sin, cos, PI, texture, passTexture, mat3, add, normalize, mul, cross, div, mix, sqrt, sub, acos, clamp } from 'three/tsl';
 
-/** @module GTAONode **/
-
 const _quadMesh = /*@__PURE__*/ new QuadMesh();
 const _size = /*@__PURE__*/ new Vector2();
 
@@ -44,7 +42,7 @@ class GTAONode extends TempNode {
 	 * Constructs a new GTAO node.
 	 *
 	 * @param {Node<float>} depthNode - A node that represents the scene's depth.
-	 * @param {Node<vec3>?} normalNode - A node that represents the scene's normals.
+	 * @param {?Node<vec3>} normalNode - A node that represents the scene's normals.
 	 * @param {Camera} camera - The camera the scene is rendered with.
 	 */
 	constructor( depthNode, normalNode, camera ) {
@@ -63,7 +61,7 @@ class GTAONode extends TempNode {
 		 * constructor (because MRT is not available), normals can be automatically
 		 * reconstructed from depth values in the shader.
 		 *
-		 * @type {Node<vec3>?}
+		 * @type {?Node<vec3>}
 		 */
 		this.normalNode = normalNode;
 
@@ -71,7 +69,7 @@ class GTAONode extends TempNode {
 		 * The resolution scale. By default the effect is rendered in full resolution
 		 * for best quality but a value of `0.5` should be sufficient for most scenes.
 		 *
-		 * @type {Number}
+		 * @type {number}
 		 * @default 1
 		 */
 		this.resolutionScale = 1;
@@ -80,7 +78,7 @@ class GTAONode extends TempNode {
 		 * The `updateBeforeType` is set to `NodeUpdateType.FRAME` since the node renders
 		 * its effect once per frame in `updateBefore()`.
 		 *
-		 * @type {String}
+		 * @type {string}
 		 * @default 'frame'
 		 */
 		this.updateBeforeType = NodeUpdateType.FRAME;
@@ -224,8 +222,8 @@ class GTAONode extends TempNode {
 	/**
 	 * Sets the size of the effect.
 	 *
-	 * @param {Number} width - The width of the effect.
-	 * @param {Number} height - The height of the effect.
+	 * @param {number} width - The width of the effect.
+	 * @param {number} height - The height of the effect.
 	 */
 	setSize( width, height ) {
 
@@ -417,7 +415,7 @@ export default GTAONode;
 /**
  * Generates the AO's noise texture for the given size.
  *
- * @param {Number} [size=5] - The noise size.
+ * @param {number} [size=5] - The noise size.
  * @return {DataTexture} The generated noise texture.
  */
 function generateMagicSquareNoise( size = 5 ) {
@@ -455,8 +453,8 @@ function generateMagicSquareNoise( size = 5 ) {
 /**
  * Computes an array of magic square values required to generate the noise texture.
  *
- * @param {Number} size - The noise size.
- * @return {Array<Number>} The magic square values.
+ * @param {number} size - The noise size.
+ * @return {Array<number>} The magic square values.
  */
 function generateMagicSquare( size ) {
 
@@ -513,9 +511,10 @@ function generateMagicSquare( size ) {
 /**
  * TSL function for creating a Ground Truth Ambient Occlusion (GTAO) effect.
  *
+ * @tsl
  * @function
  * @param {Node<float>} depthNode - A node that represents the scene's depth.
- * @param {Node<vec3>?} normalNode - A node that represents the scene's normals.
+ * @param {?Node<vec3>} normalNode - A node that represents the scene's normals.
  * @param {Camera} camera - The camera the scene is rendered with.
  * @returns {GTAONode}
  */