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

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

@@ -1,71 +1,87 @@
-import { isWebGL2 } from "../../context/context/webgl-checks.js";
+// 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) {
-  const vendorMasked = gl.getParameter(7936);
-  const rendererMasked = gl.getParameter(7937);
-  const ext = gl.getExtension('WEBGL_debug_renderer_info');
-  const vendorUnmasked = gl.getParameter(ext ? ext.UNMASKED_VENDOR_WEBGL : 7936);
-  const rendererUnmasked = gl.getParameter(ext ? ext.UNMASKED_RENDERER_WEBGL : 7937);
-  const vendor = vendorUnmasked || vendorMasked;
-  const renderer = rendererUnmasked || rendererMasked;
-  const version = gl.getParameter(7938);
-  const gpu = identifyGPUVendor(vendor, renderer);
-  const gpuBackend = identifyGPUBackend(vendor, renderer);
-  const gpuType = identifyGPUType(vendor, renderer);
-  const shadingLanguage = 'glsl';
-  const shadingLanguageVersion = isWebGL2(gl) ? 300 : 100;
-  return {
-    type: isWebGL2(gl) ? 'webgl2' : 'webgl',
-    gpu,
-    gpuType,
-    gpuBackend,
-    vendor,
-    renderer,
-    version,
-    shadingLanguage,
-    shadingLanguageVersion
-  };
+    // "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';
+    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';
+    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';
-  }
+    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';
+    }
 }
-//# sourceMappingURL=get-device-info.js.map

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

@@ -0,0 +1,19 @@
+import { DeviceFeature, DeviceFeatures } from '@luma.gl/core';
+import { GLExtensions } from '@luma.gl/constants';
+/**
+ * WebGL extensions exposed as luma.gl features
+ * To minimize GL log noise and improve performance, this class ensures that
+ * - WebGL extensions are not queried until the corresponding feature is checked.
+ * - WebGL extensions are only queried once.
+ */
+export declare class WebGLDeviceFeatures extends DeviceFeatures {
+    protected gl: WebGL2RenderingContext;
+    protected extensions: GLExtensions;
+    protected testedFeatures: Set<DeviceFeature>;
+    constructor(gl: WebGL2RenderingContext, extensions: GLExtensions);
+    [Symbol.iterator](): IterableIterator<DeviceFeature>;
+    has(feature: DeviceFeature): boolean;
+    /** Extract all WebGL features */
+    protected getWebGLFeature(feature: DeviceFeature): boolean;
+}
+//# sourceMappingURL=webgl-device-features.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"webgl-device-features.d.ts","sourceRoot":"","sources":["../../../src/adapter/device-helpers/webgl-device-features.ts"],"names":[],"mappings":"AAOA,OAAO,EAAC,aAAa,EAAE,cAAc,EAAC,MAAM,eAAe,CAAC;AAC5D,OAAO,EAAC,YAAY,EAAC,MAAM,oBAAoB,CAAC;AA8BhD;;;;;GAKG;AACH,qBAAa,mBAAoB,SAAQ,cAAc;IACrD,SAAS,CAAC,EAAE,EAAE,sBAAsB,CAAC;IACrC,SAAS,CAAC,UAAU,EAAE,YAAY,CAAC;IACnC,SAAS,CAAC,cAAc,qBAA4B;gBAExC,EAAE,EAAE,sBAAsB,EAAE,UAAU,EAAE,YAAY;IAS/D,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,gBAAgB,CAAC,aAAa,CAAC;IAc5C,GAAG,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO;IAiB7C,iCAAiC;IACjC,SAAS,CAAC,eAAe,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO;CAU3D"}

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

