@needle-tools/three 0.162.12 → 0.169.2

package/src/nodes/core/NodeCache.js

@@ -0,0 +1,36 @@
+let id = 0;
+
+class NodeCache {
+
+	constructor( parent = null ) {
+
+		this.id = id ++;
+		this.nodesData = new WeakMap();
+
+		this.parent = parent;
+
+	}
+
+	getData( node ) {
+
+		let data = this.nodesData.get( node );
+
+		if ( data === undefined && this.parent !== null ) {
+
+			data = this.parent.getData( node );
+
+		}
+
+		return data;
+
+	}
+
+	setData( node, data ) {
+
+		this.nodesData.set( node, data );
+
+	}
+
+}
+
+export default NodeCache;

package/{examples/jsm → src}/nodes/core/NodeFrame.js

@@ -14,6 +14,7 @@ class NodeFrame {
 
 		this.updateMap = new WeakMap();
 		this.updateBeforeMap = new WeakMap();
+		this.updateAfterMap = new WeakMap();
 
 		this.renderer = null;
 		this.material = null;
@@ -45,17 +46,17 @@ class NodeFrame {
 	updateBeforeNode( node ) {
 
 		const updateType = node.getUpdateBeforeType();
-		const reference = node.setReference( this );
+		const reference = node.updateReference( this );
 
 		if ( updateType === NodeUpdateType.FRAME ) {
 
 			const { frameMap } = this._getMaps( this.updateBeforeMap, reference );
 
-			if ( frameMap.get( node ) !== this.frameId ) {
+			if ( frameMap.get( reference ) !== this.frameId ) {
 
 				if ( node.updateBefore( this ) !== false ) {
 
-					frameMap.set( node, this.frameId );
+					frameMap.set( reference, this.frameId );
 
 				}
 
@@ -65,11 +66,11 @@ class NodeFrame {
 
 			const { renderMap } = this._getMaps( this.updateBeforeMap, reference );
 
-			if ( renderMap.get( node ) !== this.renderId ) {
+			if ( renderMap.get( reference ) !== this.renderId ) {
 
 				if ( node.updateBefore( this ) !== false ) {
 
-					renderMap.set( node, this.renderId );
+					renderMap.set( reference, this.renderId );
 
 				}
 
@@ -83,20 +84,61 @@ class NodeFrame {
 
 	}
 
+	updateAfterNode( node ) {
+
+		const updateType = node.getUpdateAfterType();
+		const reference = node.updateReference( this );
+
+		if ( updateType === NodeUpdateType.FRAME ) {
+
+			const { frameMap } = this._getMaps( this.updateAfterMap, reference );
+
+			if ( frameMap.get( reference ) !== this.frameId ) {
+
+				if ( node.updateAfter( this ) !== false ) {
+
+					frameMap.set( reference, this.frameId );
+
+				}
+
+			}
+
+		} else if ( updateType === NodeUpdateType.RENDER ) {
+
+			const { renderMap } = this._getMaps( this.updateAfterMap, reference );
+
+			if ( renderMap.get( reference ) !== this.renderId ) {
+
+				if ( node.updateAfter( this ) !== false ) {
+
+					renderMap.set( reference, this.renderId );
+
+				}
+
+			}
+
+		} else if ( updateType === NodeUpdateType.OBJECT ) {
+
+			node.updateAfter( this );
+
+		}
+
+	}
+
 	updateNode( node ) {
 
 		const updateType = node.getUpdateType();
-		const reference = node.setReference( this );
+		const reference = node.updateReference( this );
 
 		if ( updateType === NodeUpdateType.FRAME ) {
 
 			const { frameMap } = this._getMaps( this.updateMap, reference );
 
-			if ( frameMap.get( node ) !== this.frameId ) {
+			if ( frameMap.get( reference ) !== this.frameId ) {
 
 				if ( node.update( this ) !== false ) {
 
-					frameMap.set( node, this.frameId );
+					frameMap.set( reference, this.frameId );
 
 				}
 
@@ -106,11 +148,11 @@ class NodeFrame {
 
 			const { renderMap } = this._getMaps( this.updateMap, reference );
 
-			if ( renderMap.get( node ) !== this.renderId ) {
+			if ( renderMap.get( reference ) !== this.renderId ) {
 
 				if ( node.update( this ) !== false ) {
 
-					renderMap.set( node, this.renderId );
+					renderMap.set( reference, this.renderId );
 
 				}
 

package/{examples/jsm → src}/nodes/core/NodeFunction.js

@@ -1,11 +1,11 @@
 class NodeFunction {
 
-	constructor( type, inputs, name = '', presicion = '' ) {
+	constructor( type, inputs, name = '', precision = '' ) {
 
 		this.type = type;
 		this.inputs = inputs;
 		this.name = name;
-		this.presicion = presicion;
+		this.precision = precision;
 
 	}
 

package/{examples/jsm → src}/nodes/core/NodeUniform.js

@@ -1,13 +1,12 @@
 class NodeUniform {
 
-	constructor( name, type, node, needsUpdate = undefined ) {
+	constructor( name, type, node ) {
 
 		this.isNodeUniform = true;
 
 		this.name = name;
 		this.type = type;
 		this.node = node.getSelf();
-		this.needsUpdate = needsUpdate;
 
 	}
 

package/{examples/jsm → src}/nodes/core/NodeUtils.js

@@ -1,24 +1,72 @@
-import { Color, Matrix3, Matrix4, Vector2, Vector3, Vector4 } from 'three';
+import { Color } from '../../math/Color.js';
+import { Matrix3 } from '../../math/Matrix3.js';
+import { Matrix4 } from '../../math/Matrix4.js';
+import { Vector2 } from '../../math/Vector2.js';
+import { Vector3 } from '../../math/Vector3.js';
+import { Vector4 } from '../../math/Vector4.js';
 
-export function getCacheKey( object ) {
+// cyrb53 (c) 2018 bryc (github.com/bryc). License: Public domain. Attribution appreciated.
+// A fast and simple 64-bit (or 53-bit) string hash function with decent collision resistance.
+// Largely inspired by MurmurHash2/3, but with a focus on speed/simplicity.
+// See https://stackoverflow.com/questions/7616461/generate-a-hash-from-string-in-javascript/52171480#52171480
+// https://github.com/bryc/code/blob/master/jshash/experimental/cyrb53.js
+function cyrb53( value, seed = 0 ) {
 
-	let cacheKey = '{';
+	let h1 = 0xdeadbeef ^ seed, h2 = 0x41c6ce57 ^ seed;
+
+	if ( value instanceof Array ) {
+
+		for ( let i = 0, val; i < value.length; i ++ ) {
+
+			val = value[ i ];
+			h1 = Math.imul( h1 ^ val, 2654435761 );
+			h2 = Math.imul( h2 ^ val, 1597334677 );
+
+		}
+
+	} else {
+
+		for ( let i = 0, ch; i < value.length; i ++ ) {
+
+			ch = value.charCodeAt( i );
+			h1 = Math.imul( h1 ^ ch, 2654435761 );
+			h2 = Math.imul( h2 ^ ch, 1597334677 );
+
+		}
+
+	}
+
+	h1 = Math.imul( h1 ^ ( h1 >>> 16 ), 2246822507 );
+	h1 ^= Math.imul( h2 ^ ( h2 >>> 13 ), 3266489909 );
+	h2 = Math.imul( h2 ^ ( h2 >>> 16 ), 2246822507 );
+	h2 ^= Math.imul( h1 ^ ( h1 >>> 13 ), 3266489909 );
+
+	return 4294967296 * ( 2097151 & h2 ) + ( h1 >>> 0 );
+
+}
+
+export const hashString = ( str ) => cyrb53( str );
+export const hashArray = ( array ) => cyrb53( array );
+export const hash = ( ...params ) => cyrb53( params );
+
+export function getCacheKey( object, force = false ) {
+
+	const values = [];
 
 	if ( object.isNode === true ) {
 
-		cacheKey += object.id;
+		values.push( object.id );
+		object = object.getSelf();
 
 	}
 
 	for ( const { property, childNode } of getNodeChildren( object ) ) {
 
-		cacheKey += ',' + property.slice( 0, - 4 ) + ':' + childNode.getCacheKey();
+		values.push( values, cyrb53( property.slice( 0, - 4 ) ), childNode.getCacheKey( force ) );
 
 	}
 
-	cacheKey += '}';
-
-	return cacheKey;
+	return cyrb53( values );
 
 }
 

package/{examples/jsm → src}/nodes/core/OutputStructNode.js

@@ -1,16 +1,23 @@
-import Node, { addNodeClass } from './Node.js';
+import Node from './Node.js';
 import StructTypeNode from './StructTypeNode.js';
-import { nodeProxy } from '../shadernode/ShaderNode.js';
+import { nodeProxy } from '../tsl/TSLBase.js';
 
 class OutputStructNode extends Node {
 
+	static get type() {
+
+		return 'OutputStructNode';
+
+	}
+
 	constructor( ...members ) {
 
 		super();
 
-		this.isOutputStructNode = true;
 		this.members = members;
 
+		this.isOutputStructNode = true;
+
 	}
 
 	setup( builder ) {
@@ -32,11 +39,7 @@ class OutputStructNode extends Node {
 
 	generate( builder, output ) {
 
-		const nodeVar = builder.getVarFromNode( this );
-		nodeVar.isOutputStructVar = true;
-
-		const propertyName = builder.getPropertyName( nodeVar );
-
+		const propertyName = builder.getOutputStructName();
 		const members = this.members;
 
 		const structPrefix = propertyName !== '' ? propertyName + '.' : '';
@@ -45,7 +48,7 @@ class OutputStructNode extends Node {
 
 			const snippet = members[ i ].build( builder, output );
 
-			builder.addLineFlowCode( `${ structPrefix }m${ i } = ${ snippet }` );
+			builder.addLineFlowCode( `${ structPrefix }m${ i } = ${ snippet }`, this );
 
 		}
 
@@ -57,6 +60,4 @@ class OutputStructNode extends Node {
 
 export default OutputStructNode;
 
-export const outputStruct = nodeProxy( OutputStructNode );
-
-addNodeClass( 'OutputStructNode', OutputStructNode );
+export const outputStruct = /*@__PURE__*/ nodeProxy( OutputStructNode );

package/{examples/jsm → src}/nodes/core/ParameterNode.js

@@ -1,9 +1,14 @@
-import { addNodeClass } from './Node.js';
-import { nodeObject } from '../shadernode/ShaderNode.js';
+import { nodeObject } from '../tsl/TSLBase.js';
 import PropertyNode from './PropertyNode.js';
 
 class ParameterNode extends PropertyNode {
 
+	static get type() {
+
+		return 'ParameterNode';
+
+	}
+
 	constructor( nodeType, name = null ) {
 
 		super( nodeType, name );
@@ -29,5 +34,3 @@ class ParameterNode extends PropertyNode {
 export default ParameterNode;
 
 export const parameter = ( type, name ) => nodeObject( new ParameterNode( type, name ) );
-
-addNodeClass( 'ParameterNode', ParameterNode );

package/src/nodes/core/PropertyNode.js

@@ -0,0 +1,88 @@
+import Node from './Node.js';
+import { nodeImmutable, nodeObject } from '../tsl/TSLCore.js';
+
+class PropertyNode extends Node {
+
+	static get type() {
+
+		return 'PropertyNode';
+
+	}
+
+	constructor( nodeType, name = null, varying = false ) {
+
+		super( nodeType );
+
+		this.name = name;
+		this.varying = varying;
+
+		this.isPropertyNode = true;
+
+	}
+
+	getHash( builder ) {
+
+		return this.name || super.getHash( builder );
+
+	}
+
+	isGlobal( /*builder*/ ) {
+
+		return true;
+
+	}
+
+	generate( builder ) {
+
+		let nodeVar;
+
+		if ( this.varying === true ) {
+
+			nodeVar = builder.getVaryingFromNode( this, this.name );
+			nodeVar.needsInterpolation = true;
+
+		} else {
+
+			nodeVar = builder.getVarFromNode( this, this.name );
+
+		}
+
+		return builder.getPropertyName( nodeVar );
+
+	}
+
+}
+
+export default PropertyNode;
+
+export const property = ( type, name ) => nodeObject( new PropertyNode( type, name ) );
+export const varyingProperty = ( type, name ) => nodeObject( new PropertyNode( type, name, true ) );
+
+export const diffuseColor = /*@__PURE__*/ nodeImmutable( PropertyNode, 'vec4', 'DiffuseColor' );
+export const emissive = /*@__PURE__*/ nodeImmutable( PropertyNode, 'vec3', 'EmissiveColor' );
+export const roughness = /*@__PURE__*/ nodeImmutable( PropertyNode, 'float', 'Roughness' );
+export const metalness = /*@__PURE__*/ nodeImmutable( PropertyNode, 'float', 'Metalness' );
+export const clearcoat = /*@__PURE__*/ nodeImmutable( PropertyNode, 'float', 'Clearcoat' );
+export const clearcoatRoughness = /*@__PURE__*/ nodeImmutable( PropertyNode, 'float', 'ClearcoatRoughness' );
+export const sheen = /*@__PURE__*/ nodeImmutable( PropertyNode, 'vec3', 'Sheen' );
+export const sheenRoughness = /*@__PURE__*/ nodeImmutable( PropertyNode, 'float', 'SheenRoughness' );
+export const iridescence = /*@__PURE__*/ nodeImmutable( PropertyNode, 'float', 'Iridescence' );
+export const iridescenceIOR = /*@__PURE__*/ nodeImmutable( PropertyNode, 'float', 'IridescenceIOR' );
+export const iridescenceThickness = /*@__PURE__*/ nodeImmutable( PropertyNode, 'float', 'IridescenceThickness' );
+export const alphaT = /*@__PURE__*/ nodeImmutable( PropertyNode, 'float', 'AlphaT' );
+export const anisotropy = /*@__PURE__*/ nodeImmutable( PropertyNode, 'float', 'Anisotropy' );
+export const anisotropyT = /*@__PURE__*/ nodeImmutable( PropertyNode, 'vec3', 'AnisotropyT' );
+export const anisotropyB = /*@__PURE__*/ nodeImmutable( PropertyNode, 'vec3', 'AnisotropyB' );
+export const specularColor = /*@__PURE__*/ nodeImmutable( PropertyNode, 'color', 'SpecularColor' );
+export const specularF90 = /*@__PURE__*/ nodeImmutable( PropertyNode, 'float', 'SpecularF90' );
+export const shininess = /*@__PURE__*/ nodeImmutable( PropertyNode, 'float', 'Shininess' );
+export const output = /*@__PURE__*/ nodeImmutable( PropertyNode, 'vec4', 'Output' );
+export const dashSize = /*@__PURE__*/ nodeImmutable( PropertyNode, 'float', 'dashSize' );
+export const gapSize = /*@__PURE__*/ nodeImmutable( PropertyNode, 'float', 'gapSize' );
+export const pointWidth = /*@__PURE__*/ nodeImmutable( PropertyNode, 'float', 'pointWidth' );
+export const ior = /*@__PURE__*/ nodeImmutable( PropertyNode, 'float', 'IOR' );
+export const transmission = /*@__PURE__*/ nodeImmutable( PropertyNode, 'float', 'Transmission' );
+export const thickness = /*@__PURE__*/ nodeImmutable( PropertyNode, 'float', 'Thickness' );
+export const attenuationDistance = /*@__PURE__*/ nodeImmutable( PropertyNode, 'float', 'AttenuationDistance' );
+export const attenuationColor = /*@__PURE__*/ nodeImmutable( PropertyNode, 'color', 'AttenuationColor' );
+export const dispersion = /*@__PURE__*/ nodeImmutable( PropertyNode, 'float', 'Dispersion' );

package/{examples/jsm → src}/nodes/core/StackNode.js

@@ -1,9 +1,15 @@
-import Node, { addNodeClass } from './Node.js';
-import { cond } from '../math/CondNode.js';
-import { ShaderNode, nodeProxy, getCurrentStack, setCurrentStack } from '../shadernode/ShaderNode.js';
+import Node from './Node.js';
+import { select } from '../math/ConditionalNode.js';
+import { ShaderNode, nodeProxy, getCurrentStack, setCurrentStack } from '../tsl/TSLBase.js';
 
 class StackNode extends Node {
 
+	static get type() {
+
+		return 'StackNode';
+
+	}
+
 	constructor( parent = null ) {
 
 		super();
@@ -33,19 +39,19 @@ class StackNode extends Node {
 
 	}
 
-	if( boolNode, method ) {
+	If( boolNode, method ) {
 
 		const methodNode = new ShaderNode( method );
-		this._currentCond = cond( boolNode, methodNode );
+		this._currentCond = select( boolNode, methodNode );
 
 		return this.add( this._currentCond );
 
 	}
 
-	elseif( boolNode, method ) {
+	ElseIf( boolNode, method ) {
 
 		const methodNode = new ShaderNode( method );
-		const ifNode = cond( boolNode, methodNode );
+		const ifNode = select( boolNode, methodNode );
 
 		this._currentCond.elseNode = ifNode;
 		this._currentCond = ifNode;
@@ -54,7 +60,7 @@ class StackNode extends Node {
 
 	}
 
-	else( method ) {
+	Else( method ) {
 
 		this._currentCond.elseNode = new ShaderNode( method );
 
@@ -80,10 +86,24 @@ class StackNode extends Node {
 
 	}
 
+	//
+
+	else( ...params ) { // @deprecated, r168
+
+		console.warn( 'TSL.StackNode: .else() has been renamed to .Else().' );
+		return this.Else( ...params );
+
+	}
+
+	elseif( ...params ) { // @deprecated, r168
+
+		console.warn( 'TSL.StackNode: .elseif() has been renamed to .ElseIf().' );
+		return this.ElseIf( ...params );
+
+	}
+
 }
 
 export default StackNode;
 
-export const stack = nodeProxy( StackNode );
-
-addNodeClass( 'StackNode', StackNode );
+export const stack = /*@__PURE__*/ nodeProxy( StackNode );

package/{examples/jsm → src}/nodes/core/StructTypeNode.js

@@ -1,7 +1,13 @@
-import Node, { addNodeClass } from './Node.js';
+import Node from './Node.js';
 
 class StructTypeNode extends Node {
 
+	static get type() {
+
+		return 'StructTypeNode';
+
+	}
+
 	constructor( types ) {
 
 		super();
@@ -20,5 +26,3 @@ class StructTypeNode extends Node {
 }
 
 export default StructTypeNode;
-
-addNodeClass( 'StructTypeNode', StructTypeNode );

package/{examples/jsm → src}/nodes/core/TempNode.js

@@ -1,7 +1,13 @@
-import Node, { addNodeClass } from './Node.js';
+import Node from './Node.js';
 
 class TempNode extends Node {
 
+	static get type() {
+
+		return 'TempNode';
+
+	}
+
 	constructor( type ) {
 
 		super( type );
@@ -25,18 +31,18 @@ class TempNode extends Node {
 			const type = builder.getVectorType( this.getNodeType( builder, output ) );
 			const nodeData = builder.getDataFromNode( this );
 
-			if ( builder.context.tempRead !== false && nodeData.propertyName !== undefined ) {
+			if ( nodeData.propertyName !== undefined ) {
 
 				return builder.format( nodeData.propertyName, type, output );
 
-			} else if ( builder.context.tempWrite !== false && type !== 'void' && output !== 'void' && this.hasDependencies( builder ) ) {
+			} else if ( type !== 'void' && output !== 'void' && this.hasDependencies( builder ) ) {
 
 				const snippet = super.build( builder, type );
 
 				const nodeVar = builder.getVarFromNode( this, null, type );
 				const propertyName = builder.getPropertyName( nodeVar );
 
-				builder.addLineFlowCode( `${propertyName} = ${snippet}` );
+				builder.addLineFlowCode( `${propertyName} = ${snippet}`, this );
 
 				nodeData.snippet = snippet;
 				nodeData.propertyName = propertyName;
@@ -54,5 +60,3 @@ class TempNode extends Node {
 }
 
 export default TempNode;
-
-addNodeClass( 'TempNode', TempNode );

package/src/nodes/core/UniformGroupNode.js

@@ -0,0 +1,59 @@
+import Node from './Node.js';
+
+class UniformGroupNode extends Node {
+
+	static get type() {
+
+		return 'UniformGroupNode';
+
+	}
+
+	constructor( name, shared = false, order = 1 ) {
+
+		super( 'string' );
+
+		this.name = name;
+		this.version = 0;
+
+		this.shared = shared;
+		this.order = order;
+		this.isUniformGroup = true;
+
+	}
+
+	set needsUpdate( value ) {
+
+		if ( value === true ) this.version ++;
+
+	}
+
+	serialize( data ) {
+
+		super.serialize( data );
+
+		data.name = this.name;
+		data.version = this.version;
+		data.shared = this.shared;
+
+	}
+
+	deserialize( data ) {
+
+		super.deserialize( data );
+
+		this.name = data.name;
+		this.version = data.version;
+		this.shared = data.shared;
+
+	}
+
+}
+
+export default UniformGroupNode;
+
+export const uniformGroup = ( name ) => new UniformGroupNode( name );
+export const sharedUniformGroup = ( name, order = 0 ) => new UniformGroupNode( name, true, order );
+
+export const frameGroup = /*@__PURE__*/ sharedUniformGroup( 'frame' );
+export const renderGroup = /*@__PURE__*/ sharedUniformGroup( 'render' );
+export const objectGroup = /*@__PURE__*/ uniformGroup( 'object' );