@luma.gl/engine 9.1.9 → 9.2.0-alpha.2

package/src/factories/shader-factory.ts

@@ -2,7 +2,7 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
-import {Device, Shader, ShaderProps} from '@luma.gl/core';
+import {Device, Shader, ShaderProps, log} from '@luma.gl/core';
 
 /** Manages a cached pool of Shaders for reuse. */
 export class ShaderFactory {
@@ -10,22 +10,39 @@ export class ShaderFactory {
 
   /** Returns the default ShaderFactory for the given {@link Device}, creating one if necessary. */
   static getDefaultShaderFactory(device: Device): ShaderFactory {
-    device._lumaData.defaultShaderFactory ||= new ShaderFactory(device);
-    return device._lumaData.defaultShaderFactory as ShaderFactory;
+    device._lumaData['defaultShaderFactory'] ||= new ShaderFactory(device);
+    return device._lumaData['defaultShaderFactory'] as ShaderFactory;
   }
 
   public readonly device: Device;
+  readonly cachingEnabled: boolean;
   readonly destroyPolicy: 'unused' | 'never';
+  readonly debug: boolean;
+
   private readonly _cache: Record<string, {shader: Shader; useCount: number}> = {};
 
+  get [Symbol.toStringTag](): string {
+    return 'ShaderFactory';
+  }
+
+  toString(): string {
+    return `${this[Symbol.toStringTag]}(${this.device.id})`;
+  }
+
   /** @internal */
   constructor(device: Device) {
     this.device = device;
-    this.destroyPolicy = device.props._factoryDestroyPolicy;
+    this.cachingEnabled = device.props._cacheShaders;
+    this.destroyPolicy = device.props._cacheDestroyPolicy;
+    this.debug = true; // device.props.debugFactories;
   }
 
   /** Requests a {@link Shader} from the cache, creating a new Shader only if necessary. */
   createShader(props: ShaderProps): Shader {
+    if (!this.cachingEnabled) {
+      return this.device.createShader(props);
+    }
+
     const key = this._hashShader(props);
 
     let cacheEntry = this._cache[key];
@@ -34,15 +51,27 @@ export class ShaderFactory {
         ...props,
         id: props.id ? `${props.id}-cached` : undefined
       });
-      this._cache[key] = cacheEntry = {shader, useCount: 0};
+      this._cache[key] = cacheEntry = {shader, useCount: 1};
+      if (this.debug) {
+        log.warn(`${this}: Created new shader ${shader.id}`)();
+      }
+    } else {
+      cacheEntry.useCount++;
+      if (this.debug) {
+        log.warn(`${this}: Reusing shader ${cacheEntry.shader.id} count=${cacheEntry.useCount}`)();
+      }
     }
 
-    cacheEntry.useCount++;
     return cacheEntry.shader;
   }
 
   /** Releases a previously-requested {@link Shader}, destroying it if no users remain. */
   release(shader: Shader): void {
+    if (!this.cachingEnabled) {
+      shader.destroy();
+      return;
+    }
+
     const key = this._hashShader(shader);
     const cacheEntry = this._cache[key];
     if (cacheEntry) {
@@ -51,14 +80,21 @@ export class ShaderFactory {
         if (this.destroyPolicy === 'unused') {
           delete this._cache[key];
           cacheEntry.shader.destroy();
+          if (this.debug) {
+            log.warn(`${this}: Releasing shader ${shader.id}, destroyed`)();
+          }
         }
+      } else if (cacheEntry.useCount < 0) {
+        throw new Error(`ShaderFactory: Shader ${shader.id} released too many times`);
+      } else if (this.debug) {
+        log.warn(`${this}: Releasing shader ${shader.id} count=${cacheEntry.useCount}`)();
       }
     }
   }
 
   // PRIVATE
 
-  private _hashShader(value: Shader | ShaderProps): string {
+  protected _hashShader(value: Shader | ShaderProps): string {
     return `${value.stage}:${value.source}`;
   }
 }

package/src/geometry/geometry.ts

@@ -86,9 +86,9 @@ export class Geometry {
       }
     }
 
