super-three 0.133.3 → 0.136.0

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

@@ -1,4 +1,8 @@
-import TempNode from '../core/Node.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 {
 
@@ -16,7 +20,6 @@ class MathNode extends TempNode {
 	static CEIL = 'ceil';
 	static NORMALIZE = 'normalize';
 	static FRACT = 'fract';
-	static SATURATE = 'saturate';
 	static SIN = 'sin';
 	static COS = 'cos';
 	static TAN = 'tan';
@@ -28,6 +31,9 @@ class MathNode extends TempNode {
 	static LENGTH = 'length';
 	static NEGATE = 'negate';
 	static INVERT = 'invert';
+	static DFDX = 'dFdx';
+	static DFDY = 'dFdy';
+	static SATURATE = 'saturate'
 
 	// 2 inputs
 
@@ -40,6 +46,7 @@ class MathNode extends TempNode {
 	static DOT = 'dot';
 	static CROSS = 'cross';
 	static POW = 'pow';
+	static TRANSFORM_DIRECTION = 'transformDirection';
 
 	// 3 inputs
 
@@ -49,39 +56,43 @@ class MathNode extends TempNode {
 	static SMOOTHSTEP = 'smoothstep';
 	static FACEFORWARD = 'faceforward';
 
-	constructor( method, a, b = null, c = null ) {
+	constructor( method, aNode, bNode = null, cNode = null ) {
 
 		super();
 
 		this.method = method;
 
-		this.a = a;
-		this.b = b;
-		this.c = c;
+		this.aNode = aNode;
+		this.bNode = bNode;
+		this.cNode = cNode;
 
 	}
 
 	getInputType( builder ) {
 
-		const aLen = this.a.getTypeLength( builder );
-		const bLen = this.b ? this.b.getTypeLength( builder ) : 0;
-		const cLen = this.c ? this.c.getTypeLength( builder ) : 0;
+		const aType = this.aNode.getNodeType( builder );
+		const bType = this.bNode ? this.bNode.getNodeType( builder ) : null;
+		const cType = this.cNode ? this.cNode.getNodeType( builder ) : null;
+
+		const aLen = builder.getTypeLength( aType );
+		const bLen = builder.getTypeLength( bType );
+		const cLen = builder.getTypeLength( cType );
 
 		if ( aLen > bLen && aLen > cLen ) {
 
-			return this.a.getNodeType( builder );
+			return aType;
 
 		} else if ( bLen > cLen ) {
 
-			return this.b.getNodeType( builder );
+			return bType;
 
 		} else if ( cLen > aLen ) {
 
-			this.c.getNodeType( builder )
+			return cType;
 
 		}
 
-		return this.a.getNodeType( builder );
+		return aType;
 
 	}
 
@@ -93,7 +104,7 @@ class MathNode extends TempNode {
 
 			return 'float';
 
-		} else if (method === MathNode.CROSS) {
+		} else if ( method === MathNode.CROSS ) {
 
 			return 'vec3';
 
@@ -105,20 +116,62 @@ class MathNode extends TempNode {
 
 	}
 
-	generate( builder ) {
+	generate( builder, output ) {
 
 		const method = this.method;
 
 		const type = this.getNodeType( builder );
 		const inputType = this.getInputType( builder );
 
-		if ( method === MathNode.NEGATE ) {
+		const a = this.aNode;
+		const b = this.bNode;
+		const c = this.cNode;
+
+		const isWebGL = builder.renderer.isWebGLRenderer === true;
+
+		if ( isWebGL && ( method === MathNode.DFDX || method === MathNode.DFDY ) && output === 'vec3' ) {
+
+			// Workaround for Adreno 3XX dFd*( vec3 ) bug. See #9988
+
+			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 ) {
+
+			// dir can be either a direction vector or a normal vector
+			// upper-left 3x3 of matrix is assumed to be orthogonal
+
+			let tA = a;
+			let tB = b;
+
+			if ( builder.isMatrix( tA.getNodeType( builder ) ) ) {
+
+				tB = new ExpressionNode( `${ builder.getType( 'vec4' ) }( ${ tB.build( builder, 'vec3' ) }, 0.0 )`, 'vec4' );
+
+			} else {
+
+				tA = new ExpressionNode( `${ builder.getType( 'vec4' ) }( ${ tA.build( builder, 'vec3' ) }, 0.0 )`, 'vec4' );
+
+			}
+
+			const mulNode = new SplitNode( new OperatorNode( '*', tA, tB ), 'xyz' );
+
+			return new MathNode( MathNode.NORMALIZE, mulNode ).build( builder );
+
+		} else if ( method === MathNode.SATURATE ) {
+
+			return `clamp( ${ a.build( builder, inputType ) }, 0.0, 1.0 )`;
+
+		} else if ( method === MathNode.NEGATE ) {
 
-			return '( -' + this.a.build( builder, inputType ) + ' )';
+			return '( -' + a.build( builder, inputType ) + ' )';
 
 		} else if ( method === MathNode.INVERT ) {
 
-			return '( 1.0 - ' + this.a.build( builder, inputType ) + ' )';
+			return '( 1.0 - ' + a.build( builder, inputType ) + ' )';
 
 		} else {
 
@@ -127,57 +180,57 @@ class MathNode extends TempNode {
 			if ( method === MathNode.CROSS ) {
 
 				params.push(
-					this.a.build( builder, type ),
-					this.b.build( builder, type )
+					a.build( builder, type ),
+					b.build( builder, type )
 				);
 
 			} else if ( method === MathNode.STEP ) {
 
 				params.push(
-					this.b.build( builder, this.a.getTypeLength( builder ) === 1 ? 'float' : inputType ),
-					this.b.build( builder, inputType )
+					a.build( builder, builder.getTypeLength( a.getNodeType( builder ) ) === 1 ? 'float' : inputType ),
+					b.build( builder, inputType )
 				);
 
-			} else if ( method === MathNode.MIN || method === MathNode.MAX || method === MathNode.MOD ) {
+			} else if ( ( isWebGL && ( method === MathNode.MIN || method === MathNode.MAX ) ) || method === MathNode.MOD ) {
 
 				params.push(
-					this.a.build( builder, inputType ),
-					this.b.build( builder, this.b.getTypeLength( builder ) === 1 ? 'float' : inputType )
+					a.build( builder, inputType ),
+					b.build( builder, builder.getTypeLength( b.getNodeType( builder ) ) === 1 ? 'float' : inputType )
 				);
 
 			} else if ( method === MathNode.REFRACT ) {
 
 				params.push(
-					this.a.build( builder, inputType ),
-					this.b.build( builder, inputType ),
-					this.c.build( builder, 'float' )
+					a.build( builder, inputType ),
+					b.build( builder, inputType ),
+					c.build( builder, 'float' )
 				);
 
 			} else if ( method === MathNode.MIX ) {
 
 				params.push(
-					this.a.build( builder, inputType ),
-					this.b.build( builder, inputType ),
-					this.c.build( builder, this.c.getTypeLength( builder ) === 1 ? 'float' : inputType )
+					a.build( builder, inputType ),
+					b.build( builder, inputType ),
+					c.build( builder, builder.getTypeLength( c.getNodeType( builder ) ) === 1 ? 'float' : inputType )
 				);
 
 			} else {
 
-				params.push( this.a.build( builder, inputType ) );
+				params.push( a.build( builder, inputType ) );
 
-				if ( this.c !== null ) {
+				if ( c !== null ) {
 
-					params.push( this.b.build( builder, inputType ), this.c.build( builder, inputType ) );
+					params.push( b.build( builder, inputType ), c.build( builder, inputType ) );
 
-				} else if ( this.b !== null ) {
+				} else if ( b !== null ) {
 
-					params.push( this.b.build( builder, inputType ) );
+					params.push( b.build( builder, inputType ) );
 
 				}
 
 			}
 
-			return `${method}( ${params.join(', ')} )`;
+			return `${ builder.getMethod( method ) }( ${params.join( ', ' )} )`;
 
 		}
 

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

@@ -2,77 +2,170 @@ import TempNode from '../core/TempNode.js';
 
 class OperatorNode extends TempNode {
 
-	constructor( op, a, b ) {
+	constructor( op, aNode, bNode, ...params ) {
 
 		super();
 
 		this.op = op;
 
-		this.a = a;
-		this.b = b;
+		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;
 
 	}
 
-	getNodeType( builder ) {
+	getNodeType( builder, output ) {
 
-		const typeA = this.a.getNodeType( builder );
-		const typeB = this.b.getNodeType( builder );
+		const op = this.op;
 
-		if ( builder.isMatrix( typeA ) && builder.isVector( typeB ) ) {
+		const aNode = this.aNode;
+		const bNode = this.bNode;
 
-			// matrix x vector
+		const typeA = aNode.getNodeType( builder );
+		const typeB = bNode.getNodeType( builder );
 
-			return builder.getVectorFromMatrix( typeA );
+		if ( typeA === 'void' || typeB === 'void' ) {
 
-		} else if ( builder.isVector( typeA ) && builder.isMatrix( typeB ) ) {
+			return 'void';
 
-			// vector x matrix
+		} else if ( op === '=' ) {
 
-			return builder.getVectorFromMatrix( typeB );
+			return typeA;
 
-		} else if ( builder.getTypeLength( typeB ) > builder.getTypeLength( typeA ) ) {
+		} else if ( op === '==' || op === '&&' ) {
 
-			// anytype x anytype: use the greater length vector
+			return 'bool';
 
-			return typeB;
+		} else if ( op === '<=' || op === '>' ) {
 
-		}
+			const length = builder.getTypeLength( output );
+
+			return length > 1 ? `bvec${ length }` : 'bool';
+
+		} else {
+
+			if ( typeA === 'float' && builder.isMatrix( typeB ) ) {
 
-		return typeA;
+				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 ) {
 
-		let typeA = this.a.getNodeType( builder );
-		let typeB = this.b.getNodeType( builder );
+		const op = this.op;
 
-		let type = this.getNodeType( builder );
+		const aNode = this.aNode;
+		const bNode = this.bNode;
 
-		if ( builder.isMatrix( typeA ) && builder.isVector( typeB ) ) {
+		const type = this.getNodeType( builder, output );
 
-			// matrix x vector
+		let typeA = null;
+		let typeB = null;
 
-			type = typeB = builder.getVectorFromMatrix( typeA );
+		if ( type !== 'void' ) {
 
-		} else if ( builder.isVector( typeA ) && builder.isMatrix( typeB ) ) {
+			typeA = aNode.getNodeType( builder );
+			typeB = bNode.getNodeType( builder );
 
-			// vector x matrix
+			if ( op === '=' ) {
 
-			type = typeB = builder.getVectorFromMatrix( typeB );
+				typeB = typeA;
 
-		} else {
+			} else if ( builder.isMatrix( typeA ) && builder.isVector( typeB ) ) {
+
+				// 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
+				// anytype x anytype
+
+				typeA = typeB = type;
+
+			}
+
+		} else {
 
 			typeA = typeB = type;
 
 		}
 
-		const a = this.a.build( builder, typeA );
-		const b = this.b.build( builder, typeB );
+		const a = aNode.build( builder, typeA );
+		const b = bNode.build( builder, typeB );
+
+		const outputLength = builder.getTypeLength( output );
+
+		if ( output !== 'void' ) {
 
-		return `( ${a} ${this.op} ${b} )`;
+			if ( op === '=' ) {
+
+				builder.addFlowCode( `${a} ${this.op} ${b}` );
+
+				return a;
+
+			} else if ( op === '>' && outputLength > 1 ) {
+
+				return `${ builder.getMethod( 'greaterThan' ) }( ${a}, ${b} )`;
+
+			} else if ( op === '<=' && outputLength > 1 ) {
+
+				return `${ builder.getMethod( 'lessThanEqual' ) }( ${a}, ${b} )`;
+
+			} else {
+
+				return `( ${a} ${this.op} ${b} )`;
+
+			}
+
+		} else if ( typeA !== 'void' ) {
+
+			return `${a} ${this.op} ${b}`;
+
+		}
 
 	}
 

package/examples/jsm/renderers/nodes/parsers/GLSLNodeFunction.js

@@ -0,0 +1,137 @@
+import NodeFunction from '../core/NodeFunction.js';
+import NodeFunctionInput from '../core/NodeFunctionInput.js';
+
+const declarationRegexp = /^\s*(highp|mediump|lowp)?\s*([a-z_0-9]+)\s*([a-z_0-9]+)?\s*\(([\s\S]*?)\)/i;
+const propertiesRegexp = /[a-z_0-9]+/ig;
+
+const pragmaMain = '#pragma main';
+
+const parse = ( source ) => {
+
+	source = source.trim();
+
+	const pragmaMainIndex = source.indexOf( pragmaMain );
+
+	const mainCode = pragmaMainIndex !== - 1 ? source.substr( pragmaMainIndex + pragmaMain.length ) : source;
+
+	const declaration = mainCode.match( declarationRegexp );
+
+	if ( declaration !== null && declaration.length === 5 ) {
+
+		// tokenizer
+
+		const inputsCode = declaration[ 4 ];
+		const propsMatches = [];
+
+		let nameMatch = null;
+
+		while ( ( nameMatch = propertiesRegexp.exec( inputsCode ) ) !== null ) {
+
+			propsMatches.push( nameMatch );
+
+		}
+
+		// parser
+
+		const inputs = [];
+
+		let i = 0;
+
+		while ( i < propsMatches.length ) {
+
+			const isConst = propsMatches[ i ][ 0 ] === 'const';
+
+			if ( isConst === true ) {
+
+				i ++;
+
+			}
+
+			let qualifier = propsMatches[ i ][ 0 ];
+
+			if ( qualifier === 'in' || qualifier === 'out' || qualifier === 'inout' ) {
+
+				i ++;
+
+			} else {
+
+				qualifier = '';
+
+			}
+
+			const type = propsMatches[ i ++ ][ 0 ];
+
+			let count = Number.parseInt( propsMatches[ i ][ 0 ] );
+
+			if ( Number.isNaN( count ) === false ) i ++;
+			else count = null;
+
+			const name = propsMatches[ i ++ ][ 0 ];
+
+			inputs.push( new NodeFunctionInput( type, name, count, qualifier, isConst ) );
+
+		}
+
+		//
+
+		const blockCode = mainCode.substring( declaration[ 0 ].length );
+
+		const name = declaration[ 3 ] !== undefined ? declaration[ 3 ] : '';
+		const type = declaration[ 2 ];
+
+		const presicion = declaration[ 1 ] !== undefined ? declaration[ 1 ] : '';
+
+		const headerCode = pragmaMainIndex !== - 1 ? source.substr( 0, pragmaMainIndex ) : '';
+
+		return {
+			type,
+			inputs,
+			name,
+			presicion,
+			inputsCode,
+			blockCode,
+			headerCode
+		};
+
+	} else {
+
+		throw new Error( 'FunctionNode: Function is not a GLSL code.' );
+
+	}
+
+};
+
+class GLSLNodeFunction extends NodeFunction {
+
+	constructor( source ) {
+
+		const { type, inputs, name, presicion, inputsCode, blockCode, headerCode } = parse( source );
+
+		super( type, inputs, name, presicion );
+
+		this.inputsCode = inputsCode;
+		this.blockCode = blockCode;
+		this.headerCode = headerCode;
+
+	}
+
+	getCode( name = this.name ) {
+
+		const headerCode = this.headerCode;
+		const presicion = this.presicion;
+
+		let declarationCode = `${ this.type } ${ name } ( ${ this.inputsCode.trim() } )`;
+
+		if ( presicion !== '' ) {
+
+			declarationCode = `${ presicion } ${ declarationCode }`;
+
+		}
+
+		return headerCode + declarationCode + this.blockCode;
+
+	}
+
+}
+
+export default GLSLNodeFunction;

package/examples/jsm/renderers/nodes/parsers/GLSLNodeParser.js

@@ -0,0 +1,14 @@
+import NodeParser from '../core/NodeParser.js';
+import GLSLNodeFunction from './GLSLNodeFunction.js';
+
+class GLSLNodeParser extends NodeParser {
+
+	parseFunction( source ) {
+
+		return new GLSLNodeFunction( source );
+
+	}
+
+}
+
+export default GLSLNodeParser;

package/examples/jsm/renderers/nodes/parsers/WGSLNodeFunction.js

@@ -0,0 +1,89 @@
+import NodeFunction from '../core/NodeFunction.js';
+import NodeFunctionInput from '../core/NodeFunctionInput.js';
+
+const declarationRegexp = /^fn\s*([a-z_0-9]+)?\s*\(([\s\S]*?)\)\s*\-\>\s*([a-z_0-9]+)?/i;
+const propertiesRegexp = /[a-z_0-9]+/ig;
+
+const parse = ( source ) => {
+
+	source = source.trim();
+
+	const declaration = source.match( declarationRegexp );
+
+	if ( declaration !== null && declaration.length === 4 ) {
+
+		// tokenizer
+
+		const inputsCode = declaration[ 2 ];
+		const propsMatches = [];
+
+		let nameMatch = null;
+
+		while ( ( nameMatch = propertiesRegexp.exec( inputsCode ) ) !== null ) {
+
+			propsMatches.push( nameMatch );
+
+		}
+
+		// parser
+
+		const inputs = [];
+
+		let i = 0;
+
+		while ( i < propsMatches.length ) {
+
+			const name = propsMatches[ i ++ ][ 0 ];
+			const type = propsMatches[ i ++ ][ 0 ];
+
+			propsMatches[ i ++ ][ 0 ]; // precision
+
+			inputs.push( new NodeFunctionInput( type, name ) );
+
+		}
+
+		//
+
+		const blockCode = source.substring( declaration[ 0 ].length );
+
+		const name = declaration[ 1 ] !== undefined ? declaration[ 1 ] : '';
+		const type = declaration[ 3 ];
+
+		return {
+			type,
+			inputs,
+			name,
+			inputsCode,
+			blockCode
+		};
+
+	} else {
+
+		throw new Error( 'FunctionNode: Function is not a WGSL code.' );
+
+	}
+
+};
+
+class WGSLNodeFunction extends NodeFunction {
+
+	constructor( source ) {
+
+		const { type, inputs, name, inputsCode, blockCode } = parse( source );
+
+		super( type, inputs, name );
+
+		this.inputsCode = inputsCode;
+		this.blockCode = blockCode;
+
+	}
+
+	getCode( name = this.name ) {
+
+		return `fn ${ name } ( ${ this.inputsCode.trim() } ) -> ${ this.type }` + this.blockCode;
+
+	}
+
+}
+
+export default WGSLNodeFunction;

package/examples/jsm/renderers/nodes/parsers/WGSLNodeParser.js

@@ -0,0 +1,14 @@
+import NodeParser from '../core/NodeParser.js';
+import WGSLNodeFunction from './WGSLNodeFunction.js';
+
+class WGSLNodeParser extends NodeParser {
+
+	parseFunction( source ) {
+
+		return new WGSLNodeFunction( source );
+
+	}
+
+}
+
+export default WGSLNodeParser;