super-three 0.137.0 → 0.141.0

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

@@ -1,218 +1,352 @@
+import { NodeUpdateType } from './constants.js';
+import { getNodesKeys } from './NodeUtils.js';
 import { MathUtils } from 'three';
 
+let _nodeId = 0;
+
 class Node {
 
-	constructor( type ) {
+	constructor( nodeType = null ) {
+
+		this.isNode = true;
+
+		this.nodeType = nodeType;
+
+		this.updateType = NodeUpdateType.None;
 
 		this.uuid = MathUtils.generateUUID();
 
-		this.name = '';
+		Object.defineProperty( this, 'id', { value: _nodeId ++ } );
+
+	}
 
-		this.type = type;
+	get type() {
 
-		this.userData = {};
+		return this.constructor.name;
 
 	}
 
-	analyze( builder, settings = {} ) {
+	getChildren() {
+
+		const children = [];
+
+		for ( const property in this ) {
+
+			const object = this[ property ];
+
+			if ( Array.isArray( object ) === true ) {
+
+				for ( const child of object ) {
 
-		builder.analyzing = true;
+					if ( child?.isNode === true ) {
 
-		this.build( builder.addFlow( settings.slot, settings.cache, settings.context ), 'v4' );
+						children.push( child );
 
-		builder.clearVertexNodeCode();
-		builder.clearFragmentNodeCode();
+					}
 
-		builder.removeFlow();
+				}
 
-		builder.analyzing = false;
+			} else if ( object?.isNode === true ) {
+
+				children.push( object );
+
+			}
+
+		}
+
+		return children;
 
 	}
 
-	analyzeAndFlow( builder, output, settings = {} ) {
+	getHash( /*builder*/ ) {
 
-		this.analyze( builder, settings );
+		return this.uuid;
 
-		return this.flow( builder, output, settings );
+	}
+
+	getUpdateType( /*builder*/ ) {
+
+		return this.updateType;
 
 	}
 
-	flow( builder, output, settings = {} ) {
+	getNodeType( /*builder*/ ) {
 
-		builder.addFlow( settings.slot, settings.cache, settings.context );
+		return this.nodeType;
 
-		const flow = {};
-		flow.result = this.build( builder, output );
-		flow.code = builder.clearNodeCode();
-		flow.extra = builder.context.extra;
+	}
 
-		builder.removeFlow();
+	getConstructHash( /*builder*/ ) {
 
-		return flow;
+		return this.uuid;
 
 	}
 
-	build( builder, output, uuid ) {
+	getReference( builder ) {
+
+		const hash = this.getHash( builder );
+		const nodeFromHash = builder.getNodeFromHash( hash );
 
-		output = output || this.getType( builder, output );
+		return nodeFromHash || this;
 
-		const data = builder.getNodeData( uuid || this );
+	}
+
+	construct( builder ) {
+
+		const nodeProperties = builder.getNodeProperties( this );
 
-		if ( builder.analyzing ) {
+		for ( const childNode of this.getChildren() ) {
 
-			this.appendDepsNode( builder, data, output );
+			nodeProperties[ '_node' + childNode.id ] = childNode;
 
 		}
 
-		if ( builder.nodes.indexOf( this ) === - 1 ) {
+		// return a outputNode if exists
+		return null;
 
-			builder.nodes.push( this );
+	}
 
-		}
+	analyze( builder ) {
+
+		const nodeData = builder.getDataFromNode( this );
+		nodeData.dependenciesCount = nodeData.dependenciesCount === undefined ? 1 : nodeData.dependenciesCount + 1;
+
+		if ( nodeData.dependenciesCount === 1 ) {
+
+			// node flow children
+
+			const nodeProperties = builder.getNodeProperties( this );
+
+			for ( const childNode of Object.values( nodeProperties ) ) {
+
+				if ( childNode?.isNode === true ) {
 
-		if ( this.updateFrame !== undefined && builder.updaters.indexOf( this ) === - 1 ) {
+					childNode.build( builder );
 
-			builder.updaters.push( this );
+				}
+
+			}
 
 		}
 
-		return this.generate( builder, output, uuid );
+	}
+
+	generate( builder ) {
+
+		const { outputNode } = builder.getNodeProperties( this );
+
+		if ( outputNode?.isNode === true ) {
+
+			const type = this.getNodeType( builder );
+
+			return outputNode.build( builder, type );
+
+		}
 
 	}
 
-	generate( /* builder, output, uuid, type, ns */ ) {
+	update( /*frame*/ ) {
 
-		// This method needs to be implemented in subclasses
+		console.warn( 'Abstract function.' );
 
 	}
 
-	getHash() {
+	build( builder, output = null ) {
 
-		let hash = '{';
-		let prop, obj;
+		const refNode = this.getReference( builder );
 
-		for ( prop in this ) {
+		if ( this !== refNode ) {
 
-			obj = this[ prop ];
+			return refNode.build( builder, output );
 
-			if ( obj instanceof Node ) {
+		}
 
-				hash += '"' + prop + '":' + obj.getHash() + ',';
+		builder.addNode( this );
+		builder.addStack( this );
+
+		/* expected return:
+			- "construct"	-> Node
+			- "analyze"		-> null
+			- "generat"		-> String
+		*/
+		let result = null;
+
+		const buildStage = builder.getBuildStage();
+
+		if ( buildStage === 'construct' ) {
+
+			const properties = builder.getNodeProperties( this );
+			const nodeData = builder.getDataFromNode( this );
+
+			if ( properties.initied !== true ) {
+
+				nodeData.initied = true;
+
+				properties.outputNode =  this.construct( builder );
+
+				for ( const childNode of Object.values( properties ) ) {
+
+					if ( childNode?.isNode === true ) {
+
+						childNode.build( builder );
+
+					}
+
+				}
 
 			}
 
-		}
+		} else if ( buildStage === 'analyze' ) {
+
+			this.analyze( builder );
+
+		} else if ( buildStage === 'generate' ) {
+
+			const isGenerateOnce = this.generate.length === 1;
+
+			if ( isGenerateOnce ) {
+
+				const type = this.getNodeType( builder );
+				const nodeData = builder.getDataFromNode( this );
+
+				result = nodeData.snippet;
+
+				if ( result === undefined ) {
+
+					result = this.generate( builder ) || '';
+
+					nodeData.snippet = result;
 
-		if ( this.hashProperties ) {
+				}
 
-			for ( let i = 0; i < this.hashProperties.length; i ++ ) {
+				result = builder.format( result, type, output );
 
-				prop = this.hashProperties[ i ];
-				obj = this[ prop ];
+			} else {
 
-				hash += '"' + prop + '":"' + String( obj ) + '",';
+				result = this.generate( builder, output ) || '';
 
 			}
 
 		}
 
-		hash += '"id":"' + this.uuid + '"}';
+		builder.removeStack( this );
 
-		return hash;
+		return result;
 
 	}
 
-	appendDepsNode( builder, data, output ) {
+	serialize( json ) {
 
-		data.deps = ( data.deps || 0 ) + 1;
+		const nodeKeys = getNodesKeys( this );
 
-		const outputLen = builder.getTypeLength( output );
+		if ( nodeKeys.length > 0 ) {
 
-		if ( outputLen > ( data.outputMax || 0 ) || this.getType( builder, output ) ) {
+			const inputNodes = {};
 
-			data.outputMax = outputLen;
-			data.output = output;
+			for ( const property of nodeKeys ) {
+
+				inputNodes[ property ] = this[ property ].toJSON( json.meta ).uuid;
+
+			}
+
+			json.inputNodes = inputNodes;
 
 		}
 
 	}
 
-	setName( name ) {
+	deserialize( json ) {
 
-		this.name = name;
+		if ( json.inputNodes !== undefined ) {
 
-		return this;
+			const nodes = json.meta.nodes;
 
-	}
+			for ( const property in json.inputNodes ) {
 
-	getName( /* builder */ ) {
+				const uuid = json.inputNodes[ property ];
 
-		return this.name;
+				this[ property ] = nodes[ uuid ];
 
-	}
-
-	getType( builder, output ) {
+			}
 
-		return output === 'sampler2D' || output === 'samplerCube' ? output : this.type;
+		}
 
 	}
 
-	getJSONNode( meta ) {
+	toJSON( meta ) {
 
-		const isRootObject = ( meta === undefined || typeof meta === 'string' );
+		const { uuid, type } = this;
+		const isRoot = ( meta === undefined || typeof meta === 'string' );
 
-		if ( ! isRootObject && meta.nodes[ this.uuid ] !== undefined ) {
+		if ( isRoot ) {
 
-			return meta.nodes[ this.uuid ];
+			meta = {
+				textures: {},
+				images: {},
+				nodes: {}
+			};
 
 		}
 
-	}
+		// serialize
 
-	copy( source ) {
+		let data = meta.nodes[ uuid ];
 
-		if ( source.name !== undefined ) this.name = source.name;
+		if ( data === undefined ) {
 
-		if ( source.userData !== undefined ) this.userData = JSON.parse( JSON.stringify( source.userData ) );
+			data = {
+				uuid,
+				type,
+				meta,
+				metadata: {
+					version: 4.5,
+					type: 'Node',
+					generator: 'Node.toJSON'
+				}
+			};
 
-		return this;
+			meta.nodes[ data.uuid ] = data;
 
-	}
+			this.serialize( data );
 
-	createJSONNode( meta ) {
+			delete data.meta;
 
-		const isRootObject = ( meta === undefined || typeof meta === 'string' );
+		}
 
-		const data = {};
+		// TODO: Copied from Object3D.toJSON
 
-		if ( typeof this.nodeType !== 'string' ) throw new Error( 'Node does not allow serialization.' );
+		function extractFromCache( cache ) {
 
-		data.uuid = this.uuid;
-		data.nodeType = this.nodeType;
+			const values = [];
 
-		if ( this.name !== '' ) data.name = this.name;
+			for ( const key in cache ) {
 
-		if ( JSON.stringify( this.userData ) !== '{}' ) data.userData = this.userData;
+				const data = cache[ key ];
+				delete data.metadata;
+				values.push( data );
 
-		if ( ! isRootObject ) {
+			}
 
-			meta.nodes[ this.uuid ] = data;
+			return values;
 
 		}
 
-		return data;
+		if ( isRoot ) {
 
-	}
+			const textures = extractFromCache( meta.textures );
+			const images = extractFromCache( meta.images );
+			const nodes = extractFromCache( meta.nodes );
 
-	toJSON( meta ) {
+			if ( textures.length > 0 ) data.textures = textures;
+			if ( images.length > 0 ) data.images = images;
+			if ( nodes.length > 0 ) data.nodes = nodes;
 
-		return this.getJSONNode( meta ) || this.createJSONNode( meta );
+		}
+
+		return data;
 
 	}
 
 }
 
-Node.prototype.isNode = true;
-Node.prototype.hashProperties = undefined;
-
-export { Node };
+export default Node;

package/examples/jsm/{renderers/nodes → nodes}/core/NodeAttribute.js

@@ -2,6 +2,8 @@ class NodeAttribute {
 
 	constructor( name, type ) {
 
+		this.isNodeAttribute = true;
+
 		this.name = name;
 		this.type = type;
 
@@ -9,6 +11,4 @@ class NodeAttribute {
 
 }
 
-NodeAttribute.prototype.isNodeAttribute = true;
-
 export default NodeAttribute;