super-three 0.165.0 → 0.168.0

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

@@ -1,6 +1,6 @@
-import { addNodeClass } from '../core/Node.js';
+import { registerNode } 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 {
@@ -121,8 +121,8 @@ class AssignNode extends TempNode {
 
 export default AssignNode;
 
-export const assign = nodeProxy( AssignNode );
+AssignNode.type = /*@__PURE__*/ registerNode( 'Assign', 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,25 +1,18 @@
-import Node, { addNodeClass } from './Node.js';
-import { varying } from './VaryingNode.js';
-import { nodeObject } from '../shadernode/ShaderNode.js';
+import Node, { registerNode } from './Node.js';
+import { nodeObject, varying } from '../tsl/TSLBase.js';
 
 class AttributeNode extends Node {
 
-	constructor( attributeName, nodeType = null, defaultNode = null ) {
+	constructor( attributeName, nodeType = null ) {
 
 		super( nodeType );
 
-		this.defaultNode = defaultNode;
+		this.global = true;
 
 		this._attributeName = attributeName;
 
 	}
 
-	isGlobal() {
-
-		return true;
-
-	}
-
 	getHash( builder ) {
 
 		return this.getAttributeName( builder );
@@ -28,7 +21,7 @@ class AttributeNode extends Node {
 
 	getNodeType( builder ) {
 
-		let nodeType = super.getNodeType( builder );
+		let nodeType = this.nodeType;
 
 		if ( nodeType === null ) {
 
@@ -95,19 +88,27 @@ class AttributeNode extends Node {
 
 			console.warn( `AttributeNode: Vertex attribute "${ attributeName }" not found on geometry.` );
 
-			const { defaultNode } = this;
+			return builder.generateConst( nodeType );
 
-			if ( defaultNode !== null ) {
+		}
 
-				return defaultNode.build( builder, nodeType );
+	}
 
-			} else {
+	serialize( data ) {
 
-				return builder.generateConst( nodeType );
+		super.serialize( data );
 
-			}
+		data.global = this.global;
+		data._attributeName = this._attributeName;
 
-		}
+	}
+
+	deserialize( data ) {
+
+		super.deserialize( data );
+
+		this.global = data.global;
+		this._attributeName = data._attributeName;
 
 	}
 
@@ -115,6 +116,6 @@ class AttributeNode extends Node {
 
 export default AttributeNode;
 
-export const attribute = ( name, nodeType, defaultNode ) => nodeObject( new AttributeNode( name, nodeType, nodeObject( defaultNode ) ) );
+AttributeNode.type = /*@__PURE__*/ registerNode( 'Attribute', AttributeNode );
 
-addNodeClass( 'AttributeNode', AttributeNode );
+export const attribute = ( name, nodeType ) => nodeObject( new AttributeNode( name, nodeType ) );

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

@@ -1,5 +1,5 @@
-import Node, { addNodeClass } from './Node.js';
-import { addNodeElement, nodeProxy } from '../shadernode/ShaderNode.js';
+import Node, { registerNode } from './Node.js';
+import { addMethodChaining, nodeProxy } from '../tsl/TSLCore.js';
 
 class BypassNode extends Node {
 
@@ -38,8 +38,8 @@ class BypassNode extends Node {
 
 export default BypassNode;
 
-export const bypass = nodeProxy( BypassNode );
+BypassNode.type = /*@__PURE__*/ registerNode( 'Bypass', 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,46 @@
+import Node, { registerNode } from './Node.js';
+import { addMethodChaining, nodeObject } from '../tsl/TSLCore.js';
+
+class CacheNode extends Node {
+
+	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, parent );
+
+		builder.setCache( cache );
+
+		const data = this.node.build( builder, ...params );
+
+		builder.setCache( previousCache );
+
+		return data;
+
+	}
+
+}
+
+export default CacheNode;
+
+CacheNode.type = /*@__PURE__*/ registerNode( 'Cache', CacheNode );
+
+export const cache = ( node, ...params ) => nodeObject( new CacheNode( nodeObject( node ), ...params ) );
+
+addMethodChaining( 'cache', cache );

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

@@ -1,5 +1,5 @@
+import { registerNode } from './Node.js';
 import InputNode from './InputNode.js';
-import { addNodeClass } from './Node.js';
 
 class ConstNode extends InputNode {
 
@@ -29,4 +29,4 @@ class ConstNode extends InputNode {
 
 export default ConstNode;
 
-addNodeClass( 'ConstNode', ConstNode );
+ConstNode.type = /*@__PURE__*/ registerNode( 'Const', ConstNode );

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

@@ -1,16 +1,22 @@
-import Node, { addNodeClass } from './Node.js';
-import { addNodeElement, nodeProxy } from '../shadernode/ShaderNode.js';
+import Node, { registerNode } from './Node.js';
+import { addMethodChaining, nodeProxy } from '../tsl/TSLCore.js';
 
 class ContextNode extends Node {
 
-	constructor( node, context = {} ) {
+	constructor( node, value = {} ) {
 
 		super();
 
 		this.isContextNode = true;
 
 		this.node = node;
-		this.context = context;
+		this.value = value;
+
+	}
+
+	getScope() {
+
+		return this.node.getScope();
 
 	}
 
@@ -30,7 +36,7 @@ class ContextNode extends Node {
 
 		const previousContext = builder.getContext();
 
-		builder.setContext( { ...builder.context, ...this.context } );
+		builder.setContext( { ...builder.context, ...this.value } );
 
 		const node = this.node.build( builder );
 
@@ -44,7 +50,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 );
 
@@ -58,10 +64,10 @@ class ContextNode extends Node {
 
 export default ContextNode;
 
-export const context = nodeProxy( ContextNode );
-export const label = ( node, name ) => context( node, { label: name } );
+ContextNode.type = /*@__PURE__*/ registerNode( 'Context', ContextNode );
 
-addNodeElement( 'context', context );
-addNodeElement( 'label', label );
+export const context = /*@__PURE__*/ nodeProxy( ContextNode );
+export const label = ( node, name ) => context( node, { label: name } );
 
-addNodeClass( 'ContextNode', ContextNode );
+addMethodChaining( 'context', context );
+addMethodChaining( 'label', label );

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

@@ -1,6 +1,5 @@
-import Node, { addNodeClass } from './Node.js';
-import { varying } from './VaryingNode.js';
-import { nodeImmutable } from '../shadernode/ShaderNode.js';
+import Node, { registerNode } from './Node.js';
+import { nodeImmutable, varying } from '../tsl/TSLBase.js';
 
 class IndexNode extends Node {
 
@@ -29,6 +28,14 @@ class IndexNode extends Node {
 
 			propertyName = builder.getInstanceIndex();
 
+		} else if ( scope === IndexNode.DRAW ) {
+
+			propertyName = builder.getDrawIndex();
+
+		} else if ( scope === IndexNode.INVOCATION_LOCAL ) {
+
+			propertyName = builder.getInvocationLocalIndex();
+
 		} else {
 
 			throw new Error( 'THREE.IndexNode: Unknown scope: ' + scope );
@@ -57,10 +64,14 @@ class IndexNode extends Node {
 
 IndexNode.VERTEX = 'vertex';
 IndexNode.INSTANCE = 'instance';
+IndexNode.INVOCATION_LOCAL = 'invocationLocal';
+IndexNode.DRAW = 'draw';
 
 export default IndexNode;
 
-export const vertexIndex = nodeImmutable( IndexNode, IndexNode.VERTEX );
-export const instanceIndex = nodeImmutable( IndexNode, IndexNode.INSTANCE );
+IndexNode.type = /*@__PURE__*/ registerNode( 'Index', IndexNode );
 
-addNodeClass( 'IndexNode', IndexNode );
+export const vertexIndex = /*@__PURE__*/ nodeImmutable( IndexNode, IndexNode.VERTEX );
+export const instanceIndex = /*@__PURE__*/ nodeImmutable( IndexNode, IndexNode.INSTANCE );
+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,4 +1,4 @@
-import Node, { addNodeClass } from './Node.js';
+import Node, { registerNode } from './Node.js';
 import { getValueType, getValueFromType, arrayBufferToBase64 } from './NodeUtils.js';
 
 class InputNode extends Node {
@@ -80,4 +80,4 @@ class InputNode extends Node {
 
 export default InputNode;
 
-addNodeClass( 'InputNode', InputNode );
+InputNode.type = /*@__PURE__*/ registerNode( 'Input', 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*/ ) { }
 

package/src/nodes/core/MRTNode.js

@@ -0,0 +1,82 @@
+import { registerNode } from './Node.js';
+import OutputStructNode from './OutputStructNode.js';
+import { nodeProxy, vec4 } from '../tsl/TSLBase.js';
+
+export function getTextureIndex( textures, name ) {
+
+	for ( let i = 0; i < textures.length; i ++ ) {
+
+		if ( textures[ i ].name === name ) {
+
+			return i;
+
+		}
+
+	}
+
+	return - 1;
+
+}
+
+class MRTNode extends OutputStructNode {
+
+	constructor( outputNodes ) {
+
+		super();
+
+		this.outputNodes = outputNodes;
+
+		this.isMRTNode = true;
+
+	}
+
+	has( name ) {
+
+		return this.outputNodes[ name ] !== undefined;
+
+	}
+
+	get( name ) {
+
+		return this.outputNodes[ name ];
+
+	}
+
+	merge( mrtNode ) {
+
+		const outputs = { ...this.outputNodes, ...mrtNode.outputNodes };
+
+		return mrt( outputs );
+
+	}
+
+	setup( builder ) {
+
+		const outputNodes = this.outputNodes;
+		const mrt = builder.renderer.getRenderTarget();
+
+		const members = [];
+
+		const textures = mrt.textures;
+
+		for ( const name in outputNodes ) {
+
+			const index = getTextureIndex( textures, name );
+
+			members[ index ] = vec4( outputNodes[ name ] );
+
+		}
+
+		this.members = members;
+
+		return super.setup( builder );
+
+	}
+
+}
+
+export default MRTNode;
+
+MRTNode.type = /*@__PURE__*/ registerNode( 'MRT', MRTNode );
+
+export const mrt = /*@__PURE__*/ nodeProxy( MRTNode );

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

@@ -1,9 +1,10 @@
-import { EventDispatcher } from 'three';
 import { NodeUpdateType } from './constants.js';
 import { getNodeChildren, getCacheKey } from './NodeUtils.js';
-import { MathUtils } from 'three';
 
-const NodeClasses = new Map();
+import { EventDispatcher } from '../../core/EventDispatcher.js';
+import { MathUtils } from '../../math/MathUtils.js';
+
+const Nodes = new Map();
 
 let _nodeId = 0;
 
@@ -17,6 +18,7 @@ class Node extends EventDispatcher {
 
 		this.updateType = NodeUpdateType.NONE;
 		this.updateBeforeType = NodeUpdateType.NONE;
+		this.updateAfterType = NodeUpdateType.NONE;
 
 		this.uuid = MathUtils.generateUUID();
 
@@ -147,6 +149,12 @@ class Node extends EventDispatcher {
 
 	}
 
+	getScope() {
+
+		return this;
+
+	}
+
 	getHash( /*builder*/ ) {
 
 		return this.uuid;
@@ -165,6 +173,12 @@ class Node extends EventDispatcher {
 
 	}
 
+	getUpdateAfterType() {
+
+		return this.updateAfterType;
+
+	}
+
 	getElementType( builder ) {
 
 		const type = this.getNodeType( builder );
@@ -214,26 +228,9 @@ class Node extends EventDispatcher {
 
 	}
 
-	construct( builder ) { // @deprecated, r157
-
-		console.warn( 'THREE.Node: construct() is deprecated. Use setup() instead.' );
-
-		return this.setup( builder );
-
-	}
-
-	increaseUsage( builder ) {
-
-		const nodeData = builder.getDataFromNode( this );
-		nodeData.usageCount = nodeData.usageCount === undefined ? 1 : nodeData.usageCount + 1;
-
-		return nodeData.usageCount;
-
-	}
-
 	analyze( builder ) {
 
-		const usageCount = this.increaseUsage( builder );
+		const usageCount = builder.increaseUsage( this );
 
 		if ( usageCount === 1 ) {
 
@@ -273,6 +270,12 @@ class Node extends EventDispatcher {
 
 	}
 
+	updateAfter( /*frame*/ ) {
+
+		console.warn( 'Abstract function.' );
+
+	}
+
 	update( /*frame*/ ) {
 
 		console.warn( 'Abstract function.' );
@@ -307,7 +310,7 @@ class Node extends EventDispatcher {
 
 			const properties = builder.getNodeProperties( this );
 
-			if ( properties.initialized !== true || builder.context.tempRead === false ) {
+			if ( properties.initialized !== true ) {
 
 				const stackNodesBeforeSetup = builder.stack.nodes.length;
 
@@ -316,7 +319,8 @@ class Node extends EventDispatcher {
 
 				if ( properties.outputNode !== null && builder.stack.nodes.length !== stackNodesBeforeSetup ) {
 
-					properties.outputNode = builder.stack;
+					// !! no outputNode !!
+					//properties.outputNode = builder.stack;
 
 				}
 
@@ -347,7 +351,7 @@ class Node extends EventDispatcher {
 
 				result = nodeData.snippet;
 
-				if ( result === undefined /*|| builder.context.tempRead === false*/ ) {
+				if ( result === undefined ) {
 
 					result = this.generate( builder ) || '';
 
@@ -537,24 +541,39 @@ class Node extends EventDispatcher {
 
 export default Node;
 
-export function addNodeClass( type, nodeClass ) {
+Node.type = /*@__PURE__*/ registerNode( '', Node );
+
+export function registerNode( type, nodeClass ) {
+
+	const suffix = 'Node';
+	const nodeType = type + suffix;
+
+	if ( typeof nodeClass !== 'function' ) throw new Error( `TSL.Node: Node class ${ type } is not a class` );
+
+	if ( Nodes.has( nodeType ) ) {
 
-	if ( typeof nodeClass !== 'function' || ! type ) throw new Error( `Node class ${ type } is not a class` );
-	if ( NodeClasses.has( type ) ) {
+		console.warn( `TSL.Node: Redefinition of node class ${ nodeType }` );
+		return;
+
+	}
 
-		console.warn( `Redefinition of node class ${ type }` );
+	if ( type.slice( - suffix.length ) === suffix ) {
+
+		console.warn( `TSL.Node: Node class ${ nodeType } should not have '${ suffix }' suffix.` );
 		return;
 
 	}
 
-	NodeClasses.set( type, nodeClass );
-	nodeClass.type = type;
+	Nodes.set( nodeType, nodeClass );
+	nodeClass.type = nodeType;
+
+	return nodeType;
 
 }
 
 export function createNodeFromType( type ) {
 
-	const Class = NodeClasses.get( type );
+	const Class = Nodes.get( type );
 
 	if ( Class !== undefined ) {
 
@@ -563,3 +582,10 @@ export function createNodeFromType( type ) {
 	}
 
 }
+
+export function addNodeClass( type, nodeClass ) {
+
+	console.warn( 'TSL.Node: Function addNodeClass() is deprecated. Use /*@__PURE__*/ registerNode() instead.' );
+	/*@__PURE__*/ registerNode( type.slice( 0, - 4 ), nodeClass );
+
+}