super-three 0.136.0 → 0.141.0

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

@@ -1,281 +1,258 @@
-import { TempNode } from '../core/TempNode.js';
+import TempNode from '../core/TempNode.js';
+import ExpressionNode from '../core/ExpressionNode.js';
+import JoinNode from '../utils/JoinNode.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 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 ) {
+	generate( builder, output ) {
 
-		switch ( this.method ) {
+		const method = this.method;
 
-			case MathNode.LENGTH:
-			case MathNode.DISTANCE:
-			case MathNode.DOT:
+		const type = this.getNodeType( builder );
+		const inputType = this.getInputType( builder );
 
-				return 'f';
+		const a = this.aNode;
+		const b = this.bNode;
+		const c = this.cNode;
 
-			case MathNode.CROSS:
+		const isWebGL = builder.renderer.isWebGLRenderer === true;
 
-				return 'v3';
+		if ( isWebGL && ( method === MathNode.DFDX || method === MathNode.DFDY ) && output === 'vec3' ) {
 
-		}
+			// Workaround for Adreno 3XX dFd*( vec3 ) bug. See #9988
 
-		return this.getInputType( builder );
+			return new JoinNode( [
+				new MathNode( method, new SplitNode( a, 'x' ) ),
+				new MathNode( method, new SplitNode( a, 'y' ) ),
+				new MathNode( method, new SplitNode( a, 'z' ) )
+			] ).build( builder );
 
-	}
+		} else if ( method === MathNode.TRANSFORM_DIRECTION ) {
 
-	generate( builder, output ) {
+			// dir can be either a direction vector or a normal vector
+			// upper-left 3x3 of matrix is assumed to be orthogonal
 
-		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 );
+			let tA = a;
+			let tB = b;
 
-		switch ( this.method ) {
+			if ( builder.isMatrix( tA.getNodeType( builder ) ) ) {
 
-			// 1 input
+				tB = new ExpressionNode( `${ builder.getType( 'vec4' ) }( ${ tB.build( builder, 'vec3' ) }, 0.0 )`, 'vec4' );
 
-			case MathNode.NEGATE:
+			} else {
 
-				return builder.format( '( -' + this.a.build( builder, inputType ) + ' )', inputType, output );
+				tA = new ExpressionNode( `${ builder.getType( 'vec4' ) }( ${ tA.build( builder, 'vec3' ) }, 0.0 )`, 'vec4' );
 
-			case MathNode.INVERT:
+			}
 
-				return builder.format( '( 1.0 - ' + this.a.build( builder, inputType ) + ' )', inputType, output );
+			const mulNode = new SplitNode( new OperatorNode( '*', tA, tB ), 'xyz' );
 
-				// 2 inputs
+			return new MathNode( MathNode.NORMALIZE, mulNode ).build( builder );
 
-			case MathNode.CROSS:
+		} else if ( method === MathNode.SATURATE ) {
 
-				a = this.a.build( builder, 'v3' );
-				b = this.b.build( builder, 'v3' );
+			return builder.format( `clamp( ${ a.build( builder, inputType ) }, 0.0, 1.0 )`, type, output );
 
-				break;
+		} else if ( method === MathNode.NEGATE ) {
 
-			case MathNode.STEP:
+			return builder.format( '( -' + a.build( builder, inputType ) + ' )', type, output );
 
-				a = this.a.build( builder, al === 1 ? 'f' : inputType );
-				b = this.b.build( builder, inputType );
+		} else if ( method === MathNode.INVERT ) {
 
-				break;
+			return builder.format( '( 1.0 - ' + a.build( builder, inputType ) + ' )', type, output );
 
-			case MathNode.MIN:
-			case MathNode.MAX:
-			case MathNode.MOD:
+		} else {
 
-				a = this.a.build( builder, inputType );
-				b = this.b.build( builder, bl === 1 ? 'f' : inputType );
+			const params = [];
 
-				break;
+			if ( method === MathNode.CROSS ) {
 
-				// 3 inputs
+				params.push(
+					a.build( builder, type ),
+					b.build( builder, type )
+				);
 
-			case MathNode.REFRACT:
+			} else if ( method === MathNode.STEP ) {
 
-				a = this.a.build( builder, inputType );
-				b = this.b.build( builder, inputType );
-				c = this.c.build( builder, 'f' );
+				params.push(
+					a.build( builder, builder.getTypeLength( a.getNodeType( builder ) ) === 1 ? 'float' : inputType ),
+					b.build( builder, inputType )
+				);
 
-				break;
+			} else if ( ( isWebGL && ( method === MathNode.MIN || method === MathNode.MAX ) ) || method === MathNode.MOD ) {
 
-			case MathNode.MIX:
+				params.push(
+					a.build( builder, inputType ),
+					b.build( builder, builder.getTypeLength( b.getNodeType( builder ) ) === 1 ? 'float' : inputType )
+				);
 
-				a = this.a.build( builder, inputType );
-				b = this.b.build( builder, inputType );
-				c = this.c.build( builder, cl === 1 ? 'f' : inputType );
+			} else if ( method === MathNode.REFRACT ) {
 
-				break;
+				params.push(
+					a.build( builder, inputType ),
+					b.build( builder, inputType ),
+					c.build( builder, 'float' )
+				);
 
-				// default
+			} 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 )
+				);
 
