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

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

@@ -1,161 +0,0 @@
-// luma.gl, MIT license
-// Copyright (c) vis.gl contributors
-
-// Feature detection for WebGL
-// Provides a function that enables simple checking of which WebGL features are
-// available in an WebGL1 or WebGL2 environment.
-
-import {DeviceFeature} from '@luma.gl/core';
-import {isWebGL2} from '../../context/context/webgl-checks';
-import {isOldIE} from './is-old-ie';
-import {getTextureFeatures, _checkFloat32ColorAttachment} from '../converters/texture-formats';
-
-/** Get WebGPU style feature strings */
-export function getDeviceFeatures(gl: WebGLRenderingContext): Set<DeviceFeature> {
-  const features = getWebGLFeatures(gl);
-
-  // texture features
-  // features.add('texture-compression-bc'); 
-  for (const textureFeature of getTextureFeatures(gl)) {
-    features.add(textureFeature);
-  }
-
-  // TODO
-  // features.add('depth-clip-control'); // GPUPrimitiveState.clampDepth
-  // features.add('depth24unorm-stencil8'); // GPUTextureFormat 'depth24unorm-stencil8'.
-  // features.add('depth32float-stencil8'); // GPUTextureFormat 'depth32float-stencil8'.
-  // features.add('timestamp-query'); // GPUQueryType "timestamp-query"
-  // "indirect-first-instance"
-
-  return features;
-}
-
-/** Extract all WebGL features */
-export function getWebGLFeatures(gl: WebGLRenderingContext): Set<DeviceFeature> {
-  // Enables 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<DeviceFeature>();
-  for (const feature of Object.keys(WEBGL_FEATURES)) {
-    // @ts-expect-error
-    if (isFeatureSupported(gl, feature)) {
-      // @ts-expect-error
-      features.add(feature);
-    }
-  }
-  return features;
-}
-
-function isFeatureSupported(gl: WebGLRenderingContext, feature: DeviceFeature): boolean {
-  const featureInfo = WEBGL_FEATURES[feature];
-  if (!featureInfo) {
-    return false;
-  }
-
-  const [webgl1Feature, webgl2Feature] = featureInfo || [];
-
-  // 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 'texture-renderable-rgba32float-webgl':
-      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));
-  }
-}
-
-const compiledGLSLExtensions: Record<string, boolean> = {};
-
-/*
- * 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);
-  if (!shader) {
-    throw new Error('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: Partial<Record<DeviceFeature, [boolean | string, boolean | string]>> = {
-  'webgl': [true, true],
-  'webgl2': [false, true],
-
-  'timer-query-webgl': ['EXT_disjoint_timer_query', 'EXT_disjoint_timer_query_webgl2'],
-  'transform-feedback-webgl2': [false, true],
-
-  // WEBGL1 SUPPORT
-  'vertex-array-object-webgl1': ['OES_vertex_array_object', true],
-  'instanced-rendering-webgl1': ['ANGLE_instanced_arrays', true],
-  'multiple-render-targets-webgl1': ['WEBGL_draw_buffers', true],
-  'index-uint32-webgl1': ['OES_element_index_uint', true],
-  'blend-minmax-webgl1': ['EXT_blend_minmax', true],
-  'texture-blend-float-webgl1': ['EXT_float_blend', 'EXT_float_blend'],
-
-  // TEXTURES, RENDERBUFFERS
-  'texture-formats-srgb-webgl1': ['EXT_sRGB', true],
-
-  // TEXTURES
-  'texture-formats-depth-webgl1': ['WEBGL_depth_texture', true],
-  'texture-formats-float32-webgl1': ['OES_texture_float', true],
-  'texture-formats-float16-webgl1': ['OES_texture_half_float', true],
-
-  'texture-filter-linear-float32-webgl': ['OES_texture_float_linear', 'OES_texture_float_linear'],
-  'texture-filter-linear-float16-webgl': ['OES_texture_half_float_linear', 'OES_texture_half_float_linear'],
-  'texture-filter-anisotropic-webgl': ['EXT_texture_filter_anisotropic', 'EXT_texture_filter_anisotropic'],
-
-  // FRAMEBUFFERS, TEXTURES AND RENDERBUFFERS
-  'texture-renderable-rgba32float-webgl': ['WEBGL_color_buffer_float', 'EXT_color_buffer_float'], // Note override check
-  'texture-renderable-float32-webgl': [false, 'EXT_color_buffer_float'],
-  'texture-renderable-float16-webgl': ['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

@@ -1,155 +0,0 @@
-// luma.gl, MIT license
-// Copyright (c) vis.gl contributors
-
-import type {DeviceLimits} from '@luma.gl/core';
-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 | null = 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;
-  }
-  // 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
-  };
-}

package/src/adapter/device-helpers/is-old-ie.ts

@@ -1,14 +0,0 @@
-// luma.gl, MIT license
-// Copyright (c) vis.gl contributors
-
-// opts allows user agent to be overridden for testing
-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.
-  const isMSIE = userAgent.indexOf('MSIE ') !== -1;
-  const isTrident = userAgent.indexOf('Trident/') !== -1;
-  return isMSIE || isTrident;
-}

package/src/context/context/create-headless-context.ts

@@ -1,51 +0,0 @@
-// luma.gl, MIT license
-// Copyright (c) vis.gl contributors
-
-const ERR_HEADLESSGL_FAILED =
-  'Failed to create WebGL context in Node.js, headless gl returned null';
-
-const ERR_HEADLESSGL_LOAD = '\
-  luma.gl: loaded under Node.js without headless gl installed, meaning that WebGL \
-  contexts can not be created. This may not be an error. For example, this is a \
-  typical configuration for isorender applications running on the server.';
-
-const CONTEXT_DEFAULTS = {
-  width: 1,
-  height: 1,
-  debug: true,
-  throwOnError: false
-};
-
-/** Duck typing for the main headless gl export, a function to create contexts */
-export type HeadlessGL = (width: number, height: number, options: Record<string, unknown>) => WebGLRenderingContext;
-
-let headlessGL: HeadlessGL | null = null; 
-
-/** By importing `gl` and registering it with this function, contexts can be created under Node.js */
-export function registerHeadlessGL(headlessgl: HeadlessGL) {
-  headlessGL = headlessgl;
-}
-
-/** @returns true if headless gl is registered */
-export function isHeadlessGLRegistered(): boolean {
-  return headlessGL !== null;
-}
-
-/** Create headless gl context (for running under Node.js) */
-export function createHeadlessContext(options?: Record<string, any>): WebGLRenderingContext {
-  options = {...CONTEXT_DEFAULTS, ...options};
-
-  const {width, height, webgl1, webgl2} = options;
-
-  if (webgl2 && !webgl1) {
-    throw new Error('headless-gl does not support WebGL2');
-  }
-  if (!headlessGL) {
-    throw new Error(ERR_HEADLESSGL_LOAD);
-  }
-  const gl = headlessGL(width, height, options);
-  if (!gl) {
-    throw new Error(ERR_HEADLESSGL_FAILED);
-  }
-  return gl;
-}

