Fix for vertex pulling of interleaved buffers

Author: Mike Bond

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

@@ -1,4 +1,4 @@
-import type { VertexBuffer } from "../../Buffers/buffer";
+import { VertexBuffer } from "../../Buffers/buffer";
 import type { DataBuffer } from "../../Buffers/dataBuffer";
 import type { WebGPUDataBuffer } from "../../Meshes/WebGPU/webgpuDataBuffer";
 import type { Nullable } from "../../types";
@@ -170,6 +170,11 @@ export class WebGPUDrawContext implements IDrawContext {
         this._bufferManager.setRawData(this.indirectDrawBuffer, 0, this._indirectDrawData, 0, 20);
     }
 
+    /**
+     * Metadata storage for vertex buffer configurations (stride, offset, etc.)
+     */
+    public vertexBufferMetadata: { [name: string]: { strideInFloats: number; offsetInFloats: number; componentCount: number } } = {};
+
     public setVertexPulling(
         useVertexPulling: boolean,
         webgpuPipelineContext: WebGPUPipelineContext,
@@ -186,6 +191,9 @@ export class WebGPUDrawContext implements IDrawContext {
 
         const bufferNames = webgpuPipelineContext.shaderProcessingContext.bufferNames;
 
+        // Clear previous metadata
+        this.vertexBufferMetadata = {};
+
         if (overrideVertexBuffers) {
             for (const attributeName in overrideVertexBuffers) {
                 const vertexBuffer = overrideVertexBuffers[attributeName];
@@ -196,6 +204,17 @@ export class WebGPUDrawContext implements IDrawContext {
                 const buffer = vertexBuffer.effectiveBuffer as Nullable<WebGPUDataBuffer>;
 
                 this.setBuffer(attributeName, useVertexPulling ? buffer : null);
+
+                // Store metadata for vertex pulling
+                if (useVertexPulling) {
+                    const bytesPerElement =
+                        vertexBuffer.type === VertexBuffer.FLOAT ? 4 : vertexBuffer.type === VertexBuffer.UNSIGNED_INT || vertexBuffer.type === VertexBuffer.INT ? 4 : 2;
+                    this.vertexBufferMetadata[attributeName] = {
+                        strideInFloats: vertexBuffer.effectiveByteStride / bytesPerElement, // Convert bytes to float32 elements
+                        offsetInFloats: vertexBuffer.effectiveByteOffset / bytesPerElement, // Convert bytes to float32 elements
+                        componentCount: vertexBuffer.getSize(),
+                    };
+                }
             }
         }
 
@@ -212,6 +231,17 @@ export class WebGPUDrawContext implements IDrawContext {
             const buffer = vertexBuffer.effectiveBuffer as Nullable<WebGPUDataBuffer>;
 
             this.setBuffer(attributeName, useVertexPulling ? buffer : null);
+
+            // Store metadata for vertex pulling
+            if (useVertexPulling) {
+                const bytesPerElement =
+                    vertexBuffer.type === VertexBuffer.FLOAT ? 4 : vertexBuffer.type === VertexBuffer.UNSIGNED_INT || vertexBuffer.type === VertexBuffer.INT ? 4 : 2;
+                this.vertexBufferMetadata[attributeName] = {
+                    strideInFloats: vertexBuffer.effectiveByteStride / bytesPerElement, // Convert bytes to float32 elements
+                    offsetInFloats: vertexBuffer.effectiveByteOffset / bytesPerElement, // Convert bytes to float32 elements
+                    componentCount: vertexBuffer.getSize(),
+                };
+            }
         }
 
         if (bufferNames.indexOf("indices") !== -1) {

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

@@ -598,6 +598,44 @@ export function GetFogState(mesh: AbstractMesh, scene: Scene) {
     return scene.fogEnabled && mesh.applyFog && scene.fogMode !== Constants.FOGMODE_NONE;
 }
 
+/**
+ * Helper used to prepare vertex pulling metadata defines (stride, offset, component count)
+ * This should be called when USE_VERTEX_PULLING is enabled to properly configure buffer access
+ * @param mesh The mesh being rendered
+ * @param defines The defines object to update
+ * @param attributeNames Array of attribute names to configure (e.g., ["position", "normal"])
+ */
+export function PrepareDefinesForVertexPullingMetadata(mesh: AbstractMesh, defines: any, attributeNames: string[] = ["position"]): void {
+    if (!defines["USE_VERTEX_PULLING"]) {
+        return;
+    }
+
+    const geometry = mesh.geometry;
+    if (!geometry) {
+        return;
+    }
+
+    for (const attributeName of attributeNames) {
+        const vertexBuffer = geometry.getVertexBuffer(attributeName);
+        if (!vertexBuffer) {
+            continue;
+        }
+
+        const upperName = attributeName.toUpperCase();
+
+        // Calculate stride in float32 elements
+        const strideInFloats = vertexBuffer.effectiveByteStride / 4;
+        defines[`${upperName}_STRIDE_IN_FLOATS`] = strideInFloats || vertexBuffer.getSize();
+
+        // Calculate offset in float32 elements
+        const offsetInFloats = vertexBuffer.effectiveByteOffset / 4;
+        defines[`${upperName}_OFFSET_IN_FLOATS`] = offsetInFloats;
+
+        // Component count
+        defines[`${upperName}_COMPONENT_COUNT`] = vertexBuffer.getSize();
+    }
+}
+
 /**
  * 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

@@ -891,6 +891,27 @@ export class ShaderMaterial extends PushMaterial {
                     defines.push("#define VERTEX_PULLING_INDEX_BUFFER_32BITS");
                 }
             }
+
+            // Add vertex buffer metadata defines for proper stride/offset handling
+            const geometry = renderingMesh.geometry;
+            if (geometry) {
+                const vertexBuffers = geometry.getVertexBuffers();
+                if (vertexBuffers) {
+                    for (const attributeName in vertexBuffers) {
+                        const vertexBuffer = vertexBuffers[attributeName];
+                        if (vertexBuffer) {
+                            const upperName = attributeName.toUpperCase();
+                            const strideInFloats = vertexBuffer.effectiveByteStride / 4;
+                            const offsetInFloats = vertexBuffer.effectiveByteOffset / 4;
+                            const componentCount = vertexBuffer.getSize();
+
+                            defines.push(`#define ${upperName}_STRIDE_IN_FLOATS ${strideInFloats || componentCount}`);
+                            defines.push(`#define ${upperName}_OFFSET_IN_FLOATS ${offsetInFloats}`);
+                            defines.push(`#define ${upperName}_COMPONENT_COUNT ${componentCount}`);
+                        }
+                    }
+                }
+            }
         }
 
         const drawWrapper = storeEffectOnSubMeshes ? subMesh._getDrawWrapper(undefined, true) : this._drawWrapper;

packages/dev/core/src/ShadersWGSL/iblVoxelGrid.vertex.fx

@@ -8,7 +8,7 @@
 
 // This shader uses vertex pulling to determine the
 // provoked vertex and calculate the normal. Then, based on
-// the direction of teh normal, it swizzles the position to
+// the direction of the normal, it swizzles the position to
 // maximize the rasterized area.
 #ifdef VERTEX_PULLING_USE_INDEX_BUFFER
 var<storage, read> indices : array<u32>;
@@ -21,11 +21,25 @@ uniform invWorldScale: mat4x4f;
 varying vNormalizedPosition : vec3f;
 flat varying f_swizzle: i32;
 
+// Vertex buffer metadata (set via defines or defaults)
+#ifndef POSITION_STRIDE_IN_FLOATS
+#define POSITION_STRIDE_IN_FLOATS 3
+#endif
+
+#ifndef POSITION_OFFSET_IN_FLOATS
+#define POSITION_OFFSET_IN_FLOATS 0
+#endif
+
+#ifndef POSITION_COMPONENT_COUNT
+#define POSITION_COMPONENT_COUNT 3
+#endif
+
 fn readVertexPosition(index : u32)->vec3f {
   var pos : vec3f;
-  pos.x = position[index * 3];
-  pos.y = position[index * 3 + 1];
-  pos.z = position[index * 3 + 2];
+  let baseOffset = POSITION_OFFSET_IN_FLOATS + index * POSITION_STRIDE_IN_FLOATS;
+  pos.x = position[baseOffset];
+  pos.y = position[baseOffset + 1u];
+  pos.z = position[baseOffset + 2u];
   return pos;
 }