@needle-tools/three 0.162.12 → 0.169.2

package/{examples/jsm → src}/nodes/code/CodeNode.js

@@ -1,8 +1,14 @@
-import Node, { addNodeClass } from '../core/Node.js';
-import { nodeProxy } from '../shadernode/ShaderNode.js';
+import Node from '../core/Node.js';
+import { nodeProxy } from '../tsl/TSLBase.js';
 
 class CodeNode extends Node {
 
+	static get type() {
+
+		return 'CodeNode';
+
+	}
+
 	constructor( code = '', includes = [], language = '' ) {
 
 		super( 'code' );
@@ -75,10 +81,8 @@ class CodeNode extends Node {
 
 export default CodeNode;
 
-export const code = nodeProxy( CodeNode );
+export const code = /*@__PURE__*/ nodeProxy( CodeNode );
 
 export const js = ( src, includes ) => code( src, includes, 'js' );
 export const wgsl = ( src, includes ) => code( src, includes, 'wgsl' );
 export const glsl = ( src, includes ) => code( src, includes, 'glsl' );
-
-addNodeClass( 'CodeNode', CodeNode );

package/{examples/jsm → src}/nodes/code/ExpressionNode.js

@@ -1,8 +1,14 @@
-import Node, { addNodeClass } from '../core/Node.js';
-import { nodeProxy } from '../shadernode/ShaderNode.js';
+import Node from '../core/Node.js';
+import { nodeProxy } from '../tsl/TSLCore.js';
 
 class ExpressionNode extends Node {
 
+	static get type() {
+
+		return 'ExpressionNode';
+
+	}
+
 	constructor( snippet = '', nodeType = 'void' ) {
 
 		super( nodeType );
@@ -18,7 +24,7 @@ class ExpressionNode extends Node {
 
 		if ( type === 'void' ) {
 
-			builder.addLineFlowCode( snippet );
+			builder.addLineFlowCode( snippet, this );
 
 		} else {
 
@@ -32,6 +38,4 @@ class ExpressionNode extends Node {
 
 export default ExpressionNode;
 
-export const expression = nodeProxy( ExpressionNode );
-
-addNodeClass( 'ExpressionNode', ExpressionNode );
+export const expression = /*@__PURE__*/ nodeProxy( ExpressionNode );

package/{examples/jsm → src}/nodes/code/FunctionCallNode.js

@@ -1,9 +1,14 @@
 import TempNode from '../core/TempNode.js';
-import { addNodeClass } from '../core/Node.js';
-import { addNodeElement, nodeArray, nodeObject, nodeObjects } from '../shadernode/ShaderNode.js';
+import { addMethodChaining, nodeArray, nodeObject, nodeObjects } from '../tsl/TSLCore.js';
 
 class FunctionCallNode extends TempNode {
 
+	static get type() {
+
+		return 'FunctionCallNode';
+
+	}
+
 	constructor( functionNode = null, parameters = {} ) {
 
 		super();
@@ -91,6 +96,4 @@ export const call = ( func, ...params ) => {
 
 };
 
-addNodeElement( 'call', call );
-
-addNodeClass( 'FunctionCallNode', FunctionCallNode );
+addMethodChaining( 'call', call );

package/{examples/jsm → src}/nodes/code/FunctionNode.js

@@ -1,15 +1,18 @@
 import CodeNode from './CodeNode.js';
-import { addNodeClass } from '../core/Node.js';
-import { nodeObject } from '../shadernode/ShaderNode.js';
+import { nodeObject } from '../tsl/TSLBase.js';
 
 class FunctionNode extends CodeNode {
 
+	static get type() {
+
+		return 'FunctionNode';
+
+	}
+
 	constructor( code = '', includes = [], language = '' ) {
 
 		super( code, includes, language );
 
-		this.keywords = {};
-
 	}
 
 	getNodeType( builder ) {
@@ -63,23 +66,7 @@ class FunctionNode extends CodeNode {
 
 		const propertyName = builder.getPropertyName( nodeCode );
 
-		let code = this.getNodeFunction( builder ).getCode( propertyName );
-
-		const keywords = this.keywords;
-		const keywordsProperties = Object.keys( keywords );
-
-		if ( keywordsProperties.length > 0 ) {
-
-			for ( const property of keywordsProperties ) {
-
-				const propertyRegExp = new RegExp( `\\b${property}\\b`, 'g' );
-				const nodeProperty = keywords[ property ].build( builder, 'property' );
-
-				code = code.replace( propertyRegExp, nodeProperty );
-
-			}
-
-		}
+		const code = this.getNodeFunction( builder ).getCode( propertyName );
 
 		nodeCode.code = code + '\n';
 
@@ -126,13 +113,3 @@ const nativeFn = ( code, includes = [], language = '' ) => {
 
 export const glslFn = ( code, includes ) => nativeFn( code, includes, 'glsl' );
 export const wgslFn = ( code, includes ) => nativeFn( code, includes, 'wgsl' );
-
-export const func = ( code, includes ) => { // @deprecated, r154
-
-	console.warn( 'TSL: func() is deprecated. Use nativeFn(), wgslFn() or glslFn() instead.' );
-
-	return nodeObject( new FunctionNode( code, includes ) );
-
-};
-
-addNodeClass( 'FunctionNode', FunctionNode );

package/{examples/jsm → src}/nodes/code/ScriptableNode.js

@@ -1,6 +1,7 @@
-import Node, { addNodeClass } from '../core/Node.js';
+import Node from '../core/Node.js';
 import { scriptableValue } from './ScriptableValueNode.js';
-import { addNodeElement, nodeProxy, float } from '../shadernode/ShaderNode.js';
+import { nodeProxy, float } from '../tsl/TSLBase.js';
+import { hashArray, hashString } from '../core/NodeUtils.js';
 
 class Resources extends Map {
 
@@ -61,6 +62,12 @@ export const global = new Resources();
 
 class ScriptableNode extends Node {
 
+	static get type() {
+
+		return 'ScriptableNode';
+
+	}
+
 	constructor( codeNode = null, parameters = {} ) {
 
 		super();
@@ -437,6 +444,20 @@ class ScriptableNode extends Node {
 
 	}
 
+	getCacheKey( force ) {
+
+		const values = [ hashString( this.source ), this.getDefaultOutputNode().getCacheKey( force ) ];
+
+		for ( const param in this.parameters ) {
+
+			values.push( this.parameters[ param ].getCacheKey( force ) );
+
+		}
+
+		return hashArray( values );
+
+	}
+
 	set needsUpdate( value ) {
 
 		if ( value === true ) this.dispose();
@@ -481,8 +502,4 @@ class ScriptableNode extends Node {
 
 export default ScriptableNode;
 
-export const scriptable = nodeProxy( ScriptableNode );
-
-addNodeElement( 'scriptable', scriptable );
-
-addNodeClass( 'ScriptableNode', ScriptableNode );
+export const scriptable = /*@__PURE__*/ nodeProxy( ScriptableNode );

package/{examples/jsm → src}/nodes/code/ScriptableValueNode.js

@@ -1,10 +1,17 @@
-import Node, { addNodeClass } from '../core/Node.js';
+import Node from '../core/Node.js';
 import { arrayBufferToBase64, base64ToArrayBuffer } from '../core/NodeUtils.js';
-import { addNodeElement, nodeProxy, float } from '../shadernode/ShaderNode.js';
-import { EventDispatcher } from 'three';
+import { nodeProxy, float } from '../tsl/TSLBase.js';
+
+import { EventDispatcher } from '../../core/EventDispatcher.js';
 
 class ScriptableValueNode extends Node {
 
+	static get type() {
+
+		return 'ScriptableValueNode';
+
+	}
+
 	constructor( value = null ) {
 
 		super();
@@ -160,8 +167,4 @@ class ScriptableValueNode extends Node {
 
 export default ScriptableValueNode;
 
-export const scriptableValue = nodeProxy( ScriptableValueNode );
-
-addNodeElement( 'scriptableValue', scriptableValue );
-
-addNodeClass( 'ScriptableValueNode', ScriptableValueNode );
+export const scriptableValue = /*@__PURE__*/ nodeProxy( ScriptableValueNode );

package/{examples/jsm → src}/nodes/core/AssignNode.js

@@ -1,10 +1,15 @@
-import { addNodeClass } from '../core/Node.js';
 import TempNode from '../core/TempNode.js';
-import { addNodeElement, nodeProxy } from '../shadernode/ShaderNode.js';
+import { addMethodChaining, nodeProxy } from '../tsl/TSLCore.js';
 import { vectorComponents } from '../core/constants.js';
 
 class AssignNode extends TempNode {
 
+	static get type() {
+
+		return 'AssignNode';
+
+	}
+
 	constructor( targetNode, sourceNode ) {
 
 		super();
@@ -75,7 +80,7 @@ class AssignNode extends TempNode {
 			const sourceVar = builder.getVarFromNode( this, null, targetType );
 			const sourceProperty = builder.getPropertyName( sourceVar );
 
-			builder.addLineFlowCode( `${ sourceProperty } = ${ source }` );
+			builder.addLineFlowCode( `${ sourceProperty } = ${ source }`, this );
 
 			const targetRoot = targetNode.node.context( { assign: true } ).build( builder );
 
@@ -83,7 +88,7 @@ class AssignNode extends TempNode {
 
 				const component = targetNode.components[ i ];
 
-				builder.addLineFlowCode( `${ targetRoot }.${ component } = ${ sourceProperty }[ ${ i } ]` );
+				builder.addLineFlowCode( `${ targetRoot }.${ component } = ${ sourceProperty }[ ${ i } ]`, this );
 
 			}
 
@@ -99,7 +104,7 @@ class AssignNode extends TempNode {
 
 			if ( output === 'void' || sourceType === 'void' ) {
 
-				builder.addLineFlowCode( snippet );
+				builder.addLineFlowCode( snippet, this );
 
 				if ( output !== 'void' ) {
 
@@ -121,8 +126,6 @@ class AssignNode extends TempNode {
 
 export default AssignNode;
 
-export const assign = nodeProxy( AssignNode );
-
-addNodeClass( 'AssignNode', AssignNode );
+export const assign = /*@__PURE__*/ nodeProxy( AssignNode );
 
-addNodeElement( 'assign', assign );
+addMethodChaining( 'assign', assign );

package/{examples/jsm → src}/nodes/core/AttributeNode.js

@@ -1,20 +1,21 @@
-import Node, { addNodeClass } from './Node.js';
-import { varying } from './VaryingNode.js';
-import { nodeObject } from '../shadernode/ShaderNode.js';
+import Node from './Node.js';
+import { nodeObject, varying } from '../tsl/TSLBase.js';
 
 class AttributeNode extends Node {
 
-	constructor( attributeName, nodeType = null ) {
+	static get type() {
 
-		super( nodeType );
-
-		this._attributeName = attributeName;
+		return 'AttributeNode';
 
 	}
 
-	isGlobal() {
+	constructor( attributeName, nodeType = null ) {
+
+		super( nodeType );
 
-		return true;
+		this.global = true;
+
+		this._attributeName = attributeName;
 
 	}
 
@@ -26,7 +27,7 @@ class AttributeNode extends Node {
 
 	getNodeType( builder ) {
 
-		let nodeType = super.getNodeType( builder );
+		let nodeType = this.nodeType;
 
 		if ( nodeType === null ) {
 
@@ -99,10 +100,26 @@ class AttributeNode extends Node {
 
 	}
 
+	serialize( data ) {
+
+		super.serialize( data );
+
+		data.global = this.global;
+		data._attributeName = this._attributeName;
+
+	}
+
+	deserialize( data ) {
+
+		super.deserialize( data );
+
+		this.global = data.global;
+		this._attributeName = data._attributeName;
+
+	}
+
 }
 
 export default AttributeNode;
 
 export const attribute = ( name, nodeType ) => nodeObject( new AttributeNode( name, nodeType ) );
-
-addNodeClass( 'AttributeNode', AttributeNode );

package/{examples/jsm → src}/nodes/core/BypassNode.js

@@ -1,8 +1,14 @@
-import Node, { addNodeClass } from './Node.js';
-import { addNodeElement, nodeProxy } from '../shadernode/ShaderNode.js';
+import Node from './Node.js';
+import { addMethodChaining, nodeProxy } from '../tsl/TSLCore.js';
 
 class BypassNode extends Node {
 
+	static get type() {
+
+		return 'BypassNode';
+
+	}
+
 	constructor( returnNode, callNode ) {
 
 		super();
@@ -26,7 +32,7 @@ class BypassNode extends Node {
 
 		if ( snippet !== '' ) {
 
-			builder.addLineFlowCode( snippet );
+			builder.addLineFlowCode( snippet, this );
 
 		}
 
@@ -38,8 +44,6 @@ class BypassNode extends Node {
 
 export default BypassNode;
 
-export const bypass = nodeProxy( BypassNode );
-
-addNodeElement( 'bypass', bypass );
+export const bypass = /*@__PURE__*/ nodeProxy( BypassNode );
 
-addNodeClass( 'BypassNode', BypassNode );
+addMethodChaining( 'bypass', bypass );

package/src/nodes/core/CacheNode.js

@@ -0,0 +1,50 @@
+import Node from './Node.js';
+import { addMethodChaining, nodeObject } from '../tsl/TSLCore.js';
+
+class CacheNode extends Node {
+
+	static get type() {
+
+		return 'CacheNode';
+
+	}
+
+	constructor( node, parent = true ) {
+
+		super();
+
+		this.node = node;
+		this.parent = parent;
+
+		this.isCacheNode = true;
+
+	}
+
+	getNodeType( builder ) {
+
+		return this.node.getNodeType( builder );
+
+	}
+
+	build( builder, ...params ) {
+
+		const previousCache = builder.getCache();
+		const cache = builder.getCacheFromNode( this, this.parent );
+
+		builder.setCache( cache );
+
+		const data = this.node.build( builder, ...params );
+
+		builder.setCache( previousCache );
+
+		return data;
+
+	}
+
+}
+
+export default CacheNode;
+
+export const cache = ( node, ...params ) => nodeObject( new CacheNode( nodeObject( node ), ...params ) );
+
+addMethodChaining( 'cache', cache );

package/{examples/jsm → src}/nodes/core/ConstNode.js

@@ -1,8 +1,13 @@
 import InputNode from './InputNode.js';
-import { addNodeClass } from './Node.js';
 
 class ConstNode extends InputNode {
 
+	static get type() {
+
+		return 'ConstNode';
+
+	}
+
 	constructor( value, nodeType = null ) {
 
 		super( value, nodeType );
@@ -28,5 +33,3 @@ class ConstNode extends InputNode {
 }
 
 export default ConstNode;
-
-addNodeClass( 'ConstNode', ConstNode );

package/{examples/jsm → src}/nodes/core/ContextNode.js

@@ -1,16 +1,28 @@
-import Node, { addNodeClass } from './Node.js';
-import { addNodeElement, nodeProxy } from '../shadernode/ShaderNode.js';
+import Node from './Node.js';
+import { addMethodChaining, nodeProxy } from '../tsl/TSLCore.js';
 
 class ContextNode extends Node {
 
-	constructor( node, context = {} ) {
+	static get type() {
+
+		return 'ContextNode';
+
+	}
+
+	constructor( node, value = {} ) {
 
 		super();
 
 		this.isContextNode = true;
 
 		this.node = node;
-		this.context = context;
+		this.value = value;
+
+	}
+
+	getScope() {
+
+		return this.node.getScope();
 
 	}
 
@@ -20,11 +32,17 @@ class ContextNode extends Node {
 
 	}
 
+	analyze( builder ) {
+
+		this.node.build( builder );
+
+	}
+
 	setup( builder ) {
 
 		const previousContext = builder.getContext();
 
-		builder.setContext( { ...builder.context, ...this.context } );
+		builder.setContext( { ...builder.context, ...this.value } );
 
 		const node = this.node.build( builder );
 
@@ -38,7 +56,7 @@ class ContextNode extends Node {
 
 		const previousContext = builder.getContext();
 
-		builder.setContext( { ...builder.context, ...this.context } );
+		builder.setContext( { ...builder.context, ...this.value } );
 
 		const snippet = this.node.build( builder, output );
 
@@ -52,10 +70,8 @@ class ContextNode extends Node {
 
 export default ContextNode;
 
-export const context = nodeProxy( ContextNode );
+export const context = /*@__PURE__*/ nodeProxy( ContextNode );
 export const label = ( node, name ) => context( node, { label: name } );
 
-addNodeElement( 'context', context );
-addNodeElement( 'label', label );
-
-addNodeClass( 'ContextNode', ContextNode );
+addMethodChaining( 'context', context );
+addMethodChaining( 'label', label );

package/src/nodes/core/IndexNode.js

@@ -0,0 +1,99 @@
+import Node from './Node.js';
+import { nodeImmutable, varying } from '../tsl/TSLBase.js';
+
+class IndexNode extends Node {
+
+	static get type() {
+
+		return 'IndexNode';
+
+	}
+
+	constructor( scope ) {
+
+		super( 'uint' );
+
+		this.scope = scope;
+
+		this.isInstanceIndexNode = true;
+
+	}
+
+	generate( builder ) {
+
+		const nodeType = this.getNodeType( builder );
+		const scope = this.scope;
+
+		let propertyName;
+
+		if ( scope === IndexNode.VERTEX ) {
+
+			// The index of a vertex within a mesh.
+			propertyName = builder.getVertexIndex();
+
+		} else if ( scope === IndexNode.INSTANCE ) {
+
+			// The index of either a mesh instance or an invocation of a compute shader.
+			propertyName = builder.getInstanceIndex();
+
+		} else if ( scope === IndexNode.DRAW ) {
+
+			// The index of a draw call.
+			propertyName = builder.getDrawIndex();
+
+		} else if ( scope === IndexNode.INVOCATION_LOCAL ) {
+
+			// The index of a compute invocation within the scope of a workgroup load.
+			propertyName = builder.getInvocationLocalIndex();
+
+		} else if ( scope === IndexNode.INVOCATION_SUBGROUP ) {
+
+			// The index of a compute invocation within the scope of a subgroup.
+			propertyName = builder.getInvocationSubgroupIndex();
+
+		} else if ( scope === IndexNode.SUBGROUP ) {
+
+			// The index of the subgroup the current compute invocation belongs to.
+			propertyName = builder.getSubgroupIndex();
+
+		} else {
+
+			throw new Error( 'THREE.IndexNode: Unknown scope: ' + scope );
+
+		}
+
+		let output;
+
+		if ( builder.shaderStage === 'vertex' || builder.shaderStage === 'compute' ) {
+
+			output = propertyName;
+
+		} else {
+
+			const nodeVarying = varying( this );
+
+			output = nodeVarying.build( builder, nodeType );
+
+		}
+
+		return output;
+
+	}
+
+}
+
+IndexNode.VERTEX = 'vertex';
+IndexNode.INSTANCE = 'instance';
+IndexNode.SUBGROUP = 'subgroup';
+IndexNode.INVOCATION_LOCAL = 'invocationLocal';
+IndexNode.INVOCATION_SUBGROUP = 'invocationSubgroup';
+IndexNode.DRAW = 'draw';
+
+export default IndexNode;
+
+export const vertexIndex = /*@__PURE__*/ nodeImmutable( IndexNode, IndexNode.VERTEX );
+export const instanceIndex = /*@__PURE__*/ nodeImmutable( IndexNode, IndexNode.INSTANCE );
+export const subgroupIndex = /*@__PURE__*/ nodeImmutable( IndexNode, IndexNode.SUBGROUP );
+export const invocationSubgroupIndex = /*@__PURE__*/ nodeImmutable( IndexNode, IndexNode.INVOCATION_SUBGROUP );
+export const invocationLocalIndex = /*@__PURE__*/ nodeImmutable( IndexNode, IndexNode.INVOCATION_LOCAL );
+export const drawIndex = /*@__PURE__*/ nodeImmutable( IndexNode, IndexNode.DRAW );

package/{examples/jsm → src}/nodes/core/InputNode.js

@@ -1,8 +1,14 @@
-import Node, { addNodeClass } from './Node.js';
+import Node from './Node.js';
 import { getValueType, getValueFromType, arrayBufferToBase64 } from './NodeUtils.js';
 
 class InputNode extends Node {
 
+	static get type() {
+
+		return 'InputNode';
+
+	}
+
 	constructor( value, nodeType = null ) {
 
 		super( nodeType );
@@ -79,5 +85,3 @@ class InputNode extends Node {
 }
 
 export default InputNode;
-
-addNodeClass( 'InputNode', InputNode );

package/{examples/jsm → src}/nodes/core/LightingModel.js

@@ -6,9 +6,9 @@ class LightingModel {
 
 	direct( /*input, stack, builder*/ ) { }
 
-	indirectDiffuse( /*input, stack, builder*/ ) { }
+	directRectArea( /*input, stack, builder*/ ) {}
 
-	indirectSpecular( /*input, stack, builder*/ ) { }
+	indirect( /*input, stack, builder*/ ) { }
 
 	ambientOcclusion( /*input, stack, builder*/ ) { }