package/src/context/context/webgl-checks.ts

@@ -1,51 +0,0 @@
-// luma.gl, MIT license
-// Copyright (c) vis.gl contributors
-
-import {assert} from '@luma.gl/core';
-
-const ERR_CONTEXT = 'Invalid WebGLRenderingContext';
-export const ERR_WEBGL = ERR_CONTEXT;
-export const ERR_WEBGL2 = 'Requires WebGL2';
-
-
-/** Check if supplied parameter is a WebGLRenderingContext */
-export function isWebGL(gl: any): boolean {
-  if (typeof WebGLRenderingContext !== 'undefined' && gl instanceof WebGLRenderingContext) {
-    return true;
-  }
-  if (typeof WebGL2RenderingContext !== 'undefined' && gl instanceof WebGL2RenderingContext) {
-    return true;
-  }
-  // Look for debug contexts, headless gl etc
-  return Boolean(gl && Number.isFinite(gl._version));
-}
-
-
-/** Check if supplied parameter is a WebGL2RenderingContext */
-export function isWebGL2(gl: any): boolean {
-  if (typeof WebGL2RenderingContext !== 'undefined' && gl instanceof WebGL2RenderingContext) {
-    return true;
-  }
-  // Look for debug contexts, headless gl etc
-  return Boolean(gl && gl._version === 2);
-}
-
-
-/** Returns a properly typed WebGL2RenderingContext from a WebGL1 context, or null */
-export function getWebGL2Context(gl: WebGLRenderingContext): WebGL2RenderingContext | null {
-  // @ts-expect-error
-  return isWebGL2(gl) ? gl : null;
-}
-
-
-/** Throw if supplied parameter is not a WebGLRenderingContext, otherwise return properly typed value */
-export function assertWebGLContext(gl: any): WebGLRenderingContext {
-  assert(isWebGL(gl), ERR_CONTEXT);
-  return gl;
-}
-
-/** Throw if supplied parameter is not a WebGL2RenderingContext, otherwise return properly typed value */
-export function assertWebGL2Context(gl: any): WebGL2RenderingContext {
-  assert(isWebGL2(gl), ERR_WEBGL2);
-  return gl;
-}

