super-three 0.158.0 → 0.160.1

package/examples/jsm/transpiler/AST.js

@@ -27,6 +27,32 @@ export class VariableDeclaration {
 
 }
 
+export class Uniform {
+
+	constructor( type, name ) {
+
+		this.type = type;
+		this.name = name;
+
+		this.isUniform = true;
+
+	}
+
+}
+
+export class Varying {
+
+	constructor( type, name ) {
+
+		this.type = type;
+		this.name = name;
+
+		this.isVarying = true;
+
+	}
+
+}
+
 export class FunctionParameter {
 
 	constructor( type, name, qualifier = null, immutable = true ) {
@@ -125,6 +151,19 @@ export class Number {
 
 }
 
+export class String {
+
+	constructor( value ) {
+
+		this.value = value;
+
+		this.isString = true;
+
+	}
+
+}
+
+
 export class Conditional {
 
 	constructor( cond = null ) {
@@ -228,4 +267,4 @@ export class For {
 
 	}
 
-}
+}

package/examples/jsm/transpiler/GLSLDecoder.js

@@ -1,4 +1,4 @@
-import { Program, FunctionDeclaration, For, AccessorElements, Ternary, DynamicElement, StaticElement, FunctionParameter, Unary, Conditional, VariableDeclaration, Operator, Number, FunctionCall, Return, Accessor } from './AST.js';
+import { Program, FunctionDeclaration, For, AccessorElements, Ternary, Varying, DynamicElement, StaticElement, FunctionParameter, Unary, Conditional, VariableDeclaration, Operator, Number, String, FunctionCall, Return, Accessor, Uniform } from './AST.js';
 
 const unaryOperators = [
 	'+', '-', '~', '!', '++', '--'
@@ -180,7 +180,7 @@ class Tokenizer {
 
 				const token = new Token( this, parser.type, result[ parser.group || 0 ], this.position );
 
-				this.position += token.str.length;
+				this.position += result[ 0 ].length;
 
 				if ( parser.isTag ) {
 
@@ -218,11 +218,11 @@ class GLSLDecoder {
 
 		this._currentFunction = null;
 
-		this.addKeyword( 'gl_FragCoord', 'vec2 gl_FragCoord = vec2( viewportCoordinate.x, viewportCoordinate.y.oneMinus() );' );
+		this.addPolyfill( 'gl_FragCoord', 'vec2 gl_FragCoord = vec2( viewportCoordinate.x, viewportCoordinate.y.oneMinus() );' );
 
 	}
 
-	addKeyword( name, polyfill ) {
+	addPolyfill( name, polyfill ) {
 
 		this.keywords.push( { name, polyfill } );
 
@@ -406,15 +406,27 @@ class GLSLDecoder {
 
 			let type;
 
-			if ( /^(0x)/.test( firstToken.str ) ) type = 'int';
+			const isHex = /^(0x)/.test( firstToken.str );
+
+			if ( isHex ) type = 'int';
 			else if ( /u$/.test( firstToken.str ) ) type = 'uint';
 			else if ( /f|e|\./.test( firstToken.str ) ) type = 'float';
 			else type = 'int';
 
-			const str = firstToken.str.replace( /u$/, '' );
+			let str = firstToken.str.replace( /u|i$/, '' );
+
+			if ( isHex === false ) {
+
+				str = str.replace( /f$/, '' );
+
+			}
 
 			return new Number( str, type );
 
+		} else if ( firstToken.isString ) {
+
+			return new String( firstToken.str );
+
 		} else if ( firstToken.isLiteral ) {
 
 			if ( firstToken.str === 'return' ) {
@@ -629,6 +641,28 @@ class GLSLDecoder {
 
 	}
 
+	parseUniform() {
+
+		const tokens = this.readTokensUntil( ';' );
+
+		const type = tokens[ 1 ].str;
+		const name = tokens[ 2 ].str;
+
+		return new Uniform( type, name );
+
+	}
+
+	parseVarying() {
+
+		const tokens = this.readTokensUntil( ';' );
+
+		const type = tokens[ 1 ].str;
+		const name = tokens[ 2 ].str;
+
+		return new Varying( type, name );
+
+	}
+
 	parseReturn() {
 
 		this.readToken(); // skip 'return'
@@ -716,7 +750,7 @@ class GLSLDecoder {
 
 		let current = conditional;
 
-		while ( this.getToken().str === 'else' ) {
+		while ( this.getToken() && this.getToken().str === 'else' ) {
 
 			this.readToken(); // skip 'else'
 
@@ -778,6 +812,14 @@ class GLSLDecoder {
 
 					statement = this.parseVariables();
 
+				} else if ( token.str === 'uniform' ) {
+
+					statement = this.parseUniform();
+
+				} else if ( token.str === 'varying' ) {
+
+					statement = this.parseVarying();
+
 				} else if ( isType( token.str ) ) {
 
 					if ( this.getToken( 2 ).str === '(' ) {
@@ -896,4 +938,4 @@ class GLSLDecoder {
 
 }
 
-export default GLSLDecoder;
+export default GLSLDecoder;

package/examples/jsm/transpiler/ShaderToyDecoder.js

@@ -7,9 +7,9 @@ class ShaderToyDecoder extends GLSLDecoder {
 
 		super();
 
-		this.addKeyword( 'iTime', 'float iTime = timerGlobal();' );
-		this.addKeyword( 'iResolution', 'vec2 iResolution = viewportResolution;' );
-		this.addKeyword( 'fragCoord', 'vec2 fragCoord = vec2( viewportCoordinate.x, viewportResolution.y - viewportCoordinate.y );' );
+		this.addPolyfill( 'iTime', 'float iTime = timerGlobal();' );
+		this.addPolyfill( 'iResolution', 'vec2 iResolution = viewportResolution;' );
+		this.addPolyfill( 'fragCoord', 'vec2 fragCoord = vec2( viewportCoordinate.x, viewportResolution.y - viewportCoordinate.y );' );
 
 	}
 
@@ -46,4 +46,4 @@ class ShaderToyDecoder extends GLSLDecoder {
 
 }
 
-export default ShaderToyDecoder;
+export default ShaderToyDecoder;

package/examples/jsm/transpiler/TSLEncoder.js

@@ -1,6 +1,6 @@
 import { REVISION } from 'three';
 import { VariableDeclaration, Accessor } from './AST.js';
-import * as Nodes from 'three/nodes';
+import * as Nodes from '../nodes/Nodes.js';
 
 const opLib = {
 	'=': 'assign',
@@ -27,7 +27,7 @@ const opLib = {
 	'*=': 'mulAssign',
 	'/=': 'divAssign',
 	'%=': 'remainderAssign',
-	'^=': 'xorAssign',
+	'^=': 'bitXorAssign',
 	'&=': 'bitAndAssign',
 	'|=': 'bitOrAssign',
 	'<<=': 'shiftLeftAssign',
@@ -51,13 +51,15 @@ class TSLEncoder {
 
 		this.tab = '';
 		this.imports = new Set();
-		this.functions = new Set();
+		this.global = new Set();
+		this.overloadings = new Map();
 		this.layoutsCode = '';
 		this.iife = false;
 		this.uniqueNames = false;
+		this.reference = false;
 
 		this._currentProperties = {};
-		this._lastStatment = null;
+		this._lastStatement = null;
 
 	}
 
@@ -67,7 +69,7 @@ class TSLEncoder {
 
 		name = name.split( '.' )[ 0 ];
 
-		if ( Nodes[ name ] !== undefined && this.functions.has( name ) === false && this._currentProperties[ name ] === undefined ) {
+		if ( Nodes[ name ] !== undefined && this.global.has( name ) === false && this._currentProperties[ name ] === undefined ) {
 
 			this.imports.add( name );
 
@@ -75,10 +77,45 @@ class TSLEncoder {
 
 	}
 
+	emitUniform( node ) {
+
+		let code = `const ${ node.name } = `;
+
+		if ( this.reference === true ) {
+
+			this.addImport( 'reference' );
+
+			this.global.add( node.name );
+
+			//code += `reference( '${ node.name }', '${ node.type }', uniforms )`;
+
+			// legacy
+			code += `reference( 'value', '${ node.type }', uniforms[ '${ node.name }' ] )`;
+
+		} else {
+
+			this.addImport( 'uniform' );
+
+			this.global.add( node.name );
+
+			code += `uniform( '${ node.type }' )`;
+
+		}
+
+		return code;
+
+	}
+
 	emitExpression( node ) {
 
 		let code;
 
+		/*@TODO: else if ( node.isVarying ) {
+
+			code = this.emitVarying( node );
+
+		}*/
+
 		if ( node.isAccessor ) {
 
 			this.addImport( node.property );
@@ -99,6 +136,10 @@ class TSLEncoder {
 
 			}
 
+		} else if ( node.isString ) {
+
+			code = '\'' + node.value + '\'';
+
 		} else if ( node.isOperator ) {
 
 			const opFn = opLib[ node.type ] || node.type;
@@ -194,6 +235,10 @@ class TSLEncoder {
 
 			code = this.emitVariables( node );
 
+		} else if ( node.isUniform ) {
+
+			code = this.emitUniform( node );
+
 		} else if ( node.isTernary ) {
 
 			code = this.emitTernary( node );
@@ -204,7 +249,7 @@ class TSLEncoder {
 
 		} else if ( node.isUnary && node.expression.isNumber ) {
 
-			code = node.type + node.expression.value;
+			code = node.type + ' ' + node.expression.value;
 
 		} else if ( node.isUnary ) {
 
@@ -232,7 +277,7 @@ class TSLEncoder {
 
 		} else {
 
-			console.error( 'Unknown node type', node );
+			console.warn( 'Unknown node type', node );
 
 		}
 
@@ -291,7 +336,7 @@ class TSLEncoder {
 
 		let ifStr = `If( ${ condStr }, () => {
 
-${ bodyStr } 
+${ bodyStr }
 
 ${ this.tab }} )`;
 
@@ -305,7 +350,7 @@ ${ this.tab }} )`;
 
 				const elseCondStr = this.emitExpression( current.elseConditional.cond );
 
-				ifStr += `.elseif( ( ${ elseCondStr } ) => {
+				ifStr += `.elseif( ${ elseCondStr }, () => {
 
 ${ elseBodyStr }
 
@@ -449,6 +494,18 @@ ${ this.tab }} )`;
 
 	}
 
+	/*emitVarying( node ) { }*/
+
+	emitOverloadingFunction( nodes ) {
+
+		const { name } = nodes[ 0 ];
+
+		this.addImport( 'overloadingFn' );
+
+		return `const ${ name } = overloadingFn( [ ${ nodes.map( node => node.name + '_' + nodes.indexOf( node ) ).join( ', ' ) } ] );\n`;
+
+	}
+
 	emitFunction( node ) {
 
 		const { name, type } = node;
@@ -503,7 +560,30 @@ ${ this.tab }} )`;
 		const paramsStr = params.length > 0 ? ' [ ' + params.join( ', ' ) + ' ] ' : '';
 		const bodyStr = this.emitBody( node.body );
 
-		const funcStr = `const ${ name } = tslFn( (${ paramsStr }) => {
+		let fnName = name;
+		let overloadingNodes = null;
+
+		if ( this.overloadings.has( name ) ) {
+
+			const overloadings = this.overloadings.get( name );
+
+			if ( overloadings.length > 1 ) {
+
+				const index = overloadings.indexOf( node );
+
+				fnName += '_' + index;
+
+				if ( index === overloadings.length - 1 ) {
+
+					overloadingNodes = overloadings;
+
+				}
+
+			}
+
+		}
+
+		let funcStr = `const ${ fnName } = tslFn( (${ paramsStr }) => {
 
 ${ bodyStr }
 
@@ -513,9 +593,9 @@ ${ this.tab }} );\n`;
 
 		if ( node.layout !== false && hasPointer === false ) {
 
-			const uniqueName = this.uniqueNames ? name + '_' + Math.random().toString( 36 ).slice( 2 ) : name;
+			const uniqueName = this.uniqueNames ? fnName + '_' + Math.random().toString( 36 ).slice( 2 ) : fnName;
 
-			this.layoutsCode += `${ this.tab + name }.setLayout( {
+			this.layoutsCode += `${ this.tab + fnName }.setLayout( {
 ${ this.tab }\tname: '${ uniqueName }',
 ${ this.tab }\ttype: '${ type }',
 ${ this.tab }\tinputs: [${ layoutInput }]
@@ -525,7 +605,13 @@ ${ this.tab }} );\n\n`;
 
 		this.imports.add( 'tslFn' );
 
-		this.functions.add( node.name );
+		this.global.add( node.name );
+
+		if ( overloadingNodes !== null ) {
+
+			funcStr += '\n' + this.emitOverloadingFunction( overloadingNodes );
+
+		}
 
 		return funcStr;
 
@@ -533,13 +619,13 @@ ${ this.tab }} );\n\n`;
 
 	setLastStatement( statement ) {
 
-		this._lastStatment = statement;
+		this._lastStatement = statement;
 
 	}
 
 	emitExtraLine( statement ) {
 
-		const last = this._lastStatment;
+		const last = this._lastStatement;
 		if ( last === null ) return '';
 
 		if ( statement.isReturn ) return '\n';
@@ -560,6 +646,24 @@ ${ this.tab }} );\n\n`;
 
 		if ( this.iife ) this.tab += '\t';
 
+		const overloadings = this.overloadings;
+
+		for ( const statement of ast.body ) {
+
+			if ( statement.isFunctionDeclaration ) {
+
+				if ( overloadings.has( statement.name ) === false ) {
+
+					overloadings.set( statement.name, [] );
+
+				}
+
+				overloadings.get( statement.name ).push( statement );
+
+			}
+
+		}
+
 		for ( const statement of ast.body ) {
 
 			code += this.emitExtraLine( statement );
@@ -579,7 +683,7 @@ ${ this.tab }} );\n\n`;
 		}
 
 		const imports = [ ...this.imports ];
-		const functions = [ ...this.functions ];
+		const exports = [ ...this.global ];
 
 		const layouts = this.layoutsCode.length > 0 ? `\n${ this.tab }// layouts\n\n` + this.layoutsCode : '';
 
@@ -588,17 +692,17 @@ ${ this.tab }} );\n\n`;
 
 		if ( this.iife ) {
 
-			header += '( function ( TSL ) {\n\n';
+			header += '( function ( TSL, uniforms ) {\n\n';
 
 			header += imports.length > 0 ? '\tconst { ' + imports.join( ', ' ) + ' } = TSL;\n' : '';
-			footer += functions.length > 0 ? '\treturn { ' + functions.join( ', ' ) + ' };\n' : '';
+			footer += exports.length > 0 ? '\treturn { ' + exports.join( ', ' ) + ' };\n' : '';
 
 			footer += '\n} );';
 
 		} else {
 
 			header += imports.length > 0 ? 'import { ' + imports.join( ', ' ) + ' } from \'three/nodes\';\n' : '';
-			footer += functions.length > 0 ? 'export { ' + functions.join( ', ' ) + ' };\n' : '';
+			footer += exports.length > 0 ? 'export { ' + exports.join( ', ' ) + ' };\n' : '';
 
 		}
 
@@ -608,4 +712,4 @@ ${ this.tab }} );\n\n`;
 
 }
 
-export default TSLEncoder;
+export default TSLEncoder;

package/examples/jsm/utils/SortUtils.js

@@ -0,0 +1,158 @@
+// Hybrid radix sort from
+// - https://gist.github.com/sciecode/93ed864dd77c5c8803c6a86698d68dab
+// - https://github.com/mrdoob/three.js/pull/27202#issuecomment-1817640271
+const POWER = 3;
+const BIT_MAX = 32;
+const BIN_BITS = 1 << POWER;
+const BIN_SIZE = 1 << BIN_BITS;
+const BIN_MAX = BIN_SIZE - 1;
+const ITERATIONS = BIT_MAX / BIN_BITS;
+
+const bins = new Array( ITERATIONS );
+const bins_buffer = new ArrayBuffer( ( ITERATIONS + 1 ) * BIN_SIZE * 4 );
+
+let c = 0;
+for ( let i = 0; i < ( ITERATIONS + 1 ); i ++ ) {
+	bins[ i ] = new Uint32Array( bins_buffer, c, BIN_SIZE );
+	c += BIN_SIZE * 4;
+}
+
+const defaultGet = ( el ) => el;
+
+export const radixSort = ( arr, opt ) => {
+
+	const len = arr.length;
+
+	const options = opt || {};
+	const aux = options.aux || new arr.constructor( len );
+	const get = options.get || defaultGet;
+
+	const data = [ arr, aux ];
+
+	let compare, accumulate, recurse;
+
+	if ( options.reversed ) {
+
+		compare = ( a, b ) => a < b;
+		accumulate = ( bin ) => {
+
+			for ( let j = BIN_SIZE - 2; j >= 0; j -- )
+				bin[ j ] += bin[ j + 1 ];
+
+		};
+
+		recurse = ( cache, depth, start ) => {
+
+			let prev = 0;
+			for ( let j = BIN_MAX; j >= 0; j -- ) {
+
+				const cur = cache[ j ], diff = cur - prev;
+				if ( diff != 0 ) {
+
+					if ( diff > 32 )
+						radixSortBlock( depth + 1, start + prev, diff );
+					else
+						insertionSortBlock( depth + 1, start + prev, diff );
+					prev = cur;
+
+				}
+
+			}
+
+		};
+
+	} else {
+
+		compare = ( a, b ) => a > b;
+		accumulate = ( bin ) => {
+
+			for ( let j = 1; j < BIN_SIZE; j ++ )
+				bin[ j ] += bin[ j - 1 ];
+
+		};
+
+		recurse = ( cache, depth, start ) => {
+
+			let prev = 0;
+			for ( let j = 0; j < BIN_SIZE; j ++ ) {
+
+				const cur = cache[ j ], diff = cur - prev;
+				if ( diff != 0 ) {
+
+					if ( diff > 32 )
+						radixSortBlock( depth + 1, start + prev, diff );
+					else
+						insertionSortBlock( depth + 1, start + prev, diff );
+					prev = cur;
+
+				}
+
+			}
+
+		};
+
+	}
+
+	const insertionSortBlock = ( depth, start, len ) => {
+
+		const a = data[ depth & 1 ];
+		const b = data[ ( depth + 1 ) & 1 ];
+
+		for ( let j = start + 1; j < start + len; j ++ ) {
+
+			const p = a[ j ], t = get( p );
+			let i = j;
+			while ( i > 0 ) {
+
+				if ( compare( get( a[ i - 1 ] ), t ) )
+					a[ i ] = a[ -- i ];
+				else
+					break;
+
+			}
+
+			a[ i ] = p;
+
+		}
+
+		if ( ( depth & 1 ) == 1 ) {
+
+			for ( let i = start; i < start + len; i ++ )
+				b[ i ] = a[ i ];
+
+		}
+
+	};
+
+	const radixSortBlock = ( depth, start, len ) => {
+
+		const a = data[ depth & 1 ];
+		const b = data[ ( depth + 1 ) & 1 ];
+
+		const shift = ( 3 - depth ) << POWER;
+		const end = start + len;
+
+		const cache = bins[ depth ];
+		const bin = bins[ depth + 1 ];
+
+		bin.fill( 0 );
+
+		for ( let j = start; j < end; j ++ )
+			bin[ ( get( a[ j ] ) >> shift ) & BIN_MAX ] ++;
+
+		accumulate( bin );
+
+		cache.set( bin );
+
+		for ( let j = end - 1; j >= start; j -- )
+			b[ start + -- bin[ ( get( a[ j ] ) >> shift ) & BIN_MAX ] ] = a[ j ];
+
+		if ( depth == ITERATIONS - 1 ) return;
+
+		recurse( cache, depth, start );
+
+	};
+
+	radixSortBlock( 0, 0, len );
+
+};