@luma.gl/webgl 9.0.0-beta.5 → 9.0.0-beta.7

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

@@ -1,18 +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 {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: WebGL2RenderingContext): 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;
@@ -47,44 +50,50 @@ export function getDeviceInfo(gl: WebGL2RenderingContext): 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

@@ -1,157 +1,53 @@
-// luma.gl, MIT license
+// luma.gl
+// SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
-import type {DeviceLimits} from '@luma.gl/core';
+import {DeviceLimits} from '@luma.gl/core';
 import {GL} from '@luma.gl/constants';
 
-/** Populate a WebGPU style device limits */
-export function getDeviceLimits(gl: WebGL2RenderingContext): DeviceLimits {
-  return {
-    maxTextureDimension1D: 0, // WebGL does not support 1D textures
-    maxTextureDimension2D: gl.getParameter(GL.MAX_TEXTURE_SIZE),
-    maxTextureDimension3D: gl.getParameter(GL.MAX_3D_TEXTURE_SIZE),
-    maxTextureArrayLayers: gl.getParameter(GL.MAX_ARRAY_TEXTURE_LAYERS),
-    maxBindGroups: 1, // TBD - if we emulate bind groups we could support any number...
-    maxDynamicUniformBuffersPerPipelineLayout: 0, // TBD
-    maxDynamicStorageBuffersPerPipelineLayout: 0, // TBD
-    maxSampledTexturesPerShaderStage: gl.getParameter(GL.MAX_VERTEX_TEXTURE_IMAGE_UNITS), // TBD
-    maxSamplersPerShaderStage: gl.getParameter(GL.MAX_COMBINED_TEXTURE_IMAGE_UNITS),
-    maxStorageBuffersPerShaderStage: 0, // TBD
-    maxStorageTexturesPerShaderStage: 0, // TBD
-    maxUniformBuffersPerShaderStage: gl.getParameter(GL.MAX_UNIFORM_BUFFER_BINDINGS),
-    maxUniformBufferBindingSize: gl.getParameter(GL.MAX_UNIFORM_BLOCK_SIZE),
-    maxStorageBufferBindingSize: 0,
-    minUniformBufferOffsetAlignment: gl.getParameter(GL.UNIFORM_BUFFER_OFFSET_ALIGNMENT),
-    minStorageBufferOffsetAlignment: 0, // TBD
-    maxVertexBuffers: 0,
-    maxVertexAttributes: gl.getParameter(GL.MAX_VERTEX_ATTRIBS),
-    maxVertexBufferArrayStride: 2048, // TBD, this is just the default value from WebGPU
-    maxInterStageShaderComponents: gl.getParameter(GL.MAX_VARYING_COMPONENTS),
-    maxComputeWorkgroupStorageSize: 0, // WebGL does not support compute shaders
-    maxComputeInvocationsPerWorkgroup: 0, // WebGL does not support compute shaders
-    maxComputeWorkgroupSizeX: 0, // WebGL does not support compute shaders
-    maxComputeWorkgroupSizeY: 0, // WebGL does not support compute shaders
-    maxComputeWorkgroupSizeZ: 0, // WebGL does not support compute shaders
-    maxComputeWorkgroupsPerDimension: 0 // WebGL does not support compute shaders
-  };
-}
-
-/** WebGL context limits */
-export type WebGLLimits = {
-  [GL.ALIASED_LINE_WIDTH_RANGE]: [number, number];
-  [GL.ALIASED_POINT_SIZE_RANGE]: [number, number];
-  [GL.MAX_TEXTURE_SIZE]: number;
-  [GL.MAX_CUBE_MAP_TEXTURE_SIZE]: number;
-  [GL.MAX_TEXTURE_IMAGE_UNITS]: number;
-  [GL.MAX_COMBINED_TEXTURE_IMAGE_UNITS]: number;
-  [GL.MAX_VERTEX_TEXTURE_IMAGE_UNITS]: number;
-  [GL.MAX_RENDERBUFFER_SIZE]: number;
-  [GL.MAX_VARYING_VECTORS]: number;
-  [GL.MAX_VERTEX_ATTRIBS]: number;
-  [GL.MAX_VERTEX_UNIFORM_VECTORS]: number;
-  [GL.MAX_FRAGMENT_UNIFORM_VECTORS]: number;
-  [GL.MAX_VIEWPORT_DIMS]: [number, number];
-
-  // Extensions
-  [GL.MAX_TEXTURE_MAX_ANISOTROPY_EXT]: number;
-
-  // WebGL2 Limits
-  [GL.MAX_3D_TEXTURE_SIZE]: number;
-  [GL.MAX_ARRAY_TEXTURE_LAYERS]: number;
-  // [GL.MAX_CLIENT_WAIT_TIMEOUT_WEBGL]: number;
-  [GL.MAX_COLOR_ATTACHMENTS]: number;
-  [GL.MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS]: number;
-  [GL.MAX_COMBINED_UNIFORM_BLOCKS]: number;
-  [GL.MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS]: number;
-  [GL.MAX_DRAW_BUFFERS]: number;
-  [GL.MAX_ELEMENT_INDEX]: number;
-  [GL.MAX_ELEMENTS_INDICES]: number;
-  [GL.MAX_ELEMENTS_VERTICES]: number;
-  [GL.MAX_FRAGMENT_INPUT_COMPONENTS]: number;
-  [GL.MAX_FRAGMENT_UNIFORM_BLOCKS]: number;
-  [GL.MAX_FRAGMENT_UNIFORM_COMPONENTS]: number;
-  [GL.MAX_SAMPLES]: number;
-  // [GL.MAX_SERVER_WAIT_TIMEOUT]: number;
-  [GL.MAX_TEXTURE_LOD_BIAS]: number;
-  [GL.MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS]: number;
-  [GL.MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS]: number;
-  [GL.MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS]: number;
-  [GL.MAX_UNIFORM_BLOCK_SIZE]: number;
-  [GL.MAX_UNIFORM_BUFFER_BINDINGS]: number;
-  [GL.MAX_VARYING_COMPONENTS]: number;
-  [GL.MAX_VERTEX_OUTPUT_COMPONENTS]: number;
-  [GL.MAX_VERTEX_UNIFORM_BLOCKS]: number;
-  [GL.MAX_VERTEX_UNIFORM_COMPONENTS]: number;
-  [GL.MIN_PROGRAM_TEXEL_OFFSET]: number;
-  [GL.MAX_PROGRAM_TEXEL_OFFSET]: number;
-  [GL.UNIFORM_BUFFER_OFFSET_ALIGNMENT]: number;
-};
-
-export function getWebGLLimits(gl: WebGL2RenderingContext): WebGLLimits {
-  function get<T = number>(pname: number): T {
-    return gl.getParameter(pname) as T;
-  }
-  function get2(pname: number, defaultValue?: number): number;
-  function get2<T>(pname: number, defaultValue: T): T;
-  function get2<T>(pname: number, defaultValue: T): T {
-    return (gl.getParameter(pname) as T) || defaultValue;
+// 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;
   }
-  // function getMaxAnistropy() {
-  //   const extension = gl.getExtension('EXT_texture_filter_anisotropic');
-  // }
-  return {
-    [GL.ALIASED_LINE_WIDTH_RANGE]: get(GL.ALIASED_LINE_WIDTH_RANGE),
-    [GL.ALIASED_POINT_SIZE_RANGE]: get(GL.ALIASED_POINT_SIZE_RANGE),
-    [GL.MAX_TEXTURE_SIZE]: get(GL.MAX_TEXTURE_SIZE),
-    [GL.MAX_CUBE_MAP_TEXTURE_SIZE]: get(GL.MAX_CUBE_MAP_TEXTURE_SIZE), // GLint
-    [GL.MAX_TEXTURE_IMAGE_UNITS]: get(GL.MAX_TEXTURE_IMAGE_UNITS), // GLint
-    [GL.MAX_COMBINED_TEXTURE_IMAGE_UNITS]: get(GL.MAX_COMBINED_TEXTURE_IMAGE_UNITS), // GLint
-    [GL.MAX_VERTEX_TEXTURE_IMAGE_UNITS]: get(GL.MAX_VERTEX_TEXTURE_IMAGE_UNITS), // GLint
-    [GL.MAX_RENDERBUFFER_SIZE]: get(GL.MAX_RENDERBUFFER_SIZE), // GLint
-    [GL.MAX_VARYING_VECTORS]: get(GL.MAX_VARYING_VECTORS), // GLint
-    [GL.MAX_VERTEX_ATTRIBS]: get(GL.MAX_VERTEX_ATTRIBS), // GLint
-    [GL.MAX_VERTEX_UNIFORM_VECTORS]: get(GL.MAX_VERTEX_UNIFORM_VECTORS), // GLint
-    [GL.MAX_FRAGMENT_UNIFORM_VECTORS]: get(GL.MAX_FRAGMENT_UNIFORM_VECTORS), // GLint
-    [GL.MAX_VIEWPORT_DIMS]: get(GL.MAX_VIEWPORT_DIMS),
 
-    // Extensions
-    [GL.MAX_TEXTURE_MAX_ANISOTROPY_EXT]: get(GL.MAX_TEXTURE_MAX_ANISOTROPY_EXT), // getMaxAnistropy(),
-
-    // WebGL2 Limits
-    [GL.MAX_3D_TEXTURE_SIZE]: get2(GL.MAX_3D_TEXTURE_SIZE), //  GLint
-    [GL.MAX_ARRAY_TEXTURE_LAYERS]: get2(GL.MAX_ARRAY_TEXTURE_LAYERS), // GLint
-    // [GL.MAX_CLIENT_WAIT_TIMEOUT_WEBGL]: get2(GL.MAX_CLIENT_WAIT_TIMEOUT_WEBGL), //  GLint64
-    [GL.MAX_COLOR_ATTACHMENTS]: get2(GL.MAX_COLOR_ATTACHMENTS), //  GLint
-    [GL.MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS]: get2(
-      GL.MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS
-    ), // GLint64
-    [GL.MAX_COMBINED_UNIFORM_BLOCKS]: get2(GL.MAX_COMBINED_UNIFORM_BLOCKS), //  GLint
-    [GL.MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS]: get2(GL.MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS), // GLint64
-    [GL.MAX_DRAW_BUFFERS]: get2(GL.MAX_DRAW_BUFFERS), // GLint
-    [GL.MAX_ELEMENT_INDEX]: get2(GL.MAX_ELEMENT_INDEX), //  GLint64
-    [GL.MAX_ELEMENTS_INDICES]: get2(GL.MAX_ELEMENTS_INDICES), // GLint
-    [GL.MAX_ELEMENTS_VERTICES]: get2(GL.MAX_ELEMENTS_VERTICES), //  GLint
-    [GL.MAX_FRAGMENT_INPUT_COMPONENTS]: get2(GL.MAX_FRAGMENT_INPUT_COMPONENTS), //  GLint
-    [GL.MAX_FRAGMENT_UNIFORM_BLOCKS]: get2(GL.MAX_FRAGMENT_UNIFORM_BLOCKS), //  GLint
-    [GL.MAX_FRAGMENT_UNIFORM_COMPONENTS]: get2(GL.MAX_FRAGMENT_UNIFORM_COMPONENTS), //  GLint
-    [GL.MAX_SAMPLES]: get2(GL.MAX_SAMPLES), //  GLint
-    // [GL.MAX_SERVER_WAIT_TIMEOUT]: get2(GL.MAX_SERVER_WAIT_TIMEOUT), //  GLint64
-    [GL.MAX_TEXTURE_LOD_BIAS]: get2(GL.MAX_TEXTURE_LOD_BIAS), // GLfloat
-    [GL.MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS]: get2(
-      GL.MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS
-    ), //  GLint
-    [GL.MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS]: get2(GL.MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS), //  GLint
-    [GL.MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS]: get2(
-      GL.MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS
-    ), // GLint
-    [GL.MAX_UNIFORM_BLOCK_SIZE]: get2(GL.MAX_UNIFORM_BLOCK_SIZE), // GLint64
-    [GL.MAX_UNIFORM_BUFFER_BINDINGS]: get2(GL.MAX_UNIFORM_BUFFER_BINDINGS), //  GLint
-    [GL.MAX_VARYING_COMPONENTS]: get2(GL.MAX_VARYING_COMPONENTS), // GLint
-    [GL.MAX_VERTEX_OUTPUT_COMPONENTS]: get2(GL.MAX_VERTEX_OUTPUT_COMPONENTS), // GLint
-    [GL.MAX_VERTEX_UNIFORM_BLOCKS]: get2(GL.MAX_VERTEX_UNIFORM_BLOCKS), //  GLint
-    [GL.MAX_VERTEX_UNIFORM_COMPONENTS]: get2(GL.MAX_VERTEX_UNIFORM_COMPONENTS), //  GLint
-    [GL.MIN_PROGRAM_TEXEL_OFFSET]: get2(GL.MIN_PROGRAM_TEXEL_OFFSET), // GLint
-    [GL.MAX_PROGRAM_TEXEL_OFFSET]: get2(GL.MAX_PROGRAM_TEXEL_OFFSET), // GLint
-    [GL.UNIFORM_BUFFER_OFFSET_ALIGNMENT]: get2(GL.UNIFORM_BUFFER_OFFSET_ALIGNMENT) // GLint
-  };
+  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 {
@@ -105,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
@@ -115,7 +116,7 @@ function readAttributeDeclarations(
         name,
         location,
         stepMode,
-        type: attributeType,
+        type: attributeType
         // size - for arrays, size is the number of elements in the array
       });
     }

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 */

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,4 +1,5 @@
-// luma.gl, MIT license
+// luma.gl
+// SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
 import {assert} from '@luma.gl/core';