package/src/context/polyfill/get-parameter-polyfill.ts

@@ -1,122 +0,0 @@
-// luma.gl, MIT license
-// Copyright (c) vis.gl contributors
-
-/* eslint-disable no-inline-comments, max-len, camelcase */
-import {GL} from '@luma.gl/constants';
-import {isWebGL2} from '../context/webgl-checks';
-
-const OES_element_index = 'OES_element_index';
-const WEBGL_draw_buffers = 'WEBGL_draw_buffers';
-const EXT_disjoint_timer_query = 'EXT_disjoint_timer_query';
-const EXT_disjoint_timer_query_webgl2 = 'EXT_disjoint_timer_query_webgl2';
-const EXT_texture_filter_anisotropic = 'EXT_texture_filter_anisotropic';
-const WEBGL_debug_renderer_info = 'WEBGL_debug_renderer_info';
-
-const GL_FRAGMENT_SHADER_DERIVATIVE_HINT = 0x8b8b;
-const GL_DONT_CARE = 0x1100;
-const GL_GPU_DISJOINT_EXT = 0x8fbb;
-const GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT = 0x84ff;
-const GL_UNMASKED_VENDOR_WEBGL = 0x9245; // vendor string of the graphics driver.
-const GL_UNMASKED_RENDERER_WEBGL = 0x9246; // renderer string of the graphics driver.
-
-const getWebGL2ValueOrZero = (gl) => (!isWebGL2(gl) ? 0 : undefined);
-
-// if a function returns undefined in this table,
-// the original getParameter will be called, defeating the override
-const WEBGL_PARAMETERS = {
-  [GL.READ_BUFFER]: (gl) => (!isWebGL2(gl) ? GL.COLOR_ATTACHMENT0 : undefined),
-
-  // WebGL2 context parameters
-  [GL_FRAGMENT_SHADER_DERIVATIVE_HINT]: (gl) => (!isWebGL2(gl) ? GL_DONT_CARE : undefined),
-
-  [GL.RASTERIZER_DISCARD]: getWebGL2ValueOrZero,
-
-  [GL.SAMPLES]: getWebGL2ValueOrZero,
-
-  // WebGL2 extension context parameters
-  [GL_GPU_DISJOINT_EXT]: (gl: WebGLRenderingContext, getParameter) => {
-    const ext = isWebGL2(gl)
-      ? gl.getExtension(EXT_disjoint_timer_query_webgl2)
-      : gl.getExtension(EXT_disjoint_timer_query);
-    return ext && ext.GPU_DISJOINT_EXT ? getParameter(ext.GPU_DISJOINT_EXT) : 0;
-  },
-
-  // Extension fixed values
-  [GL_UNMASKED_VENDOR_WEBGL]: (gl: WebGLRenderingContext, getParameter) => {
-    const ext = gl.getExtension(WEBGL_debug_renderer_info);
-    return getParameter((ext && ext.UNMASKED_VENDOR_WEBGL) || GL.VENDOR);
-  },
-
-  [GL_UNMASKED_RENDERER_WEBGL]: (gl: WebGLRenderingContext, getParameter) => {
-    const ext = gl.getExtension(WEBGL_debug_renderer_info);
-    return getParameter((ext && ext.UNMASKED_RENDERER_WEBGL) || GL.RENDERER);
-  },
-
-  // Extension LIMITS
-  [GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT]: (gl: WebGLRenderingContext, getParameter) => {
-    // @ts-ignore TODO - store these on the device instance instead...
-    const ext = gl.luma?.extensions?.[EXT_texture_filter_anisotropic] ||
-      gl.getExtension('EXT_texture_filter_anisotropic');
-    return ext ? getParameter(ext.MAX_TEXTURE_MAX_ANISOTROPY_EXT) : 1.0;
-  },
-
-  // WebGL2 Limits
-  [GL.MAX_3D_TEXTURE_SIZE]: getWebGL2ValueOrZero,
-  [GL.MAX_ARRAY_TEXTURE_LAYERS]: getWebGL2ValueOrZero,
-  [GL.MAX_CLIENT_WAIT_TIMEOUT_WEBGL]: getWebGL2ValueOrZero,
-  [GL.MAX_COLOR_ATTACHMENTS]: (gl: WebGLRenderingContext, getParameter) => {
-    if (!isWebGL2(gl)) {
-      const ext = gl.getExtension(WEBGL_draw_buffers);
-      return ext ? getParameter(ext.MAX_COLOR_ATTACHMENTS_WEBGL) : 0;
-    }
-    return undefined;
-  },
-  [GL.MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS]: getWebGL2ValueOrZero,
-  [GL.MAX_COMBINED_UNIFORM_BLOCKS]: getWebGL2ValueOrZero,
-  [GL.MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS]: getWebGL2ValueOrZero,
-  [GL.MAX_DRAW_BUFFERS]: (gl) => {
-    if (!isWebGL2(gl)) {
-      const ext = gl.getExtension(WEBGL_draw_buffers);
-      return ext ? ext.MAX_DRAW_BUFFERS_WEBGL : 0;
-    }
-    return undefined;
-  },
-  [GL.MAX_ELEMENT_INDEX]:
-    // Guess: per webglstats.com 99.6% of webgl2 supports 2147483647
-    (gl) => (gl.getExtension(OES_element_index) ? 2147483647 : 65535),
-  [GL.MAX_ELEMENTS_INDICES]:
-    // Guess: "Reasonably safe" per webglstats.com - could be higher/lower (on some mobile devices)
-    (gl) => (gl.getExtension(OES_element_index) ? 16777216 : 65535),
-  [GL.MAX_ELEMENTS_VERTICES]:
-    // Guess: "Reasonably safe" per webglstats.com - could be higher/lower (on some mobile devices)
-    (gl) => 16777216,
-  [GL.MAX_FRAGMENT_INPUT_COMPONENTS]: getWebGL2ValueOrZero,
-  [GL.MAX_FRAGMENT_UNIFORM_BLOCKS]: getWebGL2ValueOrZero,
-  [GL.MAX_FRAGMENT_UNIFORM_COMPONENTS]: getWebGL2ValueOrZero,
-  [GL.MAX_SAMPLES]: getWebGL2ValueOrZero,
-  [GL.MAX_SERVER_WAIT_TIMEOUT]: getWebGL2ValueOrZero,
-  [GL.MAX_TEXTURE_LOD_BIAS]: getWebGL2ValueOrZero,
-  [GL.MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS]: getWebGL2ValueOrZero,
-  [GL.MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS]: getWebGL2ValueOrZero,
-  [GL.MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS]: getWebGL2ValueOrZero,
-  [GL.MAX_UNIFORM_BLOCK_SIZE]: getWebGL2ValueOrZero,
-  [GL.MAX_UNIFORM_BUFFER_BINDINGS]: getWebGL2ValueOrZero,
-  [GL.MAX_VARYING_COMPONENTS]: getWebGL2ValueOrZero,
-  [GL.MAX_VERTEX_OUTPUT_COMPONENTS]: getWebGL2ValueOrZero,
-  [GL.MAX_VERTEX_UNIFORM_BLOCKS]: getWebGL2ValueOrZero,
-  [GL.MAX_VERTEX_UNIFORM_COMPONENTS]: getWebGL2ValueOrZero,
-  [GL.MIN_PROGRAM_TEXEL_OFFSET]: getWebGL2ValueOrZero,
-  [GL.MAX_PROGRAM_TEXEL_OFFSET]: getWebGL2ValueOrZero,
-  [GL.UNIFORM_BUFFER_OFFSET_ALIGNMENT]: getWebGL2ValueOrZero
-};
-
-// A "replacement" gl.getParameter that accepts "enums" from extensions and WebGL2
-// and returns reasonably safe defaults
-export function getParameterPolyfill(gl: WebGLRenderingContext, originalGetParameter, pname) {
-  // Return mock limits (usually 0) for WebGL2 constants to ensure these
-  // can be queries without error
-  const limit = WEBGL_PARAMETERS[pname];
-  const value = typeof limit === 'function' ? limit(gl, originalGetParameter, pname) : limit;
-  const result = value !== undefined ? value : originalGetParameter(pname);
-  return result;
-}

