super-three 0.167.0 → 0.169.0

package/src/nodes/{shadernode/ShaderNode.js → tsl/TSLCore.js}

@@ -1,9 +1,10 @@
-import Node, { addNodeClass } from '../core/Node.js';
+import Node from '../core/Node.js';
 import ArrayElementNode from '../utils/ArrayElementNode.js';
 import ConvertNode from '../utils/ConvertNode.js';
 import JoinNode from '../utils/JoinNode.js';
 import SplitNode from '../utils/SplitNode.js';
 import SetNode from '../utils/SetNode.js';
+import FlipNode from '../utils/FlipNode.js';
 import ConstNode from '../core/ConstNode.js';
 import { getValueFromType, getValueType } from '../core/NodeUtils.js';
 
@@ -11,13 +12,13 @@ import { getValueFromType, getValueType } from '../core/NodeUtils.js';
 
 let currentStack = null;
 
-const NodeElements = new Map(); // @TODO: Currently only a few nodes are added, probably also add others
+const NodeElements = new Map();
 
-export function addNodeElement( name, nodeElement ) {
+export function addMethodChaining( name, nodeElement ) {
 
 	if ( NodeElements.has( name ) ) {
 
-		console.warn( `Redefinition of node element ${ name }` );
+		console.warn( `Redefinition of method chaining ${ name }` );
 		return;
 
 	}
@@ -29,6 +30,7 @@ export function addNodeElement( name, nodeElement ) {
 }
 
 const parseSwizzle = ( props ) => props.replace( /r|s/g, 'x' ).replace( /g|t/g, 'y' ).replace( /b|p/g, 'z' ).replace( /a|q/g, 'w' );
+const parseSwizzleAndSort = ( props ) => parseSwizzle( props ).split( '' ).sort().join( '' );
 
 const shaderNodeHandler = {
 
@@ -80,15 +82,19 @@ const shaderNodeHandler = {
 
 			} else if ( /^set[XYZWRGBASTPQ]{1,4}$/.test( prop ) === true ) {
 
-				// set properties ( swizzle )
+				// set properties ( swizzle ) and sort to xyzw sequence
 
-				prop = parseSwizzle( prop.slice( 3 ).toLowerCase() );
+				prop = parseSwizzleAndSort( prop.slice( 3 ).toLowerCase() );
 
-				// sort to xyzw sequence
+				return ( value ) => nodeObject( new SetNode( node, prop, value ) );
 
-				prop = prop.split( '' ).sort().join( '' );
+			} else if ( /^flip[XYZWRGBASTPQ]{1,4}$/.test( prop ) === true ) {
 
-				return ( value ) => nodeObject( new SetNode( node, prop, value ) );
+				// set properties ( swizzle ) and sort to xyzw sequence
+
+				prop = parseSwizzleAndSort( prop.slice( 4 ).toLowerCase() );
+
+				return () => nodeObject( new FlipNode( nodeObject( node ), prop ) );
 
 			} else if ( prop === 'width' || prop === 'height' || prop === 'depth' ) {
 
@@ -164,7 +170,7 @@ const ShaderNodeObject = function ( obj, altType = null ) {
 
 	} else if ( type === 'shader' ) {
 
-		return tslFn( obj );
+		return Fn( obj );
 
 	}
 
@@ -251,15 +257,7 @@ class ShaderCallNodeInternal extends Node {
 
 	getNodeType( builder ) {
 
-		const properties = builder.getNodeProperties( this );
-
-		if ( properties.outputNode === null ) {
-
-			properties.outputNode = this.setupOutput( builder );
-
-		}
-
-		return properties.outputNode.getNodeType( builder );
+		return this.shaderNode.nodeType || this.getOutputNode( builder ).getNodeType( builder );
 
 	}
 
@@ -267,6 +265,13 @@ class ShaderCallNodeInternal extends Node {
 
 		const { shaderNode, inputNodes } = this;
 
+		const properties = builder.getNodeProperties( shaderNode );
+		if ( properties.onceOutput ) return properties.onceOutput;
+
+		//
+
+		let result = null;
+
 		if ( shaderNode.layout ) {
 
 			let functionNodesCacheMap = nodeBuilderFunctionsCacheMap.get( builder.constructor );
@@ -295,22 +300,44 @@ class ShaderCallNodeInternal extends Node {
 
 			}
 
-			return nodeObject( functionNode.call( inputNodes ) );
+			result = nodeObject( functionNode.call( inputNodes ) );
+
+		} else {
+
+			const jsFunc = shaderNode.jsFunc;
+			const outputNode = inputNodes !== null ? jsFunc( inputNodes, builder ) : jsFunc( builder );
+
+			result = nodeObject( outputNode );
 
 		}
 
-		const jsFunc = shaderNode.jsFunc;
-		const outputNode = inputNodes !== null ? jsFunc( inputNodes, builder.stack, builder ) : jsFunc( builder.stack, builder );
+		if ( shaderNode.once ) {
+
+			properties.onceOutput = result;
+
+		}
 
-		return nodeObject( outputNode );
+		return result;
 
 	}
 
-	setup( builder ) {
+	getOutputNode( builder ) {
+
+		const properties = builder.getNodeProperties( this );
 
-		const { outputNode } = builder.getNodeProperties( this );
+		if ( properties.outputNode === null ) {
 
-		return outputNode || this.setupOutput( builder );
+			properties.outputNode = this.setupOutput( builder );
+
+		}
+
+		return properties.outputNode;
+
+	}
+
+	setup( builder ) {
+
+		return this.getOutputNode( builder );
 
 	}
 
@@ -326,17 +353,9 @@ class ShaderCallNodeInternal extends Node {
 
 	generate( builder, output ) {
 
-		const { outputNode } = builder.getNodeProperties( this );
-
-		if ( outputNode === null ) {
+		const outputNode = this.getOutputNode( builder );
 
-			// TSL: It's recommended to use `tslFn` in setup() pass.
-
-			return this.call( builder ).build( builder, output );
-
-		}
-
-		return super.generate( builder, output );
+		return outputNode.build( builder, output );
 
 	}
 
@@ -344,20 +363,16 @@ class ShaderCallNodeInternal extends Node {
 
 class ShaderNodeInternal extends Node {
 
-	constructor( jsFunc ) {
+	constructor( jsFunc, nodeType ) {
 
-		super();
+		super( nodeType );
 
 		this.jsFunc = jsFunc;
 		this.layout = null;
 
 		this.global = true;
 
-	}
-
-	get isArrayInput() {
-
-		return /^\((\s+)?\[/.test( this.jsFunc.toString() );
+		this.once = false;
 
 	}
 
@@ -472,7 +487,7 @@ const ConvertType = function ( type, cacheMap = null ) {
 
 // exports
 
-export const defined = ( value ) => value && value.value;
+export const defined = ( v ) => typeof v === 'object' && v !== null ? v.value : v; // TODO: remove boolean conversion and defined function
 
 // utils
 
@@ -480,9 +495,9 @@ export const getConstNodeType = ( value ) => ( value !== undefined && value !==
 
 // shader node base
 
-export function ShaderNode( jsFunc ) {
+export function ShaderNode( jsFunc, nodeType ) {
 
-	return new Proxy( new ShaderNodeInternal( jsFunc ), shaderNodeHandler );
+	return new Proxy( new ShaderNodeInternal( jsFunc, nodeType ), shaderNodeHandler );
 
 }
 
@@ -492,9 +507,9 @@ export const nodeArray = ( val, altType = null ) => new ShaderNodeArray( val, al
 export const nodeProxy = ( ...params ) => new ShaderNodeProxy( ...params );
 export const nodeImmutable = ( ...params ) => new ShaderNodeImmutable( ...params );
 
-export const tslFn = ( jsFunc ) => {
+export const Fn = ( jsFunc, nodeType ) => {
 
-	const shaderNode = new ShaderNode( jsFunc );
+	const shaderNode = new ShaderNode( jsFunc, nodeType );
 
 	const fn = ( ...params ) => {
 
@@ -517,6 +532,7 @@ export const tslFn = ( jsFunc ) => {
 	};
 
 	fn.shaderNode = shaderNode;
+
 	fn.setLayout = ( layout ) => {
 
 		shaderNode.setLayout( layout );
@@ -525,15 +541,28 @@ export const tslFn = ( jsFunc ) => {
 
 	};
 
+	fn.once = () => {
+
+		shaderNode.once = true;
+
+		return fn;
+
+	};
+
 	return fn;
 
 };
 
-addNodeClass( 'ShaderNode', ShaderNode );
+export const tslFn = ( ...params ) => { // @deprecated, r168
+
+	console.warn( 'TSL.ShaderNode: tslFn() has been renamed to Fn().' );
+	return Fn( ...params );
+
+};
 
 //
 
-addNodeElement( 'toGlobal', ( node ) => {
+addMethodChaining( 'toGlobal', ( node ) => {
 
 	node.global = true;
 
@@ -557,7 +586,7 @@ export const setCurrentStack = ( stack ) => {
 
 export const getCurrentStack = () => currentStack;
 
-export const If = ( ...params ) => currentStack.if( ...params );
+export const If = ( ...params ) => currentStack.If( ...params );
 
 export function append( node ) {
 
@@ -567,10 +596,9 @@ export function append( node ) {
 
 }
 
-addNodeElement( 'append', append );
+addMethodChaining( 'append', append );
 
 // types
-// @TODO: Maybe export from ConstNode.js?
 
 export const color = new ConvertType( 'color' );
 
@@ -595,58 +623,38 @@ export const uvec4 = new ConvertType( 'uvec4' );
 export const bvec4 = new ConvertType( 'bvec4' );
 
 export const mat2 = new ConvertType( 'mat2' );
-export const imat2 = new ConvertType( 'imat2' );
-export const umat2 = new ConvertType( 'umat2' );
-export const bmat2 = new ConvertType( 'bmat2' );
-
 export const mat3 = new ConvertType( 'mat3' );
-export const imat3 = new ConvertType( 'imat3' );
-export const umat3 = new ConvertType( 'umat3' );
-export const bmat3 = new ConvertType( 'bmat3' );
-
 export const mat4 = new ConvertType( 'mat4' );
-export const imat4 = new ConvertType( 'imat4' );
-export const umat4 = new ConvertType( 'umat4' );
-export const bmat4 = new ConvertType( 'bmat4' );
 
 export const string = ( value = '' ) => nodeObject( new ConstNode( value, 'string' ) );
 export const arrayBuffer = ( value ) => nodeObject( new ConstNode( value, 'ArrayBuffer' ) );
 
-addNodeElement( 'toColor', color );
-addNodeElement( 'toFloat', float );
-addNodeElement( 'toInt', int );
-addNodeElement( 'toUint', uint );
-addNodeElement( 'toBool', bool );
-addNodeElement( 'toVec2', vec2 );
-addNodeElement( 'toIvec2', ivec2 );
-addNodeElement( 'toUvec2', uvec2 );
-addNodeElement( 'toBvec2', bvec2 );
-addNodeElement( 'toVec3', vec3 );
-addNodeElement( 'toIvec3', ivec3 );
-addNodeElement( 'toUvec3', uvec3 );
-addNodeElement( 'toBvec3', bvec3 );
-addNodeElement( 'toVec4', vec4 );
-addNodeElement( 'toIvec4', ivec4 );
-addNodeElement( 'toUvec4', uvec4 );
-addNodeElement( 'toBvec4', bvec4 );
-addNodeElement( 'toMat2', mat2 );
-addNodeElement( 'toImat2', imat2 );
-addNodeElement( 'toUmat2', umat2 );
-addNodeElement( 'toBmat2', bmat2 );
-addNodeElement( 'toMat3', mat3 );
-addNodeElement( 'toImat3', imat3 );
-addNodeElement( 'toUmat3', umat3 );
-addNodeElement( 'toBmat3', bmat3 );
-addNodeElement( 'toMat4', mat4 );
-addNodeElement( 'toImat4', imat4 );
-addNodeElement( 'toUmat4', umat4 );
-addNodeElement( 'toBmat4', bmat4 );
+addMethodChaining( 'toColor', color );
+addMethodChaining( 'toFloat', float );
+addMethodChaining( 'toInt', int );
+addMethodChaining( 'toUint', uint );
+addMethodChaining( 'toBool', bool );
+addMethodChaining( 'toVec2', vec2 );
+addMethodChaining( 'toIVec2', ivec2 );
+addMethodChaining( 'toUVec2', uvec2 );
+addMethodChaining( 'toBVec2', bvec2 );
+addMethodChaining( 'toVec3', vec3 );
+addMethodChaining( 'toIVec3', ivec3 );
+addMethodChaining( 'toUVec3', uvec3 );
+addMethodChaining( 'toBVec3', bvec3 );
+addMethodChaining( 'toVec4', vec4 );
+addMethodChaining( 'toIVec4', ivec4 );
+addMethodChaining( 'toUVec4', uvec4 );
+addMethodChaining( 'toBVec4', bvec4 );
+addMethodChaining( 'toMat2', mat2 );
+addMethodChaining( 'toMat3', mat3 );
+addMethodChaining( 'toMat4', mat4 );
 
 // basic nodes
-// HACK - we cannot export them from the corresponding files because of the cyclic dependency
-export const element = nodeProxy( ArrayElementNode );
+
+export const element = /*@__PURE__*/ nodeProxy( ArrayElementNode );
 export const convert = ( node, types ) => nodeObject( new ConvertNode( nodeObject( node ), types ) );
 export const split = ( node, channels ) => nodeObject( new SplitNode( nodeObject( node ), channels ) );
 
-addNodeElement( 'element', element );
-addNodeElement( 'convert', convert );
+addMethodChaining( 'element', element );
+addMethodChaining( 'convert', convert );

package/src/nodes/utils/ArrayElementNode.js

@@ -1,6 +1,12 @@
-import Node, { addNodeClass } from '../core/Node.js';
+import Node from '../core/Node.js';
 
-class ArrayElementNode extends Node { // @TODO: If extending from TempNode it breaks webgpu_compute
+class ArrayElementNode extends Node {
+
+	static get type() {
+
+		return 'ArrayElementNode';
+
+	} // @TODO: If extending from TempNode it breaks webgpu_compute
 
 	constructor( node, indexNode ) {
 
@@ -31,5 +37,3 @@ class ArrayElementNode extends Node { // @TODO: If extending from TempNode it br
 }
 
 export default ArrayElementNode;
-
-addNodeClass( 'ArrayElementNode', ArrayElementNode );

package/src/nodes/utils/ConvertNode.js

@@ -1,7 +1,13 @@
-import Node, { addNodeClass } from '../core/Node.js';
+import Node from '../core/Node.js';
 
 class ConvertNode extends Node {
 
+	static get type() {
+
+		return 'ConvertNode';
+
+	}
+
 	constructor( node, convertTo ) {
 
 		super();
@@ -61,5 +67,3 @@ class ConvertNode extends Node {
 }
 
 export default ConvertNode;
-
-addNodeClass( 'ConvertNode', ConvertNode );

package/src/nodes/utils/CubeMapNode.js

@@ -0,0 +1,160 @@
+import TempNode from '../core/TempNode.js';
+import { NodeUpdateType } from '../core/constants.js';
+import { nodeProxy } from '../tsl/TSLBase.js';
+import { CubeTexture } from '../../textures/CubeTexture.js';
+import { cubeTexture } from '../accessors/CubeTextureNode.js';
+import CubeRenderTarget from '../../renderers/common/CubeRenderTarget.js';
+import { CubeReflectionMapping, CubeRefractionMapping, EquirectangularReflectionMapping, EquirectangularRefractionMapping } from '../../constants.js';
+
+const _cache = new WeakMap();
+
+class CubeMapNode extends TempNode {
+
+	static get type() {
+
+		return 'CubeMapNode';
+
+	}
+
+	constructor( envNode ) {
+
+		super( 'vec3' );
+
+		this.envNode = envNode;
+
+		this._cubeTexture = null;
+		this._cubeTextureNode = cubeTexture();
+
+		const defaultTexture = new CubeTexture();
+		defaultTexture.isRenderTargetTexture = true;
+
+		this._defaultTexture = defaultTexture;
+
+		this.updateBeforeType = NodeUpdateType.RENDER;
+
+	}
+
+	updateBefore( frame ) {
+
+		const { renderer, material } = frame;
+
+		const envNode = this.envNode;
+
+		if ( envNode.isTextureNode || envNode.isMaterialReferenceNode ) {
+
+			const texture = ( envNode.isTextureNode ) ? envNode.value : material[ envNode.property ];
+
+			if ( texture && texture.isTexture ) {
+
+				const mapping = texture.mapping;
+
+				if ( mapping === EquirectangularReflectionMapping || mapping === EquirectangularRefractionMapping ) {
+
+					// check for converted cubemap map
+
+					if ( _cache.has( texture ) ) {
+
+						const cubeMap = _cache.get( texture );
+
+						mapTextureMapping( cubeMap, texture.mapping );
+						this._cubeTexture = cubeMap;
+
+					} else {
+
+						// create cube map from equirectangular map
+
+						const image = texture.image;
+
+						if ( isEquirectangularMapReady( image ) ) {
+
+							const renderTarget = new CubeRenderTarget( image.height );
+							renderTarget.fromEquirectangularTexture( renderer, texture );
+
+							mapTextureMapping( renderTarget.texture, texture.mapping );
+							this._cubeTexture = renderTarget.texture;
+
+							_cache.set( texture, renderTarget.texture );
+
+							texture.addEventListener( 'dispose', onTextureDispose );
+
+						} else {
+
+							// default cube texture as fallback when equirectangular texture is not yet loaded
+
+							this._cubeTexture = this._defaultTexture;
+
+						}
+
+					}
+
+					//
+
+					this._cubeTextureNode.value = this._cubeTexture;
+
+				} else {
+
+					// envNode already refers to a cube map
+
+					this._cubeTextureNode = this.envNode;
+
+				}
+
+			}
+
+		}
+
+	}
+
+	setup( builder ) {
+
+		this.updateBefore( builder );
+
+		return this._cubeTextureNode;
+
+	}
+
+}
+
+export default CubeMapNode;
+
+function isEquirectangularMapReady( image ) {
+
+	if ( image === null || image === undefined ) return false;
+
+	return image.height > 0;
+
+}
+
+function onTextureDispose( event ) {
+
+	const texture = event.target;
+
+	texture.removeEventListener( 'dispose', onTextureDispose );
+
+	const renderTarget = _cache.get( texture );
+
+	if ( renderTarget !== undefined ) {
+
+		_cache.delete( texture );
+
+		renderTarget.dispose();
+
+	}
+
+}
+
+function mapTextureMapping( texture, mapping ) {
+
+	if ( mapping === EquirectangularReflectionMapping ) {
+
+		texture.mapping = CubeReflectionMapping;
+
+	} else if ( mapping === EquirectangularRefractionMapping ) {
+
+		texture.mapping = CubeRefractionMapping;
+
+	}
+
+}
+
+export const cubeMapNode = /*@__PURE__*/ nodeProxy( CubeMapNode );

package/src/nodes/utils/Discard.js

@@ -0,0 +1,8 @@
+import { select } from '../math/ConditionalNode.js';
+import { expression } from '../code/ExpressionNode.js';
+import { addMethodChaining } from '../tsl/TSLCore.js';
+
+export const Discard = ( conditional ) => ( conditional ? select( conditional, expression( 'discard' ) ) : expression( 'discard' ) ).append();
+export const Return = () => expression( 'return' ).append();
+
+addMethodChaining( 'discard', Discard );

package/src/nodes/utils/EquirectUVNode.js

@@ -1,10 +1,15 @@
 import TempNode from '../core/TempNode.js';
-import { positionWorldDirection } from '../accessors/PositionNode.js';
-import { nodeProxy, vec2 } from '../shadernode/ShaderNode.js';
-import { addNodeClass } from '../core/Node.js';
+import { positionWorldDirection } from '../accessors/Position.js';
+import { nodeProxy, vec2 } from '../tsl/TSLBase.js';
 
 class EquirectUVNode extends TempNode {
 
+	static get type() {
+
+		return 'EquirectUVNode';
+
+	}
+
 	constructor( dirNode = positionWorldDirection ) {
 
 		super( 'vec2' );
@@ -28,6 +33,4 @@ class EquirectUVNode extends TempNode {
 
 export default EquirectUVNode;
 
-export const equirectUV = nodeProxy( EquirectUVNode );
-
-addNodeClass( 'EquirectUVNode', EquirectUVNode );
+export const equirectUV = /*@__PURE__*/ nodeProxy( EquirectUVNode );

package/src/nodes/utils/FlipNode.js

@@ -0,0 +1,68 @@
+import TempNode from '../core/TempNode.js';
+import { vectorComponents } from '../core/constants.js';
+
+class FlipNode extends TempNode {
+
+	static get type() {
+
+		return 'FlipNode';
+
+	}
+
+	constructor( sourceNode, components ) {
+
+		super();
+
+		this.sourceNode = sourceNode;
+		this.components = components;
+
+	}
+
+	getNodeType( builder ) {
+
+		return this.sourceNode.getNodeType( builder );
+
+	}
+
+	generate( builder ) {
+
+		const { components, sourceNode } = this;
+
+		const sourceType = this.getNodeType( builder );
+		const sourceSnippet = sourceNode.build( builder );
+
+		const sourceCache = builder.getVarFromNode( this );
+		const sourceProperty = builder.getPropertyName( sourceCache );
+
+		builder.addLineFlowCode( sourceProperty + ' = ' + sourceSnippet, this );
+
+		const length = builder.getTypeLength( sourceType );
+		const snippetValues = [];
+
+		let componentIndex = 0;
+
+		for ( let i = 0; i < length; i ++ ) {
+
+			const component = vectorComponents[ i ];
+
+			if ( component === components[ componentIndex ] ) {
+
+				snippetValues.push( '1.0 - ' + ( sourceProperty + '.' + component ) );
+
+				componentIndex ++;
+
+			} else {
+
+				snippetValues.push( sourceProperty + '.' + component );
+
+			}
+
+		}
+
+		return `${ builder.getType( sourceType ) }( ${ snippetValues.join( ', ' ) } )`;
+
+	}
+
+}
+
+export default FlipNode;