@@ -0,0 +1,86 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+// Feature detection for WebGL
+// Provides a function that enables simple checking of which WebGL features are
+import { DeviceFeatures } from '@luma.gl/core';
+import { getWebGLExtension } from "../../context/helpers/webgl-extensions.js";
+import { isTextureFeature, checkTextureFeature } from "../converters/texture-formats.js";
+import { TEXTURE_FEATURES } from "../converters/texture-formats.js";
+/**
+ * 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 = {
+    // optional WebGPU features
+    'depth-clip-control': 'EXT_depth_clamp', // TODO these seem subtly different
+    // 'timestamp-query' // GPUQueryType "timestamp-query"
+    // "indirect-first-instance"
+    // Textures are handled by getTextureFeatures()
+    // 'depth24unorm-stencil8' // GPUTextureFormat 'depth24unorm-stencil8'
+    // 'depth32float-stencil8' // GPUTextureFormat 'depth32float-stencil8'
+    // optional WebGL features
+    'timer-query-webgl': 'EXT_disjoint_timer_query_webgl2',
+    'compilation-status-async-webgl': 'KHR_parallel_shader_compile',
+    'polygon-mode-webgl': 'WEBGL_polygon_mode',
+    'provoking-vertex-webgl': 'WEBGL_provoking_vertex',
+    'shader-clip-cull-distance-webgl': 'WEBGL_clip_cull_distance',
+    'shader-noperspective-interpolation-webgl': 'NV_shader_noperspective_interpolation',
+    'shader-conservative-depth-webgl': 'EXT_conservative_depth'
+    // Textures are handled by getTextureFeatures()
+};
+/**
+ * WebGL extensions exposed as luma.gl features
+ * To minimize GL log noise and improve performance, this class ensures that
+ * - WebGL extensions are not queried until the corresponding feature is checked.
+ * - WebGL extensions are only queried once.
+ */
+export class WebGLDeviceFeatures extends DeviceFeatures {
+    gl;
+    extensions;
+    testedFeatures = new Set();
+    constructor(gl, extensions) {
+        super();
+        this.gl = gl;
+        this.extensions = extensions;
+        // TODO - is this really needed?
+        // Enable EXT_float_blend first: https://developer.mozilla.org/en-US/docs/Web/API/EXT_float_blend
+        getWebGLExtension(gl, 'EXT_color_buffer_float', extensions);
+    }
+    *[Symbol.iterator]() {
+        for (const feature of Object.keys(WEBGL_FEATURES)) {
+            if (this.has(feature)) {
+                yield feature;
+            }
+        }
+        for (const feature of Object.keys(TEXTURE_FEATURES)) {
+            if (this.has(feature)) {
+                yield feature;
+            }
+        }
+        return [];
+    }
+    has(feature) {
+        // We have already tested this feature
+        if (!this.testedFeatures.has(feature)) {
+            this.testedFeatures.add(feature);
+            // Check the feature once
+            if (isTextureFeature(feature) && checkTextureFeature(this.gl, feature, this.extensions)) {
+                this.features.add(feature);
+            }
+            if (this.getWebGLFeature(feature)) {
+                this.features.add(feature);
+            }
+        }
+        return this.features.has(feature);
+    }
+    /** Extract all WebGL features */
+    getWebGLFeature(feature) {
+        const featureInfo = WEBGL_FEATURES[feature];
+        // string value requires checking the corresponding WebGL extension
+        const isSupported = typeof featureInfo === 'string'
+            ? Boolean(getWebGLExtension(this.gl, featureInfo, this.extensions))
+            : Boolean(featureInfo);
+        return isSupported;
+    }
+}

package/dist/adapter/device-helpers/webgl-device-info.d.ts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"webgl-device-info.d.ts","sourceRoot":"","sources":["../../../src/adapter/device-helpers/webgl-device-info.ts"],"names":[],"mappings":"AAIA,OAAO,EAAC,UAAU,EAAC,MAAM,eAAe,CAAC;AACzC,OAAO,EAAK,YAAY,EAAC,MAAM,oBAAoB,CAAC;AAGpD,8DAA8D;AAC9D,wBAAgB,aAAa,CAAC,EAAE,EAAE,sBAAsB,EAAE,UAAU,EAAE,YAAY,GAAG,UAAU,CAwC9F"}

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

