@luma.gl/webgl 9.0.0-alpha.9 → 9.0.0-beta.10

package/dist/adapter/converters/vertex-formats.d.ts

@@ -1,4 +1,10 @@
-import GL from '@luma.gl/constants';
-import { VertexFormat } from '@luma.gl/api';
-export declare function getVertexFormat(type: GL, components: number): VertexFormat;
+import { GL } from '@luma.gl/constants';
+import { VertexFormat, VertexType } from '@luma.gl/core';
+type GLDataType = GL.UNSIGNED_BYTE | GL.BYTE | GL.UNSIGNED_SHORT | GL.SHORT | GL.UNSIGNED_INT | GL.INT | GL.HALF_FLOAT | GL.FLOAT;
+/** Get vertex format from GL constants */
+export declare function getVertexFormatFromGL(type: GLDataType, components: 1 | 2 | 3 | 4): VertexFormat;
+/** Get data type from GL constants */
+export declare function getVertexTypeFromGL(type: GLDataType, normalized?: boolean): VertexType;
+export declare function getGLFromVertexType(dataType: VertexType): GL.UNSIGNED_BYTE | GL.BYTE | GL.UNSIGNED_SHORT | GL.SHORT | GL.UNSIGNED_INT | GL.INT | GL.HALF_FLOAT | GL.FLOAT;
+export {};
 //# sourceMappingURL=vertex-formats.d.ts.map

package/dist/adapter/converters/vertex-formats.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"vertex-formats.d.ts","sourceRoot":"","sources":["../../../src/adapter/converters/vertex-formats.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,oBAAoB,CAAC;AACpC,OAAO,EAAC,YAAY,EAAC,MAAM,cAAc,CAAC;AAE1C,wBAAgB,eAAe,CAAC,IAAI,EAAE,EAAE,EAAE,UAAU,EAAE,MAAM,GAAG,YAAY,CAQ1E"}
+{"version":3,"file":"vertex-formats.d.ts","sourceRoot":"","sources":["../../../src/adapter/converters/vertex-formats.ts"],"names":[],"mappings":"AAIA,OAAO,EAAC,EAAE,EAAC,MAAM,oBAAoB,CAAC;AACtC,OAAO,EAAC,YAAY,EAAE,UAAU,EAAC,MAAM,eAAe,CAAC;AAEvD,KAAK,UAAU,GACX,EAAE,CAAC,aAAa,GAChB,EAAE,CAAC,IAAI,GACP,EAAE,CAAC,cAAc,GACjB,EAAE,CAAC,KAAK,GACR,EAAE,CAAC,YAAY,GACf,EAAE,CAAC,GAAG,GACN,EAAE,CAAC,UAAU,GACb,EAAE,CAAC,KAAK,CAAC;AAEb,0CAA0C;AAC1C,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,UAAU,EAAE,UAAU,EAAE,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,YAAY,CAa/F;AAED,sCAAsC;AACtC,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,UAAU,EAAE,UAAU,UAAQ,GAAG,UAAU,CAepF;AAED,wBAAgB,mBAAmB,CACjC,QAAQ,EAAE,UAAU,GAElB,EAAE,CAAC,aAAa,GAChB,EAAE,CAAC,IAAI,GACP,EAAE,CAAC,cAAc,GACjB,EAAE,CAAC,KAAK,GACR,EAAE,CAAC,YAAY,GACf,EAAE,CAAC,GAAG,GACN,EAAE,CAAC,UAAU,GACb,EAAE,CAAC,KAAK,CAqBX"}

package/dist/adapter/converters/vertex-formats.js

