super-three 0.133.4 → 0.136.1

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,85 +1,68 @@
 import TempNode from '../core/Node.js';
-import CodeNode from '../core/CodeNode.js';
-import * as EncodingFunctions from '../functions/EncodingFunctions.js';
-
-import { LinearEncoding, sRGBEncoding, RGBEEncoding, RGBM7Encoding, RGBM16Encoding,
-	RGBDEncoding, GammaEncoding, LogLuvEncoding } from 'three';
-
-function getEncodingComponents ( encoding ) {
-
-	switch ( encoding ) {
-
-		case LinearEncoding:
-			return [ 'Linear' ];
-		case sRGBEncoding:
-			return [ 'sRGB' ];
-		case RGBEEncoding:
-			return [ 'RGBE' ];
-		case RGBM7Encoding:
-			return [ 'RGBM', new FloatNode( 7.0 ).setConst( true ) ];
-		case RGBM16Encoding:
-			return [ 'RGBM', new FloatNode( 16.0 ).setConst( true ) ];
-		case RGBDEncoding:
-			return [ 'RGBD', new FloatNode( 256.0 ).setConst( true ) ];
-		case GammaEncoding:
-			return [ 'Gamma', new CodeNode( 'float( GAMMA_FACTOR )' ) ];
-		case LogLuvEncoding:
-			return [ 'LogLuv' ];
+import { ShaderNode,
+	vec3,
+	pow, mul, sub, mix, join,
+	lessThanEqual } from '../ShaderNode.js';
 
-	}
+import { LinearEncoding, sRGBEncoding } from 'three';
 
-}
+export const LinearToLinear = new ShaderNode( ( inputs ) => {
 
-class ColorSpaceNode extends TempNode {
+	return inputs.value;
 
-	static LINEAR_TO_LINEAR = 'LinearToLinear';
+} );
 
-	static GAMMA_TO_LINEAR = 'GammaToLinear';
-	static LINEAR_TO_GAMMA = 'LinearToGamma';
+export const LinearTosRGB = new ShaderNode( ( inputs ) => {
 
-	static SRGB_TO_LINEAR = 'sRGBToLinear';
-	static LINEAR_TO_SRGB = 'LinearTosRGB';
+	const { value } = inputs;
+
+	const rgb = value.rgb;
+
+	const a = sub( mul( pow( value.rgb, vec3( 0.41666 ) ), 1.055 ), vec3( 0.055 ) );
+	const b = mul( rgb, 12.92 );
+	const factor = vec3( lessThanEqual( rgb, vec3( 0.0031308 ) ) );
+
+	const rgbResult = mix( a, b, factor );
 
-	static RGBE_TO_LINEAR = 'RGBEToLinear';
-	static LINEAR_TO_RGBE = 'LinearToRGBE';
+	return join( rgbResult.r, rgbResult.g, rgbResult.b, value.a );
 
-	static RGBM_TO_LINEAR = 'RGBMToLinear';
-	static LINEAR_TO_RGBM = 'LinearToRGBM';
+} );
 
-	static RGBD_TO_LINEAR = 'RGBDToLinear';
-	static LINEAR_TO_RGBD = 'LinearToRGBD';
+const EncodingLib = {
+	LinearToLinear,
+	LinearTosRGB
+};
 
-	static LINEAR_TO_LOG_LUV = 'LinearToLogLuv';
-	static LOG_LUV_TO_LINEAR = 'LogLuvToLinear';
+class ColorSpaceNode extends TempNode {
+
+	static LINEAR_TO_LINEAR = 'LinearToLinear';
+	static LINEAR_TO_SRGB = 'LinearTosRGB';
 
-	constructor( method, input ) {
+	constructor( method, node ) {
 
 		super( 'vec4' );
 
 		this.method = method;
 
-		this.input = input;
-		this.factor = null;
+		this.node = node;
 
 	}
 
 	fromEncoding( encoding ) {
 
-		const components = getEncodingComponents( encoding );
+		let method = null;
 
-		this.method = 'LinearTo' + components[ 0 ];
-		this.factor = components[ 1 ];
+		if ( encoding === LinearEncoding ) {
 
-		return this;
+			method = 'Linear';
 
-	}
+		} else if ( encoding === sRGBEncoding ) {
 
-	fromDecoding( encoding ) {
+			method = 'sRGB';
 
-		const components = getEncodingComponents( encoding );
+		}
 
-		this.method = components[ 0 ] + 'ToLinear';
-		this.factor = components[ 1 ];
+		this.method = 'LinearTo' + method;
 
 		return this;
 
@@ -90,22 +73,19 @@ 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 ];
 
-			return encodingFunctionCallNode.build( builder, type );
+			return encodingFunctionNode( {
+				value: node
+			} ).build( builder, type );
 
 		} else {
 
-			return input.build( builder, type );
+			return node.build( builder, type );
 
 		}