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

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,6 @@
+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=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":"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,CAW/E"}

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

@@ -0,0 +1,52 @@
+// 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) {
+    // Enable EXT_float_blend first: https://developer.mozilla.org/en-US/docs/Web/API/EXT_float_blend
+    gl.getExtension('EXT_color_buffer_float');
+    const features = new Set();
+    for (const feature of Object.keys(WEBGL_FEATURES)) {
+        if (isFeatureSupported(gl, feature)) {
+            features.add(feature);
+        }
+    }
+    return features;
+}
+function isFeatureSupported(gl, feature) {
+    const featureInfo = WEBGL_FEATURES[feature];
+    // string value requires checking the corresponding WebGL extension
+    return typeof featureInfo === 'string'
+        ? Boolean(gl.getExtension(featureInfo))
+        : Boolean(featureInfo);
+}
+/**
+ * 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 = {
+    webgl: true,
+    glsl: true,
+    'uniforms-webgl': true,
+    'transform-feedback-webgl': true,
+    'constant-attributes-webgl': true,
+    'timer-query-webgl': 'EXT_disjoint_timer_query_webgl2',
+    'shader-status-async-webgl': 'KHR_parallel_shader_compile'
+    // Textures are handled by getTextureFeatures()
+};

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

@@ -0,0 +1,4 @@
+import { DeviceInfo } from '@luma.gl/core';
+/** @returns strings identifying the GPU vendor and driver. */
+export declare function getDeviceInfo(gl: WebGL2RenderingContext): 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":"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/webgl-device-info.js

@@ -0,0 +1,87 @@
+// 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/adapter/device-helpers/webgl-device-limits.d.ts

@@ -0,0 +1,50 @@
+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=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":"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"}

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

@@ -0,0 +1,92 @@
+// 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/helpers/decode-webgl-types.js

@@ -1,89 +1,100 @@
+// luma.gl, MIT license
+// 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