-    if (this.indices && this.indices.isIndexed !== undefined) {
+    if (this.indices && this.indices['isIndexed'] !== undefined) {
       this.indices = Object.assign({}, this.indices);
-      delete this.indices.isIndexed;
+      delete this.indices['isIndexed'];
     }
 
     this.vertexCount = vertexCount || this._calculateVertexCount(this.attributes, this.indices);
@@ -103,6 +103,7 @@ export class Geometry {
    * TODO Geometry types are a mess
    */
   getAttributes(): GeometryAttributes {
+    // @ts-ignore
     return this.indices ? {indices: this.indices, ...this.attributes} : this.attributes;
   }
 

package/src/index.ts

@@ -80,6 +80,18 @@ export {SwapFramebuffers} from './compute/swap';
 export type {ComputationProps} from './compute/computation';
 export {Computation} from './compute/computation';
 
+export type {
+  TextureCubeFace,
+  TextureImageData,
+  TextureData,
+  Texture1DData,
+  Texture2DData,
+  Texture3DData,
+  TextureCubeData,
+  TextureArrayData,
+  TextureCubeArrayData
+} from './async-texture/async-texture';
+
 export type {AsyncTextureProps} from './async-texture/async-texture';
 export {AsyncTexture} from './async-texture/async-texture';
 

package/src/model/model.ts

@@ -13,7 +13,6 @@ import type {
   TransformFeedback,
   AttributeInfo,
   Binding,
-  UniformValue,
   PrimitiveTopology
 } from '@luma.gl/core';
 import {
@@ -27,10 +26,8 @@ import {
   RenderPass,
   UniformStore,
   log,
-  getTypedArrayFromDataType,
-  getAttributeInfosFromLayouts,
-  _BufferLayoutHelper,
-  sortedBufferLayoutByShaderSourceLocations
+  getTypedArrayConstructor,
+  getAttributeInfosFromLayouts
 } from '@luma.gl/core';
 
 import type {ShaderModule, PlatformInfo} from '@luma.gl/shadertools';
@@ -43,25 +40,24 @@ import {ShaderFactory} from '../factories/shader-factory';
 import {getDebugTableForShaderLayout} from '../debug/debug-shader-layout';
 import {debugFramebuffer} from '../debug/debug-framebuffer';
 import {deepEqual} from '../utils/deep-equal';
+import {BufferLayoutHelper} from '../utils/buffer-layout-helper';
+import {sortedBufferLayoutByShaderSourceLocations} from '../utils/buffer-layout-order';
 import {uid} from '../utils/uid';
 import {ShaderInputs} from '../shader-inputs';
-// import type {AsyncTextureProps} from '../async-texture/async-texture';
 import {AsyncTexture} from '../async-texture/async-texture';
 
-import {splitUniformsAndBindings} from './split-uniforms-and-bindings';
-
 const LOG_DRAW_PRIORITY = 2;
 const LOG_DRAW_TIMEOUT = 10000;
 
 export type ModelProps = Omit<RenderPipelineProps, 'vs' | 'fs' | 'bindings'> & {
   source?: string;
-  vs: string | null;
-  fs: string | null;
+  vs?: string | null;
+  fs?: string | null;
 
   /** shadertool shader modules (added to shader code) */
   modules?: ShaderModule[];
   /** Shadertool module defines (configures shader code)*/
-  defines?: Record<string, string | number | boolean>;
+  defines?: Record<string, boolean>;
   // TODO - injections, hooks etc?
 
   /** Shader inputs, used to generated uniform buffers and bindings */
@@ -95,9 +91,6 @@ export type ModelProps = Omit<RenderPipelineProps, 'vs' | 'fs' | 'bindings'> & {
 
   transformFeedback?: TransformFeedback;
 
-  /** Mapped uniforms for shadertool modules */
-  moduleSettings?: Record<string, Record<string, any>>;
-
   /** Show shader source in browser? */
   debugShaders?: 'never' | 'errors' | 'warnings' | 'always';
 
@@ -128,7 +121,6 @@ export class Model {
     userData: {},
     defines: {},
     modules: [],
-    moduleSettings: undefined!,
     geometry: null,
     indexBuffer: null,
     attributes: {},
@@ -188,8 +180,6 @@ export class Model {
   constantAttributes: Record<string, TypedArray> = {};
   /** Bindings (textures, samplers, uniform buffers) */
   bindings: Record<string, Binding | AsyncTexture> = {};
-  /** Sets uniforms @deprecated Use uniform buffers and setBindings() for portability*/
-  uniforms: Record<string, UniformValue> = {};
 
   /**
    * VertexArray
@@ -212,7 +202,6 @@ export class Model {
 
   _attributeInfos: Record<string, AttributeInfo> = {};
   _gpuGeometry: GPUGeometry | null = null;
-  private _getModuleUniforms: (props?: Record<string, Record<string, any>>) => Record<string, any>;
   private props: Required<ModelProps>;
 
   _pipelineNeedsUpdate: string | false = 'newly created';
@@ -309,7 +298,8 @@ export class Model {
     this.pipeline = this._updatePipeline();
 
     this.vertexArray = device.createVertexArray({
-      renderPipeline: this.pipeline
+      shaderLayout: this.pipeline.shaderLayout,
+      bufferLayout: this.pipeline.bufferLayout
     });
 
     // Now we can apply geometry attributes
@@ -340,13 +330,6 @@ export class Model {
     if (props.bindings) {
       this.setBindings(props.bindings);
     }
-    if (props.uniforms) {
-      this.setUniformsWebGL(props.uniforms);
-    }
-    if (props.moduleSettings) {
-      // log.warn('Model.props.moduleSettings is deprecated. Use Model.shaderInputs.setProps()')();
-      this.updateModuleSettingsWebGL(props.moduleSettings);
-    }
     if (props.transformFeedback) {
       this.transformFeedback = props.transformFeedback;
     }
@@ -356,16 +339,19 @@ export class Model {
   }
 
   destroy(): void {
-    if (this._destroyed) return;
-    this.pipelineFactory.release(this.pipeline);
-    this.shaderFactory.release(this.pipeline.vs);
-    if (this.pipeline.fs) {
-      this.shaderFactory.release(this.pipeline.fs);
-    }
-    this._uniformStore.destroy();
-    // TODO - mark resource as managed and destroyIfManaged() ?
-    this._gpuGeometry?.destroy();
-    this._destroyed = true;
+    if (!this._destroyed) {
+      // Release pipeline before we destroy the shaders used by the pipeline
+      this.pipelineFactory.release(this.pipeline);
+      // Release the shaders
+      this.shaderFactory.release(this.pipeline.vs);
+      if (this.pipeline.fs) {
+        this.shaderFactory.release(this.pipeline.fs);
+      }
+      this._uniformStore.destroy();
+      // TODO - mark resource as managed and destroyIfManaged() ?
+      this._gpuGeometry?.destroy();
+      this._destroyed = true;
+    }
   }
 
   // Draw call
@@ -425,9 +411,6 @@ export class Model {
       this.pipeline.setBindings(syncBindings, {
         disableWarnings: this.props.disableWarnings
       });
-      if (!isObjectEmpty(this.uniforms)) {
-        this.pipeline.setUniformsWebGL(this.uniforms);
-      }
 
       const {indexBuffer} = this.vertexArray;
       const indexCount = indexBuffer
@@ -476,7 +459,7 @@ export class Model {
     const gpuGeometry = geometry && makeGPUGeometry(this.device, geometry);
     if (gpuGeometry) {
       this.setTopology(gpuGeometry.topology || 'triangle-list');
-      const bufferLayoutHelper = new _BufferLayoutHelper(this.bufferLayout);
+      const bufferLayoutHelper = new BufferLayoutHelper(this.bufferLayout);
       this.bufferLayout = bufferLayoutHelper.mergeBufferLayouts(
         gpuGeometry.bufferLayout,
         this.bufferLayout
@@ -504,7 +487,7 @@ export class Model {
    * @note Triggers a pipeline rebuild / pipeline cache fetch
    */
   setBufferLayout(bufferLayout: BufferLayout[]): void {
-    const bufferLayoutHelper = new _BufferLayoutHelper(this.bufferLayout);
+    const bufferLayoutHelper = new BufferLayoutHelper(this.bufferLayout);
     this.bufferLayout = this._gpuGeometry
       ? bufferLayoutHelper.mergeBufferLayouts(bufferLayout, this._gpuGeometry.bufferLayout)
       : bufferLayout;
@@ -516,7 +499,8 @@ export class Model {
     // vertex array needs to be updated if we update buffer layout,
     // but not if we update parameters
     this.vertexArray = this.device.createVertexArray({
-      renderPipeline: this.pipeline
+      shaderLayout: this.pipeline.shaderLayout,
+      bufferLayout: this.pipeline.bufferLayout
     });
 
     // Reapply geometry attributes to the new vertex array
@@ -615,7 +599,7 @@ export class Model {
    */
   setAttributes(buffers: Record<string, Buffer>, options?: {disableWarnings?: boolean}): void {
     const disableWarnings = options?.disableWarnings ?? this.props.disableWarnings;
-    if (buffers.indices) {
+    if (buffers['indices']) {
       log.warn(
         `Model:${this.id} setAttributes() - indexBuffer should be set using setIndexBuffer()`
       )();
@@ -627,7 +611,7 @@ export class Model {
       this.pipeline.shaderLayout,
       this.bufferLayout
     );
-    const bufferLayoutHelper = new _BufferLayoutHelper(this.bufferLayout);
+    const bufferLayoutHelper = new BufferLayoutHelper(this.bufferLayout);
 
     // Check if all buffers have a layout
     for (const [bufferName, buffer] of Object.entries(buffers)) {
@@ -689,42 +673,7 @@ export class Model {
     this.setNeedsRedraw('constants');
   }
 
-  // DEPRECATED METHODS
-
-  /**
-   * Sets individual uniforms
-   * @deprecated WebGL only, use uniform buffers for portability
-   * @param uniforms
-   */
-  setUniforms(uniforms: Record<string, UniformValue>): void {
-    this.setUniformsWebGL(uniforms);
-  }
-
-  /**
-   * Sets individual uniforms
-   * @deprecated WebGL only, use uniform buffers for portability
-   * @param uniforms
-   */
-  setUniformsWebGL(uniforms: Record<string, UniformValue>): void {
-    if (!isObjectEmpty(uniforms)) {
-      this.pipeline.setUniformsWebGL(uniforms);
-      Object.assign(this.uniforms, uniforms);
-    }
-    this.setNeedsRedraw('uniforms');
-  }
-
-  /**
-   * @deprecated Updates shader module settings (which results in uniforms being set)
-   */
-  updateModuleSettingsWebGL(props: Record<string, any>): void {
-    // log.warn('Model.updateModuleSettings is deprecated. Use Model.shaderInputs.setProps()')();
-    const {bindings, uniforms} = splitUniformsAndBindings(this._getModuleUniforms(props));
-    Object.assign(this.bindings, bindings);
-    Object.assign(this.uniforms, uniforms);
-    this.setNeedsRedraw('moduleSettings');
-  }
-
-  // Internal methods
+  // INTERNAL METHODS
 
   /** Check that bindings are loaded. Returns id of first binding that is still loading. */
   _areBindingsLoading(): string | false {
@@ -890,10 +839,6 @@ export class Model {
       log.table(LOG_DRAW_PRIORITY, shaderLayoutTable)();
 
       const uniformTable = this.shaderInputs.getDebugTable();
-      // Add any global uniforms
-      for (const [name, value] of Object.entries(this.uniforms)) {
-        uniformTable[name] = {value};
-      }
       log.table(LOG_DRAW_PRIORITY, uniformTable)();
 
       const attributeTable = this._getAttributeDebugTable();
@@ -940,7 +885,7 @@ export class Model {
         indexBuffer.indexType === 'uint32'
           ? new Uint32Array(indexBuffer.debugData)
           : new Uint16Array(indexBuffer.debugData);
-      table.indices = {
+      table['indices'] = {
         name: 'indices',
         type: indexBuffer.indexType,
         values: values.toString()
@@ -951,7 +896,7 @@ export class Model {
 
   // TODO - fix typing of luma data types
   _getBufferOrConstantValues(attribute: Buffer | TypedArray, dataType: any): string {
-    const TypedArrayConstructor = getTypedArrayFromDataType(dataType);
+    const TypedArrayConstructor = getTypedArrayConstructor(dataType);
     const typedArray =
       attribute instanceof Buffer ? new TypedArrayConstructor(attribute.debugData) : attribute;
     return typedArray.toString();

package/src/models/billboard-texture-model.ts

@@ -11,7 +11,7 @@ const BACKGROUND_FS_WGSL = /* wgsl */ `\
 @group(0) @binding(1) var backgroundTextureSampler: sampler;
 
 fn billboardTexture_getTextureUV(coordinates: vec2<f32>) -> vec2<f32> {
-	let iTexSize: vec2<u32> = textureDimensions(backgroundTexture, 0) * 2;
+	let iTexSize: vec2<u32> = textureDimensions(backgroundTexture, 0);
 	let texSize: vec2<f32> = vec2<f32>(f32(iTexSize.x), f32(iTexSize.y));
 	var position: vec2<f32> = coordinates.xy / texSize;
 	return position;
@@ -32,7 +32,7 @@ uniform sampler2D backgroundTexture;
 out vec4 fragColor;
 
 vec2 billboardTexture_getTextureUV() {
-  ivec2 iTexSize = textureDimensions(backgroundTexture, 0) * 2;
+  ivec2 iTexSize = textureSize(backgroundTexture, 0);
   vec2 texSize = vec2(float(iTexSize.x), float(iTexSize.y));
   vec2 position = gl_FragCoord.xy / texSize;
   return position;
@@ -67,14 +67,13 @@ export class BackgroundTextureModel extends ClipSpace {
       fs: BACKGROUND_FS,
       parameters: {
         depthWriteEnabled: false,
-        depthCompare: 'always',
         ...(props.blend
           ? {
               blend: true,
               blendColorOperation: 'add',
               blendAlphaOperation: 'add',
               blendColorSrcFactor: 'one',
-              blendColorDstFactor: 'one-minus-src-color',
+              blendColorDstFactor: 'one-minus-src',
               blendAlphaSrcFactor: 'one',
               blendAlphaDstFactor: 'one-minus-src-alpha'
             }
@@ -82,6 +81,9 @@ export class BackgroundTextureModel extends ClipSpace {
       }
     });
 
+    if (!props.backgroundTexture) {
+      throw new Error('BackgroundTextureModel requires a backgroundTexture prop');
+    }
     this.setTexture(props.backgroundTexture);
   }
 

package/src/modules/picking/legacy-picking-manager.ts

@@ -42,7 +42,7 @@ export class LegacyPickingManager {
   /** Prepare for rendering picking colors */
   beginRenderPass() {
     const framebuffer = this.getFramebuffer();
-    framebuffer.resize(this.device.getCanvasContext().getPixelSize());
+    framebuffer.resize(this.device.getCanvasContext().getDevicePixelSize());
 
     this.shaderInputs.setProps({picking: {isActive: true}});
 
@@ -90,7 +90,7 @@ export class LegacyPickingManager {
    * Get pick position in device pixel range
    * use the center pixel location in device pixel range
    */
-  getPickPosition(mousePosition: number[]): [number, number] {
+  getPickPosition(mousePosition: [number, number]): [number, number] {
     const devicePixels = this.device.getCanvasContext().cssToDevicePixels(mousePosition);
     const pickX = devicePixels.x + Math.floor(devicePixels.width / 2);
     const pickY = devicePixels.y + Math.floor(devicePixels.height / 2);

package/src/modules/picking/picking-manager.ts

@@ -67,7 +67,7 @@ export class PickingManager {
   /** Prepare for rendering picking colors */
   beginRenderPass() {
     const framebuffer = this.getFramebuffer();
-    framebuffer.resize(this.device.getDefaultCanvasContext().getPixelSize());
+    framebuffer.resize(this.device.getDefaultCanvasContext().getDevicePixelSize());
 
     this.props.shaderInputs?.setProps({picking: {isActive: true}});
 
@@ -80,7 +80,7 @@ export class PickingManager {
     return pickingPass;
   }
 
-  getPickInfo(mousePosition: [number, number]): PickInfo | null {
+  async updatePickInfo(mousePosition: [number, number]): Promise<PickInfo | null> {
     const framebuffer = this.getFramebuffer();
 
     // use the center pixel location in device pixel range
@@ -128,7 +128,7 @@ export class PickingManager {
    * Get pick position in device pixel range
    * use the center pixel location in device pixel range
    */
-  getPickPosition(mousePosition: number[]): [number, number] {
+  getPickPosition(mousePosition: [number, number]): [number, number] {
     const devicePixels = this.device.getDefaultCanvasContext().cssToDevicePixels(mousePosition);
     const pickX = devicePixels.x + Math.floor(devicePixels.width / 2);
     const pickY = devicePixels.y + Math.floor(devicePixels.height / 2);

package/src/passes/get-fragment-shader.ts

@@ -37,11 +37,11 @@ export function getFragmentShaderForRenderPass(options: {
 function getFilterShaderWGSL(func: string) {
   return /* wgsl */ `\
 // Binding 0:1 is reserved for shader passes
-@group(0) @binding(0) var<uniform> brightnessContrast : brightnessContrastUniforms;
+// @group(0) @binding(0) var<uniform> brightnessContrast : brightnessContrastUniforms;
 @group(0) @binding(1) var texture: texture_2d<f32>;
 @group(0) @binding(2) var sampler: sampler;
 
-struct FragmentInputs = {
+struct FragmentInputs {
   @location(0) fragUV: vec2f,
   @location(1) fragPosition: vec4f,
   @location(2) fragCoordinate: vec4f

package/src/passes/shader-pass-renderer.ts

@@ -44,9 +44,9 @@ export class ShaderPassRenderer {
     );
     this.shaderInputs = props.shaderInputs || new ShaderInputs(modules);
 
-    const size = device.getCanvasContext().getPixelSize();
+    const size = device.getCanvasContext().getDrawingBufferSize();
     this.swapFramebuffers = new SwapFramebuffers(device, {
-      colorAttachments: ['rgba8unorm'],
+      colorAttachments: [device.preferredColorFormat],
       width: size[0],
       height: size[1]
     });
@@ -99,7 +99,7 @@ void main() {
     // this.props.passes.forEach(pass => pass.resize(width, height));
   }
 
-  renderToScreen(options: {sourceTexture: AsyncTexture; uniforms: any; bindings: any}): boolean {
+  renderToScreen(options: {sourceTexture: AsyncTexture; uniforms?: any; bindings?: any}): boolean {
     // Run the shader passes and generate an output texture
     const outputTexture = this.renderToTexture(options);
     if (!outputTexture) {
@@ -107,7 +107,16 @@ void main() {
       return false;
     }
 
-    const renderPass = this.device.beginRenderPass({clearColor: [0, 0, 0, 1], clearDepth: 1});
+    const framebuffer = this.device
+      .getDefaultCanvasContext()
+      // @ts-expect-error TODO - remove after republish
+      .getCurrentFramebuffer({depthStencilAttachment: false});
+    const renderPass = this.device.beginRenderPass({
+      id: 'shader-pass-renderer-to-screen',
+      framebuffer,
+      clearColor: [0, 0, 0, 1],
+      clearDepth: 1
+    });
     this.clipSpace.setBindings({sourceTexture: outputTexture});
     this.clipSpace.draw(renderPass);
     renderPass.end();
@@ -119,8 +128,8 @@ void main() {
    */
   renderToTexture(options: {
     sourceTexture: AsyncTexture;
-    uniforms: any;
-    bindings: any;
+    uniforms?: any;
+    bindings?: any;
   }): Texture | null {
     const {sourceTexture} = options;
     if (!sourceTexture.isReady) {
@@ -134,6 +143,7 @@ void main() {
 
     // Clear the current texture before we begin
     const clearTexturePass = this.device.beginRenderPass({
+      id: 'shader-pass-renderer-clear-texture',
       framebuffer: this.swapFramebuffers.current,
       clearColor: [0, 0, 0, 1]
     });
@@ -163,6 +173,7 @@ void main() {
         };
 
         const renderPass = this.device.beginRenderPass({
+          id: 'shader-pass-renderer-run-pass',
           framebuffer: this.swapFramebuffers.next,
           clearColor: [0, 0, 0, 1],
           clearDepth: 1
@@ -226,8 +237,7 @@ class SubPassRenderer {
       fs,
       modules: [shaderPass],
       parameters: {
-        depthWriteEnabled: false,
-        depthCompare: 'always'
+        depthWriteEnabled: false
       }
     });
   }

package/src/shader-inputs.ts

@@ -4,7 +4,7 @@
 
 import type {Binding, UniformValue} from '@luma.gl/core';
 import {log} from '@luma.gl/core';
-// import type {ShaderUniformType, UniformValue, UniformFormat, UniformInfoDevice, Texture, Sampler} from '@luma.gl/core';
+// import type {VariableShaderType, UniformValue, UniformFormat, UniformInfoDevice, Texture, Sampler} from '@luma.gl/core';
 import {getShaderModuleDependencies, ShaderModule} from '@luma.gl/shadertools';
 import {splitUniformsAndBindings} from './model/split-uniforms-and-bindings';
 

package/src/utils/buffer-layout-helper.ts

@@ -0,0 +1,51 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import {log, type BufferLayout} from '@luma.gl/core';
+
+/** BufferLayoutHelper is a helper class that should not be used directly by applications */
+export class BufferLayoutHelper {
+  bufferLayouts: BufferLayout[];
+
+  constructor(bufferLayouts: BufferLayout[]) {
+    this.bufferLayouts = bufferLayouts;
+  }
+
+  getBufferLayout(name: string): BufferLayout | null {
+    return this.bufferLayouts.find(layout => layout.name === name) || null;
+  }
+
+  /** Get attribute names from a BufferLayout */
+  getAttributeNamesForBuffer(bufferLayout: BufferLayout): string[] {
+    return bufferLayout.attributes
+      ? bufferLayout.attributes?.map(layout => layout.attribute)
+      : [bufferLayout.name];
+  }
+
+  mergeBufferLayouts(
+    bufferLayouts1: BufferLayout[],
+    bufferLayouts2: BufferLayout[]
+  ): BufferLayout[] {
+    const mergedLayouts = [...bufferLayouts1];
+    for (const attribute of bufferLayouts2) {
+      const index = mergedLayouts.findIndex(attribute2 => attribute2.name === attribute.name);
+      if (index < 0) {
+        mergedLayouts.push(attribute);
+      } else {
+        mergedLayouts[index] = attribute;
+      }
+    }
+    return mergedLayouts;
+  }
+
+  getBufferIndex(bufferName: string): number {
+    const bufferIndex = this.bufferLayouts.findIndex(layout => layout.name === bufferName);
+
+    if (bufferIndex === -1) {
+      log.warn(`BufferLayout: Missing buffer for "${bufferName}".`)();
+    }
+
+    return bufferIndex;
+  }
+}

package/src/utils/buffer-layout-order.ts

@@ -0,0 +1,26 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import {type BufferLayout, type ShaderLayout} from '@luma.gl/core';
+
+export function sortedBufferLayoutByShaderSourceLocations(
+  shaderLayout: ShaderLayout,
+  bufferLayout: BufferLayout[]
+): BufferLayout[] {
+  const shaderLayoutMap = Object.fromEntries(
+    shaderLayout.attributes.map(attr => [attr.name, attr.location])
+  );
+
+  const sortedLayout = bufferLayout.slice();
+  sortedLayout.sort((a, b) => {
+    const attributeNamesA = a.attributes ? a.attributes.map(attr => attr.attribute) : [a.name];
+    const attributeNamesB = b.attributes ? b.attributes.map(attr => attr.attribute) : [b.name];
+    const minLocationA = Math.min(...attributeNamesA.map(name => shaderLayoutMap[name]));
+    const minLocationB = Math.min(...attributeNamesB.map(name => shaderLayoutMap[name]));
+
+    return minLocationA - minLocationB;
+  });
+
+  return sortedLayout;
+}