@@ -0,0 +1,90 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+import { GL } from '@luma.gl/constants';
+import { getWebGLExtension } from "../../context/helpers/webgl-extensions.js";
+/** @returns strings identifying the GPU vendor and driver. */
+export function getDeviceInfo(gl, extensions) {
+    // "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/
+    getWebGLExtension(gl, 'WEBGL_debug_renderer_info', extensions);
+    const ext = extensions.WEBGL_debug_renderer_info;
+    const vendorUnmasked = gl.getParameter(ext ? ext.UNMASKED_VENDOR_WEBGL : GL.VENDOR);
+    const rendererUnmasked = gl.getParameter(ext ? ext.UNMASKED_RENDERER_WEBGL : GL.RENDERER);
+    const vendor = vendorUnmasked || vendorMasked;
+    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/adapter/device-helpers/webgl-device-limits.d.ts

@@ -0,0 +1,35 @@
+import { DeviceLimits } from '@luma.gl/core';
+import { GL } from '@luma.gl/constants';
+export declare class WebGLDeviceLimits extends DeviceLimits {
+    get maxTextureDimension1D(): number;
+    get maxTextureDimension2D(): number;
+    get maxTextureDimension3D(): number;
+    get maxTextureArrayLayers(): number;
+    get maxBindGroups(): number;
+    get maxDynamicUniformBuffersPerPipelineLayout(): number;
+    get maxDynamicStorageBuffersPerPipelineLayout(): number;
+    get maxSampledTexturesPerShaderStage(): number;
+    get maxSamplersPerShaderStage(): number;
+    get maxStorageBuffersPerShaderStage(): number;
+    get maxStorageTexturesPerShaderStage(): number;
+    get maxUniformBuffersPerShaderStage(): number;
+    get maxUniformBufferBindingSize(): number;
+    get maxStorageBufferBindingSize(): number;
+    get minUniformBufferOffsetAlignment(): number;
+    get minStorageBufferOffsetAlignment(): number;
+    get maxVertexBuffers(): number;
+    get maxVertexAttributes(): number;
+    get maxVertexBufferArrayStride(): number;
+    get maxInterStageShaderComponents(): number;
+    get maxComputeWorkgroupStorageSize(): number;
+    get maxComputeInvocationsPerWorkgroup(): number;
+    get maxComputeWorkgroupSizeX(): number;
+    get maxComputeWorkgroupSizeY(): number;
+    get maxComputeWorkgroupSizeZ(): number;
+    get maxComputeWorkgroupsPerDimension(): number;
+    protected gl: WebGL2RenderingContext;
+    protected limits: Partial<Record<GL, number>>;
+    constructor(gl: WebGL2RenderingContext);
+    protected getParameter(parameter: GL): number;
+}
+//# sourceMappingURL=webgl-device-limits.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"webgl-device-limits.d.ts","sourceRoot":"","sources":["../../../src/adapter/device-helpers/webgl-device-limits.ts"],"names":[],"mappings":"AAIA,OAAO,EAAC,YAAY,EAAC,MAAM,eAAe,CAAC;AAC3C,OAAO,EAAC,EAAE,EAAC,MAAM,oBAAoB,CAAC;AAGtC,qBAAa,iBAAkB,SAAQ,YAAY;IACjD,IAAI,qBAAqB,WAAgB;IACzC,IAAI,qBAAqB,WAAqD;IAC9E,IAAI,qBAAqB,WAAwD;IACjF,IAAI,qBAAqB,WAA6D;IACtF,IAAI,aAAa,WAAgB;IACjC,IAAI,yCAAyC,WAAgB;IAC7D,IAAI,yCAAyC,WAAgB;IAC7D,IAAI,gCAAgC,WAAmE;IACvG,IAAI,yBAAyB,WAAqE;IAClG,IAAI,+BAA+B,WAAgB;IACnD,IAAI,gCAAgC,WAAgB;IACpD,IAAI,+BAA+B,WAAgE;IACnG,IAAI,2BAA2B,WAA2D;IAC1F,IAAI,2BAA2B,WAAgB;IAC/C,IAAI,+BAA+B,WAAoE;IACvG,IAAI,+BAA+B,WAAgB;IACnD,IAAI,gBAAgB,WAAiB;IACrC,IAAI,mBAAmB,WAAuD;IAC9E,IAAI,0BAA0B,WAAmB;IACjD,IAAI,6BAA6B,WAA2D;IAC5F,IAAI,8BAA8B,WAAgB;IAClD,IAAI,iCAAiC,WAAgB;IACrD,IAAI,wBAAwB,WAAgB;IAC5C,IAAI,wBAAwB,WAAgB;IAC5C,IAAI,wBAAwB,WAAgB;IAC5C,IAAI,gCAAgC,WAAe;IAInD,SAAS,CAAC,EAAE,EAAE,sBAAsB,CAAC;IACrC,SAAS,CAAC,MAAM,EAAE,OAAO,CAAC,MAAM,CAAC,EAAE,EAAE,MAAM,CAAC,CAAC,CAAM;gBAEvC,EAAE,EAAE,sBAAsB;IAKtC,SAAS,CAAC,YAAY,CAAC,SAAS,EAAE,EAAE,GAAG,MAAM;CAM9C"}

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

@@ -0,0 +1,47 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+import { DeviceLimits } from '@luma.gl/core';
+import { GL } from '@luma.gl/constants';
+// prettier-ignore
+export class WebGLDeviceLimits extends DeviceLimits {
+    get maxTextureDimension1D() { return 0; } // WebGL does not support 1D textures
+    get maxTextureDimension2D() { return this.getParameter(GL.MAX_TEXTURE_SIZE); }
+    get maxTextureDimension3D() { return this.getParameter(GL.MAX_3D_TEXTURE_SIZE); }
+    get maxTextureArrayLayers() { return this.getParameter(GL.MAX_ARRAY_TEXTURE_LAYERS); }
+    get maxBindGroups() { return 0; }
+    get maxDynamicUniformBuffersPerPipelineLayout() { return 0; } // TBD
+    get maxDynamicStorageBuffersPerPipelineLayout() { return 0; } // TBD
+    get maxSampledTexturesPerShaderStage() { return this.getParameter(GL.MAX_VERTEX_TEXTURE_IMAGE_UNITS); } // ) TBD
+    get maxSamplersPerShaderStage() { return this.getParameter(GL.MAX_COMBINED_TEXTURE_IMAGE_UNITS); }
+    get maxStorageBuffersPerShaderStage() { return 0; } // TBD
+    get maxStorageTexturesPerShaderStage() { return 0; } // TBD
+    get maxUniformBuffersPerShaderStage() { return this.getParameter(GL.MAX_UNIFORM_BUFFER_BINDINGS); }
+    get maxUniformBufferBindingSize() { return this.getParameter(GL.MAX_UNIFORM_BLOCK_SIZE); }
+    get maxStorageBufferBindingSize() { return 0; }
+    get minUniformBufferOffsetAlignment() { return this.getParameter(GL.UNIFORM_BUFFER_OFFSET_ALIGNMENT); }
+    get minStorageBufferOffsetAlignment() { return 0; }
+    get maxVertexBuffers() { return 16; } // WebGL 2 supports 16 buffers, see https://github.com/gpuweb/gpuweb/issues/4284
+    get maxVertexAttributes() { return this.getParameter(GL.MAX_VERTEX_ATTRIBS); }
+    get maxVertexBufferArrayStride() { return 2048; } // TBD, this is just the default value from WebGPU
+    get maxInterStageShaderComponents() { return this.getParameter(GL.MAX_VARYING_COMPONENTS); }
+    get maxComputeWorkgroupStorageSize() { return 0; } // WebGL does not support compute shaders
+    get maxComputeInvocationsPerWorkgroup() { return 0; } // WebGL does not support compute shaders
+    get maxComputeWorkgroupSizeX() { return 0; } // WebGL does not support compute shaders
+    get maxComputeWorkgroupSizeY() { return 0; } // WebGL does not support compute shaders
+    get maxComputeWorkgroupSizeZ() { return 0; } // WebGL does not support compute shaders
+    get maxComputeWorkgroupsPerDimension() { return 0; } // WebGL does not support compute shaders
+    // PRIVATE
+    gl;
+    limits = {};
+    constructor(gl) {
+        super();
+        this.gl = gl;
+    }
+    getParameter(parameter) {
+        if (this.limits[parameter] === undefined) {
+            this.limits[parameter] = this.gl.getParameter(parameter);
+        }
+        return this.limits[parameter];
+    }
+}

package/dist/adapter/helpers/decode-webgl-types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"decode-webgl-types.d.ts","sourceRoot":"","sources":["../../../src/adapter/helpers/decode-webgl-types.ts"],"names":[],"mappings":"AAGA,OAAO,EAAC,iBAAiB,EAAE,mBAAmB,EAAE,YAAY,EAAC,MAAM,eAAe,CAAC;AACnF,OAAO,EAAC,EAAE,EAAE,aAAa,EAAiB,eAAe,EAAE,UAAU,EAAC,MAAM,oBAAoB,CAAC;AAEjG,0CAA0C;AAC1C,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO,CAE7D;AA2DD,4FAA4F;AAC5F,wBAAgB,mBAAmB,CACjC,aAAa,EAAE,EAAE,GAChB;IAAC,MAAM,EAAE,iBAAiB,CAAC;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,UAAU,CAAA;CAAC,CAOrE;AAED,4FAA4F;AAC5F,wBAAgB,qBAAqB,CAAC,eAAe,EAAE,EAAE,GAAG;IAC1D,aAAa,EAAE,mBAAmB,CAAC;IACnC,YAAY,EAAE,YAAY,CAAC;IAC3B,UAAU,EAAE,MAAM,CAAC;CAEpB,CASA;AAED,0FAA0F;AAC1F,wBAAgB,4BAA4B,CAC1C,mBAAmB,EAAE,eAAe,GACnC;IAAC,IAAI,EAAE,UAAU,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAAC,GAAG,IAAI,CAO/C;AAED,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,EAAE,EAAE,UAAU,KAAA,GAAG;IAAC,MAAM,EAAE,UAAU,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAC,GAAG,IAAI,CAkBtG"}
+{"version":3,"file":"decode-webgl-types.d.ts","sourceRoot":"","sources":["../../../src/adapter/helpers/decode-webgl-types.ts"],"names":[],"mappings":"AAIA,OAAO,EAAC,iBAAiB,EAAE,mBAAmB,EAAE,YAAY,EAAC,MAAM,eAAe,CAAC;AACnF,OAAO,EAAC,EAAE,EAAE,aAAa,EAAiB,eAAe,EAAE,UAAU,EAAC,MAAM,oBAAoB,CAAC;AAEjG,0CAA0C;AAC1C,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO,CAE7D;AA2DD,4FAA4F;AAC5F,wBAAgB,mBAAmB,CAAC,aAAa,EAAE,EAAE,GAAG;IACtD,MAAM,EAAE,iBAAiB,CAAC;IAC1B,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,UAAU,CAAC;CACpB,CAOA;AAED,4FAA4F;AAC5F,wBAAgB,qBAAqB,CAAC,eAAe,EAAE,EAAE,GAAG;IAC1D,aAAa,EAAE,mBAAmB,CAAC;IACnC,YAAY,EAAE,YAAY,CAAC;IAC3B,UAAU,EAAE,MAAM,CAAC;CAEpB,CASA;AAED,0FAA0F;AAC1F,wBAAgB,4BAA4B,CAC1C,mBAAmB,EAAE,eAAe,GACnC;IAAC,IAAI,EAAE,UAAU,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAAC,GAAG,IAAI,CAO/C;AAED,wBAAgB,sBAAsB,CACpC,IAAI,EAAE,EAAE,EACR,UAAU,KAAA,GACT;IAAC,MAAM,EAAE,UAAU,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAC,GAAG,IAAI,CAkB3C"}

