@luma.gl/webgl 9.0.0-beta.1 → 9.0.0-beta.10

package/src/adapter/converters/vertex-formats.ts

@@ -1,10 +1,11 @@
-// luma.gl, MIT license
+// luma.gl
+// SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
 import {GL} from '@luma.gl/constants';
 import {VertexFormat, VertexType} from '@luma.gl/core';
 
-type GLDataType = 
+type GLDataType =
   | GL.UNSIGNED_BYTE
   | GL.BYTE
   | GL.UNSIGNED_SHORT
@@ -14,7 +15,6 @@ type GLDataType =
   | GL.HALF_FLOAT
   | GL.FLOAT;
 
-
 /** Get vertex format from GL constants */
 export function getVertexFormatFromGL(type: GLDataType, components: 1 | 2 | 3 | 4): VertexFormat {
   const base = getVertexTypeFromGL(type);

package/src/adapter/device-helpers/webgl-device-features.ts

@@ -0,0 +1,121 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+// Feature detection for WebGL
+// Provides a function that enables simple checking of which WebGL features are
+
+import {DeviceFeature, DeviceFeatures} from '@luma.gl/core';
+import {GLExtensions} from '@luma.gl/constants';
+import {getWebGLExtension} from '../../context/helpers/webgl-extensions';
+import {isTextureFeature, checkTextureFeature} from '../converters/texture-formats';
+import {TEXTURE_FEATURES} from '../converters/texture-formats';
+
+/**
+ * Defines luma.gl "feature" names and semantics
+ * when value is 'string' it is the name of the extension that enables this feature
+ */
+const WEBGL_FEATURES: Partial<Record<DeviceFeature, boolean | string>> = {
+  // optional WebGPU features
+  'depth-clip-control': 'EXT_depth_clamp', // TODO these seem subtly different
+  // 'timestamp-query' // GPUQueryType "timestamp-query"
+  // "indirect-first-instance"
+  // Textures are handled by getTextureFeatures()
+  // 'depth24unorm-stencil8' // GPUTextureFormat 'depth24unorm-stencil8'
+  // 'depth32float-stencil8' // GPUTextureFormat 'depth32float-stencil8'
+
+  // optional WebGL features
+  'timer-query-webgl': 'EXT_disjoint_timer_query_webgl2',
+  'compilation-status-async-webgl': 'KHR_parallel_shader_compile',
+  'polygon-mode-webgl': 'WEBGL_polygon_mode',
+  'provoking-vertex-webgl': 'WEBGL_provoking_vertex',
+  'shader-clip-cull-distance-webgl': 'WEBGL_clip_cull_distance',
+  'shader-noperspective-interpolation-webgl': 'NV_shader_noperspective_interpolation',
+  'shader-conservative-depth-webgl': 'EXT_conservative_depth'
+
+  // Textures are handled by getTextureFeatures()
+};
+
+/**
+ * WebGL extensions exposed as luma.gl features
+ * To minimize GL log noise and improve performance, this class ensures that
+ * - WebGL extensions are not queried until the corresponding feature is checked.
+ * - WebGL extensions are only queried once.
+ */
+export class WebGLDeviceFeatures extends DeviceFeatures {
+  protected gl: WebGL2RenderingContext;
+  protected extensions: GLExtensions;
+  protected testedFeatures = new Set<DeviceFeature>();
+
+  constructor(
+    gl: WebGL2RenderingContext,
+    extensions: GLExtensions,
+    disabledFeatures: Partial<Record<DeviceFeature, boolean>>
+  ) {
+    super([], disabledFeatures);
+    this.gl = gl;
+    this.extensions = extensions;
+    // TODO - is this really needed?
+    // Enable EXT_float_blend first: https://developer.mozilla.org/en-US/docs/Web/API/EXT_float_blend
+    getWebGLExtension(gl, 'EXT_color_buffer_float', extensions);
+  }
+
+  *[Symbol.iterator](): IterableIterator<DeviceFeature> {
+    for (const feature of Object.keys(WEBGL_FEATURES) as DeviceFeature[]) {
+      if (this.has(feature)) {
+        yield feature;
+      }
+    }
+    for (const feature of Object.keys(TEXTURE_FEATURES) as DeviceFeature[]) {
+      if (this.has(feature)) {
+        yield feature;
+      }
+    }
+    return [];
+  }
+
+  override has(feature: DeviceFeature): boolean {
+    if (this.disabledFeatures[feature]) {
+      return false;
+    }
+
+    // We have already tested this feature
+    if (!this.testedFeatures.has(feature)) {
+      this.testedFeatures.add(feature);
+
+      // Check the feature once
+      if (isTextureFeature(feature) && checkTextureFeature(this.gl, feature, this.extensions)) {
+        this.features.add(feature);
+      }
+
+      if (this.getWebGLFeature(feature)) {
+        this.features.add(feature);
+      }
+    }
+    return this.features.has(feature);
+  }
+
+  // FOR DEVICE
+
+  initializeFeatures() {
+    // @ts-expect-error
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    for (const feature of this) {
+      // WebGL extensions are initialized by requesting them
+    }
+  }
+
+  // IMPLEMENTATION
+
+  /** Extract all WebGL features */
+  protected getWebGLFeature(feature: DeviceFeature): boolean {
+    const featureInfo = WEBGL_FEATURES[feature];
+    // string value requires checking the corresponding WebGL extension
+    const isSupported =
+      typeof featureInfo === 'string'
+        ? Boolean(getWebGLExtension(this.gl, featureInfo, this.extensions))
+        : Boolean(featureInfo);
+
+    return isSupported;
+  }
+}

package/src/adapter/device-helpers/{get-device-info.ts → webgl-device-info.ts}

@@ -1,19 +1,21 @@
-// luma.gl, MIT license
+// luma.gl
+// SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
 import {DeviceInfo} from '@luma.gl/core';
-import {GL} from '@luma.gl/constants';
-import {isWebGL2} from '../../context/context/webgl-checks';
+import {GL, GLExtensions} from '@luma.gl/constants';
+import {getWebGLExtension} from '../../context/helpers/webgl-extensions';
 
 /** @returns strings identifying the GPU vendor and driver. */
-export function getDeviceInfo(gl: WebGLRenderingContext): DeviceInfo {
+export function getDeviceInfo(gl: WebGL2RenderingContext, extensions: GLExtensions): DeviceInfo {
   // "Masked" info is always available, but don't contain much useful information
   const vendorMasked = gl.getParameter(GL.VENDOR);
   const rendererMasked = gl.getParameter(GL.RENDERER);
 
   // If we are lucky, unmasked info is available
   // https://www.khronos.org/registry/webgl/extensions/WEBGL_debug_renderer_info/
-  const ext = gl.getExtension('WEBGL_debug_renderer_info');
+  getWebGLExtension(gl, 'WEBGL_debug_renderer_info', extensions);
+  const ext = extensions.WEBGL_debug_renderer_info;
   const vendorUnmasked = gl.getParameter(ext ? ext.UNMASKED_VENDOR_WEBGL : GL.VENDOR);
   const rendererUnmasked = gl.getParameter(ext ? ext.UNMASKED_RENDERER_WEBGL : GL.RENDERER);
   const vendor = vendorUnmasked || vendorMasked;
@@ -32,10 +34,10 @@ export function getDeviceInfo(gl: WebGLRenderingContext): DeviceInfo {
   // const version = gl.getParameter(GL.SHADING_LANGUAGE_VERSION) as string;
   // const shadingLanguageVersion = parseGLSLVersion(version);
   const shadingLanguage = 'glsl';
-  const shadingLanguageVersion = isWebGL2(gl) ? 300 : 100
+  const shadingLanguageVersion = 300;
 
   return {
-    type: isWebGL2(gl) ? 'webgl2' : 'webgl',
+    type: 'webgl',
     gpu,
     gpuType,
     gpuBackend,
@@ -48,44 +50,50 @@ export function getDeviceInfo(gl: WebGLRenderingContext): DeviceInfo {
 }
 
 /** "Sniff" the GPU type from the info. This works best if unmasked info is available. */
-function identifyGPUVendor(vendor: string, renderer: string): 'nvidia' | 'intel' | 'apple' | 'amd' | 'software' | 'unknown' {
-  if ((/NVIDIA/i.exec(vendor)) || (/NVIDIA/i.exec(renderer))) {
+function identifyGPUVendor(
+  vendor: string,
+  renderer: string
+): 'nvidia' | 'intel' | 'apple' | 'amd' | 'software' | 'unknown' {
+  if (/NVIDIA/i.exec(vendor) || /NVIDIA/i.exec(renderer)) {
     return 'nvidia';
   }
-  if ((/INTEL/i.exec(vendor)) || (/INTEL/i.exec(renderer))) {
+  if (/INTEL/i.exec(vendor) || /INTEL/i.exec(renderer)) {
     return 'intel';
   }
-  if ((/Apple/i.exec(vendor)) || (/Apple/i.exec(renderer))) {
+  if (/Apple/i.exec(vendor) || /Apple/i.exec(renderer)) {
     return 'apple';
   }
   if (
-    (/AMD/i.exec(vendor)) ||
-    (/AMD/i.exec(renderer)) ||
-    (/ATI/i.exec(vendor)) ||
-    (/ATI/i.exec(renderer))
+    /AMD/i.exec(vendor) ||
+    /AMD/i.exec(renderer) ||
+    /ATI/i.exec(vendor) ||
+    /ATI/i.exec(renderer)
   ) {
     return 'amd';
   }
-  if ((/SwiftShader/i.exec(vendor)) || (/SwiftShader/i.exec(renderer))) {
+  if (/SwiftShader/i.exec(vendor) || /SwiftShader/i.exec(renderer)) {
     return 'software';
   }
-  
+
   return 'unknown';
 }
 
 /** "Sniff" the GPU backend from the info. This works best if unmasked info is available. */
 function identifyGPUBackend(vendor: string, renderer: string): 'opengl' | 'metal' | 'unknown' {
-  if ((/Metal/i.exec(vendor)) || (/Metal/i.exec(renderer))) {
+  if (/Metal/i.exec(vendor) || /Metal/i.exec(renderer)) {
     return 'metal';
   }
-  if ((/ANGLE/i.exec(vendor)) || (/ANGLE/i.exec(renderer))) {
+  if (/ANGLE/i.exec(vendor) || /ANGLE/i.exec(renderer)) {
     return 'opengl';
-  }  
+  }
   return 'unknown';
 }
 
-function identifyGPUType(vendor: string, renderer: string): 'discrete' | 'integrated' | 'cpu' | 'unknown' {
-  if ((/SwiftShader/i.exec(vendor)) || (/SwiftShader/i.exec(renderer))) {
+function identifyGPUType(
+  vendor: string,
+  renderer: string
+): 'discrete' | 'integrated' | 'cpu' | 'unknown' {
+  if (/SwiftShader/i.exec(vendor) || /SwiftShader/i.exec(renderer)) {
     return 'cpu';
   }
 

package/src/adapter/device-helpers/webgl-device-limits.ts

@@ -0,0 +1,53 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import {DeviceLimits} from '@luma.gl/core';
+import {GL} from '@luma.gl/constants';
+
+// prettier-ignore
+export class WebGLDeviceLimits extends DeviceLimits {
+  get maxTextureDimension1D() { return 0; } // WebGL does not support 1D textures
+  get maxTextureDimension2D() { return this.getParameter(GL.MAX_TEXTURE_SIZE); }
+  get maxTextureDimension3D() { return this.getParameter(GL.MAX_3D_TEXTURE_SIZE); }
+  get maxTextureArrayLayers() { return this.getParameter(GL.MAX_ARRAY_TEXTURE_LAYERS); }
+  get maxBindGroups() { return 0; }
+  get maxDynamicUniformBuffersPerPipelineLayout() { return 0; } // TBD
+  get maxDynamicStorageBuffersPerPipelineLayout() { return 0; } // TBD
+  get maxSampledTexturesPerShaderStage() { return this.getParameter(GL.MAX_VERTEX_TEXTURE_IMAGE_UNITS); } // ) TBD
+  get maxSamplersPerShaderStage() { return this.getParameter(GL.MAX_COMBINED_TEXTURE_IMAGE_UNITS); }
+  get maxStorageBuffersPerShaderStage() { return 0; } // TBD
+  get maxStorageTexturesPerShaderStage() { return 0; } // TBD
+  get maxUniformBuffersPerShaderStage() { return this.getParameter(GL.MAX_UNIFORM_BUFFER_BINDINGS); }
+  get maxUniformBufferBindingSize() { return this.getParameter(GL.MAX_UNIFORM_BLOCK_SIZE); }
+  get maxStorageBufferBindingSize() { return 0; }
+  get minUniformBufferOffsetAlignment() { return this.getParameter(GL.UNIFORM_BUFFER_OFFSET_ALIGNMENT); }
+  get minStorageBufferOffsetAlignment() { return 0; } 
+  get maxVertexBuffers() { return 16; } // WebGL 2 supports 16 buffers, see https://github.com/gpuweb/gpuweb/issues/4284
+  get maxVertexAttributes() { return this.getParameter(GL.MAX_VERTEX_ATTRIBS); }
+  get maxVertexBufferArrayStride() { return 2048; } // TBD, this is just the default value from WebGPU
+  get maxInterStageShaderComponents() { return this.getParameter(GL.MAX_VARYING_COMPONENTS); }
+  get maxComputeWorkgroupStorageSize() { return 0; } // WebGL does not support compute shaders
+  get maxComputeInvocationsPerWorkgroup() { return 0; } // WebGL does not support compute shaders
+  get maxComputeWorkgroupSizeX() { return 0; } // WebGL does not support compute shaders
+  get maxComputeWorkgroupSizeY() { return 0; } // WebGL does not support compute shaders
+  get maxComputeWorkgroupSizeZ() { return 0; } // WebGL does not support compute shaders
+  get maxComputeWorkgroupsPerDimension() { return 0;} // WebGL does not support compute shaders
+
+  // PRIVATE
+
+  protected gl: WebGL2RenderingContext;
+  protected limits: Partial<Record<GL, number>> = {};
+
+  constructor(gl: WebGL2RenderingContext) {
+    super();
+    this.gl = gl;
+  }
+
+  protected getParameter(parameter: GL): number {
+    if (this.limits[parameter] === undefined) {
+      this.limits[parameter] = this.gl.getParameter(parameter);
+    }
+    return this.limits[parameter];
+  }
+}

package/src/adapter/helpers/decode-webgl-types.ts

@@ -1,4 +1,5 @@
-// luma.gl, MIT license
+// luma.gl
+// SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
 import {ShaderUniformType, ShaderAttributeType, VertexFormat} from '@luma.gl/core';
@@ -67,9 +68,11 @@ const COMPOSITE_GL_TYPES: Record<
 };
 
 /** Decomposes a composite type (GL.VEC3) into a basic type (GL.FLOAT) and components (3) */
-export function decodeGLUniformType(
-  glUniformType: GL
-): {format: ShaderUniformType; components: number; glType: GLDataType} {
+export function decodeGLUniformType(glUniformType: GL): {
+  format: ShaderUniformType;
+  components: number;
+  glType: GLDataType;
+} {
   const typeAndSize = COMPOSITE_GL_TYPES[glUniformType];
   if (!typeAndSize) {
     throw new Error('uniform');
@@ -87,11 +90,11 @@ export function decodeGLAttributeType(glAttributeType: GL): {
 } {
   const typeAndSize = COMPOSITE_GL_TYPES[glAttributeType];
   if (!typeAndSize) {
-    throw new Error('attribute')
+    throw new Error('attribute');
   }
   const [, components, , shaderType, vertexFormat] = typeAndSize;
   // TODO sanity - if (shaderType.startsWith('mat' ...))
-  const attributeType = shaderType as unknown as ShaderAttributeType
+  const attributeType = shaderType as unknown as ShaderAttributeType;
   return {attributeType, vertexFormat, components}; // , glType};
 }
 
@@ -107,7 +110,10 @@ export function decomposeCompositeGLDataType(
   return {type, components};
 }
 
-export function getCompositeGLDataType(type: GL, components): {glType: GLDataType; name: string} | null {
+export function getCompositeGLDataType(
+  type: GL,
+  components
+): {glType: GLDataType; name: string} | null {
   switch (type) {
     case GL.BYTE:
     case GL.UNSIGNED_BYTE:

package/src/adapter/helpers/get-shader-layout.ts

@@ -1,4 +1,5 @@
-// luma.gl, MIT license
+// luma.gl
+// SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
 import type {
@@ -10,7 +11,6 @@ import type {
 } from '@luma.gl/core';
 
 import {GL} from '@luma.gl/constants';
-import {isWebGL2} from '../../context/context/webgl-checks';
 import {Accessor} from '../../classic/accessor'; // TODO - should NOT depend on classic API
 import {decodeGLUniformType, decodeGLAttributeType, isSamplerUniform} from './decode-webgl-types';
 
@@ -19,7 +19,7 @@ import {decodeGLUniformType, decodeGLAttributeType, isSamplerUniform} from './de
  * Note: `linkProgram()` needs to have been called
  * (although linking does not need to have been successful).
  */
-export function getShaderLayout(gl: WebGLRenderingContext, program: WebGLProgram): ShaderLayout {
+export function getShaderLayout(gl: WebGL2RenderingContext, program: WebGLProgram): ShaderLayout {
   const shaderLayout: ShaderLayout = {
     attributes: [],
     bindings: []
@@ -88,7 +88,7 @@ export function getShaderLayout(gl: WebGLRenderingContext, program: WebGLProgram
  * linkProgram needs to have been called, although linking does not need to have been successful
  */
 function readAttributeDeclarations(
-  gl: WebGLRenderingContext,
+  gl: WebGL2RenderingContext,
   program: WebGLProgram
 ): AttributeDeclaration[] {
   const attributes: AttributeDeclaration[] = [];
@@ -106,7 +106,7 @@ function readAttributeDeclarations(
     if (location >= 0) {
       const {attributeType} = decodeGLAttributeType(compositeType);
 
-      // Whether an attribute is instanced is essentially fixed by the structure of the shader code, 
+      // Whether an attribute is instanced is essentially fixed by the structure of the shader code,
       // so it is arguably a static property of the shader.
       // There is no hint in the shader declarations
       // Heuristic: Any attribute name containing the word "instance" will be assumed to be instanced
@@ -116,7 +116,7 @@ function readAttributeDeclarations(
         name,
         location,
         stepMode,
-        type: attributeType,
+        type: attributeType
         // size - for arrays, size is the number of elements in the array
       });
     }
@@ -132,17 +132,12 @@ function readAttributeDeclarations(
  *
  * linkProgram needs to have been called, although linking does not need to have been successful
  */
-function readVaryings(gl: WebGLRenderingContext, program: WebGLProgram): VaryingBinding[] {
-  if (!isWebGL2(gl)) {
-    return [];
-  }
-  const gl2 = gl as WebGL2RenderingContext;
-
+function readVaryings(gl: WebGL2RenderingContext, program: WebGLProgram): VaryingBinding[] {
   const varyings: VaryingBinding[] = [];
 
   const count = gl.getProgramParameter(program, GL.TRANSFORM_FEEDBACK_VARYINGS);
   for (let location = 0; location < count; location++) {
-    const activeInfo = gl2.getTransformFeedbackVarying(program, location);
+    const activeInfo = gl.getTransformFeedbackVarying(program, location);
     if (!activeInfo) {
       throw new Error('activeInfo');
     }
@@ -162,7 +157,7 @@ function readVaryings(gl: WebGLRenderingContext, program: WebGLProgram): Varying
  *
  * Query uniform locations and build name to setter map.
  */
-function readUniformBindings(gl: WebGLRenderingContext, program: WebGLProgram): UniformBinding[] {
+function readUniformBindings(gl: WebGL2RenderingContext, program: WebGLProgram): UniformBinding[] {
   const uniforms: UniformBinding[] = [];
 
   const uniformCount = gl.getProgramParameter(program, GL.ACTIVE_UNIFORMS);
@@ -209,23 +204,18 @@ function readUniformBindings(gl: WebGLRenderingContext, program: WebGLProgram):
  * @note In WebGL, "active" just means that unused (inactive) blocks may have been optimized away during linking)
  */
 function readUniformBlocks(
-  gl: WebGLRenderingContext,
+  gl: WebGL2RenderingContext,
   program: WebGLProgram
 ): UniformBlockBinding[] {
-  if (!isWebGL2(gl)) {
-    return [];
-  }
-  const gl2 = gl as WebGL2RenderingContext;
-
   const getBlockParameter = (blockIndex: number, pname: GL): any =>
-    gl2.getActiveUniformBlockParameter(program, blockIndex, pname);
+    gl.getActiveUniformBlockParameter(program, blockIndex, pname);
 
   const uniformBlocks: UniformBlockBinding[] = [];
 
-  const blockCount = gl2.getProgramParameter(program, GL.ACTIVE_UNIFORM_BLOCKS);
+  const blockCount = gl.getProgramParameter(program, GL.ACTIVE_UNIFORM_BLOCKS);
   for (let blockIndex = 0; blockIndex < blockCount; blockIndex++) {
     const blockInfo: UniformBlockBinding = {
-      name: gl2.getActiveUniformBlockName(program, blockIndex) || '',
+      name: gl.getActiveUniformBlockName(program, blockIndex) || '',
       location: getBlockParameter(blockIndex, GL.UNIFORM_BLOCK_BINDING),
       byteLength: getBlockParameter(blockIndex, GL.UNIFORM_BLOCK_DATA_SIZE),
       vertex: getBlockParameter(blockIndex, GL.UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER),
@@ -237,23 +227,23 @@ function readUniformBlocks(
     const uniformIndices =
       (getBlockParameter(blockIndex, GL.UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES) as number[]) || [];
 
-    const uniformType = gl2.getActiveUniforms(program, uniformIndices, GL.UNIFORM_TYPE); // Array of GLenum indicating the types of the uniforms.
-    const uniformArrayLength = gl2.getActiveUniforms(program, uniformIndices, GL.UNIFORM_SIZE); // Array of GLuint indicating the sizes of the uniforms.
-    // const uniformBlockIndex = gl2.getActiveUniforms(
+    const uniformType = gl.getActiveUniforms(program, uniformIndices, GL.UNIFORM_TYPE); // Array of GLenum indicating the types of the uniforms.
+    const uniformArrayLength = gl.getActiveUniforms(program, uniformIndices, GL.UNIFORM_SIZE); // Array of GLuint indicating the sizes of the uniforms.
+    // const uniformBlockIndex = gl.getActiveUniforms(
     //   program,
     //   uniformIndices,
     //   GL.UNIFORM_BLOCK_INDEX
     // ); // Array of GLint indicating the block indices of the uniforms.
-    const uniformOffset = gl2.getActiveUniforms(program, uniformIndices, GL.UNIFORM_OFFSET); // Array of GLint indicating the uniform buffer offsets.
-    const uniformStride = gl2.getActiveUniforms(program, uniformIndices, GL.UNIFORM_ARRAY_STRIDE); // Array of GLint indicating the strides between the elements.
-    // const uniformMatrixStride = gl2.getActiveUniforms(
+    const uniformOffset = gl.getActiveUniforms(program, uniformIndices, GL.UNIFORM_OFFSET); // Array of GLint indicating the uniform buffer offsets.
+    const uniformStride = gl.getActiveUniforms(program, uniformIndices, GL.UNIFORM_ARRAY_STRIDE); // Array of GLint indicating the strides between the elements.
+    // const uniformMatrixStride = gl.getActiveUniforms(
     //   program,
     //   uniformIndices,
     //   GL.UNIFORM_MATRIX_STRIDE
     // ); // Array of GLint indicating the strides between columns of a column-major matrix or a row-major matrix.
-    // const uniformRowMajor = gl2.getActiveUniforms(program, uniformIndices, GL.UNIFORM_IS_ROW_MAJOR);
+    // const uniformRowMajor = gl.getActiveUniforms(program, uniformIndices, GL.UNIFORM_IS_ROW_MAJOR);
     for (let i = 0; i < blockInfo.uniformCount; ++i) {
-      const activeInfo = gl2.getActiveUniform(program, uniformIndices[i]);
+      const activeInfo = gl.getActiveUniform(program, uniformIndices[i]);
       if (!activeInfo) {
         throw new Error('activeInfo');
       }

package/src/adapter/helpers/parse-shader-compiler-log.ts

@@ -1,4 +1,5 @@
-// luma.gl, MIT license
+// luma.gl
+// SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
 import type {CompilerMessage} from '@luma.gl/core';
@@ -8,7 +9,7 @@ import type {CompilerMessage} from '@luma.gl/core';
  * This follows documented WebGL conventions for compilation logs.
  * Based on https://github.com/wwwtyro/gl-format-compiler-error (public domain)
  */
-export function parseShaderCompilerLog(errLog: string) : readonly CompilerMessage[] {
+export function parseShaderCompilerLog(errLog: string): readonly CompilerMessage[] {
   // Parse the error - note: browser and driver dependent
   const lines = errLog.split(/\r?\n/);
 
@@ -30,7 +31,7 @@ export function parseShaderCompilerLog(errLog: string) : readonly CompilerMessag
         lineNum: 0,
         linePos: 0
       });
-      continue; // eslint-disable-line no-continue  
+      continue; // eslint-disable-line no-continue
     }
 
     const [messageType, linePosition, lineNumber, ...rest] = segments;
@@ -50,15 +51,18 @@ export function parseShaderCompilerLog(errLog: string) : readonly CompilerMessag
       type: getMessageType(messageType),
       lineNum,
       linePos // TODO
-    })
+    });
   }
 
   return messages;
 }
 
 /** Ensure supported type */
-function getMessageType(messageType: string): 'warning' | 'error' | 'info' {    
+function getMessageType(messageType: string): 'warning' | 'error' | 'info' {
   const MESSAGE_TYPES = ['warning', 'error', 'info'];
   const lowerCaseType = messageType.toLowerCase();
-  return (MESSAGE_TYPES.includes(lowerCaseType) ? lowerCaseType : 'info') as 'warning' | 'error' | 'info';
+  return (MESSAGE_TYPES.includes(lowerCaseType) ? lowerCaseType : 'info') as
+    | 'warning'
+    | 'error'
+    | 'info';
 }

package/src/adapter/helpers/set-uniform.ts

@@ -1,4 +1,5 @@
-// luma.gl, MIT license
+// luma.gl
+// SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
 /* eslint-disable */
@@ -10,7 +11,7 @@ import {GL, GLCompositeType, GLSamplerType} from '@luma.gl/constants';
 /** Set a raw uniform (without type conversion and caching) */
 /* eslint-disable max-len */
 export function setUniform(
-  gl: WebGLRenderingContext,
+  gl: WebGL2RenderingContext,
   location: WebGLUniformLocation,
   type: GLCompositeType | GLSamplerType,
   value: UniformValue
@@ -29,10 +30,8 @@ export function setUniform(
 
   // prettier-ignore
   switch (type) {
-    // WebGL1 samplers
     case GL.SAMPLER_2D:
     case GL.SAMPLER_CUBE:
-    // WebGL2 samplers
     case GL.SAMPLER_3D:
     case GL.SAMPLER_2D_SHADOW:
     case GL.SAMPLER_2D_ARRAY:

package/src/adapter/helpers/webgl-topology-utils.ts

@@ -1,4 +1,5 @@
-// luma.gl, MIT license
+// luma.gl
+// SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
 import {GL, GLPrimitiveTopology, GLPrimitive} from '@luma.gl/constants';
@@ -27,7 +28,10 @@ export function getPrimitiveDrawMode(drawMode: GLPrimitiveTopology): GLPrimitive
 }
 
 // Counts the number of complete "primitives" given a number of vertices and a drawMode
-export function getPrimitiveCount(options: {drawMode: GLPrimitiveTopology, vertexCount: number}): number {
+export function getPrimitiveCount(options: {
+  drawMode: GLPrimitiveTopology;
+  vertexCount: number;
+}): number {
   const {drawMode, vertexCount} = options;
   switch (drawMode) {
     case GL.POINTS:
@@ -48,7 +52,10 @@ export function getPrimitiveCount(options: {drawMode: GLPrimitiveTopology, verte
 }
 
 // Counts the number of vertices after splitting the vertex stream into separate "primitives"
-export function getVertexCount(options: {drawMode: GLPrimitiveTopology, vertexCount: number}): number {
+export function getVertexCount(options: {
+  drawMode: GLPrimitiveTopology;
+  vertexCount: number;
+}): number {
   const {drawMode, vertexCount} = options;
   const primitiveCount = getPrimitiveCount({drawMode, vertexCount});
   switch (getPrimitiveDrawMode(drawMode)) {

package/src/adapter/objects/constants-to-keys.ts

@@ -1,11 +1,12 @@
-// luma.gl, MIT license
+// luma.gl
+// SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
 import {assert} from '@luma.gl/core';
 import {GL} from '@luma.gl/constants';
 
 // Resolve a WebGL enumeration name (returns itself if already a number)
-export function getKeyValue(gl: WebGLRenderingContext, name: string | GL): GL {
+export function getKeyValue(gl: WebGL2RenderingContext, name: string | GL): GL {
   // If not a string, return (assume number)
   if (typeof name !== 'string') {
     return name;