package/src/adapter/objects/webgl-renderbuffer.ts

@@ -1,4 +1,5 @@
-// luma.gl, MIT license
+// luma.gl
+// SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
 import {assert, ResourceProps, TextureFormat} from '@luma.gl/core';
@@ -6,7 +7,10 @@ import {GL} from '@luma.gl/constants';
 import {WebGLDevice} from '../webgl-device';
 import {WebGLResource} from './webgl-resource';
 import {isRenderbufferFormatSupported} from '../converters/texture-formats';
-import {convertTextureFormatToGL, getTextureFormatBytesPerPixel} from '../converters/texture-formats';
+import {
+  convertTextureFormatToGL,
+  getTextureFormatBytesPerPixel
+} from '../converters/texture-formats';
 
 export type RenderbufferProps = ResourceProps & {
   format: TextureFormat;
@@ -32,23 +36,35 @@ export class WEBGLRenderbuffer extends WebGLResource<RenderbufferProps> {
     userData: undefined,
     format: undefined, // 'depth16unorm'
     width: 1,
-    height: 1, 
+    height: 1,
     samples: 0
-  };  
+  };
 
-  override get [Symbol.toStringTag](): string { return 'Renderbuffer'; }
+  override get [Symbol.toStringTag](): string {
+    return 'Renderbuffer';
+  }
 
