Voxel shadow fixes for interleaved buffers

packages/dev/core/src/Engines/WebGPU/webgpuDrawContext.ts

@@ -170,6 +170,14 @@ export class WebGPUDrawContext implements IDrawContext {
         this._bufferManager.setRawData(this.indirectDrawBuffer, 0, this._indirectDrawData, 0, 20);
     }
 
+    /**
+     * Setup or disable vertex pulling as needed.
+     * @param useVertexPulling Use vertex pulling or not
+     * @param webgpuPipelineContext The WebGPU pipeline context
+     * @param vertexBuffers The current vertex buffers
+     * @param indexBuffer The current index buffer
+     * @param overrideVertexBuffers The vertex buffers to override
+     */
     public setVertexPulling(
         useVertexPulling: boolean,
         webgpuPipelineContext: WebGPUPipelineContext,

packages/dev/core/src/Materials/materialHelper.functions.ts

@@ -22,6 +22,8 @@ import { MaterialFlags } from "./materialFlags";
 import { Texture } from "./Textures/texture";
 import type { CubeTexture } from "./Textures/cubeTexture";
 import type { Color3 } from "core/Maths/math.color";
+import type { Geometry } from "../Meshes/geometry";
+import { Vector3 } from "core/Maths/math.vector";
 
 // For backwards compatibility, we export everything from the pure version of this file.
 export * from "./materialHelper.functions.pure";
@@ -598,6 +600,98 @@ export function GetFogState(mesh: AbstractMesh, scene: Scene) {
     return scene.fogEnabled && mesh.applyFog && scene.fogMode !== Constants.FOGMODE_NONE;
 }
 
+/**
+ * Interface representing metadata for vertex pulling
+ */
+export interface IVertexPullingMetadata {
+    /**
+     * Offset in vertex buffer where data starts
+     */
+    offset: number;
+
+    /**
+     * Stride between elements in the vertex buffer
+     */
+    stride: number;
+
+    /**
+     * Type of the vertex buffer (e.g., float, int)
+     */
+    type: number; // VertexBuffer type constant
+}
+
+// Store vertex pulling metadata per geometry
+const _VertexPullingMetadataCache = new WeakMap<Geometry, Map<string, IVertexPullingMetadata>>();
+
+/**
+ * Prepares vertex pulling uniforms for the given attributes and mesh
+ * @param geometry The geometry containing the vertex buffers
+ * @returns A map of attribute names to their metadata, or null if unavailable
+ */
+export function PrepareVertexPullingUniforms(geometry: Geometry): Nullable<Map<string, IVertexPullingMetadata>> {
+    if (!geometry) {
+        return null;
+    }
+    const vertexBuffers = geometry.getVertexBuffers();
+    if (!vertexBuffers) {
+        return null;
+    }
+
+    // Check cache first
+    let metadata = _VertexPullingMetadataCache.get(geometry);
+    if (!metadata) {
+        metadata = new Map<string, IVertexPullingMetadata>();
+        _VertexPullingMetadataCache.set(geometry, metadata);
+    } else {
+        // Return cached metadata if it exists and hasn't changed
+        let needsUpdate = false;
+        for (const vb in vertexBuffers) {
+            if (!metadata.has(vb)) {
+                needsUpdate = true;
+                break;
+            }
+        }
+        if (!needsUpdate) {
+            return metadata;
+        }
+    }
+
+    // Build or update metadata
+    for (const vb in vertexBuffers) {
+        const vertexBuffer = vertexBuffers[vb];
+        if (vertexBuffer) {
+            const offset = vertexBuffer.byteOffset;
+            const stride = vertexBuffer.byteStride;
+            const type = vertexBuffer.type;
+
+            metadata.set(vb, {
+                offset: offset,
+                stride: stride,
+                type: type,
+            });
+        }
+    }
+
+    return metadata;
+}
+
+/**
+ * Bind vertex pulling uniforms to the effect
+ * @param effect The effect to bind the uniforms to
+ * @param metadata The vertex pulling metadata
+ */
+export function BindVertexPullingUniforms(effect: Effect, metadata: Map<string, IVertexPullingMetadata>): void {
+    if (!metadata || !effect) {
+        return;
+    }
+
+    for (const [attribute, data] of metadata.entries()) {
+        const uniformName = `vp_${attribute}_info`;
+        // Pack into vec3: (offset, stride, type)
+        effect.setVector3(uniformName, new Vector3(data.offset, data.stride, data.type));
+    }
+}
+
 /**
  * Helper used to prepare the list of defines associated with misc. values for shader compilation
  * @param mesh defines the current mesh

packages/dev/core/src/Materials/shaderMaterial.ts

@@ -30,8 +30,11 @@ import {
     BindMorphTargetParameters,
     BindSceneUniformBuffer,
     PrepareDefinesAndAttributesForMorphTargets,
+    PrepareVertexPullingUniforms,
+    BindVertexPullingUniforms,
     PushAttributesForInstances,
 } from "./materialHelper.functions";
+import type { IVertexPullingMetadata } from "./materialHelper.functions";
 import type { IColor3Like, IColor4Like, IVector2Like, IVector3Like, IVector4Like } from "core/Maths/math.like";
 import type { InternalTexture } from "./Textures/internalTexture";
 
@@ -147,6 +150,7 @@ export class ShaderMaterial extends PushMaterial {
     private _cachedWorldViewMatrix = new Matrix();
     private _cachedWorldViewProjectionMatrix = new Matrix();
     private _multiview = false;
+    private _vertexPullingMetadata: Map<string, IVertexPullingMetadata> | null = null;
 
     /**
      * @internal
@@ -909,12 +913,18 @@ export class ShaderMaterial extends PushMaterial {
             defines.push("#define USE_VERTEX_PULLING");
 
             const indexBuffer = renderingMesh.geometry?.getIndexBuffer();
-            if (indexBuffer) {
+            if (indexBuffer && !(renderingMesh as Mesh).isUnIndexed) {
                 defines.push("#define VERTEX_PULLING_USE_INDEX_BUFFER");
                 if (indexBuffer.is32Bits) {
                     defines.push("#define VERTEX_PULLING_INDEX_BUFFER_32BITS");
                 }
             }
+
+            // Add vertex buffer metadata defines for proper stride/offset handling
+            const geometry = renderingMesh.geometry;
+            if (geometry) {
+                this._vertexPullingMetadata = PrepareVertexPullingUniforms(geometry);
+            }
         }
 
         const drawWrapper = storeEffectOnSubMeshes ? subMesh._getDrawWrapper(undefined, true) : this._drawWrapper;
@@ -1085,6 +1095,10 @@ export class ShaderMaterial extends PushMaterial {
             // Clip plane
             BindClipPlane(effect, this, scene);
 
+            if (this._vertexPullingMetadata) {
+                BindVertexPullingUniforms(effect, this._vertexPullingMetadata);
+            }
+
             // Misc
             if (this._useLogarithmicDepth) {
                 BindLogDepth(storeEffectOnSubMeshes ? subMesh.materialDefines : effect.defines, effect, scene);

packages/dev/core/src/Rendering/IBLShadows/iblShadowsVoxelRenderer.ts

@@ -643,6 +643,9 @@ export class _IblShadowsVoxelRenderer {
      * @param includedMeshes
      */
     public updateVoxelGrid(includedMeshes: Mesh[]) {
+        if (this._voxelizationInProgress) {
+            return;
+        }
         this._stopVoxelization();
         this._includedMeshes = includedMeshes;
         this._voxelizationInProgress = true;
@@ -738,6 +741,7 @@ export class _IblShadowsVoxelRenderer {
             if (axis === 1) {
                 upDirection = new Vector3(1, 0, 0);
             }
+            mrt.onBeforeRenderObservable.clear();
             mrt.onBeforeRenderObservable.add(() => {
                 voxelMaterial.setMatrix("viewMatrix", Matrix.LookAtLH(cameraPosition, targetPosition, upDirection));
                 voxelMaterial.setMatrix("invWorldScale", this._invWorldScaleMatrix);

packages/dev/core/src/ShadersWGSL/ShadersInclude/bonesDeclaration.fx

@@ -1,9 +1,9 @@
 #if NUM_BONE_INFLUENCERS > 0
-	attribute matricesIndices : vec4<f32>;
-	attribute matricesWeights : vec4<f32>;
+	attribute matricesIndices : vec4f;
+	attribute matricesWeights : vec4f;
 	#if NUM_BONE_INFLUENCERS > 4
-		attribute matricesIndicesExtra : vec4<f32>;
-		attribute matricesWeightsExtra : vec4<f32>;
+		attribute matricesIndicesExtra : vec4f;
+		attribute matricesWeightsExtra : vec4f;
 	#endif
 
     #ifndef BAKED_VERTEX_ANIMATION_TEXTURE