Replacing an attribute of a geometry instanced by another new attribute with a superior length break the renderer

[Samsy]

Description

On previous version of Three.JS, ( r162 havnt tested between then and now ) ,we were able to replace an entire instancedgeometry attribute with a new length and set the instanceCount to a superior value

This is a valuable feature for performances if you play with huge dynamic instanced geometry that increments count over time and allows to first allocate a smaller buffer then grow with a safe multiple to limit the size of the buffer

But this also limits flexibility of building geometries by a lot

In both WebGL and WebGPU back end it now breaks the renderer :

Look at the switchArray function

Live example

[Samsy]

maybe @RenaudRohlinger knows about it ?

[RenaudRohlinger]

Ah yes, it's because the instance node is created when the material is first mounted, you need to add material.needsUpdate =true.

https://jsfiddle.net/4pk7csru/4/

[Samsy]

@RenaudRohlinger

Here is the updated fiddle with material.needsUpdate = true

Does not seem to work :

https://jsfiddle.net/zjsy4r7a/1/

[RenaudRohlinger]

oops didn't see my console, indeed, then we need to fix this in InstanceNode.

[Samsy]

@RenaudRohlinger This is a blocking bug on my end, can I help with this ?

Where should I look at exactly ?

[Makio64]

@Samsy @RenaudRohlinger I think the problem come from here , as it will not rebuild the buffer if it was build the first time

three.js/src/nodes/accessors/InstanceNode.js

Line 117 in 86c3bd3

if ( instanceMatrixNode === null ) {

[Samsy]

Hey @RenaudRohlinger
I wonder if I could give any help regarding this one, this is very blocking

Can you point me where this need fixes ?

Many thanks

[RenaudRohlinger]

In InstanceNode, probably something like:

	update( /*frame*/ ) {

		// here --->
		if ( this.instanceMatrix.uuid !== this._uuidRef ) {
                         // update the buffer
			this.buffer.copy( this.instanceMatrix.array );

		}
		
		if ( this.instanceMatrix.usage !== DynamicDrawUsage && this.buffer !== null && this.instanceMatrix.version !== this.buffer.version ) {

			this.buffer.version = this.instanceMatrix.version;

		}

		if ( this.instanceColor && this.instanceColor.usage !== DynamicDrawUsage && this.bufferColor !== null && this.instanceColor.version !== this.bufferColor.version ) {

			this.bufferColor.version = this.instanceColor.version;

		}

	}

And notify in the NodeMaterialObserver when an attribute change:

	getAttributesData( attributes ) {

		const attributesData = {};

		for ( const name in attributes ) {

			const attribute = attributes[ name ];

			attributesData[ name ] = {
				version: attribute.version,
				uuid: attribute.uuid // <-- here
			};

		}

		return attributesData;

	}

Also I'm not 100%, I'm off this week so I can't give a properly look but the idea is here.

[Samsy]

About the instance node

The live fiddle is not using any, but just a instancedgeometrybuffer

I did set a debugger in the instanceNode constructor, nothing showed up here, not certain, but it did not call any instancenode constructor

@sunag @RenaudRohlinger any clue ?

I suspect the actual buffer to not be updated properly internally :

function switchArray(){

    const newMax = 8
    
    const attribute = instancedGeometry.attributes.offset
		
    const newArray = new attribute.array.constructor(
      newMax * attribute.itemSize
    );

    newArray.set(attribute.array);
    
    const newAttribute = new THREE.InstancedBufferAttribute(
      newArray,
      attribute.itemSize,
      attribute.normalized
    );
    
    let i = 0 
    
    while(i < newAttribute.array.length ) {
			
         newAttribute.array[i] = Math.random()
			
         i++
    }

    newAttribute.setUsage(THREE.DynamicDrawUsage);
	
  	
    instancedGeometry.attributes.offset = newAttribute;

    instancedGeometry.attributes.offset.needsUpdate = true;
    
    instancedGeometry.instanceCount = newMax

}

[Samsy]

I spent a bit of time to look at the sources, but cannot put my hand on the problem, this one is a real blocker for adaptive size of buffers in a geometry and performances,

The fiddle code does not use nodeinstance, but just raw instancedbuffergeometry and custom shading not related to internals of instancedmesh

Adaptive sizes works on the legacy WebGLRenderer

Any help really to solve this would be really appreciated 🙏🏻