@needle-tools/three 0.162.12 → 0.169.2

package/src/nodes/accessors/ReflectVector.js

@@ -0,0 +1,10 @@
+import { cameraViewMatrix } from './Camera.js';
+import { transformedNormalView } from './Normal.js';
+import { positionViewDirection } from './Position.js';
+import { materialRefractionRatio } from './MaterialProperties.js';
+
+export const reflectView = /*@__PURE__*/ positionViewDirection.negate().reflect( transformedNormalView );
+export const refractView = /*@__PURE__*/ positionViewDirection.negate().refract( transformedNormalView, materialRefractionRatio );
+
+export const reflectVector = /*@__PURE__*/ reflectView.transformDirection( cameraViewMatrix ).toVar( 'reflectVector' );
+export const refractVector = /*@__PURE__*/ refractView.transformDirection( cameraViewMatrix ).toVar( 'reflectVector' );

package/src/nodes/accessors/RendererReferenceNode.js

@@ -0,0 +1,35 @@
+import ReferenceBaseNode from './ReferenceBaseNode.js';
+import { nodeObject } from '../tsl/TSLCore.js';
+import { renderGroup } from '../core/UniformGroupNode.js';
+
+class RendererReferenceNode extends ReferenceBaseNode {
+
+	static get type() {
+
+		return 'RendererReferenceNode';
+
+	}
+
+	constructor( property, inputType, renderer = null ) {
+
+		super( property, inputType, renderer );
+
+		this.renderer = renderer;
+
+		this.setGroup( renderGroup );
+
+	}
+
+	updateReference( state ) {
+
+		this.reference = this.renderer !== null ? this.renderer : state.renderer;
+
+		return this.reference;
+
+	}
+
+}
+
+export default RendererReferenceNode;
+
+export const rendererReference = ( name, type, renderer ) => nodeObject( new RendererReferenceNode( name, type, renderer ) );

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

@@ -1,10 +1,15 @@
 import Node from '../core/Node.js';
