super-three 0.165.0 → 0.168.0

package/src/nodes/accessors/SkinningNode.js

@@ -0,0 +1,187 @@
+import Node, { registerNode } 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 {
+
+	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;
+
+SkinningNode.type = /*@__PURE__*/ registerNode( 'Skinning', SkinningNode );
+
+export const skinning = ( skinnedMesh ) => nodeObject( new SkinningNode( skinnedMesh ) );
+export const skinningReference = ( skinnedMesh ) => nodeObject( new SkinningNode( skinnedMesh, true ) );

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

@@ -1,9 +1,9 @@
+import { registerNode } from '../core/Node.js';
 import BufferNode from './BufferNode.js';
 import { bufferAttribute } from './BufferAttributeNode.js';
-import { addNodeClass } from '../core/Node.js';
-import { nodeObject } from '../shadernode/ShaderNode.js';
-import { varying } from '../core/VaryingNode.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 {
 
@@ -13,11 +13,16 @@ class StorageBufferNode extends BufferNode {
 
 		this.isStorageBufferNode = true;
 
+		this.access = GPUBufferBindingType.Storage;
+
 		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
@@ -29,6 +34,30 @@ class StorageBufferNode extends BufferNode {
 
 	}
 
+	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';
@@ -49,9 +78,27 @@ class StorageBufferNode extends BufferNode {
 
 	}
 
+	setAccess( value ) {
+
+		this.access = value;
+
+		return this;
+
+	}
+
+	toReadOnly() {
+
+		return this.setAccess( GPUBufferBindingType.ReadOnlyStorage );
+
+	}
+
 	generate( builder ) {
 
-		if ( builder.isAvailable( 'storageBuffer' ) ) return super.generate( builder );
+		if ( builder.isAvailable( 'storageBuffer' ) ) {
+
+			return super.generate( builder );
+
+		}
 
 		const nodeType = this.getNodeType( builder );
 
@@ -75,7 +122,8 @@ class StorageBufferNode extends BufferNode {
 
 export default StorageBufferNode;
 
+StorageBufferNode.type = /*@__PURE__*/ registerNode( 'StorageBuffer', 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 ) );
-
-addNodeClass( 'StorageBufferNode', StorageBufferNode );

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

@@ -1,6 +1,6 @@
-import { addNodeClass } from '../core/Node.js';
+import { registerNode } 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 StorageTextureNode extends TextureNode {
@@ -57,6 +57,18 @@ class StorageTextureNode extends TextureNode {
 
 	}
 
+	toReadOnly() {
+
+		return this.setAccess( GPUStorageTextureAccess.ReadOnly );
+
+	}
+
+	toWriteOnly() {
+
+		return this.setAccess( GPUStorageTextureAccess.WriteOnly );
+
+	}
+
 	generateStore( builder ) {
 
 		const properties = builder.getNodeProperties( this );
@@ -77,10 +89,9 @@ class StorageTextureNode extends TextureNode {
 
 export default StorageTextureNode;
 
-export const storageTexture = nodeProxy( StorageTextureNode );
+StorageTextureNode.type = /*@__PURE__*/ registerNode( 'StorageTexture', StorageTextureNode );
 
-export const storageTextureReadOnly = ( value, uvNode, storeNode ) => storageTexture( value, uvNode, storeNode ).setAccess( 'read-only' );
-export const storageTextureReadWrite = ( value, uvNode, storeNode ) => storageTexture( value, uvNode, storeNode ).setAccess( 'read-write' );
+export const storageTexture = /*@__PURE__*/ nodeProxy( StorageTextureNode );
 
 export const textureStore = ( value, uvNode, storeNode ) => {
 
@@ -91,5 +102,3 @@ export const textureStore = ( value, uvNode, storeNode ) => {
 	return node;
 
 };
-
-addNodeClass( 'StorageTextureNode', StorageTextureNode );

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/{examples/jsm → src}/nodes/accessors/Texture3DNode.js

@@ -1,8 +1,8 @@
+import { registerNode } from '../core/Node.js';
 import TextureNode from './TextureNode.js';
-import { addNodeClass } from '../core/Node.js';
-import { nodeProxy, vec3, tslFn, If } from '../shadernode/ShaderNode.js';
+import { nodeProxy, vec3, Fn, If } from '../tsl/TSLBase.js';
 
-const normal = tslFn( ( { texture, uv } ) => {
+const normal = Fn( ( { texture, uv } ) => {
 
 	const epsilon = 0.0001;
 
@@ -12,27 +12,27 @@ const normal = tslFn( ( { texture, uv } ) => {
 
 		ret.assign( vec3( 1, 0, 0 ) );
 
-	} ).elseif( uv.y.lessThan( epsilon ), () => {
+	} ).ElseIf( uv.y.lessThan( epsilon ), () => {
 
 		ret.assign( vec3( 0, 1, 0 ) );
 
-	} ).elseif( uv.z.lessThan( epsilon ), () => {
+	} ).ElseIf( uv.z.lessThan( epsilon ), () => {
 
 		ret.assign( vec3( 0, 0, 1 ) );
 
-	} ).elseif( uv.x.greaterThan( 1 - epsilon ), () => {
+	} ).ElseIf( uv.x.greaterThan( 1 - epsilon ), () => {
 
 		ret.assign( vec3( - 1, 0, 0 ) );
 
-	} ).elseif( uv.y.greaterThan( 1 - epsilon ), () => {
+	} ).ElseIf( uv.y.greaterThan( 1 - epsilon ), () => {
 
 		ret.assign( vec3( 0, - 1, 0 ) );
 
-	} ).elseif( uv.z.greaterThan( 1 - epsilon ), () => {
+	} ).ElseIf( uv.z.greaterThan( 1 - epsilon ), () => {
 
 		ret.assign( vec3( 0, 0, - 1 ) );
 
-	} ).else( () => {
+	} ).Else( () => {
 
 		const step = 0.01;
 
@@ -95,6 +95,6 @@ class Texture3DNode extends TextureNode {
 
 export default Texture3DNode;
 
-export const texture3D = nodeProxy( Texture3DNode );
+Texture3DNode.type = /*@__PURE__*/ registerNode( 'Texture3D', Texture3DNode );
 
-addNodeClass( 'Texture3DNode', 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 );
+} );