@needle-tools/three 0.146.10 → 0.153.0

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

@@ -8,31 +8,82 @@ class NodeFrame {
 		this.deltaTime = 0;
 
 		this.frameId = 0;
+		this.renderId = 0;
 
 		this.startTime = null;
 
-		this.updateMap = new WeakMap();
+		this.frameMap = new WeakMap();
+		this.frameBeforeMap = new WeakMap();
+		this.renderMap = new WeakMap();
+		this.renderBeforeMap = new WeakMap();
 
 		this.renderer = null;
 		this.material = null;
 		this.camera = null;
 		this.object = null;
+		this.scene = null;
+
+	}
+
+	updateBeforeNode( node ) {
+
+		const updateType = node.getUpdateBeforeType();
+
+		if ( updateType === NodeUpdateType.FRAME ) {
+
+			if ( this.frameBeforeMap.get( node ) !== this.frameId ) {
+
+				this.frameBeforeMap.set( node, this.frameId );
+
+				node.updateBefore( this );
+
+			}
+
+		} else if ( updateType === NodeUpdateType.RENDER ) {
+
+			if ( this.renderBeforeMap.get( node ) !== this.renderId || this.frameBeforeMap.get( node ) !== this.frameId ) {
+
+				this.renderBeforeMap.set( node, this.renderId );
+				this.frameBeforeMap.set( node, this.frameId );
+
+				node.updateBefore( this );
+
+			}
+
+		} else if ( updateType === NodeUpdateType.OBJECT ) {
+
+			node.updateBefore( this );
+
+		}
 
 	}
 
 	updateNode( node ) {
 
-		if ( node.updateType === NodeUpdateType.FRAME ) {
+		const updateType = node.getUpdateType();
+
+		if ( updateType === NodeUpdateType.FRAME ) {
+
+			if ( this.frameMap.get( node ) !== this.frameId ) {
+
+				this.frameMap.set( node, this.frameId );
+
+				node.update( this );
+
+			}
+
+		} else if ( updateType === NodeUpdateType.RENDER ) {
 
-			if ( this.updateMap.get( node ) !== this.frameId ) {
+			if ( this.renderMap.get( node ) !== this.renderId || this.frameMap.get( node ) !== this.frameId ) {
 
-				this.updateMap.set( node, this.frameId );
+				this.renderMap.set( node, this.renderId );
+				this.frameMap.set( node, this.frameId );
 
 				node.update( this );
 
 			}
 
-		} else if ( node.updateType === NodeUpdateType.OBJECT ) {
+		} else if ( updateType === NodeUpdateType.OBJECT ) {
 
 			node.update( this );
 

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

@@ -1,18 +1,22 @@
 import { Color, Matrix3, Matrix4, Vector2, Vector3, Vector4 } from 'three';
 
-export const getCacheKey = ( object ) => {
+export function getCacheKey( object ) {
 
 	let cacheKey = '{';
 
 	if ( object.isNode === true ) {
 
-		cacheKey += `uuid:"${ object.uuid }",`;
+		cacheKey += `uuid:"${ object.uuid }"`;
 
 	}
 
-	for ( const property of getNodesKeys( object ) ) {
+	for ( const { property, index, childNode } of getNodeChildren( object ) ) {
 
-		cacheKey += `${ property }:${ object[ property ].getCacheKey() },`;
+		// @TODO: Think about implement NodeArray and NodeObject.
+
+		let childCacheKey = getCacheKey( childNode );
+		if ( ! childCacheKey.includes( ',' ) ) childCacheKey = childCacheKey.slice( childCacheKey.indexOf( '"' ), childCacheKey.indexOf( '}' ) );
+		cacheKey += `,${ property }${ index !== undefined ? '/' + index : '' }:${ childCacheKey }`;
 
 	}
 
@@ -20,71 +24,124 @@ export const getCacheKey = ( object ) => {
 
 	return cacheKey;
 
-};
+}
+
+export function* getNodeChildren( node, toJSON = false ) {
+
+	for ( const property in node ) {
+
+		// Ignore private properties.
+		if ( property.startsWith( '_' ) === true ) continue;
+
+		const object = node[ property ];
+
+		if ( Array.isArray( object ) === true ) {
+
+			for ( let i = 0; i < object.length; i ++ ) {
+
+				const child = object[ i ];
+
+				if ( child && ( child.isNode === true || toJSON && typeof child.toJSON === 'function' ) ) {
+
+					yield { property, index: i, childNode: child };
+
+				}
 
-export const getNodesKeys = ( object ) => {
+			}
 
-	const props = [];
+		} else if ( object && object.isNode === true ) {
 
-	for ( const name in object ) {
+			yield { property, childNode: object };
 
-		const value = object[ name ];
+		} else if ( typeof object === 'object' ) {
 
-		if ( value && value.isNode === true ) {
+			for ( const subProperty in object ) {
 
-			props.push( name );
+				const child = object[ subProperty ];
+
+				if ( child && ( child.isNode === true || toJSON && typeof child.toJSON === 'function' ) ) {
+
+					yield { property, index: subProperty, childNode: child };
+
+				}
+
+			}
 
 		}
 
 	}
 
-	return props;
+}
+
+export function getValueType( value ) {
+
+	if ( value === undefined || value === null ) return null;
 
-};
+	const typeOf = typeof value;
 
-export const getValueType = ( value ) => {
+	if ( value.isNode === true ) {
 
-	if ( typeof value === 'number' ) {
+		return 'node';
+
+	} else if ( typeOf === 'number' ) {
 
 		return 'float';
 
-	} else if ( typeof value === 'boolean' ) {
+	} else if ( typeOf === 'boolean' ) {
 
 		return 'bool';
 
-	} else if ( value?.isVector2 === true ) {
+	} else if ( typeOf === 'string' ) {
+
+		return 'string';
+
+	} else if ( typeOf === 'function' ) {
+
+		return 'shader';
+
+	} else if ( value.isVector2 === true ) {
 
 		return 'vec2';
 
-	} else if ( value?.isVector3 === true ) {
+	} else if ( value.isVector3 === true ) {
 
 		return 'vec3';
 
-	} else if ( value?.isVector4 === true ) {
+	} else if ( value.isVector4 === true ) {
 
 		return 'vec4';
 
-	} else if ( value?.isMatrix3 === true ) {
+	} else if ( value.isMatrix3 === true ) {
 
 		return 'mat3';
 
-	} else if ( value?.isMatrix4 === true ) {
+	} else if ( value.isMatrix4 === true ) {
 
 		return 'mat4';
 
-	} else if ( value?.isColor === true ) {
+	} else if ( value.isColor === true ) {
 
 		return 'color';
 
+	} else if ( value instanceof ArrayBuffer ) {
+
+		return 'ArrayBuffer';
+
 	}
 
 	return null;
 
-};
+}
+
+export function getValueFromType( type, ...params ) {
 
-export const getValueFromType = ( type, ...params ) => {
+	const last4 = type ? type.slice( - 4 ) : undefined;
 
-	const last4 = type?.slice( - 4 );
+	if ( ( last4 === 'vec2' || last4 === 'vec3' || last4 === 'vec4' ) && params.length === 1 ) { // ensure same behaviour as in NodeBuilder.format()
+
+		params = last4 === 'vec2' ? [ params[ 0 ], params[ 0 ] ] : [ params[ 0 ], params[ 0 ], params[ 0 ] ];
+
+	}
 
 	if ( type === 'color' ) {
 
@@ -112,14 +169,44 @@ export const getValueFromType = ( type, ...params ) => {
 
 	} else if ( type === 'bool' ) {
 
-		return false;
+		return params[ 0 ] || false;
 
 	} else if ( ( type === 'float' ) || ( type === 'int' ) || ( type === 'uint' ) ) {
 
-		return 0;
+		return params[ 0 ] || 0;
+
+	} else if ( type === 'string' ) {
+
+		return params[ 0 ] || '';
+
+	} else if ( type === 'ArrayBuffer' ) {
+
+		return base64ToArrayBuffer( params[ 0 ] );
 
 	}
 
 	return null;
 
-};
+}
+
+export function arrayBufferToBase64( arrayBuffer ) {
+
+	let chars = '';
+
+	const array = new Uint8Array( arrayBuffer );
+
+	for ( let i = 0; i < array.length; i ++ ) {
+
+		chars += String.fromCharCode( array[ i ] );
+
+	}
+
+	return btoa( chars );
+
+}
+
+export function base64ToArrayBuffer( base64 ) {
+
+	return Uint8Array.from( atob( base64 ), c => c.charCodeAt( 0 ) ).buffer;
+
+}

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

@@ -1,8 +1,9 @@
-import Node from './Node.js';
+import Node, { addNodeClass } from './Node.js';
+import { nodeImmutable, nodeObject } from '../shadernode/ShaderNode.js';
 
 class PropertyNode extends Node {
 
-	constructor( name = null, nodeType = 'vec4' ) {
+	constructor( nodeType, name = null ) {
 
 		super( nodeType );
 
@@ -16,6 +17,12 @@ class PropertyNode extends Node {
 
 	}
 
+	isGlobal( /*builder*/ ) {
+
+		return true;
+
+	}
+
 	generate( builder ) {
 
 		const nodeVary = builder.getVarFromNode( this, this.getNodeType( builder ) );
@@ -34,3 +41,13 @@ class PropertyNode extends Node {
 }
 
 export default PropertyNode;
+
+export const property = ( type, name ) => nodeObject( new PropertyNode( type, name ) );
+
+export const diffuseColor = nodeImmutable( PropertyNode, 'vec4', 'DiffuseColor' );
+export const roughness = nodeImmutable( PropertyNode, 'float', 'Roughness' );
+export const metalness = nodeImmutable( PropertyNode, 'float', 'Metalness' );
+export const specularColor = nodeImmutable( PropertyNode, 'color', 'SpecularColor' );
+export const shininess = nodeImmutable( PropertyNode, 'float', 'Shininess' );
+
+addNodeClass( PropertyNode );

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

@@ -0,0 +1,99 @@
+import Node, { addNodeClass } from './Node.js';
+import { assign } from '../math/OperatorNode.js';
+import { bypass } from '../core/BypassNode.js';
+import { expression } from '../code/ExpressionNode.js';
+import { cond } from '../math/CondNode.js';
+import { loop } from '../utils/LoopNode.js';
+import { nodeProxy, shader } from '../shadernode/ShaderNode.js';
+
+class StackNode extends Node {
+
+	constructor( parent = null ) {
+
+		super();
+
+		this.nodes = [];
+		this.outputNode = null;
+
+		this.parent = parent;
+
+		this._currentCond = null;
+
+		this.isStackNode = true;
+
+	}
+
+	getNodeType( builder ) {
+
+		return this.outputNode ? this.outputNode.getNodeType( builder ) : 'void';
+
+	}
+
+	add( node ) {
+
+		this.nodes.push( bypass( expression(), node ) );
+
+		return this;
+
+	}
+
+	if( boolNode, method ) {
+
+		const methodNode = shader( method );
+		this._currentCond = cond( boolNode, methodNode );
+
+		return this.add( this._currentCond );
+
+	}
+
+	elseif( boolNode, method ) {
+
+		const methodNode = shader( method );
+		const ifNode = cond( boolNode, methodNode );
+
+		this._currentCond.elseNode = ifNode;
+		this._currentCond = ifNode;
+
+		return this;
+
+	}
+
+	else( method ) {
+
+		this._currentCond.elseNode = shader( method );
+
+		return this;
+
+	}
+
+	assign( targetNode, sourceValue ) {
+
+		return this.add( assign( targetNode, sourceValue ) );
+
+	}
+
+	loop( ...params ) {
+
+		return this.add( loop( ...params ) );
+
+	}
+
+	build( builder, ...params ) {
+
+		for ( const node of this.nodes ) {
+
+			node.build( builder );
+
+		}
+
+		return this.outputNode ? this.outputNode.build( builder, ...params ) : super.build( builder, ...params );
+
+	}
+
+}
+
+export default StackNode;
+
+export const stack = nodeProxy( StackNode );
+
+addNodeClass( StackNode );

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

@@ -1,4 +1,4 @@
-import Node from './Node.js';
+import Node, { addNodeClass } from './Node.js';
 
 class TempNode extends Node {
 
@@ -10,6 +10,12 @@ class TempNode extends Node {
 
 	}
 
+	hasDependencies( builder ) {
+
+		return builder.getDataFromNode( this ).dependenciesCount > 1;
+
+	}
+
 	build( builder, output ) {
 
 		const buildStage = builder.getBuildStage();
@@ -23,14 +29,14 @@ class TempNode extends Node {
 
 				return builder.format( nodeData.propertyName, type, output );
 
-			} else if ( builder.context.tempWrite !== false && type !== 'void ' && output !== 'void' && nodeData.dependenciesCount > 1 ) {
+			} else if ( builder.context.tempWrite !== false && type !== 'void' && output !== 'void' && this.hasDependencies( builder ) ) {
 
 				const snippet = super.build( builder, type );
 
 				const nodeVar = builder.getVarFromNode( this, type );
 				const propertyName = builder.getPropertyName( nodeVar );
 
-				builder.addFlowCode( `${propertyName} = ${snippet}` );
+				builder.addLineFlowCode( `${propertyName} = ${snippet}` );
 
 				nodeData.snippet = snippet;
 				nodeData.propertyName = propertyName;
@@ -48,3 +54,5 @@ class TempNode extends Node {
 }
 
 export default TempNode;
+
+addNodeClass( TempNode );

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

@@ -1,4 +1,6 @@
 import InputNode from './InputNode.js';
+import { addNodeClass } from './Node.js';
+import { nodeObject, getConstNodeType } from '../shadernode/ShaderNode.js';
 
 class UniformNode extends InputNode {
 
@@ -34,7 +36,7 @@ class UniformNode extends InputNode {
 
 		const sharedNodeType = sharedNode.getInputType( builder );
 
-		const nodeUniform = builder.getUniformFromNode( sharedNode, builder.shaderStage, sharedNodeType );
+		const nodeUniform = builder.getUniformFromNode( sharedNode, sharedNodeType, builder.shaderStage );
 		const propertyName = builder.getPropertyName( nodeUniform );
 
 		return builder.format( propertyName, type, output );
@@ -44,3 +46,16 @@ class UniformNode extends InputNode {
 }
 
 export default UniformNode;
+
+export const uniform = ( arg1, arg2 ) => {
+
+	const nodeType = getConstNodeType( arg2 || arg1 );
+
+	// @TODO: get ConstNode from .traverse() in the future
+	const value = ( arg1 && arg1.isNode === true ) ? ( arg1.node && arg1.node.value ) || arg1.value : arg1;
+
+	return nodeObject( new UniformNode( value, nodeType ) );
+
+};
+
+addNodeClass( UniformNode );

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

@@ -1,5 +1,5 @@
-import Node from './Node.js';
-import OperatorNode from '../math/OperatorNode.js';
+import Node, { addNodeClass } from './Node.js';
+import { addNodeElement, nodeProxy } from '../shadernode/ShaderNode.js';
 
 class VarNode extends Node {
 
@@ -12,41 +12,25 @@ class VarNode extends Node {
 
 	}
 
-	op( op, ...params ) {
+	assign( node ) {
 
-		this.node = new OperatorNode( op, this.node, ...params );
+		node.traverse( ( childNode, replaceNode ) => {
 
-		return this;
-
-	}
-
-	assign( ...params ) {
-
-		return this.op( '=', ...params );
+			if ( replaceNode && childNode.uuid === this.uuid ) {
 
-	}
-
-	add( ...params ) {
-
-		return this.op( '+', ...params );
-
-	}
+				replaceNode( this.node );
 
-	sub( ...params ) {
+			}
 
-		return this.op( '-', ...params );
-
-	}
-
-	mul( ...params ) {
-
-		return this.op( '*', ...params );
+		} );
+		this.node = node;
+		return this;
 
 	}
 
-	div( ...params ) {
+	isGlobal() {
 
-		return this.op( '/', ...params );
+		return true;
 
 	}
 
@@ -86,7 +70,7 @@ class VarNode extends Node {
 
 		const propertyName = builder.getPropertyName( nodeVar );
 
-		builder.addFlowCode( `${propertyName} = ${snippet}` );
+		builder.addLineFlowCode( `${propertyName} = ${snippet}` );
 
 		return propertyName;
 
@@ -95,3 +79,11 @@ class VarNode extends Node {
 }
 
 export default VarNode;
+
+export const label = nodeProxy( VarNode );
+export const temp = label;
+
+addNodeElement( 'label', label );
+addNodeElement( 'temp', temp );
+
+addNodeClass( VarNode );

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

@@ -1,5 +1,6 @@
-import Node from './Node.js';
+import Node, { addNodeClass } from './Node.js';
 import { NodeShaderStage } from './constants.js';
+import { addNodeElement, nodeProxy } from '../shadernode/ShaderNode.js';
 
 class VaryingNode extends Node {
 
@@ -12,6 +13,12 @@ class VaryingNode extends Node {
 
 	}
 
+	isGlobal() {
+
+		return true;
+
+	}
+
 	getHash( builder ) {
 
 		return this.name || super.getHash( builder );
@@ -34,7 +41,7 @@ class VaryingNode extends Node {
 		const nodeVarying = builder.getVaryingFromNode( this, type );
 
 		// this property can be used to check if the varying can be optimized for a var
-		nodeVarying.needsInterpolation ||= builder.shaderStage === 'fragment';
+		nodeVarying.needsInterpolation || ( nodeVarying.needsInterpolation = ( builder.shaderStage === 'fragment' ) );
 
 		if ( name !== null ) {
 
@@ -54,3 +61,9 @@ class VaryingNode extends Node {
 }
 
 export default VaryingNode;
+
+export const varying = nodeProxy( VaryingNode );
+
+addNodeElement( 'varying', varying );
+
+addNodeClass( VaryingNode );

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

@@ -6,6 +6,7 @@ export const NodeShaderStage = {
 export const NodeUpdateType = {
 	NONE: 'none',
 	FRAME: 'frame',
+	RENDER: 'render',
 	OBJECT: 'object'
 };
 
@@ -19,3 +20,8 @@ export const NodeType = {
 	MATRIX3: 'mat3',
 	MATRIX4: 'mat4'
 };
+
+export const defaultShaderStages = [ 'fragment', 'vertex' ];
+export const defaultBuildStages = [ 'construct', 'analyze', 'generate' ];
+export const shaderStages = [ ...defaultShaderStages, 'compute' ];
+export const vectorComponents = [ 'x', 'y', 'z', 'w' ];