@luma.gl/webgl 8.5.8 → 8.6.0-alpha.2

package/src/debug/{debug-uniforms.js → debug-uniforms.ts}

@@ -1,14 +1,24 @@
-import {assert} from '../utils/assert';
-import {formatValue} from '../utils/format-value';
+import {assert, formatValue} from '@luma.gl/api';
 
 // Prepares a table suitable for console.table
 /* eslint-disable max-statements, complexity */
-export function getDebugTableForUniforms({
-  header = 'Uniforms',
-  program,
-  uniforms,
-  undefinedOnly = false
-}) {
+export function getDebugTableForUniforms(options?: {
+  header?: string;
+  program: any;
+  uniforms: any;
+  undefinedOnly?: boolean;
+}): {
+  table: {};
+  count: number;
+  unusedTable: {};
+  unusedCount: number;
+} {
+  const {
+    header = 'Uniforms',
+    program,
+    uniforms,
+    undefinedOnly = false
+  } = options;
   assert(program);
 
   const SHADER_MODULE_UNIFORM_REGEXP = '.*_.*';

package/src/debug/{debug-vertex-array.js → debug-vertex-array.ts}

@@ -1,10 +1,12 @@
-import Buffer from '../classes/buffer';
+import {formatValue} from '@luma.gl/api';
+import Buffer from '../classes/webgl-buffer';
 import {getKey} from '../webgl-utils/constants-to-keys';
 import {getCompositeGLType} from '../webgl-utils/attribute-utils';
-import {formatValue} from '../utils/format-value';
 
 // Creates object suitable as input for console.table
-export function getDebugTableForVertexArray({vertexArray, header = 'Attributes'}) {
+export function getDebugTableForVertexArray(options?: {vertexArray: any; header?: string}): {} {
+  const {vertexArray, header = 'Attributes'} = options;
+
   if (!vertexArray.configuration) {
     return {};
   }
@@ -14,6 +16,7 @@ export function getDebugTableForVertexArray({vertexArray, header = 'Attributes'}
   // Add index (elements) if available
   if (vertexArray.elements) {
     // const elements = Object.assign({size: 1}, vertexArray.elements);
+    // @ts-expect-error
     table.ELEMENT_ARRAY_BUFFER = getDebugTableRow(vertexArray, vertexArray.elements, null, header);
   }
 
@@ -78,9 +81,7 @@ function getDebugTableRow(vertexArray, attribute, accessor, header) {
     marker = changed ? '*' : '';
 
     value = data;
-    // @ts-ignore
     bytes = buffer.byteLength;
-    // @ts-ignore
     verts = bytes / data.BYTES_PER_ELEMENT / size;
 
     let format;

package/src/device/check-glsl-extension.ts

@@ -0,0 +1,44 @@
+// luma.gl, MIT license
+import {isOldIE} from '../webgl-utils/is-old-ie';
+
+// 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 extension fails to compile in IE11 even though its included
+// in the list of supported extensions.
+// const compiledGLSLExtensions = {};
+
+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;
+}

package/src/device/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 '../webgl-utils/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/device/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/device/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';
+}