@unikia/upe-renderer 0.186.110 → 0.187.11

package/src/renderers/common/Geometries.js

@@ -41,42 +41,46 @@ function getWireframeId( geometry ) {
  */
 function getWireframeIndex( geometry ) {
 
-	const indices = [];
-
 	const geometryIndex = geometry.index;
 	const geometryPosition = geometry.attributes.position;
+	const count = geometryIndex !== null ? geometryIndex.array.length : ( geometryPosition.array.length / 3 ) - 1;
+
+	const IndexBufferAttribute = geometryPosition.count >= 65535 ? Uint32BufferAttribute : Uint16BufferAttribute;
+	const attribute = new IndexBufferAttribute( Math.ceil( count / 3 ) * 6, 1 );
+	const indices = attribute.array;
 
 	if ( geometryIndex !== null ) {
 
 		const array = geometryIndex.array;
 
-		for ( let i = 0, l = array.length; i < l; i += 3 ) {
+		for ( let i = 0, j = 0; i < count; i += 3 ) {
 
 			const a = array[ i + 0 ];
 			const b = array[ i + 1 ];
 			const c = array[ i + 2 ];
 
-			indices.push( a, b, b, c, c, a );
+			indices[ j ++ ] = a; indices[ j ++ ] = b;
+			indices[ j ++ ] = b; indices[ j ++ ] = c;
+			indices[ j ++ ] = c; indices[ j ++ ] = a;
 
 		}
 
 	} else {
 
-		const array = geometryPosition.array;
-
-		for ( let i = 0, l = ( array.length / 3 ) - 1; i < l; i += 3 ) {
+		for ( let i = 0, j = 0; i < count; i += 3 ) {
 
 			const a = i + 0;
 			const b = i + 1;
 			const c = i + 2;
 
-			indices.push( a, b, b, c, c, a );
+			indices[ j ++ ] = a; indices[ j ++ ] = b;
+			indices[ j ++ ] = b; indices[ j ++ ] = c;
+			indices[ j ++ ] = c; indices[ j ++ ] = a;
 
 		}
 
 	}
 
-	const attribute = new ( geometryPosition.count >= 65535 ? Uint32BufferAttribute : Uint16BufferAttribute )( indices, 1 );
 	attribute.version = getWireframeVersion( geometry );
 	attribute.__id = getWireframeId( geometry );
 
@@ -84,6 +88,69 @@ function getWireframeIndex( geometry ) {
 
 }
 
+/**
+ * What of each instanced mesh's instance attribute is on the GPU: the version it was last sent at,
+ * and how many of its values were sent.
+ *
+ * @private
+ * @type {WeakMap<BufferAttribute, {version: number, end: number}>}
+ */
+const _sentInstances = /*@__PURE__*/ new WeakMap();
+
+/**
+ * Limits what goes to the GPU of an instanced mesh's `instanceMatrix` or `instanceColor` to the
+ * instances it draws (`count`), not its whole capacity: a change flagged without update ranges
+ * sends that prefix, so a culler refilling the first few hundred of thousands of slots sends those.
+ * When the mesh comes to draw more, the rest goes up before the draw, as it stands then.
+ *
+ * @private
+ * @param {BufferAttribute} attribute - The instance attribute.
+ * @param {InstancedMesh} mesh - The mesh drawing with it.
+ */
+function sendDrawnInstances( attribute, mesh ) {
+
+	const length = attribute.array.length;
+	const drawn = Math.min( mesh.count, attribute.count ) * attribute.itemSize;
+
+	let sent = _sentInstances.get( attribute );
+
+	if ( sent === undefined ) {
+
+		// The first upload sends all of it.
+		_sentInstances.set( attribute, { version: attribute.version, end: length } );
+		return;
+
+	}
+
+	if ( sent.version !== attribute.version ) {
+
+		sent.version = attribute.version;
+
+		if ( attribute.updateRanges.length > 0 ) return;
+
+		if ( drawn < length ) {
+
+			// The drawn prefix; with nothing drawn, an empty range rather than none (which sends all).
+			attribute.addUpdateRange( 0, drawn );
+			sent.end = drawn;
+
+		} else {
+
+			sent.end = length;
+
+		}
+
+	} else if ( sent.end < drawn ) {
+
+		attribute.clearUpdateRanges();
+		attribute.addUpdateRange( sent.end, drawn - sent.end );
+		sent.end = drawn;
+		sent.version = ++ attribute.version;
+
+	}
+
+}
+
 /**
  * This renderer module manages geometries.
  *
@@ -95,13 +162,21 @@ class Geometries extends DataMap {
 	/**
 	 * Constructs a new geometry management component.
 	 *
+	 * @param {Backend} backend - The renderer's backend.
 	 * @param {Attributes} attributes - Renderer component for managing attributes.
 	 * @param {Info} info - Renderer component for managing metrics and monitoring data.
 	 */
-	constructor( attributes, info ) {
+	constructor( backend, attributes, info ) {
 
 		super();
 
+		/**
+		 * The renderer's backend.
+		 *
+		 * @type {Backend}
+		 */
+		this.backend = backend;
+
 		/**
 		 * Renderer component for managing attributes.
 		 *
@@ -132,34 +207,32 @@ class Geometries extends DataMap {
 		this.attributeCall = new WeakMap();
 
 		/**
-		 * Stores the event listeners attached to geometries.
+		 * Stores weak references to the geometries with attached
+		 * `dispose` event listeners.
 		 *
 		 * @private
-		 * @type {Map<BufferGeometry,Function>}
+		 * @type {Set<WeakRef<BufferGeometry>>}
 		 */
-		this._geometryDisposeListeners = new Map();
+		this._tracked = new Set();
 
 		/**
-		 * The render objects drawing each geometry, kept as render objects are made, change geometry
-		 * and are disposed (never per draw), so disposing a geometry frees the node attributes of
-		 * every render object drawing it.
+		 * Removes weak references from `_tracked` when their geometry
+		 * has been garbage collected without an explicit `dispose()`.
 		 *
 		 * @private
-		 * @type {WeakMap<BufferGeometry,Set<RenderObject>>}
+		 * @type {FinalizationRegistry}
 		 */
-		this._users = new WeakMap();
+		this._registry = new FinalizationRegistry( ( ref ) => this._tracked.delete( ref ) );
 
 	}
 
 	/**
-	 * Returns `true` if the given render object has an initialized geometry.
+	 * Returns `true` if the given geometry is initialized.
 	 *
-	 * @param {RenderObject} renderObject - The render object.
-	 * @return {boolean} Whether if the given render object has an initialized geometry or not.
+	 * @param {BufferGeometry} geometry - The geometry.
+	 * @return {boolean} Whether if the given geometry is initialized or not.
 	 */
-	has( renderObject ) {
-
-		const geometry = renderObject.geometry;
+	has( geometry ) {
 
 		return super.has( geometry ) && this.get( geometry ).initialized === true;
 
@@ -172,37 +245,28 @@ class Geometries extends DataMap {
 	 */
 	updateForRender( renderObject ) {
 
-		if ( this.has( renderObject ) === false ) this.initGeometry( renderObject );
+		const geometry = renderObject.geometry;
+
+		if ( this.has( geometry ) === false ) this.initGeometry( geometry );
 
 		this.updateAttributes( renderObject );
 
 	}
 
 	/**
-	 * Initializes the geometry of the given render object.
+	 * Initializes the given geometry.
 	 *
-	 * @param {RenderObject} renderObject - The render object.
+	 * @param {BufferGeometry} geometry - The geometry.
 	 */
-	initGeometry( renderObject ) {
+	initGeometry( geometry ) {
 
-		const geometry = renderObject.geometry;
 		const geometryData = this.get( geometry );
 
 		geometryData.initialized = true;
 
 		this.info.memory.geometries ++;
 
-		// A geometry set up again keeps a single listener.
-
-		const previous = this._geometryDisposeListeners.get( geometry );
-
-		if ( previous !== undefined ) geometry.removeEventListener( 'dispose', previous );
-
-		// The listener holds the geometry and nothing drawn with it: holding the first render object
-		// (as three.js did) kept that object, and through its parents its whole scene, alive for as
-		// long as a shared geometry lived.
-
-		const onDispose = () => {
+		geometryData.onDispose = () => {
 
 			this.info.memory.geometries --;
 
@@ -220,7 +284,7 @@ class Geometries extends DataMap {
 
 			for ( const attribute of Object.values( geometry.attributes ) ) {
 
-				this.attributes.delete( attribute );
+				this.attributes.delete( this.backend.getBufferAttribute( attribute ) );
 
 			}
 
@@ -234,81 +298,24 @@ class Geometries extends DataMap {
 
 			}
 
-			// node attributes of the render objects drawing this geometry (`BufferAttribute.dispose()`
-			// and `Renderer.releaseObject()` free them one by one)
-
-			const users = this._users.get( geometry );
-
-			if ( users !== undefined ) {
-
-				const currentAttributes = new Set( Object.values( geometry.attributes ) );
-
-				for ( const renderObject of users ) {
-
-					// drawn ones only (render objects clear their attribute list on this same event,
-					// so it's built again from their node state)
-
-					if ( ! renderObject._nodeBuilderState ) continue;
-
-					for ( const attribute of renderObject.getAttributes() ) {
-
-						if ( currentAttributes.has( attribute ) === false ) {
-
-							this.attributes.delete( attribute );
-
-						}
-
-					}
-
-				}
-
-			}
-
 			//
 
-			geometry.removeEventListener( 'dispose', onDispose );
+			geometry.removeEventListener( 'dispose', geometryData.onDispose );
 
-			this._geometryDisposeListeners.delete( geometry );
+			this._tracked.delete( geometryData.ref );
+			this._registry.unregister( geometryData.ref );
 
 			this.delete( geometry );
 
 		};
 
-		geometry.addEventListener( 'dispose', onDispose );
+		geometry.addEventListener( 'dispose', geometryData.onDispose );
 
 		// see #31798 why tracking separate remove listeners is required right now
-		// TODO: Re-evaluate how onDispose() is managed in this component
-		this._geometryDisposeListeners.set( geometry, onDispose );
-
-	}
-
-	/**
-	 * Records that a render object draws a geometry.
-	 *
-	 * @param {RenderObject} renderObject - The render object.
-	 * @param {BufferGeometry} geometry - The geometry it draws.
-	 */
-	addUser( renderObject, geometry ) {
-
-		let users = this._users.get( geometry );
+		geometryData.ref = new WeakRef( geometry );
 
-		if ( users === undefined ) this._users.set( geometry, users = new Set() );
-
-		users.add( renderObject );
-
-	}
-
-	/**
-	 * Records that a render object no longer draws a geometry.
-	 *
-	 * @param {RenderObject} renderObject - The render object.
-	 * @param {BufferGeometry} geometry - The geometry it drew.
-	 */
-	removeUser( renderObject, geometry ) {
-
-		const users = this._users.get( geometry );
-
-		if ( users !== undefined ) users.delete( renderObject );
+		this._tracked.add( geometryData.ref );
+		this._registry.register( geometry, geometryData.ref, geometryData.ref );
 
 	}
 
@@ -322,6 +329,7 @@ class Geometries extends DataMap {
 		// attributes
 
 		const attributes = renderObject.getAttributes();
+		const object = renderObject.object;
 
 		for ( const attribute of attributes ) {
 
@@ -331,6 +339,14 @@ class Geometries extends DataMap {
 
 			} else {
 
+				if ( object.isInstancedMesh === true ) {
+
+					const bufferAttribute = this.backend.getBufferAttribute( attribute );
+
+					if ( bufferAttribute === object.instanceMatrix || bufferAttribute === object.instanceColor ) sendDrawnInstances( bufferAttribute, object );
+
+				}
+
 				this.updateAttribute( attribute, AttributeType.VERTEX );
 
 			}
@@ -369,33 +385,13 @@ class Geometries extends DataMap {
 
 		const callId = this.info.render.calls;
 
-		if ( ! attribute.isInterleavedBufferAttribute ) {
-
-			if ( this.attributeCall.get( attribute ) !== callId ) {
-
-				this.attributes.update( attribute, type );
-
-				this.attributeCall.set( attribute, callId );
-
-			}
-
-		} else {
-
-			if ( this.attributeCall.get( attribute ) === undefined ) {
-
-				this.attributes.update( attribute, type );
+		const bufferAttribute = this.backend.getBufferAttribute( attribute );
 
-				this.attributeCall.set( attribute, callId );
+		if ( this.attributeCall.get( bufferAttribute ) !== callId ) {
 
-			} else if ( this.attributeCall.get( attribute.data ) !== callId ) {
+			this.attributes.update( bufferAttribute, type );
 
-				this.attributes.update( attribute, type );
-
-				this.attributeCall.set( attribute.data, callId );
-
-				this.attributeCall.set( attribute, callId );
-
-			}
+			this.attributeCall.set( bufferAttribute, callId );
 
 		}
 
@@ -468,15 +464,57 @@ class Geometries extends DataMap {
 
 	}
 
+	/**
+	 * Deletes the attributes that are defined via nodes and not on geometry level.
+	 *
+	 * @param {RenderObject} renderObject - The render object.
+	 */
+	deleteNodeAttributes( renderObject ) {
+
+		const currentAttributes = new Set( Object.values( renderObject.geometry.attributes ) );
+
+		for ( const attribute of renderObject.getAttributes() ) {
+
+			if ( currentAttributes.has( attribute ) === false ) {
+
+				this.attributes.delete( this.backend.getBufferAttribute( attribute ) );
+
+			}
+
+		}
+
+	}
+
+	/**
+	 * Deletes the vertex state for the given render object.
+	 *
+	 * @param {RenderObject} renderObject - The render object.
+	 */
+	deleteVertexState( renderObject ) {
+
+		this.backend.deleteVertexState( renderObject );
+
+	}
+
+	/**
+	 * Frees internal resources.
+	 */
 	dispose() {
 
-		for ( const [ geometry, onDispose ] of this._geometryDisposeListeners.entries() ) {
+		for ( const ref of this._tracked ) {
+
+			const geometry = ref.deref();
 
-			geometry.removeEventListener( 'dispose', onDispose );
+			if ( geometry === undefined ) continue;
+
+			const geometryData = this.get( geometry );
+			geometryData.onDispose();
 
 		}
 
-		this._geometryDisposeListeners.clear();
+		this._tracked.clear();
+
+		super.dispose();
 
 	}
 

package/src/renderers/common/Info.js

@@ -479,7 +479,7 @@ class Info {
 		let size = width * height * depth * bytesPerPixel;
 		const mipmaps = texture.mipmaps;
 
-		if ( mipmaps && mipmaps.length > 0 ) {
+		if ( mipmaps.length > 0 ) {
 
 			let mipmapSize = 0;
 			for ( let i = 0; i < mipmaps.length; i ++ ) {

package/src/renderers/common/InspectorBase.js

@@ -1,7 +1,7 @@
 import { EventDispatcher } from '../../core/EventDispatcher.js';
 
 /**
- * InspectorBase is the base class for all inspectors.
+ * InspectorBase is the base class for all inspectors. Can only be used with {@link WebGPURenderer}.
  *
  * @augments EventDispatcher
  */
@@ -17,7 +17,7 @@ class InspectorBase extends EventDispatcher {
 		/**
 		 * The renderer associated with this inspector.
 		 *
-		 * @type {WebGLRenderer}
+		 * @type {Renderer}
 		 * @private
 		 */
 		this._renderer = null;
@@ -61,7 +61,7 @@ class InspectorBase extends EventDispatcher {
 	/**
 	 * Sets the renderer for this inspector.
 	 *
-	 * @param {WebGLRenderer} renderer - The renderer to associate with this inspector.
+	 * @param {Renderer} renderer - The renderer to associate with this inspector.
 	 * @return {InspectorBase} This inspector instance.
 	 */
 	setRenderer( renderer ) {
@@ -75,7 +75,7 @@ class InspectorBase extends EventDispatcher {
 	/**
 	 * Returns the renderer associated with this inspector.
 	 *
-	 * @return {WebGLRenderer} The associated renderer.
+	 * @return {Renderer} The associated renderer.
 	 */
 	getRenderer() {
 
@@ -138,7 +138,7 @@ class InspectorBase extends EventDispatcher {
 	 * @param {string} uid - A unique identifier for the render context.
 	 * @param {Scene} scene - The scene being rendered.
 	 * @param {Camera} camera - The camera being used for rendering.
-	 * @param {?WebGLRenderTarget} renderTarget - The render target, if any.
+	 * @param {?RenderTarget} renderTarget - The render target, if any.
 	 */
 	beginRender( /*uid, scene, camera, renderTarget*/ ) { }
 

package/src/renderers/common/Lighting.js

@@ -42,6 +42,24 @@ class Lighting {
 		 */
 		this._lightsNodeMap = new WeakMap();
 
+		/**
+		 * Weak references to the lights nodes created by this lighting manager, so they
+		 * can be disposed with {@link Lighting#dispose} without keeping scenes alive.
+		 *
+		 * @private
+		 * @type {Set<WeakRef<LightsNode>>}
+		 */
+		this._tracked = new Set();
+
+		/**
+		 * Removes weak references from `_tracked` when their lights node has been
+		 * garbage collected without an explicit `dispose()`.
+		 *
+		 * @private
+		 * @type {FinalizationRegistry}
+		 */
+		this._registry = new FinalizationRegistry( ( ref ) => this._tracked.delete( ref ) );
+
 	}
 
 	/**
@@ -73,6 +91,7 @@ class Lighting {
 
 			node = this.createNode();
 			this._lightsNodeMap.set( scene, node );
+			this._track( node );
 
 		}
 
@@ -80,6 +99,22 @@ class Lighting {
 
 	}
 
+	/**
+	 * Tracks the given lights node so it is disposed with {@link Lighting#dispose}.
+	 * Subclasses creating additional lights nodes should track them as well.
+	 *
+	 * @private
+	 * @param {LightsNode} node - The lights node.
+	 */
+	_track( node ) {
+
+		const ref = new WeakRef( node );
+
+		this._tracked.add( ref );
+		this._registry.register( node, ref, ref );
+
+	}
+
 	/**
 	 * Saves the current lights of the scene's lights node so they can be restored
 	 * in {@link Lighting#finishRender}. Must be paired with a `finishRender()` call
@@ -107,6 +142,30 @@ class Lighting {
 
 	}
 
+	/**
+	 * Frees the resources of the lights nodes created by this lighting manager. Called by
+	 * the renderer when it is disposed, or by the app after replacing the lighting system.
+	 * The lighting manager must not be used for rendering anymore after this call.
+	 */
+	dispose() {
+
+		for ( const ref of this._tracked ) {
+
+			const node = ref.deref();
+
+			if ( node !== undefined ) {
+
+				this._registry.unregister( ref );
+				node.dispose();
+
+			}
+
+		}
+
+		this._tracked.clear();
+
+	}
+
 }
 
 export default Lighting;

package/src/renderers/common/Pipelines.js

@@ -111,9 +111,7 @@ class Pipelines extends DataMap {
 
 			if ( stageCompute === undefined ) {
 
-				if ( previousPipeline && previousPipeline.computeProgram.usedTimes === 0 ) this._releaseProgram( previousPipeline.computeProgram );
-
-				stageCompute = new ProgrammableStage( nodeBuilderState.computeShader, 'compute', computeNode.name, nodeBuilderState.transforms, nodeBuilderState.nodeAttributes );
+				stageCompute = new ProgrammableStage( nodeBuilderState.computeShader, 'compute', computeNode.name );
 				this.programs.compute.set( nodeBuilderState.computeShader, stageCompute );
 
 				backend.createProgram( stageCompute );
@@ -129,8 +127,6 @@ class Pipelines extends DataMap {
 
 			if ( pipeline === undefined ) {
 
-				if ( previousPipeline && previousPipeline.usedTimes === 0 ) this._releasePipeline( previousPipeline );
-
 				pipeline = this._getComputePipeline( computeNode, stageCompute, cacheKey, bindings, promises );
 
 			}
@@ -140,6 +136,15 @@ class Pipelines extends DataMap {
 			pipeline.usedTimes ++;
 			stageCompute.usedTimes ++;
 
+			// release previous pipeline and program if they are not used anymore
+
+			if ( previousPipeline ) {
+
+				if ( previousPipeline.usedTimes === 0 ) this._releasePipeline( previousPipeline );
+				if ( previousPipeline.computeProgram.usedTimes === 0 ) this._releaseProgram( previousPipeline.computeProgram );
+
+			}
+
 			//
 
 			data.version = computeNode.version;
@@ -188,8 +193,6 @@ class Pipelines extends DataMap {
 
 			if ( stageVertex === undefined ) {
 
-				if ( previousPipeline && previousPipeline.vertexProgram.usedTimes === 0 ) this._releaseProgram( previousPipeline.vertexProgram );
-
 				stageVertex = new ProgrammableStage( nodeBuilderState.vertexShader, 'vertex', name );
 				this.programs.vertex.set( nodeBuilderState.vertexShader, stageVertex );
 
@@ -202,8 +205,6 @@ class Pipelines extends DataMap {
 
 			if ( stageFragment === undefined ) {
 
-				if ( previousPipeline && previousPipeline.fragmentProgram.usedTimes === 0 ) this._releaseProgram( previousPipeline.fragmentProgram );
-
 				stageFragment = new ProgrammableStage( nodeBuilderState.fragmentShader, 'fragment', name );
 				this.programs.fragment.set( nodeBuilderState.fragmentShader, stageFragment );
 
@@ -220,8 +221,6 @@ class Pipelines extends DataMap {
 
 			if ( pipeline === undefined ) {
 
-				if ( previousPipeline && previousPipeline.usedTimes === 0 ) this._releasePipeline( previousPipeline );
-
 				pipeline = this._getRenderPipeline( renderObject, stageVertex, stageFragment, cacheKey, promises );
 
 			} else {
@@ -236,6 +235,16 @@ class Pipelines extends DataMap {
 			stageVertex.usedTimes ++;
 			stageFragment.usedTimes ++;
 
+			// release previous pipeline and programs if they are not used anymore
+
+			if ( previousPipeline ) {
+
+				if ( previousPipeline.usedTimes === 0 ) this._releasePipeline( previousPipeline );
+				if ( previousPipeline.vertexProgram.usedTimes === 0 ) this._releaseProgram( previousPipeline.vertexProgram );
+				if ( previousPipeline.fragmentProgram.usedTimes === 0 ) this._releaseProgram( previousPipeline.fragmentProgram );
+
+			}
+
 			//
 
 			data.pipeline = pipeline;
@@ -356,7 +365,9 @@ class Pipelines extends DataMap {
 
 		if ( pipeline === undefined ) {
 
-			pipeline = new ComputePipeline( cacheKey, stageCompute );
+			const { transforms, nodeAttributes } = this.nodes.getForCompute( computeNode );
+
+			pipeline = new ComputePipeline( cacheKey, stageCompute, transforms, nodeAttributes );
 
 			this.caches.set( cacheKey, pipeline );
 
@@ -444,6 +455,8 @@ class Pipelines extends DataMap {
 	 */
 	_releasePipeline( pipeline ) {
 
+		this.backend.destroyPipeline( pipeline );
+
 		this.caches.delete( pipeline.cacheKey );
 
 	}
@@ -461,6 +474,7 @@ class Pipelines extends DataMap {
 
 		this.programs[ stage ].delete( code );
 
+		this.backend.destroyProgram( program );
 		this.info.destroyProgram( program );
 
 	}