super-three 0.167.0 → 0.169.0

package/src/nodes/utils/FunctionOverloadingNode.js

@@ -1,8 +1,14 @@
-import Node, { addNodeClass } from '../core/Node.js';
-import { nodeProxy } from '../shadernode/ShaderNode.js';
+import Node from '../core/Node.js';
+import { nodeProxy } from '../tsl/TSLBase.js';
 
 class FunctionOverloadingNode extends Node {
 
+	static get type() {
+
+		return 'FunctionOverloadingNode';
+
+	}
+
 	constructor( functionNodes = [], ...parametersNodes ) {
 
 		super();
@@ -90,8 +96,6 @@ class FunctionOverloadingNode extends Node {
 
 export default FunctionOverloadingNode;
 
-const overloadingBaseFn = nodeProxy( FunctionOverloadingNode );
+const overloadingBaseFn = /*@__PURE__*/ nodeProxy( FunctionOverloadingNode );
 
 export const overloadingFn = ( functionNodes ) => ( ...params ) => overloadingBaseFn( functionNodes, ...params );
-
-addNodeClass( 'FunctionOverloadingNode', FunctionOverloadingNode );

package/src/nodes/utils/JoinNode.js

@@ -1,8 +1,13 @@
-import { addNodeClass } from '../core/Node.js';
 import TempNode from '../core/TempNode.js';
 
 class JoinNode extends TempNode {
 
+	static get type() {
+
+		return 'JoinNode';
+
+	}
+
 	constructor( nodes = [], nodeType = null ) {
 
 		super( nodeType );
@@ -57,5 +62,3 @@ class JoinNode extends TempNode {
 }
 
 export default JoinNode;
-
-addNodeClass( 'JoinNode', JoinNode );

package/src/nodes/utils/LoopNode.js

@@ -1,10 +1,15 @@
-import Node, { addNodeClass } from '../core/Node.js';
+import Node from '../core/Node.js';
 import { expression } from '../code/ExpressionNode.js';
-import { bypass } from '../core/BypassNode.js';
-import { addNodeElement, nodeObject, nodeArray } from '../shadernode/ShaderNode.js';
+import { nodeObject, nodeArray } from '../tsl/TSLBase.js';
 
 class LoopNode extends Node {
 
+	static get type() {
+
+		return 'LoopNode';
+
+	}
+
 	constructor( params = [] ) {
 
 		super();
@@ -192,10 +197,15 @@ class LoopNode extends Node {
 
 export default LoopNode;
 
-export const loop = ( ...params ) => nodeObject( new LoopNode( nodeArray( params, 'int' ) ) ).append();
+export const Loop = ( ...params ) => nodeObject( new LoopNode( nodeArray( params, 'int' ) ) ).append();
 export const Continue = () => expression( 'continue' ).append();
 export const Break = () => expression( 'break' ).append();
 
-addNodeElement( 'loop', ( returns, ...params ) => bypass( returns, loop( ...params ) ) );
+//
+
+export const loop = ( ...params ) => { // @deprecated, r168
+
+	console.warn( 'TSL.LoopNode: loop() has been renamed to Loop().' );
+	return Loop( ...params );
 
-addNodeClass( 'LoopNode', LoopNode );
+};

package/src/nodes/utils/MatcapUVNode.js

@@ -1,11 +1,16 @@
 import TempNode from '../core/TempNode.js';
-import { transformedNormalView } from '../accessors/NormalNode.js';
-import { positionViewDirection } from '../accessors/PositionNode.js';
-import { nodeImmutable, vec2, vec3 } from '../shadernode/ShaderNode.js';
-import { addNodeClass } from '../core/Node.js';
+import { transformedNormalView } from '../accessors/Normal.js';
+import { positionViewDirection } from '../accessors/Position.js';
+import { nodeImmutable, vec2, vec3 } from '../tsl/TSLBase.js';
 
 class MatcapUVNode extends TempNode {
 
+	static get type() {
+
+		return 'MatcapUVNode';
+
+	}
+
 	constructor() {
 
 		super( 'vec2' );
@@ -25,6 +30,4 @@ class MatcapUVNode extends TempNode {
 
 export default MatcapUVNode;
 
-export const matcapUV = nodeImmutable( MatcapUVNode );
-
-addNodeClass( 'MatcapUVNode', MatcapUVNode );
+export const matcapUV = /*@__PURE__*/ nodeImmutable( MatcapUVNode );

package/src/nodes/utils/MaxMipLevelNode.js

@@ -1,10 +1,15 @@
 import UniformNode from '../core/UniformNode.js';
 import { NodeUpdateType } from '../core/constants.js';
-import { nodeProxy } from '../shadernode/ShaderNode.js';
-import { addNodeClass } from '../core/Node.js';
+import { nodeProxy } from '../tsl/TSLBase.js';
 
 class MaxMipLevelNode extends UniformNode {
 
+	static get type() {
+
+		return 'MaxMipLevelNode';
+
+	}
+
 	constructor( textureNode ) {
 
 		super( 0 );
@@ -47,6 +52,4 @@ class MaxMipLevelNode extends UniformNode {
 
 export default MaxMipLevelNode;
 
-export const maxMipLevel = nodeProxy( MaxMipLevelNode );
-
-addNodeClass( 'MaxMipLevelNode', MaxMipLevelNode );
+export const maxMipLevel = /*@__PURE__*/ nodeProxy( MaxMipLevelNode );

package/src/nodes/utils/OscNode.js

@@ -1,9 +1,15 @@
-import Node, { addNodeClass } from '../core/Node.js';
+import Node from '../core/Node.js';
 import { timerLocal } from './TimerNode.js';
-import { nodeObject, nodeProxy } from '../shadernode/ShaderNode.js';
+import { nodeObject, nodeProxy } from '../tsl/TSLBase.js';
 
 class OscNode extends Node {
 
+	static get type() {
+
+		return 'OscNode';
+
+	}
+
 	constructor( method = OscNode.SINE, timeNode = timerLocal() ) {
 
 		super();
@@ -73,9 +79,7 @@ OscNode.SAWTOOTH = 'sawtooth';
 
 export default OscNode;
 
-export const oscSine = nodeProxy( OscNode, OscNode.SINE );
-export const oscSquare = nodeProxy( OscNode, OscNode.SQUARE );
-export const oscTriangle = nodeProxy( OscNode, OscNode.TRIANGLE );
-export const oscSawtooth = nodeProxy( OscNode, OscNode.SAWTOOTH );
-
-addNodeClass( 'OscNode', OscNode );
+export const oscSine = /*@__PURE__*/ nodeProxy( OscNode, OscNode.SINE );
+export const oscSquare = /*@__PURE__*/ nodeProxy( OscNode, OscNode.SQUARE );
+export const oscTriangle = /*@__PURE__*/ nodeProxy( OscNode, OscNode.TRIANGLE );
+export const oscSawtooth = /*@__PURE__*/ nodeProxy( OscNode, OscNode.SAWTOOTH );

package/src/nodes/utils/Packing.js

@@ -0,0 +1,4 @@
+import { nodeObject } from '../tsl/TSLBase.js';
+
+export const directionToColor = ( node ) => nodeObject( node ).mul( 0.5 ).add( 0.5 );
+export const colorToDirection = ( node ) => nodeObject( node ).mul( 2.0 ).sub( 1 );

package/src/nodes/utils/RTTNode.js

@@ -1,9 +1,8 @@
-import { nodeObject, addNodeElement } from '../shadernode/ShaderNode.js';
+import { nodeObject } from '../tsl/TSLCore.js';
 import TextureNode from '../accessors/TextureNode.js';
 import { NodeUpdateType } from '../core/constants.js';
-import { addNodeClass } from '../core/Node.js';
-import NodeMaterial from '../materials/NodeMaterial.js';
-import { uv } from '../accessors/UVNode.js';
+import { uv } from '../accessors/UV.js';
+import NodeMaterial from '../../materials/nodes/NodeMaterial.js';
 import QuadMesh from '../../renderers/common/QuadMesh.js';
 
 import { RenderTarget } from '../../core/RenderTarget.js';
@@ -14,6 +13,12 @@ const _size = /*@__PURE__*/ new Vector2();
 
 class RTTNode extends TextureNode {
 
+	static get type() {
+
+		return 'RTTNode';
+
+	}
+
 	constructor( node, width = null, height = null, options = { type: HalfFloatType } ) {
 
 		const renderTarget = new RenderTarget( width, height, options );
@@ -47,6 +52,7 @@ class RTTNode extends TextureNode {
 	setup( builder ) {
 
 		this._rttNode = this.node.context( builder.getSharedContext() );
+		this._quadMesh.material.name = 'RTT';
 		this._quadMesh.material.needsUpdate = true;
 
 		return super.setup( builder );
@@ -124,7 +130,4 @@ class RTTNode extends TextureNode {
 export default RTTNode;
 
 export const rtt = ( node, ...params ) => nodeObject( new RTTNode( nodeObject( node ), ...params ) );
-
-addNodeElement( 'toTexture', ( node, ...params ) => node.isTextureNode ? node : rtt( node, ...params ) );
-
-addNodeClass( 'RTTNode', RTTNode );
+export const convertToTexture = ( node, ...params ) => node.isTextureNode ? node : rtt( node, ...params );

package/src/nodes/utils/ReflectorNode.js

@@ -1,7 +1,7 @@
 import TextureNode from '../accessors/TextureNode.js';
-import { nodeObject, vec2 } from '../shadernode/ShaderNode.js';
+import { nodeObject } from '../tsl/TSLBase.js';
 import { NodeUpdateType } from '../core/constants.js';
-import { viewportTopLeft } from '../display/ViewportNode.js';
+import { screenUV } from '../display/ScreenNode.js';
 
 import { HalfFloatType, LinearMipMapLinearFilter } from '../../constants.js';
 import { Plane } from '../../math/Plane.js';
@@ -27,12 +27,18 @@ const _q = new Vector4();
 const _size = new Vector2();
 
 const _defaultRT = new RenderTarget();
-const _defaultUV = vec2( viewportTopLeft.x.oneMinus(), viewportTopLeft.y );
+const _defaultUV = screenUV.flipX();
 
 let _inReflector = false;
 
 class ReflectorNode extends TextureNode {
 
+	static get type() {
+
+		return 'ReflectorNode';
+
+	}
+
 	constructor( parameters = {} ) {
 
 		super( _defaultRT.texture, _defaultUV );
@@ -214,11 +220,14 @@ class ReflectorNode extends TextureNode {
 		material.visible = false;
 
 		const currentRenderTarget = renderer.getRenderTarget();
+		const currentMRT = renderer.getMRT();
 
+		renderer.setMRT( null );
 		renderer.setRenderTarget( renderTarget );
 
 		renderer.render( scene, virtualCamera );
 
+		renderer.setMRT( currentMRT );
 		renderer.setRenderTarget( currentRenderTarget );
 
 		material.visible = true;
@@ -232,4 +241,3 @@ class ReflectorNode extends TextureNode {
 export const reflector = ( parameters ) => nodeObject( new ReflectorNode( parameters ) );
 
 export default ReflectorNode;
-

package/src/nodes/utils/RemapNode.js

@@ -1,8 +1,14 @@
-import Node, { addNodeClass } from '../core/Node.js';
-import { float, addNodeElement, nodeProxy } from '../shadernode/ShaderNode.js';
+import Node from '../core/Node.js';
+import { float, addMethodChaining, nodeProxy } from '../tsl/TSLCore.js';
 
 class RemapNode extends Node {
 
+	static get type() {
+
+		return 'RemapNode';
+
+	}
+
 	constructor( node, inLowNode, inHighNode, outLowNode = float( 0 ), outHighNode = float( 1 ) ) {
 
 		super();
@@ -33,10 +39,8 @@ class RemapNode extends Node {
 
 export default RemapNode;
 
-export const remap = nodeProxy( RemapNode, null, null, { doClamp: false } );
-export const remapClamp = nodeProxy( RemapNode );
-
-addNodeElement( 'remap', remap );
-addNodeElement( 'remapClamp', remapClamp );
+export const remap = /*@__PURE__*/ nodeProxy( RemapNode, null, null, { doClamp: false } );
+export const remapClamp = /*@__PURE__*/ nodeProxy( RemapNode );
 
-addNodeClass( 'RemapNode', RemapNode );
+addMethodChaining( 'remap', remap );
+addMethodChaining( 'remapClamp', remapClamp );

package/src/nodes/utils/RotateNode.js

@@ -1,16 +1,15 @@
 import TempNode from '../core/TempNode.js';
-import { addNodeClass } from '../core/Node.js';
-import {
-	addNodeElement,
-	nodeProxy,
-	vec4,
-	mat2,
-	mat4,
-} from '../shadernode/ShaderNode.js';
+import { nodeProxy, vec4, mat2, mat4 } from '../tsl/TSLBase.js';
 import { cos, sin } from '../math/MathNode.js';
 
 class RotateNode extends TempNode {
 
+	static get type() {
+
+		return 'RotateNode';
+
+	}
+
 	constructor( positionNode, rotationNode ) {
 
 		super();
@@ -61,8 +60,4 @@ class RotateNode extends TempNode {
 
 export default RotateNode;
 
-export const rotate = nodeProxy( RotateNode );
-
-addNodeElement( 'rotate', rotate );
-
-addNodeClass( 'RotateNode', RotateNode );
+export const rotate = /*@__PURE__*/ nodeProxy( RotateNode );

package/src/nodes/utils/SetNode.js

@@ -1,9 +1,14 @@
-import { addNodeClass } from '../core/Node.js';
 import TempNode from '../core/TempNode.js';
 import { vectorComponents } from '../core/constants.js';
 
 class SetNode extends TempNode {
 
+	static get type() {
+
+		return 'SetNode';
+
+	}
+
 	constructor( sourceNode, components, targetNode ) {
 
 		super();
@@ -25,7 +30,7 @@ class SetNode extends TempNode {
 		const { sourceNode, components, targetNode } = this;
 
 		const sourceType = this.getNodeType( builder );
-		const targetType = builder.getTypeFromLength( components.length );
+		const targetType = builder.getTypeFromLength( components.length, targetNode.getNodeType( builder ) );
 
 		const targetSnippet = targetNode.build( builder, targetType );
 		const sourceSnippet = sourceNode.build( builder, sourceType );
@@ -58,5 +63,3 @@ class SetNode extends TempNode {
 }
 
 export default SetNode;
-
-addNodeClass( 'SetNode', SetNode );

package/src/nodes/utils/SplitNode.js

@@ -1,10 +1,16 @@
-import Node, { addNodeClass } from '../core/Node.js';
+import Node from '../core/Node.js';
 import { vectorComponents } from '../core/constants.js';
 
 const stringVectorComponents = vectorComponents.join( '' );
 
 class SplitNode extends Node {
 
+	static get type() {
+
+		return 'SplitNode';
+
+	}
+
 	constructor( node, components = 'x' ) {
 
 		super();
@@ -108,5 +114,3 @@ class SplitNode extends Node {
 }
 
 export default SplitNode;
-
-addNodeClass( 'SplitNode', SplitNode );

package/src/nodes/utils/SpriteSheetUVNode.js

@@ -1,9 +1,15 @@
-import Node, { addNodeClass } from '../core/Node.js';
-import { uv } from '../accessors/UVNode.js';
-import { nodeProxy, float, vec2 } from '../shadernode/ShaderNode.js';
+import Node from '../core/Node.js';
+import { uv } from '../accessors/UV.js';
+import { nodeProxy, float, vec2 } from '../tsl/TSLBase.js';
 
 class SpriteSheetUVNode extends Node {
 
+	static get type() {
+
+		return 'SpriteSheetUVNode';
+
+	}
+
 	constructor( countNode, uvNode = uv(), frameNode = float( 0 ) ) {
 
 		super( 'vec2' );
@@ -36,6 +42,4 @@ class SpriteSheetUVNode extends Node {
 
 export default SpriteSheetUVNode;
 
-export const spritesheetUV = nodeProxy( SpriteSheetUVNode );
-
-addNodeClass( 'SpriteSheetUVNode', SpriteSheetUVNode );
+export const spritesheetUV = /*@__PURE__*/ nodeProxy( SpriteSheetUVNode );

package/src/nodes/utils/SpriteUtils.js

@@ -0,0 +1,47 @@
+import { modelWorldMatrix } from '../accessors/ModelNode.js';
+import { cameraViewMatrix, cameraProjectionMatrix } from '../accessors/Camera.js';
+import { positionLocal } from '../accessors/Position.js';
+import { Fn, defined } from '../tsl/TSLBase.js';
+
+export const billboarding = /*@__PURE__*/ Fn( ( { position = null, horizontal = true, vertical = false } ) => {
+
+	let worldMatrix;
+
+	if ( position !== null ) {
+
+		worldMatrix = modelWorldMatrix.toVar();
+		worldMatrix[ 3 ][ 0 ] = position.x;
+		worldMatrix[ 3 ][ 1 ] = position.y;
+		worldMatrix[ 3 ][ 2 ] = position.z;
+
+	} else {
+
+		worldMatrix = modelWorldMatrix;
+
+	}
+
+	const modelViewMatrix = cameraViewMatrix.mul( worldMatrix );
+
+	if ( defined( horizontal ) ) {
+
+		modelViewMatrix[ 0 ][ 0 ] = modelWorldMatrix[ 0 ].length();
+		modelViewMatrix[ 0 ][ 1 ] = 0;
+		modelViewMatrix[ 0 ][ 2 ] = 0;
+
+	}
+
+	if ( defined( vertical ) ) {
+
+		modelViewMatrix[ 1 ][ 0 ] = 0;
+		modelViewMatrix[ 1 ][ 1 ] = modelWorldMatrix[ 1 ].length();
+		modelViewMatrix[ 1 ][ 2 ] = 0;
+
+	}
+
+	modelViewMatrix[ 2 ][ 0 ] = 0;
+	modelViewMatrix[ 2 ][ 1 ] = 0;
+	modelViewMatrix[ 2 ][ 2 ] = 1;
+
+	return cameraProjectionMatrix.mul( modelViewMatrix ).mul( positionLocal );
+
+} );

package/src/nodes/utils/StorageArrayElementNode.js

@@ -1,9 +1,14 @@
-import { addNodeClass } from '../core/Node.js';
-import { nodeProxy, addNodeElement } from '../shadernode/ShaderNode.js';
+import { nodeProxy } from '../tsl/TSLBase.js';
 import ArrayElementNode from './ArrayElementNode.js';
 
 class StorageArrayElementNode extends ArrayElementNode {
 
+	static get type() {
+
+		return 'StorageArrayElementNode';
+
+	}
+
 	constructor( storageBufferNode, indexNode ) {
 
 		super( storageBufferNode, indexNode );
@@ -28,7 +33,7 @@ class StorageArrayElementNode extends ArrayElementNode {
 
 		if ( builder.isAvailable( 'storageBuffer' ) === false ) {
 
-			if ( ! this.node.instanceIndex && this.node.bufferObject === true ) {
+			if ( this.node.bufferObject === true ) {
 
 				builder.setupPBO( this.node );
 
@@ -50,15 +55,13 @@ class StorageArrayElementNode extends ArrayElementNode {
 
 		if ( builder.isAvailable( 'storageBuffer' ) === false ) {
 
-			const { node } = this;
-
-			if ( ! node.instanceIndex && this.node.bufferObject === true && isAssignContext !== true ) {
+			if ( this.node.bufferObject === true && isAssignContext !== true ) {
 
 				snippet = builder.generatePBO( this );
 
 			} else {
 
-				snippet = node.build( builder );
+				snippet = this.node.build( builder );
 
 			}
 
@@ -84,8 +87,4 @@ class StorageArrayElementNode extends ArrayElementNode {
 
 export default StorageArrayElementNode;
 
-export const storageElement = nodeProxy( StorageArrayElementNode );
-
-addNodeElement( 'storageElement', storageElement );
-
-addNodeClass( 'StorageArrayElementNode', StorageArrayElementNode );
+export const storageElement = /*@__PURE__*/ nodeProxy( StorageArrayElementNode );

package/src/nodes/utils/TimerNode.js

@@ -1,10 +1,15 @@
 import UniformNode from '../core/UniformNode.js';
 import { NodeUpdateType } from '../core/constants.js';
-import { nodeObject, nodeImmutable } from '../shadernode/ShaderNode.js';
-import { addNodeClass } from '../core/Node.js';
+import { nodeObject, nodeImmutable } from '../tsl/TSLBase.js';
 
 class TimerNode extends UniformNode {
 
+	static get type() {
+
+		return 'TimerNode';
+
+	}
+
 	constructor( scope = TimerNode.LOCAL, scale = 1, value = 0 ) {
 
 		super( value );
@@ -89,6 +94,4 @@ export default TimerNode;
 export const timerLocal = ( timeScale, value = 0 ) => nodeObject( new TimerNode( TimerNode.LOCAL, timeScale, value ) );
 export const timerGlobal = ( timeScale, value = 0 ) => nodeObject( new TimerNode( TimerNode.GLOBAL, timeScale, value ) );
 export const timerDelta = ( timeScale, value = 0 ) => nodeObject( new TimerNode( TimerNode.DELTA, timeScale, value ) );
-export const frameId = nodeImmutable( TimerNode, TimerNode.FRAME ).toUint();
-
-addNodeClass( 'TimerNode', TimerNode );
+export const frameId = /*@__PURE__*/ nodeImmutable( TimerNode, TimerNode.FRAME ).toUint();

package/src/nodes/utils/TriplanarTexturesNode.js

@@ -1,12 +1,18 @@
-import Node, { addNodeClass } from '../core/Node.js';
+import Node from '../core/Node.js';
 import { add } from '../math/OperatorNode.js';
-import { normalLocal } from '../accessors/NormalNode.js';
-import { positionLocal } from '../accessors/PositionNode.js';
+import { normalLocal } from '../accessors/Normal.js';
+import { positionLocal } from '../accessors/Position.js';
 import { texture } from '../accessors/TextureNode.js';
-import { addNodeElement, nodeProxy, float, vec3 } from '../shadernode/ShaderNode.js';
+import { nodeProxy, float, vec3 } from '../tsl/TSLBase.js';
 
 class TriplanarTexturesNode extends Node {
 
+	static get type() {
+
+		return 'TriplanarTexturesNode';
+
+	}
+
 	constructor( textureXNode, textureYNode = null, textureZNode = null, scaleNode = float( 1 ), positionNode = positionLocal, normalNode = normalLocal ) {
 
 		super( 'vec4' );
@@ -54,9 +60,5 @@ class TriplanarTexturesNode extends Node {
 
 export default TriplanarTexturesNode;
 
-export const triplanarTextures = nodeProxy( TriplanarTexturesNode );
+export const triplanarTextures = /*@__PURE__*/ nodeProxy( TriplanarTexturesNode );
 export const triplanarTexture = ( ...params ) => triplanarTextures( ...params );
-
-addNodeElement( 'triplanarTexture', triplanarTexture );
-
-addNodeClass( 'TriplanarTexturesNode', TriplanarTexturesNode );

package/src/nodes/utils/UVUtils.js

@@ -0,0 +1,19 @@
+import { Fn, vec2 } from '../tsl/TSLBase.js';
+import { rotate } from './RotateNode.js';
+
+export const rotateUV = /*@__PURE__*/ Fn( ( [ uv, rotation, center = vec2( 0.5 ) ] ) => {
+
+	return rotate( uv.sub( center ), rotation ).add( center );
+
+} );
+
+export const spherizeUV = /*@__PURE__*/ Fn( ( [ uv, strength, center = vec2( 0.5 ) ] ) => {
+
+	const delta = uv.sub( center );
+	const delta2 = delta.dot( delta );
+	const delta4 = delta2.mul( delta2 );
+	const deltaOffset = delta4.mul( strength );
+
+	return uv.add( delta.mul( deltaOffset ) );
+
+} );

package/src/nodes/utils/ViewportUtils.js

@@ -0,0 +1,14 @@
+import { Fn } from '../tsl/TSLBase.js';
+import { screenUV } from '../display/ScreenNode.js';
+import { viewportDepthTexture } from '../display/ViewportDepthTextureNode.js';
+import { linearDepth } from '../display/ViewportDepthNode.js';
+
+export const viewportSafeUV = /*@__PURE__*/ Fn( ( [ uv = null ] ) => {
+
+	const depth = linearDepth();
+	const depthDiff = linearDepth( viewportDepthTexture( uv ) ).sub( depth );
+	const finalUV = depthDiff.lessThan( 0 ).select( screenUV, uv );
+
+	return finalUV;
+
+} );