sketch out solve

Author: cmhhelgeson

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 } 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 } from 'three/tsl';
 
 const _quadMesh = /*@__PURE__*/ new QuadMesh();
 const _size = /*@__PURE__*/ new Vector2();
@@ -445,7 +445,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 ) ) ) );
@@ -459,7 +459,7 @@ class SSGINode extends TempNode {
 			inputs: [
 				{ name: 'value', type: 'uint' }
 			]
-		} );
+		} ); */
 
 		const horizonSampling = Fn( ( [ directionIsRight, RADIUS, viewPosition, slideDirTexelSize, initialRayStep, uvNode, viewDir, viewNormal, n ] ) => {
 

src/renderers/webgl-fallback/nodes/GLSLNodeBuilder.js

@@ -1,4 +1,4 @@
-import { GLSLNodeParser, NodeBuilder, TextureNode, vectorComponents } from '../../../nodes/Nodes.js';
+import { CodeNode, GLSLNodeParser, NodeBuilder, TextureNode, vectorComponents } from '../../../nodes/Nodes.js';
 
 import NodeUniformBuffer from '../../common/nodes/NodeUniformBuffer.js';
 import NodeUniformsGroup from '../../common/nodes/NodeUniformsGroup.js';
@@ -9,13 +9,77 @@ import { NoColorSpace, ByteType, ShortType, RGBAIntegerFormat, RGBIntegerFormat,
 import { DataTexture } from '../../../textures/DataTexture.js';
 import { error } from '../../../utils.js';
 
+const uintBitCount = new CodeNode( /* glsl */`
+uint tsl_bit_count ( uint value ) {
+
+	uint newValue = value;
+	newValue = ( newValue - ( ( newValue >> 1u ) & 1431655765u ) );
+	newValue = ( ( newValue & 858993459u ) + ( ( newValue >> 2u ) & 858993459u ) );
+
+	return ( ( ( ( newValue + ( newValue >> 4u ) ) & 252645135u ) * 16843009u ) >> 24u );
+
+}
+` );
+
+const intBitCount = new CodeNode( /* glsl */`
+uint tsl_bit_count_int ( int value ) {
+
+	uint v = floatBitsToUint( intBitsToFloat( value ) );
+	v = ( v - ( ( v >> 1u ) & 1431655765u ) );
+	v = ( ( v & 858993459u ) + ( ( v >> 2u ) & 858993459u ) );
+
+	return ( ( ( ( v + ( v >> 4u ) ) & 252645135u ) * 16843009u ) >> 24u );
+
+}
+` );
+
+const uvec2BitCount = new CodeNode( /* glsl */'uint tsl_bit_count_vec2 (uvec2 value) { return tsl_bit_count(value.x) + tsl_bit_count(value.y) } )' );
+const uvec3BitCount = new CodeNode( /* glsl */'uint tsl_bit_count_vec3 (uvec3 value) { return tsl_bit_count(value.x) + tsl_bit_count(value.y) + tsl_bit_count(value.z)  } )' );
+const uvec4BitCount = new CodeNode( /* glsl */'uint tsl_bit_count_vec3 (uvec4 value) { return tsl_bit_count(value.x) + tsl_bit_count(value.y) + tsl_bit_count(value.z) + tsl_bit_count(value.w) }' );
+
+const uintFindLSB = '';
+const uintFindMSB = '';
+
+
+/* Remove polyfills and method mappings for findLSB, findMSB, and bitCount
+   when OpenGL ES 3.1 bit counting functionality is implemented in WebGL.
+   Tracking for issue found here https://github.com/KhronosGroup/WebGL/issues/3714 */
+const glslPolyfills = {
+	tsl_find_lsb: {
+		entryIndex: 0,
+		codeNodes: [ uintFindLSB ],
+	},
+	tsl_find_msb: {
+		entryIndex: 0,
+		codeNodes: [ uintFindMSB ],
+	},
+	tsl_bit_count: {
+		codeNodes: [ uintBitCount ],
+	},
+	tsl_bit_count_uvec2: {
+		codeNodes: [ uintBitCount, uvec2BitCount ]
+	},
+	tsl_bit_count_uvec3: {
+		codeNodes: [ uintBitCount, uvec3BitCount ]
+	},
+	tsl_bit_count_uvec4: {
+		codeNodes: [ uintBitCount, uvec4BitCount ]
+	}
+};
+
 const glslMethods = {
 	textureDimensions: 'textureSize',
 	equals: 'equal',
 	bitcast_float_int: 'floatBitsToInt',
 	bitcast_int_float: 'intBitsToFloat',
 	bitcast_uint_float: 'uintBitsToFloat',
 	bitcast_float_uint: 'floatBitsToUint',
+	findLSB: 'tsl_find_lsb',
+	findMSB: 'tsl_find_msb',
+	bitCount: 'tsl_bit_count',
+	countTrailingZeros: 'tsl_find_lsb',
+	countLeadingZeros: 'tsl_find_msb',
+	countOneBits: 'tsl_bit_count'
 };
 
 const precisionLib = {
@@ -127,6 +191,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 ];
+
+	}
+
 	/**
 	 * Returns the native shader method name for a given generic name.
 	 *
@@ -135,7 +216,17 @@ class GLSLNodeBuilder extends NodeBuilder {
 	 */
 	getMethod( method ) {
 
-		return glslMethods[ method ] || method;
+		const glslMethod = glslMethods[ method ] || method;
+
+		if ( glslPolyfills[ glslMethod ] !== undefined ) {
+
+			console.log( 'calling glsl polyfill for ', method );
+
+			this._include( glslMethod );
+
+		}
+
+		return glslMethod;
 
 	}
 
@@ -1288,6 +1379,8 @@ ${vars}
 	 */
 	_getGLSLVertexCode( shaderData ) {
 
+		console.log( shaderData );
+
 		return `#version 300 es
 
 ${ this.getSignature() }
@@ -1337,6 +1430,8 @@ void main() {
 	 */
 	_getGLSLFragmentCode( shaderData ) {
 
+		console.log( shaderData );
+
 		return `#version 300 es
 
 ${ this.getSignature() }
@@ -1446,6 +1541,8 @@ void main() {
 
 			this.vertexShader = this._getGLSLVertexCode( shadersData.vertex );
 			this.fragmentShader = this._getGLSLFragmentCode( shadersData.fragment );
+			console.log( this.vertexShader );
+			console.log( this.fragmentShader );
 
 		} else {