@needle-tools/three 0.162.12 → 0.169.2

package/{examples/jsm → src}/nodes/accessors/TextureNode.js

@@ -1,16 +1,23 @@
 import UniformNode, { uniform } from '../core/UniformNode.js';
-import { uv } from './UVNode.js';
+import { uv } from './UV.js';
 import { textureSize } from './TextureSizeNode.js';
-import { colorSpaceToLinear } from '../display/ColorSpaceNode.js';
+import { colorSpaceToWorking } from '../display/ColorSpaceNode.js';
 import { expression } from '../code/ExpressionNode.js';
-import { addNodeClass } from '../core/Node.js';
 import { maxMipLevel } from '../utils/MaxMipLevelNode.js';
-import { addNodeElement, nodeProxy, vec3, nodeObject } from '../shadernode/ShaderNode.js';
+import { nodeProxy, vec3, nodeObject, int } from '../tsl/TSLBase.js';
 import { NodeUpdateType } from '../core/constants.js';
 
+import { IntType, UnsignedIntType } from '../../constants.js';
+
 class TextureNode extends UniformNode {
 
-	constructor( value, uvNode = null, levelNode = null ) {
+	static get type() {
+
+		return 'TextureNode';
+
+	}
+
+	constructor( value, uvNode = null, levelNode = null, biasNode = null ) {
 
 		super( value );
 
@@ -18,17 +25,44 @@ class TextureNode extends UniformNode {
 
 		this.uvNode = uvNode;
 		this.levelNode = levelNode;
+		this.biasNode = biasNode;
 		this.compareNode = null;
 		this.depthNode = null;
+		this.gradNode = null;
 
 		this.sampler = true;
 		this.updateMatrix = false;
 		this.updateType = NodeUpdateType.NONE;
 
+		this.referenceNode = null;
+
+		this._value = value;
+		this._matrixUniform = null;
+
 		this.setUpdateMatrix( uvNode === null );
 
 	}
 
+	set value( value ) {
+
+		if ( this.referenceNode ) {
+
+			this.referenceNode.value = value;
+
+		} else {
+
+			this._value = value;
+
+		}
+
+	}
+
+	get value() {
+
+		return this.referenceNode ? this.referenceNode.value : this._value;
+
+	}
+
 	getUniformHash( /*builder*/ ) {
 
 		return this.value.uuid;
@@ -39,6 +73,16 @@ class TextureNode extends UniformNode {
 
 		if ( this.value.isDepthTexture === true ) return 'float';
 
+		if ( this.value.type === UnsignedIntType ) {
+
+			return 'uvec4';
+
+		} else if ( this.value.type === IntType ) {
+
+			return 'ivec4';
+
+		}
+
 		return 'vec4';
 
 	}
@@ -55,7 +99,7 @@ class TextureNode extends UniformNode {
 
 	}
 
-	setReference( /*state*/ ) {
+	updateReference( /*state*/ ) {
 
 		return this.value;
 
@@ -63,9 +107,9 @@ class TextureNode extends UniformNode {
 
 	getTransformedUV( uvNode ) {
 
-		const texture = this.value;
+		if ( this._matrixUniform === null ) this._matrixUniform = uniform( this.value.matrix );
 
-		return uniform( texture.matrix ).mul( vec3( uvNode, 1 ) ).xy;
+		return this._matrixUniform.mul( vec3( uvNode, 1 ) ).xy;
 
 	}
 
@@ -84,7 +128,15 @@ class TextureNode extends UniformNode {
 
 		if ( builder.isFlipY() && ( texture.isRenderTargetTexture === true || texture.isFramebufferTexture === true || texture.isDepthTexture === true ) ) {
 
-			uvNode = uvNode.setY( uvNode.y.oneMinus() );
+			if ( this.sampler ) {
+
+				uvNode = uvNode.flipY();
+
+			} else {
+
+				uvNode = uvNode.setY( int( textureSize( this, this.levelNode ).y ).sub( uvNode.y ).sub( 1 ) );
+
+			}
 
 		}
 
@@ -95,6 +147,7 @@ class TextureNode extends UniformNode {
 	setup( builder ) {
 
 		const properties = builder.getNodeProperties( this );
+		properties.referenceNode = this.referenceNode;
 
 		//
 
@@ -126,17 +179,13 @@ class TextureNode extends UniformNode {
 
 		}
 
-		if ( levelNode !== null && builder.context.getTextureLevelAlgorithm !== undefined ) {
-
-			levelNode = builder.context.getTextureLevelAlgorithm( this, levelNode );
-
-		}
-
 		//
 
 		properties.uvNode = uvNode;
 		properties.levelNode = levelNode;
+		properties.biasNode = this.biasNode;
 		properties.compareNode = this.compareNode;
+		properties.gradNode = this.gradNode;
 		properties.depthNode = this.depthNode;
 
 	}
@@ -147,7 +196,7 @@ class TextureNode extends UniformNode {
 
 	}
 
-	generateSnippet( builder, textureProperty, uvSnippet, levelSnippet, depthSnippet, compareSnippet ) {
+	generateSnippet( builder, textureProperty, uvSnippet, levelSnippet, biasSnippet, depthSnippet, compareSnippet, gradSnippet ) {
 
 		const texture = this.value;
 
@@ -157,6 +206,14 @@ class TextureNode extends UniformNode {
 
 			snippet = builder.generateTextureLevel( texture, textureProperty, uvSnippet, levelSnippet, depthSnippet );
 
+		} else if ( biasSnippet ) {
+
+			snippet = builder.generateTextureBias( texture, textureProperty, uvSnippet, biasSnippet, depthSnippet );
+
+		} else if ( gradSnippet ) {
+
+			snippet = builder.generateTextureGrad( texture, textureProperty, uvSnippet, gradSnippet, depthSnippet );
+
 		} else if ( compareSnippet ) {
 
 			snippet = builder.generateTextureCompare( texture, textureProperty, uvSnippet, compareSnippet, depthSnippet );
@@ -205,36 +262,34 @@ class TextureNode extends UniformNode {
 
 			if ( propertyName === undefined ) {
 
-				const { uvNode, levelNode, compareNode, depthNode } = properties;
+				const { uvNode, levelNode, biasNode, compareNode, depthNode, gradNode } = properties;
 
 				const uvSnippet = this.generateUV( builder, uvNode );
 				const levelSnippet = levelNode ? levelNode.build( builder, 'float' ) : null;
+				const biasSnippet = biasNode ? biasNode.build( builder, 'float' ) : null;
 				const depthSnippet = depthNode ? depthNode.build( builder, 'int' ) : null;
 				const compareSnippet = compareNode ? compareNode.build( builder, 'float' ) : null;
+				const gradSnippet = gradNode ? [ gradNode[ 0 ].build( builder, 'vec2' ), gradNode[ 1 ].build( builder, 'vec2' ) ] : null;
 
 				const nodeVar = builder.getVarFromNode( this );
 
 				propertyName = builder.getPropertyName( nodeVar );
 
-				const snippet = this.generateSnippet( builder, textureProperty, uvSnippet, levelSnippet, depthSnippet, compareSnippet );
-
-				builder.addLineFlowCode( `${propertyName} = ${snippet}` );
-
-				if ( builder.context.tempWrite !== false ) {
+				const snippet = this.generateSnippet( builder, textureProperty, uvSnippet, levelSnippet, biasSnippet, depthSnippet, compareSnippet, gradSnippet );
 
-					nodeData.snippet = snippet;
-					nodeData.propertyName = propertyName;
+				builder.addLineFlowCode( `${propertyName} = ${snippet}`, this );
 
-				}
+				nodeData.snippet = snippet;
+				nodeData.propertyName = propertyName;
 
 			}
 
 			let snippet = propertyName;
 			const nodeType = this.getNodeType( builder );
 
-			if ( builder.needsColorSpaceToLinear( texture ) ) {
+			if ( builder.needsToWorkingColorSpace( texture ) ) {
 
-				snippet = colorSpaceToLinear( expression( snippet, nodeType ), texture.colorSpace ).setup( builder ).build( builder, nodeType );
+				snippet = colorSpaceToWorking( expression( snippet, nodeType ), texture.colorSpace ).setup( builder ).build( builder, nodeType );
 
 			}
 
@@ -263,16 +318,18 @@ class TextureNode extends UniformNode {
 	uv( uvNode ) {
 
 		const textureNode = this.clone();
-		textureNode.uvNode = uvNode;
+		textureNode.uvNode = nodeObject( uvNode );
+		textureNode.referenceNode = this.getSelf();
 
 		return nodeObject( textureNode );
 
 	}
 
-	blur( levelNode ) {
+	blur( amountNode ) {
 
 		const textureNode = this.clone();
-		textureNode.levelNode = levelNode.mul( maxMipLevel( textureNode ) );
+		textureNode.biasNode = nodeObject( amountNode ).mul( maxMipLevel( textureNode ) );
+		textureNode.referenceNode = this.getSelf();
 
 		return nodeObject( textureNode );
 
@@ -281,9 +338,10 @@ class TextureNode extends UniformNode {
 	level( levelNode ) {
 
 		const textureNode = this.clone();
-		textureNode.levelNode = levelNode;
+		textureNode.levelNode = nodeObject( levelNode );
+		textureNode.referenceNode = this.getSelf();
 
-		return textureNode;
+		return nodeObject( textureNode );
 
 	}
 
@@ -293,10 +351,31 @@ class TextureNode extends UniformNode {
 
 	}
 
+	bias( biasNode ) {
+
+		const textureNode = this.clone();
+		textureNode.biasNode = nodeObject( biasNode );
+		textureNode.referenceNode = this.getSelf();
+
+		return nodeObject( textureNode );
+
+	}
+
 	compare( compareNode ) {
 
 		const textureNode = this.clone();
 		textureNode.compareNode = nodeObject( compareNode );
+		textureNode.referenceNode = this.getSelf();
+
+		return nodeObject( textureNode );
+
+	}
+
+	grad( gradNodeX, gradNodeY ) {
+
+		const textureNode = this.clone();
+		textureNode.gradNode = [ nodeObject( gradNodeX ), nodeObject( gradNodeY ) ];
+		textureNode.referenceNode = this.getSelf();
 
 		return nodeObject( textureNode );
 
@@ -306,6 +385,7 @@ class TextureNode extends UniformNode {
 
 		const textureNode = this.clone();
 		textureNode.depthNode = nodeObject( depthNode );
+		textureNode.referenceNode = this.getSelf();
 
 		return nodeObject( textureNode );
 
@@ -318,6 +398,9 @@ class TextureNode extends UniformNode {
 		super.serialize( data );
 
 		data.value = this.value.toJSON( data.meta ).uuid;
+		data.sampler = this.sampler;
+		data.updateMatrix = this.updateMatrix;
+		data.updateType = this.updateType;
 
 	}
 
@@ -326,12 +409,18 @@ class TextureNode extends UniformNode {
 		super.deserialize( data );
 
 		this.value = data.meta.textures[ data.value ];
+		this.sampler = data.sampler;
+		this.updateMatrix = data.updateMatrix;
+		this.updateType = data.updateType;
 
 	}
 
 	update() {
 
 		const texture = this.value;
+		const matrixUniform = this._matrixUniform;
+
+		if ( matrixUniform !== null ) matrixUniform.value = texture.matrix;
 
 		if ( texture.matrixAutoUpdate === true ) {
 
@@ -343,7 +432,7 @@ class TextureNode extends UniformNode {
 
 	clone() {
 
-		const newNode = new this.constructor( this.value, this.uvNode, this.levelNode );
+		const newNode = new this.constructor( this.value, this.uvNode, this.levelNode, this.biasNode );
 		newNode.sampler = this.sampler;
 
 		return newNode;
@@ -354,14 +443,9 @@ class TextureNode extends UniformNode {
 
 export default TextureNode;
 
-export const texture = nodeProxy( TextureNode );
+export const texture = /*@__PURE__*/ nodeProxy( TextureNode );
 export const textureLoad = ( ...params ) => texture( ...params ).setSampler( false );
 
 //export const textureLevel = ( value, uv, level ) => texture( value, uv ).level( level );
 
 export const sampler = ( aTexture ) => ( aTexture.isNode === true ? aTexture : texture( aTexture ) ).convert( 'sampler' );
-
-addNodeElement( 'texture', texture );
-//addNodeElement( 'textureLevel', textureLevel );
-
-addNodeClass( 'TextureNode', TextureNode );

package/src/nodes/accessors/TextureSizeNode.js

@@ -0,0 +1,36 @@
+import Node from '../core/Node.js';
+import { nodeProxy } from '../tsl/TSLBase.js';
+
+class TextureSizeNode extends Node {
+
+	static get type() {
+
+		return 'TextureSizeNode';
+
+	}
+
+	constructor( textureNode, levelNode = null ) {
+
+		super( 'uvec2' );
+
+		this.isTextureSizeNode = true;
+
+		this.textureNode = textureNode;
+		this.levelNode = levelNode;
+
+	}
+
+	generate( builder, output ) {
+
+		const textureProperty = this.textureNode.build( builder, 'property' );
+		const level = this.levelNode === null ? '0' : this.levelNode.build( builder, 'int' );
+
+		return builder.format( `${ builder.getMethod( 'textureDimensions' ) }( ${ textureProperty }, ${ level } )`, this.getNodeType( builder ), output );
+
+	}
+
+}
+
+export default TextureSizeNode;
+
+export const textureSize = /*@__PURE__*/ nodeProxy( TextureSizeNode );

package/src/nodes/accessors/UV.js

@@ -0,0 +1,3 @@
+import { attribute } from '../core/AttributeNode.js';
+
+export const uv = ( index ) => attribute( 'uv' + ( index > 0 ? index : '' ), 'vec2' );

package/{examples/jsm/nodes/accessors/UniformsNode.js → src/nodes/accessors/UniformArrayNode.js}

@@ -1,23 +1,22 @@
-import { addNodeClass } from '../core/Node.js';
-import { nodeObject } from '../shadernode/ShaderNode.js';
+import { nodeObject } from '../tsl/TSLBase.js';
 import { NodeUpdateType } from '../core/constants.js';
 import { getValueType } from '../core/NodeUtils.js';
 import ArrayElementNode from '../utils/ArrayElementNode.js';
 import BufferNode from './BufferNode.js';
 
-class UniformsElementNode extends ArrayElementNode {
+class UniformArrayElementNode extends ArrayElementNode {
 
-	constructor( arrayBuffer, indexNode ) {
+	static get type() {
 
-		super( arrayBuffer, indexNode );
-
-		this.isArrayBufferElementNode = true;
+		return 'UniformArrayElementNode';
 
 	}
 
-	getNodeType( builder ) {
+	constructor( arrayBuffer, indexNode ) {
 
-		return this.node.getElementType( builder );
+		super( arrayBuffer, indexNode );
+
+		this.isArrayBufferElementNode = true;
 
 	}
 
@@ -32,7 +31,13 @@ class UniformsElementNode extends ArrayElementNode {
 
 }
 
-class UniformsNode extends BufferNode {
+class UniformArrayNode extends BufferNode {
+
+	static get type() {
+
+		return 'UniformArrayNode';
+
+	}
 
 	constructor( value, elementType = null ) {
 
@@ -118,8 +123,14 @@ class UniformsNode extends BufferNode {
 		this._elementType = this.elementType === null ? getValueType( this.array[ 0 ] ) : this.elementType;
 		this._elementLength = builder.getTypeLength( this._elementType );
 
-		this.value = new Float32Array( length * 4 );
+		let arrayType = Float32Array;
+
+		if ( this._elementType.charAt( 0 ) === 'i' ) arrayType = Int32Array;
+		else if ( this._elementType.charAt( 0 ) === 'u' ) arrayType = Uint32Array;
+
+		this.value = new arrayType( length * 4 );
 		this.bufferCount = length;
+		this.bufferType = builder.changeComponentType( 'vec4', builder.getComponentType( this._elementType ) );
 
 		return super.setup( builder );
 
@@ -127,14 +138,21 @@ class UniformsNode extends BufferNode {
 
 	element( indexNode ) {
 
-		return nodeObject( new UniformsElementNode( this, nodeObject( indexNode ) ) );
+		return nodeObject( new UniformArrayElementNode( this, nodeObject( indexNode ) ) );
 
 	}
 
 }
 
-export default UniformsNode;
+export default UniformArrayNode;
+
+export const uniformArray = ( values, nodeType ) => nodeObject( new UniformArrayNode( values, nodeType ) );
+
+//
+
+export const uniforms = ( values, nodeType ) => { // @deprecated, r168
 
-export const uniforms = ( values, nodeType ) => nodeObject( new UniformsNode( values, nodeType ) );
+	console.warn( 'TSL.UniformArrayNode: uniforms() has been renamed to uniformArray().' );
+	return nodeObject( new UniformArrayNode( values, nodeType ) );
 
-addNodeClass( 'UniformsNode', UniformsNode );
+};

package/{examples/jsm → src}/nodes/accessors/UserDataNode.js

@@ -1,9 +1,14 @@
 import ReferenceNode from './ReferenceNode.js';
-import { addNodeClass } from '../core/Node.js';
-import { nodeObject } from '../shadernode/ShaderNode.js';
+import { nodeObject } from '../tsl/TSLBase.js';
 
 class UserDataNode extends ReferenceNode {
 
+	static get type() {
+
+		return 'UserDataNode';
+
+	}
+
 	constructor( property, inputType, userData = null ) {
 
 		super( property, inputType, userData );
@@ -12,11 +17,11 @@ class UserDataNode extends ReferenceNode {
 
 	}
 
-	update( frame ) {
+	updateReference( state ) {
 
-		this.reference = this.userData !== null ? this.userData : frame.object.userData;
+		this.reference = this.userData !== null ? this.userData : state.object.userData;
 
-		super.update( frame );
+		return this.reference;
 
 	}
 
@@ -25,5 +30,3 @@ class UserDataNode extends ReferenceNode {
 export default UserDataNode;
 
 export const userData = ( name, inputType, userData ) => nodeObject( new UserDataNode( name, inputType, userData ) );
-
-addNodeClass( 'UserDataNode', UserDataNode );

package/src/nodes/accessors/VelocityNode.js

@@ -0,0 +1,134 @@
+import TempNode from '../core/TempNode.js';
+import { modelViewMatrix } from './ModelNode.js';
+import { positionLocal, positionPrevious } from './Position.js';
+import { nodeImmutable } from '../tsl/TSLBase.js';
+import { NodeUpdateType } from '../core/constants.js';
+import { Matrix4 } from '../../math/Matrix4.js';
+import { uniform } from '../core/UniformNode.js';
+import { sub } from '../math/OperatorNode.js';
+import { cameraProjectionMatrix } from './Camera.js';
+import { renderGroup } from '../core/UniformGroupNode.js';
+
+const _objectData = new WeakMap();
+
+class VelocityNode extends TempNode {
+
+	static get type() {
+
+		return 'VelocityNode';
+
+	}
+
+	constructor() {
+
+		super( 'vec2' );
+
+		this.updateType = NodeUpdateType.OBJECT;
+		this.updateAfterType = NodeUpdateType.OBJECT;
+
+		this.previousModelWorldMatrix = uniform( new Matrix4() );
+		this.previousProjectionMatrix = uniform( new Matrix4() ).setGroup( renderGroup );
+		this.previousCameraViewMatrix = uniform( new Matrix4() );
+
+	}
+
+	update( { frameId, camera, object } ) {
+
+		const previousModelMatrix = getPreviousMatrix( object );
+
+		this.previousModelWorldMatrix.value.copy( previousModelMatrix );
+
+		//
+
+		const cameraData = getData( camera );
+
+		if ( cameraData.frameId !== frameId ) {
+
+			cameraData.frameId = frameId;
+
+			if ( cameraData.previousProjectionMatrix === undefined ) {
+
+				cameraData.previousProjectionMatrix = new Matrix4();
+				cameraData.previousCameraViewMatrix = new Matrix4();
+
+				cameraData.currentProjectionMatrix = new Matrix4();
+				cameraData.currentCameraViewMatrix = new Matrix4();
+
+				cameraData.previousProjectionMatrix.copy( camera.projectionMatrix );
+				cameraData.previousCameraViewMatrix.copy( camera.matrixWorldInverse );
+
+			} else {
+
+				cameraData.previousProjectionMatrix.copy( cameraData.currentProjectionMatrix );
+				cameraData.previousCameraViewMatrix.copy( cameraData.currentCameraViewMatrix );
+
+			}
+
+			cameraData.currentProjectionMatrix.copy( camera.projectionMatrix );
+			cameraData.currentCameraViewMatrix.copy( camera.matrixWorldInverse );
+
+			this.previousProjectionMatrix.value.copy( cameraData.previousProjectionMatrix );
+			this.previousCameraViewMatrix.value.copy( cameraData.previousCameraViewMatrix );
+
+		}
+
+	}
+
+	updateAfter( { object } ) {
+
+		getPreviousMatrix( object ).copy( object.matrixWorld );
+
+	}
+
+	setup( /*builder*/ ) {
+
+		const previousModelViewMatrix = this.previousCameraViewMatrix.mul( this.previousModelWorldMatrix );
+
+		const clipPositionCurrent = cameraProjectionMatrix.mul( modelViewMatrix ).mul( positionLocal );
+		const clipPositionPrevious = this.previousProjectionMatrix.mul( previousModelViewMatrix ).mul( positionPrevious );
+
+		const ndcPositionCurrent = clipPositionCurrent.xy.div( clipPositionCurrent.w );
+		const ndcPositionPrevious = clipPositionPrevious.xy.div( clipPositionPrevious.w );
+
+		const velocity = sub( ndcPositionCurrent, ndcPositionPrevious );
+
+		return velocity;
+
+	}
+
+}
+
+function getData( object ) {
+
+	let objectData = _objectData.get( object );
+
+	if ( objectData === undefined ) {
+
+		objectData = {};
+		_objectData.set( object, objectData );
+
+	}
+
+	return objectData;
+
+}
+
+function getPreviousMatrix( object, index = 0 ) {
+
+	const objectData = getData( object );
+
+	let matrix = objectData[ index ];
+
+	if ( matrix === undefined ) {
+
+		objectData[ index ] = matrix = new Matrix4();
+
+	}
+
+	return matrix;
+
+}
+
+export default VelocityNode;
+
+export const velocity = /*@__PURE__*/ nodeImmutable( VelocityNode );

package/{examples/jsm → src}/nodes/accessors/VertexColorNode.js

@@ -1,10 +1,16 @@
-import { addNodeClass } from '../core/Node.js';
 import AttributeNode from '../core/AttributeNode.js';
-import { nodeObject } from '../shadernode/ShaderNode.js';
-import { Vector4 } from 'three';
+import { nodeObject } from '../tsl/TSLBase.js';
+
+import { Vector4 } from '../../math/Vector4.js';
 
 class VertexColorNode extends AttributeNode {
 
+	static get type() {
+
+		return 'VertexColorNode';
+
+	}
+
 	constructor( index = 0 ) {
 
 		super( null, 'vec4' );
@@ -66,5 +72,3 @@ class VertexColorNode extends AttributeNode {
 export default VertexColorNode;
 
 export const vertexColor = ( ...params ) => nodeObject( new VertexColorNode( ...params ) );
-
-addNodeClass( 'VertexColorNode', VertexColorNode );