@luma.gl/core 9.2.6 → 9.3.0-alpha.10

package/src/adapter/types/shader-layout.ts

@@ -2,15 +2,15 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
-import type {TextureFormat} from '../../shadertypes/textures/texture-formats';
-import type {
-  VariableShaderType,
-  AttributeShaderType
-} from '../../shadertypes/data-types/shader-types';
-import type {Buffer} from '../resources/buffer';
-import type {Sampler} from '../resources/sampler';
-import type {Texture} from '../resources/texture';
-import type {TextureView} from '../resources/texture-view';
+import {type TextureFormat} from '../../shadertypes/texture-types/texture-formats';
+import {
+  type VariableShaderType,
+  type AttributeShaderType
+} from '../../shadertypes/shader-types/shader-types';
+import {type Buffer} from '../resources/buffer';
+import {type Sampler} from '../resources/sampler';
+import {type Texture} from '../resources/texture';
+import {type TextureView} from '../resources/texture-view';
 
 /**
  * Describes all shader binding points for a `RenderPipeline` or `ComputePipeline`
@@ -166,6 +166,12 @@ export type Binding =
   | Buffer
   | {buffer: Buffer; offset?: number; size?: number};
 
+/** Named binding map */
+export type Bindings = Record<string, Binding>;
+
+/** Bindings partitioned by bind-group index */
+export type BindingsByGroup = Partial<Record<number, Bindings>>;
+
 // SHADER LAYOUTS
 
 /**

package/src/adapter/types/uniforms.ts

@@ -8,3 +8,15 @@ import {NumericArray} from '@math.gl/types';
 
 /** Valid values for uniforms. @note boolean values get converted to 0 or 1 before setting */
 export type UniformValue = number | boolean | Readonly<NumericArray>; // Float32Array> | Readonly<Int32Array> | Readonly<Uint32Array> | Readonly<number[]>;
+
+/** Recursive uniform value tree used by uniform-buffer packing utilities. */
+export type CompositeUniformValue =
+  | UniformValue
+  | CompositeUniformValueStruct
+  | CompositeUniformValueArray;
+
+export type CompositeUniformValueStruct = {
+  [name: string]: CompositeUniformValue | undefined;
+};
+
+export type CompositeUniformValueArray = ReadonlyArray<CompositeUniformValue | undefined>;

package/src/adapter-utils/bind-groups.ts

@@ -0,0 +1,71 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import type {
+  BindingDeclaration,
+  Bindings,
+  BindingsByGroup,
+  ComputeShaderLayout,
+  ShaderLayout
+} from '../adapter/types/shader-layout';
+import {log} from '../utils/log';
+
+type AnyShaderLayout = Pick<ShaderLayout | ComputeShaderLayout, 'bindings'>;
+
+export function getShaderLayoutBinding(
+  shaderLayout: AnyShaderLayout,
+  bindingName: string,
+  options?: {ignoreWarnings?: boolean}
+): BindingDeclaration | null {
+  const bindingLayout = shaderLayout.bindings.find(
+    binding =>
+      binding.name === bindingName ||
+      `${binding.name.toLocaleLowerCase()}uniforms` === bindingName.toLocaleLowerCase()
+  );
+
+  if (!bindingLayout && !options?.ignoreWarnings) {
+    log.warn(`Binding ${bindingName} not set: Not found in shader layout.`)();
+  }
+
+  return bindingLayout || null;
+}
+
+export function normalizeBindingsByGroup(
+  shaderLayout: AnyShaderLayout,
+  bindingsOrBindGroups?: Bindings | BindingsByGroup
+): BindingsByGroup {
+  if (!bindingsOrBindGroups) {
+    return {};
+  }
+
+  if (areBindingsGrouped(bindingsOrBindGroups)) {
+    const bindGroups = bindingsOrBindGroups as BindingsByGroup;
+    return Object.fromEntries(
+      Object.entries(bindGroups).map(([group, bindings]) => [Number(group), {...bindings}])
+    ) as BindingsByGroup;
+  }
+
+  const bindGroups: BindingsByGroup = {};
+  for (const [bindingName, binding] of Object.entries(bindingsOrBindGroups as Bindings)) {
+    const bindingLayout = getShaderLayoutBinding(shaderLayout, bindingName);
+    const group = bindingLayout?.group ?? 0;
+    bindGroups[group] ||= {};
+    bindGroups[group][bindingName] = binding;
+  }
+
+  return bindGroups;
+}
+
+export function flattenBindingsByGroup(bindGroups: BindingsByGroup): Bindings {
+  const bindings: Bindings = {};
+  for (const groupBindings of Object.values(bindGroups)) {
+    Object.assign(bindings, groupBindings);
+  }
+  return bindings;
+}
+
+function areBindingsGrouped(bindingsOrBindGroups: Bindings | BindingsByGroup): boolean {
+  const keys = Object.keys(bindingsOrBindGroups);
+  return keys.length > 0 && keys.every(key => /^\d+$/.test(key));
+}