package/dist/adapter/helpers/decode-webgl-types.js

@@ -1,89 +1,101 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+import { GL } from '@luma.gl/constants';
+/** Check is uniform is of sampler type */
 export function isSamplerUniform(type) {
-  return SAMPLER_TYPES.includes(type);
+    return SAMPLER_TYPES.includes(type);
 }
-const SAMPLER_TYPES = [35678, 35680, 35679, 35682, 36289, 36292, 36293, 36298, 36299, 36300, 36303, 36306, 36307, 36308, 36311];
+const SAMPLER_TYPES = [
+    GL.SAMPLER_2D,
+    GL.SAMPLER_CUBE,
+    GL.SAMPLER_3D,
+    GL.SAMPLER_2D_SHADOW,
+    GL.SAMPLER_2D_ARRAY,
+    GL.SAMPLER_2D_ARRAY_SHADOW,
+    GL.SAMPLER_CUBE_SHADOW,
+    GL.INT_SAMPLER_2D,
+    GL.INT_SAMPLER_3D,
+    GL.INT_SAMPLER_CUBE,
+    GL.INT_SAMPLER_2D_ARRAY,
+    GL.UNSIGNED_INT_SAMPLER_2D,
+    GL.UNSIGNED_INT_SAMPLER_3D,
+    GL.UNSIGNED_INT_SAMPLER_CUBE,
+    GL.UNSIGNED_INT_SAMPLER_2D_ARRAY
+];
+// Composite types table
 const COMPOSITE_GL_TYPES = {
-  [5126]: [5126, 1, 'float', 'f32', 'float32'],
-  [35664]: [5126, 2, 'vec2', 'vec2<f32>', 'float32x2'],
-  [35665]: [5126, 3, 'vec3', 'vec3<f32>', 'float32x3'],
-  [35666]: [5126, 4, 'vec4', 'vec4<f32>', 'float32x4'],
-  [5124]: [5124, 1, 'int', 'i32', 'sint32'],
-  [35667]: [5124, 2, 'ivec2', 'vec2<i32>', 'sint32x2'],
-  [35668]: [5124, 3, 'ivec3', 'vec3<i32>', 'sint32x3'],
-  [35669]: [5124, 4, 'ivec4', 'vec4<i32>', 'sint32x4'],
-  [5125]: [5125, 1, 'uint', 'u32', 'uint32'],
-  [36294]: [5125, 2, 'uvec2', 'vec2<u32>', 'uint32x2'],
-  [36295]: [5125, 3, 'uvec3', 'vec3<u32>', 'uint32x3'],
-  [36296]: [5125, 4, 'uvec4', 'vec4<u32>', 'uint32x4'],
-  [35670]: [5126, 1, 'bool', 'f32', 'float32'],
-  [35671]: [5126, 2, 'bvec2', 'vec2<f32>', 'float32x2'],
-  [35672]: [5126, 3, 'bvec3', 'vec3<f32>', 'float32x3'],
-  [35673]: [5126, 4, 'bvec4', 'vec4<f32>', 'float32x4'],
-  [35674]: [5126, 8, 'mat2', 'mat2x2<f32>'],
-  [35685]: [5126, 8, 'mat2x3', 'mat2x3<f32>'],
-  [35686]: [5126, 8, 'mat2x4', 'mat2x4<f32>'],
-  [35687]: [5126, 12, 'mat3x2', 'mat3x2<f32>'],
-  [35675]: [5126, 12, 'mat3', 'mat3x3<f32>'],
-  [35688]: [5126, 12, 'mat3x4', 'mat3x4<f32>'],
-  [35689]: [5126, 16, 'mat4x2', 'mat4x2<f32>'],
-  [35690]: [5126, 16, 'mat4x3', 'mat4x3<f32>'],
-  [35676]: [5126, 16, 'mat4', 'mat4x4<f32>']
+    [GL.FLOAT]: [GL.FLOAT, 1, 'float', 'f32', 'float32'],
+    [GL.FLOAT_VEC2]: [GL.FLOAT, 2, 'vec2', 'vec2<f32>', 'float32x2'],
+    [GL.FLOAT_VEC3]: [GL.FLOAT, 3, 'vec3', 'vec3<f32>', 'float32x3'],
+    [GL.FLOAT_VEC4]: [GL.FLOAT, 4, 'vec4', 'vec4<f32>', 'float32x4'],
+    [GL.INT]: [GL.INT, 1, 'int', 'i32', 'sint32'],
+    [GL.INT_VEC2]: [GL.INT, 2, 'ivec2', 'vec2<i32>', 'sint32x2'],
+    [GL.INT_VEC3]: [GL.INT, 3, 'ivec3', 'vec3<i32>', 'sint32x3'],
+    [GL.INT_VEC4]: [GL.INT, 4, 'ivec4', 'vec4<i32>', 'sint32x4'],
+    [GL.UNSIGNED_INT]: [GL.UNSIGNED_INT, 1, 'uint', 'u32', 'uint32'],
+    [GL.UNSIGNED_INT_VEC2]: [GL.UNSIGNED_INT, 2, 'uvec2', 'vec2<u32>', 'uint32x2'],
+    [GL.UNSIGNED_INT_VEC3]: [GL.UNSIGNED_INT, 3, 'uvec3', 'vec3<u32>', 'uint32x3'],
+    [GL.UNSIGNED_INT_VEC4]: [GL.UNSIGNED_INT, 4, 'uvec4', 'vec4<u32>', 'uint32x4'],
+    [GL.BOOL]: [GL.FLOAT, 1, 'bool', 'f32', 'float32'],
+    [GL.BOOL_VEC2]: [GL.FLOAT, 2, 'bvec2', 'vec2<f32>', 'float32x2'],
+    [GL.BOOL_VEC3]: [GL.FLOAT, 3, 'bvec3', 'vec3<f32>', 'float32x3'],
+    [GL.BOOL_VEC4]: [GL.FLOAT, 4, 'bvec4', 'vec4<f32>', 'float32x4'],
+    // TODO - are sizes/components below correct?
+    [GL.FLOAT_MAT2]: [GL.FLOAT, 8, 'mat2', 'mat2x2<f32>'], // 4
+    [GL.FLOAT_MAT2x3]: [GL.FLOAT, 8, 'mat2x3', 'mat2x3<f32>'], // 6
+    [GL.FLOAT_MAT2x4]: [GL.FLOAT, 8, 'mat2x4', 'mat2x4<f32>'], // 8
+    [GL.FLOAT_MAT3x2]: [GL.FLOAT, 12, 'mat3x2', 'mat3x2<f32>'], // 6
+    [GL.FLOAT_MAT3]: [GL.FLOAT, 12, 'mat3', 'mat3x3<f32>'], // 9
+    [GL.FLOAT_MAT3x4]: [GL.FLOAT, 12, 'mat3x4', 'mat3x4<f32>'], // 12
+    [GL.FLOAT_MAT4x2]: [GL.FLOAT, 16, 'mat4x2', 'mat4x2<f32>'], // 8
+    [GL.FLOAT_MAT4x3]: [GL.FLOAT, 16, 'mat4x3', 'mat4x3<f32>'], // 12
+    [GL.FLOAT_MAT4]: [GL.FLOAT, 16, 'mat4', 'mat4x4<f32>'] // 16
 };