-  get width(): number { return this.props.width; }
-  get height(): number { return this.props.height; }
-  get format(): TextureFormat { return this.props.format; }
-  get samples(): number { return this.props.samples; }
-  get attachment() { return  }
+  get width(): number {
+    return this.props.width;
+  }
+  get height(): number {
+    return this.props.height;
+  }
+  get format(): TextureFormat {
+    return this.props.format;
+  }
+  get samples(): number {
+    return this.props.samples;
+  }
+  get attachment() {
+    return;
+  }
 
   /** WebGL format constant */
   glFormat: GL;
 
   static isTextureFormatSupported(device: WebGLDevice, format: TextureFormat): boolean {
-    return isRenderbufferFormatSupported(device.gl, format);
+    return isRenderbufferFormatSupported(device.gl, format, device._extensions);
   }
 
   constructor(device: WebGLDevice, props: RenderbufferProps) {
@@ -61,7 +77,7 @@ export class WEBGLRenderbuffer extends WebGLResource<RenderbufferProps> {
     this._initialize(this.props);
   }
 
-  resize(size: {width: number, height: number}): void {
+  resize(size: {width: number; height: number}): void {
     // Don't resize if width/height haven't changed
     if (size.width !== this.width || size.height !== this.height) {
       Object.assign(this.props, {...size, format: this.format, samples: this.samples});
@@ -81,7 +97,13 @@ export class WEBGLRenderbuffer extends WebGLResource<RenderbufferProps> {
     this.gl.bindRenderbuffer(GL.RENDERBUFFER, this.handle);
 
     if (samples !== 0) {
-      this.gl.renderbufferStorageMultisample(GL.RENDERBUFFER, samples, this.glFormat, width, height);
+      this.gl.renderbufferStorageMultisample(
+        GL.RENDERBUFFER,
+        samples,
+        this.glFormat,
+        width,
+        height
+      );
     } else {
       this.gl.renderbufferStorage(GL.RENDERBUFFER, this.glFormat, width, height);
     }
@@ -89,7 +111,7 @@ export class WEBGLRenderbuffer extends WebGLResource<RenderbufferProps> {
     this.gl.bindRenderbuffer(GL.RENDERBUFFER, null);
 
     this.trackAllocatedMemory(
-      width * height * (samples || 1) * getTextureFormatBytesPerPixel(this.glFormat)
+      width * height * (samples || 1) * getTextureFormatBytesPerPixel(this.format)
     );
   }