super-three 0.136.1 → 0.144.0

package/examples/jsm/nodes/math/CondNode.js

@@ -1,129 +1,60 @@
-import { TempNode } from '../core/TempNode.js';
+import Node from '../core/Node.js';
+import PropertyNode from '../core/PropertyNode.js';
+import ContextNode from '../core/ContextNode.js';
 
-class CondNode extends TempNode {
+class CondNode extends Node {
 
-	constructor( a, b, op, ifNode, elseNode ) {
+	constructor( condNode, ifNode, elseNode ) {
 
 		super();
 
-		this.a = a;
-		this.b = b;
-
-		this.op = op;
+		this.condNode = condNode;
 
 		this.ifNode = ifNode;
 		this.elseNode = elseNode;
 
 	}
 
-	getType( builder ) {
-
-		if ( this.ifNode ) {
-
-			const ifType = this.ifNode.getType( builder );
-			const elseType = this.elseNode.getType( builder );
-
-			if ( builder.getTypeLength( elseType ) > builder.getTypeLength( ifType ) ) {
-
-				return elseType;
-
-			}
-
-			return ifType;
-
-		}
-
-		return 'b';
-
-	}
+	getNodeType( builder ) {
 
-	getCondType( builder ) {
+		const ifType = this.ifNode.getNodeType( builder );
+		const elseType = this.elseNode.getNodeType( builder );
 
-		if ( builder.getTypeLength( this.b.getType( builder ) ) > builder.getTypeLength( this.a.getType( builder ) ) ) {
+		if ( builder.getTypeLength( elseType ) > builder.getTypeLength( ifType ) ) {
 
-			return this.b.getType( builder );
+			return elseType;
 
 		}
 
-		return this.a.getType( builder );
+		return ifType;
 
 	}
 
-	generate( builder, output ) {
+	generate( builder ) {
 
-		const type = this.getType( builder ),
-			condType = this.getCondType( builder ),
-			a = this.a.build( builder, condType ),
-			b = this.b.build( builder, condType );
+		const type = this.getNodeType( builder );
 
-		let code;
+		const context = { tempWrite: false };
+		const nodeProperty = new PropertyNode( null, type ).build( builder );
 
-		if ( this.ifNode ) {
+		const nodeSnippet = new ContextNode( this.condNode/*, context*/ ).build( builder, 'bool' ),
+			ifSnippet = new ContextNode( this.ifNode, context ).build( builder, type ),
+			elseSnippet = new ContextNode( this.elseNode, context ).build( builder, type );
 
-			const ifCode = this.ifNode.build( builder, type ),
-				elseCode = this.elseNode.build( builder, type );
+		builder.addFlowCode( `if ( ${nodeSnippet} ) {
 
-			code = '( ' + [ a, this.op, b, '?', ifCode, ':', elseCode ].join( ' ' ) + ' )';
+\t\t${nodeProperty} = ${ifSnippet};
 
-		} else {
+\t} else {
 
-			code = '( ' + a + ' ' + this.op + ' ' + b + ' )';
+\t\t${nodeProperty} = ${elseSnippet};
 
-		}
+\t}` );
 
-		return builder.format( code, this.getType( builder ), output );
-
-	}
-
-	copy( source ) {
-
-		super.copy( source );
-
-		this.a = source.a;
-		this.b = source.b;
-
-		this.op = source.op;
-
-		this.ifNode = source.ifNode;
-		this.elseNode = source.elseNode;
-
-		return this;
-
-	}
-
-	toJSON( meta ) {
-
-		let data = this.getJSONNode( meta );
-
-		if ( ! data ) {
-
-			data = this.createJSONNode( meta );
-
-			data.a = this.a.toJSON( meta ).uuid;
-			data.b = this.b.toJSON( meta ).uuid;
-
-			data.op = this.op;
-
-			if ( data.ifNode ) data.ifNode = this.ifNode.toJSON( meta ).uuid;
-			if ( data.elseNode ) data.elseNode = this.elseNode.toJSON( meta ).uuid;
-
-		}
-
-		return data;
+		return nodeProperty;
 
 	}
 
 }
 
-CondNode.EQUAL = '==';
-CondNode.NOT_EQUAL = '!=';
-CondNode.GREATER = '>';
-CondNode.GREATER_EQUAL = '>=';
-CondNode.LESS = '<';
-CondNode.LESS_EQUAL = '<=';
-CondNode.AND = '&&';
-CondNode.OR = '||';
-
-CondNode.prototype.nodeType = 'Cond';
-
-export { CondNode };
+export default CondNode;

package/examples/jsm/nodes/math/MathNode.js

@@ -1,281 +1,248 @@
-import { TempNode } from '../core/TempNode.js';
+import TempNode from '../core/TempNode.js';
+import ExpressionNode from '../core/ExpressionNode.js';
+import SplitNode from '../utils/SplitNode.js';
+import OperatorNode from './OperatorNode.js';
 
 class MathNode extends TempNode {
 
-	constructor( a, bOrMethod, cOrMethod, method ) {
+	// 1 input
+
+	static RADIANS = 'radians';
+	static DEGREES = 'degrees';
+	static EXP = 'exp';
+	static EXP2 = 'exp2';
+	static LOG = 'log';
+	static LOG2 = 'log2';
+	static SQRT = 'sqrt';
+	static INVERSE_SQRT = 'inversesqrt';
+	static FLOOR = 'floor';
+	static CEIL = 'ceil';
+	static NORMALIZE = 'normalize';
+	static FRACT = 'fract';
+	static SIN = 'sin';
+	static COS = 'cos';
+	static TAN = 'tan';
+	static ASIN = 'asin';
+	static ACOS = 'acos';
+	static ATAN = 'atan';
+	static ABS = 'abs';
+	static SIGN = 'sign';
+	static LENGTH = 'length';
+	static NEGATE = 'negate';
+	static INVERT = 'invert';
+	static DFDX = 'dFdx';
+	static DFDY = 'dFdy';
+	static SATURATE = 'saturate';
+	static ROUND = 'round';
+
+	// 2 inputs
+
+	static ATAN2 = 'atan2';
+	static MIN = 'min';
+	static MAX = 'max';
+	static MOD = 'mod';
+	static STEP = 'step';
+	static REFLECT = 'reflect';
+	static DISTANCE = 'distance';
+	static DOT = 'dot';
+	static CROSS = 'cross';
+	static POW = 'pow';
+	static TRANSFORM_DIRECTION = 'transformDirection';
+
+	// 3 inputs
+
+	static MIX = 'mix';
+	static CLAMP = 'clamp';
+	static REFRACT = 'refract';
+	static SMOOTHSTEP = 'smoothstep';
+	static FACEFORWARD = 'faceforward';
+
+	constructor( method, aNode, bNode = null, cNode = null ) {
 
 		super();
 
-		this.a = a;
-		typeof bOrMethod !== 'string' ? this.b = bOrMethod : method = bOrMethod;
-		typeof cOrMethod !== 'string' ? this.c = cOrMethod : method = cOrMethod;
-
 		this.method = method;
 
+		this.aNode = aNode;
+		this.bNode = bNode;
+		this.cNode = cNode;
+
 	}
 
-	getNumInputs( /*builder*/ ) {
+	getInputType( builder ) {
 
-		switch ( this.method ) {
+		const aType = this.aNode.getNodeType( builder );
+		const bType = this.bNode ? this.bNode.getNodeType( builder ) : null;
+		const cType = this.cNode ? this.cNode.getNodeType( builder ) : null;
 
-			// variable
+		const aLen = builder.isMatrix( aType ) ? 0 : builder.getTypeLength( aType );
+		const bLen = builder.isMatrix( bType ) ? 0 : builder.getTypeLength( bType );
+		const cLen = builder.isMatrix( cType ) ? 0 : builder.getTypeLength( cType );
 
-			case MathNode.ARCTAN:
+		if ( aLen > bLen && aLen > cLen ) {
 
-				return this.b ? 2 : 1;
+			return aType;
 
-			// 3
+		} else if ( bLen > cLen ) {
 
-			case MathNode.MIX:
-			case MathNode.CLAMP:
-			case MathNode.REFRACT:
-			case MathNode.SMOOTHSTEP:
-			case MathNode.FACEFORWARD:
+			return bType;
 
-				return 3;
+		} else if ( cLen > aLen ) {
 
-			// 2
+			return cType;
 
-			case MathNode.MIN:
-			case MathNode.MAX:
-			case MathNode.MOD:
-			case MathNode.STEP:
-			case MathNode.REFLECT:
-			case MathNode.DISTANCE:
-			case MathNode.DOT:
-			case MathNode.CROSS:
-			case MathNode.POW:
+		}
 
-				return 2;
+		return aType;
 
-			// 1
+	}
 
-			default:
+	getNodeType( builder ) {
 
-				return 1;
+		const method = this.method;
 
-		}
+		if ( method === MathNode.LENGTH || method === MathNode.DISTANCE || method === MathNode.DOT ) {
 
-	}
+			return 'float';
 
-	getInputType( builder ) {
-
-		const a = builder.getTypeLength( this.a.getType( builder ) );
-		const b = this.b ? builder.getTypeLength( this.b.getType( builder ) ) : 0;
-		const c = this.c ? builder.getTypeLength( this.c.getType( builder ) ) : 0;
-
-		if ( a > b && a > c ) {
+		} else if ( method === MathNode.CROSS ) {
 
-			return this.a.getType( builder );
+			return 'vec3';
 
-		} else if ( b > c ) {
+		} else {
 
-			return this.b.getType( builder );
+			return this.getInputType( builder );
 
 		}
 
-		return this.c.getType( builder );
-
 	}
 
-	getType( builder ) {
-
-		switch ( this.method ) {
-
-			case MathNode.LENGTH:
-			case MathNode.DISTANCE:
-			case MathNode.DOT:
+	generate( builder, output ) {
 
-				return 'f';
+		const method = this.method;
 
-			case MathNode.CROSS:
+		const type = this.getNodeType( builder );
+		const inputType = this.getInputType( builder );
 
-				return 'v3';
+		const a = this.aNode;
+		const b = this.bNode;
+		const c = this.cNode;
 
-		}
+		const isWebGL = builder.renderer.isWebGLRenderer === true;
 
-		return this.getInputType( builder );
+		if ( method === MathNode.TRANSFORM_DIRECTION ) {
 
-	}
+			// dir can be either a direction vector or a normal vector
+			// upper-left 3x3 of matrix is assumed to be orthogonal
 
-	generate( builder, output ) {
+			let tA = a;
+			let tB = b;
 
-		let a, b, c;
-		const al = this.a ? builder.getTypeLength( this.a.getType( builder ) ) : 0,
-			bl = this.b ? builder.getTypeLength( this.b.getType( builder ) ) : 0,
-			cl = this.c ? builder.getTypeLength( this.c.getType( builder ) ) : 0,
-			inputType = this.getInputType( builder ),
-			nodeType = this.getType( builder );
+			if ( builder.isMatrix( tA.getNodeType( builder ) ) ) {
 
-		switch ( this.method ) {
+				tB = new ExpressionNode( `${ builder.getType( 'vec4' ) }( ${ tB.build( builder, 'vec3' ) }, 0.0 )`, 'vec4' );
 
-			// 1 input
+			} else {
 
-			case MathNode.NEGATE:
+				tA = new ExpressionNode( `${ builder.getType( 'vec4' ) }( ${ tA.build( builder, 'vec3' ) }, 0.0 )`, 'vec4' );
 
-				return builder.format( '( -' + this.a.build( builder, inputType ) + ' )', inputType, output );
+			}
 
-			case MathNode.INVERT:
+			const mulNode = new SplitNode( new OperatorNode( '*', tA, tB ), 'xyz' );
 
-				return builder.format( '( 1.0 - ' + this.a.build( builder, inputType ) + ' )', inputType, output );
+			return new MathNode( MathNode.NORMALIZE, mulNode ).build( builder );
 
-				// 2 inputs
+		} else if ( method === MathNode.SATURATE ) {
 
-			case MathNode.CROSS:
+			return builder.format( `clamp( ${ a.build( builder, inputType ) }, 0.0, 1.0 )`, type, output );
 
-				a = this.a.build( builder, 'v3' );
-				b = this.b.build( builder, 'v3' );
+		} else if ( method === MathNode.NEGATE ) {
 
-				break;
+			return builder.format( '( -' + a.build( builder, inputType ) + ' )', type, output );
 
-			case MathNode.STEP:
+		} else if ( method === MathNode.INVERT ) {
 
-				a = this.a.build( builder, al === 1 ? 'f' : inputType );
-				b = this.b.build( builder, inputType );
+			return builder.format( '( 1.0 - ' + a.build( builder, inputType ) + ' )', type, output );
 
-				break;
+		} else {
 
-			case MathNode.MIN:
-			case MathNode.MAX:
-			case MathNode.MOD:
+			const params = [];
 
-				a = this.a.build( builder, inputType );
-				b = this.b.build( builder, bl === 1 ? 'f' : inputType );
+			if ( method === MathNode.CROSS ) {
 
-				break;
+				params.push(
+					a.build( builder, type ),
+					b.build( builder, type )
+				);
 
-				// 3 inputs
+			} else if ( method === MathNode.STEP ) {
 
-			case MathNode.REFRACT:
+				params.push(
+					a.build( builder, builder.getTypeLength( a.getNodeType( builder ) ) === 1 ? 'float' : inputType ),
+					b.build( builder, inputType )
+				);
 
-				a = this.a.build( builder, inputType );
-				b = this.b.build( builder, inputType );
-				c = this.c.build( builder, 'f' );
+			} else if ( ( isWebGL && ( method === MathNode.MIN || method === MathNode.MAX ) ) || method === MathNode.MOD ) {
 
-				break;
+				params.push(
+					a.build( builder, inputType ),
+					b.build( builder, builder.getTypeLength( b.getNodeType( builder ) ) === 1 ? 'float' : inputType )
+				);
 
-			case MathNode.MIX:
+			} else if ( method === MathNode.REFRACT ) {
 
-				a = this.a.build( builder, inputType );
-				b = this.b.build( builder, inputType );
-				c = this.c.build( builder, cl === 1 ? 'f' : inputType );
+				params.push(
+					a.build( builder, inputType ),
+					b.build( builder, inputType ),
+					c.build( builder, 'float' )
+				);
 
-				break;
+			} else if ( method === MathNode.MIX ) {
 
-				// default
+				params.push(
+					a.build( builder, inputType ),
+					b.build( builder, inputType ),
+					c.build( builder, builder.getTypeLength( c.getNodeType( builder ) ) === 1 ? 'float' : inputType )
+				);
 
-			default:
+			} else {
 
-				a = this.a.build( builder, inputType );
-				if ( this.b ) b = this.b.build( builder, inputType );
-				if ( this.c ) c = this.c.build( builder, inputType );
+				params.push( a.build( builder, inputType ) );
 
-				break;
+				if ( c !== null ) {
 
-		}
+					params.push( b.build( builder, inputType ), c.build( builder, inputType ) );
 
-		// build function call
+				} else if ( b !== null ) {
 
-		const params = [];
-		params.push( a );
-		if ( b ) params.push( b );
-		if ( c ) params.push( c );
+					params.push( b.build( builder, inputType ) );
 
-		const numInputs = this.getNumInputs( builder );
+				}
 
-		if ( params.length !== numInputs ) {
+			}
 
-			throw Error( `Arguments not match used in "${this.method}". Require ${numInputs}, currently ${params.length}.` );
+			return builder.format( `${ builder.getMethod( method ) }( ${params.join( ', ' )} )`, type, output );
 
 		}
 
-		return builder.format( this.method + '( ' + params.join( ', ' ) + ' )', nodeType, output );
-
 	}
 
-	copy( source ) {
-
-		super.copy( source );
+	serialize( data ) {
 
-		this.a = source.a;
-		this.b = source.b;
-		this.c = source.c;
-		this.method = source.method;
+		super.serialize( data );
 
-		return this;
+		data.method = this.method;
 
 	}
 
-	toJSON( meta ) {
+	deserialize( data ) {
 
-		let data = this.getJSONNode( meta );
-
-		if ( ! data ) {
-
-			data = this.createJSONNode( meta );
-
-			data.a = this.a.toJSON( meta ).uuid;
-			if ( this.b ) data.b = this.b.toJSON( meta ).uuid;
-			if ( this.c ) data.c = this.c.toJSON( meta ).uuid;
-
-			data.method = this.method;
-
-		}
+		super.deserialize( data );
 
-		return data;
+		this.method = data.method;
 
 	}
 
 }
 
-// 1 input
-
-MathNode.RAD = 'radians';
-MathNode.DEG = 'degrees';
-MathNode.EXP = 'exp';
-MathNode.EXP2 = 'exp2';
-MathNode.LOG = 'log';
-MathNode.LOG2 = 'log2';
-MathNode.SQRT = 'sqrt';
-MathNode.INV_SQRT = 'inversesqrt';
-MathNode.FLOOR = 'floor';
-MathNode.CEIL = 'ceil';
-MathNode.NORMALIZE = 'normalize';
-MathNode.FRACT = 'fract';
-MathNode.SATURATE = 'saturate';
-MathNode.SIN = 'sin';
-MathNode.COS = 'cos';
-MathNode.TAN = 'tan';
-MathNode.ASIN = 'asin';
-MathNode.ACOS = 'acos';
-MathNode.ARCTAN = 'atan';
-MathNode.ABS = 'abs';
-MathNode.SIGN = 'sign';
-MathNode.LENGTH = 'length';
-MathNode.NEGATE = 'negate';
-MathNode.INVERT = 'invert';
-
-// 2 inputs
-
-MathNode.MIN = 'min';
-MathNode.MAX = 'max';
-MathNode.MOD = 'mod';
-MathNode.STEP = 'step';
-MathNode.REFLECT = 'reflect';
-MathNode.DISTANCE = 'distance';
-MathNode.DOT = 'dot';
-MathNode.CROSS = 'cross';
-MathNode.POW = 'pow';
-
-// 3 inputs
-
-MathNode.MIX = 'mix';
-MathNode.CLAMP = 'clamp';
-MathNode.REFRACT = 'refract';
-MathNode.SMOOTHSTEP = 'smoothstep';
-MathNode.FACEFORWARD = 'faceforward';
-
-MathNode.prototype.nodeType = 'Math';
-MathNode.prototype.hashProperties = [ 'method' ];
-
-export { MathNode };
+export default MathNode;