@unikia/upe-renderer 0.186.110 → 0.187.11

package/src/nodes/accessors/Instance.js

@@ -1,21 +1,23 @@
 
 import { vec3, mat4, Fn } from '../tsl/TSLBase.js';
-import { OnAfterObjectUpdate, OnBeforeObjectUpdate } from '../utils/EventNode.js';
+import { OnAfterObjectUpdate } from '../utils/EventNode.js';
 import { normalLocal, transformNormal } from './Normal.js';
 import { positionLocal, positionPrevious } from './Position.js';
 import { varyingProperty } from '../core/PropertyNode.js';
 import { instancedBufferAttribute, instancedDynamicBufferAttribute } from './BufferAttributeNode.js';
+import ReferenceAttributeNode, { referenceAttribute } from './ReferenceAttributeNode.js';
 import { buffer } from './BufferNode.js';
 import { storage } from './StorageBufferNode.js';
 import { instanceIndex } from '../core/IndexNode.js';
 
-import { InstancedInterleavedBuffer } from '../../core/InstancedInterleavedBuffer.js';
-import { InstancedBufferAttribute } from '../../core/InstancedBufferAttribute.js';
+import { InterleavedBufferAttribute } from '../../core/InterleavedBufferAttribute.js';
 import { DynamicDrawUsage } from '../../constants.js';
 
-const _matrixBuffers = /*@__PURE__*/ new WeakMap();
-const _colorBuffers = /*@__PURE__*/ new WeakMap();
 const _previousInstanceMatrices = /*@__PURE__*/ new WeakMap();