+/** Decomposes a composite type (GL.VEC3) into a basic type (GL.FLOAT) and components (3) */
 export function decodeGLUniformType(glUniformType) {
-  const typeAndSize = COMPOSITE_GL_TYPES[glUniformType];
-  if (!typeAndSize) {
-    throw new Error('uniform');
-  }
-  const [glType, components,, format] = typeAndSize;
-  return {
-    format,
-    components,
-    glType
-  };
+    const typeAndSize = COMPOSITE_GL_TYPES[glUniformType];
+    if (!typeAndSize) {
+        throw new Error('uniform');
+    }
+    const [glType, components, , format] = typeAndSize;
+    return { format, components, glType };
 }
+/** Decomposes a composite type (GL.VEC3) into a basic type (GL.FLOAT) and components (3) */
 export function decodeGLAttributeType(glAttributeType) {
-  const typeAndSize = COMPOSITE_GL_TYPES[glAttributeType];
-  if (!typeAndSize) {
-    throw new Error('attribute');
-  }
-  const [, components,, shaderType, vertexFormat] = typeAndSize;
-  const attributeType = shaderType;
-  return {
-    attributeType,
-    vertexFormat,
-    components
-  };
+    const typeAndSize = COMPOSITE_GL_TYPES[glAttributeType];
+    if (!typeAndSize) {
+        throw new Error('attribute');
+    }
+    const [, components, , shaderType, vertexFormat] = typeAndSize;
+    // TODO sanity - if (shaderType.startsWith('mat' ...))
+    const attributeType = shaderType;
+    return { attributeType, vertexFormat, components }; // , glType};
 }
