@threenative/core 0.3.2 → 0.3.4

package/patches/three@0.185.1.patch

@@ -1,5 +1,5 @@
 diff --git a/build/three.cjs b/build/three.cjs
-index 8939a67dd76325ccd25ee8806fc4d22b1caea88a..b0f917241f1f2cd25baa21dec20edda32176ef6a 100644
+index 8939a67..b0f9172 100644
 --- a/build/three.cjs
 +++ b/build/three.cjs
 @@ -26116,6 +26116,8 @@ function copyArrayContents( src, target ) {
@@ -12,7 +12,7 @@ index 8939a67dd76325ccd25ee8806fc4d22b1caea88a..b0f917241f1f2cd25baa21dec20edda3
  	 * Constructs a new batched mesh.
  	 *
 diff --git a/build/three.core.js b/build/three.core.js
-index 0bb9262cd029f411933d077fd44197a51ec5e8e9..868a634b4294be5f32664912a50813d55d6dd6e7 100644
+index 0bb9262..868a634 100644
 --- a/build/three.core.js
 +++ b/build/three.core.js
 @@ -26136,6 +26136,8 @@ function copyArrayContents( src, target ) {
@@ -25,10 +25,277 @@ index 0bb9262cd029f411933d077fd44197a51ec5e8e9..868a634b4294be5f32664912a50813d5
  	 * Constructs a new batched mesh.
  	 *
 diff --git a/build/three.webgpu.js b/build/three.webgpu.js
-index 2e490796d4d4aa9479b04a5c46ddbf31cc05b1a1..d05599255744ccfca19dbfd0433da612583ce6ea 100644
+index 2e49079..7aa62ad 100644
 --- a/build/three.webgpu.js
 +++ b/build/three.webgpu.js
-@@ -18500,7 +18500,8 @@ const instance = /*@__PURE__*/ Fn( ( [ matrices, colors = null ], builder ) => {
+@@ -141,6 +141,15 @@ class NodeMaterialObserver {
+ 		 */
+ 		this.renderId = 0;
+ 
++		/**
++		 * Whether the current render produces motion vectors. Objects keep refreshing
++		 * fully while this is the case.
++		 *
++		 * @type {boolean}
++		 * @default false
++		 */
++		this.renderingVelocity = false;
++
+ 	}
+ 
+ 	/**
+@@ -240,6 +249,88 @@ class NodeMaterialObserver {
+ 
+ 	}
+ 
++	/**
++	 * Returns `true` if the given render object is a static object whose per-object state - world
++	 * matrix, material, geometry and the scene environment - did not change since the last
++	 * refresh. A settled object is still drawn every frame and its FRAME and RENDER nodes still
++	 * have to be updated; what it may skip is the work whose inputs it froze: its OBJECT node
++	 * updates, its object uniform group upload and its per-draw attribute scan.
++	 *
++	 * @param {RenderObject} renderObject - The render object.
++	 * @return {boolean} Whether the given render object is settled or not.
++	 */
++	isSettled( renderObject ) {
++
++		const data = this.renderObjects.get( renderObject );
++
++		return data !== undefined && data.settledState === true;
++
++	}
++
++	/**
++	 * Recomputes {@link NodeMaterialObserver#isSettled} for the given render object, once per draw,
++	 * so every step of that draw reads the same answer.
++	 *
++	 * @param {RenderObject} renderObject - The render object.
++	 * @return {boolean} Whether the given render object is settled or not.
++	 */
++	updateSettled( renderObject ) {
++
++		const { object, material, geometry, scene } = renderObject;
++		const data = this.getRenderObjectData( renderObject );
++
++		if ( object.static !== true || this.renderingVelocity === true ) {
++
++			data.settledState = false;
++
++			return false;
++
++		}
++
++		let settled = data.settled;
++
++		if ( settled === undefined ) {
++
++			data.settled = settled = {
++				matrix: object.matrixWorld.clone(),
++				environmentRotation: scene.environmentRotation.clone(),
++				environmentIntensity: scene.environmentIntensity,
++				materialVersion: material.version,
++				geometryVersion: geometry.version
++			};
++
++			data.settledState = false;
++
++			return false;
++
++		}
++
++		if ( settled.matrix.equals( object.matrixWorld ) !== true ||
++			settled.environmentRotation.equals( scene.environmentRotation ) !== true ||
++			settled.environmentIntensity !== scene.environmentIntensity ||
++			settled.materialVersion !== material.version ||
++			settled.geometryVersion !== geometry.version ) {
++
++			// re-arm with the current state, so the object settles again once it stops changing
++
++			settled.matrix.copy( object.matrixWorld );
++			settled.environmentRotation.copy( scene.environmentRotation );
++			settled.environmentIntensity = scene.environmentIntensity;
++			settled.materialVersion = material.version;
++			settled.geometryVersion = geometry.version;
++
++			data.settledState = false;
++
++			return false;
++
++		}
++
++		data.settledState = true;
++
++		return true;
++
++	}
++
+ 	/**
+ 	 * Returns an attribute data structure holding the attributes versions for
+ 	 * monitoring.
+@@ -306,7 +397,6 @@ class NodeMaterialObserver {
+ 
+ 			data = {
+ 				_renderId: -1,
+-				_equal: false,
+ 
+ 				attributes: this.getAttributesData( geometry.attributes ),
+ 				indexId: geometry.index ? geometry.index.id : null,
+@@ -335,7 +425,7 @@ class NodeMaterialObserver {
+ 
+ 		if ( data === undefined ) {
+ 
+-			data = { _renderId: -1, _equal: false };
++			data = { _renderId: -1 };
+ 
+ 			for ( const property of this.refreshUniforms ) {
+ 
+@@ -419,7 +509,6 @@ class NodeMaterialObserver {
+ 
+ 						value.copy( mtlValue );
+ 
+-						materialData._equal = false;
+ 						return false;
+ 
+ 					}
+@@ -431,7 +520,6 @@ class NodeMaterialObserver {
+ 						value.id = mtlValue.id;
+ 						value.version = mtlValue.version;
+ 
+-						materialData._equal = false;
+ 						return false;
+ 
+ 					}
+@@ -440,7 +528,6 @@ class NodeMaterialObserver {
+ 
+ 					materialData[ property ] = mtlValue;
+ 
+-					materialData._equal = false;
+ 					return false;
+ 
+ 				}
+@@ -456,18 +543,12 @@ class NodeMaterialObserver {
+ 					renderObjectData.bufferWidth = width;
+ 					renderObjectData.bufferHeight = height;
+ 
+-					materialData._equal = false;
+ 					return false;
+ 
+ 				}
+ 
+ 			}
+ 
+-			materialData._equal = true;
+-
+-		} else {
+-
+-			if ( materialData._equal === false ) return false;
+ 
+ 		}
+ 
+@@ -510,7 +591,6 @@ class NodeMaterialObserver {
+ 					// attribute was removed
+ 					delete storedAttributes[ name ];
+ 
+-					geometryData._equal = false;
+ 					return false;
+ 
+ 				}
+@@ -523,7 +603,6 @@ class NodeMaterialObserver {
+ 					storedAttributeData.id = id;
+ 					storedAttributeData.version = version;
+ 
+-					geometryData._equal = false;
+ 					return false;
+ 
+ 				}
+@@ -534,7 +613,6 @@ class NodeMaterialObserver {
+ 
+ 				geometryData.attributes = this.getAttributesData( attributes );
+ 
+-				geometryData._equal = false;
+ 				return false;
+ 
+ 			}
+@@ -552,7 +630,6 @@ class NodeMaterialObserver {
+ 				geometryData.indexId = currentIndexId;
+ 				geometryData.indexVersion = currentIndexVersion;
+ 
+-				geometryData._equal = false;
+ 				return false;
+ 
+ 			}
+@@ -564,16 +641,10 @@ class NodeMaterialObserver {
+ 				geometryData.drawRange.start = geometry.drawRange.start;
+ 				geometryData.drawRange.count = geometry.drawRange.count;
+ 
+-				geometryData._equal = false;
+ 				return false;
+ 
+ 			}
+ 
+-			geometryData._equal = true;
+-
+-		} else {
+-
+-			if ( geometryData._equal === false ) return false;
+ 
+ 		}
+ 
+@@ -724,7 +795,14 @@ class NodeMaterialObserver {
+ 	 */
+ 	needsRefresh( renderObject, nodeFrame ) {
+ 
+-		if ( this.hasNode || this.hasAnimation || this.firstInitialization( renderObject ) || this.needsVelocity( nodeFrame.renderer ) )
++		this.renderingVelocity = this.needsVelocity( nodeFrame.renderer );
++
++		// Answered for the whole draw, so updateBefore, the geometry scan, the node updates and
++		// the object uniform upload of this object all skip or all refresh.
++
++		this.updateSettled( renderObject );
++
++		if ( this.hasNode || this.hasAnimation || this.firstInitialization( renderObject ) || this.renderingVelocity )
+ 			return true;
+ 
+ 		const { renderId } = nodeFrame;
+@@ -737,10 +815,14 @@ class NodeMaterialObserver {
+ 
+ 		}
+ 
+-		const isStatic = renderObject.object.static === true;
+ 		const isBundle = renderObject.bundle !== null && renderObject.bundle.static === true && this.getRenderObjectData( renderObject ).version === renderObject.bundle.version;
+ 
+-		if ( isStatic || isBundle )
++		// `object.static` is not the question - it is a switch, and a brand new object has it set
++		// before it has been drawn once, so answering from it skips the draw that creates this
++		// object's bind groups and leaves the pipeline reading a layout that was never built. A
++		// static object that moved, or whose material or geometry was edited, has to refresh like
++		// any other; only a settled one may skip, and nothing is settled before its first refresh.
++		if ( this.isSettled( renderObject ) === true || isBundle )
+ 			return false;
+ 
+ 		const lightsData = this.getLights( renderObject.lightsNode, renderId );
+@@ -18320,7 +18402,8 @@ function createInstanceMatrixNode( builder, instanceMatrix ) {
+ 
+ 		const uniformBufferSize = matrixCount * 16 * 4;
+ 
+-		if ( uniformBufferSize <= builder.getUniformBufferLimit() ) {
++		// threenative: the uniform path re-uploads every draw; the attribute path uploads on version change
++		if ( false ) {
+ 
+ 			instanceMatrixNode = buffer( instanceMatrix.array, 'mat4', matrixCount ).element( instanceIndex );
+ 
+@@ -18414,7 +18497,8 @@ const instance = /*@__PURE__*/ Fn( ( [ matrices, colors = null ], builder ) => {
+ 
+ 		const uniformBufferSize = Math.max( matrices.count, 1 ) * 16 * 4;
+ 
+-		if ( uniformBufferSize > builder.getUniformBufferLimit() ) {
++		// threenative: the uniform path re-uploads every draw; the attribute path uploads on version change
++		if ( true ) {
+ 
+ 			interleavedMatrix = _matrixBuffers.get( matrices );
+ 
+@@ -18500,7 +18584,8 @@ const instance = /*@__PURE__*/ Fn( ( [ matrices, colors = null ], builder ) => {
  
  			const previousInstanceData = _previousInstanceMatrices.get( object );
  
@@ -38,7 +305,7 @@ index 2e490796d4d4aa9479b04a5c46ddbf31cc05b1a1..d05599255744ccfca19dbfd0433da612
  
  		} );
  
-@@ -18599,6 +18600,7 @@ const batch = /*@__PURE__*/ Fn( ( [ batchMesh ], builder ) => {
+@@ -18599,6 +18684,7 @@ const batch = /*@__PURE__*/ Fn( ( [ batchMesh ], builder ) => {
  	const indirectId = getIndirectIndex( batchMesh._indirectTexture, int( batchingIdNode ) );
  
  	const matricesTexture = batchMesh._matricesTexture;
@@ -46,7 +313,7 @@ index 2e490796d4d4aa9479b04a5c46ddbf31cc05b1a1..d05599255744ccfca19dbfd0433da612
  
  	const size = int( textureSize( textureLoad( matricesTexture ), 0 ).x ).toConst();
  	const j = float( indirectId ).mul( 4 ).toInt().toConst();
-@@ -18626,6 +18628,19 @@ const batch = /*@__PURE__*/ Fn( ( [ batchMesh ], builder ) => {
+@@ -18626,6 +18712,19 @@ const batch = /*@__PURE__*/ Fn( ( [ batchMesh ], builder ) => {
  
  	positionLocal.assign( batchingMatrix.mul( positionLocal ) );
  
@@ -66,7 +333,7 @@ index 2e490796d4d4aa9479b04a5c46ddbf31cc05b1a1..d05599255744ccfca19dbfd0433da612
  	const transformedNormal = normalLocal.div( vec3( bm[ 0 ].dot( bm[ 0 ] ), bm[ 1 ].dot( bm[ 1 ] ), bm[ 2 ].dot( bm[ 2 ] ) ) );
  
  	const batchingNormal = bm.mul( transformedNormal ).xyz;
-@@ -18777,7 +18792,8 @@ const skinning = /*@__PURE__*/ Fn( ( [ skinnedMesh ], builder ) => {
+@@ -18777,7 +18876,8 @@ const skinning = /*@__PURE__*/ Fn( ( [ skinnedMesh ], builder ) => {
  
  			if ( skeletonData !== undefined ) {
  
@@ -76,7 +343,7 @@ index 2e490796d4d4aa9479b04a5c46ddbf31cc05b1a1..d05599255744ccfca19dbfd0433da612
  
  			}
  
-@@ -18844,7 +18860,8 @@ const computeSkinning = /*@__PURE__*/ Fn( ( [ skinnedMesh, toPosition = null ],
+@@ -18844,7 +18944,8 @@ const computeSkinning = /*@__PURE__*/ Fn( ( [ skinnedMesh, toPosition = null ],
  
  			if ( state !== undefined ) {
  
@@ -86,7 +353,7 @@ index 2e490796d4d4aa9479b04a5c46ddbf31cc05b1a1..d05599255744ccfca19dbfd0433da612
  
  			}
  
-@@ -29911,6 +29928,18 @@ class RenderObject {
+@@ -29911,6 +30012,18 @@ class RenderObject {
  		 */
  		this._sourceMaterial = renderer._currentSourceMaterial;
  
@@ -105,7 +372,33 @@ index 2e490796d4d4aa9479b04a5c46ddbf31cc05b1a1..d05599255744ccfca19dbfd0433da612
  		/**
  		 * An event listener which is defined by `RenderObjects`. It performs
  		 * clean up tasks when `dispose()` on this render object.
-@@ -30707,9 +30736,18 @@ class RenderObjects {
+@@ -30098,7 +30211,7 @@ class RenderObject {
+ 	 */
+ 	getChainArray() {
+ 
+-		return [ this.object, this.material, this.context, this.lightsNode ];
++		return [ this.object, this.material, this.context, this.lightsNode, this._sourceMaterial ?? this.material ];
+ 
+ 	}
+ 
+@@ -30548,6 +30661,7 @@ class RenderObject {
+ 		}
+ 
+ 		cacheKey = hash$1( cacheKey, this.renderer.contextNode.id, this.renderer.contextNode.version );
++		cacheKey = hash$1( cacheKey, this.context.sampleCount );
+ 
+ 		return cacheKey;
+ 
+@@ -30680,6 +30794,8 @@ class RenderObjects {
+ 		_chainKeys$3[ 1 ] = material;
+ 		_chainKeys$3[ 2 ] = renderContext;
+ 		_chainKeys$3[ 3 ] = lightsNode;
++		// Material groups share the shadow override, but must retain separate GPU bindings.
++		_chainKeys$3[ 4 ] = this.renderer._currentSourceMaterial ?? material;
+ 
+ 		//
+ 
+@@ -30707,9 +30823,18 @@ class RenderObjects {
  
  			}
  
@@ -118,121 +411,1426 @@ index 2e490796d4d4aa9479b04a5c46ddbf31cc05b1a1..d05599255744ccfca19dbfd0433da612
 +			const sourceTracked = sourceMaterial !== null && sourceMaterial !== undefined;
 +			const sourceReplaced = sourceTracked && renderObject._sourceMaterial !== sourceMaterial;
 +			const sourceChanged = sourceTracked && ( sourceReplaced || renderObject.sourceVersion !== sourceMaterial.version );
++
++			if ( renderObject.version !== material.version || sourceChanged || renderObject.needsUpdate ) {
  
 -				if ( renderObject.initialCacheKey !== renderObject.getCacheKey() ) {
-+			if ( renderObject.version !== material.version || sourceChanged || renderObject.needsUpdate ) {
-+
 +				if ( sourceReplaced || renderObject.initialCacheKey !== renderObject.getCacheKey() ) {
  
- 					renderObject.dispose();
+ 					renderObject.dispose();
+ 
+@@ -30719,6 +30844,8 @@ class RenderObjects {
+ 
+ 					renderObject.version = material.version;
+ 
++					if ( sourceTracked ) renderObject.sourceVersion = sourceMaterial.version;
++
+ 				}
+ 
+ 			}
+@@ -30731,6 +30858,7 @@ class RenderObjects {
+ 		_chainKeys$3[ 1 ] = null;
+ 		_chainKeys$3[ 2 ] = null;
+ 		_chainKeys$3[ 3 ] = null;
++		_chainKeys$3[ 4 ] = null;
+ 
+ 		//
+ 
+@@ -31165,6 +31293,14 @@ class Geometries extends DataMap {
+ 		 */
+ 		this._geometryDisposeListeners = new Map();
+ 
++		/**
++		 * This Weak Map holds the attribute versions a settled render object was last drawn with,
++		 * so a write into one of them is what brings the object back out of the settled path.
++		 *
++		 * @type {WeakMap<RenderObject,Map<BufferAttribute,number>>}
++		 */
++		this._settledAttributes = new WeakMap();
++
+ 	}
+ 
+ 	/**
+@@ -31190,10 +31326,69 @@ class Geometries extends DataMap {
+ 
+ 		if ( this.has( renderObject ) === false ) this.initGeometry( renderObject );
+ 
++		// A settled static object has no attribute that could have changed since the last refresh,
++		// unless a writer bumped one. An InstancedMesh's instance buffer is a vertex attribute of
++		// this draw, and a BufferGeometry carries no version of its own to announce the write, so
++		// the attributes' own versions are the signal - and the only one there is.
++
++		const monitor = renderObject.getMonitor();
++
++		if ( monitor !== undefined && monitor.isSettled( renderObject ) === true && this.attributesChanged( renderObject ) === false ) return;
++
+ 		this.updateAttributes( renderObject );
+ 
+ 	}
+ 
++	/**
++	 * Returns `true` if an attribute of the given render object - or its index - was written to
++	 * since the last time its versions were read, and records the versions it holds now.
++	 *
++	 * @param {RenderObject} renderObject - The render object.
++	 * @return {boolean} Whether any of the render object's versions moved.
++	 */
++	attributesChanged( renderObject ) {
++
++		const attributes = renderObject.getAttributes();
++		const index = this.getIndex( renderObject );
++		const settled = this._settledAttributes.get( renderObject );
++
++		if ( settled !== undefined && settled.size === attributes.length + ( index === null ? 0 : 1 ) ) {
++
++			let changed = false;
++
++			for ( const attribute of attributes ) {
++
++				if ( settled.get( attribute.isInterleavedBufferAttribute ? attribute.data : attribute ) !== attribute.version ) {
++
++					changed = true;
++					break;
++
++				}
++
++			}
++
++			if ( changed === false && ( index === null || settled.get( index ) === index.version ) ) return false;
++
++		}
++
++		const versions = new Map();
++
++		for ( const attribute of attributes ) {
++
++			const data = attribute.isInterleavedBufferAttribute ? attribute.data : attribute;
++
++			versions.set( data, data.version );
++
++		}
++
++		if ( index !== null ) versions.set( index, index.version );
++
++		this._settledAttributes.set( renderObject, versions );
++
++		return true;
++
++	}
++
+ 	/**
+ 	 * Initializes the geometry of the given render object.
+ 	 *
+@@ -32771,7 +32966,7 @@ class Bindings extends DataMap {
+ 	 */
+ 	updateForRender( renderObject ) {
+ 
+-		this._updateBindings( this.getForRender( renderObject ) );
++		this._updateBindings( this.getForRender( renderObject ), this.nodes.isSettled( renderObject ) );
+ 
+ 	}
+ 
+@@ -32918,12 +33113,13 @@ class Bindings extends DataMap {
+ 	 * Updates the given array of bindings.
+ 	 *
+ 	 * @param {Array<BindGroup>} bindings - The bind groups.
++	 * @param {boolean} [settled] - Whether the render object is a settled static object.
+ 	 */
+-	_updateBindings( bindings ) {
++	_updateBindings( bindings, settled ) {
+ 
+ 		for ( const bindGroup of bindings ) {
+ 
+-			this._update( bindGroup, bindings );
++			this._update( bindGroup, bindings, settled );
+ 
+ 		}
+ 
+@@ -32934,11 +33130,27 @@ class Bindings extends DataMap {
+ 	 *
+ 	 * @param {BindGroup} bindGroup - The bind group to update.
+ 	 * @param {Array<BindGroup>} bindings - The bind groups.
++	 * @param {boolean} [settled] - Whether the render object is a settled static object.
+ 	 */
+-	_update( bindGroup, bindings ) {
++	_update( bindGroup, bindings, settled ) {
+ 
+ 		const { backend } = this;
+ 
++		// A group a node added after this object's first draw has no buffers and no layout yet, and
++		// the pipeline reads that layout whatever this draw decides to do with it - so it is built
++		// here, on every draw. A group that did not exist cannot have been written either, so it is
++		// written now: `settled` is what tells the loop below to write it, not to skip it.
++		if ( this.get( bindGroup ).bindGroup === undefined ) {
++
++			this._createBindings( [ bindGroup ] );
++
++			settled = false;
++
++		}
++
++		// a settled object keeps the values it uploaded the last time it refreshed, so an object
++		// group it has already written is the one thing in here it may skip
++
+ 		let needsBindingsUpdate = false;
+ 		let cacheBindings = true;
+ 		let cacheIndex = 0;
+@@ -32948,7 +33160,7 @@ class Bindings extends DataMap {
+ 
+ 		for ( const binding of bindGroup.bindings ) {
+ 
+-			const updatedGroup = this.nodes.updateGroup( binding );
++			const updatedGroup = this.nodes.updateGroup( binding, settled );
+ 
+ 			// every uniforms group is a uniform buffer. So if no update is required,
+ 			// we move one with the next binding. Otherwise the next if block will update the group.
+@@ -33952,7 +34164,8 @@ class RenderContexts {
+ 
+ 		}
+ 
+-		if ( renderTarget !== null ) renderState.sampleCount = renderTarget.samples === 0 ? 1 : renderTarget.samples;
++		const sampleCount = renderTarget !== null ? renderTarget.samples : this.renderer.currentSamples;
++		renderState.sampleCount = sampleCount === 0 ? 1 : sampleCount;
+ 
+ 		renderState.clearDepthValue = this.renderer.getClearDepth();
+ 		renderState.clearStencilValue = this.renderer.getClearStencil();
+@@ -34181,6 +34394,21 @@ class Textures extends DataMap {
+ 
+ 			backend.destroyTexture( texture );
+ 
++			// delete cached bind groups so they don't point to the destroyed texture
++
++			if ( textureData.bindGroups ) {
++
++				for ( const bindGroup of textureData.bindGroups ) {
++
++					const bindingsData = this.backend.get( bindGroup );
++
++					bindingsData.groups = undefined;
++					bindingsData.versions = undefined;
++
++				}
++
++			}
++
+ 		}
+ 
+ 		//
+@@ -39725,7 +39953,8 @@ class VelocityNode extends TempNode {
+ 
+ 		const previousModelMatrix = getPreviousMatrix( object );
+ 
+-		this.previousModelWorldMatrix.value.copy( previousModelMatrix );
++		const scheduledPrevious = object[ Symbol.for( 'threenative.velocity.previousWorldMatrix' ) ];
++		this.previousModelWorldMatrix.value.copy( scheduledPrevious ?? previousModelMatrix );
+ 
+ 		//
+ 
+@@ -53841,7 +54070,7 @@ class NodeBuilder {
+ 
+ 		const mrt = this.renderer.getMRT();
+ 
+-		return ( mrt && mrt.has( 'velocity' ) ) || getDataFromObject( this.object ).useVelocity === true;
++		return ( mrt && mrt.has( 'velocity' ) ) || getDataFromObject( this.object ).useVelocity === true || this.object.userData?.useVelocity === true;
+ 
+ 	}
+ 
+@@ -55244,15 +55473,17 @@ class NodeManager extends DataMap {
+ 	 * Returns `true` if the given node uniforms group must be updated or not.
+ 	 *
+ 	 * @param {NodeUniformsGroup} nodeUniformsGroup - The node uniforms group.
++	 * @param {boolean} [settled] - Whether the render object is a settled static object.
+ 	 * @return {boolean} Whether the node uniforms group requires an update or not.
+ 	 */
+-	updateGroup( nodeUniformsGroup ) {
++	updateGroup( nodeUniformsGroup, settled ) {
+ 
+ 		const groupNode = nodeUniformsGroup.groupNode;
+ 
+-		// groups that are updated per object always require an update so no further checks are needed
++		// groups that are updated per object always require an update so no further checks are needed.
++		// A settled static object keeps the values it uploaded the last time it was refreshed.
+ 
+-		if ( groupNode.updateType === NodeUpdateType.OBJECT ) return true;
++		if ( groupNode.updateType === NodeUpdateType.OBJECT ) return settled !== true;
+ 
+ 		// check for update
+ 
+@@ -56056,6 +56287,21 @@ class NodeManager extends DataMap {
+ 
+ 	}
+ 
++	/**
++	 * Returns `true` if the per-object updates of the given render object can be skipped
++	 * because the object is static and nothing it depends on changed since its last refresh.
++	 *
++	 * @param {RenderObject} renderObject - The render object.
++	 * @return {boolean} Whether the render object is settled or not.
++	 */
++	isSettled( renderObject ) {
++
++		const monitor = renderObject.getMonitor();
++
++		return monitor !== undefined ? monitor.isSettled( renderObject ) : false;
++
++	}
++
+ 	/**
+ 	 * Triggers the call of `updateBefore()` methods
+ 	 * for all nodes of the given render object.
+@@ -56065,9 +56311,14 @@ class NodeManager extends DataMap {
+ 	updateBefore( renderObject ) {
+ 
+ 		const nodeBuilder = renderObject.getNodeBuilderState();
++		const settled = this.isSettled( renderObject );
+ 
+ 		for ( const node of nodeBuilder.updateBeforeNodes ) {
+ 
++			// a settled static object has nothing to update per object
++
++			if ( settled === true && node.getUpdateBeforeType() === NodeUpdateType.OBJECT ) continue;
++
+ 			// update frame state for each node
+ 
+ 			this.getNodeFrameForRender( renderObject ).updateBeforeNode( node );
+@@ -56085,10 +56336,11 @@ class NodeManager extends DataMap {
+ 	updateAfter( renderObject ) {
+ 
+ 		const nodeBuilder = renderObject.getNodeBuilderState();
++		const settled = this.isSettled( renderObject );
+ 
+ 		for ( const node of nodeBuilder.updateAfterNodes ) {
+ 
+-			// update frame state for each node
++			if ( settled === true && node.getUpdateAfterType() === NodeUpdateType.OBJECT ) continue;
+ 
+ 			this.getNodeFrameForRender( renderObject ).updateAfterNode( node );
+ 
+@@ -56125,9 +56377,14 @@ class NodeManager extends DataMap {
+ 
+ 		const nodeFrame = this.getNodeFrameForRender( renderObject );
+ 		const nodeBuilder = renderObject.getNodeBuilderState();
++		const settled = this.isSettled( renderObject );
+ 
+ 		for ( const node of nodeBuilder.updateNodes ) {
+ 
++			// a settled static object keeps the per-object values it uploaded last time
++
++			if ( settled === true && node.getUpdateType() === NodeUpdateType.OBJECT ) continue;
++
+ 			nodeFrame.updateNode( node );
+ 
+ 		}
+@@ -62731,6 +62988,7 @@ class Renderer {
+ 		let materialDisplacementMap;
+ 		let materialDisplacementScale;
+ 		let materialDisplacementBias;
++		let materialAlphaTest;
+ 
+ 		const previousSourceMaterial = this._currentSourceMaterial;
+ 
+@@ -62756,6 +63014,7 @@ class Renderer {
+ 			materialDisplacementMap = overrideMaterial.displacementMap;
+ 			materialDisplacementScale = overrideMaterial.displacementScale;
+ 			materialDisplacementBias = overrideMaterial.displacementBias;
++			materialAlphaTest = overrideMaterial.alphaTest;
+ 
+ 			if ( material.positionNode && material.positionNode.isNode ) {
+ 
+@@ -62763,7 +63022,15 @@ class Renderer {
+ 
+ 			}
+ 
+-			overrideMaterial.alphaTest = material.alphaTest;
++			// `Material.alphaTest`'s setter bumps `version` whenever alpha-test-ness flips, and this
++			// override material is shared by every caster in the pass. A scene that mixes alpha-tested
++			// casters with opaque ones therefore moves that shared version several times per frame,
++			// and every OTHER render object drawn with it then fails the version gate in
++			// `RenderObjects.get` and recomputes a full material cache key that always matches.
++			// Writing the backing field leaves the `alphaTest` getter — and so the cache key — still
++			// reporting this caster's value, while each render object tracks the staleness signal
++			// that belongs to it: its own source material's version.
++			overrideMaterial._alphaTest = material.alphaTest;
+ 			overrideMaterial.alphaMap = material.alphaMap;
+ 			overrideMaterial.displacementMap = material.displacementMap;
+ 			overrideMaterial.displacementScale = material.displacementScale;
+@@ -62825,6 +63092,7 @@ class Renderer {
+ 			scene.overrideMaterial.displacementMap = materialDisplacementMap;
+ 			scene.overrideMaterial.displacementScale = materialDisplacementScale;
+ 			scene.overrideMaterial.displacementBias = materialDisplacementBias;
++			scene.overrideMaterial._alphaTest = materialAlphaTest;
+ 
+ 		}
+ 
+@@ -62886,18 +63154,17 @@ class Renderer {
+ 
+ 		//
+ 
+-		const needsRefresh = this._nodes.needsRefresh( renderObject );
++		this._nodes.needsRefresh( renderObject );
+ 
+-		if ( needsRefresh ) {
+-
+-			this._nodes.updateBefore( renderObject );
+-
+-			this._geometries.updateForRender( renderObject );
+-
+-			this._nodes.updateForRender( renderObject );
+-			this._bindings.updateForRender( renderObject );
+-
+-		}
++		// Every step of a draw runs, settled or not. What a settled static object skips is decided
++		// inside each of them - its OBJECT node updates, its object uniform group write and its
++		// attribute scan - because each of those answers for itself, and a step left out here
++		// cannot: a group a node added after this object's first draw still has to be created, and
++		// the pipeline reads that group's layout whatever this draw decided to do with it.
++		this._geometries.updateForRender( renderObject );
++		this._nodes.updateBefore( renderObject );
++		this._nodes.updateForRender( renderObject );
++		this._bindings.updateForRender( renderObject );
+ 
+ 		this._pipelines.updateForRender( renderObject );
+ 
+@@ -62907,7 +63174,7 @@ class Renderer {
+ 
+ 			this.backend.draw( renderObject, this.info );
+ 
+-			if ( needsRefresh ) this._nodes.updateAfter( renderObject );
++			this._nodes.updateAfter( renderObject );
+ 
+ 		}
+ 
+@@ -79004,7 +79271,14 @@ class WGSLNodeBuilder extends NodeBuilder {
+ 
+ 		} else {
+ 
+-			snippet = `textureLoad( ${ textureProperty }, ${ uvIndexSnippet }, u32( ${ levelSnippet } ) )`;
++			// naga v25 (wgpu-native v25.0.2.2) rejects a u32 sample index on a
++			// multisampled textureLoad; i32 is accepted by every backend. Mip-level
++			// operands (including the array form above) stay u32.
++			const sampleData = texture ? this.renderer?.backend?.utils?.getTextureSampleData?.( texture ) : null;
++			const backendMultisampled = sampleData !== null && sampleData !== undefined && sampleData.primarySamples > 1;
++			const targetMultisampled = Boolean( texture && texture.renderTarget && texture.renderTarget.samples > 1 );
++			const indexType = ( backendMultisampled || targetMultisampled ) ? 'i32' : 'u32';
++			snippet = `textureLoad( ${ textureProperty }, ${ uvIndexSnippet }, ${ indexType }( ${ levelSnippet } ) )`;
+ 
+ 			if ( this.renderer.backend.compatibilityMode && texture.isDepthTexture ) {
+ 
+@@ -79586,7 +79860,8 @@ class WGSLNodeBuilder extends NodeBuilder {
+ 
+ 				uniformGPU = buffer;
+ 
+-				uniformNode.name = name ? name : 'NodeBuffer_' + uniformNode.id;
++				// The base builder supplies a unique name within this program. A process-wide
++				// allocation id changes otherwise identical shader source for every buffer.
+ 
+ 			} else {
+ 
+@@ -80329,9 +80604,12 @@ ${ flowData.code }
+ 				const textureNode = uniform.node;
+ 				const texture = textureNode.value;
+ 
+-				// Cube textures always need samplers (they use textureSampleLevel, not textureLoad)
+-				// Also textureGather always need sampler.
+-				const needsSampler = texture.isCubeTexture === true || ( this.isUnfilterable( texture ) === false && textureNode.isStorageTextureNode !== true ) || textureNode.gatherNode !== null;
++				// The bind group layout freezes sampler inclusion once, in getUniformFromNode
++				// (nodeData.uniformGPU). Re-deriving it here from live texture filter state can
++				// disagree with that layout and shift every later binding index.
++				const nodeData = this.getDataFromNode( textureNode, shaderStage, this.globalCache );
++				const uniformGPU = nodeData.uniformGPU;
++				const needsSampler = Array.isArray( uniformGPU ) && uniformGPU[ 0 ].isSampler === true && uniformGPU[ 0 ].isSampledTexture !== true;
+ 
+ 				if ( needsSampler ) {
+ 
+@@ -81295,9 +81573,15 @@ class WebGPUAttributeUtils {
+ 	destroyAttribute( attribute ) {
+ 
+ 		const backend = this.backend;
+-		const data = backend.get( this._getBufferAttribute( attribute ) );
++		const bufferAttribute = this._getBufferAttribute( attribute );
++		const data = backend.get( bufferAttribute );
+ 
+-		data.buffer.destroy();
++		// An interleaved attribute's GPU buffer lives on its InterleavedBuffer, and several attributes
++		// share it: destroy it once and forget it there too, as the WebGL backend does, or the next
++		// createAttribute() finds the destroyed buffer and submits it (threenative patch).
++		if ( data.buffer !== undefined ) data.buffer.destroy();
++
++		if ( bufferAttribute !== attribute ) backend.delete( bufferAttribute );
+ 
+ 		backend.delete( attribute );
+ 
+@@ -81598,18 +81882,16 @@ class WebGPUBindingUtils {
+ 
+ 		const bindingsData = backend.get( bindGroup );
+ 
+-		// check if the the bind group already has a layout
++		const entries = this._createLayoutEntries( bindGroup );
++		const bindGroupLayoutKey = hashString( JSON.stringify( entries ) );
+ 
+ 		if ( bindingsData.layout ) {
+ 
+-			return bindingsData.layout.layoutGPU;
++			if ( bindingsData.layoutKey === bindGroupLayoutKey ) return bindingsData.layout.layoutGPU;
+ 
+-		}
+-
+-		// if not, assing one
++			this.deleteBindGroupData( bindGroup );
+ 
+-		const entries = this._createLayoutEntries( bindGroup );
+-		const bindGroupLayoutKey = hashString( JSON.stringify( entries ) );
++		}
+ 
+ 		// try to find an existing layout in the cache
+ 
+@@ -82131,6 +82413,9 @@ class WebGPUBindingUtils {
+ 
+ 		}
+ 
++		bindingsData.groups = [];
++		bindingsData.versions = [];
++
+ 	}
+ 
+ 	/**
+@@ -83814,6 +84099,14 @@ class WebGPUBackend extends Backend {
+ 		 */
+ 		this.compatibilityMode = null;
+ 
++		/**
++		 * A reference to the WebGPU instance that creates adapters.
++		 *
++		 * @type {?GPU}
++		 * @default null
++		 */
++		this.gpu = null;
++
+ 		/**
+ 		 * A reference to the device.
+ 		 *
+@@ -83926,7 +84219,9 @@ class WebGPUBackend extends Backend {
+ 				xrCompatible: renderer.xr.enabled
+ 			};
+ 
+-			const adapter = ( typeof navigator !== 'undefined' ) ? await navigator.gpu.requestAdapter( adapterOptions ) : null;
++			this.gpu = ( typeof navigator !== 'undefined' ) ? navigator.gpu : null;
++
++			const adapter = this.gpu !== null ? await this.gpu.requestAdapter( adapterOptions ) : null;
+ 
+ 			if ( adapter === null ) {
+ 
+@@ -85461,13 +85756,12 @@ class WebGPUBackend extends Backend {
+ 		for ( let i = 0, l = bindings.length; i < l; i ++ ) {
+ 
+ 			const bindGroup = bindings[ i ];
++			const bindingsData = this.get( bindGroup );
+ 
+-			if ( currentBindingGroups[ i ] !== bindGroup.id ) {
+-
+-				const bindingsData = this.get( bindGroup );
++			if ( currentBindingGroups[ i ] !== bindingsData.group ) {
+ 
+ 				passEncoderGPU.setBindGroup( i, bindingsData.group );
+-				currentBindingGroups[ i ] = bindGroup.id;
++				currentBindingGroups[ i ] = bindingsData.group;
+ 
+ 			}
+ 
+@@ -85766,6 +86060,7 @@ class WebGPUBackend extends Backend {
+ 		const utils = this.utils;
+ 
+ 		const sampleCount = utils.getSampleCountRenderContext( renderObject.context );
++		const bindGroupLayoutKeys = renderObject.getBindings().map( bindGroup => this.get( bindGroup ).layoutKey ).join( '|' );
+ 		const colorSpace = utils.getCurrentColorSpace( renderObject.context );
+ 		const colorFormat = utils.getCurrentColorFormat( renderObject.context );
+ 		const depthStencilFormat = utils.getCurrentDepthStencilFormat( renderObject.context );
+@@ -85787,7 +86082,8 @@ class WebGPUBackend extends Backend {
+ 			data.colorFormat !== colorFormat || data.depthStencilFormat !== depthStencilFormat ||
+ 			data.primitiveTopology !== primitiveTopology ||
+ 			data.frontFaceCW !== frontFaceCW ||
+-			data.clippingContextCacheKey !== renderObject.clippingContextCacheKey
++			data.clippingContextCacheKey !== renderObject.clippingContextCacheKey ||
++			data.bindGroupLayoutKeys !== bindGroupLayoutKeys
+ 		) {
+ 
+ 			data.material = material; data.materialVersion = material.version;
+@@ -85807,6 +86103,7 @@ class WebGPUBackend extends Backend {
+ 			data.primitiveTopology = primitiveTopology;
+ 			data.frontFaceCW = frontFaceCW;
+ 			data.clippingContextCacheKey = renderObject.clippingContextCacheKey;
++			data.bindGroupLayoutKeys = bindGroupLayoutKeys;
+ 
+ 			needsUpdate = true;
+ 
+@@ -85828,6 +86125,7 @@ class WebGPUBackend extends Backend {
+ 
+ 		const utils = this.utils;
+ 		const renderContext = renderObject.context;
++		const bindGroupLayoutKeys = renderObject.getBindings().map( bindGroup => this.get( bindGroup ).layoutKey ).join( '|' );
+ 
+ 		// meshes with negative scale have a different frontFace render pipeline
+ 		// descriptor value so the following must be honored in the cache key
+@@ -85846,6 +86144,7 @@ class WebGPUBackend extends Backend {
+ 			material.side,
+ 			frontFaceCW,
+ 			utils.getSampleCountRenderContext( renderContext ),
++			bindGroupLayoutKeys,
+ 			utils.getCurrentColorSpace( renderContext ), utils.getCurrentColorFormat( renderContext ), utils.getCurrentDepthStencilFormat( renderContext ),
+ 			utils.getPrimitiveTopology( object, material ),
+ 			renderObject.getGeometryCacheKey(),
+diff --git a/build/three.webgpu.nodes.js b/build/three.webgpu.nodes.js
+index f707acc..b8a7b2f 100644
+--- a/build/three.webgpu.nodes.js
++++ b/build/three.webgpu.nodes.js
+@@ -141,6 +141,15 @@ class NodeMaterialObserver {
+ 		 */
+ 		this.renderId = 0;
+ 
++		/**
++		 * Whether the current render produces motion vectors. Objects keep refreshing
++		 * fully while this is the case.
++		 *
++		 * @type {boolean}
++		 * @default false
++		 */
++		this.renderingVelocity = false;
++
+ 	}
+ 
+ 	/**
+@@ -240,6 +249,88 @@ class NodeMaterialObserver {
+ 
+ 	}
+ 
++	/**
++	 * Returns `true` if the given render object is a static object whose per-object state - world
++	 * matrix, material, geometry and the scene environment - did not change since the last
++	 * refresh. A settled object is still drawn every frame and its FRAME and RENDER nodes still
++	 * have to be updated; what it may skip is the work whose inputs it froze: its OBJECT node
++	 * updates, its object uniform group upload and its per-draw attribute scan.
++	 *
++	 * @param {RenderObject} renderObject - The render object.
++	 * @return {boolean} Whether the given render object is settled or not.
++	 */
++	isSettled( renderObject ) {
++
++		const data = this.renderObjects.get( renderObject );
++
++		return data !== undefined && data.settledState === true;
++
++	}
++
++	/**
++	 * Recomputes {@link NodeMaterialObserver#isSettled} for the given render object, once per draw,
++	 * so every step of that draw reads the same answer.
++	 *
++	 * @param {RenderObject} renderObject - The render object.
++	 * @return {boolean} Whether the given render object is settled or not.
++	 */
++	updateSettled( renderObject ) {
++
++		const { object, material, geometry, scene } = renderObject;
++		const data = this.getRenderObjectData( renderObject );
++
++		if ( object.static !== true || this.renderingVelocity === true ) {
++
++			data.settledState = false;
++
++			return false;
++
++		}
++
++		let settled = data.settled;
++
++		if ( settled === undefined ) {
++
++			data.settled = settled = {
++				matrix: object.matrixWorld.clone(),
++				environmentRotation: scene.environmentRotation.clone(),
++				environmentIntensity: scene.environmentIntensity,
++				materialVersion: material.version,
++				geometryVersion: geometry.version
++			};
++
++			data.settledState = false;
++
++			return false;
++
++		}
++
++		if ( settled.matrix.equals( object.matrixWorld ) !== true ||
++			settled.environmentRotation.equals( scene.environmentRotation ) !== true ||
++			settled.environmentIntensity !== scene.environmentIntensity ||
++			settled.materialVersion !== material.version ||
++			settled.geometryVersion !== geometry.version ) {
++
++			// re-arm with the current state, so the object settles again once it stops changing
++
++			settled.matrix.copy( object.matrixWorld );
++			settled.environmentRotation.copy( scene.environmentRotation );
++			settled.environmentIntensity = scene.environmentIntensity;
++			settled.materialVersion = material.version;
++			settled.geometryVersion = geometry.version;
++
++			data.settledState = false;
++
++			return false;
++
++		}
++
++		data.settledState = true;
++
++		return true;
++
++	}
++
+ 	/**
+ 	 * Returns an attribute data structure holding the attributes versions for
+ 	 * monitoring.
+@@ -306,7 +397,6 @@ class NodeMaterialObserver {
+ 
+ 			data = {
+ 				_renderId: -1,
+-				_equal: false,
+ 
+ 				attributes: this.getAttributesData( geometry.attributes ),
+ 				indexId: geometry.index ? geometry.index.id : null,
+@@ -335,7 +425,7 @@ class NodeMaterialObserver {
+ 
+ 		if ( data === undefined ) {
+ 
+-			data = { _renderId: -1, _equal: false };
++			data = { _renderId: -1 };
+ 
+ 			for ( const property of this.refreshUniforms ) {
+ 
+@@ -419,7 +509,6 @@ class NodeMaterialObserver {
+ 
+ 						value.copy( mtlValue );
+ 
+-						materialData._equal = false;
+ 						return false;
+ 
+ 					}
+@@ -431,7 +520,6 @@ class NodeMaterialObserver {
+ 						value.id = mtlValue.id;
+ 						value.version = mtlValue.version;
+ 
+-						materialData._equal = false;
+ 						return false;
+ 
+ 					}
+@@ -440,7 +528,6 @@ class NodeMaterialObserver {
+ 
+ 					materialData[ property ] = mtlValue;
+ 
+-					materialData._equal = false;
+ 					return false;
+ 
+ 				}
+@@ -456,18 +543,12 @@ class NodeMaterialObserver {
+ 					renderObjectData.bufferWidth = width;
+ 					renderObjectData.bufferHeight = height;
+ 
+-					materialData._equal = false;
+ 					return false;
+ 
+ 				}
+ 
+ 			}
+ 
+-			materialData._equal = true;
+-
+-		} else {
+-
+-			if ( materialData._equal === false ) return false;
+ 
+ 		}
+ 
+@@ -510,7 +591,6 @@ class NodeMaterialObserver {
+ 					// attribute was removed
+ 					delete storedAttributes[ name ];
+ 
+-					geometryData._equal = false;
+ 					return false;
+ 
+ 				}
+@@ -523,7 +603,6 @@ class NodeMaterialObserver {
+ 					storedAttributeData.id = id;
+ 					storedAttributeData.version = version;
+ 
+-					geometryData._equal = false;
+ 					return false;
+ 
+ 				}
+@@ -534,7 +613,6 @@ class NodeMaterialObserver {
+ 
+ 				geometryData.attributes = this.getAttributesData( attributes );
+ 
+-				geometryData._equal = false;
+ 				return false;
+ 
+ 			}
+@@ -552,7 +630,6 @@ class NodeMaterialObserver {
+ 				geometryData.indexId = currentIndexId;
+ 				geometryData.indexVersion = currentIndexVersion;
+ 
+-				geometryData._equal = false;
+ 				return false;
+ 
+ 			}
+@@ -564,16 +641,10 @@ class NodeMaterialObserver {
+ 				geometryData.drawRange.start = geometry.drawRange.start;
+ 				geometryData.drawRange.count = geometry.drawRange.count;
+ 
+-				geometryData._equal = false;
+ 				return false;
+ 
+ 			}
+ 
+-			geometryData._equal = true;
+-
+-		} else {
+-
+-			if ( geometryData._equal === false ) return false;
+ 
+ 		}
+ 
+@@ -724,7 +795,14 @@ class NodeMaterialObserver {
+ 	 */
+ 	needsRefresh( renderObject, nodeFrame ) {
+ 
+-		if ( this.hasNode || this.hasAnimation || this.firstInitialization( renderObject ) || this.needsVelocity( nodeFrame.renderer ) )
++		this.renderingVelocity = this.needsVelocity( nodeFrame.renderer );
++
++		// Answered for the whole draw, so updateBefore, the geometry scan, the node updates and
++		// the object uniform upload of this object all skip or all refresh.
++
++		this.updateSettled( renderObject );
++
++		if ( this.hasNode || this.hasAnimation || this.firstInitialization( renderObject ) || this.renderingVelocity )
+ 			return true;
+ 
+ 		const { renderId } = nodeFrame;
+@@ -737,10 +815,14 @@ class NodeMaterialObserver {
+ 
+ 		}
+ 
+-		const isStatic = renderObject.object.static === true;
+ 		const isBundle = renderObject.bundle !== null && renderObject.bundle.static === true && this.getRenderObjectData( renderObject ).version === renderObject.bundle.version;
+ 
+-		if ( isStatic || isBundle )
++		// `object.static` is not the question - it is a switch, and a brand new object has it set
++		// before it has been drawn once, so answering from it skips the draw that creates this
++		// object's bind groups and leaves the pipeline reading a layout that was never built. A
++		// static object that moved, or whose material or geometry was edited, has to refresh like
++		// any other; only a settled one may skip, and nothing is settled before its first refresh.
++		if ( this.isSettled( renderObject ) === true || isBundle )
+ 			return false;
+ 
+ 		const lightsData = this.getLights( renderObject.lightsNode, renderId );
+@@ -18320,7 +18402,8 @@ function createInstanceMatrixNode( builder, instanceMatrix ) {
+ 
+ 		const uniformBufferSize = matrixCount * 16 * 4;
+ 
+-		if ( uniformBufferSize <= builder.getUniformBufferLimit() ) {
++		// threenative: the uniform path re-uploads every draw; the attribute path uploads on version change
++		if ( false ) {
+ 
+ 			instanceMatrixNode = buffer( instanceMatrix.array, 'mat4', matrixCount ).element( instanceIndex );
+ 
+@@ -18414,7 +18497,8 @@ const instance = /*@__PURE__*/ Fn( ( [ matrices, colors = null ], builder ) => {
+ 
+ 		const uniformBufferSize = Math.max( matrices.count, 1 ) * 16 * 4;
+ 
+-		if ( uniformBufferSize > builder.getUniformBufferLimit() ) {
++		// threenative: the uniform path re-uploads every draw; the attribute path uploads on version change
++		if ( true ) {
+ 
+ 			interleavedMatrix = _matrixBuffers.get( matrices );
+ 
+@@ -31165,6 +31249,14 @@ class Geometries extends DataMap {
+ 		 */
+ 		this._geometryDisposeListeners = new Map();
+ 
++		/**
++		 * This Weak Map holds the attribute versions a settled render object was last drawn with,
++		 * so a write into one of them is what brings the object back out of the settled path.
++		 *
++		 * @type {WeakMap<RenderObject,Map<BufferAttribute,number>>}
++		 */
++		this._settledAttributes = new WeakMap();
++
+ 	}
+ 
+ 	/**
+@@ -31190,10 +31282,69 @@ class Geometries extends DataMap {
+ 
+ 		if ( this.has( renderObject ) === false ) this.initGeometry( renderObject );
+ 
++		// A settled static object has no attribute that could have changed since the last refresh,
++		// unless a writer bumped one. An InstancedMesh's instance buffer is a vertex attribute of
++		// this draw, and a BufferGeometry carries no version of its own to announce the write, so
++		// the attributes' own versions are the signal - and the only one there is.
++
++		const monitor = renderObject.getMonitor();
++
++		if ( monitor !== undefined && monitor.isSettled( renderObject ) === true && this.attributesChanged( renderObject ) === false ) return;
++
+ 		this.updateAttributes( renderObject );
+ 
+ 	}
+ 
++	/**
++	 * Returns `true` if an attribute of the given render object - or its index - was written to
++	 * since the last time its versions were read, and records the versions it holds now.
++	 *
++	 * @param {RenderObject} renderObject - The render object.
++	 * @return {boolean} Whether any of the render object's versions moved.
++	 */
++	attributesChanged( renderObject ) {
++
++		const attributes = renderObject.getAttributes();
++		const index = this.getIndex( renderObject );
++		const settled = this._settledAttributes.get( renderObject );
++
++		if ( settled !== undefined && settled.size === attributes.length + ( index === null ? 0 : 1 ) ) {
++
++			let changed = false;
++
++			for ( const attribute of attributes ) {
++
++				if ( settled.get( attribute.isInterleavedBufferAttribute ? attribute.data : attribute ) !== attribute.version ) {
++
++					changed = true;
++					break;
++
++				}
++
++			}
++
++			if ( changed === false && ( index === null || settled.get( index ) === index.version ) ) return false;
++
++		}
++
++		const versions = new Map();
++
++		for ( const attribute of attributes ) {
++
++			const data = attribute.isInterleavedBufferAttribute ? attribute.data : attribute;
++
++			versions.set( data, data.version );
++
++		}
++
++		if ( index !== null ) versions.set( index, index.version );
++
++		this._settledAttributes.set( renderObject, versions );
++
++		return true;
++
++	}
++
+ 	/**
+ 	 * Initializes the geometry of the given render object.
+ 	 *
+@@ -32771,7 +32922,7 @@ class Bindings extends DataMap {
+ 	 */
+ 	updateForRender( renderObject ) {
+ 
+-		this._updateBindings( this.getForRender( renderObject ) );
++		this._updateBindings( this.getForRender( renderObject ), this.nodes.isSettled( renderObject ) );
+ 
+ 	}
+ 
+@@ -32918,12 +33069,13 @@ class Bindings extends DataMap {
+ 	 * Updates the given array of bindings.
+ 	 *
+ 	 * @param {Array<BindGroup>} bindings - The bind groups.
++	 * @param {boolean} [settled] - Whether the render object is a settled static object.
+ 	 */
+-	_updateBindings( bindings ) {
++	_updateBindings( bindings, settled ) {
+ 
+ 		for ( const bindGroup of bindings ) {
+ 
+-			this._update( bindGroup, bindings );
++			this._update( bindGroup, bindings, settled );
+ 
+ 		}
+ 
+@@ -32934,11 +33086,27 @@ class Bindings extends DataMap {
+ 	 *
+ 	 * @param {BindGroup} bindGroup - The bind group to update.
+ 	 * @param {Array<BindGroup>} bindings - The bind groups.
++	 * @param {boolean} [settled] - Whether the render object is a settled static object.
+ 	 */
+-	_update( bindGroup, bindings ) {
++	_update( bindGroup, bindings, settled ) {
+ 
+ 		const { backend } = this;
+ 
++		// A group a node added after this object's first draw has no buffers and no layout yet, and
++		// the pipeline reads that layout whatever this draw decides to do with it - so it is built
++		// here, on every draw. A group that did not exist cannot have been written either, so it is
++		// written now: `settled` is what tells the loop below to write it, not to skip it.
++		if ( this.get( bindGroup ).bindGroup === undefined ) {
++
++			this._createBindings( [ bindGroup ] );
++
++			settled = false;
++
++		}
++
++		// a settled object keeps the values it uploaded the last time it refreshed, so an object
++		// group it has already written is the one thing in here it may skip
++
+ 		let needsBindingsUpdate = false;
+ 		let cacheBindings = true;
+ 		let cacheIndex = 0;
+@@ -32948,7 +33116,7 @@ class Bindings extends DataMap {
+ 
+ 		for ( const binding of bindGroup.bindings ) {
+ 
+-			const updatedGroup = this.nodes.updateGroup( binding );
++			const updatedGroup = this.nodes.updateGroup( binding, settled );
+ 
+ 			// every uniforms group is a uniform buffer. So if no update is required,
+ 			// we move one with the next binding. Otherwise the next if block will update the group.
+@@ -34181,6 +34349,21 @@ class Textures extends DataMap {
+ 
+ 			backend.destroyTexture( texture );
+ 
++			// delete cached bind groups so they don't point to the destroyed texture
++
++			if ( textureData.bindGroups ) {
++
++				for ( const bindGroup of textureData.bindGroups ) {
++
++					const bindingsData = this.backend.get( bindGroup );
++
++					bindingsData.groups = undefined;
++					bindingsData.versions = undefined;
++
++				}
++
++			}
++
+ 		}
+ 
+ 		//
+@@ -55244,15 +55427,17 @@ class NodeManager extends DataMap {
+ 	 * Returns `true` if the given node uniforms group must be updated or not.
+ 	 *
+ 	 * @param {NodeUniformsGroup} nodeUniformsGroup - The node uniforms group.
++	 * @param {boolean} [settled] - Whether the render object is a settled static object.
+ 	 * @return {boolean} Whether the node uniforms group requires an update or not.
+ 	 */
+-	updateGroup( nodeUniformsGroup ) {
++	updateGroup( nodeUniformsGroup, settled ) {
+ 
+ 		const groupNode = nodeUniformsGroup.groupNode;
+ 
+-		// groups that are updated per object always require an update so no further checks are needed
++		// groups that are updated per object always require an update so no further checks are needed.
++		// A settled static object keeps the values it uploaded the last time it was refreshed.
+ 
+-		if ( groupNode.updateType === NodeUpdateType.OBJECT ) return true;
++		if ( groupNode.updateType === NodeUpdateType.OBJECT ) return settled !== true;
+ 
+ 		// check for update
+ 
+@@ -56056,6 +56241,21 @@ class NodeManager extends DataMap {
+ 
+ 	}
+ 
++	/**
++	 * Returns `true` if the per-object updates of the given render object can be skipped
++	 * because the object is static and nothing it depends on changed since its last refresh.
++	 *
++	 * @param {RenderObject} renderObject - The render object.
++	 * @return {boolean} Whether the render object is settled or not.
++	 */
++	isSettled( renderObject ) {
++
++		const monitor = renderObject.getMonitor();
++
++		return monitor !== undefined ? monitor.isSettled( renderObject ) : false;
++
++	}
++
+ 	/**
+ 	 * Triggers the call of `updateBefore()` methods
+ 	 * for all nodes of the given render object.
+@@ -56065,9 +56265,14 @@ class NodeManager extends DataMap {
+ 	updateBefore( renderObject ) {
+ 
+ 		const nodeBuilder = renderObject.getNodeBuilderState();
++		const settled = this.isSettled( renderObject );
+ 
+ 		for ( const node of nodeBuilder.updateBeforeNodes ) {
+ 
++			// a settled static object has nothing to update per object
++
++			if ( settled === true && node.getUpdateBeforeType() === NodeUpdateType.OBJECT ) continue;
++
+ 			// update frame state for each node
+ 
+ 			this.getNodeFrameForRender( renderObject ).updateBeforeNode( node );
+@@ -56085,10 +56290,11 @@ class NodeManager extends DataMap {
+ 	updateAfter( renderObject ) {
+ 
+ 		const nodeBuilder = renderObject.getNodeBuilderState();
++		const settled = this.isSettled( renderObject );
+ 
+ 		for ( const node of nodeBuilder.updateAfterNodes ) {
+ 
+-			// update frame state for each node
++			if ( settled === true && node.getUpdateAfterType() === NodeUpdateType.OBJECT ) continue;
+ 
+ 			this.getNodeFrameForRender( renderObject ).updateAfterNode( node );
+ 
+@@ -56125,9 +56331,14 @@ class NodeManager extends DataMap {
+ 
+ 		const nodeFrame = this.getNodeFrameForRender( renderObject );
+ 		const nodeBuilder = renderObject.getNodeBuilderState();
++		const settled = this.isSettled( renderObject );
+ 
+ 		for ( const node of nodeBuilder.updateNodes ) {
+ 
++			// a settled static object keeps the per-object values it uploaded last time
++
++			if ( settled === true && node.getUpdateType() === NodeUpdateType.OBJECT ) continue;
++
+ 			nodeFrame.updateNode( node );
+ 
+ 		}
+@@ -62886,18 +63097,17 @@ class Renderer {
+ 
+ 		//
+ 
+-		const needsRefresh = this._nodes.needsRefresh( renderObject );
+-
+-		if ( needsRefresh ) {
+-
+-			this._nodes.updateBefore( renderObject );
+-
+-			this._geometries.updateForRender( renderObject );
+-
+-			this._nodes.updateForRender( renderObject );
+-			this._bindings.updateForRender( renderObject );
++		this._nodes.needsRefresh( renderObject );
+ 
+-		}
++		// Every step of a draw runs, settled or not. What a settled static object skips is decided
++		// inside each of them - its OBJECT node updates, its object uniform group write and its
++		// attribute scan - because each of those answers for itself, and a step left out here
++		// cannot: a group a node added after this object's first draw still has to be created, and
++		// the pipeline reads that group's layout whatever this draw decided to do with it.
++		this._geometries.updateForRender( renderObject );
++		this._nodes.updateBefore( renderObject );
++		this._nodes.updateForRender( renderObject );
++		this._bindings.updateForRender( renderObject );
+ 
+ 		this._pipelines.updateForRender( renderObject );
+ 
+@@ -62907,7 +63117,7 @@ class Renderer {
+ 
+ 			this.backend.draw( renderObject, this.info );
+ 
+-			if ( needsRefresh ) this._nodes.updateAfter( renderObject );
++			this._nodes.updateAfter( renderObject );
+ 
+ 		}
+ 
+@@ -79004,7 +79214,14 @@ class WGSLNodeBuilder extends NodeBuilder {
+ 
+ 		} else {
+ 
+-			snippet = `textureLoad( ${ textureProperty }, ${ uvIndexSnippet }, u32( ${ levelSnippet } ) )`;
++			// naga v25 (wgpu-native v25.0.2.2) rejects a u32 sample index on a
++			// multisampled textureLoad; i32 is accepted by every backend. Mip-level
++			// operands (including the array form above) stay u32.
++			const sampleData = texture ? this.renderer?.backend?.utils?.getTextureSampleData?.( texture ) : null;
++			const backendMultisampled = sampleData !== null && sampleData !== undefined && sampleData.primarySamples > 1;
++			const targetMultisampled = Boolean( texture && texture.renderTarget && texture.renderTarget.samples > 1 );
++			const indexType = ( backendMultisampled || targetMultisampled ) ? 'i32' : 'u32';
++			snippet = `textureLoad( ${ textureProperty }, ${ uvIndexSnippet }, ${ indexType }( ${ levelSnippet } ) )`;
+ 
+ 			if ( this.renderer.backend.compatibilityMode && texture.isDepthTexture ) {
+ 
+@@ -81295,9 +81512,15 @@ class WebGPUAttributeUtils {
+ 	destroyAttribute( attribute ) {
+ 
+ 		const backend = this.backend;
+-		const data = backend.get( this._getBufferAttribute( attribute ) );
++		const bufferAttribute = this._getBufferAttribute( attribute );
++		const data = backend.get( bufferAttribute );
++
++		// An interleaved attribute's GPU buffer lives on its InterleavedBuffer, and several attributes
++		// share it: destroy it once and forget it there too, as the WebGL backend does, or the next
++		// createAttribute() finds the destroyed buffer and submits it (threenative patch).
++		if ( data.buffer !== undefined ) data.buffer.destroy();
+ 
+-		data.buffer.destroy();
++		if ( bufferAttribute !== attribute ) backend.delete( bufferAttribute );
+ 
+ 		backend.delete( attribute );
+ 
+diff --git a/src/materials/nodes/manager/NodeMaterialObserver.js b/src/materials/nodes/manager/NodeMaterialObserver.js
+index 1f4c254..7e2cb99 100644
+--- a/src/materials/nodes/manager/NodeMaterialObserver.js
++++ b/src/materials/nodes/manager/NodeMaterialObserver.js
+@@ -133,6 +133,15 @@ class NodeMaterialObserver {
+ 		 */
+ 		this.renderId = 0;
+ 
++		/**
++		 * Whether the current render produces motion vectors. Objects keep refreshing
++		 * fully while this is the case.
++		 *
++		 * @type {boolean}
++		 * @default false
++		 */
++		this.renderingVelocity = false;
++
+ 	}
+ 
+ 	/**
+@@ -232,6 +241,88 @@ class NodeMaterialObserver {
+ 
+ 	}
+ 
++	/**
++	 * Returns `true` if the given render object is a static object whose per-object state - world
++	 * matrix, material, geometry and the scene environment - did not change since the last
++	 * refresh. A settled object is still drawn every frame and its FRAME and RENDER nodes still
++	 * have to be updated; what it may skip is the work whose inputs it froze: its OBJECT node
++	 * updates, its object uniform group upload and its per-draw attribute scan.
++	 *
++	 * @param {RenderObject} renderObject - The render object.
++	 * @return {boolean} Whether the given render object is settled or not.
++	 */
++	isSettled( renderObject ) {
++
++		const data = this.renderObjects.get( renderObject );
++
++		return data !== undefined && data.settledState === true;
++
++	}
++
++	/**
++	 * Recomputes {@link NodeMaterialObserver#isSettled} for the given render object, once per draw,
++	 * so every step of that draw reads the same answer.
++	 *
++	 * @param {RenderObject} renderObject - The render object.
++	 * @return {boolean} Whether the given render object is settled or not.
++	 */
++	updateSettled( renderObject ) {
++
++		const { object, material, geometry, scene } = renderObject;
++		const data = this.getRenderObjectData( renderObject );
++
++		if ( object.static !== true || this.renderingVelocity === true ) {
++
++			data.settledState = false;
++
++			return false;
++
++		}
++
++		let settled = data.settled;
++
++		if ( settled === undefined ) {
++
++			data.settled = settled = {
++				matrix: object.matrixWorld.clone(),
++				environmentRotation: scene.environmentRotation.clone(),
++				environmentIntensity: scene.environmentIntensity,
++				materialVersion: material.version,
++				geometryVersion: geometry.version
++			};
++
++			data.settledState = false;
++
++			return false;
++
++		}
++
++		if ( settled.matrix.equals( object.matrixWorld ) !== true ||
++			settled.environmentRotation.equals( scene.environmentRotation ) !== true ||
++			settled.environmentIntensity !== scene.environmentIntensity ||
++			settled.materialVersion !== material.version ||
++			settled.geometryVersion !== geometry.version ) {
++
++			// re-arm with the current state, so the object settles again once it stops changing
++
++			settled.matrix.copy( object.matrixWorld );
++			settled.environmentRotation.copy( scene.environmentRotation );
++			settled.environmentIntensity = scene.environmentIntensity;
++			settled.materialVersion = material.version;
++			settled.geometryVersion = geometry.version;
++
++			data.settledState = false;
++
++			return false;
++
++		}
++
++		data.settledState = true;
++
++		return true;
++
++	}
++
+ 	/**
+ 	 * Returns an attribute data structure holding the attributes versions for
+ 	 * monitoring.
+@@ -298,7 +389,6 @@ class NodeMaterialObserver {
+ 
+ 			data = {
+ 				_renderId: - 1,
+-				_equal: false,
+ 
+ 				attributes: this.getAttributesData( geometry.attributes ),
+ 				indexId: geometry.index ? geometry.index.id : null,
+@@ -327,7 +417,7 @@ class NodeMaterialObserver {
+ 
+ 		if ( data === undefined ) {
+ 
+-			data = { _renderId: - 1, _equal: false };
++			data = { _renderId: - 1 };
+ 
+ 			for ( const property of this.refreshUniforms ) {
+ 
+@@ -411,7 +501,6 @@ class NodeMaterialObserver {
+ 
+ 						value.copy( mtlValue );
+ 
+-						materialData._equal = false;
+ 						return false;
+ 
+ 					}
+@@ -423,7 +512,6 @@ class NodeMaterialObserver {
+ 						value.id = mtlValue.id;
+ 						value.version = mtlValue.version;
+ 
+-						materialData._equal = false;
+ 						return false;
+ 
+ 					}
+@@ -432,7 +520,6 @@ class NodeMaterialObserver {
+ 
+ 					materialData[ property ] = mtlValue;
  
-@@ -30719,6 +30757,8 @@ class RenderObjects {
+-					materialData._equal = false;
+ 					return false;
  
- 					renderObject.version = material.version;
+ 				}
+@@ -448,18 +535,12 @@ class NodeMaterialObserver {
+ 					renderObjectData.bufferWidth = width;
+ 					renderObjectData.bufferHeight = height;
+ 
+-					materialData._equal = false;
+ 					return false;
  
-+					if ( sourceTracked ) renderObject.sourceVersion = sourceMaterial.version;
-+
  				}
  
  			}
-@@ -39725,7 +39765,8 @@ class VelocityNode extends TempNode {
- 
- 		const previousModelMatrix = getPreviousMatrix( object );
  
--		this.previousModelWorldMatrix.value.copy( previousModelMatrix );
-+		const scheduledPrevious = object[ Symbol.for( 'threenative.velocity.previousWorldMatrix' ) ];
-+		this.previousModelWorldMatrix.value.copy( scheduledPrevious ?? previousModelMatrix );
+-			materialData._equal = true;
+-
+-		} else {
+-
+-			if ( materialData._equal === false ) return false;
  
- 		//
+ 		}
  
-@@ -53841,7 +53882,7 @@ class NodeBuilder {
+@@ -502,7 +583,6 @@ class NodeMaterialObserver {
+ 					// attribute was removed
+ 					delete storedAttributes[ name ];
  
- 		const mrt = this.renderer.getMRT();
+-					geometryData._equal = false;
+ 					return false;
  
--		return ( mrt && mrt.has( 'velocity' ) ) || getDataFromObject( this.object ).useVelocity === true;
-+		return ( mrt && mrt.has( 'velocity' ) ) || getDataFromObject( this.object ).useVelocity === true || this.object.userData?.useVelocity === true;
+ 				}
+@@ -515,7 +595,6 @@ class NodeMaterialObserver {
+ 					storedAttributeData.id = id;
+ 					storedAttributeData.version = version;
  
- 	}
+-					geometryData._equal = false;
+ 					return false;
  
-@@ -62731,6 +62772,7 @@ class Renderer {
- 		let materialDisplacementMap;
- 		let materialDisplacementScale;
- 		let materialDisplacementBias;
-+		let materialAlphaTest;
+ 				}
+@@ -526,7 +605,6 @@ class NodeMaterialObserver {
  
- 		const previousSourceMaterial = this._currentSourceMaterial;
+ 				geometryData.attributes = this.getAttributesData( attributes );
  
-@@ -62756,6 +62798,7 @@ class Renderer {
- 			materialDisplacementMap = overrideMaterial.displacementMap;
- 			materialDisplacementScale = overrideMaterial.displacementScale;
- 			materialDisplacementBias = overrideMaterial.displacementBias;
-+			materialAlphaTest = overrideMaterial.alphaTest;
+-				geometryData._equal = false;
+ 				return false;
  
- 			if ( material.positionNode && material.positionNode.isNode ) {
+ 			}
+@@ -544,7 +622,6 @@ class NodeMaterialObserver {
+ 				geometryData.indexId = currentIndexId;
+ 				geometryData.indexVersion = currentIndexVersion;
  
-@@ -62763,7 +62806,15 @@ class Renderer {
+-				geometryData._equal = false;
+ 				return false;
  
  			}
+@@ -556,16 +633,10 @@ class NodeMaterialObserver {
+ 				geometryData.drawRange.start = geometry.drawRange.start;
+ 				geometryData.drawRange.count = geometry.drawRange.count;
  
--			overrideMaterial.alphaTest = material.alphaTest;
-+			// `Material.alphaTest`'s setter bumps `version` whenever alpha-test-ness flips, and this
-+			// override material is shared by every caster in the pass. A scene that mixes alpha-tested
-+			// casters with opaque ones therefore moves that shared version several times per frame,
-+			// and every OTHER render object drawn with it then fails the version gate in
-+			// `RenderObjects.get` and recomputes a full material cache key that always matches.
-+			// Writing the backing field leaves the `alphaTest` getter — and so the cache key — still
-+			// reporting this caster's value, while each render object tracks the staleness signal
-+			// that belongs to it: its own source material's version.
-+			overrideMaterial._alphaTest = material.alphaTest;
- 			overrideMaterial.alphaMap = material.alphaMap;
- 			overrideMaterial.displacementMap = material.displacementMap;
- 			overrideMaterial.displacementScale = material.displacementScale;
-@@ -62825,6 +62876,7 @@ class Renderer {
- 			scene.overrideMaterial.displacementMap = materialDisplacementMap;
- 			scene.overrideMaterial.displacementScale = materialDisplacementScale;
- 			scene.overrideMaterial.displacementBias = materialDisplacementBias;
-+			scene.overrideMaterial._alphaTest = materialAlphaTest;
+-				geometryData._equal = false;
+ 				return false;
  
- 		}
+ 			}
  
-@@ -79586,7 +79638,8 @@ class WGSLNodeBuilder extends NodeBuilder {
+-			geometryData._equal = true;
+-
+-		} else {
+-
+-			if ( geometryData._equal === false ) return false;
  
- 				uniformGPU = buffer;
+ 		}
  
--				uniformNode.name = name ? name : 'NodeBuffer_' + uniformNode.id;
-+				// The base builder supplies a unique name within this program. A process-wide
-+				// allocation id changes otherwise identical shader source for every buffer.
+@@ -716,7 +787,14 @@ class NodeMaterialObserver {
+ 	 */
+ 	needsRefresh( renderObject, nodeFrame ) {
  
- 			} else {
+-		if ( this.hasNode || this.hasAnimation || this.firstInitialization( renderObject ) || this.needsVelocity( nodeFrame.renderer ) )
++		this.renderingVelocity = this.needsVelocity( nodeFrame.renderer );
++
++		// Answered for the whole draw, so updateBefore, the geometry scan, the node updates and
++		// the object uniform upload of this object all skip or all refresh.
++
++		this.updateSettled( renderObject );
++
++		if ( this.hasNode || this.hasAnimation || this.firstInitialization( renderObject ) || this.renderingVelocity )
+ 			return true;
  
-@@ -83814,6 +83867,14 @@ class WebGPUBackend extends Backend {
- 		 */
- 		this.compatibilityMode = null;
+ 		const { renderId } = nodeFrame;
+@@ -729,10 +807,14 @@ class NodeMaterialObserver {
  
-+		/**
-+		 * A reference to the WebGPU instance that creates adapters.
-+		 *
-+		 * @type {?GPU}
-+		 * @default null
-+		 */
-+		this.gpu = null;
-+
- 		/**
- 		 * A reference to the device.
- 		 *
-@@ -83926,7 +83987,9 @@ class WebGPUBackend extends Backend {
- 				xrCompatible: renderer.xr.enabled
- 			};
+ 		}
  
--			const adapter = ( typeof navigator !== 'undefined' ) ? await navigator.gpu.requestAdapter( adapterOptions ) : null;
-+			this.gpu = ( typeof navigator !== 'undefined' ) ? navigator.gpu : null;
-+
-+			const adapter = this.gpu !== null ? await this.gpu.requestAdapter( adapterOptions ) : null;
+-		const isStatic = renderObject.object.static === true;
+ 		const isBundle = renderObject.bundle !== null && renderObject.bundle.static === true && this.getRenderObjectData( renderObject ).version === renderObject.bundle.version;
  
- 			if ( adapter === null ) {
+-		if ( isStatic || isBundle )
++		// `object.static` is not the question - it is a switch, and a brand new object has it set
++		// before it has been drawn once, so answering from it skips the draw that creates this
++		// object's bind groups and leaves the pipeline reading a layout that was never built. A
++		// static object that moved, or whose material or geometry was edited, has to refresh like
++		// any other; only a settled one may skip, and nothing is settled before its first refresh.
++		if ( this.isSettled( renderObject ) === true || isBundle )
+ 			return false;
  
+ 		const lightsData = this.getLights( renderObject.lightsNode, renderId );
 diff --git a/src/nodes/accessors/Batch.js b/src/nodes/accessors/Batch.js
-index ab62e98dadab2539d7e1d663fd42267bbc8ebcaa..2cf4bb6039853d5c922e89041419250b243694ef 100644
+index ab62e98..2cf4bb6 100644
 --- a/src/nodes/accessors/Batch.js
 +++ b/src/nodes/accessors/Batch.js
 @@ -1,6 +1,6 @@
@@ -278,10 +1876,30 @@ index ab62e98dadab2539d7e1d663fd42267bbc8ebcaa..2cf4bb6039853d5c922e89041419250b
 -
 -
 diff --git a/src/nodes/accessors/Instance.js b/src/nodes/accessors/Instance.js
-index b89834b9166c75fd946ade24db265bf8c367d244..c7b7bdd7a31d852a581d4bc75a1e1afc1d214e5e 100644
+index b89834b..ed00e75 100644
 --- a/src/nodes/accessors/Instance.js
 +++ b/src/nodes/accessors/Instance.js
-@@ -220,7 +220,8 @@ export const instance = /*@__PURE__*/ Fn( ( [ matrices, colors = null ], builder
+@@ -40,7 +40,8 @@ function createInstanceMatrixNode( builder, instanceMatrix ) {
+ 
+ 		const uniformBufferSize = matrixCount * 16 * 4;
+ 
+-		if ( uniformBufferSize <= builder.getUniformBufferLimit() ) {
++		// threenative: the uniform path re-uploads every draw; the attribute path uploads on version change
++		if ( false ) {
+ 
+ 			instanceMatrixNode = buffer( instanceMatrix.array, 'mat4', matrixCount ).element( instanceIndex );
+ 
+@@ -134,7 +135,8 @@ export const instance = /*@__PURE__*/ Fn( ( [ matrices, colors = null ], builder
+ 
+ 		const uniformBufferSize = Math.max( matrices.count, 1 ) * 16 * 4;
+ 
+-		if ( uniformBufferSize > builder.getUniformBufferLimit() ) {
++		// threenative: the uniform path re-uploads every draw; the attribute path uploads on version change
++		if ( true ) {
+ 
+ 			interleavedMatrix = _matrixBuffers.get( matrices );
+ 
+@@ -220,7 +222,8 @@ export const instance = /*@__PURE__*/ Fn( ( [ matrices, colors = null ], builder
  
  			const previousInstanceData = _previousInstanceMatrices.get( object );
  
@@ -292,7 +1910,7 @@ index b89834b9166c75fd946ade24db265bf8c367d244..c7b7bdd7a31d852a581d4bc75a1e1afc
  		} );
  
 diff --git a/src/nodes/accessors/Skinning.js b/src/nodes/accessors/Skinning.js
-index 2356aed8656dceb1ea74b73ea2e739371a960484..aaeea633a8ece291be5faf868e312867ddad01b6 100644
+index 2356aed..aaeea63 100644
 --- a/src/nodes/accessors/Skinning.js
 +++ b/src/nodes/accessors/Skinning.js
 @@ -149,7 +149,8 @@ export const skinning = /*@__PURE__*/ Fn( ( [ skinnedMesh ], builder ) => {
@@ -316,7 +1934,7 @@ index 2356aed8656dceb1ea74b73ea2e739371a960484..aaeea633a8ece291be5faf868e312867
  			}
  
 diff --git a/src/nodes/accessors/VelocityNode.js b/src/nodes/accessors/VelocityNode.js
-index 373548b0b587e7da3ef0993bfe316af420e7f66c..c48002abbce20ee8b29908cf314d7b03afe0db03 100644
+index 373548b..c48002a 100644
 --- a/src/nodes/accessors/VelocityNode.js
 +++ b/src/nodes/accessors/VelocityNode.js
 @@ -106,7 +106,8 @@ class VelocityNode extends TempNode {
@@ -330,7 +1948,7 @@ index 373548b0b587e7da3ef0993bfe316af420e7f66c..c48002abbce20ee8b29908cf314d7b03
  		//
  
 diff --git a/src/nodes/core/NodeBuilder.js b/src/nodes/core/NodeBuilder.js
-index be00b81ef36e1af83b0066603e616f8f1f81a115..1990da8fe8f1f29a7b53030756dfd966d8de3cb6 100644
+index be00b81..1990da8 100644
 --- a/src/nodes/core/NodeBuilder.js
 +++ b/src/nodes/core/NodeBuilder.js
 @@ -3450,7 +3450,7 @@ class NodeBuilder {
@@ -343,7 +1961,7 @@ index be00b81ef36e1af83b0066603e616f8f1f81a115..1990da8fe8f1f29a7b53030756dfd966
  	}
  
 diff --git a/src/objects/BatchedMesh.js b/src/objects/BatchedMesh.js
-index 2ef7cb257438826059eb2408b3756c4891f06a10..35cc0ffe83a69ea9fa5fca6dec2d820ca193f88d 100644
+index 2ef7cb2..35cc0ff 100644
 --- a/src/objects/BatchedMesh.js
 +++ b/src/objects/BatchedMesh.js
 @@ -181,6 +181,8 @@ function copyArrayContents( src, target ) {
@@ -356,9 +1974,18 @@ index 2ef7cb257438826059eb2408b3756c4891f06a10..35cc0ffe83a69ea9fa5fca6dec2d820c
  	 * Constructs a new batched mesh.
  	 *
 diff --git a/src/renderers/common/Bindings.js b/src/renderers/common/Bindings.js
-index 5f3d213a016b37db3b2e5d022da3dd0234d86f6d..7a9a168f29773f37ef9a51ef9f07ade9f3ea95ef 100644
+index 5f3d213..a3cec4e 100644
 --- a/src/renderers/common/Bindings.js
 +++ b/src/renderers/common/Bindings.js
+@@ -145,7 +145,7 @@ class Bindings extends DataMap {
+ 	 */
+ 	updateForRender( renderObject ) {
+ 
+-		this._updateBindings( this.getForRender( renderObject ) );
++		this._updateBindings( this.getForRender( renderObject ), this.nodes.isSettled( renderObject ) );
+ 
+ 	}
+ 
 @@ -206,10 +206,14 @@ class Bindings extends DataMap {
  
  					} else if ( binding.isSampledTexture ) {
@@ -374,8 +2001,165 @@ index 5f3d213a016b37db3b2e5d022da3dd0234d86f6d..7a9a168f29773f37ef9a51ef9f07ade9
  						this.textures.updateSampler( binding );
  
  					} else if ( binding.isStorageBuffer ) {
+@@ -292,12 +296,13 @@ class Bindings extends DataMap {
+ 	 * Updates the given array of bindings.
+ 	 *
+ 	 * @param {Array<BindGroup>} bindings - The bind groups.
++	 * @param {boolean} [settled] - Whether the render object is a settled static object.
+ 	 */
+-	_updateBindings( bindings ) {
++	_updateBindings( bindings, settled ) {
+ 
+ 		for ( const bindGroup of bindings ) {
+ 
+-			this._update( bindGroup, bindings );
++			this._update( bindGroup, bindings, settled );
+ 
+ 		}
+ 
+@@ -308,11 +313,27 @@ class Bindings extends DataMap {
+ 	 *
+ 	 * @param {BindGroup} bindGroup - The bind group to update.
+ 	 * @param {Array<BindGroup>} bindings - The bind groups.
++	 * @param {boolean} [settled] - Whether the render object is a settled static object.
+ 	 */
+-	_update( bindGroup, bindings ) {
++	_update( bindGroup, bindings, settled ) {
+ 
+ 		const { backend } = this;
+ 
++		// A group a node added after this object's first draw has no buffers and no layout yet, and
++		// the pipeline reads that layout whatever this draw decides to do with it - so it is built
++		// here, on every draw. A group that did not exist cannot have been written either, so it is
++		// written now: `settled` is what tells the loop below to write it, not to skip it.
++		if ( this.get( bindGroup ).bindGroup === undefined ) {
++
++			this._createBindings( [ bindGroup ] );
++
++			settled = false;
++
++		}
++
++		// a settled object keeps the values it uploaded the last time it refreshed, so an object
++		// group it has already written is the one thing in here it may skip
++
+ 		let needsBindingsUpdate = false;
+ 		let cacheBindings = true;
+ 		let cacheIndex = 0;
+@@ -322,7 +343,7 @@ class Bindings extends DataMap {
+ 
+ 		for ( const binding of bindGroup.bindings ) {
+ 
+-			const updatedGroup = this.nodes.updateGroup( binding );
++			const updatedGroup = this.nodes.updateGroup( binding, settled );
+ 
+ 			// every uniforms group is a uniform buffer. So if no update is required,
+ 			// we move one with the next binding. Otherwise the next if block will update the group.
+diff --git a/src/renderers/common/Geometries.js b/src/renderers/common/Geometries.js
+index eb332c4..979da2f 100644
+--- a/src/renderers/common/Geometries.js
++++ b/src/renderers/common/Geometries.js
+@@ -139,6 +139,14 @@ class Geometries extends DataMap {
+ 		 */
+ 		this._geometryDisposeListeners = new Map();
+ 
++		/**
++		 * This Weak Map holds the attribute versions a settled render object was last drawn with,
++		 * so a write into one of them is what brings the object back out of the settled path.
++		 *
++		 * @type {WeakMap<RenderObject,Map<BufferAttribute,number>>}
++		 */
++		this._settledAttributes = new WeakMap();
++
+ 	}
+ 
+ 	/**
+@@ -164,10 +172,69 @@ class Geometries extends DataMap {
+ 
+ 		if ( this.has( renderObject ) === false ) this.initGeometry( renderObject );
+ 
++		// A settled static object has no attribute that could have changed since the last refresh,
++		// unless a writer bumped one. An InstancedMesh's instance buffer is a vertex attribute of
++		// this draw, and a BufferGeometry carries no version of its own to announce the write, so
++		// the attributes' own versions are the signal - and the only one there is.
++
++		const monitor = renderObject.getMonitor();
++
++		if ( monitor !== undefined && monitor.isSettled( renderObject ) === true && this.attributesChanged( renderObject ) === false ) return;
++
+ 		this.updateAttributes( renderObject );
+ 
+ 	}
+ 
++	/**
++	 * Returns `true` if an attribute of the given render object - or its index - was written to
++	 * since the last time its versions were read, and records the versions it holds now.
++	 *
++	 * @param {RenderObject} renderObject - The render object.
++	 * @return {boolean} Whether any of the render object's versions moved.
++	 */
++	attributesChanged( renderObject ) {
++
++		const attributes = renderObject.getAttributes();
++		const index = this.getIndex( renderObject );
++		const settled = this._settledAttributes.get( renderObject );
++
++		if ( settled !== undefined && settled.size === attributes.length + ( index === null ? 0 : 1 ) ) {
++
++			let changed = false;
++
++			for ( const attribute of attributes ) {
++
++				if ( settled.get( attribute.isInterleavedBufferAttribute ? attribute.data : attribute ) !== attribute.version ) {
++
++					changed = true;
++					break;
++
++				}
++
++			}
++
++			if ( changed === false && ( index === null || settled.get( index ) === index.version ) ) return false;
++
++		}
++
++		const versions = new Map();
++
++		for ( const attribute of attributes ) {
++
++			const data = attribute.isInterleavedBufferAttribute ? attribute.data : attribute;
++
++			versions.set( data, data.version );
++
++		}
++
++		if ( index !== null ) versions.set( index, index.version );
++
++		this._settledAttributes.set( renderObject, versions );
++
++		return true;
++
++	}
++
+ 	/**
+ 	 * Initializes the geometry of the given render object.
+ 	 *
+diff --git a/src/renderers/common/RenderContexts.js b/src/renderers/common/RenderContexts.js
+index 64ecdee..7319e25 100644
+--- a/src/renderers/common/RenderContexts.js
++++ b/src/renderers/common/RenderContexts.js
+@@ -77,7 +77,8 @@ class RenderContexts {
+ 
+ 		}
+ 
+-		if ( renderTarget !== null ) renderState.sampleCount = renderTarget.samples === 0 ? 1 : renderTarget.samples;
++		const sampleCount = renderTarget !== null ? renderTarget.samples : this.renderer.currentSamples;
++		renderState.sampleCount = sampleCount === 0 ? 1 : sampleCount;
+ 
+ 		renderState.clearDepthValue = this.renderer.getClearDepth();
+ 		renderState.clearStencilValue = this.renderer.getClearStencil();
 diff --git a/src/renderers/common/RenderObject.js b/src/renderers/common/RenderObject.js
-index c900fa4c9654f8cf3512e96de52a2c1c83e189a6..d0a87eabffc8f667ebe9b2f0eccda0ddf3309652 100644
+index c900fa4..a3dcba2 100644
 --- a/src/renderers/common/RenderObject.js
 +++ b/src/renderers/common/RenderObject.js
 @@ -299,6 +299,18 @@ class RenderObject {
@@ -397,11 +2181,37 @@ index c900fa4c9654f8cf3512e96de52a2c1c83e189a6..d0a87eabffc8f667ebe9b2f0eccda0dd
  		/**
  		 * An event listener which is defined by `RenderObjects`. It performs
  		 * clean up tasks when `dispose()` on this render object.
+@@ -486,7 +498,7 @@ class RenderObject {
+ 	 */
+ 	getChainArray() {
+ 
+-		return [ this.object, this.material, this.context, this.lightsNode ];
++		return [ this.object, this.material, this.context, this.lightsNode, this._sourceMaterial ?? this.material ];
+ 
+ 	}
+ 
+@@ -936,6 +948,7 @@ class RenderObject {
+ 		}
+ 
+ 		cacheKey = hash( cacheKey, this.renderer.contextNode.id, this.renderer.contextNode.version );
++		cacheKey = hash( cacheKey, this.context.sampleCount );
+ 
+ 		return cacheKey;
+ 
 diff --git a/src/renderers/common/RenderObjects.js b/src/renderers/common/RenderObjects.js
-index 676cc2bd4169427ed420f2467b1e6684bd2aeebc..0fa661db793548254a15ff43f39207abcc43ef49 100644
+index 676cc2b..72569d0 100644
 --- a/src/renderers/common/RenderObjects.js
 +++ b/src/renderers/common/RenderObjects.js
-@@ -124,9 +124,18 @@ class RenderObjects {
+@@ -97,6 +97,8 @@ class RenderObjects {
+ 		_chainKeys[ 1 ] = material;
+ 		_chainKeys[ 2 ] = renderContext;
+ 		_chainKeys[ 3 ] = lightsNode;
++		// Material groups share the shadow override, but must retain separate GPU bindings.
++		_chainKeys[ 4 ] = this.renderer._currentSourceMaterial ?? material;
+ 
+ 		//
+ 
+@@ -124,9 +126,18 @@ class RenderObjects {
  
  			}
  
@@ -422,7 +2232,7 @@ index 676cc2bd4169427ed420f2467b1e6684bd2aeebc..0fa661db793548254a15ff43f39207ab
  
  					renderObject.dispose();
  
-@@ -136,6 +145,8 @@ class RenderObjects {
+@@ -136,6 +147,8 @@ class RenderObjects {
  
  					renderObject.version = material.version;
  
@@ -431,8 +2241,16 @@ index 676cc2bd4169427ed420f2467b1e6684bd2aeebc..0fa661db793548254a15ff43f39207ab
  				}
  
  			}
+@@ -148,6 +161,7 @@ class RenderObjects {
+ 		_chainKeys[ 1 ] = null;
+ 		_chainKeys[ 2 ] = null;
+ 		_chainKeys[ 3 ] = null;
++		_chainKeys[ 4 ] = null;
+ 
+ 		//
+ 
 diff --git a/src/renderers/common/Renderer.js b/src/renderers/common/Renderer.js
-index 8dfc2ae055ad7b9d4c00e91f7d52a39e747caebe..e9d27b3ddad3b1f080a717d1f6683b60afd2b259 100644
+index 8dfc2ae..89b33ef 100644
 --- a/src/renderers/common/Renderer.js
 +++ b/src/renderers/common/Renderer.js
 @@ -3550,6 +3550,7 @@ class Renderer {
@@ -476,8 +2294,162 @@ index 8dfc2ae055ad7b9d4c00e91f7d52a39e747caebe..e9d27b3ddad3b1f080a717d1f6683b60
  
  		}
  
+@@ -3705,18 +3716,17 @@ class Renderer {
+ 
+ 		//
+ 
+-		const needsRefresh = this._nodes.needsRefresh( renderObject );
++		this._nodes.needsRefresh( renderObject );
+ 
+-		if ( needsRefresh ) {
+-
+-			this._nodes.updateBefore( renderObject );
+-
+-			this._geometries.updateForRender( renderObject );
+-
+-			this._nodes.updateForRender( renderObject );
+-			this._bindings.updateForRender( renderObject );
+-
+-		}
++		// Every step of a draw runs, settled or not. What a settled static object skips is decided
++		// inside each of them - its OBJECT node updates, its object uniform group write and its
++		// attribute scan - because each of those answers for itself, and a step left out here
++		// cannot: a group a node added after this object's first draw still has to be created, and
++		// the pipeline reads that group's layout whatever this draw decided to do with it.
++		this._geometries.updateForRender( renderObject );
++		this._nodes.updateBefore( renderObject );
++		this._nodes.updateForRender( renderObject );
++		this._bindings.updateForRender( renderObject );
+ 
+ 		this._pipelines.updateForRender( renderObject );
+ 
+@@ -3726,7 +3736,7 @@ class Renderer {
+ 
+ 			this.backend.draw( renderObject, this.info );
+ 
+-			if ( needsRefresh ) this._nodes.updateAfter( renderObject );
++			this._nodes.updateAfter( renderObject );
+ 
+ 		}
+ 
+diff --git a/src/renderers/common/Textures.js b/src/renderers/common/Textures.js
+index f42b90e..be47645 100644
+--- a/src/renderers/common/Textures.js
++++ b/src/renderers/common/Textures.js
+@@ -215,6 +215,21 @@ class Textures extends DataMap {
+ 
+ 			backend.destroyTexture( texture );
+ 
++			// delete cached bind groups so they don't point to the destroyed texture
++
++			if ( textureData.bindGroups ) {
++
++				for ( const bindGroup of textureData.bindGroups ) {
++
++					const bindingsData = this.backend.get( bindGroup );
++
++					bindingsData.groups = undefined;
++					bindingsData.versions = undefined;
++
++				}
++
++			}
++
+ 		}
+ 
+ 		//
+diff --git a/src/renderers/common/nodes/NodeManager.js b/src/renderers/common/nodes/NodeManager.js
+index f6d4f0b..033128c 100644
+--- a/src/renderers/common/nodes/NodeManager.js
++++ b/src/renderers/common/nodes/NodeManager.js
+@@ -109,15 +109,17 @@ class NodeManager extends DataMap {
+ 	 * Returns `true` if the given node uniforms group must be updated or not.
+ 	 *
+ 	 * @param {NodeUniformsGroup} nodeUniformsGroup - The node uniforms group.
++	 * @param {boolean} [settled] - Whether the render object is a settled static object.
+ 	 * @return {boolean} Whether the node uniforms group requires an update or not.
+ 	 */
+-	updateGroup( nodeUniformsGroup ) {
++	updateGroup( nodeUniformsGroup, settled ) {
+ 
+ 		const groupNode = nodeUniformsGroup.groupNode;
+ 
+-		// groups that are updated per object always require an update so no further checks are needed
++		// groups that are updated per object always require an update so no further checks are needed.
++		// A settled static object keeps the values it uploaded the last time it was refreshed.
+ 
+-		if ( groupNode.updateType === NodeUpdateType.OBJECT ) return true;
++		if ( groupNode.updateType === NodeUpdateType.OBJECT ) return settled !== true;
+ 
+ 		// check for update
+ 
+@@ -921,6 +923,21 @@ class NodeManager extends DataMap {
+ 
+ 	}
+ 
++	/**
++	 * Returns `true` if the per-object updates of the given render object can be skipped
++	 * because the object is static and nothing it depends on changed since its last refresh.
++	 *
++	 * @param {RenderObject} renderObject - The render object.
++	 * @return {boolean} Whether the render object is settled or not.
++	 */
++	isSettled( renderObject ) {
++
++		const monitor = renderObject.getMonitor();
++
++		return monitor !== undefined ? monitor.isSettled( renderObject ) : false;
++
++	}
++
+ 	/**
+ 	 * Triggers the call of `updateBefore()` methods
+ 	 * for all nodes of the given render object.
+@@ -930,9 +947,14 @@ class NodeManager extends DataMap {
+ 	updateBefore( renderObject ) {
+ 
+ 		const nodeBuilder = renderObject.getNodeBuilderState();
++		const settled = this.isSettled( renderObject );
+ 
+ 		for ( const node of nodeBuilder.updateBeforeNodes ) {
+ 
++			// a settled static object has nothing to update per object
++
++			if ( settled === true && node.getUpdateBeforeType() === NodeUpdateType.OBJECT ) continue;
++
+ 			// update frame state for each node
+ 
+ 			this.getNodeFrameForRender( renderObject ).updateBeforeNode( node );
+@@ -950,10 +972,11 @@ class NodeManager extends DataMap {
+ 	updateAfter( renderObject ) {
+ 
+ 		const nodeBuilder = renderObject.getNodeBuilderState();
++		const settled = this.isSettled( renderObject );
+ 
+ 		for ( const node of nodeBuilder.updateAfterNodes ) {
+ 
+-			// update frame state for each node
++			if ( settled === true && node.getUpdateAfterType() === NodeUpdateType.OBJECT ) continue;
+ 
+ 			this.getNodeFrameForRender( renderObject ).updateAfterNode( node );
+ 
+@@ -990,9 +1013,14 @@ class NodeManager extends DataMap {
+ 
+ 		const nodeFrame = this.getNodeFrameForRender( renderObject );
+ 		const nodeBuilder = renderObject.getNodeBuilderState();
++		const settled = this.isSettled( renderObject );
+ 
+ 		for ( const node of nodeBuilder.updateNodes ) {
+ 
++			// a settled static object keeps the per-object values it uploaded last time
++
++			if ( settled === true && node.getUpdateType() === NodeUpdateType.OBJECT ) continue;
++
+ 			nodeFrame.updateNode( node );
+ 
+ 		}
 diff --git a/src/renderers/webgpu/WebGPUBackend.js b/src/renderers/webgpu/WebGPUBackend.js
-index 06e203693ed9b168a2bddf773cd8ce8dc23196e4..37b5e0be09967e8acbd38e570b71eb201fc9bad7 100644
+index 06e2036..69b8b67 100644
 --- a/src/renderers/webgpu/WebGPUBackend.js
 +++ b/src/renderers/webgpu/WebGPUBackend.js
 @@ -102,6 +102,14 @@ class WebGPUBackend extends Backend {
@@ -506,11 +2478,86 @@ index 06e203693ed9b168a2bddf773cd8ce8dc23196e4..37b5e0be09967e8acbd38e570b71eb20
  
  			if ( adapter === null ) {
  
+@@ -1749,13 +1759,12 @@ class WebGPUBackend extends Backend {
+ 		for ( let i = 0, l = bindings.length; i < l; i ++ ) {
+ 
+ 			const bindGroup = bindings[ i ];
++			const bindingsData = this.get( bindGroup );
+ 
+-			if ( currentBindingGroups[ i ] !== bindGroup.id ) {
+-
+-				const bindingsData = this.get( bindGroup );
++			if ( currentBindingGroups[ i ] !== bindingsData.group ) {
+ 
+ 				passEncoderGPU.setBindGroup( i, bindingsData.group );
+-				currentBindingGroups[ i ] = bindGroup.id;
++				currentBindingGroups[ i ] = bindingsData.group;
+ 
+ 			}
+ 
+@@ -2054,6 +2063,7 @@ class WebGPUBackend extends Backend {
+ 		const utils = this.utils;
+ 
+ 		const sampleCount = utils.getSampleCountRenderContext( renderObject.context );
++		const bindGroupLayoutKeys = renderObject.getBindings().map( bindGroup => this.get( bindGroup ).layoutKey ).join( '|' );
+ 		const colorSpace = utils.getCurrentColorSpace( renderObject.context );
+ 		const colorFormat = utils.getCurrentColorFormat( renderObject.context );
+ 		const depthStencilFormat = utils.getCurrentDepthStencilFormat( renderObject.context );
+@@ -2075,7 +2085,8 @@ class WebGPUBackend extends Backend {
+ 			data.colorFormat !== colorFormat || data.depthStencilFormat !== depthStencilFormat ||
+ 			data.primitiveTopology !== primitiveTopology ||
+ 			data.frontFaceCW !== frontFaceCW ||
+-			data.clippingContextCacheKey !== renderObject.clippingContextCacheKey
++			data.clippingContextCacheKey !== renderObject.clippingContextCacheKey ||
++			data.bindGroupLayoutKeys !== bindGroupLayoutKeys
+ 		) {
+ 
+ 			data.material = material; data.materialVersion = material.version;
+@@ -2095,6 +2106,7 @@ class WebGPUBackend extends Backend {
+ 			data.primitiveTopology = primitiveTopology;
+ 			data.frontFaceCW = frontFaceCW;
+ 			data.clippingContextCacheKey = renderObject.clippingContextCacheKey;
++			data.bindGroupLayoutKeys = bindGroupLayoutKeys;
+ 
+ 			needsUpdate = true;
+ 
+@@ -2116,6 +2128,7 @@ class WebGPUBackend extends Backend {
+ 
+ 		const utils = this.utils;
+ 		const renderContext = renderObject.context;
++		const bindGroupLayoutKeys = renderObject.getBindings().map( bindGroup => this.get( bindGroup ).layoutKey ).join( '|' );
+ 
+ 		// meshes with negative scale have a different frontFace render pipeline
+ 		// descriptor value so the following must be honored in the cache key
+@@ -2134,6 +2147,7 @@ class WebGPUBackend extends Backend {
+ 			material.side,
+ 			frontFaceCW,
+ 			utils.getSampleCountRenderContext( renderContext ),
++			bindGroupLayoutKeys,
+ 			utils.getCurrentColorSpace( renderContext ), utils.getCurrentColorFormat( renderContext ), utils.getCurrentDepthStencilFormat( renderContext ),
+ 			utils.getPrimitiveTopology( object, material ),
+ 			renderObject.getGeometryCacheKey(),
 diff --git a/src/renderers/webgpu/nodes/WGSLNodeBuilder.js b/src/renderers/webgpu/nodes/WGSLNodeBuilder.js
-index be07536301cd47ef2544e4a54f6abe17407f52af..6144b98ddeb5d53c5cf280bb51401385a4427547 100644
+index be07536..2acc832 100644
 --- a/src/renderers/webgpu/nodes/WGSLNodeBuilder.js
 +++ b/src/renderers/webgpu/nodes/WGSLNodeBuilder.js
-@@ -1323,7 +1323,8 @@ class WGSLNodeBuilder extends NodeBuilder {
+@@ -741,7 +741,14 @@ class WGSLNodeBuilder extends NodeBuilder {
+ 
+ 		} else {
+ 
+-			snippet = `textureLoad( ${ textureProperty }, ${ uvIndexSnippet }, u32( ${ levelSnippet } ) )`;
++			// naga v25 (wgpu-native v25.0.2.2) rejects a u32 sample index on a
++			// multisampled textureLoad; i32 is accepted by every backend. Mip-level
++			// operands (including the array form above) stay u32.
++			const sampleData = texture ? this.renderer?.backend?.utils?.getTextureSampleData?.( texture ) : null;
++			const backendMultisampled = sampleData !== null && sampleData !== undefined && sampleData.primarySamples > 1;
++			const targetMultisampled = Boolean( texture && texture.renderTarget && texture.renderTarget.samples > 1 );
++			const indexType = ( backendMultisampled || targetMultisampled ) ? 'i32' : 'u32';
++			snippet = `textureLoad( ${ textureProperty }, ${ uvIndexSnippet }, ${ indexType }( ${ levelSnippet } ) )`;
+ 
+ 			if ( this.renderer.backend.compatibilityMode && texture.isDepthTexture ) {
+ 
+@@ -1323,7 +1330,8 @@ class WGSLNodeBuilder extends NodeBuilder {
  
  				uniformGPU = buffer;
  
@@ -520,3 +2567,79 @@ index be07536301cd47ef2544e4a54f6abe17407f52af..6144b98ddeb5d53c5cf280bb51401385
  
  			} else {
  
+@@ -2066,9 +2074,12 @@ ${ flowData.code }
+ 				const textureNode = uniform.node;
+ 				const texture = textureNode.value;
+ 
+-				// Cube textures always need samplers (they use textureSampleLevel, not textureLoad)
+-				// Also textureGather always need sampler.
+-				const needsSampler = texture.isCubeTexture === true || ( this.isUnfilterable( texture ) === false && textureNode.isStorageTextureNode !== true ) || textureNode.gatherNode !== null;
++				// The bind group layout freezes sampler inclusion once, in getUniformFromNode
++				// (nodeData.uniformGPU). Re-deriving it here from live texture filter state can
++				// disagree with that layout and shift every later binding index.
++				const nodeData = this.getDataFromNode( textureNode, shaderStage, this.globalCache );
++				const uniformGPU = nodeData.uniformGPU;
++				const needsSampler = Array.isArray( uniformGPU ) && uniformGPU[ 0 ].isSampler === true && uniformGPU[ 0 ].isSampledTexture !== true;
+ 
+ 				if ( needsSampler ) {
+ 
+diff --git a/src/renderers/webgpu/utils/WebGPUAttributeUtils.js b/src/renderers/webgpu/utils/WebGPUAttributeUtils.js
+index f683d74..83bbe18 100644
+--- a/src/renderers/webgpu/utils/WebGPUAttributeUtils.js
++++ b/src/renderers/webgpu/utils/WebGPUAttributeUtils.js
+@@ -361,9 +361,15 @@ class WebGPUAttributeUtils {
+ 	destroyAttribute( attribute ) {
+ 
+ 		const backend = this.backend;
+-		const data = backend.get( this._getBufferAttribute( attribute ) );
++		const bufferAttribute = this._getBufferAttribute( attribute );
++		const data = backend.get( bufferAttribute );
++
++		// An interleaved attribute's GPU buffer lives on its InterleavedBuffer, and several attributes
++		// share it: destroy it once and forget it there too, as the WebGL backend does, or the next
++		// createAttribute() finds the destroyed buffer and submits it (threenative patch).
++		if ( data.buffer !== undefined ) data.buffer.destroy();
+ 
+-		data.buffer.destroy();
++		if ( bufferAttribute !== attribute ) backend.delete( bufferAttribute );
+ 
+ 		backend.delete( attribute );
+ 
+diff --git a/src/renderers/webgpu/utils/WebGPUBindingUtils.js b/src/renderers/webgpu/utils/WebGPUBindingUtils.js
+index da4bd47..a5da7ca 100644
+--- a/src/renderers/webgpu/utils/WebGPUBindingUtils.js
++++ b/src/renderers/webgpu/utils/WebGPUBindingUtils.js
+@@ -97,18 +97,16 @@ class WebGPUBindingUtils {
+ 
+ 		const bindingsData = backend.get( bindGroup );
+ 
+-		// check if the the bind group already has a layout
++		const entries = this._createLayoutEntries( bindGroup );
++		const bindGroupLayoutKey = hashString( JSON.stringify( entries ) );
+ 
+ 		if ( bindingsData.layout ) {
+ 
+-			return bindingsData.layout.layoutGPU;
+-
+-		}
++			if ( bindingsData.layoutKey === bindGroupLayoutKey ) return bindingsData.layout.layoutGPU;
+ 
+-		// if not, assing one
++			this.deleteBindGroupData( bindGroup );
+ 
+-		const entries = this._createLayoutEntries( bindGroup );
+-		const bindGroupLayoutKey = hashString( JSON.stringify( entries ) );
++		}
+ 
+ 		// try to find an existing layout in the cache
+ 
+@@ -630,6 +628,9 @@ class WebGPUBindingUtils {
+ 
+ 		}
+ 
++		bindingsData.groups = [];
++		bindingsData.versions = [];
++
+ 	}
+ 
+ 	/**