+const _previousMatrices = /*@__PURE__*/ new WeakMap();
+
+// The default limit of vertex buffers in WebGPU.
+const MAX_VERTEX_BUFFERS = 8;
 
 /**
  * The most instance matrices may take in a uniform buffer, in bytes: WebGPU's default limit (64 KB,
@@ -31,84 +33,6 @@ function instanceUniformLimit( builder ) {
 
 }
 
-/**
- * What of each instance buffer's source is on the GPU: the source version it was last synced from,
- * and how many of its values are current there.
- *
- * @type {WeakMap<Object, {version: number, end: number}>}
- */
-const _uploaded = /*@__PURE__*/ new WeakMap();
-
-/**
- * Brings the GPU copy of an instance attribute (`target`) up to date with `source`, the instanced
- * mesh's own attribute. A change with no update ranges sends only the instances the mesh draws
- * (`count`), not the whole capacity: a culler that refills a prefix every frame sends that prefix.
- * The rest follows when the mesh comes to draw more of them.
- *
- * @param {BufferAttribute|InterleavedBuffer} target - What the GPU reads.
- * @param {BufferAttribute} source - The mesh's attribute.
- * @param {?Object3D} mesh - The instanced mesh, if it is one.
- */
-function syncInstances( target, source, mesh ) {
-
-	const length = source.array.length;
-	const drawn = mesh !== null && mesh.isInstancedMesh === true ? Math.min( mesh.count, source.count ) * source.itemSize : length;
-
-	let uploaded = _uploaded.get( target );
-
-	if ( uploaded === undefined ) {
-
-		// The first upload of a buffer sends all of it.
-		uploaded = { version: target.version, end: length };
-		_uploaded.set( target, uploaded );
-
-	}
-
-	if ( uploaded.version !== source.version ) {
-
-		target.clearUpdateRanges();
-
-		if ( drawn === 0 && source.updateRanges.length === 0 ) {
-
-			// Nothing drawn: nothing to send until there is (no update ranges would mean all of it).
-			uploaded.version = source.version;
-			uploaded.end = 0;
-			return;
-
-		}
-
-		if ( source.updateRanges.length > 0 ) {
-
-			target.updateRanges.push( ...source.updateRanges );
-
-		} else if ( drawn < length ) {
-
-			target.addUpdateRange( 0, drawn );
-			uploaded.end = drawn;
-
-		} else {
-
-			uploaded.end = length;
-
-		}
-
-		source.clearUpdateRanges(); // the source is never uploaded directly: clear to avoid update range accumulation
-
-		uploaded.version = source.version;
-		target.version ++; // only ever up, so the upload can't be skipped by a version that matches by chance
-
-	} else if ( uploaded.end < drawn ) {
-
-		// Drawing more than was sent: send the rest, as it stands now.
-		target.clearUpdateRanges();
-		target.addUpdateRange( uploaded.end, drawn - uploaded.end );
-		uploaded.end = drawn;
-		target.version ++;
-
-	}
-
-}
-
 /**
  * Creates the appropriate node for instanced matrix transformations.
  * Depending on buffer limits and storage capability, returns either a storage, buffer, or instanced interleaved attribute node.
@@ -142,23 +66,11 @@ function createInstanceMatrixNode( builder, instanceMatrix ) {
 
 		} else {
 
-			let interleaved = _matrixBuffers.get( instanceMatrix );
-
-			if ( ! interleaved ) {
-
-				interleaved = new InstancedInterleavedBuffer( instanceMatrix.array, 16, 1 );
-				_matrixBuffers.set( instanceMatrix, interleaved );
-
-			}
+			// the columns view the matrices, so both share the same GPU buffer which is freed via instanceMatrix.dispose()
 
 			const bufferFn = instanceMatrix.usage === DynamicDrawUsage ? instancedDynamicBufferAttribute : instancedBufferAttribute;
 
-			const instanceBuffers = [
-				bufferFn( interleaved, 'vec4', 16, 0 ),
-				bufferFn( interleaved, 'vec4', 16, 4 ),
-				bufferFn( interleaved, 'vec4', 16, 8 ),
-				bufferFn( interleaved, 'vec4', 16, 12 )
-			];
+			const instanceBuffers = [ 0, 4, 8, 12 ].map( ( offset ) => bufferFn( new InterleavedBufferAttribute( instanceMatrix, 4, offset ) ) );
 
 			instanceMatrixNode = mat4( ...instanceBuffers );
 
@@ -194,6 +106,8 @@ function getPreviousInstance( instancedMesh, instanceMatrix, builder ) {
 
 		_previousInstanceMatrices.set( instancedMesh, data );
 
+		instancedMesh.addEventListener( 'dispose', onPreviousInstanceDispose );
+
 	}
 
 	return data.node;
@@ -201,128 +115,218 @@ function getPreviousInstance( instancedMesh, instanceMatrix, builder ) {
 }
 
 /**
- * TSL object representing a varying property for the instanced color vector.
+ * Frees the GPU buffer of the previous frame instance matrices when the mesh is disposed.
+ * The matrices are kept since the node refers to them, rendering the mesh again re-creates the buffer.
  *
- * @type {VaryingNode<vec3>}
+ * @param {Object} event - The dispose event.
  */
-export const instanceColor = /*@__PURE__*/ varyingProperty( 'vec3', 'vInstanceColor' );
+function onPreviousInstanceDispose( { target: object } ) {
+
+	_previousInstanceMatrices.get( object ).previousInstanceMatrix.dispose();
+
+}
 
 /**
- * TSL function representing the standard instancing vertex shader setup.
- * Transforms positionLocal and normalLocal, and assigns varying color in-place.
+ * Returns the instance matrices of the previous frame of the given mesh, for motion vectors.
  *
- * @tsl
- * @function
- * @param {InstancedBufferAttribute|StorageInstancedBufferAttribute} matrices - The instanced transformation matrices.
- * @param {?InstancedBufferAttribute|StorageInstancedBufferAttribute} [colors=null] - The optional instanced colors.
+ * @param {InstancedMesh} object - The instanced mesh.
+ * @returns {InstancedBufferAttribute} The matrices of the previous frame.
  */