package/src/context/polyfill/polyfill-context.ts

@@ -1,104 +0,0 @@
-// luma.gl, MIT license
-// Copyright (c) vis.gl contributors
-
-// WebGL1/WebGL2 extension polyfill support
-//
-// Provides a function that creates polyfills for WebGL2 functions based
-// on available extensions and installs them on a supplied target (could be
-// the WebGLContext or its prototype, or a separate object).
-//
-// This is intended to be a stand-alone file with minimal dependencies,
-// easy to reuse or repurpose in other projects.
-
-import {assert} from '@luma.gl/core';
-import {polyfillVertexArrayObject} from './polyfill-vertex-array-object';
-
-import {WEBGL2_CONTEXT_POLYFILLS, WEBGL2_CONTEXT_OVERRIDES} from './polyfill-table';
-import {getContextData} from './context-data';
-
-/**
- * Registers extensions, polyfills or mock functions for extensions in the polyfills list
- */
-export function polyfillContext(gl: WebGLRenderingContext): WebGL2RenderingContext {
-  const contextState = getContextData(gl);
-
-  if (!contextState._polyfilled) {
-    polyfillVertexArrayObject(gl);
-    initializeExtensions(gl);
-    installPolyfills(gl, WEBGL2_CONTEXT_POLYFILLS);
-    installOverrides(gl, {target: contextState, target2: gl});
-    contextState._polyfilled = true;
-  }
-
-  // Note - only supports a subset of WebGL2
-  return gl as WebGL2RenderingContext;
-}
-
-function initializeExtensions(gl: WebGLRenderingContext): void {
-  const contextState = getContextData(gl);
-  // `getSupportedExtensions` can return null when context is lost.
-  const EXTENSIONS = gl.getSupportedExtensions() || [];
-  // Generates warnings in Chrome
-  const IGNORE_EXTENSIONS = ['WEBGL_polygon_mode'];
-  for (const extensionName of EXTENSIONS) {
-    if (!IGNORE_EXTENSIONS.includes(extensionName)) {
-      const extension = gl.getExtension(extensionName);
-      contextState._extensions[extensionName] = extension;
-    }
-  }
-}
-
-function installPolyfills(gl: WebGLRenderingContext, polyfills): void {
-  const contextState = getContextData(gl);
-  for (const extension of Object.getOwnPropertyNames(polyfills)) {
-    if (extension !== 'overrides') {
-      polyfillExtension(gl, {extension, target: contextState, target2: gl});
-    }
-  }
-}
-
-/** Polyfills a single WebGL extension into the `target` object */
-function polyfillExtension(gl: WebGLRenderingContext, {extension, target, target2}): void {
-  const defaults = WEBGL2_CONTEXT_POLYFILLS[extension];
-  assert(defaults);
-
-  const {meta = {}} = defaults;
-  const {suffix = ''} = meta;
-
-  const ext = gl.getExtension(extension);
-
-  for (const key of Object.keys(defaults)) {
-    const extKey = `${key}${suffix}`;
-
-    let polyfill: Function | null = null;
-    if (key === 'meta') {
-      // ignore
-    } else if (typeof gl[key] === 'function') {
-      // WebGL2 implementation is already
-    } else if (ext && typeof ext[extKey] === 'function') {
-      // pick extension implementation,if available
-      polyfill = (...args) => ext[extKey](...args);
-    } else if (typeof defaults[key] === 'function') {
-      // pick the mock implementation, if no implementation was detected
-      polyfill = defaults[key].bind(target);
-    }
-
-    if (polyfill) {
-      target[key] = polyfill;
-      target2[key] = polyfill;
-    }
-  }
-}
-
-/** Install simple overrides (mostly get* functions) */
-function installOverrides(gl: WebGLRenderingContext, {target, target2}) {
-  Object.keys(WEBGL2_CONTEXT_OVERRIDES).forEach((key) => {
-    if (typeof WEBGL2_CONTEXT_OVERRIDES[key] === 'function') {
-      // install an override, if no implementation was detected
-      const originalFunc = gl[key] ? gl[key].bind(gl) : () => {};
-      const polyfill = WEBGL2_CONTEXT_OVERRIDES[key].bind(null, gl, originalFunc);
-      target[key] = polyfill;
-      target2[key] = polyfill;
-    }
-  });
-}