super-three 0.136.1 → 0.144.0

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;

package/examples/jsm/{renderers/nodes → nodes}/parsers/GLSLNodeFunction.js

@@ -12,7 +12,7 @@ const parse = ( source ) => {
 
 	const pragmaMainIndex = source.indexOf( pragmaMain );
 
-	const mainCode = pragmaMainIndex !== - 1 ? source.substr( pragmaMainIndex + pragmaMain.length ) : source;
+	const mainCode = pragmaMainIndex !== - 1 ? source.slice( pragmaMainIndex + pragmaMain.length ) : source;
 
 	const declaration = mainCode.match( declarationRegexp );
 
@@ -81,7 +81,7 @@ const parse = ( source ) => {
 
 		const presicion = declaration[ 1 ] !== undefined ? declaration[ 1 ] : '';
 
-		const headerCode = pragmaMainIndex !== - 1 ? source.substr( 0, pragmaMainIndex ) : '';
+		const headerCode = pragmaMainIndex !== - 1 ? source.slice( 0, pragmaMainIndex ) : '';
 
 		return {
 			type,
@@ -117,18 +117,33 @@ class GLSLNodeFunction extends NodeFunction {
 
 	getCode( name = this.name ) {
 
-		const headerCode = this.headerCode;
-		const presicion = this.presicion;
+		let code;
 
-		let declarationCode = `${ this.type } ${ name } ( ${ this.inputsCode.trim() } )`;
+		const blockCode = this.blockCode;
 
-		if ( presicion !== '' ) {
+		if ( blockCode !== '' ) {
 
-			declarationCode = `${ presicion } ${ declarationCode }`;
+			const { type, inputsCode, headerCode, presicion } = this;
+
+			let declarationCode = `${ type } ${ name } ( ${ inputsCode.trim() } )`;
+
+			if ( presicion !== '' ) {
+
+				declarationCode = `${ presicion } ${ declarationCode }`;
+
+			}
+
+			code = headerCode + declarationCode + blockCode;
+
+		} else {
+
+			// interface function
+
+			code = '';
 
 		}
 
-		return headerCode + declarationCode + this.blockCode;
+		return code;
 
 	}
 

package/examples/jsm/{renderers/nodes → nodes}/parsers/WGSLNodeFunction.js

@@ -1,9 +1,13 @@
 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 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 wgslTypeLib = {
+	f32: 'float'
+};
+
 const parse = ( source ) => {
 
 	source = source.trim();
@@ -33,10 +37,19 @@ const parse = ( source ) => {
 
 		while ( i < propsMatches.length ) {
 
+			// default
+
 			const name = propsMatches[ i ++ ][ 0 ];
-			const type = propsMatches[ i ++ ][ 0 ];
+			let type = propsMatches[ i ++ ][ 0 ];
+
+			type = wgslTypeLib[ type ] || type;
 
-			propsMatches[ i ++ ][ 0 ]; // precision
+			// precision
+
+			if ( i < propsMatches.length && /^[fui]\d{2}$/.test( propsMatches[ i ][ 0 ] ) === true )
+				i ++;
+
+			// add input
 
 			inputs.push( new NodeFunctionInput( type, name ) );
 
@@ -47,7 +60,7 @@ const parse = ( source ) => {
 		const blockCode = source.substring( declaration[ 0 ].length );
 
 		const name = declaration[ 1 ] !== undefined ? declaration[ 1 ] : '';
-		const type = declaration[ 3 ];
+		const type = declaration[ 3 ] || 'void';
 
 		return {
 			type,
@@ -80,7 +93,9 @@ class WGSLNodeFunction extends NodeFunction {
 
 	getCode( name = this.name ) {
 
-		return `fn ${ name } ( ${ this.inputsCode.trim() } ) -> ${ this.type }` + this.blockCode;
+		const type = this.type !== 'void' ? '-> ' + this.type : '';
+
+		return `fn ${ name } ( ${ this.inputsCode.trim() } ) ${ type }` + this.blockCode;
 
 	}
 

package/examples/jsm/nodes/procedural/CheckerNode.js

@@ -1,75 +1,34 @@
-import { TempNode } from '../core/TempNode.js';
-import { FunctionNode } from '../core/FunctionNode.js';
-import { UVNode } from '../accessors/UVNode.js';
+import TempNode from '../core/TempNode.js';
+import { ShaderNode, uv, add, mul, floor, mod, sign } from '../shadernode/ShaderNodeBaseElements.js';
 
-class CheckerNode extends TempNode {
-
-	constructor( uv ) {
-
-		super( 'f' );
+const checkerShaderNode = new ShaderNode( ( inputs ) => {
 
-		this.uv = uv || new UVNode();
+	const uv = mul( inputs.uv, 2.0 );
 
-	}
-
-	generate( builder, output ) {
+	const cx = floor( uv.x );
+	const cy = floor( uv.y );
+	const result = mod( add( cx, cy ), 2.0 );
 
-		const snoise = builder.include( CheckerNode.Nodes.checker );
+	return sign( result );
 
-		return builder.format( snoise + '( ' + this.uv.build( builder, 'v2' ) + ' )', this.getType( builder ), output );
+} );
 
-	}
-
-	copy( source ) {
+class CheckerNode extends TempNode {
 
-		super.copy( source );
+	constructor( uvNode = uv() ) {
 
-		this.uv = source.uv;
+		super( 'float' );
 
-		return this;
+		this.uvNode = uvNode;
 
 	}
 
-	toJSON( meta ) {
-
-		let data = this.getJSONNode( meta );
-
-		if ( ! data ) {
-
-			data = this.createJSONNode( meta );
+	generate( builder ) {
 
-			data.uv = this.uv.toJSON( meta ).uuid;
-
-		}
-
-		return data;
+		return checkerShaderNode.call( { uv: this.uvNode } ).build( builder );
 
 	}
 
 }
 
-CheckerNode.Nodes = ( function () {
-
-	// https://github.com/mattdesl/glsl-checker/blob/master/index.glsl
-
-	const checker = new FunctionNode( /* glsl */`
-		float checker( vec2 uv ) {
-
-			float cx = floor( uv.x );
-			float cy = floor( uv.y );
-			float result = mod( cx + cy, 2.0 );
-
-			return sign( result );
-
-		}`
-	);
-
-	return {
-		checker: checker
-	};
-
-} )();
-
-CheckerNode.prototype.nodeType = 'Noise';
-
-export { CheckerNode };
+export default CheckerNode;