-export const instance = /*@__PURE__*/ Fn( ( [ matrices, colors = null ], builder ) => {
+function getPreviousMatrix( object ) {
 
-	const isStorageMatrix = matrices.isStorageInstancedBufferAttribute === true;
-	const isStorageColor = colors && colors.isStorageInstancedBufferAttribute === true;
+	const matrices = object.instanceMatrix;
 
-	const instanceMatrixNode = createInstanceMatrixNode( builder, matrices );
+	let previous = _previousMatrices.get( object );
 
-	// interleaved buffer tracking for matrix
-	let interleavedMatrix = null;
+	if ( previous === undefined || previous.count !== matrices.count ) {
 
-	if ( ! isStorageMatrix ) {
+		if ( previous === undefined ) {
 
-		const uniformBufferSize = Math.max( matrices.count, 1 ) * 16 * 4;
+			object.addEventListener( 'dispose', onPreviousMatrixDispose );
 
-		if ( uniformBufferSize > instanceUniformLimit( builder ) ) {
+		} else {
 
-			interleavedMatrix = _matrixBuffers.get( matrices );
+			previous.dispose();
 
 		}
 
+		previous = matrices.clone();
+
+		_previousMatrices.set( object, previous );
+
 	}
 
-	let instanceColorNode = null;
-	let interleavedColor = null;
+	return previous;
 
-	if ( colors ) {
+}
 
-		if ( isStorageColor ) {
+/**
+ * Disposes the instance matrices of the previous frame when the mesh is disposed.
+ *
+ * @param {Object} event - The dispose event.
+ */
+function onPreviousMatrixDispose( { target: object } ) {
 
-			instanceColorNode = storage( colors, 'vec3', Math.max( colors.count, 1 ) ).element( instanceIndex );
+	object.removeEventListener( 'dispose', onPreviousMatrixDispose );
 
-		} else {
+	_previousMatrices.get( object ).dispose();
+	_previousMatrices.delete( object );
 
-			let bufferAttribute = _colorBuffers.get( colors );
+}
 
-			if ( ! bufferAttribute ) {
+/**
+ * Binds the instance matrices of the previous frame of the rendered mesh.
+ *
+ * @private
+ * @augments ReferenceAttributeNode
+ */
+class PreviousInstanceMatrixNode extends ReferenceAttributeNode {
 
-				bufferAttribute = new InstancedBufferAttribute( colors.array, 3 );
-				_colorBuffers.set( colors, bufferAttribute );
+	static get type() {
 
-			}
+		return 'PreviousInstanceMatrixNode';
 
-			interleavedColor = bufferAttribute;
+	}
 
-			const bufferFn = colors.usage === DynamicDrawUsage ? instancedDynamicBufferAttribute : instancedBufferAttribute;
+	/**
+	 * Constructs a new previous instance matrix node.
+	 */
+	constructor() {
 
-			instanceColorNode = vec3( bufferFn( bufferAttribute, 'vec3', 3, 0 ) );
+		super( 'previousInstanceMatrix', 'mat4' );
 
-		}
+	}
+
+	/**
+	 * Returns the instance matrices of the previous frame of the given mesh.
+	 *
+	 * @param {InstancedMesh} object - The instanced mesh.
+	 * @return {InstancedBufferAttribute} The matrices of the previous frame.
+	 */
+	getValueFromReference( object ) {
+
+		return getPreviousMatrix( object );
 
 	}
 
-	// Synchronization of dynamic buffer updates per frame.
-	if ( interleavedMatrix !== null || interleavedColor !== null ) {
+}
 
-		const mesh = builder.object || null;
+/**
+ * Returns `true` if the build can bind the instance data of the rendered mesh, so it can
+ * be shared between instanced meshes.
+ *
+ * @param {InstancedMesh} object - The instanced mesh.
+ * @param {NodeBuilder} builder - The current node builder.
+ * @returns {boolean} Whether the build can bind the instance data of the rendered mesh.
+ */
+function canReferenceInstanceData( object, builder ) {
 
-		// Before each draw, not once a frame: a mesh can draw more instances in the next render of the
-		// same frame, and those have to be sent first.
-		OnBeforeObjectUpdate( () => {
+	// only render objects bind attributes per object
 
-			if ( interleavedMatrix !== null ) syncInstances( interleavedMatrix, matrices, mesh );
+	if ( builder.renderer.isRenderer !== true ) return false;
 
-			if ( colors && interleavedColor !== null ) syncInstances( interleavedColor, colors, mesh );
+	// the instance data take up to three vertex buffers next to the ones of the geometry
 
-		} );
+	const instanceBuffers = 1 + ( object.instanceColor !== null ? 1 : 0 ) + ( builder.needsPreviousData() ? 1 : 0 );
 
-	}
+	return Object.keys( object.geometry.attributes ).length + instanceBuffers <= MAX_VERTEX_BUFFERS;
+
+}
+
+/**
+ * Transforms the position, the previous position and the normal with the given instance matrices.
+ *
+ * @param {NodeBuilder} builder - The current node builder.
+ * @param {Node<mat4>} instanceMatrixNode - The instance matrix.
+ * @param {?Node<mat4>} previousMatrixNode - The instance matrix of the previous frame, if motion vectors are needed.
+ */
+function transformInstance( builder, instanceMatrixNode, previousMatrixNode ) {
 
 	// POSITION
 
 	const instancePosition = instanceMatrixNode.mul( positionLocal ).xyz;
 	positionLocal.assign( instancePosition );
 
-	if ( builder.needsPreviousData() ) {
+	if ( previousMatrixNode !== null ) {
 
-		const instancedMesh = builder.object;
+		positionPrevious.assign( previousMatrixNode.mul( positionPrevious ).xyz );
 
-		OnAfterObjectUpdate( ( { object } ) => {
+	}
 
-			const { previousInstanceMatrix } = _previousInstanceMatrices.get( object );
+	// NORMAL
 
-			previousInstanceMatrix.array.set( matrices.array );
-			previousInstanceMatrix.version = matrices.version;
+	if ( builder.hasGeometryAttribute( 'normal' ) ) {
 
-			// handle interleaved path
+		const instanceNormal = transformNormal( normalLocal, instanceMatrixNode );
+		normalLocal.assign( instanceNormal );
 
-			const previousInterleavedMatrix = _matrixBuffers.get( previousInstanceMatrix );
+	}
 
-			if ( previousInterleavedMatrix !== undefined ) previousInterleavedMatrix.version = matrices.version;
+}
 
-		} );
+/**
+ * TSL object representing a varying property for the instanced color vector.
+ *
+ * @type {VaryingNode<vec3>}
+ */
+export const instanceColor = /*@__PURE__*/ varyingProperty( 'vec3', 'vInstanceColor' );
+
+/**
+ * TSL function representing the standard instancing vertex shader setup.
+ * Transforms positionLocal and normalLocal, and assigns varying color in-place.
+ *
+ * @tsl
+ * @function
+ * @param {InstancedBufferAttribute|StorageInstancedBufferAttribute} matrices - The instanced transformation matrices.
+ * @param {?InstancedBufferAttribute|StorageInstancedBufferAttribute} [colors=null] - The optional instanced colors.
+ */
+export const instance = /*@__PURE__*/ Fn( ( [ matrices, colors = null ], builder ) => {
+
+	const isStorageColor = colors && colors.isStorageInstancedBufferAttribute === true;
+
+	const instanceMatrixNode = createInstanceMatrixNode( builder, matrices );
+
+	let instanceColorNode = null;
+
+	if ( colors ) {
+
+		if ( isStorageColor ) {
+
+			instanceColorNode = storage( colors, 'vec3', Math.max( colors.count, 1 ) ).element( instanceIndex );
+
+		} else {
+
+			// bound directly, so the GPU buffer is freed via instanceColor.dispose()
+
+			const bufferFn = colors.usage === DynamicDrawUsage ? instancedDynamicBufferAttribute : instancedBufferAttribute;
 
-		const previousInstanceMatrixNode = getPreviousInstance( instancedMesh, matrices, builder );
-		positionPrevious.assign( previousInstanceMatrixNode.mul( positionPrevious ).xyz );
+			instanceColorNode = vec3( bufferFn( colors ) );
+
+		}
 
 	}
 
-	// NORMAL
+	let previousInstanceMatrixNode = null;
 
-	if ( builder.hasGeometryAttribute( 'normal' ) ) {
+	if ( builder.needsPreviousData() ) {
 
-		const instanceNormal = transformNormal( normalLocal, instanceMatrixNode );
-		normalLocal.assign( instanceNormal );
+		const instancedMesh = builder.object;
+
+		OnAfterObjectUpdate( ( { object } ) => {
+
+			const { previousInstanceMatrix } = _previousInstanceMatrices.get( object );
+
+			previousInstanceMatrix.array.set( matrices.array );
+			previousInstanceMatrix.version = matrices.version;
+
+		} );
+
+		previousInstanceMatrixNode = getPreviousInstance( instancedMesh, matrices, builder );
 
 	}
 
+	transformInstance( builder, instanceMatrixNode, previousInstanceMatrixNode );
+
 	// COLOR
 
 	if ( instanceColorNode !== null ) {
@@ -336,14 +340,48 @@ export const instance = /*@__PURE__*/ Fn( ( [ matrices, colors = null ], builder
 /**
  * TSL wrapper for applying instanced mesh rendering setup.
  *
+ * The instance data of the rendered mesh are bound per object via {@link ReferenceAttributeNode},
+ * so instanced meshes share builds.
+ *
  * @tsl
  * @function
  * @param {InstancedMesh} instancedMesh - The instanced mesh.
  */
-export const instancedMesh = /*@__PURE__*/ Fn( ( [ instancedMesh ] ) => {
+export const instancedMesh = /*@__PURE__*/ Fn( ( [ instancedMesh ], builder ) => {
+
+	if ( canReferenceInstanceData( instancedMesh, builder ) ) {
+
+		let previousInstanceMatrixNode = null;
+
+		if ( builder.needsPreviousData() ) {
+
+			OnAfterObjectUpdate( ( { object } ) => {
+
+				const previous = getPreviousMatrix( object );
+
+				previous.array.set( object.instanceMatrix.array );
+				previous.version = object.instanceMatrix.version;
+
+			} );
+
+			previousInstanceMatrixNode = new PreviousInstanceMatrixNode();
 
-	const { instanceMatrix, instanceColor } = instancedMesh;
+		}
+
+		transformInstance( builder, referenceAttribute( 'instanceMatrix', 'mat4' ), previousInstanceMatrixNode );
+
+		if ( instancedMesh.instanceColor !== null ) {
+
+			instanceColor.assign( referenceAttribute( 'instanceColor', 'vec3' ) );
+
+		}
 
-	instance( instanceMatrix, instanceColor );
+	} else {
+
+		builder.objectSpecific = true;
+
+		instance( instancedMesh.instanceMatrix, instancedMesh.instanceColor );
+
+	}
 
 }, 'void' );

package/src/nodes/accessors/Lights.js

@@ -1,6 +1,7 @@
 import { uniform } from '../core/UniformNode.js';
 import { renderGroup } from '../core/UniformGroupNode.js';
 import { Vector3 } from '../../math/Vector3.js';
+import { Fn, vec4 } from '../tsl/TSLBase.js';
 import { cameraViewMatrix } from './Camera.js';
 import { positionWorld } from './Position.js';
 
@@ -111,20 +112,32 @@ export function lightTargetPosition( light ) {
  * @tsl
  * @function
  * @param {Light} light - The light source.
- * @returns {UniformNode<vec3>} The light's position in view space.
+ * @returns {Node<vec3>} The light's position in view space.
  */
 export function lightViewPosition( light ) {
 
 	const data = getLightData( light );
 
-	return data.viewPosition || ( data.viewPosition = uniform( new Vector3() ).setGroup( renderGroup ).onRenderUpdate( ( { camera }, self ) => {
+	return data.viewPosition || ( data.viewPosition = ( Fn( ( { camera } ) => {
 
-		self.value = self.value || new Vector3();
-		self.value.setFromMatrixPosition( light.matrixWorld );
+		// Each sub-camera of an array camera has its own view space.
 
-		self.value.applyMatrix4( camera.matrixWorldInverse );
+		if ( camera.isArrayCamera && camera.cameras.length > 0 ) {
 
-	} ) );
+			return cameraViewMatrix.mul( vec4( lightPosition( light ), 1 ) ).xyz;
+
+		}
+
+		return data.viewPositionUniform || ( data.viewPositionUniform = uniform( new Vector3() ).setGroup( renderGroup ).onRenderUpdate( ( { camera }, self ) => {
+
+			self.value = self.value || new Vector3();
+			self.value.setFromMatrixPosition( light.matrixWorld );
+
+			self.value.applyMatrix4( camera.matrixWorldInverse );
+
+		} ) );
+
+	} ).once() )() );
 
 }
 

package/src/nodes/accessors/MaterialNode.js

@@ -1,5 +1,4 @@
 import Node from '../core/Node.js';
-import { reference } from './ReferenceNode.js';
 import { materialReference } from './MaterialReferenceNode.js';
 import { normalView } from './Normal.js';
 import { nodeImmutable, float, vec2, vec3, mat2 } from '../tsl/TSLBase.js';
@@ -46,6 +45,12 @@ class MaterialNode extends Node {
 
 	}
 
+	isCacheable( /*builder*/ ) {
+
+		return false;
+
+	}
+
 	/**
 	 * Returns a cached reference node for the given property and type.
 	 *
@@ -201,6 +206,20 @@ class MaterialNode extends Node {
 
 			}
 
+		} else if ( scope === MaterialNode.DIFFUSE_ROUGHNESS ) {
+
+			const diffuseRoughnessNode = this.getFloat( scope );
+
+			if ( material.diffuseRoughnessMap && material.diffuseRoughnessMap.isTexture === true ) {
+
+				node = diffuseRoughnessNode.mul( this.getTexture( scope ).r );
+
+			} else {
+
+				node = diffuseRoughnessNode;
+
+			}
+
 		} else if ( scope === MaterialNode.METALNESS ) {
 
 			const metalnessNode = this.getFloat( scope );
@@ -273,7 +292,7 @@ class MaterialNode extends Node {
 
 			if ( material.clearcoatRoughnessMap && material.clearcoatRoughnessMap.isTexture === true ) {
 
-				node = clearcoatRoughnessNode.mul( this.getTexture( scope ).r );
+				node = clearcoatRoughnessNode.mul( this.getTexture( scope ).g );
 
 			} else {
 
@@ -340,11 +359,11 @@ class MaterialNode extends Node {
 
 		} else if ( scope === MaterialNode.IRIDESCENCE_THICKNESS ) {
 
-			const iridescenceThicknessMaximum = reference( '1', 'float', material.iridescenceThicknessRange );
+			const iridescenceThicknessMaximum = this.getFloat( 'iridescenceThicknessMaximum' );
 
 			if ( material.iridescenceThicknessMap ) {
 
-				const iridescenceThicknessMinimum = reference( '0', 'float', material.iridescenceThicknessRange );
+				const iridescenceThicknessMinimum = this.getFloat( 'iridescenceThicknessMinimum' );
 
 				node = iridescenceThicknessMaximum.sub( iridescenceThicknessMinimum ).mul( this.getTexture( scope ).g ).add( iridescenceThicknessMinimum );
 
@@ -438,6 +457,7 @@ MaterialNode.SPECULAR_INTENSITY = 'specularIntensity';
 MaterialNode.SPECULAR_COLOR = 'specularColor';
 MaterialNode.REFLECTIVITY = 'reflectivity';
 MaterialNode.ROUGHNESS = 'roughness';
+MaterialNode.DIFFUSE_ROUGHNESS = 'diffuseRoughness';
 MaterialNode.METALNESS = 'metalness';
 MaterialNode.NORMAL = 'normal';
 MaterialNode.CLEARCOAT = 'clearcoat';
@@ -564,6 +584,15 @@ export const materialReflectivity = /*@__PURE__*/ nodeImmutable( MaterialNode, M
  */
 export const materialRoughness = /*@__PURE__*/ nodeImmutable( MaterialNode, MaterialNode.ROUGHNESS );
 
+/**
+ * TSL object that represents the diffuse roughness of the current material.
+ * The value is composed via `diffuseRoughness` * `diffuseRoughnessMap.r`.
+ *
+ * @tsl
+ * @type {Node<float>}
+ */
+export const materialDiffuseRoughness = /*@__PURE__*/ nodeImmutable( MaterialNode, MaterialNode.DIFFUSE_ROUGHNESS );
+
 /**
  * TSL object that represents the metalness of the current material.
  * The value is composed via `metalness` * `metalnessMap.b`.