@needle-tools/three 0.146.9 → 0.153.0

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

@@ -4,20 +4,34 @@ import NodeVarying from './NodeVarying.js';
 import NodeVar from './NodeVar.js';
 import NodeCode from './NodeCode.js';
 import NodeKeywords from './NodeKeywords.js';
-import { NodeUpdateType } from './constants.js';
-
-import { REVISION, LinearEncoding, Color, Vector2, Vector3, Vector4 } from 'three';
-
-export const defaultShaderStages = [ 'fragment', 'vertex' ];
-export const shaderStages = [ ...defaultShaderStages, 'compute' ];
-export const vector = [ 'x', 'y', 'z', 'w' ];
-
-const typeFromLength = new Map();
-typeFromLength.set( 2, 'vec2' );
-typeFromLength.set( 3, 'vec3' );
-typeFromLength.set( 4, 'vec4' );
-typeFromLength.set( 9, 'mat3' );
-typeFromLength.set( 16, 'mat4' );
+import NodeCache from './NodeCache.js';
+import { createNodeMaterialFromType } from '../materials/NodeMaterial.js';
+import { NodeUpdateType, defaultBuildStages, shaderStages } from './constants.js';
+
+import { REVISION, NoColorSpace, LinearEncoding, sRGBEncoding, SRGBColorSpace, Color, Vector2, Vector3, Vector4, Float16BufferAttribute } from 'three';
+
+import { stack } from './StackNode.js';
+import { maxMipLevel } from '../utils/MaxMipLevelNode.js';
+
+const typeFromLength = new Map( [
+	[ 2, 'vec2' ],
+	[ 3, 'vec3' ],
+	[ 4, 'vec4' ],
+	[ 9, 'mat3' ],
+	[ 16, 'mat4' ]
+] );
+
+const typeFromArray = new Map( [
+	[ Int8Array, 'int' ],
+	[ Int16Array, 'int' ],
+	[ Int32Array, 'int' ],
+	[ Uint8Array, 'uint' ],
+	[ Uint16Array, 'uint' ],
+	[ Uint32Array, 'uint' ],
+	[ Float32Array, 'float' ]
+] );
+
+const isNonPaddingElementArray = new Set( [ Int32Array, Uint32Array, Float32Array ] );
 
 const toFloat = ( value ) => {
 
@@ -32,18 +46,20 @@ class NodeBuilder {
 	constructor( object, renderer, parser ) {
 
 		this.object = object;
-		this.material = object.material || null;
-		this.geometry = object.geometry || null;
+		this.material = object && ( object.material || null );
+		this.geometry = object && ( object.geometry || null );
 		this.renderer = renderer;
 		this.parser = parser;
 
 		this.nodes = [];
 		this.updateNodes = [];
+		this.updateBeforeNodes = [];
 		this.hashNodes = {};
 
-		this.scene = null;
 		this.lightsNode = null;
+		this.environmentNode = null;
 		this.fogNode = null;
+		this.toneMappingNode = null;
 
 		this.vertexShader = null;
 		this.fragmentShader = null;
@@ -53,18 +69,27 @@ class NodeBuilder {
 		this.flowCode = { vertex: '', fragment: '', compute: [] };
 		this.uniforms = { vertex: [], fragment: [], compute: [], index: 0 };
 		this.codes = { vertex: [], fragment: [], compute: [] };
+		this.bindings = { vertex: [], fragment: [], compute: [] };
+		this.bindingsOffset = { vertex: 0, fragment: 0, compute: 0 };
+		this.bindingsArray = null;
 		this.attributes = [];
+		this.bufferAttributes = [];
 		this.varyings = [];
 		this.vars = { vertex: [], fragment: [], compute: [] };
 		this.flow = { code: '' };
-		this.stack = [];
+		this.chaining = [];
+		this.stack = stack();
+		this.tab = '\t';
 
 		this.context = {
 			keywords: new NodeKeywords(),
-			material: object.material
+			material: this.material,
+			getMIPLevelAlgorithmNode: ( textureNode, levelNode ) => levelNode.mul( maxMipLevel( textureNode ) )
 		};
 
-		this.nodesData = new WeakMap();
+		this.cache = new NodeCache();
+		this.globalCache = this.cache;
+
 		this.flowsData = new WeakMap();
 
 		this.shaderStage = null;
@@ -72,35 +97,19 @@ class NodeBuilder {
 
 	}
 
-	get node() {
+	getBindings() {
 
-		return this.stack[ this.stack.length - 1 ];
+		let bindingsArray = this.bindingsArray;
 
-	}
+		if ( bindingsArray === null ) {
 
-	addStack( node ) {
+			const bindings = this.bindings;
 
-		/*
-		if ( this.stack.indexOf( node ) !== - 1 ) {
-
-			console.warn( 'Recursive node: ', node );
+			this.bindingsArray = bindingsArray = ( this.material !== null ) ? [ ...bindings.vertex, ...bindings.fragment ] : bindings.compute;
 
 		}
-		*/
 
-		this.stack.push( node );
-
-	}
-
-	removeStack( node ) {
-
-		const lastStack = this.stack.pop();
-
-		if ( lastStack !== node ) {
-
-			throw new Error( 'NodeBuilder: Invalid node stack!' );
-
-		}
+		return bindingsArray;
 
 	}
 
@@ -114,7 +123,8 @@ class NodeBuilder {
 
 		if ( this.nodes.indexOf( node ) === - 1 ) {
 
-			const updateType = node.getUpdateType( this );
+			const updateType = node.getUpdateType();
+			const updateBeforeType = node.getUpdateBeforeType();
 
 			if ( updateType !== NodeUpdateType.NONE ) {
 
@@ -122,6 +132,12 @@ class NodeBuilder {
 
 			}
 
+			if ( updateBeforeType !== NodeUpdateType.NONE ) {
+
+				this.updateBeforeNodes.push( node );
+
+			}
+
 			this.nodes.push( node );
 
 			this.setHashNode( node, node.getHash( this ) );
@@ -130,6 +146,38 @@ class NodeBuilder {
 
 	}
 
+	get currentNode() {
+
+		return this.chaining[ this.chaining.length - 1 ];
+
+	}
+
+	addChain( node ) {
+
+		/*
+		if ( this.chaining.indexOf( node ) !== - 1 ) {
+
+			console.warn( 'Recursive node: ', node );
+
+		}
+		*/
+
+		this.chaining.push( node );
+
+	}
+
+	removeChain( node ) {
+
+		const lastChain = this.chaining.pop();
+
+		if ( lastChain !== node ) {
+
+			throw new Error( 'NodeBuilder: Invalid node chaining!' );
+
+		}
+
+	}
+
 	getMethod( method ) {
 
 		return method;
@@ -162,55 +210,55 @@ class NodeBuilder {
 
 	}
 
-	isAvailable( /*name*/ ) {
+	setCache( cache ) {
 
-		return false;
+		this.cache = cache;
 
 	}
 
-	getInstanceIndex() {
+	getCache() {
 
-		console.warn( 'Abstract function.' );
+		return this.cache;
 
 	}
 
-	getFrontFacing() {
+	isAvailable( /*name*/ ) {
 
-		console.warn( 'Abstract function.' );
+		return false;
 
 	}
 
-	getFragCoord() {
+	getInstanceIndex() {
 
 		console.warn( 'Abstract function.' );
 
 	}
 
-	isFlipY() {
+	getFrontFacing() {
 
-		return false;
+		console.warn( 'Abstract function.' );
 
 	}
 
-	getTexture( /* textureProperty, uvSnippet */ ) {
+	getFragCoord() {
 
 		console.warn( 'Abstract function.' );
 
 	}
 
-	getTextureLevel( /* textureProperty, uvSnippet, levelSnippet */ ) {
+	isFlipY() {
 
-		console.warn( 'Abstract function.' );
+		return false;
 
 	}
 
-	getCubeTexture( /* textureProperty, uvSnippet */ ) {
+	getTexture( /* texture, textureProperty, uvSnippet */ ) {
 
 		console.warn( 'Abstract function.' );
 
 	}
 
-	getCubeTextureLevel( /* textureProperty, uvSnippet, levelSnippet */ ) {
+	getTextureLevel( /* texture, textureProperty, uvSnippet, levelSnippet */ ) {
 
 		console.warn( 'Abstract function.' );
 
@@ -254,6 +302,10 @@ class NodeBuilder {
 
 			return `${ this.getType( type ) }( ${ getConst( value.x ) }, ${ getConst( value.y ) }, ${ getConst( value.z ) }, ${ getConst( value.w ) } )`;
 
+		} else if ( typeLength > 4 && value && ( value.isMatrix3 || value.isMatrix4 ) ) {
+
+			return `${ this.getType( type ) }( ${ value.elements.map( getConst ).join( ', ' ) } )`;
+
 		} else if ( typeLength > 4 ) {
 
 			return `${ this.getType( type ) }()`;
@@ -278,7 +330,7 @@ class NodeBuilder {
 
 	hasGeometryAttribute( name ) {
 
-		return this.geometry?.getAttribute( name ) !== undefined;
+		return this.geometry && this.geometry.getAttribute( name ) !== undefined;
 
 	}
 
@@ -332,31 +384,33 @@ class NodeBuilder {
 
 	}
 
-	isShaderStage( shaderStage ) {
+	/** @deprecated, r152 */
+	getTextureEncodingFromMap( map ) {
 
-		return this.shaderStage === shaderStage;
+		console.warn( 'THREE.NodeBuilder: Method .getTextureEncodingFromMap replaced by .getTextureColorSpaceFromMap in r152+.' );
+		return this.getTextureColorSpaceFromMap( map ) === SRGBColorSpace ? sRGBEncoding : LinearEncoding;
 
 	}
 
-	getTextureEncodingFromMap( map ) {
+	getTextureColorSpaceFromMap( map ) {
 
-		let encoding;
+		let colorSpace;
 
 		if ( map && map.isTexture ) {
 
-			encoding = map.encoding;
+			colorSpace = map.colorSpace;
 
 		} else if ( map && map.isWebGLRenderTarget ) {
 
-			encoding = map.texture.encoding;
+			colorSpace = map.texture.colorSpace;
 
 		} else {
 
-			encoding = LinearEncoding;
+			colorSpace = NoColorSpace;
 
 		}
 
-		return encoding;
+		return colorSpace;
 
 	}
 
@@ -390,12 +444,42 @@ class NodeBuilder {
 	getTypeFromLength( length, componentType = 'float' ) {
 
 		if ( length === 1 ) return componentType;
+
 		const baseType = typeFromLength.get( length );
 		const prefix = componentType === 'float' ? '' : componentType[ 0 ];
+
 		return prefix + baseType;
 
 	}
 
+	getTypeFromArray( array ) {
+
+		return typeFromArray.get( array.constructor );
+
+	}
+
+	getTypeFromAttribute( attribute ) {
+
+		let dataAttribute = attribute;
+
+		if ( attribute.isInterleavedBufferAttribute ) dataAttribute = attribute.data;
+
+		const array = dataAttribute.array;
+		const itemSize = isNonPaddingElementArray.has( array.constructor ) ? attribute.itemSize : dataAttribute.stride || attribute.itemSize;
+		const normalized = attribute.normalized;
+
+		let arrayType;
+
+		if ( ! ( attribute instanceof Float16BufferAttribute ) && normalized !== true ) {
+
+			arrayType = this.getTypeFromArray( array );
+
+		}
+
+		return this.getTypeFromLength( itemSize, arrayType );
+
+	}
+
 	getTypeLength( type ) {
 
 		const vecType = this.getVectorType( type );
@@ -432,15 +516,35 @@ class NodeBuilder {
 
 	}
 
+	addStack() {
+
+		this.stack = stack( this.stack );
+
+		return this.stack;
+
+	}
+
+	removeStack() {
+
+		const currentStack = this.stack;
+
+		this.stack = currentStack.parent;
+
+		return currentStack;
+
+	}
+
 	getDataFromNode( node, shaderStage = this.shaderStage ) {
 
-		let nodeData = this.nodesData.get( node );
+		const cache = node.isGlobal( this ) ? this.globalCache : this.cache;
+
+		let nodeData = cache.getNodeData( node );
 
 		if ( nodeData === undefined ) {
 
 			nodeData = { vertex: {}, fragment: {}, compute: {} };
 
-			this.nodesData.set( node, nodeData );
+			cache.setNodeData( node, nodeData );
 
 		}
 
@@ -450,17 +554,35 @@ class NodeBuilder {
 
 	getNodeProperties( node, shaderStage = this.shaderStage ) {
 
-		const nodeData = this.getDataFromNode( this, shaderStage );
-		const constructHash = node.getConstructHash( this );
+		const nodeData = this.getDataFromNode( node, shaderStage );
+
+		return nodeData.properties || ( nodeData.properties = { outputNode: null } );
+
+	}
+
+	getBufferAttributeFromNode( node, type ) {
+
+		const nodeData = this.getDataFromNode( node );
+
+		let bufferAttribute = nodeData.bufferAttribute;
+
+		if ( bufferAttribute === undefined ) {
 
-		nodeData.properties = nodeData.properties || {};
-		nodeData.properties[ constructHash ] = nodeData.properties[ constructHash ] || { outputNode: null };
+			const index = this.uniforms.index ++;
+
+			bufferAttribute = new NodeAttribute( 'nodeAttribute' + index, type, node );
+
+			this.bufferAttributes.push( bufferAttribute );
+
+			nodeData.bufferAttribute = bufferAttribute;
+
+		}
 
-		return nodeData.properties[ constructHash ];
+		return bufferAttribute;
 
 	}
 
-	getUniformFromNode( node, shaderStage, type ) {
+	getUniformFromNode( node, type, shaderStage = this.shaderStage ) {
 
 		const nodeData = this.getDataFromNode( node, shaderStage );
 
@@ -551,10 +673,46 @@ class NodeBuilder {
 
 	}
 
+	addLineFlowCode( code ) {
+
+		if ( code === '' ) return this;
+
+		code = this.tab + code;
+
+		if ( ! /;\s*$/.test( code ) ) {
+
+			code = code + ';\n';
+
+		}
+
+		this.flow.code += code;
+
+		return this;
+
+	}
+
 	addFlowCode( code ) {
 
 		this.flow.code += code;
 
+		return this;
+
+	}
+
+	addFlowTab() {
+
+		this.tab += '\t';
+
+		return this;
+
+	}
+
+	removeFlowTab() {
+
+		this.tab = this.tab.slice( 0, - 1 );
+
+		return this;
+
 	}
 
 	getFlowData( node/*, shaderStage*/ ) {
@@ -603,7 +761,7 @@ class NodeBuilder {
 
 		if ( propertyName !== null ) {
 
-			flowData.code += `${propertyName} = ${flowData.result};\n\t`;
+			flowData.code += `${ this.tab + propertyName } = ${ flowData.result };\n`;
 
 		}
 
@@ -615,6 +773,12 @@ class NodeBuilder {
 
 	}
 
+	getAttributesArray() {
+
+		return this.attributes.concat( this.bufferAttributes );
+
+	}
+
 	getAttributes( /*shaderStage*/ ) {
 
 		console.warn( 'Abstract function.' );
@@ -627,6 +791,12 @@ class NodeBuilder {
 
 	}
 
+	getVar( type, name ) {
+
+		return `${type} ${name}`;
+
+	}
+
 	getVars( shaderStage ) {
 
 		let snippet = '';
@@ -635,7 +805,7 @@ class NodeBuilder {
 
 		for ( const variable of vars ) {
 
-			snippet += `${variable.type} ${variable.name}; `;
+			snippet += `${ this.getVar( variable.type, variable.name ) }; `;
 
 		}
 
@@ -703,65 +873,39 @@ class NodeBuilder {
 
 	build() {
 
-		// stage 1: generate shader node
-
-		this.setBuildStage( 'construct' );
+		// construct() -> stage 1: create possible new nodes and returns an output reference node
+		// analyze()   -> stage 2: analyze nodes to possible optimization and validation
+		// generate()  -> stage 3: generate shader
 
-		for ( const shaderStage of shaderStages ) {
+		for ( const buildStage of defaultBuildStages ) {
 
-			this.setShaderStage( shaderStage );
+			this.setBuildStage( buildStage );
 
-			const flowNodes = this.flowNodes[ shaderStage ];
+			if ( this.context.vertex && this.context.vertex.isNode ) {
 
-			for ( const node of flowNodes ) {
-
-				node.build( this );
+				this.flowNodeFromShaderStage( 'vertex', this.context.vertex );
 
 			}
 
-		}
-
-		// stage 2: analyze nodes to possible optimization and validation
+			for ( const shaderStage of shaderStages ) {
 
-		this.setBuildStage( 'analyze' );
+				this.setShaderStage( shaderStage );
 
-		for ( const shaderStage of shaderStages ) {
+				const flowNodes = this.flowNodes[ shaderStage ];
 
-			this.setShaderStage( shaderStage );
+				for ( const node of flowNodes ) {
 
-			const flowNodes = this.flowNodes[ shaderStage ];
+					if ( buildStage === 'generate' ) {
 
-			for ( const node of flowNodes ) {
+						this.flowNode( node );
 
-				node.build( this );
+					} else {
 
-			}
-
-		}
+						node.build( this );
 
-		// stage 3: pre-build vertex code used in fragment shader
-
-		this.setBuildStage( 'generate' );
-
-		if ( this.context.vertex && this.context.vertex.isNode ) {
-
-			this.flowNodeFromShaderStage( 'vertex', this.context.vertex );
-
-		}
+					}
 
-		// stage 4: generate shader
-
-		this.setBuildStage( 'generate' );
-
-		for ( const shaderStage of shaderStages ) {
-
-			this.setShaderStage( shaderStage );
-
-			const flowNodes = this.flowNodes[ shaderStage ];
-
-			for ( const node of flowNodes ) {
-
-				this.flowNode( node );
+				}
 
 			}
 
@@ -770,7 +914,7 @@ class NodeBuilder {
 		this.setBuildStage( null );
 		this.setShaderStage( null );
 
-		// stage 5: build code for a specific output
+		// stage 4: build code for a specific output
 
 		this.buildCode();
 
@@ -778,6 +922,12 @@ class NodeBuilder {
 
 	}
 
+	createNodeMaterial( type ) {
+
+		return createNodeMaterialFromType( type );
+
+	}
+
 	format( snippet, fromType, toType ) {
 
 		fromType = this.getVectorType( fromType );
@@ -816,7 +966,7 @@ class NodeBuilder {
 
 		if ( fromTypeLength > toTypeLength ) {
 
-			return this.format( `${ snippet }.${ 'xyz'.slice( 0, toTypeLength ) }`, this.getTypeFromLength( toTypeLength ), toType );
+			return this.format( `${ snippet }.${ 'xyz'.slice( 0, toTypeLength ) }`, this.getTypeFromLength( toTypeLength, this.getComponentType( fromType ) ), toType );
 
 		}
 

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

@@ -0,0 +1,26 @@
+let id = 0;
+
+class NodeCache {
+
+	constructor() {
+
+		this.id = id ++;
+		this.nodesData = new WeakMap();
+
+	}
+
+	getNodeData( node ) {
+
+		return this.nodesData.get( node );
+
+	}
+
+	setNodeData( node, data ) {
+
+		this.nodesData.set( node, data );
+
+	}
+
+}
+
+export default NodeCache;