super-three 0.147.1 → 0.154.0

package/examples/jsm/nodes/core/BypassNode.js

@@ -1,4 +1,5 @@
-import Node from './Node.js';
+import Node, { addNodeClass } from './Node.js';
+import { addNodeElement, nodeProxy } from '../shadernode/ShaderNode.js';
 
 class BypassNode extends Node {
 
@@ -19,20 +20,26 @@ class BypassNode extends Node {
 
 	}
 
-	generate( builder, output ) {
+	generate( builder ) {
 
 		const snippet = this.callNode.build( builder, 'void' );
 
 		if ( snippet !== '' ) {
 
-			builder.addFlowCode( snippet );
+			builder.addLineFlowCode( snippet );
 
 		}
 
-		return this.outputNode.build( builder, output );
+		return this.outputNode.build( builder );
 
 	}
 
 }
 
 export default BypassNode;
+
+export const bypass = nodeProxy( BypassNode );
+
+addNodeElement( 'bypass', bypass );
+
+addNodeClass( BypassNode );

package/examples/jsm/nodes/core/CacheNode.js

@@ -0,0 +1,46 @@
+import Node, { addNodeClass } from './Node.js';
+import NodeCache from './NodeCache.js';
+import { addNodeElement, nodeProxy } from '../shadernode/ShaderNode.js';
+
+class CacheNode extends Node {
+
+	constructor( node, cache = new NodeCache() ) {
+
+		super();
+
+		this.isCacheNode = true;
+
+		this.node = node;
+		this.cache = cache;
+
+	}
+
+	getNodeType( builder ) {
+
+		return this.node.getNodeType( builder );
+
+	}
+
+	build( builder, ...params ) {
+
+		const previousCache = builder.getCache();
+
+		builder.setCache( this.cache );
+
+		const data = this.node.build( builder, ...params );
+
+		builder.setCache( previousCache );
+
+		return data;
+
+	}
+
+}
+
+export default CacheNode;
+
+export const cache = nodeProxy( CacheNode );
+
+addNodeElement( 'cache', cache );
+
+addNodeClass( CacheNode );

package/examples/jsm/nodes/core/ConstNode.js

@@ -1,4 +1,5 @@
 import InputNode from './InputNode.js';
+import { addNodeClass } from './Node.js';
 
 class ConstNode extends InputNode {
 
@@ -27,3 +28,5 @@ class ConstNode extends InputNode {
 }
 
 export default ConstNode;
+
+addNodeClass( ConstNode );

package/examples/jsm/nodes/core/ContextNode.js

@@ -1,4 +1,5 @@
-import Node from './Node.js';
+import Node, { addNodeClass } from './Node.js';
+import { addNodeElement, nodeProxy } from '../shadernode/ShaderNode.js';
 
 class ContextNode extends Node {
 
@@ -50,3 +51,11 @@ class ContextNode extends Node {
 }
 
 export default ContextNode;
+
+export const context = nodeProxy( ContextNode );
+export const label = ( node, name ) => context( node, { label: name } );
+
+addNodeElement( 'context', context );
+addNodeElement( 'label', label );
+
+addNodeClass( ContextNode );

package/examples/jsm/nodes/core/IndexNode.js

@@ -0,0 +1,66 @@
+import Node, { addNodeClass } from './Node.js';
+import { varying } from './VaryingNode.js';
+import { nodeImmutable } from '../shadernode/ShaderNode.js';
+
+class IndexNode extends Node {
+
+	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 ) {
+
+			propertyName = builder.getVertexIndex();
+
+		} else if ( scope === IndexNode.INSTANCE ) {
+
+			propertyName = builder.getInstanceIndex();
+
+		} 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';
+
+export default IndexNode;
+
+export const vertexIndex = nodeImmutable( IndexNode, IndexNode.VERTEX );
+export const instanceIndex = nodeImmutable( IndexNode, IndexNode.INSTANCE );
+
+addNodeClass( IndexNode );

package/examples/jsm/nodes/core/InputNode.js

@@ -1,5 +1,5 @@
-import Node from './Node.js';
-import { getValueType, getValueFromType } from './NodeUtils.js';
+import Node, { addNodeClass } from './Node.js';
+import { getValueType, getValueFromType, arrayBufferToBase64 } from './NodeUtils.js';
 
 class InputNode extends Node {
 
@@ -10,6 +10,7 @@ class InputNode extends Node {
 		this.isInputNode = true;
 
 		this.value = value;
+		this.precision = null;
 
 	}
 
@@ -31,14 +32,29 @@ class InputNode extends Node {
 
 	}
 
+	setPrecision( precision ) {
+
+		this.precision = precision;
+
+		return this;
+
+	}
+
 	serialize( data ) {
 
 		super.serialize( data );
 
-		data.value = this.value?.toArray?.() || this.value;
+		data.value = this.value;
+
+		if ( this.value && this.value.toArray ) data.value = this.value.toArray();
+
 		data.valueType = getValueType( this.value );
 		data.nodeType = this.nodeType;
 
+		if ( data.valueType === 'ArrayBuffer' ) data.value = arrayBufferToBase64( data.value );
+
+		data.precision = this.precision;
+
 	}
 
 	deserialize( data ) {
@@ -46,8 +62,11 @@ class InputNode extends Node {
 		super.deserialize( data );
 
 		this.nodeType = data.nodeType;
-		this.value = getValueFromType( data.valueType );
-		this.value = this.value?.fromArray?.( data.value ) || data.value;
+		this.value = Array.isArray( data.value ) ? getValueFromType( data.valueType, ...data.value ) : data.value;
+
+		this.precision = data.precision || null;
+
+		if ( this.value && this.value.fromArray ) this.value = this.value.fromArray( data.value );
 
 	}
 
@@ -60,3 +79,5 @@ class InputNode extends Node {
 }
 
 export default InputNode;
+
+addNodeClass( InputNode );

package/examples/jsm/nodes/core/LightingModel.js

@@ -0,0 +1,17 @@
+class LightingModel {
+
+	constructor( init = null, direct = null, indirectDiffuse = null, indirectSpecular = null, ambientOcclusion = null ) {
+
+		this.init = init;
+		this.direct = direct;
+		this.indirectDiffuse = indirectDiffuse;
+		this.indirectSpecular = indirectSpecular;
+		this.ambientOcclusion = ambientOcclusion;
+
+	}
+
+}
+
+export default LightingModel;
+
+export const lightingModel = ( ...params ) => new LightingModel( ...params );

package/examples/jsm/nodes/core/Node.js

@@ -1,7 +1,9 @@
 import { NodeUpdateType } from './constants.js';
-import { getNodesKeys, getCacheKey } from './NodeUtils.js';
+import { getNodeChildren, getCacheKey } from './NodeUtils.js';
 import { MathUtils } from 'three';
 
+const NodeClasses = new Map();
+
 let _nodeId = 0;
 
 class Node {
@@ -13,6 +15,7 @@ class Node {
 		this.nodeType = nodeType;
 
 		this.updateType = NodeUpdateType.NONE;
+		this.updateBeforeType = NodeUpdateType.NONE;
 
 		this.uuid = MathUtils.generateUUID();
 
@@ -26,35 +29,38 @@ class Node {
 
 	}
 
-	getChildren() {
+	isGlobal( /*builder*/ ) {
 
-		const children = [];
+		return false;
 
-		for ( const property in this ) {
+	}
 
-			const object = this[ property ];
+	* getChildren() {
 
-			if ( Array.isArray( object ) === true ) {
+		const self = this;
 
-				for ( const child of object ) {
+		for ( const { property, index, childNode } of getNodeChildren( this ) ) {
 
-					if ( child?.isNode === true ) {
+			yield { childNode, replaceNode( node ) {
 
-						children.push( child );
+				if ( index === undefined ) self[ property ] = node;
+				else self[ property ][ index ] = node;
 
-					}
+			} };
 
-				}
+		}
 
-			} else if ( object?.isNode === true ) {
+	}
 
-				children.push( object );
+	traverse( callback, replaceNode = null ) {
 
-			}
+		callback( this, replaceNode );
 
-		}
+		for ( const { childNode, replaceNode } of this.getChildren() ) {
+
+			childNode.traverse( callback, replaceNode );
 
-		return children;
+		}
 
 	}
 
@@ -70,21 +76,21 @@ class Node {
 
 	}
 
-	getUpdateType( /*builder*/ ) {
+	getUpdateType() {
 
 		return this.updateType;
 
 	}
 
-	getNodeType( /*builder*/ ) {
+	getUpdateBeforeType() {
 
-		return this.nodeType;
+		return this.updateBeforeType;
 
 	}
 
-	getConstructHash( /*builder*/ ) {
+	getNodeType( /*builder*/ ) {
 
-		return this.uuid;
+		return this.nodeType;
 
 	}
 
@@ -101,7 +107,7 @@ class Node {
 
 		const nodeProperties = builder.getNodeProperties( this );
 
-		for ( const childNode of this.getChildren() ) {
+		for ( const { childNode } of this.getChildren() ) {
 
 			nodeProperties[ '_node' + childNode.id ] = childNode;
 
@@ -125,7 +131,7 @@ class Node {
 
 			for ( const childNode of Object.values( nodeProperties ) ) {
 
-				if ( childNode?.isNode === true ) {
+				if ( childNode && childNode.isNode === true ) {
 
 					childNode.build( builder );
 
@@ -141,7 +147,7 @@ class Node {
 
 		const { outputNode } = builder.getNodeProperties( this );
 
-		if ( outputNode?.isNode === true ) {
+		if ( outputNode && outputNode.isNode === true ) {
 
 			return outputNode.build( builder, output );
 
@@ -149,6 +155,12 @@ class Node {
 
 	}
 
+	updateBefore( /*frame*/ ) {
+
+		console.warn( 'Abstract function.' );
+
+	}
+
 	update( /*frame*/ ) {
 
 		console.warn( 'Abstract function.' );
@@ -166,9 +178,9 @@ class Node {
 		}
 
 		builder.addNode( this );
-		builder.addStack( this );
+		builder.addChain( this );
 
-		/* expected return:
+		/* Build stages expected results:
 			- "construct"	-> Node
 			- "analyze"		-> null
 			- "generate"	-> String
@@ -183,12 +195,20 @@ class Node {
 
 			if ( properties.initialized !== true || builder.context.tempRead === false ) {
 
+				const stackNodesBeforeConstruct = builder.stack.nodes.length;
+
 				properties.initialized = true;
 				properties.outputNode = this.construct( builder );
 
+				if ( properties.outputNode !== null && builder.stack.nodes.length !== stackNodesBeforeConstruct ) {
+
+					properties.outputNode = builder.stack;
+
+				}
+
 				for ( const childNode of Object.values( properties ) ) {
 
-					if ( childNode?.isNode === true ) {
+					if ( childNode && childNode.isNode === true ) {
 
 						childNode.build( builder );
 
@@ -231,26 +251,46 @@ class Node {
 
 		}
 
-		builder.removeStack( this );
+		builder.removeChain( this );
 
 		return result;
 
 	}
 
+	getSerializeChildren() {
+
+		return getNodeChildren( this );
+
+	}
+
 	serialize( json ) {
 
-		const nodeKeys = getNodesKeys( this );
+		const nodeChildren = this.getSerializeChildren();
+
+		const inputNodes = {};
+
+		for ( const { property, index, childNode } of nodeChildren ) {
 
-		if ( nodeKeys.length > 0 ) {
+			if ( index !== undefined ) {
+
+				if ( inputNodes[ property ] === undefined ) {
+
+					inputNodes[ property ] = Number.isInteger( index ) ? [] : {};
+
+				}
 
-			const inputNodes = {};
+				inputNodes[ property ][ index ] = childNode.toJSON( json.meta ).uuid;
 
-			for ( const property of nodeKeys ) {
+			} else {
 
-				inputNodes[ property ] = this[ property ].toJSON( json.meta ).uuid;
+				inputNodes[ property ] = childNode.toJSON( json.meta ).uuid;
 
 			}
 
+		}
+
+		if ( Object.keys( inputNodes ).length > 0 ) {
+
 			json.inputNodes = inputNodes;
 
 		}
@@ -265,9 +305,39 @@ class Node {
 
 			for ( const property in json.inputNodes ) {
 
-				const uuid = json.inputNodes[ property ];
+				if ( Array.isArray( json.inputNodes[ property ] ) ) {
+
+					const inputArray = [];
+
+					for ( const uuid of json.inputNodes[ property ] ) {
+
+						inputArray.push( nodes[ uuid ] );
+
+					}
+
+					this[ property ] = inputArray;
+
+				} else if ( typeof json.inputNodes[ property ] === 'object' ) {
+
+					const inputObject = {};
+
+					for ( const subProperty in json.inputNodes[ property ] ) {
+
+						const uuid = json.inputNodes[ property ][ subProperty ];
+
+						inputObject[ subProperty ] = nodes[ uuid ];
+
+					}
+
+					this[ property ] = inputObject;
 
-				this[ property ] = nodes[ uuid ];
+				} else {
+
+					const uuid = json.inputNodes[ property ];
+
+					this[ property ] = nodes[ uuid ];
+
+				}
 
 			}
 
@@ -301,13 +371,13 @@ class Node {
 				type,
 				meta,
 				metadata: {
-					version: 4.5,
+					version: 4.6,
 					type: 'Node',
 					generator: 'Node.toJSON'
 				}
 			};
 
-			meta.nodes[ data.uuid ] = data;
+			if ( isRoot !== true ) meta.nodes[ data.uuid ] = data;
 
 			this.serialize( data );
 
@@ -352,3 +422,24 @@ class Node {
 }
 
 export default Node;
+
+export function addNodeClass( nodeClass ) {
+
+	if ( typeof nodeClass !== 'function' || ! nodeClass.name ) throw new Error( `Node class ${ nodeClass.name } is not a class` );
+	if ( NodeClasses.has( nodeClass.name ) ) throw new Error( `Redefinition of node class ${ nodeClass.name }` );
+
+	NodeClasses.set( nodeClass.name, nodeClass );
+
+}
+
+export function createNodeFromType( type ) {
+
+	const Class = NodeClasses.get( type );
+
+	if ( Class !== undefined ) {
+
+		return new Class();
+
+	}
+
+}

package/examples/jsm/nodes/core/NodeAttribute.js

@@ -1,11 +1,12 @@
 class NodeAttribute {
 
-	constructor( name, type ) {
+	constructor( name, type, node = null ) {
 
 		this.isNodeAttribute = true;
 
 		this.name = name;
 		this.type = type;
+		this.node = node;
 
 	}