package/src/adapter-utils/format-compiler-log.ts

@@ -21,25 +21,33 @@ export function formatCompilerLog(
   switch (options?.showSourceCode || 'no') {
     case 'all':
       // Parse the error - note: browser and driver dependent
-      let currentMessage = 0;
+      let currentMessageIndex = 0;
       for (let lineNum = 1; lineNum <= lines.length; lineNum++) {
-        formattedLog += getNumberedLine(lines[lineNum - 1], lineNum, options);
-        while (log.length > currentMessage && log[currentMessage].lineNum === lineNum) {
-          const message = log[currentMessage++];
-          formattedLog += formatCompilerMessage(message, lines, message.lineNum, {
+        const line = lines[lineNum - 1];
+        const currentMessage = log[currentMessageIndex];
+        if (line && currentMessage) {
+          formattedLog += getNumberedLine(line, lineNum, options);
+        }
+        while (log.length > currentMessageIndex && currentMessage.lineNum === lineNum) {
+          const message = log[currentMessageIndex++];
+          if (message) {
+            formattedLog += formatCompilerMessage(message, lines, message.lineNum, {
+              ...options,
+              inlineSource: false
+            });
+          }
+        }
+      }
+      // Print any remaining messages
+      while (log.length > currentMessageIndex) {
+        const message = log[currentMessageIndex++];
+        if (message) {
+          formattedLog += formatCompilerMessage(message, [], 0, {
             ...options,
             inlineSource: false
           });
         }
       }
-      // Print any remaining messages
-      while (log.length > currentMessage) {
-        const message = log[currentMessage++];
-        formattedLog += formatCompilerMessage(message, [], 0, {
-          ...options,
-          inlineSource: false
-        });
-      }
       return formattedLog;
 
     case 'issues':
@@ -75,9 +83,9 @@ ${numberedLines}${positionIndicator}${message.type.toUpperCase()}: ${message.mes
 
 `;
   }
-  const color = message.type === 'error' ? 'red' : '#8B4000'; // dark orange
+  const color = message.type === 'error' ? 'red' : 'orange';
   return options?.html
-    ? `<div class='luma-compiler-log-error' style="color:${color};"><b> ${message.type.toUpperCase()}: ${
+    ? `<div class='luma-compiler-log-${message.type}' style="color:${color};"><b> ${message.type.toUpperCase()}: ${
         message.message
       }</b></div>`
     : `${message.type.toUpperCase()}: ${message.message}`;

package/src/adapter-utils/get-attribute-from-layouts.ts

@@ -4,13 +4,10 @@
 
 import {log} from '../utils/log';
 import type {PrimitiveDataType, NormalizedDataType} from '../shadertypes/data-types/data-types';
-import type {AttributeShaderType} from '../shadertypes/data-types/shader-types';
-import type {VertexFormat} from '../shadertypes/vertex-arrays/vertex-formats';
-import {getAttributeShaderTypeInfo} from '../shadertypes/data-types/decode-shader-types';
-import {
-  getVertexFormatInfo,
-  getCompatibleVertexFormat
-} from '../shadertypes/vertex-arrays/decode-vertex-format';
+import type {AttributeShaderType} from '../shadertypes/shader-types/shader-types';
+import type {VertexFormat} from '../shadertypes/vertex-types/vertex-formats';
+import {shaderTypeDecoder} from '../shadertypes/shader-types/shader-type-decoder';
+import {vertexFormatDecoder} from '../shadertypes/vertex-types/vertex-format-decoder';
 import type {ShaderLayout, AttributeDeclaration} from '../adapter/types/shader-layout';
 import type {BufferLayout} from '../adapter/types/buffer-layout';
 
@@ -112,10 +109,10 @@ function getAttributeInfoFromLayouts(
     return null;
   }
 
-  const attributeTypeInfo = getAttributeShaderTypeInfo(shaderDeclaration.type);
-  const defaultVertexFormat = getCompatibleVertexFormat(attributeTypeInfo);
+  const attributeTypeInfo = shaderTypeDecoder.getAttributeShaderTypeInfo(shaderDeclaration.type);
+  const defaultVertexFormat = vertexFormatDecoder.getCompatibleVertexFormat(attributeTypeInfo);
   const vertexFormat = bufferMapping?.vertexFormat || defaultVertexFormat;
-  const vertexFormatInfo = getVertexFormatInfo(vertexFormat);
+  const vertexFormatInfo = vertexFormatDecoder.getVertexFormatInfo(vertexFormat);
 
   return {
     attributeName: bufferMapping?.attributeName || shaderDeclaration.name,
@@ -217,7 +214,7 @@ function getAttributeFromAttributesList(
     // Calculate a default byte stride if not provided
     if (typeof bufferLayout.byteStride !== 'number') {
       for (const attributeMapping of bufferLayout.attributes || []) {
-        const info = getVertexFormatInfo(attributeMapping.format);
+        const info = vertexFormatDecoder.getVertexFormatInfo(attributeMapping.format);
         // @ts-ignore
         byteStride += info.byteLength;
       }

package/src/factories/bind-group-factory.ts

@@ -0,0 +1,139 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import type {
+  Bindings,
+  BindingsByGroup,
+  ComputeShaderLayout,
+  ShaderLayout
+} from '../adapter/types/shader-layout';
+import type {Device} from '../adapter/device';
+import type {ComputePipeline} from '../adapter/resources/compute-pipeline';
+import type {RenderPipeline} from '../adapter/resources/render-pipeline';
+import {normalizeBindingsByGroup} from '../adapter-utils/bind-groups';
+
+type AnyPipeline = RenderPipeline | ComputePipeline;
+type AnyShaderLayout = ShaderLayout | ComputeShaderLayout;
+type BindGroupCacheKeys = Partial<Record<number, object>>;
+type BindGroupMap = Partial<Record<number, unknown>>;
+type LayoutCache = Partial<Record<number, object>>;
+type LayoutBindGroupCache = {
+  bindGroupsBySource: WeakMap<object, unknown | null>;
+  emptyBindGroup?: unknown;
+};
+
+export class BindGroupFactory {
+  readonly device: Device;
+
+  private readonly _layoutCacheByPipeline: WeakMap<AnyPipeline, LayoutCache> = new WeakMap();
+  private readonly _bindGroupCacheByLayout: WeakMap<object, LayoutBindGroupCache> = new WeakMap();
+
+  constructor(device: Device) {
+    this.device = device;
+  }
+
+  getBindGroups(
+    pipeline: AnyPipeline,
+    bindings?: Bindings | BindingsByGroup,
+    bindGroupCacheKeys?: BindGroupCacheKeys
+  ): BindGroupMap {
+    if (this.device.type !== 'webgpu' || pipeline.shaderLayout.bindings.length === 0) {
+      return {};
+    }
+
+    const bindingsByGroup = normalizeBindingsByGroup(pipeline.shaderLayout, bindings);
+    const resolvedBindGroups: BindGroupMap = {};
+
+    for (const group of getBindGroupIndicesUpToMax(pipeline.shaderLayout.bindings)) {
+      const groupBindings = bindingsByGroup[group];
+      const bindGroupLayout = this._getBindGroupLayout(pipeline, group);
+
+      if (!groupBindings || Object.keys(groupBindings).length === 0) {
+        if (!hasBindingsInGroup(pipeline.shaderLayout.bindings, group)) {
+          resolvedBindGroups[group] = this._getEmptyBindGroup(
+            bindGroupLayout,
+            pipeline.shaderLayout,
+            group
+          );
+        }
+        continue;
+      }
+
+      const bindGroupCacheKey = bindGroupCacheKeys?.[group];
+      if (bindGroupCacheKey) {
+        const layoutCache = this._getLayoutBindGroupCache(bindGroupLayout);
+        if (layoutCache.bindGroupsBySource.has(bindGroupCacheKey)) {
+          resolvedBindGroups[group] = layoutCache.bindGroupsBySource.get(bindGroupCacheKey) || null;
+          continue;
+        }
+
+        const bindGroup = this.device._createBindGroupWebGPU(
+          bindGroupLayout,
+          pipeline.shaderLayout,
+          groupBindings,
+          group
+        );
+        layoutCache.bindGroupsBySource.set(bindGroupCacheKey, bindGroup);
+        resolvedBindGroups[group] = bindGroup;
+      } else {
+        resolvedBindGroups[group] = this.device._createBindGroupWebGPU(
+          bindGroupLayout,
+          pipeline.shaderLayout,
+          groupBindings,
+          group
+        );
+      }
+    }
+
+    return resolvedBindGroups;
+  }
+
+  private _getBindGroupLayout(pipeline: AnyPipeline, group: number): object {
+    let layoutCache = this._layoutCacheByPipeline.get(pipeline);
+    if (!layoutCache) {
+      layoutCache = {};
+      this._layoutCacheByPipeline.set(pipeline, layoutCache);
+    }
+
+    layoutCache[group] ||= this.device._createBindGroupLayoutWebGPU(pipeline, group) as object;
+    return layoutCache[group];
+  }
+
+  private _getEmptyBindGroup(
+    bindGroupLayout: object,
+    shaderLayout: AnyShaderLayout,
+    group: number
+  ): unknown {
+    const layoutCache = this._getLayoutBindGroupCache(bindGroupLayout);
+    layoutCache.emptyBindGroup ||=
+      this.device._createBindGroupWebGPU(bindGroupLayout, shaderLayout, {}, group) || null;
+    return layoutCache.emptyBindGroup;
+  }
+
+  private _getLayoutBindGroupCache(bindGroupLayout: object): LayoutBindGroupCache {
+    let layoutCache = this._bindGroupCacheByLayout.get(bindGroupLayout);
+    if (!layoutCache) {
+      layoutCache = {bindGroupsBySource: new WeakMap()};
+      this._bindGroupCacheByLayout.set(bindGroupLayout, layoutCache);
+    }
+    return layoutCache;
+  }
+}
+
+export function _getDefaultBindGroupFactory(device: Device): BindGroupFactory {
+  device._factories.bindGroupFactory ||= new BindGroupFactory(device);
+  return device._factories.bindGroupFactory as BindGroupFactory;
+}
+
+function getBindGroupIndicesUpToMax(bindings: AnyShaderLayout['bindings']): number[] {
+  const maxGroup = bindings.reduce(
+    (highestGroup, binding) => Math.max(highestGroup, binding.group),
+    -1
+  );
+  return Array.from({length: maxGroup + 1}, (_, group) => group);
+}
+
+function hasBindingsInGroup(bindings: AnyShaderLayout['bindings'], group: number): boolean {
+  return bindings.some(binding => binding.group === group);
+}

package/src/factories/core-module-state.ts

@@ -0,0 +1,11 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import type {PipelineFactory} from './pipeline-factory';
+import type {ShaderFactory} from './shader-factory';
+
+export type CoreModuleState = {
+  defaultPipelineFactory?: PipelineFactory;
+  defaultShaderFactory?: ShaderFactory;
+};