@luma.gl/webgl 8.5.10 → 8.6.0-alpha.4

package/src/adapter/converters/webgpu-texture-formats.ts

@@ -0,0 +1,167 @@
+import GL from '@luma.gl/constants';
+
+// Define local extension strings to optimize minification
+const SRGB = 'EXT_sRGB';
+const EXT_FLOAT_WEBGL1 = 'WEBGL.color_buffer_float';
+const EXT_FLOAT_WEBGL2 = 'EXT_color_buffer_float';
+const EXT_HALF_FLOAT_WEBGL1 = 'EXT_color_buffer_half_float';
+
+// const S3TC = 'WEBGL_compressed_texture_s3tc';
+// const PVRTC = 'WEBGL_compressed_texture_pvrtc';
+// const ES3 = 'WEBGL_compressed_texture_es3';
+// const ETC1 = 'WEBGL_compressed_texture_etc1';
+// const SRGB = 'EXT_sRGB';
+// const DEPTH = 'WEBGL_depth_texture';
+
+// NOTES:
+// - gl2: format requires WebGL2, when using a WebGL 1 context, color renderbuffer formats are limited
+// - b (bytes per pixel), for memory usage calculations.
+// - c (channels)
+// - p (packed)
+
+export const TEXTURE_FORMAT_DEFINITIONS = {
+  // 8-bit formats
+  'r8unorm': {b: 1, c: 1, gl: GL.R8, gl2: true},
+  'r8snorm': {b: 1, c: 1},
+  'r8uint': {b: 1, c: 1, gl: GL.R8UI, gl2: true},
+  'r8sint': {b: 1, c: 1, gl: GL.R8I, gl2: true},
+
+  // 16-bit formats
+  'r16uint': {b: 2, c: 1, gl: GL.R16UI, gl2: true},
+  'r16sint': {b: 2, c: 1, gl: GL.R16I, gl2: true},
+  'r16float': {b: 2, c: 1, gl: GL.R16F, gl2: EXT_FLOAT_WEBGL2},
+  'rg8unorm': {b: 2, c: 2, gl: GL.RG8, gl2: true},
+  'rg8snorm': {b: 2, c: 2},
+  'rg8uint': {b: 2, c: 2, gl: GL.RG8UI, gl2: true},
+  'rg8sint': {b: 2, c: 2, gl: GL.RG8I, gl2: true},
+
+  // Packed 16-bit formats
+  // 'rgba4norm?': {b: 2, c: 4, gl: GL.RGBA4, wgpu: false},
+  // 'rgb565norm?': {b: 2, c: 4, gl: GL.RGB565, wgpu: false},
+  // 'rgb5a1norm?': {b: 2, c: 4, gl: GL.RGB5_A1, wgpu: false},
+
+  // 24-bit formats
+  // 'rbg8norm?': {b: 3, c: 3, gl: GL.RGB8, gl2: true, wgpu: false},
+
+  // 32-bit formats
+  'r32uint': {b: 4, c: 1, gl: GL.R32UI, gl2: true, bpp: 4},
+  'r32sint': {b: 4, c: 1, gl: GL.R32I, gl2: true, bpp: 4},
+  'r32float': {b: 4, c: 1, gl: GL.R32F, gl2: EXT_FLOAT_WEBGL2, bpp: 4},
+  'rg16uint': {b: 4, c: 1, gl: GL.RG16UI, gl2: true, bpp: 4},
+  'rg16sint': {b: 4, c: 2, gl: GL.RG16I, gl2: true, bpp: 4},
+  // When using a WebGL 2 context and the EXT_color_buffer_float WebGL2 extension
+  'rg16float': {b: 4, c: 2, gl: GL.RG16F, gl2: EXT_FLOAT_WEBGL2, bpp: 4},
+  'rgba8unorm': {b: 4, c: 2, gl: GL.RGBA8, gl2: true, bpp: 4},
+
+  'rgba8unorm-srgb': {b: 4, c: 4, gl: GL.SRGB8_ALPHA8, gl2: true, gl1: SRGB, bpp: 4},
+  'rgba8snorm': {b: 4, c: 4},
+  'rgba8uint': {b: 4, c: 4, gl: GL.RGBA8UI, gl2: true, bpp: 4},
+  'rgba8sint': {b: 4, c: 4, gl: GL.RGBA8I, gl2: true, bpp: 4},
+  'bgra8unorm': {b: 4, c: 4},
+  'bgra8unorm-srgb': {b: 4, c: 4},
+
+  // Packed 32-bit formats
+  'rgb9e5ufloat': {b: 4, c: 3, p: 1, gl: GL.RGB9_E5, gl2: true, gl1: 'WEBGL_color_buffer_half_float'},
+  'rg11b10ufloat': {b: 4, c: 3, p: 1, gl: GL.R11F_G11F_B10F, gl2: EXT_FLOAT_WEBGL2},
+  'rgb10a2unorm': {b: 4, c: 4, p: 1, gl: GL.RGB10_A2, gl2: true},
+  // webgl2 only
+  // '?rgb10a2unorm?': {b: 4, c: 4, p: 1, webgpu: false, gl: GL.RGB10_A2UI, gl2: true, bpp: 4},
+
+  // 64-bit formats
+  'rg32uint': {b: 8, c: 2, gl: GL.RG32UI, gl2: true},
+  'rg32sint': {b: 8, c: 2, gl: GL.RG32I, gl2: true},
+  'rg32float': {b: 8, c: 2, gl: GL.RG32F, gl2: EXT_FLOAT_WEBGL2},
+  'rgba16uint': {b: 8, c: 4, gl: GL.RGBA16UI, gl2: true},
+  'rgba16sint': {b: 8, c: 4, gl: GL.RGBA16I, gl2: true},
+  'rgba16float': {b: 8, c: 4, gl: GL.RGBA16F, gl2: EXT_FLOAT_WEBGL2},
+
+  // 96-bit formats
+  // {gl: GL.RGB32F, dataFormat: GL.RGB, types: [GL.FLOAT], gl2: true},
+
+  // 128-bit formats
+  'rgba32uint': {b: 16, c: 4, gl: GL.RGBA32UI, gl2: true},
+  'rgba32sint': {b: 16, c: 4, gl: GL.RGBA32I, gl2: true},
+  'rgba32float': {b: 16, c: 4, gl: GL.RGBA32F, gl2: EXT_FLOAT_WEBGL2}, // gl1: EXT_FLOAT_WEBGL1
+
+  // Depth and stencil formats
+  'stencil8': {b: 1, c: 1, gl: GL.STENCIL_INDEX8}, // 8 stencil bits
+  'depth16unorm': {b: 2, c: 1, gl: GL.DEPTH_COMPONENT16}, // 16 depth bits
+  'depth24plus': {b: 3, c: 1, gl: GL.DEPTH_COMPONENT24, gl2: true},
+  'depth24plus-stencil8': {b: 4, c: 2, p: 1, gl: GL.DEPTH24_STENCIL8, gl2: true},
+  'depth32float': {b: 4, c: 1, gl: GL.DEPTH_COMPONENT32F, gl2: true},
+
+  // "depth24unorm-stencil8" feature
+  'depth24unorm-stencil8': {b: 4, c: 2, p: 1, gl: GL.DEPTH_STENCIL},
+
+  // "depth32float-stencil8" feature
+  "depth32float-stencil8": {b: 5, c: 2, p: 1, gl: GL.DEPTH32F_STENCIL8, gl2: true},
+
+  // BC compressed formats usable if "texture-compression-bc" is both
+  // supported by the device/user agent and enabled in requestDevice.
+  'bc1-rgba-unorm': {},
+  'bc1-rgba-unorm-srgb': {},
+  'bc2-rgba-unorm': {},
+  'bc2-rgba-unorm-srgb': {},
+  'bc3-rgba-unorm': {},
+  'bc3-rgba-unorm-srgb': {},
+  'bc4-r-unorm': {},
+  'bc4-r-snorm': {},
+  'bc5-rg-unorm': {},
+  'bc5-rg-snorm': {},
+  'bc6h-rgb-ufloat': {},
+  'bc6h-rgb-float': {},
+  'bc7-rgba-unorm': {},
+  'bc7-rgba-unorm-srgb': {}
+};
+
+////////////////////////////////////////////////////
+// Compressed formats
+
+// WEBGL_compressed_texture_s3tc
+
+// {gl: GL.COMPRESSED_RGB_S3TC_DXT1_EXT, compressed: true, gl1: S3TC},
+// {gl: GL.COMPRESSED_RGBA_S3TC_DXT1_EXT, compressed: true, gl1: S3TC},
+// {gl: GL.COMPRESSED_RGBA_S3TC_DXT3_EXT, compressed: true, gl1: S3TC},
+// {gl: GL.COMPRESSED_RGBA_S3TC_DXT5_EXT, compressed: true, gl1: S3TC},
+
+// WEBGL_compressed_texture_es3
+
+// {gl: GL.COMPRESSED_R11_EAC, compressed: true, gl1: ES3}, // RED
+// {gl: GL.COMPRESSED_SIGNED_R11_EAC, compressed: true, gl1: ES3}, // RED
+// {gl: GL.COMPRESSED_RG11_EAC, compressed: true, gl1: ES3}, // RG
+// {gl: GL.COMPRESSED_SIGNED_RG11_EAC, compressed: true, gl1: ES3}, // RG
+// {gl: GL.COMPRESSED_RGB8_ETC2, compressed: true, gl1: ES3}, // RGB
+// {gl: GL.COMPRESSED_RGBA8_ETC2_EAC, compressed: true, gl1: ES3}, // RBG
+// {gl: GL.COMPRESSED_SRGB8_ETC2, compressed: true, gl1: ES3}, // RGB
+// {gl: GL.COMPRESSED_SRGB8_ALPHA8_ETC2_EAC, compressed: true, gl1: ES3}, // RGBA
+// {gl: GL.COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2, compressed: true, gl1: ES3}, // RGBA
+// {gl: GL.COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2, compressed: true, gl1: ES3}, // RGBA
+/* WebGL2 guaranteed availability compressed formats?
+COMPRESSED_R11_EAC RED
+COMPRESSED_SIGNED_R11_EAC RED
+COMPRESSED_RG11_EAC RG
+COMPRESSED_SIGNED_RG11_EAC RG
+COMPRESSED_RGB8_ETC2 RGB
+COMPRESSED_SRGB8_ETC2 RGB
+COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2 RGBA
+COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2 RGBA
+COMPRESSED_RGBA8_ETC2_EAC RGBA
+COMPRESSED_SRGB8_ALPHA8_ETC2_EAC
+*/
+
+// WEBGL_compressed_texture_pvrtc
+
+// {gl: GL.COMPRESSED_RGB_PVRTC_4BPPV1_IMG, compressed: true, gl1: PVRTC},
+// {gl: GL.COMPRESSED_RGBA_PVRTC_4BPPV1_IMG, compressed: true, gl1: PVRTC},
+// {gl: GL.COMPRESSED_RGB_PVRTC_2BPPV1_IMG, compressed: true, gl1: PVRTC},
+// {gl: GL.COMPRESSED_RGBA_PVRTC_2BPPV1_IMG, compressed: true, gl1: PVRTC},
+
+// WEBGL_compressed_texture_etc1
+
+// {gl: GL.COMPRESSED_RGB_ETC1_WEBGL, compressed: true, gl1: ETC1},
+
+// WEBGL_compressed_texture_atc
+
+// {gl: GL.COMPRESSED_RGB_ATC_WEBGL, compressed: true, gl1: ETC1},
+// {gl: GL.COMPRESSED_RGBA_ATC_EXPLICIT_ALPHA_WEBGL, compressed: true, gl1: ETC1},
+// {gl: GL.COMPRESSED_RGBA_ATC_INTERPOLATED_ALPHA_WEBGL, compressed: true, gl1: ETC1}

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

