super-three 0.144.0 → 0.147.1

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

@@ -10,8 +10,8 @@ class NormalNode extends Node {
 
 	static GEOMETRY = 'geometry';
 	static LOCAL = 'local';
-	static WORLD = 'world';
 	static VIEW = 'view';
+	static WORLD = 'world';
 
 	constructor( scope = NormalNode.LOCAL ) {
 
@@ -43,18 +43,18 @@ class NormalNode extends Node {
 
 		} else if ( scope === NormalNode.VIEW ) {
 
-			const vertexNormalNode = new OperatorNode( '*', new ModelNode( ModelNode.NORMAL_MATRIX ), new NormalNode( NormalNode.LOCAL ) );
-			outputNode = new MathNode( MathNode.NORMALIZE, new VaryingNode( vertexNormalNode ) );
+			const vertexNode = new OperatorNode( '*', new ModelNode( ModelNode.NORMAL_MATRIX ), new NormalNode( NormalNode.LOCAL ) );
+			outputNode = new MathNode( MathNode.NORMALIZE, new VaryingNode( vertexNode ) );
 
 		} else if ( scope === NormalNode.WORLD ) {
 
 			// To use INVERSE_TRANSFORM_DIRECTION only inverse the param order like this: MathNode( ..., Vector, Matrix );
-			const vertexNormalNode = new MathNode( MathNode.TRANSFORM_DIRECTION, new NormalNode( NormalNode.VIEW ), new CameraNode( CameraNode.VIEW_MATRIX ) );
-			outputNode = new MathNode( MathNode.NORMALIZE, new VaryingNode( vertexNormalNode ) );
+			const vertexNode = new MathNode( MathNode.TRANSFORM_DIRECTION, new NormalNode( NormalNode.VIEW ), new CameraNode( CameraNode.VIEW_MATRIX ) );
+			outputNode = new MathNode( MathNode.NORMALIZE, new VaryingNode( vertexNode ) );
 
 		}
 
-		return outputNode.build( builder );
+		return outputNode.build( builder, this.getNodeType( builder ) );
 
 	}
 

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

@@ -18,7 +18,7 @@ class Object3DNode extends Node {
 		this.scope = scope;
 		this.object3d = object3d;
 
-		this.updateType = NodeUpdateType.Object;
+		this.updateType = NodeUpdateType.OBJECT;
 
 		this._uniformNode = new UniformNode( null );
 

package/examples/jsm/nodes/accessors/PositionNode.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';
 
@@ -56,6 +57,11 @@ class PositionNode extends Node {
 			const vertexPositionNode = new MathNode( MathNode.NEGATE, new PositionNode( PositionNode.VIEW ) );
 			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 ) );
+
 		}
 
 		return outputNode.build( builder, this.getNodeType( builder ) );

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/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

@@ -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 nodeVarying = new VaryingNode( this );
+			console.warn( `Attribute "${ attributeName }" not found.` );
 
-			return nodeVarying.build( builder, attribute.type );
+			return builder.getConst( nodeType );
 
 		}
 

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

@@ -12,7 +12,7 @@ class Node {
 
 		this.nodeType = nodeType;
 
-		this.updateType = NodeUpdateType.None;
+		this.updateType = NodeUpdateType.NONE;
 
 		this.uuid = MathUtils.generateUUID();
 

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

@@ -6,14 +6,13 @@ 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' );
@@ -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 );

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/NodeVarying.js

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

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

