Handle vertex pulling of different data type

Author: Mike Bond

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

@@ -23,6 +23,8 @@ import { Texture } from "./Textures/texture";
 import type { CubeTexture } from "./Textures/cubeTexture";
 import type { Color3 } from "core/Maths/math.color";
 import { GetTypeByteLength } from "../Buffers/bufferUtils";
+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";
@@ -600,24 +602,105 @@ export function GetFogState(mesh: AbstractMesh, scene: Scene) {
 }
 
 /**
- * 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"])
+ * Interface representing metadata for vertex pulling
  */
-export function PrepareDefinesForVertexPullingMetadata(mesh: AbstractMesh, defines: any, attributeNames: string[] = ["position"]): void {
-    if (!defines["USE_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;
+}
+
+export function BindVertexPullingUniforms(effect: Effect, metadata: Map<string, IVertexPullingMetadata>): void {
+    if (!metadata || !effect) {
         return;
     }
 
-    const geometry = mesh.geometry;
+    for (const [attribute, data] of metadata) {
+        const uniformName = `vp_${attribute}_info`;
+        // Pack into vec4: (offset, stride, type)
+        effect.setVector3(uniformName, new Vector3(data.offset, data.stride, data.type));
+    }
+}
+
+/**
+ * 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 geometry The geometry being rendered
+ * @param defines The defines object to update
+ */
+export function PrepareDefinesForVertexPullingMetadata(geometry: Geometry, defines: any): void {
     if (!geometry) {
         return;
     }
-
-    for (const attributeName of attributeNames) {
-        const vertexBuffer = geometry.getVertexBuffer(attributeName);
+    const vertexBuffers = geometry.getVertexBuffers();
+    for (const attributeName in vertexBuffers) {
+        const vertexBuffer = vertexBuffers[attributeName];
         if (!vertexBuffer) {
             continue;
         }
@@ -626,11 +709,14 @@ export function PrepareDefinesForVertexPullingMetadata(mesh: AbstractMesh, defin
         const sizeInBytes = GetTypeByteLength(vertexBuffer.type);
         // Calculate stride in float32 elements
         const stride = vertexBuffer.effectiveByteStride / sizeInBytes;
-        defines[`${upperName}_STRIDE`] = stride || vertexBuffer.getSize();
+        defines.push(`#define ${upperName}_STRIDE ${stride}`);
 
         // Calculate offset in float32 elements
         const offset = vertexBuffer.effectiveByteOffset / sizeInBytes;
-        defines[`${upperName}_OFFSET`] = offset;
+        defines.push(`#define ${upperName}_OFFSET ${offset}`);
+        // Calculate component count
+        const componentBytes = GetTypeByteLength(vertexBuffer.type);
+        defines.push(`#define ${upperName}_COMPONENT_BYTES ${componentBytes}`);
     }
 }
 

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

@@ -21,7 +21,6 @@ import { EngineStore } from "../Engines/engineStore";
 import { Constants } from "../Engines/constants";
 import { AddClipPlaneUniforms, BindClipPlane, PrepareStringDefinesForClipPlanes } from "./clipPlaneMaterialHelper";
 import type { WebGPUEngine } from "core/Engines/webgpuEngine";
-import { GetTypeByteLength } from "../Buffers/bufferUtils";
 
 import type { ExternalTexture } from "./Textures/externalTexture";
 import {
@@ -31,8 +30,12 @@ import {
     BindMorphTargetParameters,
     BindSceneUniformBuffer,
     PrepareDefinesAndAttributesForMorphTargets,
+    PrepareDefinesForVertexPullingMetadata,
+    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";
 
@@ -148,6 +151,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
@@ -920,22 +924,8 @@ export class ShaderMaterial extends PushMaterial {
             // 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 componentBytes = GetTypeByteLength(vertexBuffer.type);
-                            const upperName = attributeName.toUpperCase();
-                            const stride = vertexBuffer.effectiveByteStride / 4;
-                            const offset = vertexBuffer.effectiveByteOffset / 4;
-
-                            defines.push(`#define ${upperName}_STRIDE ${stride}`);
-                            defines.push(`#define ${upperName}_OFFSET ${offset}`);
-                            defines.push(`#define ${upperName}_COMPONENT_BYTES ${componentBytes}`);
-                        }
-                    }
-                }
+                PrepareDefinesForVertexPullingMetadata(geometry, defines);
+                this._vertexPullingMetadata = PrepareVertexPullingUniforms(geometry);
             }
         }
 
@@ -1107,6 +1097,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);