super-three 0.165.0 → 0.168.0

package/{examples/jsm → src}/nodes/math/OperatorNode.js

@@ -1,6 +1,6 @@
+import { registerNode } from '../core/Node.js';
 import TempNode from '../core/TempNode.js';
-import { addNodeClass } from '../core/Node.js';
-import { addNodeElement, nodeProxy } from '../shadernode/ShaderNode.js';
+import { addMethodChaining, nodeProxy } from '../tsl/TSLCore.js';
 
 class OperatorNode extends TempNode {
 
@@ -8,22 +8,22 @@ class OperatorNode extends TempNode {
 
 		super();
 
-		this.op = op;
-
 		if ( params.length > 0 ) {
 
-			let finalBNode = bNode;
+			let finalOp = new OperatorNode( op, aNode, bNode );
 
-			for ( let i = 0; i < params.length; i ++ ) {
+			for ( let i = 0; i < params.length - 1; i ++ ) {
 
-				finalBNode = new OperatorNode( op, finalBNode, params[ i ] );
+				finalOp = new OperatorNode( op, finalOp, params[ i ] );
 
 			}
 
-			bNode = finalBNode;
+			aNode = finalOp;
+			bNode = params[ params.length - 1 ];
 
 		}
 
+		this.op = op;
 		this.aNode = aNode;
 		this.bNode = bNode;
 
@@ -116,7 +116,7 @@ class OperatorNode extends TempNode {
 
 					typeB = typeA;
 
-				} else {
+				} else if ( typeA !== typeB ) {
 
 					typeA = typeB = 'float';
 
@@ -163,19 +163,51 @@ class OperatorNode extends TempNode {
 
 			if ( op === '<' && outputLength > 1 ) {
 
-				return builder.format( `${ builder.getMethod( 'lessThan' ) }( ${ a }, ${ b } )`, type, output );
+				if ( builder.useComparisonMethod ) {
+
+					return builder.format( `${ builder.getMethod( 'lessThan', output ) }( ${ a }, ${ b } )`, type, output );
+
+				} else {
+
+					return builder.format( `( ${ a } < ${ b } )`, type, output );
+
+				}
 
 			} else if ( op === '<=' && outputLength > 1 ) {
 
-				return builder.format( `${ builder.getMethod( 'lessThanEqual' ) }( ${ a }, ${ b } )`, type, output );
+				if ( builder.useComparisonMethod ) {
+
+					return builder.format( `${ builder.getMethod( 'lessThanEqual', output ) }( ${ a }, ${ b } )`, type, output );
+
+				} else {
+
+					return builder.format( `( ${ a } <= ${ b } )`, type, output );
+
+				}
 
 			} else if ( op === '>' && outputLength > 1 ) {
 
-				return builder.format( `${ builder.getMethod( 'greaterThan' ) }( ${ a }, ${ b } )`, type, output );
+				if ( builder.useComparisonMethod ) {
+
+					return builder.format( `${ builder.getMethod( 'greaterThan', output ) }( ${ a }, ${ b } )`, type, output );
+
+				} else {
+
+					return builder.format( `( ${ a } > ${ b } )`, type, output );
+
+				}
 
 			} else if ( op === '>=' && outputLength > 1 ) {
 
-				return builder.format( `${ builder.getMethod( 'greaterThanEqual' ) }( ${ a }, ${ b } )`, type, output );
+				if ( builder.useComparisonMethod ) {
+
+					return builder.format( `${ builder.getMethod( 'greaterThanEqual', output ) }( ${ a }, ${ b } )`, type, output );
+
+				} else {
+
+					return builder.format( `( ${ a } >= ${ b } )`, type, output );
+
+				}
 
 			} else if ( op === '!' || op === '~' ) {
 
@@ -227,48 +259,58 @@ class OperatorNode extends TempNode {
 
 export default OperatorNode;
 
-export const add = nodeProxy( OperatorNode, '+' );
-export const sub = nodeProxy( OperatorNode, '-' );
-export const mul = nodeProxy( OperatorNode, '*' );
-export const div = nodeProxy( OperatorNode, '/' );
-export const remainder = nodeProxy( OperatorNode, '%' );
-export const equal = nodeProxy( OperatorNode, '==' );
-export const notEqual = nodeProxy( OperatorNode, '!=' );
-export const lessThan = nodeProxy( OperatorNode, '<' );
-export const greaterThan = nodeProxy( OperatorNode, '>' );
-export const lessThanEqual = nodeProxy( OperatorNode, '<=' );
-export const greaterThanEqual = nodeProxy( OperatorNode, '>=' );
-export const and = nodeProxy( OperatorNode, '&&' );
-export const or = nodeProxy( OperatorNode, '||' );
-export const not = nodeProxy( OperatorNode, '!' );
-export const xor = nodeProxy( OperatorNode, '^^' );
-export const bitAnd = nodeProxy( OperatorNode, '&' );
-export const bitNot = nodeProxy( OperatorNode, '~' );
-export const bitOr = nodeProxy( OperatorNode, '|' );
-export const bitXor = nodeProxy( OperatorNode, '^' );
-export const shiftLeft = nodeProxy( OperatorNode, '<<' );
-export const shiftRight = nodeProxy( OperatorNode, '>>' );
-
-addNodeElement( 'add', add );
-addNodeElement( 'sub', sub );
-addNodeElement( 'mul', mul );
-addNodeElement( 'div', div );
-addNodeElement( 'remainder', remainder );
-addNodeElement( 'equal', equal );
-addNodeElement( 'notEqual', notEqual );
-addNodeElement( 'lessThan', lessThan );
-addNodeElement( 'greaterThan', greaterThan );
-addNodeElement( 'lessThanEqual', lessThanEqual );
-addNodeElement( 'greaterThanEqual', greaterThanEqual );
-addNodeElement( 'and', and );
-addNodeElement( 'or', or );
-addNodeElement( 'not', not );
-addNodeElement( 'xor', xor );
-addNodeElement( 'bitAnd', bitAnd );
-addNodeElement( 'bitNot', bitNot );
-addNodeElement( 'bitOr', bitOr );
-addNodeElement( 'bitXor', bitXor );
-addNodeElement( 'shiftLeft', shiftLeft );
-addNodeElement( 'shiftRight', shiftRight );
-
-addNodeClass( 'OperatorNode', OperatorNode );
+OperatorNode.type = /*@__PURE__*/ registerNode( 'Operator', OperatorNode );
+
+export const add = /*@__PURE__*/ nodeProxy( OperatorNode, '+' );
+export const sub = /*@__PURE__*/ nodeProxy( OperatorNode, '-' );
+export const mul = /*@__PURE__*/ nodeProxy( OperatorNode, '*' );
+export const div = /*@__PURE__*/ nodeProxy( OperatorNode, '/' );
+export const modInt = /*@__PURE__*/ nodeProxy( OperatorNode, '%' );
+export const equal = /*@__PURE__*/ nodeProxy( OperatorNode, '==' );
+export const notEqual = /*@__PURE__*/ nodeProxy( OperatorNode, '!=' );
+export const lessThan = /*@__PURE__*/ nodeProxy( OperatorNode, '<' );
+export const greaterThan = /*@__PURE__*/ nodeProxy( OperatorNode, '>' );
+export const lessThanEqual = /*@__PURE__*/ nodeProxy( OperatorNode, '<=' );
+export const greaterThanEqual = /*@__PURE__*/ nodeProxy( OperatorNode, '>=' );
+export const and = /*@__PURE__*/ nodeProxy( OperatorNode, '&&' );
+export const or = /*@__PURE__*/ nodeProxy( OperatorNode, '||' );
+export const not = /*@__PURE__*/ nodeProxy( OperatorNode, '!' );
+export const xor = /*@__PURE__*/ nodeProxy( OperatorNode, '^^' );
+export const bitAnd = /*@__PURE__*/ nodeProxy( OperatorNode, '&' );
+export const bitNot = /*@__PURE__*/ nodeProxy( OperatorNode, '~' );
+export const bitOr = /*@__PURE__*/ nodeProxy( OperatorNode, '|' );
+export const bitXor = /*@__PURE__*/ nodeProxy( OperatorNode, '^' );
+export const shiftLeft = /*@__PURE__*/ nodeProxy( OperatorNode, '<<' );
+export const shiftRight = /*@__PURE__*/ nodeProxy( OperatorNode, '>>' );
+
+addMethodChaining( 'add', add );
+addMethodChaining( 'sub', sub );
+addMethodChaining( 'mul', mul );
+addMethodChaining( 'div', div );
+addMethodChaining( 'modInt', modInt );
+addMethodChaining( 'equal', equal );
+addMethodChaining( 'notEqual', notEqual );
+addMethodChaining( 'lessThan', lessThan );
+addMethodChaining( 'greaterThan', greaterThan );
+addMethodChaining( 'lessThanEqual', lessThanEqual );
+addMethodChaining( 'greaterThanEqual', greaterThanEqual );
+addMethodChaining( 'and', and );
+addMethodChaining( 'or', or );
+addMethodChaining( 'not', not );
+addMethodChaining( 'xor', xor );
+addMethodChaining( 'bitAnd', bitAnd );
+addMethodChaining( 'bitNot', bitNot );
+addMethodChaining( 'bitOr', bitOr );
+addMethodChaining( 'bitXor', bitXor );
+addMethodChaining( 'shiftLeft', shiftLeft );
+addMethodChaining( 'shiftRight', shiftRight );
+
+
+export const remainder = ( ...params ) => { // @deprecated, r168
+
+	console.warn( 'TSL.OperatorNode: .remainder() has been renamed to .modInt().' );
+	return modInt( ...params );
+
+};
+
+addMethodChaining( 'remainder', remainder );

package/{examples/jsm → src}/nodes/math/TriNoise3D.js

@@ -1,28 +1,40 @@
 // https://github.com/cabbibo/glsl-tri-noise-3d
 
-import { loop } from '../utils/LoopNode.js';
-import { float, vec3, tslFn } from '../shadernode/ShaderNode.js';
+import { Loop } from '../utils/LoopNode.js';
+import { float, vec3, Fn } from '../tsl/TSLBase.js';
 
-const tri = tslFn( ( [ x ] ) => {
+export const tri = /*@__PURE__*/ Fn( ( [ x ] ) => {
 
 	return x.fract().sub( .5 ).abs();
 
+} ).setLayout( {
+	name: 'tri',
+	type: 'float',
+	inputs: [
+		{ name: 'x', type: 'float' }
+	]
 } );
 
-const tri3 = tslFn( ( [ p ] ) => {
+export const tri3 = /*@__PURE__*/ Fn( ( [ p ] ) => {
 
 	return vec3( tri( p.z.add( tri( p.y.mul( 1. ) ) ) ), tri( p.z.add( tri( p.x.mul( 1. ) ) ) ), tri( p.y.add( tri( p.x.mul( 1. ) ) ) ) );
 
+} ).setLayout( {
+	name: 'tri3',
+	type: 'vec3',
+	inputs: [
+		{ name: 'p', type: 'vec3' }
+	]
 } );
 
-const triNoise3D = tslFn( ( [ p_immutable, spd, time ] ) => {
+export const triNoise3D = /*@__PURE__*/ Fn( ( [ p_immutable, spd, time ] ) => {
 
 	const p = vec3( p_immutable ).toVar();
 	const z = float( 1.4 ).toVar();
 	const rz = float( 0.0 ).toVar();
 	const bp = vec3( p ).toVar();
 
-	loop( { start: float( 0.0 ), end: float( 3.0 ), type: 'float', condition: '<=' }, () => {
+	Loop( { start: float( 0.0 ), end: float( 3.0 ), type: 'float', condition: '<=' }, () => {
 
 		const dg = vec3( tri3( bp.mul( 2.0 ) ) ).toVar();
 		p.addAssign( dg.add( time.mul( float( 0.1 ).mul( spd ) ) ) );
@@ -38,27 +50,7 @@ const triNoise3D = tslFn( ( [ p_immutable, spd, time ] ) => {
 
 	return rz;
 
-} );
-
-// layouts
-
-tri.setLayout( {
-	name: 'tri',
-	type: 'float',
-	inputs: [
-		{ name: 'x', type: 'float' }
-	]
-} );
-
-tri3.setLayout( {
-	name: 'tri3',
-	type: 'vec3',
-	inputs: [
-		{ name: 'p', type: 'vec3' }
-	]
-} );
-
-triNoise3D.setLayout( {
+} ).setLayout( {
 	name: 'triNoise3D',
 	type: 'float',
 	inputs: [
@@ -67,5 +59,3 @@ triNoise3D.setLayout( {
 		{ name: 'time', type: 'float' }
 	]
 } );
-
-export { tri, tri3, triNoise3D };

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

@@ -79,7 +79,7 @@ const parse = ( source ) => {
 		const name = declaration[ 3 ] !== undefined ? declaration[ 3 ] : '';
 		const type = declaration[ 2 ];
 
-		const presicion = declaration[ 1 ] !== undefined ? declaration[ 1 ] : '';
+		const precision = declaration[ 1 ] !== undefined ? declaration[ 1 ] : '';
 
 		const headerCode = pragmaMainIndex !== - 1 ? source.slice( 0, pragmaMainIndex ) : '';
 
@@ -87,7 +87,7 @@ const parse = ( source ) => {
 			type,
 			inputs,
 			name,
-			presicion,
+			precision,
 			inputsCode,
 			blockCode,
 			headerCode
@@ -105,9 +105,9 @@ class GLSLNodeFunction extends NodeFunction {
 
 	constructor( source ) {
 
-		const { type, inputs, name, presicion, inputsCode, blockCode, headerCode } = parse( source );
+		const { type, inputs, name, precision, inputsCode, blockCode, headerCode } = parse( source );
 
-		super( type, inputs, name, presicion );
+		super( type, inputs, name, precision );
 
 		this.inputsCode = inputsCode;
 		this.blockCode = blockCode;
@@ -123,13 +123,13 @@ class GLSLNodeFunction extends NodeFunction {
 
 		if ( blockCode !== '' ) {
 
-			const { type, inputsCode, headerCode, presicion } = this;
+			const { type, inputsCode, headerCode, precision } = this;
 
 			let declarationCode = `${ type } ${ name } ( ${ inputsCode.trim() } )`;
 
-			if ( presicion !== '' ) {
+			if ( precision !== '' ) {
 
-				declarationCode = `${ presicion } ${ declarationCode }`;
+				declarationCode = `${ precision } ${ declarationCode }`;
 
 			}
 

package/{examples/jsm → src}/nodes/pmrem/PMREMNode.js

@@ -1,11 +1,13 @@
+import { registerNode } from '../core/Node.js';
 import TempNode from '../core/TempNode.js';
-import { addNodeClass } from '../core/Node.js';
 import { texture } from '../accessors/TextureNode.js';
 import { textureCubeUV } from './PMREMUtils.js';
 import { uniform } from '../core/UniformNode.js';
 import { NodeUpdateType } from '../core/constants.js';
-import { nodeProxy, vec3 } from '../shadernode/ShaderNode.js';
-import { WebGLCoordinateSystem } from 'three';
+import { nodeProxy, vec3 } from '../tsl/TSLBase.js';
+
+import { WebGLCoordinateSystem } from '../../constants.js';
+import { Texture } from '../../textures/Texture.js';
 
 let _generator = null;
 
@@ -31,25 +33,32 @@ function _getPMREMFromTexture( texture ) {
 
 	if ( pmremVersion !== texture.pmremVersion ) {
 
+		const image = texture.image;
+
 		if ( texture.isCubeTexture ) {
 
-			if ( texture.source.data.some( ( texture ) => texture === undefined ) ) {
+			if ( isCubeMapReady( image ) ) {
+
+				cacheTexture = _generator.fromCubemap( texture, cacheTexture );
+
+			} else {
 
-				throw new Error( 'PMREMNode: Undefined texture in CubeTexture. Use onLoad callback or async loader' );
+				return null;
 
 			}
 
-			cacheTexture = _generator.fromCubemap( texture, cacheTexture );
 
 		} else {
 
-			if ( texture.image === undefined ) {
+			if ( isEquirectangularMapReady( image ) ) {
 
-				throw new Error( 'PMREMNode: Undefined image in Texture. Use onLoad callback or async loader' );
+				cacheTexture = _generator.fromEquirectangular( texture, cacheTexture );
 
-			}
+			} else {
 
-			cacheTexture = _generator.fromEquirectangular( texture, cacheTexture );
+				return null;
+
+			}
 
 		}
 
@@ -76,7 +85,12 @@ class PMREMNode extends TempNode {
 		this.levelNode = levelNode;
 
 		this._generator = null;
-		this._texture = texture( null );
+
+		const defaultTexture = new Texture();
+		defaultTexture.isRenderTargetTexture = true;
+
+		this._texture = texture( defaultTexture );
+
 		this._width = uniform( 0 );
 		this._height = uniform( 0 );
 		this._maxMip = uniform( 0 );
@@ -128,9 +142,13 @@ class PMREMNode extends TempNode {
 
 			}
 
-			this._pmrem = pmrem;
+			if ( pmrem !== null ) {
+
+				this._pmrem = pmrem;
 
-			this.updateFromTexture( pmrem );
+				this.updateFromTexture( pmrem );
+
+			}
 
 		}
 
@@ -186,8 +204,34 @@ class PMREMNode extends TempNode {
 
 }
 
-export const pmremTexture = nodeProxy( PMREMNode );
+export default PMREMNode;
 
-addNodeClass( 'PMREMNode', PMREMNode );
+PMREMNode.type = /*@__PURE__*/ registerNode( 'PMREM', PMREMNode );
 
-export default PMREMNode;
+function isCubeMapReady( image ) {
+
+	if ( image === null || image === undefined ) return false;
+
+	let count = 0;
+	const length = 6;
+
+	for ( let i = 0; i < length; i ++ ) {
+
+		if ( image[ i ] !== undefined ) count ++;
+
+	}
+
+	return count === length;
+
+
+}
+
+function isEquirectangularMapReady( image ) {
+
+	if ( image === null || image === undefined ) return false;
+
+	return image.height > 0;
+
+}
+
+export const pmremTexture = /*@__PURE__*/ nodeProxy( PMREMNode );