@gnsx/three 0.185.15 → 0.186.0

package/examples/jsm/transpiler/TSLEncoder.js

@@ -188,9 +188,13 @@ class TSLEncoder {
 
 			}
 
-			// handle texture lookup function calls in separate branch
+			if ( node.name === 'array' ) {
 
-			if ( textureLookupFunctions.includes( node.name ) ) {
+				this.addImport( 'array' );
+
+				code = `array( [ ${ params.join( ', ' ) } ] )`;
+
+			} else if ( textureLookupFunctions.includes( node.name ) ) {
 
 				code = `${ params[ 0 ] }.sample( ${ params[ 1 ] } )`;
 
@@ -368,12 +372,10 @@ class TSLEncoder {
 
 		} else {
 
-			console.warn( 'Unknown node type', node );
+			throw new Error( 'THREE.TSLEncoder: Unknown AST node type "' + node.constructor.name + '"' );
 
 		}
 
-		if ( ! code ) code = '/* unknown statement */';
-
 		return code;
 
 	}
@@ -479,6 +481,38 @@ ${ this.tab }} )`;
 
 	}
 
+	isVariableUsed( node, varName ) {
+
+		if ( ! node ) return false;
+
+		if ( node.isAccessor && node.property === varName ) return true;
+
+		for ( const key in node ) {
+
+			if ( key === 'parent' ) continue;
+
+			const child = node[ key ];
+
+			if ( Array.isArray( child ) ) {
+
+				for ( const item of child ) {
+
+					if ( this.isVariableUsed( item, varName ) ) return true;
+
+				}
+
+			} else if ( child && child.isASTNode ) {
+
+				if ( this.isVariableUsed( child, varName ) ) return true;
+
+			}
+
+		}
+
+		return false;
+
+	}
+
 	emitLoop( node ) {
 
 		const start = this.emitExpression( node.initialization.value );
@@ -504,7 +538,7 @@ ${ this.tab }} )`;
 
 		} else if ( node.afterthought.isOperator ) {
 
-			if ( node.afterthought.right.isAccessor || node.afterthought.right.isNumber ) {
+			if ( node.afterthought.right && ( node.afterthought.right.isAccessor || node.afterthought.right.isNumber ) ) {
 
 				updateParam = `, update: ${ this.emitExpression( node.afterthought.right ) }`;
 
@@ -516,7 +550,22 @@ ${ this.tab }} )`;
 
 		}
 
-		let loopStr = `Loop( { start: ${ start }, end: ${ end + nameParam + typeParam + conditionParam + updateParam } }, ( { ${ name } } ) => {\n\n`;
+		let loopParams;
+
+		if ( start === '0' && nameParam === '' && typeParam === '' && conditionParam === '' && updateParam === '' ) {
+
+			loopParams = end;
+
+		} else {
+
+			loopParams = `{ start: ${ start }, end: ${ end + nameParam + typeParam + conditionParam + updateParam } }`;
+
+		}
+
+		const isUsed = this.isVariableUsed( node.body, name );
+		const callbackParams = isUsed ? `( { ${ name } } ) =>` : '() =>';
+
+		let loopStr = `Loop( ${ loopParams }, ${ callbackParams } {\n\n`;
 
 		loopStr += this.emitBody( node.body ) + '\n\n';
 
@@ -590,10 +639,10 @@ ${ this.tab }} )`;
 		const { initialization, condition, afterthought } = node;
 
 		if ( ( initialization && initialization.isVariableDeclaration && initialization.next === null ) &&
-			( condition && condition.left.isAccessor && condition.left.property === initialization.name ) &&
+			( condition && condition.left && condition.left.isAccessor && condition.left.property === initialization.name ) &&
 			( afterthought && (
-				( afterthought.isUnary && ( initialization.name === afterthought.expression.property ) ) ||
-				( afterthought.isOperator && ( initialization.name === afterthought.left.property ) )
+				( afterthought.isUnary && afterthought.expression && ( initialization.name === afterthought.expression.property ) ) ||
+				( afterthought.isOperator && afterthought.left && ( initialization.name === afterthought.left.property ) )
 			) )
 		) {
 
@@ -632,8 +681,31 @@ ${ this.tab }} )`;
 
 	}
 
+	emitDoWhile( node ) {
+
+		const condition = this.emitExpression( node.condition );
+		const body = this.emitBody( node.body );
+
+		let loopStr = `Loop( () => {\n\n${ body }\n\n${ this.tab }\tIf( ${ condition }.not(), () => {\n\n${ this.tab }\t\tBreak();\n\n${ this.tab }\t} );\n\n`;
+
+		loopStr += this.tab + '} )';
+
+		this.imports.add( 'Loop' );
+		this.imports.add( 'If' );
+		this.imports.add( 'Break' );
+
+		return loopStr;
+
+	}
+
 	emitWhile( node ) {
 
+		if ( node.doWhile ) {
+
+			return this.emitDoWhile( node );
+
+		}
+
 		const condition = this.emitExpression( node.condition );
 
 		let whileStr = `Loop( ${ condition }, () => {\n\n`;

package/examples/jsm/transpiler/WGSLEncoder.js

@@ -194,6 +194,23 @@ class WGSLEncoder {
 
 				code += `( ${ params } )`;
 
+			} else if ( fnName === 'array' ) {
+
+				const params = node.params.map( p => this.emitExpression( p ) );
+
+				if ( node.params.length > 0 && node.params[ 0 ].getType() ) {
+
+					const elemType = this.getWgslType( node.params[ 0 ].getType() );
+					const count = node.params.length;
+
+					code = `array<${ elemType }, ${ count }>( ${ params.join( ', ' ) } )`;
+
+				} else {
+
+					code = `array( ${ params.join( ', ' ) } )`;
+
+				}
+
 			} else if ( fnName.startsWith( 'texture' ) ) {
 
 				// Handle texture functions separately due to sampler handling
@@ -335,9 +352,7 @@ class WGSLEncoder {
 
 		} else {
 
-			console.warn( 'Unknown node type in WGSL Encoder:', node );
-
-			code = `/* unknown node: ${ node.constructor.name } */`;
+			throw new Error( 'THREE.WGSLEncoder: Unknown AST node type "' + node.constructor.name + '"' );
 
 		}
 
@@ -494,6 +509,12 @@ class WGSLEncoder {
 		const cond = this.emitExpression( node.condition );
 		const body = this.emitBody( node.body );
 
+		if ( node.doWhile ) {
+
+			return `loop {\n\n${ body }\n\n${ this.tab }\tcontinuing {\n${ this.tab }\t\tbreak if ( ! ( ${ cond } ) );\n${ this.tab }\t}\n${ this.tab }}`;
+
+		}
+
 		return `while ( ${ cond } ) {\n\n${ body }\n\n${ this.tab }}`;
 
 	}
@@ -577,7 +598,15 @@ class WGSLEncoder {
 
 			}
 
-			declarations.push( `${ keyword } ${ current.name }: ${ type }${ valueStr }` );
+			let typeStr = `: ${ type }`;
+
+			if ( current.value && current.value.isFunctionCall && current.value.name === 'array' ) {
+
+				typeStr = '';
+
+			}
+
+			declarations.push( `${ keyword } ${ current.name }${ typeStr }${ valueStr }` );
 
 			current = current.next;
 

package/examples/jsm/tsl/WebGLNodesHandler.js

@@ -34,7 +34,6 @@ import {
 // - Storage textures not supported
 // - Fog / environment do not automatically update - must call "dispose"
 // - instanced mesh geometry cannot be shared
-// - Node materials cannot be used with "compile" function
 
 // hash any object parameters that will impact the resulting shader so we can force
 // a program update
@@ -108,7 +107,7 @@ class SceneContext {
 
 		const { lightsNode, environmentNode, fogNode } = this;
 		const lightsHash = lightsNode.getCacheKey();
-		const envHash = environmentNode ? environmentNode.getCacheKey : 0;
+		const envHash = environmentNode ? environmentNode.getCacheKey() : 0;
 		const fogHash = fogNode ? fogNode.getCacheKey() : 0;
 		return NodeUtils.hashArray( [ lightsHash, envHash, fogHash ] );
 
@@ -116,21 +115,7 @@ class SceneContext {
 
 	update() {
 
-		const { scene, lightsNode } = this;
-
-		// update lighting
-		const sceneLights = [];
-		scene.traverse( object => {
-
-			if ( object.isLight ) {
-
-				sceneLights.push( object );
-
-			}
-
-		} );
-
-		lightsNode.setLights( sceneLights );
+		const { scene } = this;
 
 		// update fog
 		if ( this.prevFog !== scene.fog ) {
@@ -245,6 +230,12 @@ class RendererProxy {
 
 	}
 
+	getCanvasTarget() {
+
+		return null;
+
+	}
+
 	hasCompatibility( name ) {
 
 		if ( name === Compatibility.TEXTURE_COMPARE ) {
@@ -402,50 +393,41 @@ export class WebGLNodesHandler {
 	}
 
 
-	renderStart( scene, camera ) {
+	renderStart( scene, camera, targetScene = scene ) {
 
 		const { nodeFrame, renderStack, renderer, sceneContexts } = this;
 		nodeFrame.update();
 		nodeFrame.camera = camera;
-		nodeFrame.scene = scene;
+		nodeFrame.scene = targetScene;
 		nodeFrame.frameId ++;
 
-		let sceneContext = sceneContexts.get( scene );
+		let sceneContext = sceneContexts.get( targetScene );
 		if ( ! sceneContext ) {
 
-			sceneContext = new SceneContext( renderer, scene );
-			sceneContexts.set( scene, sceneContext );
+			sceneContext = new SceneContext( renderer, targetScene );
+			sceneContexts.set( targetScene, sceneContext );
 
 		}
 
+		renderer.lighting.beginRender( targetScene );
 		sceneContext.update();
 		renderStack.push( { sceneContext, camera } );
 
-		// ensure all node material callbacks are initialized before
-		// traversal and build
-		const {
-			customProgramCacheKeyCallback,
-			onBeforeRenderCallback,
-		} = this;
-
-		scene.traverse( object => {
-
-			if ( object.material && object.material.isNodeMaterial ) {
+	}
 
-				object.material.customProgramCacheKey = customProgramCacheKeyCallback;
-				object.material.onBeforeRender = onBeforeRenderCallback;
+	updateLights( lights ) {
 
-			}
-
-		} );
+		const frame = this.renderStack[ this.renderStack.length - 1 ];
+		frame.sceneContext.lightsNode.setLights( lights );
 
 	}
 
 	renderEnd() {
 
-		const { nodeFrame, renderStack } = this;
+		const { nodeFrame, renderer, renderStack } = this;
 
-		renderStack.pop();
+		const { sceneContext } = renderStack.pop();
+		renderer.lighting.finishRender( sceneContext.scene );
 
 		const frame = renderStack[ renderStack.length - 1 ];
 		if ( frame ) {
@@ -458,6 +440,14 @@ export class WebGLNodesHandler {
 
 	}
 
+	setObject( object, material ) {
+
+		this.nodeFrame.object = object;
+		material.customProgramCacheKey = this.customProgramCacheKeyCallback;
+		material.onBeforeRender = this.onBeforeRenderCallback;
+
+	}
+
 	build( material, object, parameters ) {
 
 		const {

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

@@ -231,6 +231,8 @@ class AfterImageNode extends TempNode {
 	 */
 	dispose() {
 
+		super.dispose();
+
 		this._compRT.dispose();
 		this._oldRT.dispose();
 

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

@@ -1,5 +1,5 @@
 import { Matrix3, NodeMaterial, Vector3 } from '@gnsx/three/webgpu';
-import { clamp, Fn, vec4, uv, uniform, max } from '@gnsx/three/tsl';
+import { clamp, Fn, vec4, uv, uniform, max, context } from '@gnsx/three/tsl';
 import StereoCompositePassNode from './StereoCompositePassNode.js';
 import { frameCorners } from '../../utils/CameraUtils.js';
 
@@ -523,7 +523,8 @@ class AnaglyphPassNode extends StereoCompositePassNode {
 		} );
 
 		const material = this._material || ( this._material = new NodeMaterial() );
-		material.fragmentNode = anaglyph().context( builder.getSharedContext() );
+		material.contextNode = context( builder.getSharedContext() );
+		material.fragmentNode = anaglyph();
 		material.name = 'Anaglyph';
 		material.needsUpdate = true;
 

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

@@ -1,5 +1,5 @@
 import { RenderTarget, Vector2, NodeMaterial, RendererUtils, QuadMesh, TempNode, NodeUpdateType } from '@gnsx/three/webgpu';
-import { Fn, float, uv, uniform, convertToTexture, vec2, vec4, passTexture, luminance, abs, exp, max } from '@gnsx/three/tsl';
+import { Fn, float, uv, uniform, convertToTexture, vec2, vec4, passTexture, luminance, abs, exp, max, context } from '@gnsx/three/tsl';
 
 const _quadMesh = /*@__PURE__*/ new QuadMesh();
 
@@ -302,7 +302,8 @@ class BilateralBlurNode extends TempNode {
 		//
 
 		const material = this._material || ( this._material = new NodeMaterial() );
-		material.fragmentNode = blur().context( builder.getSharedContext() );
+		material.contextNode = context( builder.getSharedContext() );
+		material.fragmentNode = blur();
 		material.name = 'Bilateral_blur';
 		material.needsUpdate = true;
 
@@ -323,6 +324,8 @@ class BilateralBlurNode extends TempNode {
 	 */
 	dispose() {
 
+		super.dispose();
+
 		this._horizontalRT.dispose();
 		this._verticalRT.dispose();
 

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

@@ -1,5 +1,5 @@
 import { HalfFloatType, RenderTarget, Vector2, Vector3, TempNode, QuadMesh, NodeMaterial, RendererUtils, NodeUpdateType } from '@gnsx/three/webgpu';
-import { nodeObject, Fn, float, uv, passTexture, uniform, Loop, texture, luminance, smoothstep, mix, vec4, uniformArray, add, int } from '@gnsx/three/tsl';
+import { nodeObject, Fn, float, uv, passTexture, uniform, Loop, texture, luminance, smoothstep, mix, vec4, uniformArray, add, int, array, context } from '@gnsx/three/tsl';
 
 const _quadMesh = /*@__PURE__*/ new QuadMesh();
 const _size = /*@__PURE__*/ new Vector2();
@@ -106,6 +106,15 @@ class BloomNode extends TempNode {
 		 */
 		this.smoothWidth = uniform( 0.01 );
 
+		/**
+		 * A per-mip tint color for the bloom, applied during the composite pass.
+		 * Defaults to white (no tint) for each of the mips. Mutate the vectors to
+		 * colorize the bloom (e.g. for a warm or anamorphic look).
+		 *
+		 * @type {Array<Vector3>}
+		 */
+		this.bloomTintColors = [ new Vector3( 1, 1, 1 ), new Vector3( 1, 1, 1 ), new Vector3( 1, 1, 1 ), new Vector3( 1, 1, 1 ), new Vector3( 1, 1, 1 ) ];
+
 		/**
 		 * Scale factor for the internal render targets.
 		 *
@@ -399,10 +408,13 @@ class BloomNode extends TempNode {
 	 */
 	setup( builder ) {
 
+		const sharedContext = context( builder.getSharedContext() );
+
 		// luminosity high pass material
 
 		this._highPassFilterMaterial = this._highPassFilterMaterial || new NodeMaterial();
-		this._highPassFilterMaterial.fragmentNode = this.highPassFn( { input: this.inputNode, threshold: this.threshold, smoothWidth: this.smoothWidth } ).context( builder.getSharedContext() );
+		this._highPassFilterMaterial.contextNode = sharedContext;
+		this._highPassFilterMaterial.fragmentNode = this.highPassFn( { input: this.inputNode, threshold: this.threshold, smoothWidth: this.smoothWidth } );
 		this._highPassFilterMaterial.name = 'Bloom_highPass';
 		this._highPassFilterMaterial.needsUpdate = true;
 
@@ -414,29 +426,14 @@ class BloomNode extends TempNode {
 
 		for ( let i = 0; i < this._nMips; i ++ ) {
 
-			this._separableBlurMaterials.push( this._getSeparableBlurMaterial( builder, kernelSizeArray[ i ] ) );
+			this._separableBlurMaterials.push( this._getSeparableBlurMaterial( sharedContext, kernelSizeArray[ i ] ) );
 
 		}
 
 		// composite material
 
-		const bloomFactors = uniformArray( [ 1.0, 0.8, 0.6, 0.4, 0.2 ] );
-		const bloomTintColors = uniformArray( [ new Vector3( 1, 1, 1 ), new Vector3( 1, 1, 1 ), new Vector3( 1, 1, 1 ), new Vector3( 1, 1, 1 ), new Vector3( 1, 1, 1 ) ] );
-
-		const lerpBloomFactor = Fn( ( [ factor, radius ] ) => {
-
-			const mirrorFactor = float( 1.2 ).sub( factor );
-			return mix( factor, mirrorFactor, radius );
-
-		} ).setLayout( {
-			name: 'lerpBloomFactor',
-			type: 'float',
-			inputs: [
-				{ name: 'factor', type: 'float' },
-				{ name: 'radius', type: 'float' },
-			]
-		} );
-
+		const bloomFactors = array( [ 1.0, 0.8, 0.6, 0.4, 0.2 ] );
+		const bloomTintColors = uniformArray( this.bloomTintColors );
 
 		const compositePass = Fn( () => {
 
@@ -453,7 +450,8 @@ class BloomNode extends TempNode {
 		} );
 
 		this._compositeMaterial = this._compositeMaterial || new NodeMaterial();
-		this._compositeMaterial.fragmentNode = compositePass().context( builder.getSharedContext() );
+		this._compositeMaterial.contextNode = sharedContext;
+		this._compositeMaterial.fragmentNode = compositePass();
 		this._compositeMaterial.name = 'Bloom_comp';
 		this._compositeMaterial.needsUpdate = true;
 
@@ -469,6 +467,8 @@ class BloomNode extends TempNode {
 	 */
 	dispose() {
 
+		super.dispose();
+
 		for ( let i = 0; i < this._renderTargetsHorizontal.length; i ++ ) {
 
 			this._renderTargetsHorizontal[ i ].dispose();
@@ -498,11 +498,11 @@ class BloomNode extends TempNode {
 	 * Create a separable blur material for the given kernel radius.
 	 *
 	 * @private
-	 * @param {NodeBuilder} builder - The current node builder.
+	 * @param {NodeContext} sharedContext
 	 * @param {number} kernelRadius - The kernel radius.
 	 * @return {NodeMaterial}
 	 */
-	_getSeparableBlurMaterial( builder, kernelRadius ) {
+	_getSeparableBlurMaterial( sharedContext, kernelRadius ) {
 
 		const coefficients = [];
 		const sigma = kernelRadius / 3;
@@ -513,10 +513,28 @@ class BloomNode extends TempNode {
 
 		}
 
+		// Merge adjacent taps into single bilinear fetches (linear sampling).
+
+		const centerWeight = coefficients[ 0 ];
+		const offsets = [];
+		const weights = [];
+
+		for ( let i = 1; i < kernelRadius; i += 2 ) {
+
+			const wa = coefficients[ i ];
+			const wb = ( i + 1 ) < kernelRadius ? coefficients[ i + 1 ] : 0;
+			const w = wa + wb;
+
+			offsets.push( ( i * wa + ( i + 1 ) * wb ) / w );
+			weights.push( w );
+
+		}
+
 		//
 
 		const colorTexture = texture( null );
-		const gaussianCoefficients = uniformArray( coefficients );
+		const gaussianOffsets = array( offsets );
+		const gaussianWeights = array( weights );
 		const invSize = uniform( new Vector2() );
 		const direction = uniform( new Vector2( 0.5, 0.5 ) );
 
@@ -525,13 +543,12 @@ class BloomNode extends TempNode {
 
 		const separableBlurPass = Fn( () => {
 
-			const diffuseSum = sampleTexel( uvNode ).rgb.mul( gaussianCoefficients.element( 0 ) ).toVar();
+			const diffuseSum = sampleTexel( uvNode ).rgb.mul( centerWeight ).toVar();
 
-			Loop( { start: int( 1 ), end: int( kernelRadius ), type: 'int', condition: '<' }, ( { i } ) => {
+			Loop( { start: int( 0 ), end: int( offsets.length ), type: 'int', condition: '<' }, ( { i } ) => {
 
-				const x = float( i );
-				const w = gaussianCoefficients.element( i );
-				const uvOffset = direction.mul( invSize ).mul( x );
+				const w = gaussianWeights.element( i );
+				const uvOffset = direction.mul( invSize ).mul( gaussianOffsets.element( i ) );
 				const sample1 = sampleTexel( uvNode.add( uvOffset ) ).rgb;
 				const sample2 = sampleTexel( uvNode.sub( uvOffset ) ).rgb;
 				diffuseSum.addAssign( add( sample1, sample2 ).mul( w ) );
@@ -543,7 +560,8 @@ class BloomNode extends TempNode {
 		} );
 
 		const separableBlurMaterial = new NodeMaterial();
-		separableBlurMaterial.fragmentNode = separableBlurPass().context( builder.getSharedContext() );
+		separableBlurMaterial.contextNode = sharedContext;
+		separableBlurMaterial.fragmentNode = separableBlurPass();
 		separableBlurMaterial.name = 'Bloom_separable';
 		separableBlurMaterial.needsUpdate = true;
 
@@ -558,6 +576,13 @@ class BloomNode extends TempNode {
 
 }
 
+const lerpBloomFactor = Fn( ( { factor, radius } ) => {
+
+	const mirrorFactor = float( 1.2 ).sub( factor );
+	return mix( factor, mirrorFactor, radius );
+
+}, { factor: 'float', radius: 'float', return: 'float' } );
+
 /**
  * TSL function for creating a bloom effect.
  *

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

@@ -56,12 +56,20 @@ class DenoiseNode extends TempNode {
 		 */
 		this.normalNode = normalNode;
 
+		/**
+		 * The internal noise texture.
+		 *
+		 * @private
+		 * @type {DataTexture}
+		 */
+		this._noiseTexture = generateDefaultNoise();
+
 		/**
 		 * The node represents the internal noise texture.
 		 *
 		 * @type {TextureNode}
 		 */
-		this.noiseNode = texture( generateDefaultNoise() );
+		this.noiseNode = texture( this._noiseTexture );
 
 		/**
 		 * The luma Phi value.
@@ -252,6 +260,18 @@ class DenoiseNode extends TempNode {
 
 	}
 
+	/**
+	 * Frees internal resources. This method should be called
+	 * when the effect is no longer required.
+	 */
+	dispose() {
+
+		super.dispose();
+
+		this._noiseTexture.dispose();
+
+	}
+
 }
 
 export default DenoiseNode;