@@ -0,0 +1,227 @@
+// Feature detection for WebGL
+// Provides a function that enables simple checking of which WebGL features are
+// available in an WebGL1 or WebGL2 environment.
+
+import GL from '@luma.gl/constants';
+import {isWebGL2} from '../../context/context/webgl-checks';
+import {isOldIE} from './is-old-ie';
+
+export type DeviceFeature =
+  'depth-clamping' |
+  'depth24unorm-stencil8' |
+  'depth32float-stencil8' |
+  'pipeline-statistics-query' |
+  'timestamp-query' |
+  'texture-compression-bc';
+
+// TODO - this should be the default export, test cases need updating
+export type WebGLFeature =
+  'webgl2' |
+
+  // api support (unify with WebGPU timestamp-query?)
+  'webgl-timer-query' |
+
+  // api support
+  'webgl-vertex-array-object' |
+  'webgl-instanced-rendering' |
+  'webgl-multiple-render-targets' |
+
+  // features
+  'webgl-element-index-uint32' |
+
+  // blending
+  'webgl-blend-equation-minmax' |
+  'webgl-float-blend' |
+
+  // textures | renderbuffers
+  'webgl-color-encoding-srgb' |
+
+  // textures
+  'webgl-texture-depth' |
+  'webgl-texture-float' |
+  'webgl-texture-half-float' |
+
+  'webgl-texture-filter-linear-float' |
+  'webgl-texture-filter-linear-half-float' |
+  'webgl-texture-filter-anisotropic' |
+
+  // framebuffers | textures and renderbuffers
+  'webgl-color-attachment-rgba32f' |
+  'webgl-color-attachment-float' |
+  'webgl-color-attachment-half-float' |
+
+  // glsl extensions
+  'glsl-frag-data' |
+  'glsl-frag-depth' |
+  'glsl-derivatives' |
+  'glsl-texture-lod';
+
+/** Valid feature strings */
+export type Feature = DeviceFeature | WebGLFeature;
+
+/** Get WebGPU style feature strings */
+export function getDeviceFeatures(gl: WebGLRenderingContext): Set<DeviceFeature | WebGLFeature> {
+  const features = getWebGLFeatures(gl);
+  // features.add('depth-clamping'); // GPUPrimitiveState.clampDepth
+  // features.add('depth24unorm-stencil8'); // GPUTextureFormat 'depth24unorm-stencil8'.
+  // features.add('depth32float-stencil8'); // GPUTextureFormat 'depth32float-stencil8'.
+  // features.add('pipeline-statistics-query'); // GPUQueryType "pipeline-statistics"
+  // features.add('timestamp-query'); // GPUQueryType "timestamp-query"
+  // TODO
+  // features.add('texture-compression-bc'); //  GPUQueryType "timestamp"
+  // TODO
+  return features;
+}
+
+/** Extract all WebGL features */
+export function getWebGLFeatures(gl: WebGLRenderingContext): Set<WebGLFeature> {
+  // Enable EXT_float_blend first: https://developer.mozilla.org/en-US/docs/Web/API/EXT_float_blend
+  gl.getExtension('EXT_color_buffer_float');
+  gl.getExtension('WEBGL_color_buffer_float');
+  gl.getExtension('EXT_float_blend');
+
+  const features = new Set<WebGLFeature>();
+  for (const feature in WEBGL_FEATURES) {
+    if (isFeatureSupported(gl, feature as WebGLFeature)) {
+      features.add(feature as WebGLFeature );
+    }
+  }
+  return features;
+}
+
+function isFeatureSupported(gl: WebGLRenderingContext, feature: WebGLFeature): boolean {
+  const [webgl1Feature, webgl2Feature] = WEBGL_FEATURES[feature];;
+
+  // Get extension name from table
+  const featureDefinition = isWebGL2(gl) ? webgl2Feature : webgl1Feature;
+
+  // Check if the value is dependent on checking one or more extensions
+  if (typeof featureDefinition === 'boolean') {
+    return featureDefinition;
+  }
+
+  switch (feature) {
+    case 'webgl-color-attachment-rgba32f':
+      return isWebGL2(gl) ? Boolean(gl.getExtension(featureDefinition)) :
+        checkFloat32ColorAttachment(gl);
+    case 'glsl-derivatives':
+      return canCompileGLSLExtension(gl, featureDefinition); // TODO options
+    case 'glsl-frag-data':
+      return canCompileGLSLExtension(gl, featureDefinition, {behavior: 'require'}); // TODO options
+    case 'glsl-frag-depth':
+      return canCompileGLSLExtension(gl, featureDefinition); // TODO options
+    default:
+      return Boolean(gl.getExtension(featureDefinition));
+  }
+}
+
+
+// function to test if Float 32 bit format texture can be bound as color attachment
+function checkFloat32ColorAttachment(gl: WebGLRenderingContext): boolean {
+  let texture: WebGLTexture;
+  let framebuffer: WebGLFramebuffer;
+  try {
+    const texture = gl.createTexture();
+    gl.bindTexture(GL.TEXTURE_2D, texture);
+
+    const level = 0;
+    const internalFormat = gl.RGBA;
+    const width = 1;
+    const height = 1;
+    const border = 0;
+    const srcFormat = gl.RGBA;
+    const srcType = gl.UNSIGNED_BYTE;
+    const pixel = new Uint8Array([0, 0, 255, 255]);  // opaque blue
+    gl.texImage2D(gl.TEXTURE_2D, level, internalFormat,
+                  width, height, border, srcFormat, srcType,
+                  pixel);
+
+    const framebuffer = gl.createFramebuffer();
+    gl.bindFramebuffer(GL.FRAMEBUFFER, framebuffer);
+    gl.framebufferTexture2D(GL.FRAMEBUFFER, GL.COLOR_ATTACHMENT0, GL.TEXTURE_2D, texture, 0);
+    const status = gl.checkFramebufferStatus(GL.FRAMEBUFFER) === GL.FRAMEBUFFER_COMPLETE;
+    return status;
+  } finally {
+    gl.deleteTexture(texture);
+    gl.deleteFramebuffer(framebuffer);
+  }
+}
+
+const compiledGLSLExtensions = {};
+
+/*
+ * Enables feature detection in IE11 due to a bug where gl.getExtension may return true
+ * but fail to compile when the extension is enabled in the shader. Specifically,
+ * the OES_standard_derivatives and WEBGL_draw_buffers extensions fails to compile in IE11 even though its included
+ * in the list of supported extensions.
+ * opts allows user agent to be overridden for testing
+ * Inputs :
+ *  gl : WebGL context
+ *  cap : Key of WEBGL_FEATURES object identifying the extension
+ *  opts :
+ *   behavior : behavior of extension to be tested, by defualt `enable` is used
+ * Returns : true, if shader is compiled successfully, false otherwise
+ */
+export function canCompileGLSLExtension(gl: WebGLRenderingContext, extensionName, opts: {behavior?} = {}) {
+  if (!isOldIE(opts)) {
+    return true;
+  }
+
+  if (extensionName in compiledGLSLExtensions) {
+    return compiledGLSLExtensions[extensionName];
+  }
+
+  const behavior = opts.behavior || 'enable';
+  const source = `#extension GL_${extensionName} : ${behavior}\nvoid main(void) {}`;
+
+  const shader = gl.createShader(gl.VERTEX_SHADER);
+  gl.shaderSource(shader, source);
+  gl.compileShader(shader);
+  const canCompile = gl.getShaderParameter(shader, gl.COMPILE_STATUS);
+  gl.deleteShader(shader);
+  compiledGLSLExtensions[extensionName] = canCompile;
+  return canCompile;
+}
+
+/** Defines luma.gl "feature" names and semantics
+ * Format: 'feature-name: [WebGL1 support, WebGL2 support] / [WebGL1 and WebGL2 support]', when support is 'string' it is the name of the extension
+ */
+const WEBGL_FEATURES: Record<WebGLFeature, [boolean | string, boolean | string]> = {
+  'webgl2': [false, true],
+
+  // API SUPPORT
+  'webgl-vertex-array-object': ['OES_vertex_array_object', true],
+  'webgl-timer-query': ['EXT_disjoint_timer_query', 'EXT_disjoint_timer_query_webgl2'],
+  'webgl-instanced-rendering': ['ANGLE_instanced_arrays', true],
+  'webgl-multiple-render-targets': ['WEBGL_draw_buffers', true],
+
+  // FEATURES
+  'webgl-element-index-uint32': ['OES_element_index_uint', true],
+
+  // BLENDING
+  'webgl-blend-equation-minmax': ['EXT_blend_minmax', true],
+  'webgl-float-blend': ['EXT_float_blend', 'EXT_float_blend'],
+
+  // TEXTURES, RENDERBUFFERS
+  'webgl-color-encoding-srgb': ['EXT_sRGB', true],
+
+  // TEXTURES
+  'webgl-texture-depth': ['WEBGL_depth_texture', true],
+  'webgl-texture-float': ['OES_texture_float', true],
+  'webgl-texture-half-float': ['OES_texture_half_float', true],
+
+  'webgl-texture-filter-linear-float': ['OES_texture_float_linear', 'OES_texture_float_linear'],
+  'webgl-texture-filter-linear-half-float': ['OES_texture_half_float_linear', 'OES_texture_half_float_linear'],
+  'webgl-texture-filter-anisotropic': ['EXT_texture_filter_anisotropic', 'EXT_texture_filter_anisotropic'],
+
+  // FRAMEBUFFERS, TEXTURES AND RENDERBUFFERS
+  'webgl-color-attachment-rgba32f': [false, 'EXT_color_buffer_float'], // Note override check
+  'webgl-color-attachment-float': [false, 'EXT_color_buffer_float'],
+  'webgl-color-attachment-half-float': ['EXT_color_buffer_half_float', 'EXT_color_buffer_half_float'],
+
+  // GLSL extensions
+  'glsl-frag-data': ['WEBGL_draw_buffers', true],
+  'glsl-frag-depth': ['EXT_frag_depth', true],
+  'glsl-derivatives': ['OES_standard_derivatives', true],
+  'glsl-texture-lod': ['EXT_shader_texture_lod', true]
+};

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

