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

package/src/adapter/webgl-device.ts

@@ -84,11 +84,11 @@ export class WebGLDevice extends Device {
   // Public `Device` API
   //
 
-  static type: string = 'webgl';
+  /** type of this device */
+  static readonly type: string = 'webgl';
 
-  static isSupported(): boolean {
-    return typeof WebGL2RenderingContext !== 'undefined';
-  }
+  /** type of this device */
+  readonly type = 'webgl';
 
   /** The underlying WebGL context */
   readonly handle: WebGL2RenderingContext;
@@ -106,6 +106,11 @@ export class WebGLDevice extends Device {
   // Static methods, expected to be present by `luma.createDevice()`
   //
 
+  /** Check if WebGL 2 is available */
+  static isSupported(): boolean {
+    return typeof WebGL2RenderingContext !== 'undefined';
+  }
+
   /**
    * Get a device instance from a GL context
    * Creates and instruments the device if not already created
@@ -149,12 +154,18 @@ export class WebGLDevice extends Device {
 
     // Wait for all the loads to settle before creating the context.
     // The Device.create() functions are async, so in contrast to the constructor, we can `await` here.
-    await Promise.all(promises);
+    const results = await Promise.allSettled(promises);
+    for (const result of results) {
+      if (result.status === 'rejected') {
+        log.error(`Failed to initialize debug libraries ${result.reason}`)();
+      }
+    }
 
     log.probe(LOG_LEVEL + 1, 'DOM is loaded')();
 
     // @ts-expect-error
     if (props.gl?.device) {
+      log.warn('reattaching existing device')();
       return WebGLDevice.attach(props.gl);
     }
 
@@ -162,7 +173,7 @@ export class WebGLDevice extends Device {
 
     // Log some debug info about the newly created context
     const message = `\
-Created ${device.info.type}${device.debug ? ' debug' : ''} context: \
+Created ${device.type}${device.debug ? ' debug' : ''} context: \
 ${device.info.vendor}, ${device.info.renderer} for canvas: ${device.canvasContext.id}`;
     log.probe(LOG_LEVEL, message)();
     log.table(LOG_LEVEL, device.info)();
@@ -216,8 +227,11 @@ ${device.info.vendor}, ${device.info.renderer} for canvas: ${device.canvasContex
 
     // luma Device fields
     this.info = getDeviceInfo(this.gl, this._extensions);
-    this.features = new WebGLDeviceFeatures(this.gl, this._extensions);
     this.limits = new WebGLDeviceLimits(this.gl);
+    this.features = new WebGLDeviceFeatures(this.gl, this._extensions, this.props.disabledFeatures);
+    if (this.props.initalizeFeatures) {
+      this.features.initializeFeatures();
+    }
 
     this.canvasContext.resize();
 
@@ -330,15 +344,6 @@ ${device.info.vendor}, ${device.info.renderer} for canvas: ${device.canvasContex
 
   private renderPass: WEBGLRenderPass | null = null;
 
-  getDefaultRenderPass(): WEBGLRenderPass {
-    this.renderPass =
-      this.renderPass ||
-      this.beginRenderPass({
-        framebuffer: this.canvasContext.getCurrentFramebuffer()
-      });
-    return this.renderPass;
-  }
-
   override createCommandEncoder(props?: CommandEncoderProps): WEBGLCommandEncoder {
     return new WEBGLCommandEncoder(this, props);
   }
@@ -395,15 +400,15 @@ ${device.info.vendor}, ${device.info.renderer} for canvas: ${device.canvasContex
   }
 
   override setParametersWebGL(parameters: any): void {
-    setGLParameters(this, parameters);
+    setGLParameters(this.gl, parameters);
   }
 
   override getParametersWebGL(parameters: any): any {
-    return getGLParameters(this, parameters);
+    return getGLParameters(this.gl, parameters);
   }
 
   override withParametersWebGL(parameters: any, func: any): any {
-    withGLParameters(this, parameters, func);
+    withGLParameters(this.gl, parameters, func);
   }
 
   override clearWebGL(options?: {

package/src/classic/clear.ts

@@ -60,8 +60,8 @@ export function clear(
   assert(clearFlags !== 0, ERR_ARGUMENTS);
 
   // Temporarily set any clear "colors" and call clear
-  withGLParameters(device, parameters, () => {
-    const gl = (device as WebGLDevice).gl;
+  const gl = (device as WebGLDevice).gl;
+  withGLParameters(gl, parameters, () => {
     gl.clear(clearFlags);
   });
 }

package/src/context/parameters/unified-parameter-api.ts

@@ -5,7 +5,6 @@
 // Provides a unified API for getting and setting any WebGL parameter
 // Also knows default values of all parameters, enabling fast cache initialization
 // Provides base functionality for the state caching.
-import {Device} from '@luma.gl/core';
 import type {GLParameters} from '@luma.gl/constants';
 import {
   GL_PARAMETER_DEFAULTS,
@@ -14,8 +13,6 @@ import {
   GL_PARAMETER_GETTERS
 } from './webgl-parameter-tables';
 
-import {WebGLDevice} from '../../adapter/webgl-device';
-
 export type {GLParameters};
 
 /**
@@ -24,13 +21,7 @@ export type {GLParameters};
  * @note requires a `cache` object to be set on the context (gl.state.cache)
  * This object is used to fill in any missing values for composite setter functions
  */
-export function setGLParameters(
-  device: Device | WebGL2RenderingContext,
-  parameters: GLParameters
-): void {
-  const webglDevice = WebGLDevice.attach(device);
-  const gl = webglDevice.gl;
-
+export function setGLParameters(gl: WebGL2RenderingContext, parameters: GLParameters): void {
   if (isObjectEmpty(parameters)) {
     return;
   }
@@ -93,12 +84,9 @@ export function setGLParameters(
  * by external code needs to be synchronized for the first time
  */
 export function getGLParameters(
-  device: Device | WebGL2RenderingContext,
+  gl: WebGL2RenderingContext,
   parameters: keyof GLParameters | (keyof GLParameters)[] | GLParameters = GL_PARAMETER_DEFAULTS
 ): GLParameters {
-  const webglDevice = WebGLDevice.attach(device);
-  const gl = webglDevice.gl;
-
   // support both arrays of parameters and objects (keys represent parameters)
 
   if (typeof parameters === 'number') {
@@ -124,8 +112,8 @@ export function getGLParameters(
  * NOT the canvas size dimensions, so they will have to be properly set after
  * calling this function.
  */
-export function resetGLParameters(device: Device | WebGL2RenderingContext): void {
-  setGLParameters(device, GL_PARAMETER_DEFAULTS);
+export function resetGLParameters(gl: WebGL2RenderingContext): void {
+  setGLParameters(gl, GL_PARAMETER_DEFAULTS);
 }
 
 // Helpers

package/src/context/state-tracker/with-parameters.ts

@@ -2,8 +2,6 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
-import type {Device} from '@luma.gl/core';
-import {WebGLDevice} from '../../adapter/webgl-device';
 import {GLParameters, setGLParameters} from '../parameters/unified-parameter-api';
 import {pushContextState, popContextState} from './track-context-state';
 
@@ -16,16 +14,13 @@ import {pushContextState, popContextState} from './track-context-state';
  * - Returns the return value of the supplied function
  */
 export function withGLParameters(
-  device: Device | WebGL2RenderingContext,
+  gl: WebGL2RenderingContext,
   parameters: GLParameters & {nocatch?: boolean},
   func: any
 ): any {
-  const webglDevice = WebGLDevice.attach(device);
-  const gl = webglDevice.gl;
-
   if (isObjectEmpty(parameters)) {
     // Avoid setting state if no parameters provided. Just call and return
-    return func(device);
+    return func(gl);
   }
 
   const {nocatch = true} = parameters;

package/src/index.ts

@@ -31,10 +31,6 @@ export {WEBGLRenderPass} from './adapter/resources/webgl-render-pass';
 // export {WEBGLComputePass} from './adapter/resources/webgl-compute-pass';
 export {WEBGLVertexArray} from './adapter/resources/webgl-vertex-array';
 
-// Internal WebGL classes
-export type {RenderbufferProps} from './adapter/objects/webgl-renderbuffer';
-export {WEBGLRenderbuffer} from './adapter/objects/webgl-renderbuffer';
-
 // WebGL adapter classes
 export {WEBGLTransformFeedback} from './adapter/resources/webgl-transform-feedback';
 
@@ -50,6 +46,10 @@ export {setDeviceParameters, withDeviceParameters} from './adapter/converters/de
 export {getShaderLayout} from './adapter/helpers/get-shader-layout';
 export {convertGLToTextureFormat} from './adapter/converters/texture-formats';
 
+// Internal WebGL classes
+export type {RenderbufferProps as _RenderbufferProps} from './adapter/objects/webgl-renderbuffer';
+export {WEBGLRenderbuffer as _WEBGLRenderbuffer} from './adapter/objects/webgl-renderbuffer';
+
 // TEST EXPORTS
 export {TEXTURE_FORMATS as _TEXTURE_FORMATS} from './adapter/converters/texture-formats';
 

package/dist/adapter/device-helpers/device-features.d.ts

@@ -1,6 +0,0 @@
-import { DeviceFeature } from '@luma.gl/core';
-/** Get WebGPU style feature strings */
-export declare function getDeviceFeatures(gl: WebGL2RenderingContext): Set<DeviceFeature>;
-/** Extract all WebGL features */
-export declare function getWebGLFeatures(gl: WebGL2RenderingContext): Set<DeviceFeature>;
-//# sourceMappingURL=device-features.d.ts.map

package/dist/adapter/device-helpers/device-features.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"device-features.d.ts","sourceRoot":"","sources":["../../../src/adapter/device-helpers/device-features.ts"],"names":[],"mappings":"AAMA,OAAO,EAAC,aAAa,EAAC,MAAM,eAAe,CAAC;AAG5C,uCAAuC;AACvC,wBAAgB,iBAAiB,CAAC,EAAE,EAAE,sBAAsB,GAAG,GAAG,CAAC,aAAa,CAAC,CAiBhF;AAED,iCAAiC;AACjC,wBAAgB,gBAAgB,CAAC,EAAE,EAAE,sBAAsB,GAAG,GAAG,CAAC,aAAa,CAAC,CAe/E"}

package/dist/adapter/device-helpers/device-features.js

@@ -1,65 +0,0 @@
-// luma.gl, MIT license
-// Copyright (c) vis.gl contributors
-import { getTextureFeatures } from '../converters/texture-formats';
-/** Get WebGPU style feature strings */
-export function getDeviceFeatures(gl) {
-    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) {
-    // 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(WEBGL_ALWAYS_FEATURES);
-    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, feature) {
-    const featureInfo = WEBGL_FEATURES[feature];
-    if (!featureInfo) {
-        return false;
-    }
-    // Get extension name from table
-    const featureDefinition = featureInfo;
-    // Check if the value is dependent on checking one or more extensions
-    if (typeof featureDefinition === 'boolean') {
-        return featureDefinition;
-    }
-    return Boolean(gl.getExtension(featureDefinition));
-}
-const WEBGL_ALWAYS_FEATURES = ['webgl', 'glsl', 'transform-feedback-webgl'];
-/**
- * Defines luma.gl "feature" names and semantics
- * when value is 'string' it is the name of the extension that enables this feature
- */
-const WEBGL_FEATURES = {
-    'timer-query-webgl': 'EXT_disjoint_timer_query_webgl2',
-    'transform-feedback-webgl': true,
-    // WEBGL1 SUPPORT
-    'texture-blend-float-webgl': 'EXT_float_blend',
-    'float32-filterable-linear-webgl': 'OES_texture_float_linear',
-    'float16-filterable-linear-webgl': 'OES_texture_half_float_linear',
-    'texture-filterable-anisotropic-webgl': 'EXT_texture_filter_anisotropic',
-    // FRAMEBUFFERS, TEXTURES AND RENDERBUFFERS
-    'float32-renderable-webgl': 'EXT_color_buffer_float',
-    'float16-renderable-webgl': 'EXT_color_buffer_half_float',
-};

package/dist/adapter/device-helpers/device-limits.d.ts

@@ -1,50 +0,0 @@
-import type { DeviceLimits } from '@luma.gl/core';
-import { GL } from '@luma.gl/constants';
-/** Populate a WebGPU style device limits */
-export declare function getDeviceLimits(gl: WebGL2RenderingContext): DeviceLimits;
-/** 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];
-    [GL.MAX_TEXTURE_MAX_ANISOTROPY_EXT]: number;
-    [GL.MAX_3D_TEXTURE_SIZE]: number;
-    [GL.MAX_ARRAY_TEXTURE_LAYERS]: 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_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 declare function getWebGLLimits(gl: WebGL2RenderingContext): WebGLLimits;
-//# sourceMappingURL=device-limits.d.ts.map

package/dist/adapter/device-helpers/device-limits.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"device-limits.d.ts","sourceRoot":"","sources":["../../../src/adapter/device-helpers/device-limits.ts"],"names":[],"mappings":"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"}

package/dist/adapter/device-helpers/device-limits.js

@@ -1,92 +0,0 @@
-// luma.gl, MIT license
-// Copyright (c) vis.gl contributors
-import { GL } from '@luma.gl/constants';
-/** Populate a WebGPU style device limits */
-export function getDeviceLimits(gl) {
-    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
-    };
-}
-export function getWebGLLimits(gl) {
-    function get(pname) {
-        return gl.getParameter(pname);
-    }
-    function get2(pname, defaultValue) {
-        return gl.getParameter(pname) || defaultValue;
-    }
-    // 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/dist/adapter/device-helpers/get-device-info.d.ts

@@ -1,4 +0,0 @@
-import { DeviceInfo } from '@luma.gl/core';
-/** @returns strings identifying the GPU vendor and driver. */
-export declare function getDeviceInfo(gl: WebGL2RenderingContext): DeviceInfo;
-//# sourceMappingURL=get-device-info.d.ts.map

package/dist/adapter/device-helpers/get-device-info.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"get-device-info.d.ts","sourceRoot":"","sources":["../../../src/adapter/device-helpers/get-device-info.ts"],"names":[],"mappings":"AAGA,OAAO,EAAC,UAAU,EAAC,MAAM,eAAe,CAAC;AAGzC,8DAA8D;AAC9D,wBAAgB,aAAa,CAAC,EAAE,EAAE,sBAAsB,GAAG,UAAU,CAuCpE"}

package/dist/adapter/device-helpers/get-device-info.js

@@ -1,87 +0,0 @@
-// luma.gl, MIT license
-// Copyright (c) vis.gl contributors
-import { GL } from '@luma.gl/constants';
-/** @returns strings identifying the GPU vendor and driver. */
-export function getDeviceInfo(gl) {
-    // "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');
-    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;
-    // Driver version
-    const version = gl.getParameter(GL.VERSION);
-    // "Sniff" the GPU type and backend from the info. This works best if unmasked info is available.
-    const gpu = identifyGPUVendor(vendor, renderer);
-    const gpuBackend = identifyGPUBackend(vendor, renderer);
-    const gpuType = identifyGPUType(vendor, renderer);
-    // Determine GLSL version
-    // For now, skip parsing of the long version string, just use context type below to deduce version
-    // const version = gl.getParameter(GL.SHADING_LANGUAGE_VERSION) as string;
-    // const shadingLanguageVersion = parseGLSLVersion(version);
-    const shadingLanguage = 'glsl';
-    const shadingLanguageVersion = 300;
-    return {
-        type: 'webgl',
-        gpu,
-        gpuType,
-        gpuBackend,
-        vendor,
-        renderer,
-        version,
-        shadingLanguage,
-        shadingLanguageVersion
-    };
-}
-/** "Sniff" the GPU type from the info. This works best if unmasked info is available. */
-function identifyGPUVendor(vendor, renderer) {
-    if ((/NVIDIA/i.exec(vendor)) || (/NVIDIA/i.exec(renderer))) {
-        return 'nvidia';
-    }
-    if ((/INTEL/i.exec(vendor)) || (/INTEL/i.exec(renderer))) {
-        return 'intel';
-    }
-    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))) {
-        return 'amd';
-    }
-    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, renderer) {
-    if ((/Metal/i.exec(vendor)) || (/Metal/i.exec(renderer))) {
-        return 'metal';
-    }
-    if ((/ANGLE/i.exec(vendor)) || (/ANGLE/i.exec(renderer))) {
-        return 'opengl';
-    }
-    return 'unknown';
-}
-function identifyGPUType(vendor, renderer) {
-    if ((/SwiftShader/i.exec(vendor)) || (/SwiftShader/i.exec(renderer))) {
-        return 'cpu';
-    }
-    const gpuVendor = identifyGPUVendor(vendor, renderer);
-    switch (gpuVendor) {
-        case 'intel':
-            return 'integrated';
-        case 'software':
-            return 'cpu';
-        case 'unknown':
-            return 'unknown';
-        default:
-            return 'discrete';
-    }
-}

package/dist/context/context/context-data.d.ts

@@ -1,14 +0,0 @@
-/**
- * Stores luma.gl specific state associated with a context
- */
-export interface WebGLContextData {
-    _polyfilled: boolean;
-    _extensions: Record<string, any>;
-}
-/**
- * Gets luma.gl specific state from a context
- * @returns context state
- */
-export declare function getContextData(gl: WebGL2RenderingContext): WebGLContextData;
-export declare function initializeExtensions(gl: WebGL2RenderingContext): void;
-//# sourceMappingURL=context-data.d.ts.map

package/dist/context/context/context-data.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"context-data.d.ts","sourceRoot":"","sources":["../../../src/context/context/context-data.ts"],"names":[],"mappings":"AAGA;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B,WAAW,EAAE,OAAO,CAAC;IACrB,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;CAClC;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAAC,EAAE,EAAE,sBAAsB,GAAG,gBAAgB,CAc3E;AAED,wBAAgB,oBAAoB,CAAC,EAAE,EAAE,sBAAsB,GAAG,IAAI,CAYrE"}

package/dist/context/context/context-data.js

@@ -1,33 +0,0 @@
-// luma.gl, MIT license
-// Copyright (c) vis.gl contributors
-/**
- * Gets luma.gl specific state from a context
- * @returns context state
- */
-export function getContextData(gl) {
-    // @ts-expect-error
-    const luma = gl.luma;
-    if (!luma) {
-        const contextState = {
-            _polyfilled: false,
-            _extensions: {}
-        };
-        // @ts-expect-error
-        gl.luma = contextState;
-    }
-    // @ts-expect-error
-    return gl.luma;
-}
-export function initializeExtensions(gl) {
-    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;
-        }
-    }
-}

package/dist/context/context/create-browser-context.d.ts

@@ -1,35 +0,0 @@
-/**
- * ContextProps
- * @param onContextLost
- * @param onContextRestored
- *
- * BROWSER CONTEXT PARAMETERS
- * @param debug Instrument context (at the expense of performance).
- * @param alpha Default render target has an alpha buffer.
- * @param depth Default render target has a depth buffer of at least 16 bits.
- * @param stencil Default render target has a stencil buffer of at least 8 bits.
- * @param antialias Boolean that indicates whether or not to perform anti-aliasing.
- * @param premultipliedAlpha Boolean that indicates that the page compositor will assume the drawing buffer contains colors with pre-multiplied alpha.
- * @param preserveDrawingBuffer Default render target buffers will not be automatically cleared and will preserve their values until cleared or overwritten
- * @param failIfMajorPerformanceCaveat Do not create if the system performance is low.
- */
-type ContextProps = {
-    onContextLost?: (event: Event) => void;
-    onContextRestored?: (event: Event) => void;
-    alpha?: boolean;
-    desynchronized?: boolean;
-    antialias?: boolean;
-    depth?: boolean;
-    failIfMajorPerformanceCaveat?: boolean;
-    powerPreference?: 'default' | 'high-performance' | 'low-power';
-    premultipliedAlpha?: boolean;
-    preserveDrawingBuffer?: boolean;
-};
-/**
- * Create a WebGL context for a canvas
- * Note calling this multiple time on the same canvas does return the same context
- * @param canvas A canvas element or offscreen canvas
- */
-export declare function createBrowserContext(canvas: HTMLCanvasElement | OffscreenCanvas, props: ContextProps): WebGL2RenderingContext;
-export {};
-//# sourceMappingURL=create-browser-context.d.ts.map

package/dist/context/context/create-browser-context.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"create-browser-context.d.ts","sourceRoot":"","sources":["../../../src/context/context/create-browser-context.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;GAcG;AACH,KAAK,YAAY,GAAG;IAClB,aAAa,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC;IACvC,iBAAiB,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC;IAC3C,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,4BAA4B,CAAC,EAAE,OAAO,CAAC;IACvC,eAAe,CAAC,EAAE,SAAS,GAAG,kBAAkB,GAAG,WAAW,CAAC;IAC/D,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B,qBAAqB,CAAC,EAAE,OAAO,CAAC;CACjC,CAAC;AAUF;;;;GAIG;AACH,wBAAgB,oBAAoB,CAClC,MAAM,EAAE,iBAAiB,GAAG,eAAe,EAC3C,KAAK,EAAE,YAAY,GAClB,sBAAsB,CA+CxB"}