super-three 0.137.0 → 0.141.0

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

@@ -1,278 +1,105 @@
-import { TempNode } from './TempNode.js';
-import { NodeLib } from './NodeLib.js';
+import CodeNode from './CodeNode.js';
+import FunctionCallNode from './FunctionCallNode.js';
 
-const declarationRegexp = /^\s*([a-z_0-9]+)\s+([a-z_0-9]+)\s*\(([\s\S]*?)\)/i,
-	propertiesRegexp = /[a-z_0-9]+/ig;
+class FunctionNode extends CodeNode {
 
-class FunctionNode extends TempNode {
+	constructor( code = '' ) {
 
-	constructor( src, includes, extensions, keywords, type ) {
+		super( code );
 
-		super( type );
-
-		this.isMethod = type === undefined;
-		this.isInterface = false;
-
-		this.parse( src, includes, extensions, keywords );
+		this.keywords = {};
 
 	}
 
-	getShared( /* builder, output */ ) {
+	getNodeType( builder ) {
 
-		return ! this.isMethod;
+		return this.getNodeFunction( builder ).type;
 
 	}
 
-	getType( builder ) {
+	getInputs( builder ) {
 
-		return builder.getTypeByFormat( this.type );
+		return this.getNodeFunction( builder ).inputs;
 
 	}
 
-	getInputByName( name ) {
+	getNodeFunction( builder ) {
 
-		let i = this.inputs.length;
+		const nodeData = builder.getDataFromNode( this );
 
-		while ( i -- ) {
+		let nodeFunction = nodeData.nodeFunction;
 
-			if ( this.inputs[ i ].name === name ) {
+		if ( nodeFunction === undefined ) {
 
-				return this.inputs[ i ];
+			nodeFunction = builder.parser.parseFunction( this.code );
 
-			}
+			nodeData.nodeFunction = nodeFunction;
 
 		}
 
-	}
-
-	getIncludeByName( name ) {
-
-		let i = this.includes.length;
-
-		while ( i -- ) {
+		return nodeFunction;
 
-			if ( this.includes[ i ].name === name ) {
-
-				return this.includes[ i ];
+	}
 
-			}
+	call( parameters = {} ) {
 
-		}
+		return new FunctionCallNode( this, parameters );
 
 	}
 
 	generate( builder, output ) {
 
-		let match, offset = 0, src = this.src;
-
-		for ( let i = 0; i < this.includes.length; i ++ ) {
-
-			builder.include( this.includes[ i ], this );
-
-		}
-
-		for ( const ext in this.extensions ) {
-
-			builder.extensions[ ext ] = true;
-
-		}
-
-		const matches = [];
-
-		while ( match = propertiesRegexp.exec( this.src ) ) matches.push( match );
-
-		for ( let i = 0; i < matches.length; i ++ ) {
-
-			const match = matches[ i ];
-
-			const prop = match[ 0 ],
-				isGlobal = this.isMethod ? ! this.getInputByName( prop ) : true;
-
-			let reference = prop;
-
-			if ( this.keywords[ prop ] || ( this.useKeywords && isGlobal && NodeLib.containsKeyword( prop ) ) ) {
-
-				let node = this.keywords[ prop ];
-
-				if ( ! node ) {
-
-					const keyword = NodeLib.getKeywordData( prop );
-
-					if ( keyword.cache ) node = builder.keywords[ prop ];
-
-					node = node || NodeLib.getKeyword( prop, builder );
-
-					if ( keyword.cache ) builder.keywords[ prop ] = node;
-
-				}
-
-				reference = node.build( builder );
-
-			}
-
-			if ( prop !== reference ) {
-
-				src = src.substring( 0, match.index + offset ) + reference + src.substring( match.index + prop.length + offset );
-
-				offset += reference.length - prop.length;
-
-			}
-
-			if ( this.getIncludeByName( reference ) === undefined && NodeLib.contains( reference ) ) {
-
-				builder.include( NodeLib.get( reference ) );
-
-			}
-
-		}
-
-		if ( output === 'source' ) {
-
-			return src;
+		super.generate( builder );
 
-		} else if ( this.isMethod ) {
+		const nodeFunction = this.getNodeFunction( builder );
 
-			if ( ! this.isInterface ) {
+		const name = nodeFunction.name;
+		const type = nodeFunction.type;
 
-				builder.include( this, false, src );
+		const nodeCode = builder.getCodeFromNode( this, type );
 
-			}
-
-			return this.name;
+		if ( name !== '' ) {
 
-		} else {
+			// use a custom property name
 
-			return builder.format( '( ' + src + ' )', this.getType( builder ), output );
+			nodeCode.name = name;
 
 		}
 
-	}
-
-	parse( src, includes, extensions, keywords ) {
-
-		this.src = src || '';
-
-		this.includes = includes || [];
-		this.extensions = extensions || {};
-		this.keywords = keywords || {};
-
-		if ( this.isMethod ) {
-
-			const match = this.src.match( declarationRegexp );
-
-			this.inputs = [];
-
-			if ( match && match.length == 4 ) {
-
-				this.type = match[ 1 ];
-				this.name = match[ 2 ];
-
-				const inputs = match[ 3 ].match( propertiesRegexp );
+		const propertyName = builder.getPropertyName( nodeCode );
 
-				if ( inputs ) {
+		let code = this.getNodeFunction( builder ).getCode( propertyName );
 
-					let i = 0;
+		const keywords = this.keywords;
+		const keywordsProperties = Object.keys( keywords );
 
-					while ( i < inputs.length ) {
+		if ( keywordsProperties.length > 0 ) {
 
-						let qualifier = inputs[ i ++ ];
-						let type;
+			for ( const property of keywordsProperties ) {
 
-						if ( qualifier === 'in' || qualifier === 'out' || qualifier === 'inout' ) {
+				const propertyRegExp = new RegExp( `\\b${property}\\b`, 'g' );
+				const nodeProperty = keywords[ property ].build( builder, 'property' );
 
-							type = inputs[ i ++ ];
-
-						} else {
-
-							type = qualifier;
-							qualifier = '';
-
-						}
-
-						const name = inputs[ i ++ ];
-
-						this.inputs.push( {
-							name: name,
-							type: type,
-							qualifier: qualifier
-						} );
-
-					}
-
-				}
-
-				this.isInterface = this.src.indexOf( '{' ) === - 1;
-
-			} else {
-
-				this.type = '';
-				this.name = '';
+				code = code.replace( propertyRegExp, nodeProperty );
 
 			}
 
 		}
 
-	}
-
-	copy( source ) {
+		nodeCode.code = code;
 
-		super.copy( source );
+		if ( output === 'property' ) {
 
-		this.isMethod = source.isMethod;
-		this.useKeywords = source.useKeywords;
+			return propertyName;
 
-		this.parse( source.src, source.includes, source.extensions, source.keywords );
-
-		if ( source.type !== undefined ) this.type = source.type;
-
-		return this;
-
-	}
-
-	toJSON( meta ) {
-
-		let data = this.getJSONNode( meta );
-
-		if ( ! data ) {
-
-			data = this.createJSONNode( meta );
-
-			data.src = this.src;
-			data.isMethod = this.isMethod;
-			data.useKeywords = this.useKeywords;
-
-			if ( ! this.isMethod ) data.type = this.type;
-
-			data.extensions = JSON.parse( JSON.stringify( this.extensions ) );
-			data.keywords = {};
-
-			for ( const keyword in this.keywords ) {
-
-				data.keywords[ keyword ] = this.keywords[ keyword ].toJSON( meta ).uuid;
-
-			}
-
-			if ( this.includes.length ) {
-
-				data.includes = [];
-
-				for ( let i = 0; i < this.includes.length; i ++ ) {
-
-					data.includes.push( this.includes[ i ].toJSON( meta ).uuid );
-
-				}
+		} else {
 
-			}
+			return builder.format( `${ propertyName }()`, type, output );
 
 		}
 
-		return data;
-
 	}
 
 }
 
-FunctionNode.prototype.nodeType = 'Function';
-FunctionNode.prototype.useKeywords = true;
-
-export { FunctionNode };
+export default FunctionNode;

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

@@ -1,94 +1,62 @@
-import { TempNode } from './TempNode.js';
+import Node from './Node.js';
+import { getValueType, getValueFromType } from './NodeUtils.js';
 
-class InputNode extends TempNode {
+class InputNode extends Node {
 
-	constructor( type, params ) {
+	constructor( value, nodeType = null ) {
 
-		params = params || {};
-		params.shared = params.shared !== undefined ? params.shared : false;
+		super( nodeType );
 
-		super( type, params );
+		this.isInputNode = true;
 
-		this.readonly = false;
+		this.value = value;
 
 	}
 
-	setReadonly( value ) {
+	getNodeType( /*builder*/ ) {
 
-		this.readonly = value;
+		if ( this.nodeType === null ) {
 
-		this.hashProperties = this.readonly ? [ 'value' ] : undefined;
+			return getValueType( this.value );
 
-		return this;
-
-	}
-
-	getReadonly( /* builder */ ) {
+		}
 
-		return this.readonly;
+		return this.nodeType;
 
 	}
 
-	copy( source ) {
-
-		super.copy( source );
-
-		if ( source.readonly !== undefined ) this.readonly = source.readonly;
+	getInputType( builder ) {
 
-		return this;
+		return this.getNodeType( builder );
 
 	}
 
-	createJSONNode( meta ) {
+	serialize( data ) {
 
-		const data = super.createJSONNode( meta );
+		super.serialize( data );
 
-		if ( this.readonly === true ) data.readonly = this.readonly;
-
-		return data;
+		data.value = this.value?.toArray?.() || this.value;
+		data.valueType = getValueType( this.value );
+		data.nodeType = this.nodeType;
 
 	}
 
-	generate( builder, output, uuid, type, ns, needsUpdate ) {
-
-		uuid = builder.getUuid( uuid || this.getUuid() );
-		type = type || this.getType( builder );
-
-		const data = builder.getNodeData( uuid ),
-			readonly = this.getReadonly( builder ) && this.generateReadonly !== undefined;
-
-		if ( readonly ) {
-
-			return this.generateReadonly( builder, output, uuid, type, ns, needsUpdate );
+	deserialize( data ) {
 
-		} else {
+		super.deserialize( data );
 
-			if ( builder.isShader( 'vertex' ) ) {
+		this.nodeType = data.nodeType;
+		this.value = getValueFromType( data.valueType );
+		this.value = this.value?.fromArray?.( data.value ) || data.value;
 
-				if ( ! data.vertex ) {
-
-					data.vertex = builder.createVertexUniform( type, this, ns, needsUpdate, this.getLabel() );
-
-				}
-
-				return builder.format( data.vertex.name, type, output );
-
-			} else {
-
-				if ( ! data.fragment ) {
-
-					data.fragment = builder.createFragmentUniform( type, this, ns, needsUpdate, this.getLabel() );
-
-				}
-
-				return builder.format( data.fragment.name, type, output );
+	}
 
-			}
+	generate( /*builder, output*/ ) {
 
-		}
+		console.warn( 'Abstract function.' );
 
 	}
 
 }
 
-export { InputNode };
+export default InputNode;

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

@@ -0,0 +1,21 @@
+import Node from './Node.js';
+
+class InstanceIndexNode extends Node {
+
+	constructor() {
+
+		super( 'uint' );
+
+		this.isInstanceIndexNode = true;
+
+	}
+
+	generate( builder ) {
+
+		return builder.getInstanceIndex();
+
+	}
+
+}
+
+export default InstanceIndexNode;