@needle-tools/three 0.162.12 → 0.169.2

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;

package/{examples/jsm → 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();
@@ -12,6 +18,8 @@ class FunctionOverloadingNode extends Node {
 
 		this._candidateFnCall = null;
 
+		this.global = true;
+
 	}
 
 	getNodeType() {
@@ -88,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/{examples/jsm → 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/{examples/jsm → src}/nodes/utils/LoopNode.js

@@ -1,11 +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 { context } from '../core/ContextNode.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();
@@ -41,8 +45,12 @@ class LoopNode extends Node {
 
 		}
 
-		properties.returnsNode = this.params[ this.params.length - 1 ]( inputs, builder.addStack(), builder );
-		properties.stackNode = builder.removeStack();
+		const stack = builder.addStack(); // TODO: cache() it
+
+		properties.returnsNode = this.params[ this.params.length - 1 ]( inputs, stack, builder );
+		properties.stackNode = stack;
+
+		builder.removeStack();
 
 		return properties;
 
@@ -68,8 +76,6 @@ class LoopNode extends Node {
 
 		const properties = this.getProperties( builder );
 
-		const contextData = { tempWrite: false };
-
 		const params = this.params;
 		const stackNode = properties.stackNode;
 
@@ -169,7 +175,7 @@ class LoopNode extends Node {
 
 		}
 
-		const stackSnippet = context( stackNode, contextData ).build( builder, 'void' );
+		const stackSnippet = stackNode.build( builder, 'void' );
 
 		const returnsSnippet = properties.returnsNode ? properties.returnsNode.build( builder ) : '';
 
@@ -191,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

@@ -0,0 +1,33 @@
+import TempNode from '../core/TempNode.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' );
+
+	}
+
+	setup() {
+
+		const x = vec3( positionViewDirection.z, 0, positionViewDirection.x.negate() ).normalize();
+		const y = positionViewDirection.cross( x );
+
+		return vec2( x.dot( transformedNormalView ), y.dot( transformedNormalView ) ).mul( 0.495 ).add( 0.5 ); // 0.495 to remove artifacts caused by undersized matcap disks
+
+	}
+
+}
+
+export default MatcapUVNode;
+
+export const matcapUV = /*@__PURE__*/ nodeImmutable( MatcapUVNode );

package/{examples/jsm → src}/nodes/utils/MaxMipLevelNode.js

@@ -1,23 +1,34 @@
 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 );
 
-		this.textureNode = textureNode;
+		this._textureNode = textureNode;
 
 		this.updateType = NodeUpdateType.FRAME;
 
 	}
 
+	get textureNode() {
+
+		return this._textureNode;
+
+	}
+
 	get texture() {
 
-		return this.textureNode.value;
+		return this._textureNode.value;
 
 	}
 
@@ -41,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/{examples/jsm → 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

@@ -0,0 +1,133 @@
+import { nodeObject } from '../tsl/TSLCore.js';
+import TextureNode from '../accessors/TextureNode.js';
+import { NodeUpdateType } from '../core/constants.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';
+import { Vector2 } from '../../math/Vector2.js';
+import { HalfFloatType } from '../../constants.js';
+
+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 );
+
+		super( renderTarget.texture, uv() );
+
+		this.node = node;
+		this.width = width;
+		this.height = height;
+
+		this.renderTarget = renderTarget;
+
+		this.textureNeedsUpdate = true;
+		this.autoUpdate = true;
+
+		this.updateMap = new WeakMap();
+
+		this._rttNode = null;
+		this._quadMesh = new QuadMesh( new NodeMaterial() );
+
+		this.updateBeforeType = NodeUpdateType.RENDER;
+
+	}
+
+	get autoSize() {
+
+		return this.width === null;
+
+	}
+
+	setup( builder ) {
+
+		this._rttNode = this.node.context( builder.getSharedContext() );
+		this._quadMesh.material.name = 'RTT';
+		this._quadMesh.material.needsUpdate = true;
+
+		return super.setup( builder );
+
+	}
+
+	setSize( width, height ) {
+
+		this.width = width;
+		this.height = height;
+
+		const effectiveWidth = width * this.pixelRatio;
+		const effectiveHeight = height * this.pixelRatio;
+
+		this.renderTarget.setSize( effectiveWidth, effectiveHeight );
+
+		this.textureNeedsUpdate = true;
+
+	}
+
+	setPixelRatio( pixelRatio ) {
+
+		this.pixelRatio = pixelRatio;
+
+		this.setSize( this.width, this.height );
+
+	}
+
+	updateBefore( { renderer } ) {
+
+		if ( this.textureNeedsUpdate === false && this.autoUpdate === false ) return;
+
+		this.textureNeedsUpdate = false;
+
+		//
+
+		if ( this.autoSize === true ) {
+
+			this.pixelRatio = renderer.getPixelRatio();
+
+			const size = renderer.getSize( _size );
+
+			this.setSize( size.width, size.height );
+
+		}
+
+		//
+
+		this._quadMesh.material.fragmentNode = this._rttNode;
+
+		//
+
+		const currentRenderTarget = renderer.getRenderTarget();
+
+		renderer.setRenderTarget( this.renderTarget );
+
+		this._quadMesh.render( renderer );
+
+		renderer.setRenderTarget( currentRenderTarget );
+
+	}
+
+	clone() {
+
+		const newNode = new TextureNode( this.value, this.uvNode, this.levelNode );
+		newNode.sampler = this.sampler;
+		newNode.referenceNode = this;
+
+		return newNode;
+
+	}
+
+}
+
+export default RTTNode;
+
+export const rtt = ( node, ...params ) => nodeObject( new RTTNode( nodeObject( node ), ...params ) );
+export const convertToTexture = ( node, ...params ) => node.isTextureNode ? node : rtt( node, ...params );

package/{examples/jsm → src}/nodes/utils/ReflectorNode.js

@@ -1,8 +1,16 @@
 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 { Matrix4, Vector2, Vector3, Vector4, Object3D, Plane, RenderTarget, HalfFloatType, LinearMipMapLinearFilter } from 'three';
+import { screenUV } from '../display/ScreenNode.js';
+
+import { HalfFloatType, LinearMipMapLinearFilter } from '../../constants.js';
+import { Plane } from '../../math/Plane.js';
+import { Object3D } from '../../core/Object3D.js';
+import { Vector2 } from '../../math/Vector2.js';
+import { Vector3 } from '../../math/Vector3.js';
+import { Vector4 } from '../../math/Vector4.js';
+import { Matrix4 } from '../../math/Matrix4.js';
+import { RenderTarget } from '../../core/RenderTarget.js';
 
 const _reflectorPlane = new Plane();
 const _normal = new Vector3();
@@ -19,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 );
@@ -206,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;
@@ -224,4 +241,3 @@ class ReflectorNode extends TextureNode {
 export const reflector = ( parameters ) => nodeObject( new ReflectorNode( parameters ) );
 
 export default ReflectorNode;
-

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