@@ -1,35 +1,58 @@
-import GL from '@luma.gl/constants';
-export function getVertexFormat(type, components) {
-  const base = getDataFormat(type);
-
-  switch (components) {
-    case 1:
-      return base;
-
-    case 2:
-      return "".concat(base, "x2");
-
-    case 3:
-      return "".concat(base, "x3");
-
-    case 4:
-      return "".concat(base, "x4");
-  }
+// luma.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+import { GL } from '@luma.gl/constants';
+/** Get vertex format from GL constants */
+export function getVertexFormatFromGL(type, components) {
+    const base = getVertexTypeFromGL(type);
+    // prettier-ignore
+    switch (components) {
+        // @ts-expect-error TODO deal with lack of formats
+        case 1: return base;
+        case 2: return `${base}x2`;
+        // @ts-expect-error TODO deal with lack of formats
+        case 3: return `${base}x3`;
+        case 4: return `${base}x4`;
+    }
+    // @ts-ignore unreachable
+    throw new Error(String(components));
 }
-
-function getDataFormat(type) {
-  switch (type) {
-    case GL.INT:
-      return 'sint32';
-
-    case GL.UNSIGNED_INT:
-      return 'uint32';
-
-    case GL.FLOAT:
-      return 'float32';
-
-    default:
-      throw new Error(String(type));
-  }
+/** Get data type from GL constants */
+export function getVertexTypeFromGL(type, normalized = false) {
+    // prettier-ignore
+    switch (type) {
+        // WebGPU does not support normalized 32 bit integer attributes
+        case 5124: return normalized ? 'sint32' : 'sint32';
+        case 5125: return normalized ? 'uint32' : 'uint32';
+        case 5122: return normalized ? 'sint16' : 'unorm16';
+        case 5123: return normalized ? 'uint16' : 'unorm16';
+        case 5120: return normalized ? 'sint8' : 'snorm16';
+        case 5121: return normalized ? 'uint8' : 'unorm8';
+        case 5126: return 'float32';
+        case 5131: return 'float16';
+    }
+    // @ts-ignore unreachable
+    throw new Error(String(type));
+}
+export function getGLFromVertexType(dataType) {
+    // prettier-ignore
+    switch (dataType) {
+        case 'uint8': return 5121;
+        case 'sint8': return 5120;
+        case 'unorm8': return 5121;
+        case 'snorm8': return 5120;
+        case 'uint16': return 5123;
+        case 'sint16': return 5122;
+        case 'unorm16': return 5123;
+        case 'snorm16': return 5122;
+        case 'uint32': return 5125;
+        case 'sint32': return 5124;
+        // WebGPU does not support normalized 32 bit integer attributes
+        // case 'unorm32': return GL.UNSIGNED_INT;
+        // case 'snorm32': return GL.INT;
+        case 'float16': return 5131;
+        case 'float32': return 5126;
+    }
+    // @ts-ignore unreachable
+    throw new Error(String(dataType));
 }
-//# sourceMappingURL=vertex-formats.js.map

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

@@ -0,0 +1,20 @@
+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, disabledFeatures: Partial<Record<DeviceFeature, boolean>>);
+    [Symbol.iterator](): IterableIterator<DeviceFeature>;
+    has(feature: DeviceFeature): boolean;
+    initializeFeatures(): void;
+    /** 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;gBAGlD,EAAE,EAAE,sBAAsB,EAC1B,UAAU,EAAE,YAAY,EACxB,gBAAgB,EAAE,OAAO,CAAC,MAAM,CAAC,aAAa,EAAE,OAAO,CAAC,CAAC;IAU1D,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,gBAAgB,CAAC,aAAa,CAAC;IAc5C,GAAG,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO;IAuB7C,kBAAkB;IAUlB,iCAAiC;IACjC,SAAS,CAAC,eAAe,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO;CAU3D"}

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

@@ -0,0 +1,98 @@
+// 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, disabledFeatures) {
+        super([], disabledFeatures);
+        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) {
+        if (this.disabledFeatures[feature]) {
+            return false;
+        }
+        // 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);
+    }
+    // FOR DEVICE
+    initializeFeatures() {
+        // @ts-expect-error
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        for (const feature of this) {
+            // WebGL extensions are initialized by requesting them
+        }
+    }
+    // IMPLEMENTATION
+    /** 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(7936);
+    const rendererMasked = gl.getParameter(7937);
+    // 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 : 7936);
+    const rendererUnmasked = gl.getParameter(ext ? ext.UNMASKED_RENDERER_WEBGL : 7937);
+    const vendor = vendorUnmasked || vendorMasked;
+    const renderer = rendererUnmasked || rendererMasked;
+    // Driver version
+    const version = gl.getParameter(7938);
+    // "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(3379); }
+    get maxTextureDimension3D() { return this.getParameter(32883); }
+    get maxTextureArrayLayers() { return this.getParameter(35071); }
+    get maxBindGroups() { return 0; }
+    get maxDynamicUniformBuffersPerPipelineLayout() { return 0; } // TBD
+    get maxDynamicStorageBuffersPerPipelineLayout() { return 0; } // TBD
+    get maxSampledTexturesPerShaderStage() { return this.getParameter(35660); } // ) TBD
+    get maxSamplersPerShaderStage() { return this.getParameter(35661); }
+    get maxStorageBuffersPerShaderStage() { return 0; } // TBD
+    get maxStorageTexturesPerShaderStage() { return 0; } // TBD
+    get maxUniformBuffersPerShaderStage() { return this.getParameter(35375); }
+    get maxUniformBufferBindingSize() { return this.getParameter(35376); }
+    get maxStorageBufferBindingSize() { return 0; }
+    get minUniformBufferOffsetAlignment() { return this.getParameter(35380); }
+    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(34921); }
+    get maxVertexBufferArrayStride() { return 2048; } // TBD, this is just the default value from WebGPU
+    get maxInterStageShaderComponents() { return this.getParameter(35659); }
+    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

@@ -0,0 +1,26 @@
+import { ShaderUniformType, ShaderAttributeType, VertexFormat } from '@luma.gl/core';
+import { GL, GLUniformType, GLCompositeType, GLDataType } from '@luma.gl/constants';
+/** Check is uniform is of sampler type */
+export declare function isSamplerUniform(type: GLUniformType): boolean;
+/** Decomposes a composite type (GL.VEC3) into a basic type (GL.FLOAT) and components (3) */
+export declare function decodeGLUniformType(glUniformType: GL): {
+    format: ShaderUniformType;
+    components: number;
+    glType: GLDataType;
+};
+/** Decomposes a composite type (GL.VEC3) into a basic type (GL.FLOAT) and components (3) */
+export declare function decodeGLAttributeType(glAttributeType: GL): {
+    attributeType: ShaderAttributeType;
+    vertexFormat: VertexFormat;
+    components: number;
+};
+/** Decomposes a composite type GL.VEC3 into a basic type (GL.FLOAT) and components (3) */
+export declare function decomposeCompositeGLDataType(compositeGLDataType: GLCompositeType): {
+    type: GLDataType;
+    components: number;
+} | null;
+export declare function getCompositeGLDataType(type: GL, components: any): {
+    glType: GLDataType;
+    name: string;
+} | null;
+//# sourceMappingURL=decode-webgl-types.d.ts.map

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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +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);
+}
+const SAMPLER_TYPES = [
+    35678,
+    35680,
+    35679,
+    35682,
+    36289,
+    36292,
+    36293,
+    36298,
+    36299,
+    36300,
+    36303,
+    36306,
+    36307,
+    36308,
+    36311
+];
+// 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'],
+    // TODO - are sizes/components below correct?
+    [35674]: [5126, 8, 'mat2', 'mat2x2<f32>'], // 4
+    [35685]: [5126, 8, 'mat2x3', 'mat2x3<f32>'], // 6
+    [35686]: [5126, 8, 'mat2x4', 'mat2x4<f32>'], // 8
+    [35687]: [5126, 12, 'mat3x2', 'mat3x2<f32>'], // 6
+    [35675]: [5126, 12, 'mat3', 'mat3x3<f32>'], // 9
+    [35688]: [5126, 12, 'mat3x4', 'mat3x4<f32>'], // 12
+    [35689]: [5126, 16, 'mat4x2', 'mat4x2<f32>'], // 8
+    [35690]: [5126, 16, 'mat4x3', 'mat4x3<f32>'], // 12
+    [35676]: [5126, 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 };
+}
+/** 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;
+    // 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 };
+}
+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 };
+        }
+    }
+    return null;
+}

package/dist/adapter/helpers/get-shader-layout.d.ts

@@ -1,55 +1,8 @@
-import { ShaderLayout, ProgramBindings } from '@luma.gl/api';
+import type { ShaderLayout } from '@luma.gl/core';
 /**
  * Extract metadata describing binding information for a program's shaders
  * Note: `linkProgram()` needs to have been called
  * (although linking does not need to have been successful).
  */
