@needle-tools/three 0.146.10 → 0.153.1

package/examples/jsm/nodes/shadernode/ShaderNode.js

@@ -1,10 +1,21 @@
-import Node from '../core/Node.js';
+import Node, { addNodeClass } from '../core/Node.js';
 import ArrayElementNode from '../utils/ArrayElementNode.js';
 import ConvertNode from '../utils/ConvertNode.js';
 import JoinNode from '../utils/JoinNode.js';
 import SplitNode from '../utils/SplitNode.js';
 import ConstNode from '../core/ConstNode.js';
-import { getValueFromType } from '../core/NodeUtils.js';
+import { getValueFromType, getValueType } from '../core/NodeUtils.js';
+
+const NodeElements = new Map(); // @TODO: Currently only a few nodes are added, probably also add others
+
+export function addNodeElement( name, nodeElement ) {
+
+	if ( NodeElements.has( name ) ) throw new Error( `Redefinition of node element ${ name }` );
+	if ( typeof nodeElement !== 'function' ) throw new Error( `Node element ${ name } is not a function` );
+
+	NodeElements.set( name, nodeElement );
+
+}
 
 const shaderNodeHandler = {
 
@@ -16,11 +27,23 @@ const shaderNodeHandler = {
 
 	},
 
-	get: function ( node, prop ) {
+	get: function ( node, prop, nodeObj ) {
 
 		if ( typeof prop === 'string' && node[ prop ] === undefined ) {
 
-			if ( /^[xyzwrgbastpq]{1,4}$/.test( prop ) === true ) {
+			if ( NodeElements.has( prop ) ) {
+
+				const nodeElement = NodeElements.get( prop );
+
+				return ( ...params ) => nodeElement( nodeObj, ...params );
+
+			} else if ( prop.endsWith( 'Assign' ) && NodeElements.has( prop.slice( 0, prop.length - 'Assign'.length ) ) ) {
+
+				const nodeElement = NodeElements.get( prop.slice( 0, prop.length - 'Assign'.length ) );
+
+				return ( ...params ) => nodeObj.assign( nodeElement( nodeObj, ...params ) );
+
+			} else if ( /^[xyzwrgbastpq]{1,4}$/.test( prop ) === true ) {
 
 				// accessing properties ( swizzle )
 
@@ -32,6 +55,12 @@ const shaderNodeHandler = {
 
 				return nodeObject( new SplitNode( node, prop ) );
 
+			} else if ( prop === 'width' || prop === 'height' ) {
+
+				// accessing property
+
+				return nodeObject( new SplitNode( node, prop === 'width' ? 'x' : 'y' ) );
+
 			} else if ( /^\d+$/.test( prop ) === true ) {
 
 				// accessing array
@@ -50,31 +79,31 @@ const shaderNodeHandler = {
 
 const nodeObjectsCacheMap = new WeakMap();
 
-const ShaderNodeObject = function ( obj ) {
+const ShaderNodeObject = function ( obj, altType = null ) {
 
-	const type = typeof obj;
+	const type = getValueType( obj );
 
-	if ( ( type === 'number' ) || ( type === 'boolean' ) ) {
+	if ( type === 'node' ) {
 
-		return nodeObject( getAutoTypedConstNode( obj ) );
+		let nodeObject = nodeObjectsCacheMap.get( obj );
 
-	} else if ( type === 'object' ) {
+		if ( nodeObject === undefined ) {
 
-		if ( obj?.isNode === true ) {
+			nodeObject = new Proxy( obj, shaderNodeHandler );
+			nodeObjectsCacheMap.set( obj, nodeObject );
+			nodeObjectsCacheMap.set( nodeObject, nodeObject );
 
-			let nodeObject = nodeObjectsCacheMap.get( obj );
+		}
 
-			if ( nodeObject === undefined ) {
+		return nodeObject;
 
-				nodeObject = new Proxy( obj, shaderNodeHandler );
-				nodeObjectsCacheMap.set( obj, nodeObject );
-				nodeObjectsCacheMap.set( nodeObject, nodeObject );
+	} else if ( ( altType === null && ( type === 'float' || type === 'boolean' ) ) || ( type && type !== 'shader' && type !== 'string' ) ) {
 
-			}
+		return nodeObject( getConstNode( obj, altType ) );
 
-			return nodeObject;
+	} else if ( type === 'shader' ) {
 
-		}
+		return shader( obj );
 
 	}
 
@@ -82,11 +111,11 @@ const ShaderNodeObject = function ( obj ) {
 
 };
 
-const ShaderNodeObjects = function ( objects ) {
+const ShaderNodeObjects = function ( objects, altType = null ) {
 
 	for ( const name in objects ) {
 
-		objects[ name ] = nodeObject( objects[ name ] );
+		objects[ name ] = nodeObject( objects[ name ], altType );
 
 	}
 
@@ -94,13 +123,13 @@ const ShaderNodeObjects = function ( objects ) {
 
 };
 
-const ShaderNodeArray = function ( array ) {
+const ShaderNodeArray = function ( array, altType = null ) {
 
 	const len = array.length;
 
 	for ( let i = 0; i < len; i ++ ) {
 
-		array[ i ] = nodeObject( array[ i ] );
+		array[ i ] = nodeObject( array[ i ], altType );
 
 	}
 
@@ -158,43 +187,33 @@ class ShaderNodeInternal extends Node {
 
 	}
 
-	call( inputs, builder ) {
+	call( inputs, stack, builder ) {
 
 		inputs = nodeObjects( inputs );
 
-		return nodeObject( this._jsFunc( inputs, builder ) );
+		return nodeObject( this._jsFunc( inputs, stack, builder ) );
 
 	}
 
-	generate( builder, output ) {
-
-		const nodeCall = this.call( {}, builder );
+	getNodeType( builder ) {
 
-		if ( nodeCall === undefined ) {
+		const { outputNode } = builder.getNodeProperties( this );
 
-			return '';
-
-		}
-
-		return builder.format( nodeCall.build( builder ), nodeCall.getNodeType( builder ), output );
+		return outputNode ? outputNode.getNodeType( builder ) : super.getNodeType( builder );
 
 	}
 
-}
+	construct( builder ) {
 
-const ShaderNodeScript = function ( jsFunc ) {
+		builder.addStack();
 
-	return new ShaderNodeInternal( jsFunc );
+		builder.stack.outputNode = nodeObject( this._jsFunc( builder.stack, builder ) );
 
-};
+		return builder.removeStack();
 
-export const ShaderNode = new Proxy( ShaderNodeScript, shaderNodeHandler );
+	}
 
-export const nodeObject = ( val ) => /* new */ ShaderNodeObject( val );
-export const nodeObjects = ( val ) => new ShaderNodeObjects( val );
-export const nodeArray = ( val ) => new ShaderNodeArray( val );
-export const nodeProxy = ( ...val ) => new ShaderNodeProxy( ...val );
-export const nodeImmutable = ( ...val ) => new ShaderNodeImmutable( ...val );
+}
 
 const bools = [ false, true ];
 const uints = [ 0, 1, 2, 3 ];
@@ -214,11 +233,11 @@ const floatsCacheMap = new Map( [ ...intsCacheMap ].map( el => new ConstNode( el
 for ( const float of floats ) floatsCacheMap.set( float, new ConstNode( float ) );
 for ( const float of floats ) floatsCacheMap.set( - float, new ConstNode( - float ) );
 
-export const cacheMaps = { bool: boolsCacheMap, uint: uintsCacheMap, ints: intsCacheMap, float: floatsCacheMap };
+const cacheMaps = { bool: boolsCacheMap, uint: uintsCacheMap, ints: intsCacheMap, float: floatsCacheMap };
 
 const constNodesCacheMap = new Map( [ ...boolsCacheMap, ...floatsCacheMap ] );
 
-const getAutoTypedConstNode = ( value ) => {
+const getConstNode = ( value, type ) => {
 
 	if ( constNodesCacheMap.has( value ) ) {
 
@@ -230,48 +249,152 @@ const getAutoTypedConstNode = ( value ) => {
 
 	} else {
 
-		return new ConstNode( value );
+		return new ConstNode( value, type );
 
 	}
 
 };
 
-export const ConvertType = function ( type, cacheMap = null ) {
+const safeGetNodeType = ( node ) => {
 
-	return ( ...params ) => {
+	try {
 
-		if ( params.length === 0 ) {
+		return node.getNodeType();
 
-			return nodeObject( new ConstNode( getValueFromType( type ), type ) );
+	} catch {
 
-		} else {
+		return undefined;
 
-			if ( type === 'color' && params[ 0 ].isNode !== true ) {
+	}
 
-				params = [ getValueFromType( type, ...params ) ];
+};
 
-			}
+const ConvertType = function ( type, cacheMap = null ) {
 
-			if ( params.length === 1 && cacheMap !== null && cacheMap.has( params[ 0 ] ) ) {
+	return ( ...params ) => {
 
-				return cacheMap.get( params[ 0 ] );
+		if ( params.length === 0 || ( ! [ 'bool', 'float', 'int', 'uint' ].includes( type ) && params.every( param => typeof param !== 'object' ) ) ) {
 
-			}
+			params = [ getValueFromType( type, ...params ) ];
+
+		}
 
-			const nodes = params.map( getAutoTypedConstNode );
+		if ( params.length === 1 && cacheMap !== null && cacheMap.has( params[ 0 ] ) ) {
 
-			if ( nodes.length === 1 ) {
+			return nodeObject( cacheMap.get( params[ 0 ] ) );
 
-				return nodeObject( nodes[ 0 ].nodeType === type ? nodes[ 0 ] : new ConvertNode( nodes[ 0 ], type ) );
+		}
 
-			}
+		if ( params.length === 1 ) {
 
-			return nodeObject( new JoinNode( nodes, type ) );
+			const node = getConstNode( params[ 0 ], type );
+			if ( safeGetNodeType( node ) === type ) return nodeObject( node );
+			return nodeObject( new ConvertNode( node, type ) );
 
 		}
 
+		const nodes = params.map( param => getConstNode( param ) );
+		return nodeObject( new JoinNode( nodes, type ) );
+
 	};
 
 };
 
-export const getConstNodeType = ( value ) => value.nodeType || value.convertTo || ( typeof value === 'string' ? value : null );
+// exports
+
+// utils
+
+export const getConstNodeType = ( value ) => ( value !== undefined && value !== null ) ? ( value.nodeType || value.convertTo || ( typeof value === 'string' ? value : null ) ) : null;
+
+// shader node base
+
+export function ShaderNode( jsFunc ) {
+
+	return new Proxy( new ShaderNodeInternal( jsFunc ), shaderNodeHandler );
+
+}
+
+export const nodeObject = ( val, altType = null ) => /* new */ ShaderNodeObject( val, altType );
+export const nodeObjects = ( val, altType = null ) => new ShaderNodeObjects( val, altType );
+export const nodeArray = ( val, altType = null ) => new ShaderNodeArray( val, altType );
+export const nodeProxy = ( ...val ) => new ShaderNodeProxy( ...val );
+export const nodeImmutable = ( ...val ) => new ShaderNodeImmutable( ...val );
+
+export const shader = ( ...val ) => new ShaderNode( ...val );
+
+addNodeClass( ShaderNode );
+
+// types
+// @TODO: Maybe export from ConstNode.js?
+
+export const color = new ConvertType( 'color' );
+
+export const float = new ConvertType( 'float', cacheMaps.float );
+export const int = new ConvertType( 'int', cacheMaps.int );
+export const uint = new ConvertType( 'uint', cacheMaps.uint );
+export const bool = new ConvertType( 'bool', cacheMaps.bool );
+
+export const vec2 = new ConvertType( 'vec2' );
+export const ivec2 = new ConvertType( 'ivec2' );
+export const uvec2 = new ConvertType( 'uvec2' );
+export const bvec2 = new ConvertType( 'bvec2' );
+
+export const vec3 = new ConvertType( 'vec3' );
+export const ivec3 = new ConvertType( 'ivec3' );
+export const uvec3 = new ConvertType( 'uvec3' );
+export const bvec3 = new ConvertType( 'bvec3' );
+
+export const vec4 = new ConvertType( 'vec4' );
+export const ivec4 = new ConvertType( 'ivec4' );
+export const uvec4 = new ConvertType( 'uvec4' );
+export const bvec4 = new ConvertType( 'bvec4' );
+
+export const mat3 = new ConvertType( 'mat3' );
+export const imat3 = new ConvertType( 'imat3' );
+export const umat3 = new ConvertType( 'umat3' );
+export const bmat3 = new ConvertType( 'bmat3' );
+
+export const mat4 = new ConvertType( 'mat4' );
+export const imat4 = new ConvertType( 'imat4' );
+export const umat4 = new ConvertType( 'umat4' );
+export const bmat4 = new ConvertType( 'bmat4' );
+
+export const string = ( value = '' ) => nodeObject( new ConstNode( value, 'string' ) );
+export const arrayBuffer = ( value ) => nodeObject( new ConstNode( value, 'ArrayBuffer' ) );
+
+addNodeElement( 'color', color );
+addNodeElement( 'float', float );
+addNodeElement( 'int', int );
+addNodeElement( 'uint', uint );
+addNodeElement( 'bool', bool );
+addNodeElement( 'vec2', vec2 );
+addNodeElement( 'ivec2', ivec2 );
+addNodeElement( 'uvec2', uvec2 );
+addNodeElement( 'bvec2', bvec2 );
+addNodeElement( 'vec3', vec3 );
+addNodeElement( 'ivec3', ivec3 );
+addNodeElement( 'uvec3', uvec3 );
+addNodeElement( 'bvec3', bvec3 );
+addNodeElement( 'vec4', vec4 );
+addNodeElement( 'ivec4', ivec4 );
+addNodeElement( 'uvec4', uvec4 );
+addNodeElement( 'bvec4', bvec4 );
+addNodeElement( 'mat3', mat3 );
+addNodeElement( 'imat3', imat3 );
+addNodeElement( 'umat3', umat3 );
+addNodeElement( 'bmat3', bmat3 );
+addNodeElement( 'mat4', mat4 );
+addNodeElement( 'imat4', imat4 );
+addNodeElement( 'umat4', umat4 );
+addNodeElement( 'bmat4', bmat4 );
+addNodeElement( 'string', string );
+addNodeElement( 'arrayBuffer', arrayBuffer );
+
+// basic nodes
+// HACK - we cannot export them from the corresponding files because of the cyclic dependency
+export const element = nodeProxy( ArrayElementNode );
+export const convert = ( node, types ) => nodeObject( new ConvertNode( nodeObject( node ), types ) );
+export const split = ( node, channels ) => nodeObject( new SplitNode( nodeObject( node ), channels ) );
+
+addNodeElement( 'element', element );
+addNodeElement( 'convert', convert );

package/examples/jsm/nodes/utils/ArrayElementNode.js

@@ -1,6 +1,6 @@
-import TempNode from '../core/Node.js';
+import Node, { addNodeClass } from '../core/Node.js';
 
-class ArrayElementNode extends TempNode {
+class ArrayElementNode extends Node { // @TODO: If extending from TempNode it breaks webgpu_compute
 
 	constructor( node, indexNode ) {
 
@@ -29,3 +29,5 @@ class ArrayElementNode extends TempNode {
 }
 
 export default ArrayElementNode;
+
+addNodeClass( ArrayElementNode );

package/examples/jsm/nodes/utils/ConvertNode.js

@@ -1,4 +1,4 @@
-import Node from '../core/Node.js';
+import Node, { addNodeClass } from '../core/Node.js';
 
 class ConvertNode extends Node {
 
@@ -31,6 +31,22 @@ class ConvertNode extends Node {
 
 	}
 
+	serialize( data ) {
+
+		super.serialize( data );
+
+		data.convertTo = this.convertTo;
+
+	}
+
+	deserialize( data ) {
+
+		super.deserialize( data );
+
+		this.convertTo = data.convertTo;
+
+	}
+
 	generate( builder, output ) {
 
 		const node = this.node;
@@ -45,3 +61,5 @@ class ConvertNode extends Node {
 }
 
 export default ConvertNode;
+
+addNodeClass( ConvertNode );

package/examples/jsm/nodes/utils/DiscardNode.js

@@ -0,0 +1,26 @@
+import CondNode from '../math/CondNode.js';
+import { expression } from '../code/ExpressionNode.js';
+import { addNodeClass } from '../core/Node.js';
+import { addNodeElement, nodeProxy } from '../shadernode/ShaderNode.js';
+
+let discardExpression;
+
+class DiscardNode extends CondNode {
+
+	constructor( condNode ) {
+
+		discardExpression = discardExpression || expression( 'discard' );
+
+		super( condNode, discardExpression );
+
+	}
+
+}
+
+export default DiscardNode;
+
+export const discard = nodeProxy( DiscardNode );
+
+addNodeElement( 'discard', discard );
+
+addNodeClass( DiscardNode );

package/examples/jsm/nodes/utils/EquirectUVNode.js

@@ -1,5 +1,7 @@
 import TempNode from '../core/TempNode.js';
-import { nodeObject, vec2, add, mul, atan2, asin, clamp, positionWorldDirection } from '../shadernode/ShaderNodeElements.js';
+import { positionWorldDirection } from '../accessors/PositionNode.js';
+import { nodeProxy, vec2 } from '../shadernode/ShaderNode.js';
+import { addNodeClass } from '../core/Node.js';
 
 class EquirectUVNode extends TempNode {
 
@@ -13,10 +15,10 @@ class EquirectUVNode extends TempNode {
 
 	construct() {
 
-		const dir = nodeObject( this.dirNode );
+		const dir = this.dirNode;
 
-		const u = add( mul( atan2( dir.z, dir.x ), 1 / ( Math.PI * 2 ) ), 0.5 );
-		const v = add( mul( asin( clamp( dir.y, - 1.0, 1.0 ) ), 1 / Math.PI ), 0.5 );
+		const u = dir.z.atan2( dir.x ).mul( 1 / ( Math.PI * 2 ) ).add( 0.5 );
+		const v = dir.y.negate().clamp( - 1.0, 1.0 ).asin().mul( 1 / Math.PI ).add( 0.5 ); // @TODO: The use of negate() here could be an NDC issue.
 
 		return vec2( u, v );
 
@@ -25,3 +27,7 @@ class EquirectUVNode extends TempNode {
 }
 
 export default EquirectUVNode;
+
+export const equirectUV = nodeProxy( EquirectUVNode );
+
+addNodeClass( EquirectUVNode );

package/examples/jsm/nodes/utils/JoinNode.js

@@ -1,4 +1,5 @@
-import TempNode from '../core/Node.js';
+import { addNodeClass } from '../core/Node.js';
+import TempNode from '../core/TempNode.js';
 
 class JoinNode extends TempNode {
 
@@ -46,3 +47,5 @@ class JoinNode extends TempNode {
 }
 
 export default JoinNode;
+
+addNodeClass( JoinNode );

package/examples/jsm/nodes/utils/LoopNode.js

@@ -0,0 +1,186 @@
+import Node, { addNodeClass } from '../core/Node.js';
+import { expression } from '../code/ExpressionNode.js';
+import { bypass } from '../core/BypassNode.js';
+import { context as contextNode } from '../core/ContextNode.js';
+import { addNodeElement, nodeObject, nodeArray } from '../shadernode/ShaderNode.js';
+
+class LoopNode extends Node {
+
+	constructor( params = [] ) {
+
+		super();
+
+		this.params = params;
+
+	}
+
+	getVarName( index ) {
+
+		return String.fromCharCode( 'i'.charCodeAt() + index );
+
+	}
+
+	getProperties( builder ) {
+
+		const properties = builder.getNodeProperties( this );
+
+		if ( properties.stackNode !== undefined ) return properties;
+
+		//
+
+		const inputs = {};
+
+		for ( let i = 0, l = this.params.length - 1; i < l; i ++ ) {
+
+			const prop = this.getVarName( i );
+
+			inputs[ prop ] = expression( prop, 'int' );
+
+		}
+
+		properties.returnsNode = this.params[ this.params.length - 1 ].call( inputs, builder.addStack(), builder );
+		properties.stackNode = builder.removeStack();
+
+		return properties;
+
+	}
+
+	getNodeType( builder ) {
+
+		const { returnsNode } = this.getProperties( builder );
+
+		return returnsNode ? returnsNode.getNodeType( builder ) : 'void';
+
+	}
+
+	construct( builder ) {
+
+		// construct properties
+
+		this.getProperties( builder );
+
+	}
+
+	generate( builder ) {
+
+		const properties = this.getProperties( builder );
+
+		const context = { tempWrite: false };
+
+		const params = this.params;
+		const stackNode = properties.stackNode;
+
+		const returnsSnippet = properties.returnsNode ? properties.returnsNode.build( builder ) : '';
+
+		for ( let i = 0, l = params.length - 1; i < l; i ++ ) {
+
+			const param = params[ i ];
+			const property = this.getVarName( i );
+
+			let start = null, end = null, direction = null;
+
+			if ( param.isNode ) {
+
+				start = '0';
+				end = param.generate( builder, 'int' );
+				direction = 'forward';
+
+			} else {
+
+				start = param.start;
+				end = param.end;
+				direction = param.direction;
+
+				if ( typeof start === 'number' ) start = start.toString();
+				else if ( start && start.isNode ) start = start.generate( builder, 'int' );
+
+				if ( typeof end === 'number' ) end = end.toString();
+				else if ( end && end.isNode ) end = end.generate( builder, 'int' );
+
+				if ( start !== undefined && end === undefined ) {
+
+					start = start + ' - 1';
+					end = '0';
+					direction = 'backwards';
+
+				} else if ( end !== undefined && start === undefined ) {
+
+					start = '0';
+					direction = 'forward';
+
+				}
+
+				if ( direction === undefined ) {
+
+					if ( Number( start ) > Number( end ) ) {
+
+						direction = 'backwards';
+
+					} else {
+
+						direction = 'forward';
+
+					}
+
+				}
+
+			}
+
+			const internalParam = { start, end, direction };
+
+			//
+
+			const startSnippet = internalParam.start;
+			const endSnippet = internalParam.end;
+
+			let declarationSnippet = '';
+			let conditionalSnippet = '';
+			let updateSnippet = '';
+
+			declarationSnippet += builder.getVar( 'int', property ) + ' = ' + startSnippet;
+
+			if ( internalParam.direction === 'backwards' ) {
+
+				conditionalSnippet += property + ' >= ' + endSnippet;
+				updateSnippet += property + ' --';
+
+			} else {
+
+				// forward
+
+				conditionalSnippet += property + ' < ' + endSnippet;
+				updateSnippet += property + ' ++';
+
+			}
+
+			const forSnippet = `for ( ${ declarationSnippet }; ${ conditionalSnippet }; ${ updateSnippet } )`;
+
+			builder.addFlowCode( ( i === 0 ? '\n' : '' ) + builder.tab + forSnippet + ' {\n\n' ).addFlowTab();
+
+		}
+
+		const stackSnippet = contextNode( stackNode, context ).build( builder, 'void' );
+
+		builder.removeFlowTab().addFlowCode( '\n' + builder.tab + stackSnippet );
+
+		for ( let i = 0, l = this.params.length - 1; i < l; i ++ ) {
+
+			builder.addFlowCode( ( i === 0 ? '' : builder.tab ) + '}\n\n' ).removeFlowTab();
+
+		}
+
+		builder.addFlowTab();
+
+		return returnsSnippet;
+
+	}
+
+}
+
+export default LoopNode;
+
+export const loop = ( ...params ) => nodeObject( new LoopNode( nodeArray( params, 'int' ) ) );
+
+addNodeElement( 'loop', ( returns, ...params ) => bypass( returns, loop( ...params ) ) );
+
+addNodeClass( LoopNode );