@@ -0,0 +1,150 @@
+// luma.gl, MIT license
+import type {DeviceLimits} from '@luma.gl/api';
+import GL from '@luma.gl/constants';
+import {getWebGL2Context} from '../../context/context/webgl-checks';
+
+/** Populate a WebGPU style device limits */
+export function getDeviceLimits(gl: WebGLRenderingContext): DeviceLimits {
+  const gl2: WebGL2RenderingContext = getWebGL2Context(gl);
+  return {
+    maxTextureDimension1D: 0, // WebGL does not support 1D textures
+    maxTextureDimension2D: gl.getParameter(GL.MAX_TEXTURE_SIZE),
+    maxTextureDimension3D: gl2 ? gl2.getParameter(GL.MAX_3D_TEXTURE_SIZE) : 0,
+    maxTextureArrayLayers: gl2 ? gl2.getParameter(GL.MAX_ARRAY_TEXTURE_LAYERS) : 0,
+    maxBindGroups: 1, // TBD
+    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: gl2 ? gl2.getParameter(GL.MAX_UNIFORM_BUFFER_BINDINGS) : 0,
+    maxUniformBufferBindingSize: gl2 ? gl2.getParameter(GL.MAX_UNIFORM_BLOCK_SIZE) : 0,
+    maxStorageBufferBindingSize: 0,
+    minUniformBufferOffsetAlignment: gl2 ? gl2.getParameter(GL.UNIFORM_BUFFER_OFFSET_ALIGNMENT) : 0,
+    minStorageBufferOffsetAlignment: 0, // TBD
+    maxVertexBuffers: 0,
+    maxVertexAttributes: gl.getParameter(GL.MAX_VERTEX_ATTRIBS),
+    maxVertexBufferArrayStride: 2048, // TBD, this is just the default value from WebGPU
+    maxInterStageShaderComponents: gl2 ? gl2.getParameter(GL.MAX_VARYING_COMPONENTS) : 0,
+    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: WebGLRenderingContext): WebGLLimits {
+  const gl2 = getWebGL2Context(gl);
+  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 gl2 ? gl2.getParameter(pname) as T : (defaultValue || 0) as T;
+  }
+  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]: {gl1: 1.0, extension: 'EXT_texture_filter_anisotropic'},
+
+    // 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
+  };
+}

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