-import { addNodeClass } from '../core/Node.js';
-import { nodeImmutable } from '../shadernode/ShaderNode.js';
+import { nodeImmutable } from '../tsl/TSLBase.js';
 import { reference } from './ReferenceNode.js';
 
 class SceneNode extends Node {
 
+	static get type() {
+
+		return 'SceneNode';
+
+	}
+
 	constructor( scope = SceneNode.BACKGROUND_BLURRINESS, scene = null ) {
 
 		super();
@@ -46,7 +51,5 @@ SceneNode.BACKGROUND_INTENSITY = 'backgroundIntensity';
 
 export default SceneNode;
 
-export const backgroundBlurriness = nodeImmutable( SceneNode, SceneNode.BACKGROUND_BLURRINESS );
-export const backgroundIntensity = nodeImmutable( SceneNode, SceneNode.BACKGROUND_INTENSITY );
-
-addNodeClass( 'SceneNode', SceneNode );
+export const backgroundBlurriness = /*@__PURE__*/ nodeImmutable( SceneNode, SceneNode.BACKGROUND_BLURRINESS );
+export const backgroundIntensity = /*@__PURE__*/ nodeImmutable( SceneNode, SceneNode.BACKGROUND_INTENSITY );

package/src/nodes/accessors/SkinningNode.js

@@ -0,0 +1,191 @@
+import Node from '../core/Node.js';
+import { NodeUpdateType } from '../core/constants.js';
+import { nodeObject } from '../tsl/TSLBase.js';
+import { attribute } from '../core/AttributeNode.js';
+import { reference, referenceBuffer } from './ReferenceNode.js';
+import { add } from '../math/OperatorNode.js';
+import { normalLocal } from './Normal.js';
+import { positionLocal, positionPrevious } from './Position.js';
+import { tangentLocal } from './Tangent.js';
+import { uniform } from '../core/UniformNode.js';
+import { buffer } from './BufferNode.js';
+
+const _frameId = new WeakMap();
+
+class SkinningNode extends Node {
+
+	static get type() {
+
+		return 'SkinningNode';
+
+	}
+
+	constructor( skinnedMesh, useReference = false ) {
+
+		super( 'void' );
+
+		this.skinnedMesh = skinnedMesh;
+		this.useReference = useReference;
+
+		this.updateType = NodeUpdateType.OBJECT;
+
+		//
+
+		this.skinIndexNode = attribute( 'skinIndex', 'uvec4' );
+		this.skinWeightNode = attribute( 'skinWeight', 'vec4' );
+
+		let bindMatrixNode, bindMatrixInverseNode, boneMatricesNode;
+
+		if ( useReference ) {
+
+			bindMatrixNode = reference( 'bindMatrix', 'mat4' );
+			bindMatrixInverseNode = reference( 'bindMatrixInverse', 'mat4' );
+			boneMatricesNode = referenceBuffer( 'skeleton.boneMatrices', 'mat4', skinnedMesh.skeleton.bones.length );
+
+		} else {
+
+			bindMatrixNode = uniform( skinnedMesh.bindMatrix, 'mat4' );
+			bindMatrixInverseNode = uniform( skinnedMesh.bindMatrixInverse, 'mat4' );
+			boneMatricesNode = buffer( skinnedMesh.skeleton.boneMatrices, 'mat4', skinnedMesh.skeleton.bones.length );
+
+		}
+
+		this.bindMatrixNode = bindMatrixNode;
+		this.bindMatrixInverseNode = bindMatrixInverseNode;
+		this.boneMatricesNode = boneMatricesNode;
+		this.previousBoneMatricesNode = null;
+
+	}
+
+	getSkinnedPosition( boneMatrices = this.boneMatricesNode, position = positionLocal ) {
+
+		const { skinIndexNode, skinWeightNode, bindMatrixNode, bindMatrixInverseNode } = this;
+
+		const boneMatX = boneMatrices.element( skinIndexNode.x );
+		const boneMatY = boneMatrices.element( skinIndexNode.y );
+		const boneMatZ = boneMatrices.element( skinIndexNode.z );
+		const boneMatW = boneMatrices.element( skinIndexNode.w );
+
+		// POSITION
+
+		const skinVertex = bindMatrixNode.mul( position );
+
+		const skinned = add(
+			boneMatX.mul( skinWeightNode.x ).mul( skinVertex ),
+			boneMatY.mul( skinWeightNode.y ).mul( skinVertex ),
+			boneMatZ.mul( skinWeightNode.z ).mul( skinVertex ),
+			boneMatW.mul( skinWeightNode.w ).mul( skinVertex )
+		);
+
+		return bindMatrixInverseNode.mul( skinned ).xyz;
+
+	}
+
+	getSkinnedNormal( boneMatrices = this.boneMatricesNode, normal = normalLocal ) {
+
+		const { skinIndexNode, skinWeightNode, bindMatrixNode, bindMatrixInverseNode } = this;
+
+		const boneMatX = boneMatrices.element( skinIndexNode.x );
+		const boneMatY = boneMatrices.element( skinIndexNode.y );
+		const boneMatZ = boneMatrices.element( skinIndexNode.z );
+		const boneMatW = boneMatrices.element( skinIndexNode.w );
+
+		// NORMAL
+
+		let skinMatrix = add(
+			skinWeightNode.x.mul( boneMatX ),
+			skinWeightNode.y.mul( boneMatY ),
+			skinWeightNode.z.mul( boneMatZ ),
+			skinWeightNode.w.mul( boneMatW )
+		);
+
+		skinMatrix = bindMatrixInverseNode.mul( skinMatrix ).mul( bindMatrixNode );
+
+		return skinMatrix.transformDirection( normal ).xyz;
+
+	}
+
+	getPreviousSkinnedPosition( builder ) {
+
+		const skinnedMesh = builder.object;
+
+		if ( this.previousBoneMatricesNode === null ) {
+
+			skinnedMesh.skeleton.previousBoneMatrices = new Float32Array( skinnedMesh.skeleton.boneMatrices );
+
+			this.previousBoneMatricesNode = referenceBuffer( 'skeleton.previousBoneMatrices', 'mat4', skinnedMesh.skeleton.bones.length );
+
+		}
+
+		return this.getSkinnedPosition( this.previousBoneMatricesNode, positionPrevious );
+
+	}
+
+	needsPreviousBoneMatrices( builder ) {
+
+		const mrt = builder.renderer.getMRT();
+
+		return mrt && mrt.has( 'velocity' );
+
+	}
+
+	setup( builder ) {
+
+		if ( this.needsPreviousBoneMatrices( builder ) ) {
+
+			positionPrevious.assign( this.getPreviousSkinnedPosition( builder ) );
+
+		}
+
+		const skinPosition = this.getSkinnedPosition();
+
+
+		positionLocal.assign( skinPosition );
+
+		if ( builder.hasGeometryAttribute( 'normal' ) ) {
+
+			const skinNormal = this.getSkinnedNormal();
+
+			normalLocal.assign( skinNormal );
+
+			if ( builder.hasGeometryAttribute( 'tangent' ) ) {
+
+				tangentLocal.assign( skinNormal );
+
+			}
+
+		}
+
+	}
+
+	generate( builder, output ) {
+
+		if ( output !== 'void' ) {
+
+			return positionLocal.build( builder, output );
+
+		}
+
+	}
+
+	update( frame ) {
+
+		const object = this.useReference ? frame.object : this.skinnedMesh;
+		const skeleton = object.skeleton;
+
+		if ( _frameId.get( skeleton ) === frame.frameId ) return;
+
+		_frameId.set( skeleton, frame.frameId );
+
+		if ( this.previousBoneMatricesNode !== null ) skeleton.previousBoneMatrices.set( skeleton.boneMatrices );
+
+		skeleton.update();
+
+	}
+
+}
+
+export default SkinningNode;
+
+export const skinning = ( skinnedMesh ) => nodeObject( new SkinningNode( skinnedMesh ) );
+export const skinningReference = ( skinnedMesh ) => nodeObject( new SkinningNode( skinnedMesh, true ) );

package/src/nodes/accessors/StorageBufferNode.js

@@ -0,0 +1,147 @@
+import BufferNode from './BufferNode.js';
+import { bufferAttribute } from './BufferAttributeNode.js';
+import { nodeObject, varying } from '../tsl/TSLBase.js';
+import { storageElement } from '../utils/StorageArrayElementNode.js';
+import { GPUBufferBindingType } from '../../renderers/webgpu/utils/WebGPUConstants.js';
+
+class StorageBufferNode extends BufferNode {
+
+	static get type() {
+
+		return 'StorageBufferNode';
+
+	}
+
+	constructor( value, bufferType, bufferCount = 0 ) {
+
+		super( value, bufferType, bufferCount );
+
+		this.isStorageBufferNode = true;
+
+		this.access = GPUBufferBindingType.Storage;
+		this.isAtomic = false;
+
+		this.bufferObject = false;
+		this.bufferCount = bufferCount;
+
+		this._attribute = null;
+		this._varying = null;
+
+		this.global = true;
+
+		if ( value.isStorageBufferAttribute !== true && value.isStorageInstancedBufferAttribute !== true ) {
+
+			// TOOD: Improve it, possibly adding a new property to the BufferAttribute to identify it as a storage buffer read-only attribute in Renderer
+
+			if ( value.isInstancedBufferAttribute ) value.isStorageInstancedBufferAttribute = true;
+			else value.isStorageBufferAttribute = true;
+
+		}
+
+	}
+
+	getHash( builder ) {
+
+		if ( this.bufferCount === 0 ) {
+
+			let bufferData = builder.globalCache.getData( this.value );
+
+			if ( bufferData === undefined ) {
+
+				bufferData = {
+					node: this
+				};
+
+				builder.globalCache.setData( this.value, bufferData );
+
+			}
+
+			return bufferData.node.uuid;
+
+		}
+
+		return this.uuid;
+
+	}
+
+	getInputType( /*builder*/ ) {
+
+		return 'storageBuffer';
+
+	}
+
+	element( indexNode ) {
+
+		return storageElement( this, indexNode );
+
+	}
+
+	setBufferObject( value ) {
+
+		this.bufferObject = value;
+
+		return this;
+
+	}
+
+	setAccess( value ) {
+
+		this.access = value;
+
+		return this;
+
+	}
+
+	toReadOnly() {
+
+		return this.setAccess( GPUBufferBindingType.ReadOnlyStorage );
+
+	}
+
+	setAtomic( value ) {
+
+		this.isAtomic = value;
+
+		return this;
+
+	}
+
+	toAtomic() {
+
+		return this.setAtomic( true );
+
+	}
+
+	generate( builder ) {
+
+		if ( builder.isAvailable( 'storageBuffer' ) ) {
+
+			return super.generate( builder );
+
+		}
+
+		const nodeType = this.getNodeType( builder );
+
+		if ( this._attribute === null ) {
+
+			this._attribute = bufferAttribute( this.value );
+			this._varying = varying( this._attribute );
+
+		}
+
+
+		const output = this._varying.build( builder, nodeType );
+
+		builder.registerTransform( output, this._attribute );
+
+		return output;
+
+	}
+
+}
+
+export default StorageBufferNode;
+
+// Read-Write Storage
+export const storage = ( value, type, count ) => nodeObject( new StorageBufferNode( value, type, count ) );
+export const storageObject = ( value, type, count ) => nodeObject( new StorageBufferNode( value, type, count ).setBufferObject( true ) );

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

@@ -1,8 +1,14 @@
-import { addNodeClass } from '../core/Node.js';
 import TextureNode from './TextureNode.js';
-import { nodeProxy } from '../shadernode/ShaderNode.js';
+import { nodeProxy } from '../tsl/TSLBase.js';
+import { GPUStorageTextureAccess } from '../../renderers/webgpu/utils/WebGPUConstants.js';
 
-class TextureStoreNode extends TextureNode {
+class StorageTextureNode extends TextureNode {
+
+	static get type() {
+
+		return 'StorageTextureNode';
+
+	}
 
 	constructor( value, uvNode, storeNode = null ) {
 
@@ -10,7 +16,9 @@ class TextureStoreNode extends TextureNode {
 
 		this.storeNode = storeNode;
 
-		this.isStoreTextureNode = true;
+		this.isStorageTextureNode = true;
+
+		this.access = GPUStorageTextureAccess.WriteOnly;
 
 	}
 
@@ -29,6 +37,13 @@ class TextureStoreNode extends TextureNode {
 
 	}
 
+	setAccess( value ) {
+
+		this.access = value;
+		return this;
+
+	}
+
 	generate( builder, output ) {
 
 		let snippet;
@@ -47,6 +62,18 @@ class TextureStoreNode extends TextureNode {
 
 	}
 
+	toReadOnly() {
+
+		return this.setAccess( GPUStorageTextureAccess.ReadOnly );
+
+	}
+
+	toWriteOnly() {
+
+		return this.setAccess( GPUStorageTextureAccess.WriteOnly );
+
+	}
+
 	generateStore( builder ) {
 
 		const properties = builder.getNodeProperties( this );
@@ -59,24 +86,22 @@ class TextureStoreNode extends TextureNode {
 
 		const snippet = builder.generateTextureStore( builder, textureProperty, uvSnippet, storeSnippet );
 
-		builder.addLineFlowCode( snippet );
+		builder.addLineFlowCode( snippet, this );
 
 	}
 
 }
 
-export default TextureStoreNode;
+export default StorageTextureNode;
 
-const textureStoreBase = nodeProxy( TextureStoreNode );
+export const storageTexture = /*@__PURE__*/ nodeProxy( StorageTextureNode );
 
 export const textureStore = ( value, uvNode, storeNode ) => {
 
-	const node = textureStoreBase( value, uvNode, storeNode );
+	const node = storageTexture( value, uvNode, storeNode );
 
 	if ( storeNode !== null ) node.append();
 
 	return node;
 
 };
-
-addNodeClass( 'TextureStoreNode', TextureStoreNode );

package/src/nodes/accessors/Tangent.js

@@ -0,0 +1,22 @@
+import { attribute } from '../core/AttributeNode.js';
+import { cameraViewMatrix } from './Camera.js';
+import { modelViewMatrix } from './ModelNode.js';
+import { Fn, vec4 } from '../tsl/TSLBase.js';
+
+export const tangentGeometry = /*@__PURE__*/ Fn( ( builder ) => {
+
+	if ( builder.geometry.hasAttribute( 'tangent' ) === false ) {
+
+		builder.geometry.computeTangents();
+
+	}
+
+	return attribute( 'tangent', 'vec4' );
+
+} )();
+
+export const tangentLocal = /*@__PURE__*/ tangentGeometry.xyz.toVar( 'tangentLocal' );
+export const tangentView = /*@__PURE__*/ modelViewMatrix.mul( vec4( tangentLocal, 0 ) ).xyz.varying( 'v_tangentView' ).normalize().toVar( 'tangentView' );
+export const tangentWorld = /*@__PURE__*/ tangentView.transformDirection( cameraViewMatrix ).varying( 'v_tangentWorld' ).normalize().toVar( 'tangentWorld' );
+export const transformedTangentView = /*@__PURE__*/ tangentView.toVar( 'transformedTangentView' );
+export const transformedTangentWorld = /*@__PURE__*/ transformedTangentView.transformDirection( cameraViewMatrix ).normalize().toVar( 'transformedTangentWorld' );

package/src/nodes/accessors/Texture3DNode.js

@@ -0,0 +1,103 @@
+import TextureNode from './TextureNode.js';
+import { nodeProxy, vec3, Fn, If } from '../tsl/TSLBase.js';
+
+const normal = Fn( ( { texture, uv } ) => {
+
+	const epsilon = 0.0001;
+
+	const ret = vec3().toVar();
+
+	If( uv.x.lessThan( epsilon ), () => {
+
+		ret.assign( vec3( 1, 0, 0 ) );
+
+	} ).ElseIf( uv.y.lessThan( epsilon ), () => {
+
+		ret.assign( vec3( 0, 1, 0 ) );
+
+	} ).ElseIf( uv.z.lessThan( epsilon ), () => {
+
+		ret.assign( vec3( 0, 0, 1 ) );
+
+	} ).ElseIf( uv.x.greaterThan( 1 - epsilon ), () => {
+
+		ret.assign( vec3( - 1, 0, 0 ) );
+
+	} ).ElseIf( uv.y.greaterThan( 1 - epsilon ), () => {
+
+		ret.assign( vec3( 0, - 1, 0 ) );
+
+	} ).ElseIf( uv.z.greaterThan( 1 - epsilon ), () => {
+
+		ret.assign( vec3( 0, 0, - 1 ) );
+
+	} ).Else( () => {
+
+		const step = 0.01;
+
+		const x = texture.uv( uv.add( vec3( - step, 0.0, 0.0 ) ) ).r.sub( texture.uv( uv.add( vec3( step, 0.0, 0.0 ) ) ).r );
+		const y = texture.uv( uv.add( vec3( 0.0, - step, 0.0 ) ) ).r.sub( texture.uv( uv.add( vec3( 0.0, step, 0.0 ) ) ).r );
+		const z = texture.uv( uv.add( vec3( 0.0, 0.0, - step ) ) ).r.sub( texture.uv( uv.add( vec3( 0.0, 0.0, step ) ) ).r );
+
+		ret.assign( vec3( x, y, z ) );
+
+	} );
+
+	return ret.normalize();
+
+} );
+
+
+class Texture3DNode extends TextureNode {
+
+	static get type() {
+
+		return 'Texture3DNode';
+
+	}
+
+	constructor( value, uvNode = null, levelNode = null ) {
+
+		super( value, uvNode, levelNode );
+
+		this.isTexture3DNode = true;
+
+	}
+
+	getInputType( /*builder*/ ) {
+
+		return 'texture3D';
+
+	}
+
+	getDefaultUV() {
+
+		return vec3( 0.5, 0.5, 0.5 );
+
+	}
+
+	setUpdateMatrix( /*updateMatrix*/ ) { } // Ignore .updateMatrix for 3d TextureNode
+
+	setupUV( builder, uvNode ) {
+
+		return uvNode;
+
+	}
+
+	generateUV( builder, uvNode ) {
+
+		return uvNode.build( builder, 'vec3' );
+
+	}
+
+	normal( uvNode ) {
+
+		return normal( { texture: this, uv: uvNode } );
+
+	}
+
+}
+
+export default Texture3DNode;
+
+export const texture3D = /*@__PURE__*/ nodeProxy( Texture3DNode );

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

@@ -1,8 +1,6 @@
-import TempNode from '../core/TempNode.js';
-import { addNodeClass } from '../core/Node.js';
 import { add, mul, div } from '../math/OperatorNode.js';
 import { floor, ceil, fract, pow } from '../math/MathNode.js';
-import { nodeProxy, addNodeElement, float, vec2, vec4, int } from '../shadernode/ShaderNode.js';
+import { Fn, float, vec2, vec4, int } from '../tsl/TSLBase.js';
 
 // Mipped Bicubic Texture Filtering by N8
 // https://www.shadertoy.com/view/Dl2SDW
@@ -53,7 +51,7 @@ const bicubic = ( textureNode, texelSize, lod ) => {
 
 };
 
-const textureBicubicMethod = ( textureNode, lodNode ) => {
+export const textureBicubic = /*@__PURE__*/ Fn( ( [ textureNode, lodNode = float( 3 ) ] ) => {
 
 	const fLodSize = vec2( textureNode.size( int( lodNode ) ) );
 	const cLodSize = vec2( textureNode.size( int( lodNode.add( 1.0 ) ) ) );
@@ -64,31 +62,4 @@ const textureBicubicMethod = ( textureNode, lodNode ) => {
 
 	return fract( lodNode ).mix( fSample, cSample );
 
-};
-
-class TextureBicubicNode extends TempNode {
-
-	constructor( textureNode, blurNode = float( 3 ) ) {
-
-		super( 'vec4' );
-
-		this.textureNode = textureNode;
-		this.blurNode = blurNode;
-
-	}
-
-	setup() {
-
-		return textureBicubicMethod( this.textureNode, this.blurNode );
-
-	}
-
-}
-
-export default TextureBicubicNode;
-
-export const textureBicubic = nodeProxy( TextureBicubicNode );
-
-addNodeElement( 'bicubic', textureBicubic );
-
-addNodeClass( 'TextureBicubicNode', TextureBicubicNode );
+} );