@plastic-software/three 0.179.0 → 0.180.0

package/src/nodes/tsl/TSLCore.js

@@ -13,6 +13,8 @@ let currentStack = null;
 
 const NodeElements = new Map();
 
+// Extend Node Class for TSL using prototype
+
 export function addMethodChaining( name, nodeElement ) {
 
 	if ( NodeElements.has( name ) ) {
@@ -26,152 +28,274 @@ export function addMethodChaining( name, nodeElement ) {
 
 	NodeElements.set( name, nodeElement );
 
+	if ( name !== 'assign' ) {
+
+		// Changing Node prototype to add method chaining
+
+		Node.prototype[ name ] = function ( ...params ) {
+
+			//if ( name === 'toVarIntent' ) return this;
+
+			return this.isStackNode ? this.add( nodeElement( ...params ) ) : nodeElement( this, ...params );
+
+		};
+
+		// Adding assign method chaining
+
+		Node.prototype[ name + 'Assign' ] = function ( ...params ) {
+
+			return this.isStackNode ? this.assign( params[ 0 ], nodeElement( ...params ) ) : this.assign( nodeElement( this, ...params ) );
+
+		};
+
+	}
+
 }
 
 const parseSwizzle = ( props ) => props.replace( /r|s/g, 'x' ).replace( /g|t/g, 'y' ).replace( /b|p/g, 'z' ).replace( /a|q/g, 'w' );
 const parseSwizzleAndSort = ( props ) => parseSwizzle( props ).split( '' ).sort().join( '' );
 
-const shaderNodeHandler = {
+Node.prototype.assign = function ( ...params ) {
+
+	if ( this.isStackNode !== true ) {
 
-	setup( NodeClosure, params ) {
+		if ( currentStack !== null ) {
 
-		const inputs = params.shift();
+			currentStack.assign( this, ...params );
 
-		return NodeClosure( nodeObjects( inputs ), ...params );
+		} else {
+
+			console.error( 'THREE.TSL: No stack defined for assign operation. Make sure the assign is inside a Fn().' );
 
-	},
+		}
 
-	get( node, prop, nodeObj ) {
+		return this;
 
-		if ( typeof prop === 'string' && node[ prop ] === undefined ) {
+	} else {
 
-			if ( node.isStackNode !== true && prop === 'assign' ) {
+		const nodeElement = NodeElements.get( 'assign' );
 
-				return ( ...params ) => {
+		return this.add( nodeElement( ...params ) );
 
-					currentStack.assign( nodeObj, ...params );
+	}
 
-					return nodeObj;
+};
 
-				};
+Node.prototype.toVarIntent = function () {
+
+	return this;
+
+};
+
+Node.prototype.get = function ( value ) {
+
+	return new MemberNode( this, value );
+
+};
+
+// Cache prototype for TSL
 
-			} else if ( NodeElements.has( prop ) ) {
+const proto = {};
 
-				const nodeElement = NodeElements.get( prop );
+// Set swizzle properties for xyzw, rgba, and stpq.
 
-				return node.isStackNode ? ( ...params ) => nodeObj.add( nodeElement( ...params ) ) : ( ...params ) => nodeElement( nodeObj, ...params );
+function setProtoSwizzle( property, altA, altB ) {
 
-			} else if ( prop === 'toVarIntent' ) {
+	// swizzle properties
 
-				return () => nodeObj;
+	proto[ property ] = proto[ altA ] = proto[ altB ] = {
 
-			} else if ( prop === 'self' ) {
+		get() {
 
-				return node;
+			this._cache = this._cache || {};
 
-			} 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 ) );
+			let split = this._cache[ property ];
 
-				return node.isStackNode ? ( ...params ) => nodeObj.assign( params[ 0 ], nodeElement( ...params ) ) : ( ...params ) => nodeObj.assign( nodeElement( nodeObj, ...params ) );
+			if ( split === undefined ) {
 
-			} else if ( /^[xyzwrgbastpq]{1,4}$/.test( prop ) === true ) {
+				split = new SplitNode( this, property );
 
-				// accessing properties ( swizzle )
+				this._cache[ property ] = split;
 
-				prop = parseSwizzle( prop );
+			}
+
+			return split;
+
+		},
+
+		set( value ) {
+
+			this[ property ].assign( nodeObject( value ) );
+
+		}
+
+	};
+
+	// set properties ( swizzle ) and sort to xyzw sequence
+
+	const propUpper = property.toUpperCase();
+	const altAUpper = altA.toUpperCase();
+	const altBUpper = altB.toUpperCase();
+
+	// Set methods for swizzle properties
+
+	Node.prototype[ 'set' + propUpper ] = Node.prototype[ 'set' + altAUpper ] = Node.prototype[ 'set' + altBUpper ] = function ( value ) {
+
+		const swizzle = parseSwizzleAndSort( property );
+
+		return new SetNode( this, swizzle, nodeObject( value ) );
+
+	};
 
-				return nodeObject( new SplitNode( nodeObj, prop ) );
+	// Set methods for flip properties
 
-			} else if ( /^set[XYZWRGBASTPQ]{1,4}$/.test( prop ) === true ) {
+	Node.prototype[ 'flip' + propUpper ] = Node.prototype[ 'flip' + altAUpper ] = Node.prototype[ 'flip' + altBUpper ] = function () {
 
-				// set properties ( swizzle ) and sort to xyzw sequence
+		const swizzle = parseSwizzleAndSort( property );
 
-				prop = parseSwizzleAndSort( prop.slice( 3 ).toLowerCase() );
+		return new FlipNode( this, swizzle );
 
-				return ( value ) => nodeObject( new SetNode( node, prop, nodeObject( value ) ) );
+	};
 
-			} else if ( /^flip[XYZWRGBASTPQ]{1,4}$/.test( prop ) === true ) {
+}
 
-				// set properties ( swizzle ) and sort to xyzw sequence
+const swizzleA = [ 'x', 'y', 'z', 'w' ];
+const swizzleB = [ 'r', 'g', 'b', 'a' ];
+const swizzleC = [ 's', 't', 'p', 'q' ];
 
-				prop = parseSwizzleAndSort( prop.slice( 4 ).toLowerCase() );
+for ( let a = 0; a < 4; a ++ ) {
 
-				return () => nodeObject( new FlipNode( nodeObject( node ), prop ) );
+	let prop = swizzleA[ a ];
+	let altA = swizzleB[ a ];
+	let altB = swizzleC[ a ];
 
-			} else if ( prop === 'width' || prop === 'height' || prop === 'depth' ) {
+	setProtoSwizzle( prop, altA, altB );
 
-				// accessing property
+	for ( let b = 0; b < 4; b ++ ) {
 
-				if ( prop === 'width' ) prop = 'x';
-				else if ( prop === 'height' ) prop = 'y';
-				else if ( prop === 'depth' ) prop = 'z';
+		prop = swizzleA[ a ] + swizzleA[ b ];
+		altA = swizzleB[ a ] + swizzleB[ b ];
+		altB = swizzleC[ a ] + swizzleC[ b ];
 
-				return nodeObject( new SplitNode( node, prop ) );
+		setProtoSwizzle( prop, altA, altB );
 
-			} else if ( /^\d+$/.test( prop ) === true ) {
+		for ( let c = 0; c < 4; c ++ ) {
 
-				// accessing array
+			prop = swizzleA[ a ] + swizzleA[ b ] + swizzleA[ c ];
+			altA = swizzleB[ a ] + swizzleB[ b ] + swizzleB[ c ];
+			altB = swizzleC[ a ] + swizzleC[ b ] + swizzleC[ c ];
 
-				return nodeObject( new ArrayElementNode( nodeObj, new ConstNode( Number( prop ), 'uint' ) ) );
+			setProtoSwizzle( prop, altA, altB );
 
-			} else if ( /^get$/.test( prop ) === true ) {
+			for ( let d = 0; d < 4; d ++ ) {
 
-				// accessing properties
+				prop = swizzleA[ a ] + swizzleA[ b ] + swizzleA[ c ] + swizzleA[ d ];
+				altA = swizzleB[ a ] + swizzleB[ b ] + swizzleB[ c ] + swizzleB[ d ];
+				altB = swizzleC[ a ] + swizzleC[ b ] + swizzleC[ c ] + swizzleC[ d ];
 
-				return ( value ) => nodeObject( new MemberNode( nodeObj, value ) );
+				setProtoSwizzle( prop, altA, altB );
 
 			}
 
 		}
 
-		return Reflect.get( node, prop, nodeObj );
+	}
+
+}
+
+// Set/get static properties for array elements (0-31).
+
+for ( let i = 0; i < 32; i ++ ) {
 
-	},
+	proto[ i ] = {
 
-	set( node, prop, value, nodeObj ) {
+		get() {
 
-		if ( typeof prop === 'string' && node[ prop ] === undefined ) {
+			this._cache = this._cache || {};
 
-			// setting properties
+			//
 
-			if ( /^[xyzwrgbastpq]{1,4}$/.test( prop ) === true || prop === 'width' || prop === 'height' || prop === 'depth' || /^\d+$/.test( prop ) === true ) {
+			let element = this._cache[ i ];
 
-				nodeObj[ prop ].assign( value );
+			if ( element === undefined ) {
 
-				return true;
+				element = new ArrayElementNode( this, new ConstNode( i, 'uint' ) );
+
+				this._cache[ i ] = element;
 
 			}
 
+			return element;
+
+		},
+
+		set( value ) {
+
+			this[ i ].assign( nodeObject( value ) );
+
 		}
 
-		return Reflect.set( node, prop, value, nodeObj );
+	};
 
-	}
+}
 
-};
+/*
+// Set properties for width, height, and depth.
 
-const nodeObjectsCacheMap = new WeakMap();
-const nodeBuilderFunctionsCacheMap = new WeakMap();
+function setProtoProperty( property, target ) {
 
-const ShaderNodeObject = function ( obj, altType = null ) {
+	proto[ property ] = {
 
-	const type = getValueType( obj );
+		get() {
 
-	if ( type === 'node' ) {
+			this._cache = this._cache || {};
+
+			//
+
+			let split = this._cache[ target ];
+
+			if ( split === undefined ) {
 
-		let nodeObject = nodeObjectsCacheMap.get( obj );
+				split = new SplitNode( this, target );
 
-		if ( nodeObject === undefined ) {
+				this._cache[ target ] = split;
 
-			nodeObject = new Proxy( obj, shaderNodeHandler );
+			}
+
+			return split;
+
+		},
+
+		set( value ) {
 
-			nodeObjectsCacheMap.set( obj, nodeObject );
-			nodeObjectsCacheMap.set( nodeObject, nodeObject );
+			this[ target ].assign( nodeObject( value ) );
 
 		}
 
-		return nodeObject;
+	};
+
+}
+
+setProtoProperty( 'width', 'x' );
+setProtoProperty( 'height', 'y' );
+setProtoProperty( 'depth', 'z' );
+*/
+
+Object.defineProperties( Node.prototype, proto );
+
+// --- FINISH ---
+
+const nodeBuilderFunctionsCacheMap = new WeakMap();
+
+const ShaderNodeObject = function ( obj, altType = null ) {
+
+	const type = getValueType( obj );
+
+	if ( type === 'node' ) {
+
+		return obj;
 
 	} else if ( ( altType === null && ( type === 'float' || type === 'boolean' ) ) || ( type && type !== 'shader' && type !== 'string' ) ) {
 
@@ -322,12 +446,12 @@ const ShaderNodeImmutable = function ( NodeClass, ...params ) {
 
 class ShaderCallNodeInternal extends Node {
 
-	constructor( shaderNode, inputNodes ) {
+	constructor( shaderNode, rawInputs ) {
 
 		super();
 
 		this.shaderNode = shaderNode;
-		this.inputNodes = inputNodes;
+		this.rawInputs = rawInputs;
 
 		this.isShaderCallNodeInternal = true;
 
@@ -347,7 +471,7 @@ class ShaderCallNodeInternal extends Node {
 
 	call( builder ) {
 
-		const { shaderNode, inputNodes } = this;
+		const { shaderNode, rawInputs } = this;
 
 		const properties = builder.getNodeProperties( shaderNode );
 
@@ -392,40 +516,48 @@ class ShaderCallNodeInternal extends Node {
 
 			builder.addInclude( functionNode );
 
-			result = nodeObject( functionNode.call( inputNodes ) );
+			//
 
-		} else {
+			const inputs = rawInputs ? getLayoutParameters( rawInputs ) : null;
 
-			let inputs = inputNodes;
+			result = nodeObject( functionNode.call( inputs ) );
 
-			if ( Array.isArray( inputs ) ) {
+		} else {
 
-				// If inputs is an array, we need to convert it to a Proxy
-				// so we can call TSL functions using the syntax `Fn( ( { r, g, b } ) => { ... } )`
-				// and call through `fn( 0, 1, 0 )` or `fn( { r: 0, g: 1, b: 0 } )`
+			const secureNodeBuilder = new Proxy( builder, {
 
-				let index = 0;
+				get: ( target, property, receiver ) => {
 
-				inputs = new Proxy( inputs, {
-					get: ( target, property, receiver ) => {
+					let value;
 
-						if ( target[ property ] === undefined ) {
+					if ( Symbol.iterator === property ) {
 
-							return target[ index ++ ];
+						value = function* () {
 
-						} else {
+							yield undefined;
 
-							return Reflect.get( target, property, receiver );
+						};
 
-						}
+					} else {
+
+						value = Reflect.get( target, property, receiver );
 
 					}
-				} );
 
-			}
+					return value;
+
+				}
+
+			} );
+
+			//
+
+			const inputs = rawInputs ? getProxyParameters( rawInputs ) : null;
+
+			const hasParameters = Array.isArray( rawInputs ) ? rawInputs.length > 0 : rawInputs !== null;
 
 			const jsFunc = shaderNode.jsFunc;
-			const outputNode = inputs !== null || jsFunc.length > 1 ? jsFunc( inputs || [], builder ) : jsFunc( builder );
+			const outputNode = hasParameters || jsFunc.length > 1 ? jsFunc( inputs, secureNodeBuilder ) : jsFunc( secureNodeBuilder );
 
 			result = nodeObject( outputNode );
 
@@ -528,6 +660,110 @@ class ShaderCallNodeInternal extends Node {
 
 }
 
+function getLayoutParameters( params ) {
+
+	let output;
+
+	nodeObjects( params );
+
+	const isArrayAsParameter = params[ 0 ] && ( params[ 0 ].isNode || Object.getPrototypeOf( params[ 0 ] ) !== Object.prototype );
+
+	if ( isArrayAsParameter ) {
+
+		output = [ ...params ];
+
+	} else {
+
+		output = params[ 0 ];
+
+	}
+
+	return output;
+
+}
+
+function getProxyParameters( params ) {
+
+	let index = 0;
+
+	nodeObjects( params );
+
+	return new Proxy( params, {
+
+		get: ( target, property, receiver ) => {
+
+			let value;
+
+			if ( property === 'length' ) {
+
+				value = params.length;
+
+				return value;
+
+			}
+
+			if ( Symbol.iterator === property ) {
+
+				value = function* () {
+
+					for ( const inputNode of params ) {
+
+						yield nodeObject( inputNode );
+
+					}
+
+				};
+
+			} else {
+
+				if ( params.length > 0 ) {
+
+					if ( Object.getPrototypeOf( params[ 0 ] ) === Object.prototype ) {
+
+						const objectTarget = params[ 0 ];
+
+						if ( objectTarget[ property ] === undefined ) {
+
+							value = objectTarget[ index ++ ];
+
+						} else {
+
+							value = Reflect.get( objectTarget, property, receiver );
+
+						}
+
+					} else if ( params[ 0 ] instanceof Node ) {
+
+						if ( params[ property ] === undefined ) {
+
+							value = params[ index ++ ];
+
+						} else {
+
+							value = Reflect.get( params, property, receiver );
+
+						}
+
+					}
+
+				} else {
+
+					value = Reflect.get( target, property, receiver );
+
+				}
+
+				value = nodeObject( value );
+
+			}
+
+			return value;
+
+		}
+
+	} );
+
+}
+
 class ShaderNodeInternal extends Node {
 
 	constructor( jsFunc, nodeType ) {
@@ -551,11 +787,9 @@ class ShaderNodeInternal extends Node {
 
 	}
 
-	call( inputs = null ) {
+	call( rawInputs = null ) {
 
-		nodeObjects( inputs );
-
-		return nodeObject( new ShaderCallNodeInternal( this, inputs ) );
+		return nodeObject( new ShaderCallNodeInternal( this, rawInputs ) );
 
 	}
 
@@ -611,7 +845,25 @@ const ConvertType = function ( type, cacheMap = null ) {
 
 	return ( ...params ) => {
 
-		if ( params.length === 0 || ( ! [ 'bool', 'float', 'int', 'uint' ].includes( type ) && params.every( param => typeof param !== 'object' ) ) ) {
+		for ( const param of params ) {
+
+			if ( param === undefined ) {
+
+				console.error( `THREE.TSL: Invalid parameter for the type "${ type }".` );
+
+				return nodeObject( new ConstNode( 0, type ) );
+
+			}
+
+		}
+
+		if ( params.length === 0 || ( ! [ 'bool', 'float', 'int', 'uint' ].includes( type ) && params.every( param => {
+
+			const paramType = typeof param;
+
+			return paramType !== 'object' && paramType !== 'function';
+
+		} ) ) ) {
 
 			params = [ getValueFromType( type, ...params ) ];
 
@@ -650,7 +902,7 @@ export const getConstNodeType = ( value ) => ( value !== undefined && value !==
 
 export function ShaderNode( jsFunc, nodeType ) {
 
-	return new Proxy( new ShaderNodeInternal( jsFunc, nodeType ), shaderNodeHandler );
+	return new ShaderNodeInternal( jsFunc, nodeType );
 
 }
 
@@ -664,119 +916,147 @@ export const nodeProxyIntent = ( NodeClass, scope = null, factor = null, setting
 
 let fnId = 0;
 
-export const Fn = ( jsFunc, layout = null ) => {
+class FnNode extends Node {
 
-	let nodeType = null;
+	constructor( jsFunc, layout = null ) {
 
-	if ( layout !== null ) {
-
-		if ( typeof layout === 'object' ) {
+		super();
 
-			nodeType = layout.return;
+		let nodeType = null;
 
-		} else {
+		if ( layout !== null ) {
 
-			if ( typeof layout === 'string' ) {
+			if ( typeof layout === 'object' ) {
 
-				nodeType = layout;
+				nodeType = layout.return;
 
 			} else {
 
-				console.error( 'THREE.TSL: Invalid layout type.' );
+				if ( typeof layout === 'string' ) {
+
+					nodeType = layout;
+
+				} else {
+
+					console.error( 'THREE.TSL: Invalid layout type.' );
+
+				}
+
+				layout = null;
 
 			}
 
-			layout = null;
+		}
+
+		this.shaderNode = new ShaderNode( jsFunc, nodeType );
+
+		if ( layout !== null ) {
+
+			this.setLayout( layout );
 
 		}
 
+		this.isFn = true;
+
 	}
 
-	const shaderNode = new ShaderNode( jsFunc, nodeType );
+	setLayout( layout ) {
 
-	const fn = ( ...params ) => {
+		const nodeType = this.shaderNode.nodeType;
 
-		let inputs;
+		if ( typeof layout.inputs !== 'object' ) {
 
-		nodeObjects( params );
+			const fullLayout = {
+				name: 'fn' + fnId ++,
+				type: nodeType,
+				inputs: []
+			};
 
-		const isArrayAsParameter = params[ 0 ] && ( params[ 0 ].isNode || Object.getPrototypeOf( params[ 0 ] ) !== Object.prototype );
+			for ( const name in layout ) {
 
-		if ( isArrayAsParameter ) {
+				if ( name === 'return' ) continue;
 
-			inputs = [ ...params ];
+				fullLayout.inputs.push( {
+					name: name,
+					type: layout[ name ]
+				} );
 
-		} else {
+			}
 
-			inputs = params[ 0 ];
+			layout = fullLayout;
 
 		}
 
-		const fnCall = shaderNode.call( inputs );
+		this.shaderNode.setLayout( layout );
+
+		return this;
+
+	}
+
+	getNodeType( builder ) {
+
+		return this.shaderNode.getNodeType( builder ) || 'float';
+
+	}
+
+	call( ...params ) {
 
-		if ( nodeType === 'void' ) fnCall.toStack();
+		const fnCall = this.shaderNode.call( params );
+
+		if ( this.shaderNode.nodeType === 'void' ) fnCall.toStack();
 
 		return fnCall.toVarIntent();
 
-	};
+	}
 
-	fn.shaderNode = shaderNode;
-	fn.id = shaderNode.id;
+	once( subBuilds = null ) {
 
-	fn.isFn = true;
+		this.shaderNode.once = true;
+		this.shaderNode.subBuilds = subBuilds;
 
-	fn.getNodeType = ( ...params ) => shaderNode.getNodeType( ...params );
-	fn.getCacheKey = ( ...params ) => shaderNode.getCacheKey( ...params );
+		return this;
 
-	fn.setLayout = ( layout ) => {
+	}
 
-		shaderNode.setLayout( layout );
+	generate( builder ) {
 
-		return fn;
+		const type = this.getNodeType( builder );
 
-	};
+		console.error( 'THREE.TSL: "Fn()" was declared but not invoked. Try calling it like "Fn()( ...params )".' );
 
-	fn.once = ( subBuilds = null ) => {
+		return builder.generateConst( type );
 
-		shaderNode.once = true;
-		shaderNode.subBuilds = subBuilds;
+	}
 
-		return fn;
+}
 
-	};
+export function Fn( jsFunc, layout = null ) {
 
-	if ( layout !== null ) {
+	const instance = new FnNode( jsFunc, layout );
 
-		if ( typeof layout.inputs !== 'object' ) {
+	return new Proxy( () => {}, {
 
-			const fullLayout = {
-				name: 'fn' + fnId ++,
-				type: nodeType,
-				inputs: []
-			};
+		apply( target, thisArg, params ) {
 
-			for ( const name in layout ) {
+			return instance.call( ...params );
 
-				if ( name === 'return' ) continue;
+		},
 
-				fullLayout.inputs.push( {
-					name: name,
-					type: layout[ name ]
-				} );
+		get( target, prop, receiver ) {
 
-			}
+			return Reflect.get( instance, prop, receiver );
 
-			layout = fullLayout;
+		},
 
-		}
+		set( target, prop, value, receiver ) {
 
-		fn.setLayout( layout );
+			return Reflect.set( instance, prop, value, receiver );
 
-	}
+		}
 
-	return fn;
+	} );
 
-};
+}
 
 //