super-three 0.141.0 → 0.147.0

package/examples/jsm/nodes/accessors/PositionNode.js

@@ -1,6 +1,6 @@
 import Node from '../core/Node.js';
 import AttributeNode from '../core/AttributeNode.js';
-import VaryNode from '../core/VaryNode.js';
+import VaryingNode from '../core/VaryingNode.js';
 import ModelNode from '../accessors/ModelNode.js';
 import MathNode from '../math/MathNode.js';
 import OperatorNode from '../math/OperatorNode.js';
@@ -10,6 +10,7 @@ class PositionNode extends Node {
 	static GEOMETRY = 'geometry';
 	static LOCAL = 'local';
 	static WORLD = 'world';
+	static WORLD_DIRECTION = 'worldDirection';
 	static VIEW = 'view';
 	static VIEW_DIRECTION = 'viewDirection';
 
@@ -39,22 +40,27 @@ class PositionNode extends Node {
 
 		} else if ( scope === PositionNode.LOCAL ) {
 
-			outputNode = new VaryNode( new PositionNode( PositionNode.GEOMETRY ) );
+			outputNode = new VaryingNode( new PositionNode( PositionNode.GEOMETRY ) );
 
 		} else if ( scope === PositionNode.WORLD ) {
 
 			const vertexPositionNode = new MathNode( MathNode.TRANSFORM_DIRECTION, new ModelNode( ModelNode.WORLD_MATRIX ), new PositionNode( PositionNode.LOCAL ) );
-			outputNode = new VaryNode( vertexPositionNode );
+			outputNode = new VaryingNode( vertexPositionNode );
 
 		} else if ( scope === PositionNode.VIEW ) {
 
 			const vertexPositionNode = new OperatorNode( '*', new ModelNode( ModelNode.VIEW_MATRIX ), new PositionNode( PositionNode.LOCAL ) );
-			outputNode = new VaryNode( vertexPositionNode );
+			outputNode = new VaryingNode( vertexPositionNode );
 
 		} else if ( scope === PositionNode.VIEW_DIRECTION ) {
 
 			const vertexPositionNode = new MathNode( MathNode.NEGATE, new PositionNode( PositionNode.VIEW ) );
-			outputNode = new MathNode( MathNode.NORMALIZE, new VaryNode( vertexPositionNode ) );
+			outputNode = new MathNode( MathNode.NORMALIZE, new VaryingNode( vertexPositionNode ) );
+
+		} else if ( scope === PositionNode.WORLD_DIRECTION ) {
+
+			const vertexPositionNode = new MathNode( MathNode.NEGATE, new PositionNode( PositionNode.WORLD ) );
+			outputNode = new MathNode( MathNode.NORMALIZE, new VaryingNode( vertexPositionNode ) );
 
 		}
 

package/examples/jsm/nodes/accessors/ReferenceNode.js

@@ -16,7 +16,7 @@ class ReferenceNode extends Node {
 
 		this.node = null;
 
-		this.updateType = NodeUpdateType.Object;
+		this.updateType = NodeUpdateType.OBJECT;
 
 		this.setNodeType( uniformType );
 

package/examples/jsm/nodes/accessors/ReflectVectorNode.js

@@ -0,0 +1,31 @@
+import Node from '../core/Node.js';
+import {
+	transformedNormalView, positionViewDirection,
+	transformDirection, negate, reflect, cameraViewMatrix
+} from '../shadernode/ShaderNodeBaseElements.js';
+
+class ReflectVectorNode extends Node {
+
+	constructor() {
+
+		super( 'vec3' );
+
+	}
+
+	getHash( /*builder*/ ) {
+
+		return 'reflectVector';
+
+	}
+
+	construct() {
+
+		const reflectView = reflect( negate( positionViewDirection ), transformedNormalView );
+
+		return transformDirection( reflectView, cameraViewMatrix );
+
+	}
+
+}
+
+export default ReflectVectorNode;

package/examples/jsm/nodes/accessors/SkinningNode.js

@@ -7,6 +7,7 @@ import {
 	uniform,
 	positionLocal,
 	normalLocal,
+	tangentLocal,
 	assign,
 	element,
 	add,
@@ -56,6 +57,12 @@ const Skinning = new ShaderNode( ( inputs, builder ) => {
 	assign( positionLocal, skinPosition ).build( builder );
 	assign( normalLocal, skinNormal ).build( builder );
 
+	if ( builder.hasGeometryAttribute( 'tangent' ) ) {
+
+		assign( tangentLocal, skinNormal ).build( builder );
+
+	}
+
 } );
 
 class SkinningNode extends Node {
@@ -66,7 +73,7 @@ class SkinningNode extends Node {
 
 		this.skinnedMesh = skinnedMesh;
 
-		this.updateType = NodeUpdateType.Object;
+		this.updateType = NodeUpdateType.OBJECT;
 
 		//
 

package/examples/jsm/nodes/accessors/TangentNode.js

@@ -0,0 +1,95 @@
+import Node from '../core/Node.js';
+import AttributeNode from '../core/AttributeNode.js';
+import VaryingNode from '../core/VaryingNode.js';
+import ModelNode from '../accessors/ModelNode.js';
+import CameraNode from '../accessors/CameraNode.js';
+import OperatorNode from '../math/OperatorNode.js';
+import MathNode from '../math/MathNode.js';
+import SplitNode from '../utils/SplitNode.js';
+
+class TangentNode extends Node {
+
+	static GEOMETRY = 'geometry';
+	static LOCAL = 'local';
+	static VIEW = 'view';
+	static WORLD = 'world';
+
+	constructor( scope = TangentNode.LOCAL ) {
+
+		super();
+
+		this.scope = scope;
+
+	}
+
+	getHash( /*builder*/ ) {
+
+		return `tangent-${this.scope}`;
+
+	}
+
+	getNodeType() {
+
+		const scope = this.scope;
+
+		if ( scope === TangentNode.GEOMETRY ) {
+
+			return 'vec4';
+
+		}
+
+		return 'vec3';
+
+	}
+
+
+	generate( builder ) {
+
+		const scope = this.scope;
+
+		let outputNode = null;
+
+		if ( scope === TangentNode.GEOMETRY ) {
+
+			outputNode = new AttributeNode( 'tangent', 'vec4' );
+
+		} else if ( scope === TangentNode.LOCAL ) {
+
+			outputNode = new VaryingNode( new SplitNode( new TangentNode( TangentNode.GEOMETRY ), 'xyz' ) );
+
+		} else if ( scope === TangentNode.VIEW ) {
+
+			const vertexNode = new SplitNode( new OperatorNode( '*', new ModelNode( ModelNode.VIEW_MATRIX ), new TangentNode( TangentNode.LOCAL ) ), 'xyz' );
+
+			outputNode = new MathNode( MathNode.NORMALIZE, new VaryingNode( vertexNode ) );
+
+		} else if ( scope === TangentNode.WORLD ) {
+
+			const vertexNode = new MathNode( MathNode.TRANSFORM_DIRECTION, new TangentNode( TangentNode.VIEW ), new CameraNode( CameraNode.VIEW_MATRIX ) );
+			outputNode = new MathNode( MathNode.NORMALIZE, new VaryingNode( vertexNode ) );
+
+		}
+
+		return outputNode.build( builder, this.getNodeType( builder ) );
+
+	}
+
+	serialize( data ) {
+
+		super.serialize( data );
+
+		data.scope = this.scope;
+
+	}
+
+	deserialize( data ) {
+
+		super.deserialize( data );
+
+		this.scope = data.scope;
+
+	}
+
+}
+
+export default TangentNode;

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

@@ -1,5 +1,5 @@
 import Node from './Node.js';
-import VaryNode from './VaryNode.js';
+import VaryingNode from './VaryingNode.js';
 
 class AttributeNode extends Node {
 
@@ -19,14 +19,23 @@ class AttributeNode extends Node {
 
 	getNodeType( builder ) {
 
+		const attributeName = this.getAttributeName( builder );
+
 		let nodeType = super.getNodeType( builder );
 
 		if ( nodeType === null ) {
 
-			const attributeName = this.getAttributeName( builder );
-			const attribute = builder.geometry.getAttribute( attributeName );
+			if ( builder.hasGeometryAttribute( attributeName ) ) {
+
+				const attribute = builder.geometry.getAttribute( attributeName );
+
+				nodeType = builder.getTypeFromLength( attribute.itemSize );
 
-			nodeType = builder.getTypeFromLength( attribute.itemSize );
+			} else {
+
+				nodeType = 'float';
+
+			}
 
 		}
 
@@ -50,17 +59,31 @@ class AttributeNode extends Node {
 
 	generate( builder ) {
 
-		const attribute = builder.getAttribute( this.getAttributeName( builder ), this.getNodeType( builder ) );
+		const attributeName = this.getAttributeName( builder );
+		const nodeType = this.getNodeType( builder );
+		const geometryAttribute = builder.hasGeometryAttribute( attributeName );
+
+		if ( geometryAttribute === true ) {
+
+			const nodeAttribute = builder.getAttribute( attributeName, nodeType );
+
+			if ( builder.isShaderStage( 'vertex' ) ) {
+
+				return nodeAttribute.name;
+
+			} else {
+
+				const nodeVarying = new VaryingNode( this );
 
-		if ( builder.isShaderStage( 'vertex' ) ) {
+				return nodeVarying.build( builder, nodeAttribute.type );
 
-			return attribute.name;
+			}
 
 		} else {
 
-			const nodeVary = new VaryNode( this );
+			console.warn( `Attribute "${ attributeName }" not found.` );
 
-			return nodeVary.build( builder, attribute.type );
+			return builder.getConst( nodeType );
 
 		}
 

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

@@ -2,15 +2,15 @@ import Node from './Node.js';
 
 class CodeNode extends Node {
 
-	constructor( code = '', nodeType = 'code' ) {
+	constructor( code = '', includes = [] ) {
 
-		super( nodeType );
+		super( 'code' );
 
 		this.isCodeNode = true;
 
 		this.code = code;
 
-		this._includes = [];
+		this._includes = includes;
 
 	}
 

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

@@ -40,17 +40,32 @@ class FunctionCallNode extends TempNode {
 		const inputs = functionNode.getInputs( builder );
 		const parameters = this.parameters;
 
-		for ( const inputNode of inputs ) {
+		if ( Array.isArray( parameters ) ) {
 
-			const node = parameters[ inputNode.name ];
+			for ( let i = 0; i < parameters.length; i ++ ) {
 
-			if ( node !== undefined ) {
+				const inputNode = inputs[ i ];
+				const node = parameters[ i ];
 
 				params.push( node.build( builder, inputNode.type ) );
 
-			} else {
+			}
+
+		} else {
+
+			for ( const inputNode of inputs ) {
+
+				const node = parameters[ inputNode.name ];
+
+				if ( node !== undefined ) {
+
+					params.push( node.build( builder, inputNode.type ) );
+
+				} else {
+
+					throw new Error( `FunctionCallNode: Input '${inputNode.name}' not found in FunctionNode.` );
 
-				throw new Error( `FunctionCallNode: Input '${inputNode.name}' not found in FunctionNode.` );
+				}
 
 			}
 

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

@@ -3,9 +3,9 @@ import FunctionCallNode from './FunctionCallNode.js';
 
 class FunctionNode extends CodeNode {
 
-	constructor( code = '' ) {
+	constructor( code = '', includes = [] ) {
 
-		super( code );
+		super( code, includes );
 
 		this.keywords = {};
 

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

@@ -1,5 +1,5 @@
 import { NodeUpdateType } from './constants.js';
-import { getNodesKeys } from './NodeUtils.js';
+import { getNodesKeys, getCacheKey } from './NodeUtils.js';
 import { MathUtils } from 'three';
 
 let _nodeId = 0;
@@ -12,7 +12,7 @@ class Node {
 
 		this.nodeType = nodeType;
 
-		this.updateType = NodeUpdateType.None;
+		this.updateType = NodeUpdateType.NONE;
 
 		this.uuid = MathUtils.generateUUID();
 
@@ -58,6 +58,12 @@ class Node {
 
 	}
 
+	getCacheKey() {
+
+		return getCacheKey( this );
+
+	}
+
 	getHash( /*builder*/ ) {
 
 		return this.uuid;
@@ -131,15 +137,13 @@ class Node {
 
 	}
 
-	generate( builder ) {
+	generate( builder, output ) {
 
 		const { outputNode } = builder.getNodeProperties( this );
 
 		if ( outputNode?.isNode === true ) {
 
-			const type = this.getNodeType( builder );
-
-			return outputNode.build( builder, type );
+			return outputNode.build( builder, output );
 
 		}
 
@@ -167,7 +171,7 @@ class Node {
 		/* expected return:
 			- "construct"	-> Node
 			- "analyze"		-> null
-			- "generat"		-> String
+			- "generate"	-> String
 		*/
 		let result = null;
 
@@ -176,13 +180,11 @@ class Node {
 		if ( buildStage === 'construct' ) {
 
 			const properties = builder.getNodeProperties( this );
-			const nodeData = builder.getDataFromNode( this );
-
-			if ( properties.initied !== true ) {
 
-				nodeData.initied = true;
+			if ( properties.initialized !== true || builder.context.tempRead === false ) {
 
-				properties.outputNode =  this.construct( builder );
+				properties.initialized = true;
+				properties.outputNode = this.construct( builder );
 
 				for ( const childNode of Object.values( properties ) ) {
 
@@ -211,7 +213,7 @@ class Node {
 
 				result = nodeData.snippet;
 
-				if ( result === undefined ) {
+				if ( result === undefined /*|| builder.context.tempRead === false*/ ) {
 
 					result = this.generate( builder ) || '';
 

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

@@ -1,19 +1,18 @@
 import NodeUniform from './NodeUniform.js';
 import NodeAttribute from './NodeAttribute.js';
-import NodeVary from './NodeVary.js';
+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 } from 'three';
+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( 1, 'float' );
 typeFromLength.set( 2, 'vec2' );
 typeFromLength.set( 3, 'vec3' );
 typeFromLength.set( 4, 'vec4' );
@@ -55,7 +54,7 @@ class NodeBuilder {
 		this.uniforms = { vertex: [], fragment: [], compute: [], index: 0 };
 		this.codes = { vertex: [], fragment: [], compute: [] };
 		this.attributes = [];
-		this.varys = [];
+		this.varyings = [];
 		this.vars = { vertex: [], fragment: [], compute: [] };
 		this.flow = { code: '' };
 		this.stack = [];
@@ -117,7 +116,7 @@ class NodeBuilder {
 
 			const updateType = node.getUpdateType( this );
 
-			if ( updateType !== NodeUpdateType.None ) {
+			if ( updateType !== NodeUpdateType.NONE ) {
 
 				this.updateNodes.push( node );
 
@@ -181,6 +180,18 @@ class NodeBuilder {
 
 	}
 
+	getFragCoord() {
+
+		console.warn( 'Abstract function.' );
+
+	}
+
+	isFlipY() {
+
+		return false;
+
+	}
+
 	getTexture( /* textureProperty, uvSnippet */ ) {
 
 		console.warn( 'Abstract function.' );
@@ -206,7 +217,18 @@ class NodeBuilder {
 	}
 
 	// @TODO: rename to .generateConst()
-	getConst( type, value ) {
+	getConst( type, value = null ) {
+
+		if ( value === null ) {
+
+			if ( type === 'float' || type === 'int' || type === 'uint' ) value = 0;
+			else if ( type === 'bool' ) value = false;
+			else if ( type === 'color' ) value = new Color();
+			else if ( type === 'vec2' ) value = new Vector2();
+			else if ( type === 'vec3' ) value = new Vector3();
+			else if ( type === 'vec4' ) value = new Vector4();
+
+		}
 
 		if ( type === 'float' ) return toFloat( value );
 		if ( type === 'int' ) return `${ Math.round( value ) }`;
@@ -254,6 +276,12 @@ class NodeBuilder {
 
 	}
 
+	hasGeometryAttribute( name ) {
+
+		return this.geometry?.getAttribute( name ) !== undefined;
+
+	}
+
 	getAttribute( name, type ) {
 
 		const attributes = this.attributes;
@@ -336,6 +364,8 @@ class NodeBuilder {
 
 		type = this.getVectorType( type );
 
+		if ( type === 'float' || type === 'bool' || type === 'int' || type === 'uint' ) return type;
+
 		const componentType = /(b|i|u|)(vec|mat)([2-4])/.exec( type );
 
 		if ( componentType === null ) return null;
@@ -357,9 +387,12 @@ class NodeBuilder {
 
 	}
 
-	getTypeFromLength( length ) {
+	getTypeFromLength( length, componentType = 'float' ) {
 
-		return typeFromLength.get( length );
+		if ( length === 1 ) return componentType;
+		const baseType = typeFromLength.get( length );
+		const prefix = componentType === 'float' ? '' : componentType[ 0 ];
+		return prefix + baseType;
 
 	}
 
@@ -383,6 +416,22 @@ class NodeBuilder {
 
 	}
 
+	changeComponentType( type, newComponentType ) {
+
+		return this.getTypeFromLength( this.getTypeLength( type ), newComponentType );
+
+	}
+
+	getIntegerType( type ) {
+
+		const componentType = this.getComponentType( type );
+
+		if ( componentType === 'int' || componentType === 'uint' ) return type;
+
+		return this.changeComponentType( type, 'int' );
+
+	}
+
 	getDataFromNode( node, shaderStage = this.shaderStage ) {
 
 		let nodeData = this.nodesData.get( node );
@@ -456,26 +505,26 @@ class NodeBuilder {
 
 	}
 
-	getVaryFromNode( node, type ) {
+	getVaryingFromNode( node, type ) {
 
 		const nodeData = this.getDataFromNode( node, null );
 
-		let nodeVary = nodeData.vary;
+		let nodeVarying = nodeData.varying;
 
-		if ( nodeVary === undefined ) {
+		if ( nodeVarying === undefined ) {
 
-			const varys = this.varys;
-			const index = varys.length;
+			const varyings = this.varyings;
+			const index = varyings.length;
 
-			nodeVary = new NodeVary( 'nodeVary' + index, type );
+			nodeVarying = new NodeVarying( 'nodeVarying' + index, type );
 
-			varys.push( nodeVary );
+			varyings.push( nodeVarying );
 
-			nodeData.vary = nodeVary;
+			nodeData.varying = nodeVarying;
 
 		}
 
-		return nodeVary;
+		return nodeVarying;
 
 	}
 
@@ -572,7 +621,7 @@ class NodeBuilder {
 
 	}
 
-	getVarys( /*shaderStage*/ ) {
+	getVaryings( /*shaderStage*/ ) {
 
 		console.warn( 'Abstract function.' );
 

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

@@ -22,7 +22,7 @@ class NodeFrame {
 
 	updateNode( node ) {
 
-		if ( node.updateType === NodeUpdateType.Frame ) {
+		if ( node.updateType === NodeUpdateType.FRAME ) {
 
 			if ( this.updateMap.get( node ) !== this.frameId ) {
 
@@ -32,7 +32,7 @@ class NodeFrame {
 
 			}
 
-		} else if ( node.updateType === NodeUpdateType.Object ) {
+		} else if ( node.updateType === NodeUpdateType.OBJECT ) {
 
 			node.update( this );
 

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

@@ -1,5 +1,27 @@
 import { Color, Matrix3, Matrix4, Vector2, Vector3, Vector4 } from 'three';
 
+export const getCacheKey = ( object ) => {
+
+	let cacheKey = '{';
+
+	if ( object.isNode === true ) {
+
+		cacheKey += `uuid:"${ object.uuid }",`;
+
+	}
+
+	for ( const property of getNodesKeys( object ) ) {
+
+		cacheKey += `${ property }:${ object[ property ].getCacheKey() },`;
+
+	}
+
+	cacheKey += '}';
+
+	return cacheKey;
+
+};
+
 export const getNodesKeys = ( object ) => {
 
 	const props = [];
@@ -62,7 +84,7 @@ export const getValueType = ( value ) => {
 
 export const getValueFromType = ( type, ...params ) => {
 
-	const last4 = type?.slice( -4 );
+	const last4 = type?.slice( - 4 );
 
 	if ( type === 'color' ) {
 

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

@@ -0,0 +1,17 @@
+import NodeVar from './NodeVar.js';
+
+class NodeVarying extends NodeVar {
+
+	constructor( name, type ) {
+
+		super( name, type );
+
+		this.needsInterpolation = false;
+
+		this.isNodeVarying = true;
+
+	}
+
+}
+
+export default NodeVarying;