@needle-tools/three 0.162.12 → 0.169.2

package/{examples/jsm/nodes/shadernode/ShaderNode.js → src/nodes/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,9 +257,7 @@ class ShaderCallNodeInternal extends Node {
 
 	getNodeType( builder ) {
 
-		const { outputNode } = builder.getNodeProperties( this );
-
-		return outputNode ? outputNode.getNodeType( builder ) : super.getNodeType( builder );
+		return this.shaderNode.nodeType || this.getOutputNode( builder ).getNodeType( builder );
 
 	}
 
@@ -261,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 );
@@ -289,19 +300,49 @@ 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 ) {
 
-		return nodeObject( outputNode );
+			properties.onceOutput = result;
+
+		}
+
+		return result;
+
+	}
+
+	getOutputNode( builder ) {
+
+		const properties = builder.getNodeProperties( this );
+
+		if ( properties.outputNode === null ) {
+
+			properties.outputNode = this.setupOutput( builder );
+
+		}
+
+		return properties.outputNode;
 
 	}
 
 	setup( builder ) {
 
+		return this.getOutputNode( builder );
+
+	}
+
+	setupOutput( builder ) {
+
 		builder.addStack();
 
 		builder.stack.outputNode = this.call( builder );
@@ -312,17 +353,9 @@ class ShaderCallNodeInternal extends Node {
 
 	generate( builder, output ) {
 
-		const { outputNode } = builder.getNodeProperties( this );
-
-		if ( outputNode === null ) {
-
-			// TSL: It's recommended to use `tslFn` in setup() pass.
-
-			return this.call( builder ).build( builder, output );
+		const outputNode = this.getOutputNode( builder );
 
-		}
-
-		return super.generate( builder, output );
+		return outputNode.build( builder, output );
 
 	}
 
@@ -330,18 +363,16 @@ class ShaderCallNodeInternal extends Node {
 
 class ShaderNodeInternal extends Node {
 
-	constructor( jsFunc ) {
+	constructor( jsFunc, nodeType ) {
 
-		super();
+		super( nodeType );
 
 		this.jsFunc = jsFunc;
 		this.layout = null;
 
-	}
-
-	get isArrayInput() {
+		this.global = true;
 
-		return /^\((\s+)?\[/.test( this.jsFunc.toString() );
+		this.once = false;
 
 	}
 
@@ -456,15 +487,17 @@ const ConvertType = function ( type, cacheMap = null ) {
 
 // exports
 
+export const defined = ( v ) => typeof v === 'object' && v !== null ? v.value : v; // TODO: remove boolean conversion and defined function
+
 // utils
 
 export const getConstNodeType = ( value ) => ( value !== undefined && value !== null ) ? ( value.nodeType || value.convertTo || ( typeof value === 'string' ? value : null ) ) : null;
 
 // 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 );
 
 }
 
@@ -474,17 +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 shader = ( jsFunc ) => { // @deprecated, r154
-
-	console.warn( 'TSL: shader() is deprecated. Use tslFn() instead.' );
-
-	return new ShaderNode( jsFunc );
+export const Fn = ( jsFunc, nodeType ) => {
 
-};
-
-export const tslFn = ( jsFunc ) => {
-
-	const shaderNode = new ShaderNode( jsFunc );
+	const shaderNode = new ShaderNode( jsFunc, nodeType );
 
 	const fn = ( ...params ) => {
 
@@ -507,6 +532,7 @@ export const tslFn = ( jsFunc ) => {
 	};
 
 	fn.shaderNode = shaderNode;
+
 	fn.setLayout = ( layout ) => {
 
 		shaderNode.setLayout( layout );
@@ -515,11 +541,34 @@ 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 );
+
+};
+
+//
+
+addMethodChaining( 'toGlobal', ( node ) => {
+
+	node.global = true;
+
+	return node;
+
+} );
 
 //
 
@@ -537,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 ) {
 
@@ -547,15 +596,14 @@ export function append( node ) {
 
 }
 
-addNodeElement( 'append', append );
+addMethodChaining( 'append', append );
 
 // types
-// @TODO: Maybe export from ConstNode.js?
 
 export const color = new ConvertType( 'color' );
 
 export const float = new ConvertType( 'float', cacheMaps.float );
-export const int = new ConvertType( 'int', cacheMaps.int );
+export const int = new ConvertType( 'int', cacheMaps.ints );
 export const uint = new ConvertType( 'uint', cacheMaps.uint );
 export const bool = new ConvertType( 'bool', cacheMaps.bool );
 
@@ -575,60 +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( 'color', color );
-addNodeElement( 'float', float );
-addNodeElement( 'int', int );
-addNodeElement( 'uint', uint );
-addNodeElement( 'bool', bool );
-addNodeElement( 'vec2', vec2 );
-addNodeElement( 'ivec2', ivec2 );
-addNodeElement( 'uvec2', uvec2 );
-addNodeElement( 'bvec2', bvec2 );
-addNodeElement( 'vec3', vec3 );
-addNodeElement( 'ivec3', ivec3 );
-addNodeElement( 'uvec3', uvec3 );
-addNodeElement( 'bvec3', bvec3 );
-addNodeElement( 'vec4', vec4 );
-addNodeElement( 'ivec4', ivec4 );
-addNodeElement( 'uvec4', uvec4 );
-addNodeElement( 'bvec4', bvec4 );
-addNodeElement( 'mat2', mat2 );
-addNodeElement( 'imat2', imat2 );
-addNodeElement( 'umat2', umat2 );
-addNodeElement( 'bmat2', bmat2 );
-addNodeElement( 'mat3', mat3 );
-addNodeElement( 'imat3', imat3 );
-addNodeElement( 'umat3', umat3 );
-addNodeElement( 'bmat3', bmat3 );
-addNodeElement( 'mat4', mat4 );
-addNodeElement( 'imat4', imat4 );
-addNodeElement( 'umat4', umat4 );
-addNodeElement( 'bmat4', bmat4 );
-addNodeElement( 'string', string );
-addNodeElement( 'arrayBuffer', arrayBuffer );
+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/{examples/jsm → 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 ) {
 
@@ -15,7 +21,7 @@ class ArrayElementNode extends Node { // @TODO: If extending from TempNode it br
 
 	getNodeType( builder ) {
 
-		return this.node.getNodeType( builder );
+		return this.node.getElementType( builder );
 
 	}
 
@@ -31,5 +37,3 @@ class ArrayElementNode extends Node { // @TODO: If extending from TempNode it br
 }
 
 export default ArrayElementNode;
-
-addNodeClass( 'ArrayElementNode', ArrayElementNode );

package/{examples/jsm → 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

@@ -0,0 +1,36 @@
+import TempNode from '../core/TempNode.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' );
+
+		this.dirNode = dirNode;
+
+	}
+
+	setup() {
+
+		const dir = this.dirNode;
+
+		const u = dir.z.atan2( dir.x ).mul( 1 / ( Math.PI * 2 ) ).add( 0.5 );
+		const v = dir.y.clamp( - 1.0, 1.0 ).asin().mul( 1 / Math.PI ).add( 0.5 );
+
+		return vec2( u, v );
+
+	}
+
+}
+
+export default EquirectUVNode;
+
+export const equirectUV = /*@__PURE__*/ nodeProxy( EquirectUVNode );