use setup approach and register functions that need to be created

Author: cmhhelgeson

examples/jsm/tsl/display/SSGINode.js

@@ -445,22 +445,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();

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();
+
+		}
 
 	}
 

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 ) {