-export declare function getShaderLayout(gl: WebGLRenderingContext, program: WebGLProgram): ShaderLayout;
-/**
- * Extract metadata describing binding information for a program's shaders
- * Note: `linkProgram()` needs to have been called
- * (although linking does not need to have been successful).
- */
-export declare function getProgramBindings(gl: WebGLRenderingContext, program: WebGLProgram): ProgramBindings;
-/**
- * TODO - verify this is a copy of above and delete
- * import type {TextureFormat} from '@luma.gl/api';
-* Extract info about all "active" uniform blocks
- * ("Active" just means that unused (inactive) blocks may have been optimized away during linking)
- *
- function getUniformBlockBindings(gl, program): Binding[] {
-  if (!isWebGL2(gl)) {
-    return;
-  }
-  const bindings: Binding[] = [];
-  const count = gl.getProgramParameter(program, gl.ACTIVE_UNIFORM_BLOCKS);
-  for (let blockIndex = 0; blockIndex < count; blockIndex++) {
-    const vertex = gl.getActiveUniformBlockParameter(program, blockIndex, gl.UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER),
-    const fragment = gl.getActiveUniformBlockParameter(program, blockIndex, gl.UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER),
-    const visibility = (vertex) + (fragment);
-    const binding: BufferBinding = {
-      location: gl.getActiveUniformBlockParameter(program, blockIndex, gl.UNIFORM_BLOCK_BINDING),
-      // name: gl.getActiveUniformBlockName(program, blockIndex),
-      type: 'uniform',
-      visibility,
-      minBindingSize: gl.getActiveUniformBlockParameter(program, blockIndex, gl.UNIFORM_BLOCK_DATA_SIZE),
-      // uniformCount: gl.getActiveUniformBlockParameter(program, blockIndex, gl.UNIFORM_BLOCK_ACTIVE_UNIFORMS),
-      // uniformIndices: gl.getActiveUniformBlockParameter(program, blockIndex, gl.UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES),
-    }
-    bindings.push(binding);
-  }
-  return bindings;
-}
-
-function setBindings(gl2: WebGL2RenderingContext, program: WebGLProgram, bindings: Binding[][]): void {
-  for (const bindGroup of bindings) {
-    for (const binding of bindGroup) {
-
-    }
-  }
-
-  // Set up indirection table
-  // this.gl2.uniformBlockBinding(this.handle, blockIndex, blockBinding);
-}
- */
+export declare function getShaderLayout(gl: WebGL2RenderingContext, program: WebGLProgram): ShaderLayout;
 //# sourceMappingURL=get-shader-layout.d.ts.map

package/dist/adapter/helpers/get-shader-layout.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"get-shader-layout.d.ts","sourceRoot":"","sources":["../../../src/adapter/helpers/get-shader-layout.ts"],"names":[],"mappings":"AAEA,OAAO,EACL,YAAY,EAIZ,eAAe,EAKhB,MAAM,cAAc,CAAC;AAOtB;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,EAAE,EAAE,qBAAqB,EAAE,OAAO,EAAE,YAAY,GAAG,YAAY,CAkE9F;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAChC,EAAE,EAAE,qBAAqB,EACzB,OAAO,EAAE,YAAY,GACpB,eAAe,CAWjB;AA+PD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG"}
+{"version":3,"file":"get-shader-layout.d.ts","sourceRoot":"","sources":["../../../src/adapter/helpers/get-shader-layout.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EACV,YAAY,EAKb,MAAM,eAAe,CAAC;AAMvB;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,EAAE,EAAE,sBAAsB,EAAE,OAAO,EAAE,YAAY,GAAG,YAAY,CA2D/F"}