@@ -0,0 +1,49 @@
+import {DeviceInfo} from '@luma.gl/api';
+import GL from '@luma.gl/constants';
+import {isWebGL2} from '../../context/context/webgl-checks';
+
+/** @returns strings identifying the GPU vendor and driver. */
+export function getDeviceInfo(gl: WebGLRenderingContext): DeviceInfo {
+  const vendorMasked = gl.getParameter(GL.VENDOR);
+  const rendererMasked = gl.getParameter(GL.RENDERER);
+  // Get unmasked strings if available
+  // https://www.khronos.org/registry/webgl/extensions/WEBGL_debug_renderer_info/
+  const ext = gl.getExtension('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;
+  const renderer = rendererUnmasked || rendererMasked;
+  const gpuVendor = identifyGPUVendor(vendor, renderer);
+  return {
+    type: isWebGL2(gl) ? 'webgl2' : 'webgl',
+    gpuVendor,
+    vendor: vendorUnmasked || vendorMasked,
+    renderer: rendererUnmasked || rendererMasked,
+    version: gl.getParameter(GL.VERSION),
+    shadingLanguages: ['glsl'],
+    shadingLanguageVersions: {
+      'glsl': gl.getParameter(GL.SHADING_LANGUAGE_VERSION) as string
+    }
+  };
+}
+
+function identifyGPUVendor(vendor: string, renderer: string): 'NVIDIA' | 'INTEL' | 'APPLE' | 'AMD' | 'UNKNOWN' {
+  if (vendor.match(/NVIDIA/i) || renderer.match(/NVIDIA/i)) {
+    return 'NVIDIA';
+  }
+  if (vendor.match(/INTEL/i) || renderer.match(/INTEL/i)) {
+    return 'INTEL';
+  }
+  if (vendor.match(/Apple/i) || renderer.match(/Apple/i)) {
+    return 'APPLE';
+  }
+  if (
+    vendor.match(/AMD/i) ||
+    renderer.match(/AMD/i) ||
+    vendor.match(/ATI/i) ||
+    renderer.match(/ATI/i)
+  ) {
+    return 'AMD';
+  }
+  return 'UNKNOWN';
+}

package/src/{features/check-old-ie.js → adapter/device-helpers/is-old-ie.ts}

@@ -1,7 +1,7 @@
 // opts allows user agent to be overridden for testing
-export default function isOldIE(opts = {}) {
-  const navigator = (typeof window !== 'undefined' && window.navigator) || {};
-  // @ts-ignore
+export function isOldIE(opts = {}) {
+  const navigator = typeof window !== 'undefined' ? window.navigator || {} : {};
+  // @ts-expect-error
   const userAgent = opts.userAgent || navigator.userAgent || '';
   // We only care about older versions of IE (IE 11 and below). Newer versions of IE (Edge)
   // have much better web standards support.