super-three 0.133.5 → 0.135.0

package/examples/jsm/renderers/nodes/core/NodeKeywords.js

@@ -1,75 +1,10 @@
-import VarNode from './VarNode.js';
-import PropertyNode from './PropertyNode.js';
-import PositionNode from '../accessors/PositionNode.js';
-import NormalNode from '../accessors/NormalNode.js';
-
-import { PI, RECIPROCAL_PI, EPSILON } from '../consts/MathConsts.js';
-import { saturateMacro, whiteComplementMacro } from '../functions/MathFunctions.js';
-
 class NodeKeywords {
 
-	static PI = 'PI';
-	static RECIPROCAL_PI = 'RECIPROCAL_PI';
-	static EPSILON = 'EPSILON';
-
-	static Saturate = 'saturate';
-	static WhiteComplement = 'whiteComplement';
-
-	static PositionLocal = 'PositionLocal';
-	static PositionWorld = 'PositionWorld';
-	static PositionView = 'PositionView';
-	static PositionViewDirection = 'PositionViewDirection';
-
-	static NormalLocal = 'NormalLocal';
-	static NormalWorld = 'NormalWorld';
-	static NormalView = 'NormalView';
-
-	static Irradiance = 'Irradiance';
-	static ReflectedLightIndirectDiffuse = 'ReflectedLightIndirectDiffuse';
-	static ReflectedLightIndirectSpecular = 'ReflectedLightIndirectSpecular';
-	static ReflectedLightDirectDiffuse = 'ReflectedLightDirectDiffuse';
-	static ReflectedLightDirectSpecular = 'ReflectedLightDirectSpecular';
-
-	static MaterialDiffuseColor = 'MaterialDiffuseColor';
-
-	// STANDARD
-	static MaterialRoughness = 'MaterialRoughness';
-	static MaterialMetalness = 'MaterialMetalness';
-	static MaterialSpecularTint = 'MaterialSpecularTint';
-
 	constructor() {
 
-		this.keywords = [
-			// consts
-			NodeKeywords.PI,
-			NodeKeywords.RECIPROCAL_PI,
-			NodeKeywords.EPSILON,
-			// variadic macros
-			NodeKeywords.Saturate,
-			NodeKeywords.WhiteComplement,
-			// nodes
-			NodeKeywords.PositionLocal,
-			NodeKeywords.PositionWorld,
-			NodeKeywords.PositionView,
-			NodeKeywords.PositionViewDirection,
-			NodeKeywords.NormalLocal,
-			NodeKeywords.NormalWorld,
-			NodeKeywords.NormalView,
-			// vars -> float
-			NodeKeywords.MaterialRoughness,
-			NodeKeywords.MaterialMetalness,
-			// vars -> vec3
-			NodeKeywords.Irradiance,
-			NodeKeywords.ReflectedLightIndirectDiffuse,
-			NodeKeywords.ReflectedLightIndirectSpecular,
-			NodeKeywords.ReflectedLightDirectDiffuse,
-			NodeKeywords.ReflectedLightDirectSpecular,
-			NodeKeywords.MaterialSpecularTint,
-			// vars -> vec4
-			NodeKeywords.MaterialDiffuseColor
-		];
-
+		this.keywords = [];
 		this.nodes = [];
+		this.keywordsCallback = {};
 
 	}
 
@@ -77,120 +12,24 @@ class NodeKeywords {
 
 		let node = this.nodes[ name ];
 
-		if ( node === undefined ) {
-
-			switch ( name ) {
-
-				case NodeKeywords.PI:
-
-					node = PI;
-
-					break;
-
-				case NodeKeywords.RECIPROCAL_PI:
-
-					node = RECIPROCAL_PI;
-
-					break;
-
-				case NodeKeywords.EPSILON:
-
-					node = EPSILON;
-
-					break;
-
-				case NodeKeywords.Saturate:
-
-					node = saturateMacro;
-
-					break;
-
-				case NodeKeywords.WhiteComplement:
-
-					node = whiteComplementMacro;
-
-					break;
-
-				case NodeKeywords.PositionLocal:
-
-					node = new VarNode( new PositionNode( PositionNode.LOCAL ), name );
-
-					break;
-
-				case NodeKeywords.PositionWorld:
-
-					node = new VarNode( new PositionNode( PositionNode.WORLD ), name );
+		if ( node === undefined && this.keywordsCallback[ name ] !== undefined ) {
 
-					break;
+			node = this.keywordsCallback[ name ]( name );
 
-				case NodeKeywords.PositionView:
+			this.nodes[ name ] = node;
 
-					node = new VarNode( new PositionNode( PositionNode.VIEW ), name );
-
-					break;
-
-				case NodeKeywords.PositionViewDirection:
-
-					node = new VarNode( new PositionNode( PositionNode.VIEW_DIRECTION ), name );
-
-					break;
-
-				case NodeKeywords.NormalLocal:
-
-					node = new VarNode( new NormalNode( NormalNode.LOCAL ), name );
-
-					break;
-
-				case NodeKeywords.NormalWorld:
-
-					node = new VarNode( new NormalNode( NormalNode.WORLD ), name );
-
-					break;
-
-				case NodeKeywords.NormalView:
-
-					node = new VarNode( new NormalNode( NormalNode.VIEW ), name );
-
-					break;
-
-				// floats properties
-				case NodeKeywords.MaterialRoughness:
-				case NodeKeywords.MaterialMetalness:
-
-					node = new PropertyNode( name, 'float' );
-
-					break;
-
-				// vec3 properties
-				case NodeKeywords.Irradiance:
-				case NodeKeywords.ReflectedLightIndirectDiffuse:
-				case NodeKeywords.ReflectedLightIndirectSpecular:
-				case NodeKeywords.ReflectedLightDirectDiffuse:
-				case NodeKeywords.ReflectedLightDirectSpecular:
-				case NodeKeywords.MaterialSpecularTint:
-
-					node = new PropertyNode( name, 'vec3' );
-
-					break;
-
-				// vec4 properties
-				case NodeKeywords.MaterialDiffuseColor:
-
-					node = new PropertyNode( name, 'vec4' );
-
-					break;
-
-			}
+		}
 
-			if ( node !== undefined ) {
+		return node;
 
-				this.nodes[ name ] = node;
+	}
 
-			}
+	addKeyword( name, callback ) {
 
-		}
+		this.keywords.push( name );
+		this.keywordsCallback[ name ] = callback;
 
-		return node;
+		return this;
 
 	}
 
@@ -202,7 +41,7 @@ class NodeKeywords {
 
 		const codeKeywords = code.match( regExp );
 
-		const keywords = [];
+		const keywordNodes = [];
 
 		if ( codeKeywords !== null ) {
 
@@ -210,9 +49,9 @@ class NodeKeywords {
 
 				const node = this.getNode( keyword );
 
-				if ( keywords.indexOf( node ) === - 1 ) {
+				if ( node !== undefined && keywordNodes.indexOf( node ) === - 1 ) {
 
-					keywords.push( node );
+					keywordNodes.push( node );
 
 				}
 
@@ -220,15 +59,15 @@ class NodeKeywords {
 
 		}
 
-		return keywords;
+		return keywordNodes;
 
 	}
 
 	include( builder, code ) {
 
-		const keywords = this.parse( code );
+		const keywordNodes = this.parse( code );
 
-		for ( const keywordNode of keywords ) {
+		for ( const keywordNode of keywordNodes ) {
 
 			keywordNode.build( builder );
 

package/examples/jsm/renderers/nodes/core/NodeParser.js

@@ -0,0 +1,11 @@
+class NodeParser {
+
+	parseFunction( /*source*/ ) {
+
+		console.warn( 'Abstract function.' );
+
+	}
+
+}
+
+export default NodeParser;

package/examples/jsm/renderers/nodes/core/NodeVar.js

@@ -5,10 +5,10 @@ class NodeVar {
 		this.name = name;
 		this.type = type;
 
-		Object.defineProperty( this, 'isNodeVar', { value: true } );
-
 	}
 
 }
 
+NodeVar.prototype.isNodeVar = true;
+
 export default NodeVar;

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

@@ -2,7 +2,7 @@ import Node from './Node.js';
 
 class PropertyNode extends Node {
 
-	constructor( name, nodeType ) {
+	constructor( name = null, nodeType = 'vec4' ) {
 
 		super( nodeType );
 
@@ -10,10 +10,22 @@ class PropertyNode extends Node {
 
 	}
 
+	getHash( builder ) {
+
+		return this.name || super.getHash( builder );
+
+	}
+
 	generate( builder ) {
 
 		const nodeVary = builder.getVarFromNode( this, this.getNodeType( builder ) );
-		nodeVary.name = this.name;
+		const name = this.name;
+
+		if ( name !== null ) {
+
+			nodeVary.name = name;
+
+		}
 
 		return builder.getPropertyName( nodeVary );
 

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

@@ -10,35 +10,32 @@ class TempNode extends Node {
 
 	build( builder, output ) {
 
-		const type = builder.getVectorType( this.getNodeType( builder ) );
+		const type = builder.getVectorType( this.getNodeType( builder, output ) );
 
-		if ( type !== 'void' ) {
-
-			const nodeVar = builder.getVarFromNode( this, type );
-			const propertyName = builder.getPropertyName( nodeVar );
+		if ( builder.context.temp !== false && type !== 'void ' && output !== 'void' ) {
 
 			const nodeData = builder.getDataFromNode( this );
 
-			let snippet = nodeData.snippet;
+			if ( nodeData.snippet === undefined ) {
 
-			if ( snippet === undefined ) {
+				const snippet = super.build( builder, type );
 
-				snippet = super.build( builder, type );
+				const nodeVar = builder.getVarFromNode( this, type );
+				const propertyName = builder.getPropertyName( nodeVar );
 
 				builder.addFlowCode( `${propertyName} = ${snippet}` );
 
 				nodeData.snippet = snippet;
+				nodeData.propertyName = propertyName;
 
 			}
 
-			return builder.format( propertyName, type, output );
-
-		} else {
-
-			return super.build( builder, output );
+			return builder.format( nodeData.propertyName, type, output );
 
 		}
 
+		return super.build( builder, output );
+
 	}
 
 }

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

@@ -2,32 +2,37 @@ import Node from './Node.js';
 
 class VarNode extends Node {
 
-	constructor( value, name = '', nodeType = null ) {
+	constructor( node, name = null, nodeType = null ) {
 
 		super( nodeType );
 
-		this.value = value;
+		this.node = node;
 		this.name = name;
 
 	}
 
+	getHash( builder ) {
+
+		return this.name || super.getHash( builder );
+
+	}
+
 	getNodeType( builder ) {
 
-		return super.getNodeType( builder ) || this.value.getNodeType( builder );
+		return super.getNodeType( builder ) || this.node.getNodeType( builder );
 
 	}
 
 	generate( builder ) {
 
 		const type = builder.getVectorType( this.getNodeType( builder ) );
+		const node = this.node;
 		const name = this.name;
-		const value = this.value;
 
+		const snippet = node.build( builder, type );
 		const nodeVar = builder.getVarFromNode( this, type );
 
-		const snippet = value.build( builder, type );
-
-		if ( name !== '' ) {
+		if ( name !== null ) {
 
 			nodeVar.name = name;
 

package/examples/jsm/renderers/nodes/core/VaryNode.js

@@ -3,11 +3,18 @@ import { NodeShaderStage } from './constants.js';
 
 class VaryNode extends Node {
 
-	constructor( value ) {
+	constructor( node, name = null ) {
 
 		super();
 
-		this.value = value;
+		this.node = node;
+		this.name = name;
+
+	}
+
+	getHash( builder ) {
+
+		return this.name || super.getHash( builder );
 
 	}
 
@@ -15,22 +22,30 @@ class VaryNode extends Node {
 
 		// VaryNode is auto type
 
-		return this.value.getNodeType( builder );
+		return this.node.getNodeType( builder );
 
 	}
 
 	generate( builder ) {
 
 		const type = this.getNodeType( builder );
-		const value = this.value;
+		const node = this.node;
+		const name = this.name;
 
 		const nodeVary = builder.getVaryFromNode( this, type );
-		const propertyName = builder.getPropertyName( nodeVary );
 
-		// force nodeVary.snippet work in vertex stage
-		builder.flowNodeFromShaderStage( NodeShaderStage.Vertex, value, type, propertyName );
+		if ( name !== null ) {
+
+			nodeVary.name = name;
+
+		}
+
+		const propertyName = builder.getPropertyName( nodeVary, NodeShaderStage.Vertex );
+
+		// force node run in vertex stage
+		builder.flowNodeFromShaderStage( NodeShaderStage.Vertex, node, type, propertyName );
 
-		return propertyName;
+		return builder.getPropertyName( nodeVary );
 
 	}
 

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

@@ -10,6 +10,8 @@ export const NodeUpdateType = {
 };
 
 export const NodeType = {
+	Boolean: 'bool',
+	Integer: 'int',
 	Float: 'float',
 	Vector2: 'vec2',
 	Vector3: 'vec3',

package/examples/jsm/renderers/nodes/display/ColorSpaceNode.js

@@ -1,9 +1,36 @@
 import TempNode from '../core/Node.js';
-import CodeNode from '../core/CodeNode.js';
-import * as EncodingFunctions from '../functions/EncodingFunctions.js';
+import { ShaderNode, vec3, pow, mul, add, mix, join, lessThanEqual } from '../ShaderNode.js';
 
-import { LinearEncoding, sRGBEncoding, RGBEEncoding, RGBM7Encoding, RGBM16Encoding,
-	RGBDEncoding, GammaEncoding, LogLuvEncoding } from 'three';
+import { LinearEncoding,
+	sRGBEncoding/*, RGBEEncoding, RGBM7Encoding, RGBM16Encoding,
+	RGBDEncoding, GammaEncoding*/ } from 'three';
+
+export const LinearToLinear = new ShaderNode( ( inputs ) => {
+
+	return inputs.value;
+
+} );
+
+export const sRGBToLinear = new ShaderNode( ( inputs ) => {
+
+	const { value } = inputs;
+
+	const rgb = value.rgb;
+
+	const a = pow( add( mul( rgb, 0.9478672986 ), vec3( 0.0521327014 ) ), vec3( 2.4 ) );
+	const b = mul( rgb, 0.0773993808 );
+	const factor = vec3( lessThanEqual( rgb, vec3( 0.04045 ) ) );
+
+	const rgbResult = mix( a, b, factor );
+
+	return join( rgbResult.r, rgbResult.g, rgbResult.b, value.a );
+
+} );
+
+const EncodingLib = {
+	LinearToLinear,
+	sRGBToLinear
+};
 
 function getEncodingComponents ( encoding ) {
 
@@ -13,6 +40,7 @@ function getEncodingComponents ( encoding ) {
 			return [ 'Linear' ];
 		case sRGBEncoding:
 			return [ 'sRGB' ];
+/*
 		case RGBEEncoding:
 			return [ 'RGBE' ];
 		case RGBM7Encoding:
@@ -23,9 +51,7 @@ function getEncodingComponents ( encoding ) {
 			return [ 'RGBD', new FloatNode( 256.0 ).setConst( true ) ];
 		case GammaEncoding:
 			return [ 'Gamma', new CodeNode( 'float( GAMMA_FACTOR )' ) ];
-		case LogLuvEncoding:
-			return [ 'LogLuv' ];
-
+*/
 	}
 
 }
@@ -34,11 +60,11 @@ class ColorSpaceNode extends TempNode {
 
 	static LINEAR_TO_LINEAR = 'LinearToLinear';
 
-	static GAMMA_TO_LINEAR = 'GammaToLinear';
-	static LINEAR_TO_GAMMA = 'LinearToGamma';
-
 	static SRGB_TO_LINEAR = 'sRGBToLinear';
 	static LINEAR_TO_SRGB = 'LinearTosRGB';
+/*
+	static GAMMA_TO_LINEAR = 'GammaToLinear';
+	static LINEAR_TO_GAMMA = 'LinearToGamma';
 
 	static RGBE_TO_LINEAR = 'RGBEToLinear';
 	static LINEAR_TO_RGBE = 'LinearToRGBE';
@@ -48,17 +74,14 @@ class ColorSpaceNode extends TempNode {
 
 	static RGBD_TO_LINEAR = 'RGBDToLinear';
 	static LINEAR_TO_RGBD = 'LinearToRGBD';
-
-	static LINEAR_TO_LOG_LUV = 'LinearToLogLuv';
-	static LOG_LUV_TO_LINEAR = 'LogLuvToLinear';
-
-	constructor( method, input ) {
+*/
+	constructor( method, node ) {
 
 		super( 'vec4' );
 
 		this.method = method;
 
-		this.input = input;
+		this.node = node;
 		this.factor = null;
 
 	}
@@ -90,22 +113,21 @@ class ColorSpaceNode extends TempNode {
 		const type = this.getNodeType( builder );
 
 		const method = this.method;
-		const input = this.input;
+		const node = this.node;
 
 		if ( method !== ColorSpaceNode.LINEAR_TO_LINEAR ) {
 
-			const encodingFunctionNode = EncodingFunctions[ method ];
-
-			const encodingFunctionCallNode = encodingFunctionNode.call( {
-				value: input,
-				factor: this.factor
-			} );
+			const encodingFunctionNode = EncodingLib[ method ];			
+			const factor = this.factor;
 
-			return encodingFunctionCallNode.build( builder, type );
+			return encodingFunctionNode( {
+				value: node,
+				factor
+			} ).build( builder, type );
 
 		} else {
 
-			return input.build( builder, type );
+			return node.build( builder, type );
 
 		}
 

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

@@ -5,46 +5,45 @@ import MathNode from '../math/MathNode.js';
 import OperatorNode from '../math/OperatorNode.js';
 import FloatNode from '../inputs/FloatNode.js';
 import TempNode from '../core/TempNode.js';
-import FunctionNode from '../core/FunctionNode.js';
 import ModelNode from '../accessors/ModelNode.js';
+import { ShaderNode, cond, add, mul, dFdx, dFdy, cross, max, dot, normalize, inversesqrt, equal } from '../ShaderNode.js';
 
 import { TangentSpaceNormalMap, ObjectSpaceNormalMap } from 'three';
 
 // Normal Mapping Without Precomputed Tangents
 // http://www.thetenthplanet.de/archives/1180
 
-export const perturbNormal2Arb = new FunctionNode( `
-vec3 ( vec3 eye_pos, vec3 surf_norm, vec3 mapN, float faceDirection, const in vec2 uv ) {
+const perturbNormal2ArbNode = new ShaderNode( ( inputs ) => {
 
-	// Workaround for Adreno 3XX dFd*( vec3 ) bug. See #9988
+	const { eye_pos, surf_norm, mapN, faceDirection, uv } = inputs;
 
-	vec3 q0 = vec3( dFdx( eye_pos.x ), dFdx( eye_pos.y ), dFdx( eye_pos.z ) );
-	vec3 q1 = vec3( dFdy( eye_pos.x ), dFdy( eye_pos.y ), dFdy( eye_pos.z ) );
-	vec2 st0 = dFdx( uv.st );
-	vec2 st1 = dFdy( uv.st );
+	const q0 = dFdx( eye_pos.xyz );
+	const q1 = dFdy( eye_pos.xyz );
+	const st0 = dFdx( uv.st );
+	const st1 = dFdy( uv.st );
 
-	vec3 N = surf_norm; // normalized
+	const N = surf_norm; // normalized
 
-	vec3 q1perp = cross( q1, N );
-	vec3 q0perp = cross( N, q0 );
+	const q1perp = cross( q1, N );
+	const q0perp = cross( N, q0 );
 
-	vec3 T = q1perp * st0.x + q0perp * st1.x;
-	vec3 B = q1perp * st0.y + q0perp * st1.y;
+	const T = add( mul( q1perp, st0.x ), mul( q0perp, st1.x ) );
+	const B = add( mul( q1perp, st0.y ), mul( q0perp, st1.y ) );
 
-	float det = max( dot( T, T ), dot( B, B ) );
-	float scale = ( det == 0.0 ) ? 0.0 : faceDirection * inversesqrt( det );
+	const det = max( dot( T, T ), dot( B, B ) );
+	const scale = cond( equal( det, 0 ), 0, mul( faceDirection, inversesqrt( det ) ) );
 
-	return normalize( T * ( mapN.x * scale ) + B * ( mapN.y * scale ) + N * mapN.z );
+	return normalize( add( mul( T, mul( mapN.x, scale ) ), mul( B, mul( mapN.y, scale ) ), mul( N, mapN.z ) ) );
 
-}` );
+} );
 
 class NormalMapNode extends TempNode {
 
-	constructor( value ) {
+	constructor( node ) {
 
 		super( 'vec3' );
 
-		this.value = value;
+		this.node = node;
 
 		this.normalMapType = TangentSpaceNormalMap;
 
@@ -56,7 +55,7 @@ class NormalMapNode extends TempNode {
 
 		const normalMapType = this.normalMapType;
 
-		const normalOP = new OperatorNode( '*', this.value, new FloatNode( 2.0 ).setConst( true ) );
+		const normalOP = new OperatorNode( '*', this.node, new FloatNode( 2.0 ).setConst( true ) );
 		const normalMap = new OperatorNode( '-', normalOP, new FloatNode( 1.0 ).setConst( true ) );
 
 		if ( normalMapType === ObjectSpaceNormalMap ) {
@@ -69,7 +68,7 @@ class NormalMapNode extends TempNode {
 
 		} else if ( normalMapType === TangentSpaceNormalMap ) {
 
-			const perturbNormal2ArbCall = perturbNormal2Arb.call( {
+			const perturbNormal2ArbCall = perturbNormal2ArbNode( {
 				eye_pos: new PositionNode( PositionNode.VIEW ),
 				surf_norm: new NormalNode( NormalNode.VIEW ),
 				mapN: normalMap,
@@ -78,7 +77,7 @@ class NormalMapNode extends TempNode {
 			} );
 
 			return perturbNormal2ArbCall.build( builder, type );
-			
+
 		}
 
 	}