From 64d593df921c041bc173674eca73898b0f5feeec Mon Sep 17 00:00:00 2001
From: Christian Helgeson <62450112+cmhhelgeson@users.noreply.github.com>
Date: Tue, 30 Sep 2025 16:04:22 -0700
Subject: [PATCH 01/17] init branch

---
 examples/webgpu_compute_reduce.html |  8 ++---
 src/Three.TSL.js                    |  6 ++++
 src/nodes/math/MathNode.js          | 46 +++++++++++++++++++++++++++++
 3 files changed, 56 insertions(+), 4 deletions(-)

diff --git a/examples/webgpu_compute_reduce.html b/examples/webgpu_compute_reduce.html
index 8145d709f29229..d14ac0994fd439 100644
--- a/examples/webgpu_compute_reduce.html
+++ b/examples/webgpu_compute_reduce.html
@@ -190,7 +190,7 @@ <h3 id="panel-title" style="flex: 0 0 auto;">Subgroup Reduction Explanation</h3>
 		<script type="module">
 
 			import * as THREE from 'three/webgpu';
-			import { instancedArray, Loop, If, vec3, dot, clamp, storage, uvec4, subgroupAdd, uniform, uv, uint, float, Fn, vec2, invocationLocalIndex, invocationSubgroupIndex, uvec2, floor, instanceIndex, workgroupId, workgroupBarrier, workgroupArray, subgroupSize, select, log2 } from 'three/tsl';
+			import { instancedArray, Loop, If, vec3, dot, clamp, storage, uvec4, subgroupAdd, uniform, uv, uint, float, Fn, vec2, invocationLocalIndex, invocationSubgroupIndex, uvec2, floor, instanceIndex, workgroupId, workgroupBarrier, workgroupArray, subgroupSize, select, countTrailingZeros } from 'three/tsl';
 
 			import WebGPU from 'three/addons/capabilities/WebGPU.js';
 
@@ -831,12 +831,12 @@ <h3 id="panel-title" style="flex: 0 0 auto;">Subgroup Reduction Explanation</h3>
 
 					// Multiple approaches here
 					// log2(subgroupSize) -> TSL log2 function
-					// countTrailingZeros/findLSB(subgroupSize) -> Currently unsupported function in TSL that counts trailing zeros in number bit representation
+					// countTrailingZeros/findLSB(subgroupSize) -> TSL function that counts trailing zeros in number bit representation
 					// Can technically petition GPU for subgroupSize in shader and calculate logs on CPU at cost of shader being generalizable across devices
 					// May also break if subgroupSize changes when device is lost or if program is rerun on lower power device
-					const subgroupSizeLog = uint( log2( float( subgroupSize ) ) ).toVar( 'subgroupSizeLog' );
+					const subgroupSizeLog = countTrailingZeros( subgroupSize ).toVar( 'subgroupSizeLog' );
 					const spineSize = uint( workgroupSize ).shiftRight( subgroupSizeLog );
-					const spineSizeLog = uint( log2( float( spineSize ) ) ).toVar( 'spineSizeLog' );
+					const spineSizeLog = countTrailingZeros( spineSize ).toVar( 'spineSizeLog' );
 
 
 					// Align size to powers of subgroupSize
diff --git a/src/Three.TSL.js b/src/Three.TSL.js
index 46ba4ef06e8541..529be9a5798632 100644
--- a/src/Three.TSL.js
+++ b/src/Three.TSL.js
@@ -80,6 +80,7 @@ export const batch = TSL.batch;
 export const bentNormalView = TSL.bentNormalView;
 export const billboarding = TSL.billboarding;
 export const bitAnd = TSL.bitAnd;
+export const bitCount = TSL.bitCount;
 export const bitNot = TSL.bitNot;
 export const bitOr = TSL.bitOr;
 export const bitXor = TSL.bitXor;
@@ -136,6 +137,9 @@ export const context = TSL.context;
 export const convert = TSL.convert;
 export const convertColorSpace = TSL.convertColorSpace;
 export const convertToTexture = TSL.convertToTexture;
+export const countLeadingZeros = TSL.countLeadingZeros;
+export const countOneBits = TSL.countOneBits;
+export const countTrailingZeros = TSL.countTrailingZeros;
 export const cos = TSL.cos;
 export const cross = TSL.cross;
 export const cubeTexture = TSL.cubeTexture;
@@ -180,6 +184,8 @@ export const expression = TSL.expression;
 export const faceDirection = TSL.faceDirection;
 export const faceForward = TSL.faceForward;
 export const faceforward = TSL.faceforward;
+export const findLSB = TSL.findLSB;
+export const findMSB = TSL.findMSB;
 export const float = TSL.float;
 export const floatBitsToInt = TSL.floatBitsToInt;
 export const floatBitsToUint = TSL.floatBitsToUint;
diff --git a/src/nodes/math/MathNode.js b/src/nodes/math/MathNode.js
index 8271477e82f6ec..ca221ec1c0e671 100644
--- a/src/nodes/math/MathNode.js
+++ b/src/nodes/math/MathNode.js
@@ -364,6 +364,9 @@ MathNode.FWIDTH = 'fwidth';
 MathNode.TRANSPOSE = 'transpose';
 MathNode.DETERMINANT = 'determinant';
 MathNode.INVERSE = 'inverse';
+MathNode.COUNT_TRAILING_ZEROS = 'countTrailingZeros';
+MathNode.COUNT_LEADING_ZEROS = 'countLeadingZeros';
+MathNode.COUNT_ONE_BITS = 'countOneBits';
 
 // 2 inputs
 
@@ -1099,10 +1102,50 @@ export const atan2 = ( y, x ) => { // @deprecated, r172
 
 };
 
+
+/**
+ * Finds the number of consecutive 0 bits from the least significant bit of the input value,
+ * which is also the index of the least significant bit of the input value.
+ *
+ * Can only be used with {@link WebGPURenderer} and a WebGPU backend.
+ *
+ * @tsl
+ * @function
+ * @param {Node | number} x - The input value.
+ * @returns {Node}
+ */
+export const countTrailingZeros = /*@__PURE__*/ nodeProxyIntent( MathNode, MathNode.COUNT_TRAILING_ZEROS ).setParameterLength( 1 );
+
+/**
+ * Finds the number of consecutive 0 bits starting from the most significant bit of the input value.
+ *
+ * Can only be used with {@link WebGPURenderer} and a WebGPU backend.
+ *
+ * @tsl
+ * @function
+ * @param {Node | number} x - The input value.
+ * @returns {Node}
+ */
+export const countLeadingZeros = /*@__PURE__*/ nodeProxyIntent( MathNode, MathNode.COUNT_LEADING_ZEROS ).setParameterLength( 1 );
+
+/**
+ * Finds the number of '1' bits set in the input value
+ *
+ * Can only be used with {@link WebGPURenderer} and a WebGPU backend.
+ *
+ * @tsl
+ * @function
+ * @returns {Node}
+ */
+export const countOneBits = /*@__PURE__*/ nodeProxyIntent( MathNode, MathNode.COUNT_ONE_BITS ).setParameterLength( 1 );
+
 // GLSL alias function
 
 export const faceforward = faceForward;
 export const inversesqrt = inverseSqrt;
+export const findLSB = countTrailingZeros;
+export const findMSB = countLeadingZeros;
+export const bitCount = countOneBits;
 
 // Method chaining
 
@@ -1165,3 +1208,6 @@ addMethodChaining( 'transpose', transpose );
 addMethodChaining( 'determinant', determinant );
 addMethodChaining( 'inverse', inverse );
 addMethodChaining( 'rand', rand );
+addMethodChaining( 'countTrailingZeros', countTrailingZeros );
+addMethodChaining( 'countLeadingZeros', countLeadingZeros );
+addMethodChaining( 'countOneBits', countOneBits );

From 6c32a0613cafa366ba815496b5b93c5346dfe6f2 Mon Sep 17 00:00:00 2001
From: Christian Helgeson <62450112+cmhhelgeson@users.noreply.github.com>
Date: Wed, 1 Oct 2025 15:33:14 -0700
Subject: [PATCH 02/17] sketch out solve

---
 examples/jsm/tsl/display/SSGINode.js          |  7 +++---
 .../webgl-fallback/nodes/GLSLNodeBuilder.js   | 23 +++++++++++++++++++
 2 files changed, 27 insertions(+), 3 deletions(-)

diff --git a/examples/jsm/tsl/display/SSGINode.js b/examples/jsm/tsl/display/SSGINode.js
index e0a549874cb7db..2675a90dd3e92b 100644
--- a/examples/jsm/tsl/display/SSGINode.js
+++ b/examples/jsm/tsl/display/SSGINode.js
@@ -1,5 +1,6 @@
 import { RenderTarget, Vector2, TempNode, QuadMesh, NodeMaterial, RendererUtils, MathUtils } from 'three/webgpu';
-import { clamp, normalize, reference, nodeObject, Fn, NodeUpdateType, uniform, vec4, passTexture, uv, logarithmicDepthToViewZ, viewZToPerspectiveDepth, getViewPosition, screenCoordinate, float, sub, fract, dot, vec2, rand, vec3, Loop, mul, PI, cos, sin, uint, cross, acos, sign, pow, luminance, If, max, abs, Break, sqrt, HALF_PI, div, ceil, shiftRight, convertToTexture, bool, getNormalFromDepth, interleavedGradientNoise } from 'three/tsl';
+import { clamp, normalize, reference, nodeObject, Fn, NodeUpdateType, uniform, vec4, passTexture, uv, logarithmicDepthToViewZ, viewZToPerspectiveDepth, getViewPosition, screenCoordinate, float, sub, fract, dot, vec2, rand, vec3, Loop, mul, PI, cos, sin, uint, cross, acos, sign, pow, luminance, If, max, abs, Break, sqrt, HALF_PI, div, ceil, shiftRight, convertToTexture, bool, getNormalFromDepth, bitCount, interleavedGradientNoise } from 'three/tsl';
+
 
 const _quadMesh = /*@__PURE__*/ new QuadMesh();
 const _size = /*@__PURE__*/ new Vector2();
@@ -435,7 +436,7 @@ class SSGINode extends TempNode {
 			]
 		} );
 