@@ -28,22 +28,24 @@ class VaryingNode extends Node {
 
 	generate( builder ) {
 
+		const { name, node } = this;
 		const type = this.getNodeType( builder );
-		const node = this.node;
-		const name = this.name;
 
 		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';
+
 		if ( name !== null ) {
 
 			nodeVarying.name = name;
 
 		}
 
-		const propertyName = builder.getPropertyName( nodeVarying, NodeShaderStage.Vertex );
+		const propertyName = builder.getPropertyName( nodeVarying, NodeShaderStage.VERTEX );
 
 		// force node run in vertex stage
-		builder.flowNodeFromShaderStage( NodeShaderStage.Vertex, node, type, propertyName );
+		builder.flowNodeFromShaderStage( NodeShaderStage.VERTEX, node, type, propertyName );
 
 		return builder.getPropertyName( nodeVarying );
 

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

@@ -1,21 +1,21 @@
 export const NodeShaderStage = {
-	Vertex: 'vertex',
-	Fragment: 'fragment'
+	VERTEX: 'vertex',
+	FRAGMENT: 'fragment'
 };
 
 export const NodeUpdateType = {
-	None: 'none',
-	Frame: 'frame',
-	Object: 'object'
+	NONE: 'none',
+	FRAME: 'frame',
+	OBJECT: 'object'
 };
 
 export const NodeType = {
-	Boolean: 'bool',
-	Integer: 'int',
-	Float: 'float',
-	Vector2: 'vec2',
-	Vector3: 'vec3',
-	Vector4: 'vec4',
-	Matrix3: 'mat3',
-	Matrix4: 'mat4'
+	BOOLEAN: 'bool',
+	INTEGER: 'int',
+	FLOAT: 'float',
+	VECTOR2: 'vec2',
+	VECTOR3: 'vec3',
+	VECTOR4: 'vec4',
+	MATRIX3: 'mat3',
+	MATRIX4: 'mat4'
 };

package/examples/jsm/nodes/display/BlendModeNode.js

@@ -0,0 +1,85 @@
+import TempNode from '../core/Node.js';
+import { ShaderNode, EPSILON, vec3, sub, mul, div, cond, lessThan, equal, max } from '../shadernode/ShaderNodeBaseElements.js';
+
+export const BurnNode = new ShaderNode( ( { base, blend } ) => {
+
+	const fn = ( c ) => cond( lessThan( blend[ c ], EPSILON ), blend[ c ], max( sub( 1.0, div( sub( 1.0, base[ c ] ), blend[ c ] ) ), 0 ) );
+
+	return vec3( fn( 'x' ), fn( 'y' ), fn( 'z' ) );
+
+} );
+
+export const DodgeNode = new ShaderNode( ( { base, blend } ) => {
+
+	const fn = ( c ) => cond( equal( blend[ c ], 1.0 ), blend[ c ], max( div( base[ c ], sub( 1.0, blend[ c ] ) ), 0 ) );
+
+	return vec3( fn( 'x' ), fn( 'y' ), fn( 'z' ) );
+
+} );
+
+export const ScreenNode = new ShaderNode( ( { base, blend } ) => {
+
+	const fn = ( c ) => sub( 1.0, mul( sub( 1.0, base[ c ] ), sub( 1.0, blend[ c ] ) ) );
+
+	return vec3( fn( 'x' ), fn( 'y' ), fn( 'z' ) );
+
+} );
+
+export const OverlayNode = new ShaderNode( ( { base, blend } ) => {
+
+	const fn = ( c ) => cond( lessThan( base[ c ], 0.5 ), mul( 2.0, base[ c ], blend[ c ] ), sub( 1.0, mul( sub( 1.0, base[ c ] ), sub( 1.0, blend[ c ] ) ) ) );
+
+	return vec3( fn( 'x' ), fn( 'y' ), fn( 'z' ) );
+
+} );
+
+class BlendModeNode extends TempNode {
+
+	static BURN = 'burn';
+	static DODGE = 'dodge';
+	static SCREEN = 'screen';
+	static OVERLAY = 'overlay';
+
+	constructor( blendMode, baseNode, blendNode ) {
+
+		super();
+
+		this.blendMode = blendMode;
+
+		this.baseNode = baseNode;
+		this.blendNode = blendNode;
+
+	}
+
+	construct() {
+
+		const { blendMode, baseNode, blendNode } = this;
+		const params = { base: baseNode, blend: blendNode };
+
+		let outputNode = null;
+
+		if ( blendMode === BlendModeNode.BURN ) {
+
+			outputNode = BurnNode.call( params );
+
+		} else if ( blendMode === BlendModeNode.DODGE ) {
+
+			outputNode = DodgeNode.call( params );
+
+		} else if ( blendMode === BlendModeNode.SCREEN ) {
+
+			outputNode = ScreenNode.call( params );
+
+		} else if ( blendMode === BlendModeNode.OVERLAY ) {
+
+			outputNode = OverlayNode.call( params );
+
+		}
+
+		return outputNode;
+
+	}
+
+}
+
+export default BlendModeNode;

package/examples/jsm/nodes/display/ColorAdjustmentNode.js

@@ -1,19 +1,9 @@
 import TempNode from '../core/TempNode.js';
-import { ShaderNode, vec3, mat3, add, sub, mul, max, div, dot, float, mix, cos, sin, atan2, sqrt } from '../shadernode/ShaderNodeBaseElements.js';
-
-const luminanceNode = new ShaderNode( ( { color } ) => {
-
-	const LUMA = vec3( 0.2125, 0.7154, 0.0721 );
-
-	return dot( color, LUMA );
-
-} );
+import { ShaderNode, vec3, mat3, add, sub, mul, max, div, float, mix, cos, sin, atan2, sqrt, luminance } from '../shadernode/ShaderNodeBaseElements.js';
 
 const saturationNode = new ShaderNode( ( { color, adjustment } ) => {
 
-	const intensityNode = luminanceNode.call( { color } );
-
-	return mix( intensityNode, color, adjustment );
+	return mix( luminance( color ), color, adjustment );
 
 } );
 

package/examples/jsm/nodes/display/NormalMapNode.js

@@ -1,6 +1,5 @@
 import TempNode from '../core/TempNode.js';
-import ModelNode from '../accessors/ModelNode.js';
-import { ShaderNode, positionView, normalView, uv, vec3, add, sub, mul, dFdx, dFdy, cross, max, dot, normalize, inversesqrt, faceDirection } from '../shadernode/ShaderNodeBaseElements.js';
+import { ShaderNode, positionView, normalView, uv, vec3, add, sub, mul, dFdx, dFdy, cross, max, dot, normalize, inversesqrt, faceDirection, modelNormalMatrix, TBNViewMatrix } from '../shadernode/ShaderNodeBaseElements.js';
 
 import { TangentSpaceNormalMap, ObjectSpaceNormalMap } from 'three';
 
@@ -44,7 +43,7 @@ class NormalMapNode extends TempNode {
 
 	}
 
-	construct() {
+	construct( builder ) {
 
 		const { normalMapType, scaleNode } = this;
 
@@ -62,18 +61,26 @@ class NormalMapNode extends TempNode {
 
 		if ( normalMapType === ObjectSpaceNormalMap ) {
 
-			const vertexNormalNode = mul( new ModelNode( ModelNode.NORMAL_MATRIX ), normalMap );
-
-			outputNode = normalize( vertexNormalNode );
+			outputNode = normalize( mul( modelNormalMatrix, normalMap ) );
 
 		} else if ( normalMapType === TangentSpaceNormalMap ) {
 
-			outputNode = perturbNormal2ArbNode.call( {
-				eye_pos: positionView,
-				surf_norm: normalView,
-				mapN: normalMap,
-				uv: uv()
-			} );
+			const tangent = builder.hasGeometryAttribute( 'tangent' );
+
+			if ( tangent === true ) {
+
+				outputNode = normalize( mul( TBNViewMatrix, normalMap ) );
+
+			} else {
+
+				outputNode = perturbNormal2ArbNode.call( {
+					eye_pos: positionView,
+					surf_norm: normalView,
+					mapN: normalMap,
+					uv: uv()
+				} );
+
+			}
 
 		}
 

package/examples/jsm/nodes/display/PosterizeNode.js

@@ -0,0 +1,25 @@
+import TempNode from '../core/Node.js';
+import { mul, floor, reciprocal } from '../shadernode/ShaderNodeBaseElements.js';
+
+class PosterizeNode extends TempNode {
+
+	constructor( sourceNode, stepsNode ) {
+
+		super();
+
+		this.sourceNode = sourceNode;
+		this.stepsNode = stepsNode;
+
+	}
+
+	construct() {
+
+		const { sourceNode, stepsNode } = this;
+
+		return mul( floor( mul( sourceNode, stepsNode ) ), reciprocal( stepsNode ) );
+
+	}
+
+}
+
+export default PosterizeNode;