+/** Decomposes a composite type GL.VEC3 into a basic type (GL.FLOAT) and components (3) */
 export function decomposeCompositeGLDataType(compositeGLDataType) {
-  const typeAndSize = COMPOSITE_GL_TYPES[compositeGLDataType];
-  if (!typeAndSize) {
-    return null;
-  }
-  const [type, components] = typeAndSize;
-  return {
-    type,
-    components
-  };
+    const typeAndSize = COMPOSITE_GL_TYPES[compositeGLDataType];
+    if (!typeAndSize) {
+        return null;
+    }
+    const [type, components] = typeAndSize;
+    return { type, components };
 }
 export function getCompositeGLDataType(type, components) {
-  switch (type) {
-    case 5120:
-    case 5121:
-    case 5122:
-    case 5123:
-      type = 5126;
-      break;
-    default:
-  }
-  for (const glType in COMPOSITE_GL_TYPES) {
-    const [compType, compComponents, name] = COMPOSITE_GL_TYPES[glType];
-    if (compType === type && compComponents === components) {
-      return {
-        glType: Number(glType),
-        name
-      };
+    switch (type) {
+        case GL.BYTE:
+        case GL.UNSIGNED_BYTE:
+        case GL.SHORT:
+        case GL.UNSIGNED_SHORT:
+            type = GL.FLOAT;
+            break;
+        default:
+    }
+    for (const glType in COMPOSITE_GL_TYPES) {
+        const [compType, compComponents, name] = COMPOSITE_GL_TYPES[glType];
+        if (compType === type && compComponents === components) {
+            return { glType: Number(glType), name };
+        }
     }
-  }
-  return null;
+    return null;
 }
-//# sourceMappingURL=decode-webgl-types.js.map