-		const bitCount = Fn( ( [ value ] ) => {
+		/*const bitCount = Fn( ( [ value ] ) => {
 
 			const v = uint( value );
 			v.assign( v.sub( v.shiftRight( uint( 1 ) ).bitAnd( uint( 0x55555555 ) ) ) );
@@ -449,7 +450,7 @@ class SSGINode extends TempNode {
 			inputs: [
 				{ name: 'value', type: 'uint' }
 			]
-		} );
+		} ); */
 
 		const horizonSampling = Fn( ( [ directionIsRight, RADIUS, viewPosition, slideDirTexelSize, initialRayStep, uvNode, viewDir, viewNormal, n ] ) => {
 
diff --git a/src/renderers/webgl-fallback/nodes/GLSLNodeBuilder.js b/src/renderers/webgl-fallback/nodes/GLSLNodeBuilder.js
index 476e07f0c61876..76f18ba9d0ed9c 100644
--- a/src/renderers/webgl-fallback/nodes/GLSLNodeBuilder.js
+++ b/src/renderers/webgl-fallback/nodes/GLSLNodeBuilder.js
@@ -134,6 +134,23 @@ class GLSLNodeBuilder extends NodeBuilder {
 
 	}
 
+	_include( name ) {
+
+		// Collect the array of functions needed to polyfill the specified functionality
+		const polyfill = glslPolyfills[ name ];
+
+		for ( const codeNode of polyfill.codeNodes ) {
+
+			// Build and include each relevant function
+			codeNode.build( this );
+			this.addInclude( codeNode );
+
+		}
+
+		return polyfill.entryIndex ? polyfill.codeNodes[ polyfill.entryIndex ] : polyfill.codeNodes[ 0 ];
+
+	}
+
 	/**
 	 * Includes the given method name into the current
 	 * function node.
@@ -1320,6 +1337,8 @@ ${vars}
 	 */
 	_getGLSLVertexCode( shaderData ) {
 
+		console.log( shaderData );
+
 		return `#version 300 es
 
 ${ this.getSignature() }
@@ -1369,6 +1388,8 @@ void main() {
 	 */
 	_getGLSLFragmentCode( shaderData ) {
 
+		console.log( shaderData );
+
 		return `#version 300 es
 
 ${ this.getSignature() }
@@ -1478,6 +1499,8 @@ void main() {
 
 			this.vertexShader = this._getGLSLVertexCode( shadersData.vertex );
 			this.fragmentShader = this._getGLSLFragmentCode( shadersData.fragment );
+			console.log( this.vertexShader );
+			console.log( this.fragmentShader );
 
 		} else {
 

From 2706a8458dfd27314fbf0d5709febf111847fa61 Mon Sep 17 00:00:00 2001
From: Christian Helgeson <62450112+cmhhelgeson@users.noreply.github.com>
Date: Thu, 2 Oct 2025 12:51:46 -0700
Subject: [PATCH 03/17] work on src

---
 src/nodes/TSL.js                              |   1 +
 src/nodes/math/BitcountNode.js                | 211 ++++++++++++++++++
 src/nodes/math/MathNode.js                    |  50 +----
 .../webgl-fallback/nodes/GLSLNodeBuilder.js   |  32 ++-
 4 files changed, 228 insertions(+), 66 deletions(-)
 create mode 100644 src/nodes/math/BitcountNode.js

diff --git a/src/nodes/TSL.js b/src/nodes/TSL.js
index 2ed79fae9778c0..da2f0ca507dd54 100644
--- a/src/nodes/TSL.js
+++ b/src/nodes/TSL.js
@@ -20,6 +20,7 @@ export * from './core/MRTNode.js';
 
 // math
 export * from './math/BitcastNode.js';
+export * from './math/BitcountNode.js';
 export * from './math/Hash.js';
 export * from './math/MathUtils.js';
 export * from './math/TriNoise3D.js';
diff --git a/src/nodes/math/BitcountNode.js b/src/nodes/math/BitcountNode.js
new file mode 100644
index 00000000000000..20e27cd0876893
--- /dev/null
+++ b/src/nodes/math/BitcountNode.js
@@ -0,0 +1,211 @@
+import TempNode from '../core/TempNode.js';
+import { addMethodChaining, Fn, nodeProxyIntent, uint } from '../tsl/TSLCore.js';
+import { bitcast } from './BitcastNode.js';
+import MathNode from './MathNode.js';
+/**
+ * This node represents an operation that reinterprets the bit representation of a value
+ * in one type as a value in another type.
+ *
+ * @augments TempNode
+ */
+class BitcountNode extends MathNode {
+
+	static get type() {
+
+		return 'BitcountNode';
+
+	}
+
+	/**
+	 * Constructs a new math node.
+	 *
+	 * @param {string} method - The method name.
+	 * @param {Node} aNode - The first input.
+	 */
+	constructor( method, aNode ) {
+
+		super( method, aNode );
+
+		/**
+		 * This flag can be used for type testing.
+		 *
+		 * @type {boolean}
+		 * @readonly
+		 * @default true
+		 */
+		this.isBitcountNode = true;
+
+	}
+
+	getNodeType( /*builder*/ ) {
+
+		return 'uint';
+
+	}
+
+	/**
+	 * Constructs a new math node.
+	 *
+	 * @param {NodeBuilder} builder - The method name.
+	 * @return {?Node} The output node.
+	 */
+	setup( builder ) {
+
+		const { method, aNode } = this;
+
+		const { renderer } = builder;
+
+		if ( renderer.backend.isWebGPUBackend ) {
+
+			return super.setup( builder );
+
+		}
+
+		const inputType = this.getInputType();
+		const elementType = builder.getElementType( inputType );
+
+		const typeLength = builder.getTypeLength();
+
+		console.log( inputType, elementType, typeLength );
+
+
+		if ( method === BitcountNode.COUNT_LEADING_ZEROS ) {
+
+
+
+
+		} else if ( method === BitcountNode.COUNT_TRAILING_ZEROS ) {
+
+
+
+		} else if ( method === BitcountNode.COUNT_ONE_BITS ) {
+
+			const bitCountBase = Fn( ( [ value ] ) => {
+
+				const v = uint( 0.0 );
+
+				if ( elementType === 'int' ) {
+
+					v.assign( bitcast( value, 'uint' ) );
+
+				}
+
+				v.assign( v.sub( v.shiftRight( uint( 1 ) ).bitAnd( uint( 0x55555555 ) ) ) );
+				v.assign( v.bitAnd( uint( 0x33333333 ) ).add( v.shiftRight( uint( 2 ) ).bitAnd( uint( 0x33333333 ) ) ) );
+
+				return v.add( v.shiftRight( uint( 4 ) ) ).bitAnd( uint( 0xF0F0F0F ) ).mul( uint( 0x1010101 ) ).shiftRight( uint( 24 ) );
+
+			} ).setLayout( {
+				name: `bitcount_${elementType}`,
+				type: 'uint',
+				inputs: [
+					{ name: 'value', type: elementType }
+				]
+			} );
+
+
+			const bitCountFn = Fn( ( [ value ] ) => {
+
+				const v = uint( 0.0 );
+
+				if ( typeLength === 1 ) {
+
+					v.addAssign( bitCountBase( value ) );
+
+				} else {
+
+					const components = [ 'x', 'y', 'z', 'w' ];
+
+					for ( let i = 0; i < typeLength; i ++ ) {
+
+						const component = components[ i ];
+
+						v.addAssign( bitCountBase( value[ component ] ) );
+
+					}
+
+				}
+
+				return v;
+
+			} ).setLayout( {
+				name: `bitcount_main_${this.nodeType}`,
+				type: 'uint',
+				inputs: [
+					{ name: 'value', type: inputType }
+				]
+			} );
+
+			console.log( 'test' );
+
+			const exec = bitCountFn( aNode ).toVar( 'testVar' );
+
+			return exec;
+
+		}
+
+	}
+
+	generate( builder ) {
+
+		this.method += 'test';
+
+		super.generate( builder );
+
+
+
+	}
+
+}
+
+export default BitcountNode;
+
+BitcountNode.COUNT_TRAILING_ZEROS = 'countTrailingZeros';
+BitcountNode.COUNT_LEADING_ZEROS = 'countLeadingZeros';
+BitcountNode.COUNT_ONE_BITS = 'countOneBits';
+
+/**
+ * Finds the number of consecutive 0 bits from the least significant bit of the input value,
+ * which is also the index of the least significant bit of the input value.
+ *
+ * Can only be used with {@link WebGPURenderer} and a WebGPU backend.
+ *
+ * @tsl
+ * @function
+ * @param {Node | number} x - The input value.
+ * @returns {Node}
+ */
+export const countTrailingZeros = /*@__PURE__*/ nodeProxyIntent( BitcountNode, BitcountNode.COUNT_TRAILING_ZEROS ).setParameterLength( 1 );
+
+/**
+ * Finds the number of consecutive 0 bits starting from the most significant bit of the input value.
+ *
+ * Can only be used with {@link WebGPURenderer} and a WebGPU backend.
+ *
+ * @tsl
+ * @function
+ * @param {Node | number} x - The input value.
+ * @returns {Node}
+ */
+export const countLeadingZeros = /*@__PURE__*/ nodeProxyIntent( BitcountNode, BitcountNode.COUNT_LEADING_ZEROS ).setParameterLength( 1 );
+
+/**
+ * Finds the number of '1' bits set in the input value
+ *
+ * Can only be used with {@link WebGPURenderer} and a WebGPU backend.
+ *
+ * @tsl
+ * @function
+ * @returns {Node}
+ */
+export const countOneBits = /*@__PURE__*/ nodeProxyIntent( BitcountNode, BitcountNode.COUNT_ONE_BITS ).setParameterLength( 1 );
+
+// GLSL alias function
+
+export const findLSB = countTrailingZeros;
+export const findMSB = countLeadingZeros;
+export const bitCount = countOneBits;
+
+addMethodChaining( 'countTrailingZeros', countTrailingZeros );
+addMethodChaining( 'countLeadingZeros', countLeadingZeros );
+addMethodChaining( 'countOneBits', countOneBits );
diff --git a/src/nodes/math/MathNode.js b/src/nodes/math/MathNode.js
index ca221ec1c0e671..4736d84f44bd85 100644
--- a/src/nodes/math/MathNode.js
+++ b/src/nodes/math/MathNode.js
@@ -217,6 +217,8 @@ class MathNode extends TempNode {
 
 	generate( builder, output ) {
 
+		console.log( this.method );
+
 		const properties = builder.getNodeProperties( this );
 
 		if ( properties.outputNode ) {
@@ -364,9 +366,6 @@ MathNode.FWIDTH = 'fwidth';
 MathNode.TRANSPOSE = 'transpose';
 MathNode.DETERMINANT = 'determinant';
 MathNode.INVERSE = 'inverse';
-MathNode.COUNT_TRAILING_ZEROS = 'countTrailingZeros';
-MathNode.COUNT_LEADING_ZEROS = 'countLeadingZeros';
-MathNode.COUNT_ONE_BITS = 'countOneBits';
 
 // 2 inputs
 
@@ -1103,49 +1102,7 @@ export const atan2 = ( y, x ) => { // @deprecated, r172
 };
 
 
-/**
- * Finds the number of consecutive 0 bits from the least significant bit of the input value,
- * which is also the index of the least significant bit of the input value.
- *
- * Can only be used with {@link WebGPURenderer} and a WebGPU backend.
- *
- * @tsl
- * @function
- * @param {Node | number} x - The input value.
- * @returns {Node}
- */
-export const countTrailingZeros = /*@__PURE__*/ nodeProxyIntent( MathNode, MathNode.COUNT_TRAILING_ZEROS ).setParameterLength( 1 );
-
-/**
- * Finds the number of consecutive 0 bits starting from the most significant bit of the input value.
- *
- * Can only be used with {@link WebGPURenderer} and a WebGPU backend.
- *
- * @tsl
- * @function
- * @param {Node | number} x - The input value.
- * @returns {Node}
- */
-export const countLeadingZeros = /*@__PURE__*/ nodeProxyIntent( MathNode, MathNode.COUNT_LEADING_ZEROS ).setParameterLength( 1 );
-
-/**
- * Finds the number of '1' bits set in the input value
- *
- * Can only be used with {@link WebGPURenderer} and a WebGPU backend.
- *
- * @tsl
- * @function
- * @returns {Node}
- */
-export const countOneBits = /*@__PURE__*/ nodeProxyIntent( MathNode, MathNode.COUNT_ONE_BITS ).setParameterLength( 1 );
-
-// GLSL alias function
 
-export const faceforward = faceForward;
-export const inversesqrt = inverseSqrt;
-export const findLSB = countTrailingZeros;
-export const findMSB = countLeadingZeros;
-export const bitCount = countOneBits;
 
 // Method chaining
 
@@ -1208,6 +1165,3 @@ addMethodChaining( 'transpose', transpose );
 addMethodChaining( 'determinant', determinant );
 addMethodChaining( 'inverse', inverse );
 addMethodChaining( 'rand', rand );
-addMethodChaining( 'countTrailingZeros', countTrailingZeros );
-addMethodChaining( 'countLeadingZeros', countLeadingZeros );
-addMethodChaining( 'countOneBits', countOneBits );
diff --git a/src/renderers/webgl-fallback/nodes/GLSLNodeBuilder.js b/src/renderers/webgl-fallback/nodes/GLSLNodeBuilder.js
index 76f18ba9d0ed9c..d3f26bedd5dd2b 100644
--- a/src/renderers/webgl-fallback/nodes/GLSLNodeBuilder.js
+++ b/src/renderers/webgl-fallback/nodes/GLSLNodeBuilder.js
@@ -10,8 +10,8 @@ import { DataTexture } from '../../../textures/DataTexture.js';
 import { error } from '../../../utils.js';
 
 const glslPolyfills = {
-	bitcast_int_uint: new CodeNode( /* glsl */'uint tsl_bitcast_uint_to_int ( int x ) { return floatBitsToInt( uintBitsToFloat( x ) ); }' ),
-	bitcast_uint_int: new CodeNode( /* glsl */'uint tsl_bitcast_int_to_uint ( int x ) { return floatBitsToUint( intBitsToFloat ( x ) ); }' )
+	bitcast_int_uint: new CodeNode( /* glsl */'uint tsl_bitcast_int_to_uint ( int x ) { return floatBitsToUint( intBitsToFloat ( x ) ); }' ),
+	bitcast_uint_int: new CodeNode( /* glsl */'int tsl_bitcast_uint_to_int ( uint x ) { return floatBitsToInt( uintBitsToFloat( x ) ); }' )
 };
 
 const glslMethods = {
@@ -134,20 +134,22 @@ class GLSLNodeBuilder extends NodeBuilder {
 
 	}
 
+	/**
+	 * Includes the given method name into the current
+	 * function node.
+	 *
+	 * @private
+	 * @param {string} name - The method name to include.
+	 * @return {CodeNode} The respective code node.
+	 */
 	_include( name ) {
 
-		// Collect the array of functions needed to polyfill the specified functionality
-		const polyfill = glslPolyfills[ name ];
-
-		for ( const codeNode of polyfill.codeNodes ) {
-
-			// Build and include each relevant function
-			codeNode.build( this );
-			this.addInclude( codeNode );
+		const codeNode = glslPolyfills[ name ];
+		codeNode.build( this );
 
-		}
+		this.addInclude( codeNode );
 
-		return polyfill.entryIndex ? polyfill.codeNodes[ polyfill.entryIndex ] : polyfill.codeNodes[ 0 ];
+		return codeNode;
 
 	}
 
@@ -1337,8 +1339,6 @@ ${vars}
 	 */
 	_getGLSLVertexCode( shaderData ) {
 
-		console.log( shaderData );
-
 		return `#version 300 es
 
 ${ this.getSignature() }
@@ -1388,8 +1388,6 @@ void main() {
 	 */
 	_getGLSLFragmentCode( shaderData ) {
 
-		console.log( shaderData );
-
 		return `#version 300 es
 
 ${ this.getSignature() }
@@ -1499,8 +1497,6 @@ void main() {
 
 			this.vertexShader = this._getGLSLVertexCode( shadersData.vertex );
 			this.fragmentShader = this._getGLSLFragmentCode( shadersData.fragment );
-			console.log( this.vertexShader );
-			console.log( this.fragmentShader );
 
 		} else {
 

From 1e79f2618bbd2c5e4df92df7d245cad76bdaff4d Mon Sep 17 00:00:00 2001
From: Christian Helgeson <62450112+cmhhelgeson@users.noreply.github.com>
Date: Fri, 3 Oct 2025 16:02:30 -0700
Subject: [PATCH 04/17] use setup approach and register functions that need to
 be created

---
 examples/jsm/tsl/display/SSGINode.js |  16 ----
 src/nodes/math/BitcountNode.js       | 114 ++++++++++++++++-----------
 src/nodes/math/MathNode.js           |   2 -
 3 files changed, 66 insertions(+), 66 deletions(-)

diff --git a/examples/jsm/tsl/display/SSGINode.js b/examples/jsm/tsl/display/SSGINode.js
index 2675a90dd3e92b..017dbda4e1ee6b 100644
--- a/examples/jsm/tsl/display/SSGINode.js
+++ b/examples/jsm/tsl/display/SSGINode.js
@@ -436,22 +436,6 @@ class SSGINode extends TempNode {
 			]
 		} );
 
-		/*const bitCount = Fn( ( [ value ] ) => {
-
-			const v = uint( value );
-			v.assign( v.sub( v.shiftRight( uint( 1 ) ).bitAnd( uint( 0x55555555 ) ) ) );
-			v.assign( v.bitAnd( uint( 0x33333333 ) ).add( v.shiftRight( uint( 2 ) ).bitAnd( uint( 0x33333333 ) ) ) );
-
-			return v.add( v.shiftRight( uint( 4 ) ) ).bitAnd( uint( 0xF0F0F0F ) ).mul( uint( 0x1010101 ) ).shiftRight( uint( 24 ) );
-
-		} ).setLayout( {
-			name: 'bitCount',
-			type: 'uint',
-			inputs: [
-				{ name: 'value', type: 'uint' }
-			]
-		} ); */
-
 		const horizonSampling = Fn( ( [ directionIsRight, RADIUS, viewPosition, slideDirTexelSize, initialRayStep, uvNode, viewDir, viewNormal, n ] ) => {
 
 			const STEP_COUNT = this.stepCount.toConst();
diff --git a/src/nodes/math/BitcountNode.js b/src/nodes/math/BitcountNode.js
index 20e27cd0876893..ede8be97b779b9 100644
--- a/src/nodes/math/BitcountNode.js
+++ b/src/nodes/math/BitcountNode.js
@@ -1,7 +1,9 @@
-import TempNode from '../core/TempNode.js';
 import { addMethodChaining, Fn, nodeProxyIntent, uint } from '../tsl/TSLCore.js';
 import { bitcast } from './BitcastNode.js';
 import MathNode from './MathNode.js';
+
+const registeredBitcountFunctions = {};
+
 /**
  * This node represents an operation that reinterprets the bit representation of a value
  * in one type as a value in another type.
@@ -61,13 +63,10 @@ class BitcountNode extends MathNode {
 
 		}
 
-		const inputType = this.getInputType();
+		const inputType = this.getInputType( builder );
 		const elementType = builder.getElementType( inputType );
 
-		const typeLength = builder.getTypeLength();
-
-		console.log( inputType, elementType, typeLength );
-
+		const typeLength = builder.getTypeLength( inputType );
 
 		if ( method === BitcountNode.COUNT_LEADING_ZEROS ) {
 
@@ -80,79 +79,98 @@ class BitcountNode extends MathNode {
 
 		} else if ( method === BitcountNode.COUNT_ONE_BITS ) {
 
-			const bitCountBase = Fn( ( [ value ] ) => {
+			const bitcountBaseMethod = `bitcount_base_${elementType}`;
 
-				const v = uint( 0.0 );
+			let bitCountBaseFn = registeredBitcountFunctions[ bitcountBaseMethod ];
 
-				if ( elementType === 'int' ) {
+			if ( bitCountBaseFn === undefined ) {
 
-					v.assign( bitcast( value, 'uint' ) );
+				bitCountBaseFn = Fn( ( [ value ] ) => {
 
-				}
+					const v = uint( 0.0 );
 
-				v.assign( v.sub( v.shiftRight( uint( 1 ) ).bitAnd( uint( 0x55555555 ) ) ) );
-				v.assign( v.bitAnd( uint( 0x33333333 ) ).add( v.shiftRight( uint( 2 ) ).bitAnd( uint( 0x33333333 ) ) ) );
+					if ( elementType === 'int' ) {
 
-				return v.add( v.shiftRight( uint( 4 ) ) ).bitAnd( uint( 0xF0F0F0F ) ).mul( uint( 0x1010101 ) ).shiftRight( uint( 24 ) );
+						v.assign( bitcast( value, 'uint' ) );
 
-			} ).setLayout( {
-				name: `bitcount_${elementType}`,
-				type: 'uint',
-				inputs: [
-					{ name: 'value', type: elementType }
-				]
-			} );
+					} else {
 
+						v.assign( value );
 
-			const bitCountFn = Fn( ( [ value ] ) => {
+					}
 
-				const v = uint( 0.0 );
+					v.assign( v.sub( v.shiftRight( uint( 1 ) ).bitAnd( uint( 0x55555555 ) ) ) );
+					v.assign( v.bitAnd( uint( 0x33333333 ) ).add( v.shiftRight( uint( 2 ) ).bitAnd( uint( 0x33333333 ) ) ) );
 
-				if ( typeLength === 1 ) {
+					return v.add( v.shiftRight( uint( 4 ) ) ).bitAnd( uint( 0xF0F0F0F ) ).mul( uint( 0x1010101 ) ).shiftRight( uint( 24 ) );
 
-					v.addAssign( bitCountBase( value ) );
+				} ).setLayout( {
+					name: bitcountBaseMethod,
+					type: 'uint',
+					inputs: [
+						{ name: 'value', type: elementType }
+					]
+				} );
 
-				} else {
 
-					const components = [ 'x', 'y', 'z', 'w' ];
+				registeredBitcountFunctions[ bitcountBaseMethod ] = bitCountBaseFn;
 
-					for ( let i = 0; i < typeLength; i ++ ) {
+			}
 
-						const component = components[ i ];
+			const bitCountMethod = `bitcount_${inputType}`;
 
-						v.addAssign( bitCountBase( value[ component ] ) );
+			let bitCountFn = registeredBitcountFunctions[ bitCountMethod ];
 
-					}
+			if ( bitCountFn === undefined ) {
 
-				}
+				bitCountFn = Fn( ( [ value ] ) => {
 
-				return v;
+					const v = uint( 0.0 );
 
-			} ).setLayout( {
-				name: `bitcount_main_${this.nodeType}`,
-				type: 'uint',
-				inputs: [
-					{ name: 'value', type: inputType }
-				]
-			} );
+					if ( typeLength === 1 ) {
 
-			console.log( 'test' );
+						v.addAssign( bitCountBaseFn( value ) );
 
-			const exec = bitCountFn( aNode ).toVar( 'testVar' );
+					} else {
 
-			return exec;
+						const components = [ 'x', 'y', 'z', 'w' ];
 
-		}
+						for ( let i = 0; i < typeLength; i ++ ) {
 
-	}
+							const component = components[ i ];
 
-	generate( builder ) {
+							v.addAssign( bitCountBaseFn( value[ component ] ) );
 
-		this.method += 'test';
+						}
 
-		super.generate( builder );
+					}
 
+					return v;
 
+				} ).setLayout( {
+					name: bitCountMethod,
+					type: 'uint',
+					inputs: [
+						{ name: 'value', type: inputType }
+					]
+				} );
+
+				registeredBitcountFunctions[ bitCountMethod ] = bitCountFn;
+
+
+			}
+
+			const methodFn = Fn( () => {
+
+				return bitCountFn(
+					aNode,
+				);
+
+			} );
+
+			return methodFn();
+
+		}
 
 	}
 
diff --git a/src/nodes/math/MathNode.js b/src/nodes/math/MathNode.js
index 4736d84f44bd85..8f1f28bac8ad20 100644
--- a/src/nodes/math/MathNode.js
+++ b/src/nodes/math/MathNode.js
@@ -217,8 +217,6 @@ class MathNode extends TempNode {
 
 	generate( builder, output ) {
 
-		console.log( this.method );
-
 		const properties = builder.getNodeProperties( this );
 
 		if ( properties.outputNode ) {

From da5bfa5cca03c806577b4a4b011c83c0b53579cc Mon Sep 17 00:00:00 2001
From: Christian Helgeson <62450112+cmhhelgeson@users.noreply.github.com>
Date: Sun, 5 Oct 2025 20:19:30 -0700
Subject: [PATCH 05/17] bitcountNode

---
 src/nodes/math/BitcountNode.js | 371 +++++++++++++++++++++++++++------
 1 file changed, 303 insertions(+), 68 deletions(-)

diff --git a/src/nodes/math/BitcountNode.js b/src/nodes/math/BitcountNode.js
index ede8be97b779b9..51594d66c8d1b5 100644
--- a/src/nodes/math/BitcountNode.js
+++ b/src/nodes/math/BitcountNode.js
@@ -1,6 +1,6 @@
-import { addMethodChaining, Fn, nodeProxyIntent, uint } from '../tsl/TSLCore.js';
-import { bitcast } from './BitcastNode.js';
-import MathNode from './MathNode.js';
+import { addMethodChaining, float, Fn, If, int, nodeProxyIntent, uint } from '../tsl/TSLCore.js';
+import { bitcast, floatBitsToUint } from './BitcastNode.js';
+import MathNode, { negate } from './MathNode.js';
 
 const registeredBitcountFunctions = {};
 
@@ -21,7 +21,7 @@ class BitcountNode extends MathNode {
 	/**
 	 * Constructs a new math node.
 	 *
-	 * @param {string} method - The method name.
+	 * @param {'countTrailingZeros'|'countLeadingZeros'|'countOneBits'} method - The method name.
 	 * @param {Node} aNode - The first input.
 	 */
 	constructor( method, aNode ) {
@@ -46,132 +46,367 @@ class BitcountNode extends MathNode {
 	}
 
 	/**
-	 * Constructs a new math node.
+	 * Casts the input value of the function to an integer if necessary.
 	 *
-	 * @param {NodeBuilder} builder - The method name.
-	 * @return {?Node} The output node.
+	 * @param {Node<uint>|Node<int>} inputNode - The input value.
+	 * @param {Node<uint>} outputNode - The output value.
+	 * @param {string} elementType - The type of the input value.
 	 */
-	setup( builder ) {
+	_resolveElementType( inputNode, outputNode, elementType ) {
 
-		const { method, aNode } = this;
+		if ( elementType === 'int' ) {
 
-		const { renderer } = builder;
+			outputNode.assign( bitcast( inputNode, 'uint' ) );
 
-		if ( renderer.backend.isWebGPUBackend ) {
+		} else {
 
-			return super.setup( builder );
+			outputNode.assign( inputNode );
 
 		}
 
-		const inputType = this.getInputType( builder );
-		const elementType = builder.getElementType( inputType );
+	}
 
-		const typeLength = builder.getTypeLength( inputType );
+	_constructTrailingZerosBaseLayout( method, elementType ) {
+
+		const fnDef = Fn( ( [ value ] ) => {
+
+			const v = uint( 0.0 );
+
+			this._resolveElementType( value, v, elementType );
+
+			const f = float( v.bitAnd( negate( v ) ) );
+			const uintBits = floatBitsToUint( f );
+
+			return ( uintBits.shiftRight( 23 ) ).sub( 127 );
+
+		} ).setLayout( {
+			name: method,
+			type: 'uint',
+			inputs: [
+				{ name: 'value', type: elementType }
+			]
+		} );
+
+		return fnDef;
+
+	}
+
+	_constructTrailingZerosMainLayout( method, inputType, typeLength, baseFn ) {
+
+		const fnDef = Fn( ( [ value ] ) => {
+
+			const v = uint( 0.0 );
+
+			if ( typeLength === 1 ) {
+
+				v.addAssign( baseFn( value ) );
+
+			} else {
+
+				const components = [ 'x', 'y', 'z', 'w' ];
+				for ( let i = 0; i < typeLength; i ++ ) {
+
+					const component = components[ i ];
+
+					v.addAssign( baseFn( value[ component ] ) );
+
+					// Continue loop only if it's not the maximumn number
+					If( v.equal( 32 * i ), () => {
+
+						return v;
+
+					} );
+
+				}
 
-		if ( method === BitcountNode.COUNT_LEADING_ZEROS ) {
+			}
+
+			return v;
+
+		} ).setLayout( {
+			name: method,
+			type: 'uint',
+			inputs: [
+				{ name: 'value', type: inputType }
+			]
+		} );
+
+		return fnDef;
+
+	}
+
+	_constructLeadingZerosBaseLayout( method, elementType ) {
+
+		const fnDef = Fn( ( [ value ] ) => {
+
+			If( value.equal( uint( 0 ) ), () => {
+
+				return uint( 32 );
+
+			} );
+
+			const v = uint( 0 );
+			const n = uint( 0 );
+			this._resolveElementType( value, v, elementType );
+
+			If( v.shiftRight( 16 ).equal( 0 ), () => {
+
+				n.addAssign( 16 );
+				v.shiftLeftAssign( 16 );
+
+			} );
 
+			If( v.shiftRight( 24 ).equal( 0 ), () => {
 
+				n.addAssign( 8 );
+				v.shiftLeftAssign( 8 );
 
+			} );
 
-		} else if ( method === BitcountNode.COUNT_TRAILING_ZEROS ) {
+			If( v.shiftRight( 28 ).equal( 0 ), () => {
 
+				n.addAssign( 4 );
+				v.shiftLeftAssign( 4 );
 
+			} );
 
-		} else if ( method === BitcountNode.COUNT_ONE_BITS ) {
+			If( v.shiftRight( 30 ).equal( 0 ), () => {
 
-			const bitcountBaseMethod = `bitcount_base_${elementType}`;
+				n.addAssign( 2 );
+				v.shiftLeftAssign( 2 );
 
-			let bitCountBaseFn = registeredBitcountFunctions[ bitcountBaseMethod ];
+			} );
 
-			if ( bitCountBaseFn === undefined ) {
+			If( v.shiftRight( 31 ).equal( 0 ), () => {
 
-				bitCountBaseFn = Fn( ( [ value ] ) => {
+				n.addAssign( 1 );
+
+			} );
 
-					const v = uint( 0.0 );
+			return n;
+
+		} ).setLayout( {
+			name: method,
+			type: 'uint',
+			inputs: [
+				{ name: 'value', type: elementType }
+			]
+		} );
+
+		return fnDef;
+
+	}
 
-					if ( elementType === 'int' ) {
+	_constructLeadingZerosMainLayout( method, inputType, typeLength, baseFn ) {
 
-						v.assign( bitcast( value, 'uint' ) );
+		const fnDef = Fn( ( [ value ] ) => {
 
-					} else {
+			const v = uint( 0.0 );
 
-						v.assign( value );
+			if ( typeLength === 1 ) {
 
-					}
+				v.addAssign( baseFn( value ) );
 
-					v.assign( v.sub( v.shiftRight( uint( 1 ) ).bitAnd( uint( 0x55555555 ) ) ) );
-					v.assign( v.bitAnd( uint( 0x33333333 ) ).add( v.shiftRight( uint( 2 ) ).bitAnd( uint( 0x33333333 ) ) ) );
+			} else {
 
-					return v.add( v.shiftRight( uint( 4 ) ) ).bitAnd( uint( 0xF0F0F0F ) ).mul( uint( 0x1010101 ) ).shiftRight( uint( 24 ) );
+				const components = [ 'w', 'z', 'y', 'x' ];
+				for ( let i = 0; i < typeLength; i ++ ) {
 
-				} ).setLayout( {
-					name: bitcountBaseMethod,
-					type: 'uint',
-					inputs: [
-						{ name: 'value', type: elementType }
-					]
-				} );
+					const component = components[ i ];
 
+					v.addAssign( baseFn( value[ component ] ) );
 
-				registeredBitcountFunctions[ bitcountBaseMethod ] = bitCountBaseFn;
+					If( v.notEqual( 32 * i ), () => {
+
+						return v;
+
+					} );
+
+				}
 
 			}
 
-			const bitCountMethod = `bitcount_${inputType}`;
+			return v;
+
+		} ).setLayout( {
+			name: method,
+			type: 'uint',
+			inputs: [
+				{ name: 'value', type: inputType }
+			]
+		} );
 
-			let bitCountFn = registeredBitcountFunctions[ bitCountMethod ];
+		return fnDef;
 
-			if ( bitCountFn === undefined ) {
 
-				bitCountFn = Fn( ( [ value ] ) => {
+	}
+
+	_constructOneBitsBaseLayout( method, elementType ) {
 
-					const v = uint( 0.0 );
+		const fnDef = Fn( ( [ value ] ) => {
 
-					if ( typeLength === 1 ) {
+			const v = uint( 0.0 );
 
-						v.addAssign( bitCountBaseFn( value ) );
+			this._resolveElementType( value, v, elementType );
 
-					} else {
+			v.assign( v.sub( v.shiftRight( uint( 1 ) ).bitAnd( uint( 0x55555555 ) ) ) );
+			v.assign( v.bitAnd( uint( 0x33333333 ) ).add( v.shiftRight( uint( 2 ) ).bitAnd( uint( 0x33333333 ) ) ) );
 
-						const components = [ 'x', 'y', 'z', 'w' ];
+			return v.add( v.shiftRight( uint( 4 ) ) ).bitAnd( uint( 0xF0F0F0F ) ).mul( uint( 0x1010101 ) ).shiftRight( uint( 24 ) );
 
-						for ( let i = 0; i < typeLength; i ++ ) {
+		} ).setLayout( {
+			name: method,
+			type: 'uint',
+			inputs: [
+				{ name: 'value', type: elementType }
+			]
+		} );
 
-							const component = components[ i ];
+		return fnDef;
+
+	}
 
-							v.addAssign( bitCountBaseFn( value[ component ] ) );
+	_constructOneBitsMainLayout( method, inputType, typeLength, baseFn ) {
 
-						}
+		const fnDef = Fn( ( [ value ] ) => {
 
-					}
+			const v = uint( 0.0 );
 
-					return v;
+			if ( typeLength === 1 ) {
 
-				} ).setLayout( {
-					name: bitCountMethod,
-					type: 'uint',
-					inputs: [
-						{ name: 'value', type: inputType }
-					]
-				} );
+				v.addAssign( baseFn( value ) );
 
-				registeredBitcountFunctions[ bitCountMethod ] = bitCountFn;
+			} else {
 
+				const components = [ 'x', 'y', 'z', 'w' ];
+
+				for ( let i = 0; i < typeLength; i ++ ) {
+
+					const component = components[ i ];
+
+					v.addAssign( baseFn( value[ component ] ) );
+
+				}
 
 			}
 
-			const methodFn = Fn( () => {
+			return v;
 
-				return bitCountFn(
-					aNode,
-				);
+		} ).setLayout( {
+			name: method,
+			type: 'uint',
+			inputs: [
+				{ name: 'value', type: inputType }
+			]
+		} );
 
-			} );
+		return fnDef;
+
+
+	}
+
+	/**
+	 * Constructs a new math node.
+	 *
+	 * @param {NodeBuilder} builder - The method name.
+	 * @return {?Node} The output node.
+	 */
+	setup( builder ) {
+
+		const { method, aNode } = this;
 
-			return methodFn();
+		const { renderer } = builder;
+
+		if ( renderer.backend.isWebGPUBackend ) {
+
+			return super.setup( builder );
 
 		}
 
+		const inputType = this.getInputType( builder );
+		const elementType = builder.getElementType( inputType );
+
+		const typeLength = builder.getTypeLength( inputType );
+
+		const baseMethod = `${method}_base_${elementType}`;
+		const newMethod = `${method}_${inputType}`;
+
+		let baseFn = registeredBitcountFunctions[ baseMethod ];
+
+		if ( baseFn === undefined ) {
+
+			switch ( method ) {
+
+				case BitcountNode.COUNT_LEADING_ZEROS: {
+
+					baseFn = this._constructLeadingZerosBaseLayout( baseMethod, elementType );
+					break;
+
+				}
+
+				case BitcountNode.COUNT_TRAILING_ZEROS: {
+
+					baseFn = this._constructTrailingZerosBaseLayout( baseMethod, elementType );
+					break;
+
+				}
+
+				case BitcountNode.COUNT_ONE_BITS: {
+
+					baseFn = this._constructOneBitsBaseLayout( baseMethod, elementType );
+					break;
+
+				}
+
+			}
+
+			registeredBitcountFunctions[ baseMethod ] = baseFn;
+
+		}
+
+		let fn = registeredBitcountFunctions[ newMethod ];
+
+		if ( fn === undefined ) {
+
+			switch ( method ) {
+
+				case BitcountNode.COUNT_LEADING_ZEROS: {
+
+					fn = this._constructLeadingZerosMainLayout( newMethod, inputType, typeLength, baseFn );
+					break;
+
+				}
+
+				case BitcountNode.COUNT_TRAILING_ZEROS: {
+
+					fn = this._constructTrailingZerosMainLayout( newMethod, inputType, typeLength, baseFn );
+					break;
+
+				}
+
+				case BitcountNode.COUNT_ONE_BITS: {
+
+					fn = this._constructOneBitsMainLayout( newMethod, inputType, typeLength, baseFn );
+					break;
+
+				}
+
+			}
+
+			registeredBitcountFunctions[ newMethod ] = fn;
+
+		}
+
+		const output = Fn( () => {
+
+			return fn(
+				aNode,
+			);
+
+		} );
+
+		return output();
+
 	}
 
 }

From ec3541d249fbdc553a20789711fdc3b3674796c4 Mon Sep 17 00:00:00 2001
From: Christian Helgeson <62450112+cmhhelgeson@users.noreply.github.com>
Date: Sun, 5 Oct 2025 20:22:57 -0700
Subject: [PATCH 06/17] revert glslNodeBuilder changes

---
 src/renderers/webgl-fallback/nodes/GLSLNodeBuilder.js | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/renderers/webgl-fallback/nodes/GLSLNodeBuilder.js b/src/renderers/webgl-fallback/nodes/GLSLNodeBuilder.js
index d3f26bedd5dd2b..6aaa4052d5e453 100644
--- a/src/renderers/webgl-fallback/nodes/GLSLNodeBuilder.js
+++ b/src/renderers/webgl-fallback/nodes/GLSLNodeBuilder.js
@@ -10,8 +10,8 @@ import { DataTexture } from '../../../textures/DataTexture.js';
 import { error } from '../../../utils.js';
 
 const glslPolyfills = {
-	bitcast_int_uint: new CodeNode( /* glsl */'uint tsl_bitcast_int_to_uint ( int x ) { return floatBitsToUint( intBitsToFloat ( x ) ); }' ),
-	bitcast_uint_int: new CodeNode( /* glsl */'int tsl_bitcast_uint_to_int ( uint x ) { return floatBitsToInt( uintBitsToFloat( x ) ); }' )
+	bitcast_int_uint: new CodeNode( /* glsl */'uint tsl_bitcast_uint_to_int ( int x ) { return floatBitsToInt( uintBitsToFloat( x ) ); }' ),
+	bitcast_uint_int: new CodeNode( /* glsl */'uint tsl_bitcast_int_to_uint ( int x ) { return floatBitsToUint( intBitsToFloat ( x ) ); }' )
 };
 
 const glslMethods = {

From 71e0936fa8608dc3ef2671a8784dd19e8e08f506 Mon Sep 17 00:00:00 2001
From: Christian Helgeson <62450112+cmhhelgeson@users.noreply.github.com>
Date: Sun, 5 Oct 2025 20:33:10 -0700
Subject: [PATCH 07/17] lint-fix

---
 src/nodes/math/BitcountNode.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/nodes/math/BitcountNode.js b/src/nodes/math/BitcountNode.js
index 51594d66c8d1b5..b7d775abfa4489 100644
--- a/src/nodes/math/BitcountNode.js
+++ b/src/nodes/math/BitcountNode.js
@@ -1,4 +1,4 @@
-import { addMethodChaining, float, Fn, If, int, nodeProxyIntent, uint } from '../tsl/TSLCore.js';
+import { addMethodChaining, float, Fn, If, nodeProxyIntent, uint } from '../tsl/TSLCore.js';
 import { bitcast, floatBitsToUint } from './BitcastNode.js';
 import MathNode, { negate } from './MathNode.js';
 

From 3d9b6a0ca9ae2cc6c2b95700df3fa16e089fdbfc Mon Sep 17 00:00:00 2001
From: Christian Helgeson <62450112+cmhhelgeson@users.noreply.github.com>
Date: Mon, 6 Oct 2025 12:49:49 -0700
Subject: [PATCH 08/17] revert unintended changes to glslNodeBuilder and
 MathNode, change bitCount helper function names

---
 src/nodes/math/BitcountNode.js                | 24 +++++++++----------
 src/nodes/math/MathNode.js                    |  4 +++-
 .../webgl-fallback/nodes/GLSLNodeBuilder.js   |  4 ++--
 3 files changed, 17 insertions(+), 15 deletions(-)

diff --git a/src/nodes/math/BitcountNode.js b/src/nodes/math/BitcountNode.js
index b7d775abfa4489..af51fbf3b36fba 100644
--- a/src/nodes/math/BitcountNode.js
+++ b/src/nodes/math/BitcountNode.js
@@ -66,7 +66,7 @@ class BitcountNode extends MathNode {
 
 	}
 
-	_constructTrailingZerosBaseLayout( method, elementType ) {
+	_createTrailingZerosBaseLayout( method, elementType ) {
 
 		const fnDef = Fn( ( [ value ] ) => {
 
@@ -91,7 +91,7 @@ class BitcountNode extends MathNode {
 
 	}
 
-	_constructTrailingZerosMainLayout( method, inputType, typeLength, baseFn ) {
+	_createTrailingZerosMainLayout( method, inputType, typeLength, baseFn ) {
 
 		const fnDef = Fn( ( [ value ] ) => {
 
@@ -135,7 +135,7 @@ class BitcountNode extends MathNode {
 
 	}
 
-	_constructLeadingZerosBaseLayout( method, elementType ) {
+	_createLeadingZerosBaseLayout( method, elementType ) {
 
 		const fnDef = Fn( ( [ value ] ) => {
 
@@ -197,7 +197,7 @@ class BitcountNode extends MathNode {
 
 	}
 
-	_constructLeadingZerosMainLayout( method, inputType, typeLength, baseFn ) {
+	_createLeadingZerosMainLayout( method, inputType, typeLength, baseFn ) {
 
 		const fnDef = Fn( ( [ value ] ) => {
 
@@ -241,7 +241,7 @@ class BitcountNode extends MathNode {
 
 	}
 
-	_constructOneBitsBaseLayout( method, elementType ) {
+	_createOneBitsBaseLayout( method, elementType ) {
 
 		const fnDef = Fn( ( [ value ] ) => {
 
@@ -266,7 +266,7 @@ class BitcountNode extends MathNode {
 
 	}
 
-	_constructOneBitsMainLayout( method, inputType, typeLength, baseFn ) {
+	_createOneBitsMainLayout( method, inputType, typeLength, baseFn ) {
 
 		const fnDef = Fn( ( [ value ] ) => {
 
@@ -339,21 +339,21 @@ class BitcountNode extends MathNode {
 
 				case BitcountNode.COUNT_LEADING_ZEROS: {
 
-					baseFn = this._constructLeadingZerosBaseLayout( baseMethod, elementType );
+					baseFn = this._createLeadingZerosBaseLayout( baseMethod, elementType );
 					break;
 
 				}
 
 				case BitcountNode.COUNT_TRAILING_ZEROS: {
 
-					baseFn = this._constructTrailingZerosBaseLayout( baseMethod, elementType );
+					baseFn = this._createTrailingZerosBaseLayout( baseMethod, elementType );
 					break;
 
 				}
 
 				case BitcountNode.COUNT_ONE_BITS: {
 
-					baseFn = this._constructOneBitsBaseLayout( baseMethod, elementType );
+					baseFn = this._createOneBitsBaseLayout( baseMethod, elementType );
 					break;
 
 				}
@@ -372,21 +372,21 @@ class BitcountNode extends MathNode {
 
 				case BitcountNode.COUNT_LEADING_ZEROS: {
 
-					fn = this._constructLeadingZerosMainLayout( newMethod, inputType, typeLength, baseFn );
+					fn = this._createLeadingZerosMainLayout( newMethod, inputType, typeLength, baseFn );
 					break;
 
 				}
 
 				case BitcountNode.COUNT_TRAILING_ZEROS: {
 
-					fn = this._constructTrailingZerosMainLayout( newMethod, inputType, typeLength, baseFn );
+					fn = this._createTrailingZerosMainLayout( newMethod, inputType, typeLength, baseFn );
 					break;
 
 				}
 
 				case BitcountNode.COUNT_ONE_BITS: {
 
-					fn = this._constructOneBitsMainLayout( newMethod, inputType, typeLength, baseFn );
+					fn = this._createOneBitsMainLayout( newMethod, inputType, typeLength, baseFn );
 					break;
 
 				}
diff --git a/src/nodes/math/MathNode.js b/src/nodes/math/MathNode.js
index 8f1f28bac8ad20..8271477e82f6ec 100644
--- a/src/nodes/math/MathNode.js
+++ b/src/nodes/math/MathNode.js
@@ -1099,8 +1099,10 @@ export const atan2 = ( y, x ) => { // @deprecated, r172
 
 };
 
+// GLSL alias function
 
-
+export const faceforward = faceForward;
+export const inversesqrt = inverseSqrt;
 
 // Method chaining
 
diff --git a/src/renderers/webgl-fallback/nodes/GLSLNodeBuilder.js b/src/renderers/webgl-fallback/nodes/GLSLNodeBuilder.js
index 6aaa4052d5e453..627603807a0170 100644
--- a/src/renderers/webgl-fallback/nodes/GLSLNodeBuilder.js
+++ b/src/renderers/webgl-fallback/nodes/GLSLNodeBuilder.js
@@ -10,8 +10,8 @@ import { DataTexture } from '../../../textures/DataTexture.js';
 import { error } from '../../../utils.js';
 
 const glslPolyfills = {
-	bitcast_int_uint: new CodeNode( /* glsl */'uint tsl_bitcast_uint_to_int ( int x ) { return floatBitsToInt( uintBitsToFloat( x ) ); }' ),
-	bitcast_uint_int: new CodeNode( /* glsl */'uint tsl_bitcast_int_to_uint ( int x ) { return floatBitsToUint( intBitsToFloat ( x ) ); }' )
+	bitcast_int_uint: new CodeNode( /* glsl */'uint tsl_bitcast_int_to_uint ( int x ) { return floatBitsToUint( intBitsToFloat ( x ) ); }' ),
+	bitcast_uint_int: new CodeNode( /* glsl */'uint tsl_bitcast_uint_to_int ( uint x ) { return floatBitsToInt( uintBitsToFloat ( x ) ); }' )
 };
 
 const glslMethods = {

From d67c34a639fa895c18a4b76fc629d422de671f82 Mon Sep 17 00:00:00 2001
From: Christian Helgeson <62450112+cmhhelgeson@users.noreply.github.com>
Date: Mon, 6 Oct 2025 13:02:26 -0700
Subject: [PATCH 09/17] remove extra _include

---
 .../webgl-fallback/nodes/GLSLNodeBuilder.js   | 19 -------------------
 1 file changed, 19 deletions(-)

diff --git a/src/renderers/webgl-fallback/nodes/GLSLNodeBuilder.js b/src/renderers/webgl-fallback/nodes/GLSLNodeBuilder.js
index 627603807a0170..33462c8fea4b39 100644
--- a/src/renderers/webgl-fallback/nodes/GLSLNodeBuilder.js
+++ b/src/renderers/webgl-fallback/nodes/GLSLNodeBuilder.js
@@ -153,25 +153,6 @@ class GLSLNodeBuilder extends NodeBuilder {
 
 	}
 
-	/**
-	 * Includes the given method name into the current
-	 * function node.
-	 *
-	 * @private
-	 * @param {string} name - The method name to include.
-	 * @return {CodeNode} The respective code node.
-	 */
-	_include( name ) {
-
-		const codeNode = glslPolyfills[ name ];
-		codeNode.build( this );
-
-		this.addInclude( codeNode );
-
-		return codeNode;
-
-	}
-
 	/**
 	 * Returns the native shader method name for a given generic name.
 	 *

From 57f859369d348c9ffef67d933a640fcf052c27af Mon Sep 17 00:00:00 2001
From: Christian Helgeson <62450112+cmhhelgeson@users.noreply.github.com>
Date: Mon, 6 Oct 2025 13:37:35 -0700
Subject: [PATCH 10/17] change mainLayout function to accurately reflect WGSL
 documentation (component wise bitCounts rather than accumulative bitCounts

---
 src/nodes/math/BitcountNode.js | 216 +++++++++++++++------------------
 1 file changed, 95 insertions(+), 121 deletions(-)

diff --git a/src/nodes/math/BitcountNode.js b/src/nodes/math/BitcountNode.js
index af51fbf3b36fba..1e2f8f5a8b1570 100644
--- a/src/nodes/math/BitcountNode.js
+++ b/src/nodes/math/BitcountNode.js
@@ -1,14 +1,13 @@
-import { addMethodChaining, float, Fn, If, nodeProxyIntent, uint } from '../tsl/TSLCore.js';
+import { addMethodChaining, float, Fn, If, nodeProxyIntent, uint, int, uvec2, uvec3, uvec4, ivec2, ivec3, ivec4 } from '../tsl/TSLCore.js';
 import { bitcast, floatBitsToUint } from './BitcastNode.js';
 import MathNode, { negate } from './MathNode.js';
 
 const registeredBitcountFunctions = {};
 
 /**
- * This node represents an operation that reinterprets the bit representation of a value
- * in one type as a value in another type.
+ * This node represents an operation that counts the bits of a piece of shader data.
  *
- * @augments TempNode
+ * @augments MathNode
  */
 class BitcountNode extends MathNode {
 
@@ -66,68 +65,103 @@ class BitcountNode extends MathNode {
 
 	}
 
-	_createTrailingZerosBaseLayout( method, elementType ) {
+	_returnBaseDataNode( elementType ) {
 
-		const fnDef = Fn( ( [ value ] ) => {
+		if ( elementType === 'uint' ) {
 
-			const v = uint( 0.0 );
+			return uint;
 
-			this._resolveElementType( value, v, elementType );
+		}
 
-			const f = float( v.bitAnd( negate( v ) ) );
-			const uintBits = floatBitsToUint( f );
+		if ( elementType === 'int' ) {
 
-			return ( uintBits.shiftRight( 23 ) ).sub( 127 );
+			return int;
 
-		} ).setLayout( {
-			name: method,
-			type: 'uint',
-			inputs: [
-				{ name: 'value', type: elementType }
-			]
-		} );
-
-		return fnDef;
+		}
 
 	}
 
-	_createTrailingZerosMainLayout( method, inputType, typeLength, baseFn ) {
+	_returnDataNode( inputType ) {
 
-		const fnDef = Fn( ( [ value ] ) => {
+		switch ( inputType ) {
 
-			const v = uint( 0.0 );
+			case 'uint': {
 
-			if ( typeLength === 1 ) {
+				return uint;
 
-				v.addAssign( baseFn( value ) );
+			}
 
-			} else {
+			case 'int': {
 
-				const components = [ 'x', 'y', 'z', 'w' ];
-				for ( let i = 0; i < typeLength; i ++ ) {
+				return int;
 
-					const component = components[ i ];
+			}
 
-					v.addAssign( baseFn( value[ component ] ) );
+			case 'uvec2': {
 
-					// Continue loop only if it's not the maximumn number
-					If( v.equal( 32 * i ), () => {
+				return uvec2;
 
-						return v;
+			}
 
-					} );
+			case 'uvec3': {
 
-				}
+				return uvec3;
+
+			}
+
+			case 'uvec4': {
+
+				return uvec4;
+
+			}
+
+			case 'ivec2': {
+
+				return ivec2;
 
 			}
 
-			return v;
+			case 'ivec3': {
+
+				return ivec3;
+
+			}
+
+			case 'ivec4': {
+
+				return ivec4;
+
+			}
+
+
+		}
+
+
+
+	}
+
+	_createTrailingZerosBaseLayout( method, elementType ) {
+
+		const outputConvertNode = this._returnDataNode( elementType );
+
+		const fnDef = Fn( ( [ value ] ) => {
+
+			const v = uint( 0.0 );
+
+			this._resolveElementType( value, v, elementType );
+
+			const f = float( v.bitAnd( negate( v ) ) );
+			const uintBits = floatBitsToUint( f );
+
+			const numTrailingZeros = ( uintBits.shiftRight( 23 ) ).sub( 127 );
+
+			return outputConvertNode( numTrailingZeros );
 
 		} ).setLayout( {
 			name: method,
-			type: 'uint',
+			type: elementType,
 			inputs: [
-				{ name: 'value', type: inputType }
+				{ name: 'value', type: elementType }
 			]
 		} );
 
@@ -137,6 +171,8 @@ class BitcountNode extends MathNode {
 
 	_createLeadingZerosBaseLayout( method, elementType ) {
 
+		const outputConvertNode = this._returnDataNode( elementType );
+
 		const fnDef = Fn( ( [ value ] ) => {
 
 			If( value.equal( uint( 0 ) ), () => {
@@ -183,11 +219,11 @@ class BitcountNode extends MathNode {
 
 			} );
 
-			return n;
+			return outputConvertNode( n );
 
 		} ).setLayout( {
 			name: method,
-			type: 'uint',
+			type: elementType,
 			inputs: [
 				{ name: 'value', type: elementType }
 			]
@@ -197,54 +233,13 @@ class BitcountNode extends MathNode {
 
 	}
 
-	_createLeadingZerosMainLayout( method, inputType, typeLength, baseFn ) {
-
-		const fnDef = Fn( ( [ value ] ) => {
-
-			const v = uint( 0.0 );
-
-			if ( typeLength === 1 ) {
-
-				v.addAssign( baseFn( value ) );
-
-			} else {
-
-				const components = [ 'w', 'z', 'y', 'x' ];
-				for ( let i = 0; i < typeLength; i ++ ) {
-
-					const component = components[ i ];
-
-					v.addAssign( baseFn( value[ component ] ) );
-
-					If( v.notEqual( 32 * i ), () => {
-
-						return v;
-
-					} );
-
-				}
-
-			}
-
-			return v;
-
-		} ).setLayout( {
-			name: method,
-			type: 'uint',
-			inputs: [
-				{ name: 'value', type: inputType }
-			]
-		} );
-
-		return fnDef;
-
-
-	}
-
 	_createOneBitsBaseLayout( method, elementType ) {
 
+		const outputConvertNode = this._returnDataNode( elementType );
+
 		const fnDef = Fn( ( [ value ] ) => {
 
+
 			const v = uint( 0.0 );
 
 			this._resolveElementType( value, v, elementType );
@@ -252,11 +247,13 @@ class BitcountNode extends MathNode {
 			v.assign( v.sub( v.shiftRight( uint( 1 ) ).bitAnd( uint( 0x55555555 ) ) ) );
 			v.assign( v.bitAnd( uint( 0x33333333 ) ).add( v.shiftRight( uint( 2 ) ).bitAnd( uint( 0x33333333 ) ) ) );
 
-			return v.add( v.shiftRight( uint( 4 ) ) ).bitAnd( uint( 0xF0F0F0F ) ).mul( uint( 0x1010101 ) ).shiftRight( uint( 24 ) );
+			const numBits = v.add( v.shiftRight( uint( 4 ) ) ).bitAnd( uint( 0xF0F0F0F ) ).mul( uint( 0x1010101 ) ).shiftRight( uint( 24 ) );
+
+			return outputConvertNode( numBits );
 
 		} ).setLayout( {
 			name: method,
-			type: 'uint',
+			type: elementType,
 			inputs: [
 				{ name: 'value', type: elementType }
 			]
@@ -266,35 +263,36 @@ class BitcountNode extends MathNode {
 
 	}
 
-	_createOneBitsMainLayout( method, inputType, typeLength, baseFn ) {
+	_createMainLayout( method, inputType, typeLength, baseFn ) {
 
-		const fnDef = Fn( ( [ value ] ) => {
+		const outputConvertNode = this._returnDataNode( inputType );
 
-			const v = uint( 0.0 );
+		const fnDef = Fn( ( [ value ] ) => {
 
 			if ( typeLength === 1 ) {
 
-				v.addAssign( baseFn( value ) );
+				return outputConvertNode( baseFn( value ) );
 
 			} else {
 
-				const components = [ 'x', 'y', 'z', 'w' ];
+				const vec = outputConvertNode( 0 );
 
+				const components = [ 'x', 'y', 'z', 'w' ];
 				for ( let i = 0; i < typeLength; i ++ ) {
 
 					const component = components[ i ];
 
-					v.addAssign( baseFn( value[ component ] ) );
+					vec[ component ].assign( baseFn( value[ component ] ) );
 
 				}
 
-			}
+				return vec;
 
-			return v;
+			}
 
 		} ).setLayout( {
 			name: method,
-			type: 'uint',
+			type: inputType,
 			inputs: [
 				{ name: 'value', type: inputType }
 			]
@@ -302,9 +300,9 @@ class BitcountNode extends MathNode {
 
 		return fnDef;
 
-
 	}
 
+
 	/**
 	 * Constructs a new math node.
 	 *
@@ -368,31 +366,7 @@ class BitcountNode extends MathNode {
 
 		if ( fn === undefined ) {
 
-			switch ( method ) {
-
-				case BitcountNode.COUNT_LEADING_ZEROS: {
-
-					fn = this._createLeadingZerosMainLayout( newMethod, inputType, typeLength, baseFn );
-					break;
-
-				}
-
-				case BitcountNode.COUNT_TRAILING_ZEROS: {
-
-					fn = this._createTrailingZerosMainLayout( newMethod, inputType, typeLength, baseFn );
-					break;
-
-				}
-
-				case BitcountNode.COUNT_ONE_BITS: {
-
-					fn = this._createOneBitsMainLayout( newMethod, inputType, typeLength, baseFn );
-					break;
-
-				}
-
-			}
-
+			fn = this._createMainLayout( newMethod, inputType, typeLength, baseFn );
 			registeredBitcountFunctions[ newMethod ] = fn;
 
 		}

From 2769f80ab951dadaa765d60160713113da167ceb Mon Sep 17 00:00:00 2001
From: Christian Helgeson <62450112+cmhhelgeson@users.noreply.github.com>
Date: Mon, 6 Oct 2025 13:41:48 -0700
Subject: [PATCH 11/17] fix nodeType

---
 src/nodes/math/BitcountNode.js | 6 ------
 1 file changed, 6 deletions(-)

diff --git a/src/nodes/math/BitcountNode.js b/src/nodes/math/BitcountNode.js
index 1e2f8f5a8b1570..e9060c7c4a7347 100644
--- a/src/nodes/math/BitcountNode.js
+++ b/src/nodes/math/BitcountNode.js
@@ -38,12 +38,6 @@ class BitcountNode extends MathNode {
 
 	}
 
-	getNodeType( /*builder*/ ) {
-
-		return 'uint';
-
-	}
-
 	/**
 	 * Casts the input value of the function to an integer if necessary.
 	 *

From c00b82e9735631f4b08fcda1cad7bde1cb02e3be Mon Sep 17 00:00:00 2001
From: Christian Helgeson <62450112+cmhhelgeson@users.noreply.github.com>
Date: Sat, 1 Nov 2025 09:34:31 -0700
Subject: [PATCH 12/17] add comments for private functions and setup

---
 src/nodes/math/BitcountNode.js | 69 +++++++++++++++++++++-------------
 1 file changed, 42 insertions(+), 27 deletions(-)

diff --git a/src/nodes/math/BitcountNode.js b/src/nodes/math/BitcountNode.js
index e9060c7c4a7347..8bfde18cf25780 100644
--- a/src/nodes/math/BitcountNode.js
+++ b/src/nodes/math/BitcountNode.js
@@ -41,6 +41,7 @@ class BitcountNode extends MathNode {
 	/**
 	 * Casts the input value of the function to an integer if necessary.
 	 *
+	 * @private
 	 * @param {Node<uint>|Node<int>} inputNode - The input value.
 	 * @param {Node<uint>} outputNode - The output value.
 	 * @param {string} elementType - The type of the input value.
@@ -59,22 +60,6 @@ class BitcountNode extends MathNode {
 
 	}
 
-	_returnBaseDataNode( elementType ) {
-
-		if ( elementType === 'uint' ) {
-
-			return uint;
-
-		}
-
-		if ( elementType === 'int' ) {
-
-			return int;
-
-		}
-
-	}
-
 	_returnDataNode( inputType ) {
 
 		switch ( inputType ) {
@@ -127,13 +112,18 @@ class BitcountNode extends MathNode {
 
 			}
 
-
 		}
 
-
-
 	}
 
+	/**
+	 * Creates and registers a reusable GLSL function that emulates the behavior of countTrailingZeros.
+	 *
+	 * @private
+	 * @param {string} method - The name of the function to create.
+	 * @param {string} elementType - The type of the input value.
+	 * @returns {Function} - The generated function
+	 */
 	_createTrailingZerosBaseLayout( method, elementType ) {
 
 		const outputConvertNode = this._returnDataNode( elementType );
@@ -159,10 +149,20 @@ class BitcountNode extends MathNode {
 			]
 		} );
 
+		console.log( fnDef );
+
 		return fnDef;
 
 	}
 
+	/**
+	 * Creates and registers a reusable GLSL function that emulates the behavior of countLeadingZeros.
+	 *
+	 * @private
+	 * @param {string} method - The name of the function to create.
+	 * @param {string} elementType - The type of the input value.
+	 * @returns {Function} - The generated function
+	 */
 	_createLeadingZerosBaseLayout( method, elementType ) {
 
 		const outputConvertNode = this._returnDataNode( elementType );
@@ -227,13 +227,20 @@ class BitcountNode extends MathNode {
 
 	}
 
+	/**
+	 * Creates and registers a reusable GLSL function that emulates the behavior of countOneBits.
+	 *
+	 * @private
+	 * @param {string} method - The name of the function to create.
+	 * @param {string} elementType - The type of the input value.
+	 * @returns {Function} - The generated function
+	 */
 	_createOneBitsBaseLayout( method, elementType ) {
 
 		const outputConvertNode = this._returnDataNode( elementType );
 
 		const fnDef = Fn( ( [ value ] ) => {
 
-
 			const v = uint( 0.0 );
 
 			this._resolveElementType( value, v, elementType );
@@ -253,10 +260,23 @@ class BitcountNode extends MathNode {
 			]
 		} );
 
+		console.log( fnDef );
+
 		return fnDef;
 
 	}
 
+	/**
+	 * Creates and registers a reusable GLSL function that emulates the behavior of the specified bitcount function.
+	 * including considerations for component-wise bitcounts on vector type inputs.
+	 *
+	 * @private
+	 * @param {string} method - The name of the function to create.
+	 * @param {string} inputType - The type of the input value.
+	 * @param {number} typeLength - The vec length of the input value.
+	 * @param {Function} baseFn - The base function that operates on an individual component of the vector.
+	 * @returns {Function} - The alias function for the specified bitcount method.
+	 */
 	_createMainLayout( method, inputType, typeLength, baseFn ) {
 
 		const outputConvertNode = this._returnDataNode( inputType );
@@ -296,13 +316,6 @@ class BitcountNode extends MathNode {
 
 	}
 
-
-	/**
-	 * Constructs a new math node.
-	 *
-	 * @param {NodeBuilder} builder - The method name.
-	 * @return {?Node} The output node.
-	 */
 	setup( builder ) {
 
 		const { method, aNode } = this;
@@ -311,6 +324,8 @@ class BitcountNode extends MathNode {
 
 		if ( renderer.backend.isWebGPUBackend ) {
 
+			// use built-in WGSL functions for WebGPU
+
 			return super.setup( builder );
 
 		}

From 4a0baaefab4828934ffb9f72ce9454b2afb4b552 Mon Sep 17 00:00:00 2001
From: Christian Helgeson <62450112+cmhhelgeson@users.noreply.github.com>
Date: Sat, 1 Nov 2025 12:46:45 -0700
Subject: [PATCH 13/17] remove glsl aliases

---
 examples/jsm/tsl/display/SSGINode.js | 6 +++---
 src/Three.TSL.js                     | 3 ---
 src/nodes/math/BitcountNode.js       | 6 ------
 3 files changed, 3 insertions(+), 12 deletions(-)

diff --git a/examples/jsm/tsl/display/SSGINode.js b/examples/jsm/tsl/display/SSGINode.js
index 017dbda4e1ee6b..b0aa5c8f542320 100644
--- a/examples/jsm/tsl/display/SSGINode.js
+++ b/examples/jsm/tsl/display/SSGINode.js
@@ -1,5 +1,5 @@
 import { RenderTarget, Vector2, TempNode, QuadMesh, NodeMaterial, RendererUtils, MathUtils } from 'three/webgpu';
-import { clamp, normalize, reference, nodeObject, Fn, NodeUpdateType, uniform, vec4, passTexture, uv, logarithmicDepthToViewZ, viewZToPerspectiveDepth, getViewPosition, screenCoordinate, float, sub, fract, dot, vec2, rand, vec3, Loop, mul, PI, cos, sin, uint, cross, acos, sign, pow, luminance, If, max, abs, Break, sqrt, HALF_PI, div, ceil, shiftRight, convertToTexture, bool, getNormalFromDepth, bitCount, interleavedGradientNoise } from 'three/tsl';
+import { clamp, normalize, reference, nodeObject, Fn, NodeUpdateType, uniform, vec4, passTexture, uv, logarithmicDepthToViewZ, viewZToPerspectiveDepth, getViewPosition, screenCoordinate, float, sub, fract, dot, vec2, rand, vec3, Loop, mul, PI, cos, sin, uint, cross, acos, sign, pow, luminance, If, max, abs, Break, sqrt, HALF_PI, div, ceil, shiftRight, convertToTexture, bool, getNormalFromDepth, countOneBits, interleavedGradientNoise } from 'three/tsl';
 
 
 const _quadMesh = /*@__PURE__*/ new QuadMesh();
@@ -498,7 +498,7 @@ class SSGINode extends TempNode {
 				currentOccludedBitfield = currentOccludedBitfield.bitAnd( globalOccludedBitfield.bitNot() );
 
 				globalOccludedBitfield.assign( globalOccludedBitfield.bitOr( currentOccludedBitfield ) );
-				const numOccludedZones = bitCount( currentOccludedBitfield );
+				const numOccludedZones = countOneBits( currentOccludedBitfield );
 
 				//
 
@@ -582,7 +582,7 @@ class SSGINode extends TempNode {
 				color.addAssign( horizonSampling( bool( true ), RADIUS, viewPosition, slideDirTexelSize, initialRayStep, uvNode, viewDir, viewNormal, n ) );
 				color.addAssign( horizonSampling( bool( false ), RADIUS, viewPosition, slideDirTexelSize, initialRayStep, uvNode, viewDir, viewNormal, n ) );
 
-				ao.addAssign( float( bitCount( globalOccludedBitfield ) ).div( float( MAX_RAY ) ) );
+				ao.addAssign( float( countOneBits( globalOccludedBitfield ) ).div( float( MAX_RAY ) ) );
 
 			} );
 
diff --git a/src/Three.TSL.js b/src/Three.TSL.js
index 529be9a5798632..e31e626a38a2b9 100644
--- a/src/Three.TSL.js
+++ b/src/Three.TSL.js
@@ -80,7 +80,6 @@ export const batch = TSL.batch;
 export const bentNormalView = TSL.bentNormalView;
 export const billboarding = TSL.billboarding;
 export const bitAnd = TSL.bitAnd;
-export const bitCount = TSL.bitCount;
 export const bitNot = TSL.bitNot;
 export const bitOr = TSL.bitOr;
 export const bitXor = TSL.bitXor;
@@ -184,8 +183,6 @@ export const expression = TSL.expression;
 export const faceDirection = TSL.faceDirection;
 export const faceForward = TSL.faceForward;
 export const faceforward = TSL.faceforward;
-export const findLSB = TSL.findLSB;
-export const findMSB = TSL.findMSB;
 export const float = TSL.float;
 export const floatBitsToInt = TSL.floatBitsToInt;
 export const floatBitsToUint = TSL.floatBitsToUint;
diff --git a/src/nodes/math/BitcountNode.js b/src/nodes/math/BitcountNode.js
index 8bfde18cf25780..1b5343a004f498 100644
--- a/src/nodes/math/BitcountNode.js
+++ b/src/nodes/math/BitcountNode.js
@@ -436,12 +436,6 @@ export const countLeadingZeros = /*@__PURE__*/ nodeProxyIntent( BitcountNode, Bi
  */
 export const countOneBits = /*@__PURE__*/ nodeProxyIntent( BitcountNode, BitcountNode.COUNT_ONE_BITS ).setParameterLength( 1 );
 
-// GLSL alias function
-
-export const findLSB = countTrailingZeros;
-export const findMSB = countLeadingZeros;
-export const bitCount = countOneBits;
-
 addMethodChaining( 'countTrailingZeros', countTrailingZeros );
 addMethodChaining( 'countLeadingZeros', countLeadingZeros );
 addMethodChaining( 'countOneBits', countOneBits );

From 3f9a2fc54aacd909959c7211514ccfae91d73153 Mon Sep 17 00:00:00 2001
From: Christian Helgeson <62450112+cmhhelgeson@users.noreply.github.com>
Date: Sat, 1 Nov 2025 12:56:24 -0700
Subject: [PATCH 14/17] remove logs

---
 src/nodes/math/BitcountNode.js | 4 ----
 1 file changed, 4 deletions(-)

diff --git a/src/nodes/math/BitcountNode.js b/src/nodes/math/BitcountNode.js
index 1b5343a004f498..42ac177140fe69 100644
--- a/src/nodes/math/BitcountNode.js
+++ b/src/nodes/math/BitcountNode.js
@@ -149,8 +149,6 @@ class BitcountNode extends MathNode {
 			]
 		} );
 
-		console.log( fnDef );
-
 		return fnDef;
 
 	}
@@ -260,8 +258,6 @@ class BitcountNode extends MathNode {
 			]
 		} );
 
-		console.log( fnDef );
-
 		return fnDef;
 
 	}

From 7f28e08bc08bbaeb1c9274edbd927a339311fe52 Mon Sep 17 00:00:00 2001
From: Christian Helgeson <62450112+cmhhelgeson@users.noreply.github.com>
Date: Sat, 1 Nov 2025 17:10:26 -0700
Subject: [PATCH 15/17] remove method chaining

---
 src/nodes/math/BitcountNode.js | 4 ----
 1 file changed, 4 deletions(-)

diff --git a/src/nodes/math/BitcountNode.js b/src/nodes/math/BitcountNode.js
index 42ac177140fe69..0a9563b5ac9fe7 100644
--- a/src/nodes/math/BitcountNode.js
+++ b/src/nodes/math/BitcountNode.js
@@ -431,7 +431,3 @@ export const countLeadingZeros = /*@__PURE__*/ nodeProxyIntent( BitcountNode, Bi
  * @returns {Node}
  */
 export const countOneBits = /*@__PURE__*/ nodeProxyIntent( BitcountNode, BitcountNode.COUNT_ONE_BITS ).setParameterLength( 1 );
-
-addMethodChaining( 'countTrailingZeros', countTrailingZeros );
-addMethodChaining( 'countLeadingZeros', countLeadingZeros );
-addMethodChaining( 'countOneBits', countOneBits );

From 02ac3fbb98ef2dfa00067967fba095cb1474f3d1 Mon Sep 17 00:00:00 2001
From: Christian Helgeson <62450112+cmhhelgeson@users.noreply.github.com>
Date: Sun, 2 Nov 2025 21:06:48 -0800
Subject: [PATCH 16/17] remove methodChaining import

---
 src/nodes/math/BitcountNode.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/nodes/math/BitcountNode.js b/src/nodes/math/BitcountNode.js
index 0a9563b5ac9fe7..e11f63b2810cf0 100644
--- a/src/nodes/math/BitcountNode.js
+++ b/src/nodes/math/BitcountNode.js
@@ -1,4 +1,4 @@
-import { addMethodChaining, float, Fn, If, nodeProxyIntent, uint, int, uvec2, uvec3, uvec4, ivec2, ivec3, ivec4 } from '../tsl/TSLCore.js';
+import { float, Fn, If, nodeProxyIntent, uint, int, uvec2, uvec3, uvec4, ivec2, ivec3, ivec4 } from '../tsl/TSLCore.js';
 import { bitcast, floatBitsToUint } from './BitcastNode.js';
 import MathNode, { negate } from './MathNode.js';
 

From 4d8ac8c23a7112ac28631669c7ac744577f280ba Mon Sep 17 00:00:00 2001
From: Christian Helgeson <62450112+cmhhelgeson@users.noreply.github.com>
Date: Wed, 5 Nov 2025 10:50:41 -0800
Subject: [PATCH 17/17] fix

---
 examples/jsm/tsl/display/SSGINode.js | 1 -
 1 file changed, 1 deletion(-)

diff --git a/examples/jsm/tsl/display/SSGINode.js b/examples/jsm/tsl/display/SSGINode.js
index b0aa5c8f542320..7731ce8f89251f 100644
--- a/examples/jsm/tsl/display/SSGINode.js
+++ b/examples/jsm/tsl/display/SSGINode.js
@@ -1,7 +1,6 @@
 import { RenderTarget, Vector2, TempNode, QuadMesh, NodeMaterial, RendererUtils, MathUtils } from 'three/webgpu';
 import { clamp, normalize, reference, nodeObject, Fn, NodeUpdateType, uniform, vec4, passTexture, uv, logarithmicDepthToViewZ, viewZToPerspectiveDepth, getViewPosition, screenCoordinate, float, sub, fract, dot, vec2, rand, vec3, Loop, mul, PI, cos, sin, uint, cross, acos, sign, pow, luminance, If, max, abs, Break, sqrt, HALF_PI, div, ceil, shiftRight, convertToTexture, bool, getNormalFromDepth, countOneBits, interleavedGradientNoise } from 'three/tsl';
 
-
 const _quadMesh = /*@__PURE__*/ new QuadMesh();
 const _size = /*@__PURE__*/ new Vector2();