super-three 0.177.0 → 0.181.0

package/src/nodes/tsl/TSLCore.js

@@ -8,16 +8,19 @@ import FlipNode from '../utils/FlipNode.js';
 import ConstNode from '../core/ConstNode.js';
 import MemberNode from '../utils/MemberNode.js';
 import { getValueFromType, getValueType } from '../core/NodeUtils.js';
+import { warn, error } from '../../utils.js';
 
 let currentStack = null;
 
 const NodeElements = new Map();
 
+// Extend Node Class for TSL using prototype
+
 export function addMethodChaining( name, nodeElement ) {
 
 	if ( NodeElements.has( name ) ) {
 
-		console.warn( `THREE.TSL: Redefinition of method chaining '${ name }'.` );
+		warn( `TSL: Redefinition of method chaining '${ name }'.` );
 		return;
 
 	}
@@ -26,148 +29,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.addToStack( 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 ) {
+
+		if ( currentStack !== null ) {
+
+			currentStack.assign( this, ...params );
+
+		} else {
+
+			error( 'TSL: No stack defined for assign operation. Make sure the assign is inside a Fn().' );
 
-	setup( NodeClosure, params ) {
+		}
+
+		return this;
 
-		const inputs = params.shift();
+	} else {
 
-		return NodeClosure( nodeObjects( inputs ), ...params );
+		const nodeElement = NodeElements.get( 'assign' );
 
-	},
+		return this.addToStack( nodeElement( ...params ) );
 
-	get( node, prop, nodeObj ) {
+	}
 
-		if ( typeof prop === 'string' && node[ prop ] === undefined ) {
+};
 
-			if ( node.isStackNode !== true && prop === 'assign' ) {
+Node.prototype.toVarIntent = function () {
 
-				return ( ...params ) => {
+	return this;
 
-					currentStack.assign( nodeObj, ...params );
+};
 
-					return nodeObj;
+Node.prototype.get = function ( value ) {
 
-				};
+	return new MemberNode( this, value );
+
+};
+
+// Cache prototype for TSL
+
+const proto = {};
+
+// Set swizzle properties for xyzw, rgba, and stpq.
+
+function setProtoSwizzle( property, altA, altB ) {
+
+	// swizzle properties
+
+	proto[ property ] = proto[ altA ] = proto[ altB ] = {
+
+		get() {
 
-			} else if ( NodeElements.has( prop ) ) {
+			this._cache = this._cache || {};
 
-				const nodeElement = NodeElements.get( prop );
+			//
 
-				return node.isStackNode ? ( ...params ) => nodeObj.add( nodeElement( ...params ) ) : ( ...params ) => nodeElement( nodeObj, ...params );
+			let split = this._cache[ property ];
 
-			} else if ( prop === 'self' ) {
+			if ( split === undefined ) {
 
-				return node;
+				split = new SplitNode( this, property );
 
-			} else if ( prop.endsWith( 'Assign' ) && NodeElements.has( prop.slice( 0, prop.length - 'Assign'.length ) ) ) {
+				this._cache[ property ] = split;
 
-				const nodeElement = NodeElements.get( prop.slice( 0, prop.length - 'Assign'.length ) );
+			}
+
+			return split;
+
+		},
+
+		set( value ) {
+
+			this[ property ].assign( nodeObject( value ) );
 
-				return node.isStackNode ? ( ...params ) => nodeObj.assign( params[ 0 ], nodeElement( ...params ) ) : ( ...params ) => nodeObj.assign( nodeElement( nodeObj, ...params ) );
+		}
 
-			} else if ( /^[xyzwrgbastpq]{1,4}$/.test( prop ) === true ) {
+	};
 
-				// accessing properties ( swizzle )
+	// set properties ( swizzle ) and sort to xyzw sequence
 
-				prop = parseSwizzle( prop );
+	const propUpper = property.toUpperCase();
+	const altAUpper = altA.toUpperCase();
+	const altBUpper = altB.toUpperCase();
 
-				return nodeObject( new SplitNode( nodeObj, prop ) );
+	// Set methods for swizzle properties
 
-			} else if ( /^set[XYZWRGBASTPQ]{1,4}$/.test( prop ) === true ) {
+	Node.prototype[ 'set' + propUpper ] = Node.prototype[ 'set' + altAUpper ] = Node.prototype[ 'set' + altBUpper ] = function ( value ) {
 
-				// set properties ( swizzle ) and sort to xyzw sequence
+		const swizzle = parseSwizzleAndSort( property );
 
-				prop = parseSwizzleAndSort( prop.slice( 3 ).toLowerCase() );
+		return new SetNode( this, swizzle, nodeObject( value ) );
 
-				return ( value ) => nodeObject( new SetNode( node, prop, nodeObject( value ) ) );
+	};
 
-			} else if ( /^flip[XYZWRGBASTPQ]{1,4}$/.test( prop ) === true ) {
+	// Set methods for flip properties
 
-				// set properties ( swizzle ) and sort to xyzw sequence
+	Node.prototype[ 'flip' + propUpper ] = Node.prototype[ 'flip' + altAUpper ] = Node.prototype[ 'flip' + altBUpper ] = function () {
 
-				prop = parseSwizzleAndSort( prop.slice( 4 ).toLowerCase() );
+		const swizzle = parseSwizzleAndSort( property );
 
-				return () => nodeObject( new FlipNode( nodeObject( node ), prop ) );
+		return new FlipNode( this, swizzle );
 
-			} else if ( prop === 'width' || prop === 'height' || prop === 'depth' ) {
+	};
 
-				// accessing property
+}
 
-				if ( prop === 'width' ) prop = 'x';
-				else if ( prop === 'height' ) prop = 'y';
-				else if ( prop === 'depth' ) prop = 'z';
+const swizzleA = [ 'x', 'y', 'z', 'w' ];
+const swizzleB = [ 'r', 'g', 'b', 'a' ];
+const swizzleC = [ 's', 't', 'p', 'q' ];
 
-				return nodeObject( new SplitNode( node, prop ) );
+for ( let a = 0; a < 4; a ++ ) {
 
-			} else if ( /^\d+$/.test( prop ) === true ) {
+	let prop = swizzleA[ a ];
+	let altA = swizzleB[ a ];
+	let altB = swizzleC[ a ];
 
-				// accessing array
+	setProtoSwizzle( prop, altA, altB );
 
-				return nodeObject( new ArrayElementNode( nodeObj, new ConstNode( Number( prop ), 'uint' ) ) );
+	for ( let b = 0; b < 4; b ++ ) {
 
-			} else if ( /^get$/.test( prop ) === true ) {
+		prop = swizzleA[ a ] + swizzleA[ b ];
+		altA = swizzleB[ a ] + swizzleB[ b ];
+		altB = swizzleC[ a ] + swizzleC[ b ];
 
-				// accessing properties
+		setProtoSwizzle( prop, altA, altB );
 
-				return ( value ) => nodeObject( new MemberNode( nodeObj, value ) );
+		for ( let c = 0; c < 4; c ++ ) {
+
+			prop = swizzleA[ a ] + swizzleA[ b ] + swizzleA[ c ];
+			altA = swizzleB[ a ] + swizzleB[ b ] + swizzleB[ c ];
+			altB = swizzleC[ a ] + swizzleC[ b ] + swizzleC[ c ];
+
+			setProtoSwizzle( prop, altA, altB );
+
+			for ( let d = 0; d < 4; d ++ ) {
+
+				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 ];
+
+				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 ++ ) {
 
-	set( node, prop, value, nodeObj ) {
+	proto[ i ] = {
 
-		if ( typeof prop === 'string' && node[ prop ] === undefined ) {
+		get() {
 
-			// setting properties
+			this._cache = this._cache || {};
 
-			if ( /^[xyzwrgbastpq]{1,4}$/.test( prop ) === true || prop === 'width' || prop === 'height' || prop === 'depth' || /^\d+$/.test( prop ) === true ) {
+			//
 
-				nodeObj[ prop ].assign( value );
+			let element = this._cache[ i ];
 
-				return true;
+			if ( element === undefined ) {
+
+				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 nodeObject = nodeObjectsCacheMap.get( obj );
+			let split = this._cache[ target ];
 
-		if ( nodeObject === undefined ) {
+			if ( split === undefined ) {
+
+				split = new SplitNode( this, target );
+
+				this._cache[ target ] = split;
+
+			}
 
-			nodeObject = new Proxy( obj, shaderNodeHandler );
+			return split;
 
-			nodeObjectsCacheMap.set( obj, nodeObject );
-			nodeObjectsCacheMap.set( nodeObject, nodeObject );
+		},
+
+		set( value ) {
+
+			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' ) ) {
 
@@ -175,7 +304,7 @@ const ShaderNodeObject = function ( obj, altType = null ) {
 
 	} else if ( type === 'shader' ) {
 
-		return Fn( obj );
+		return obj.isFn ? obj : Fn( obj );
 
 	}
 
@@ -211,7 +340,28 @@ const ShaderNodeArray = function ( array, altType = null ) {
 
 const ShaderNodeProxy = function ( NodeClass, scope = null, factor = null, settings = null ) {
 
-	const assignNode = ( node ) => nodeObject( settings !== null ? Object.assign( node, settings ) : node );
+	function assignNode( node ) {
+
+		if ( settings !== null ) {
+
+			node = nodeObject( Object.assign( node, settings ) );
+
+			if ( settings.intent === true ) {
+
+				node = node.toVarIntent();
+
+			}
+
+		} else {
+
+			node = nodeObject( node );
+
+		}
+
+		return node;
+
+
+	}
 
 	let fn, name = scope, minParams, maxParams;
 
@@ -224,13 +374,13 @@ const ShaderNodeProxy = function ( NodeClass, scope = null, factor = null, setti
 
 		if ( minParams !== undefined && params.length < minParams ) {
 
-			console.error( `THREE.TSL: "${ tslName }" parameter length is less than minimum required.` );
+			error( `TSL: "${ tslName }" parameter length is less than minimum required.` );
 
 			return params.concat( new Array( minParams - params.length ).fill( 0 ) );
 
 		} else if ( maxParams !== undefined && params.length > maxParams ) {
 
-			console.error( `THREE.TSL: "${ tslName }" parameter length exceeds limit.` );
+			error( `TSL: "${ tslName }" parameter length exceeds limit.` );
 
 			return params.slice( 0, maxParams );
 
@@ -297,12 +447,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;
 
@@ -314,6 +464,12 @@ class ShaderCallNodeInternal extends Node {
 
 	}
 
+	getElementType( builder ) {
+
+		return this.getOutputNode( builder ).getElementType( builder );
+
+	}
+
 	getMemberType( builder, name ) {
 
 		return this.getOutputNode( builder ).getMemberType( builder, name );
@@ -322,19 +478,27 @@ class ShaderCallNodeInternal extends Node {
 
 	call( builder ) {
 
-		const { shaderNode, inputNodes } = this;
+		const { shaderNode, rawInputs } = this;
 
 		const properties = builder.getNodeProperties( shaderNode );
-		const onceNS = shaderNode.namespace && shaderNode.namespace === builder.namespace ? builder.getNamespace( 'once' ) : 'once';
 
-		if ( properties[ onceNS ] ) {
+		const subBuild = builder.getClosestSubBuild( shaderNode.subBuilds ) || '';
+		const subBuildProperty = subBuild || 'default';
 
-			return properties[ onceNS ];
+		if ( properties[ subBuildProperty ] ) {
+
+			return properties[ subBuildProperty ];
 
 		}
 
 		//
 
+		const previousSubBuildFn = builder.subBuildFn;
+		const previousFnCall = builder.fnCall;
+
+		builder.subBuildFn = subBuild;
+		builder.fnCall = this;
+
 		let result = null;
 
 		if ( shaderNode.layout ) {
@@ -361,20 +525,59 @@ class ShaderCallNodeInternal extends Node {
 
 			builder.addInclude( functionNode );
 
-			result = nodeObject( functionNode.call( inputNodes ) );
+			//
+
+			const inputs = rawInputs ? getLayoutParameters( rawInputs ) : null;
+
+			result = nodeObject( functionNode.call( inputs ) );
 
 		} else {
 
+			const secureNodeBuilder = new Proxy( builder, {
+
+				get: ( target, property, receiver ) => {
+
+					let value;
+
+					if ( Symbol.iterator === property ) {
+
+						value = function* () {
+
+							yield undefined;
+
+						};
+
+					} 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 = inputNodes !== null || jsFunc.length > 1 ? jsFunc( inputNodes || [], builder ) : jsFunc( builder );
+			const outputNode = hasParameters || jsFunc.length > 1 ? jsFunc( inputs, secureNodeBuilder ) : jsFunc( secureNodeBuilder );
 
 			result = nodeObject( outputNode );
 
 		}
 
+		builder.subBuildFn = previousSubBuildFn;
+		builder.fnCall = previousFnCall;
+
 		if ( shaderNode.once ) {
 
-			properties[ onceNS ] = result;
+			properties[ subBuildProperty ] = result;
 
 		}
 
@@ -395,11 +598,12 @@ class ShaderCallNodeInternal extends Node {
 	getOutputNode( builder ) {
 
 		const properties = builder.getNodeProperties( this );
-		const outputNamespace = builder.getOutputNamespace();
+		const subBuildOutput = builder.getSubBuildOutput( this );
 
-		properties[ outputNamespace ] = properties[ outputNamespace ] || this.setupOutput( builder );
+		properties[ subBuildOutput ] = properties[ subBuildOutput ] || this.setupOutput( builder );
+		properties[ subBuildOutput ].subBuild = builder.getClosestSubBuild( this );
 
-		return properties[ outputNamespace ];
+		return properties[ subBuildOutput ];
 
 	}
 
@@ -410,23 +614,49 @@ class ShaderCallNodeInternal extends Node {
 		const buildStage = builder.getBuildStage();
 		const properties = builder.getNodeProperties( this );
 
-		const outputNamespace = builder.getOutputNamespace();
+		const subBuildOutput = builder.getSubBuildOutput( this );
 		const outputNode = this.getOutputNode( builder );
 
+		const previousFnCall = builder.fnCall;
+
+		builder.fnCall = this;
+
 		if ( buildStage === 'setup' ) {
 
-			const initializedNamespace = builder.getNamespace( 'initialized' );
+			const subBuildInitialized = builder.getSubBuildProperty( 'initialized', this );
+
+			if ( properties[ subBuildInitialized ] !== true ) {
+
+				properties[ subBuildInitialized ] = true;
+
+				properties[ subBuildOutput ] = this.getOutputNode( builder );
+				properties[ subBuildOutput ].build( builder );
+
+				// If the shaderNode has subBuilds, add them to the chaining nodes
+				// so they can be built later in the build process.
+
+				if ( this.shaderNode.subBuilds ) {
+
+					for ( const node of builder.chaining ) {
 
-			if ( properties[ initializedNamespace ] !== true ) {
+						const nodeData = builder.getDataFromNode( node, 'any' );
+						nodeData.subBuilds = nodeData.subBuilds || new Set();
 
-				properties[ initializedNamespace ] = true;
+						for ( const subBuild of this.shaderNode.subBuilds ) {
 
-				properties[ outputNamespace ] = this.getOutputNode( builder );
-				properties[ outputNamespace ].build( builder );
+							nodeData.subBuilds.add( subBuild );
+
+						}
+
+						//builder.getDataFromNode( node ).subBuilds = nodeData.subBuilds;
+
+					}
+
+				}
 
 			}
 
-			result = properties[ outputNamespace ];
+			result = properties[ subBuildOutput ];
 
 		} else if ( buildStage === 'analyze' ) {
 
@@ -438,12 +668,118 @@ class ShaderCallNodeInternal extends Node {
 
 		}
 
+		builder.fnCall = previousFnCall;
+
 		return result;
 
 	}
 
 }
 
+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 ) {
@@ -456,7 +792,6 @@ class ShaderNodeInternal extends Node {
 		this.global = true;
 
 		this.once = false;
-		this.namespace = null;
 
 	}
 
@@ -468,11 +803,15 @@ class ShaderNodeInternal extends Node {
 
 	}
 
-	call( inputs = null ) {
+	getLayout() {
 
-		nodeObjects( inputs );
+		return this.layout;
 
-		return nodeObject( new ShaderCallNodeInternal( this, inputs ) );
+	}
+
+	call( rawInputs = null ) {
+
+		return new ShaderCallNodeInternal( this, rawInputs );
 
 	}
 
@@ -524,25 +863,29 @@ const getConstNode = ( value, type ) => {
 
 };
 
-const safeGetNodeType = ( node ) => {
+const ConvertType = function ( type, cacheMap = null ) {
 
-	try {
+	return ( ...params ) => {
 
-		return node.getNodeType();
+		for ( const param of params ) {
 
-	} catch ( _ ) {
+			if ( param === undefined ) {
 
-		return undefined;
+				error( `TSL: Invalid parameter for the type "${ type }".` );
 
-	}
+				return nodeObject( new ConstNode( 0, type ) );
 
-};
+			}
 
-const ConvertType = function ( type, cacheMap = null ) {
+		}
 
-	return ( ...params ) => {
+		if ( params.length === 0 || ( ! [ 'bool', 'float', 'int', 'uint' ].includes( type ) && params.every( param => {
+
+			const paramType = typeof param;
+
+			return paramType !== 'object' && paramType !== 'function';
 
-		if ( params.length === 0 || ( ! [ 'bool', 'float', 'int', 'uint' ].includes( type ) && params.every( param => typeof param !== 'object' ) ) ) {
+		} ) ) ) {
 
 			params = [ getValueFromType( type, ...params ) ];
 
@@ -550,20 +893,20 @@ const ConvertType = function ( type, cacheMap = null ) {
 
 		if ( params.length === 1 && cacheMap !== null && cacheMap.has( params[ 0 ] ) ) {
 
-			return nodeObject( cacheMap.get( params[ 0 ] ) );
+			return nodeObjectIntent( cacheMap.get( params[ 0 ] ) );
 
 		}
 
 		if ( params.length === 1 ) {
 
 			const node = getConstNode( params[ 0 ], type );
-			if ( safeGetNodeType( node ) === type ) return nodeObject( node );
-			return nodeObject( new ConvertNode( node, type ) );
+			if ( node.nodeType === type ) return nodeObjectIntent( node );
+			return nodeObjectIntent( new ConvertNode( node, type ) );
 
 		}
 
 		const nodes = params.map( param => getConstNode( param ) );
-		return nodeObject( new JoinNode( nodes, type ) );
+		return nodeObjectIntent( new JoinNode( nodes, type ) );
 
 	};
 
@@ -581,129 +924,161 @@ 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 );
 
 }
 
 export const nodeObject = ( val, altType = null ) => /* new */ ShaderNodeObject( val, altType );
+export const nodeObjectIntent = ( val, altType = null ) => /* new */ nodeObject( val, altType ).toVarIntent();
 export const nodeObjects = ( val, altType = null ) => new ShaderNodeObjects( val, altType );
 export const nodeArray = ( val, altType = null ) => new ShaderNodeArray( val, altType );
-export const nodeProxy = ( ...params ) => new ShaderNodeProxy( ...params );
-export const nodeImmutable = ( ...params ) => new ShaderNodeImmutable( ...params );
+export const nodeProxy = ( NodeClass, scope = null, factor = null, settings = null ) => new ShaderNodeProxy( NodeClass, scope, factor, settings );
+export const nodeImmutable = ( NodeClass, ...params ) => new ShaderNodeImmutable( NodeClass, ...params );
+export const nodeProxyIntent = ( NodeClass, scope = null, factor = null, settings = {} ) => new ShaderNodeProxy( NodeClass, scope, factor, { ...settings, intent: true } );
 
 let fnId = 0;
 
-export const Fn = ( jsFunc, layout = null ) => {
+class FnNode extends Node {
 
-	let nodeType = null;
+	constructor( jsFunc, layout = null ) {
 
-	if ( layout !== null ) {
+		super();
 
-		if ( typeof layout === 'object' ) {
+		let nodeType = null;
 
-			nodeType = layout.return;
+		if ( layout !== null ) {
 
-		} else {
+			if ( typeof layout === 'object' ) {
 
-			if ( typeof layout === 'string' ) {
-
-				nodeType = layout;
+				nodeType = layout.return;
 
 			} else {
 
-				console.error( 'THREE.TSL: Invalid layout type.' );
+				if ( typeof layout === 'string' ) {
+
+					nodeType = layout;
+
+				} else {
+
+					error( '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 );
 
-		if ( nodeType === 'void' ) fnCall.toStack();
+		return this;
 
-		return fnCall;
+	}
 
-	};
+	getNodeType( builder ) {
 
-	fn.shaderNode = shaderNode;
-	fn.id = shaderNode.id;
+		return this.shaderNode.getNodeType( builder ) || 'float';
 
-	fn.getNodeType = ( ...params ) => shaderNode.getNodeType( ...params );
-	fn.getCacheKey = ( ...params ) => shaderNode.getCacheKey( ...params );
+	}
 
-	fn.setLayout = ( layout ) => {
+	call( ...params ) {
 
-		shaderNode.setLayout( layout );
+		const fnCall = this.shaderNode.call( params );
 
-		return fn;
+		if ( this.shaderNode.nodeType === 'void' ) fnCall.toStack();
 
-	};
+		return fnCall.toVarIntent();
 
-	fn.once = ( namespace = null ) => {
+	}
 
-		shaderNode.once = true;
-		shaderNode.namespace = namespace;
+	once( subBuilds = null ) {
 
-		return fn;
+		this.shaderNode.once = true;
+		this.shaderNode.subBuilds = subBuilds;
 
-	};
+		return this;
 
-	if ( layout !== null ) {
+	}
 
-		if ( typeof layout.inputs !== 'object' ) {
+	generate( builder ) {
 
-			const fullLayout = {
-				name: 'fn' + fnId ++,
-				type: nodeType,
-				inputs: []
-			};
+		const type = this.getNodeType( builder );
 
-			for ( const name in layout ) {
+		error( 'TSL: "Fn()" was declared but not invoked. Try calling it like "Fn()( ...params )".' );
 
-				if ( name === 'return' ) continue;
+		return builder.generateConst( type );
 
-				fullLayout.inputs.push( {
-					name: name,
-					type: layout[ name ]
-				} );
+	}
 
-			}
+}
 
-			layout = fullLayout;
+export function Fn( jsFunc, layout = null ) {
 
-		}
+	const instance = new FnNode( jsFunc, layout );
 
-		fn.setLayout( layout );
+	return new Proxy( () => {}, {
 
-	}
+		apply( target, thisArg, params ) {
 
-	return fn;
+			return instance.call( ...params );
 
-};
+		},
+
+		get( target, prop, receiver ) {
+
+			return Reflect.get( instance, prop, receiver );
+
+		},
+
+		set( target, prop, value, receiver ) {
+
+			return Reflect.set( instance, prop, value, receiver );
+
+		}
+
+	} );
+
+}
 
 //
 
@@ -760,7 +1135,7 @@ export const Switch = ( ...params ) => currentStack.Switch( ...params );
  */
 export function Stack( node ) {
 
-	if ( currentStack ) currentStack.add( node );
+	if ( currentStack ) currentStack.addToStack( node );
 
 	return node;
 
@@ -841,29 +1216,14 @@ addMethodChaining( 'convert', convert );
  */
 export const append = ( node ) => { // @deprecated, r176
 
-	console.warn( 'THREE.TSL: append() has been renamed to Stack().' );
+	warn( 'TSL: append() has been renamed to Stack().' );
 	return Stack( node );
 
 };
 
 addMethodChaining( 'append', ( node ) => { // @deprecated, r176
 
-	console.warn( 'THREE.TSL: .append() has been renamed to .toStack().' );
+	warn( 'TSL: .append() has been renamed to .toStack().' );
 	return Stack( node );
 
 } );
-
-/**
- * @tsl
- * @function
- * @deprecated since r168. Use {@link Fn} instead.
- *
- * @param {...any} params
- * @returns {Function}
- */
-export const tslFn = ( ...params ) => { // @deprecated, r168
-
-	console.warn( 'THREE.TSL: tslFn() has been renamed to Fn().' );
-	return Fn( ...params );
-
-};