-				a = this.a.build( builder, inputType );
-				if ( this.b ) b = this.b.build( builder, inputType );
-				if ( this.c ) c = this.c.build( builder, inputType );
+			} else {
 
-				break;
+				params.push( a.build( builder, inputType ) );
 
-		}
+				if ( c !== null ) {
 
-		// build function call
+					params.push( b.build( builder, inputType ), c.build( builder, inputType ) );
 
-		const params = [];
-		params.push( a );
-		if ( b ) params.push( b );
-		if ( c ) params.push( c );
+				} else if ( b !== null ) {
 
-		const numInputs = this.getNumInputs( builder );
+					params.push( b.build( builder, inputType ) );
 
-		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;

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

@@ -1,86 +1,206 @@
-import { TempNode } from '../core/TempNode.js';
+import TempNode from '../core/TempNode.js';
 
 class OperatorNode extends TempNode {
 
-	constructor( a, b, op ) {
+	constructor( op, aNode, bNode, ...params ) {
 
 		super();
 
-		this.a = a;
-		this.b = b;
 		this.op = op;
 
+		if ( params.length > 0 ) {
+
+			let finalBNode = bNode;
+
+			for ( let i = 0; i < params.length; i ++ ) {
+
+				finalBNode = new OperatorNode( op, finalBNode, params[ i ] );
+
+			}
+
+			bNode = finalBNode;
+
+		}
+
+		this.aNode = aNode;
+		this.bNode = bNode;
+
 	}
 
-	getType( builder ) {
+	getNodeType( builder, output ) {
 
-		const a = this.a.getType( builder ),
-			b = this.b.getType( builder );
+		const op = this.op;
 
-		if ( builder.isTypeMatrix( a ) ) {
+		const aNode = this.aNode;
+		const bNode = this.bNode;
 
-			return 'v4';
+		const typeA = aNode.getNodeType( builder );
+		const typeB = bNode.getNodeType( builder );
 
-		} else if ( builder.getTypeLength( b ) > builder.getTypeLength( a ) ) {
+		if ( typeA === 'void' || typeB === 'void' ) {
 
-			// use the greater length vector
+			return 'void';
 
-			return b;
+		} else if ( op === '=' || op === '%' ) {
 
-		}
+			return typeA;
+
+		} else if ( op === '&' || op === '|' || op === '^' || op === '>>' || op === '<<' ) {
+
+			return 'int';
+
+		} else if ( op === '==' || op === '&&' || op === '||' || op === '^^' ) {
+
+			return 'bool';
+
+		} else if ( op === '<' || op === '>' || op === '<=' || op === '>=' ) {
+
+			const typeLength = builder.getTypeLength( output );
+
+			return typeLength > 1 ? `bvec${ typeLength }` : 'bool';
+
+		} else {
 
-		return a;
+			if ( typeA === 'float' && builder.isMatrix( typeB ) ) {
+
+				return typeB;
+
+			} else if ( builder.isMatrix( typeA ) && builder.isVector( typeB ) ) {
+
+				// matrix x vector
+
+				return builder.getVectorFromMatrix( typeA );
+
+			} else if ( builder.isVector( typeA ) && builder.isMatrix( typeB ) ) {
+
+				// vector x matrix
+
+				return builder.getVectorFromMatrix( typeB );
+
+			} else if ( builder.getTypeLength( typeB ) > builder.getTypeLength( typeA ) ) {
+
+				// anytype x anytype: use the greater length vector
+
+				return typeB;
+
+			}
+
+			return typeA;
+
+		}
 
 	}
 
 	generate( builder, output ) {
 
-		const type = this.getType( builder );
+		const op = this.op;
 
-		const a = this.a.build( builder, type ),
-			b = this.b.build( builder, type );
+		const aNode = this.aNode;
+		const bNode = this.bNode;
 
-		return builder.format( '( ' + a + ' ' + this.op + ' ' + b + ' )', type, output );
+		const type = this.getNodeType( builder, output );
 
-	}
+		let typeA = null;
+		let typeB = null;
 
-	copy( source ) {
+		if ( type !== 'void' ) {
 
-		super.copy( source );
+			typeA = aNode.getNodeType( builder );
+			typeB = bNode.getNodeType( builder );
 
-		this.a = source.a;
-		this.b = source.b;
-		this.op = source.op;
+			if ( op === '=' ) {
 
-		return this;
+				typeB = typeA;
 
-	}
+			} else if ( op === '<' || op === '>' || op === '<=' || op === '>=' ) {
+
+				if ( builder.isVector( typeA ) ) {
+
+					typeB = typeA;
 
-	toJSON( meta ) {
+				} else {
 
-		let data = this.getJSONNode( meta );
+					typeA = typeB = 'float';
 
-		if ( ! data ) {
+				}
 
-			data = this.createJSONNode( meta );
+			} else if ( builder.isMatrix( typeA ) && builder.isVector( typeB ) ) {
 
-			data.a = this.a.toJSON( meta ).uuid;
-			data.b = this.b.toJSON( meta ).uuid;
-			data.op = this.op;
+				// matrix x vector
+
+				typeB = builder.getVectorFromMatrix( typeA );
+
+			} else if ( builder.isVector( typeA ) && builder.isMatrix( typeB ) ) {
+
+				// vector x matrix
+
+				typeA = builder.getVectorFromMatrix( typeB );
+
+			} else {
+
+				// anytype x anytype
+
+				typeA = typeB = type;
+
+			}
+
+		} else {
+
+			typeA = typeB = type;
+
+		}
+
+		const a = aNode.build( builder, typeA );
+		const b = bNode.build( builder, typeB );
+
+		const outputLength = builder.getTypeLength( output );
+
+		if ( output !== 'void' ) {
+
+			if ( op === '=' ) {
+
+				builder.addFlowCode( `${a} ${this.op} ${b}` );
+
+				return a;
+
+			} else if ( op === '>' && outputLength > 1 ) {
+
+				return builder.format( `${ builder.getMethod( 'greaterThan' ) }( ${a}, ${b} )`, type, output );
+
+			} else if ( op === '<=' && outputLength > 1 ) {
+
+				return builder.format( `${ builder.getMethod( 'lessThanEqual' ) }( ${a}, ${b} )`, type, output );
+
+			} else {
+
+				return builder.format( `( ${a} ${this.op} ${b} )`, type, output );
+
+			}
+
+		} else if ( typeA !== 'void' ) {
+
+			return builder.format( `${a} ${this.op} ${b}`, type, output );
 
 		}
 
-		return data;
+	}
+
+	serialize( data ) {
+
+		super.serialize( data );
+
+		data.op = this.op;
 
 	}
 
-}
+	deserialize( data ) {
 
-OperatorNode.ADD = '+';
-OperatorNode.SUB = '-';
-OperatorNode.MUL = '*';
-OperatorNode.DIV = '/';
+		super.deserialize( data );
 
-OperatorNode.prototype.nodeType = 'Operator';
+		this.op = data.op;
+
+	}
+
+}
 
-export { OperatorNode };
+export default OperatorNode;