@luma.gl/webgl 9.0.0-alpha.30 → 9.0.0-alpha.32

package/dist/index.cjs

@@ -20,8 +20,8 @@ var __spreadValues = (a, b) => {
 };
 var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
 var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
+  for (var name2 in all)
+    __defProp(target, name2, { get: all[name2], enumerable: true });
 };
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
@@ -84,7 +84,6 @@ __export(src_exports, {
   getWebGL2Context: () => getWebGL2Context,
   isWebGL: () => isWebGL,
   isWebGL2: () => isWebGL2,
-  mergeShaderLayout: () => mergeShaderLayout,
   polyfillContext: () => polyfillContext,
   popContextState: () => popContextState,
   pushContextState: () => pushContextState,
@@ -405,12 +404,12 @@ function polyfillVertexArrayObject(gl2) {
     return list;
   };
   const original_getExtension = gl2.getExtension;
-  gl2.getExtension = function getExtension(name) {
-    const ext = original_getExtension.call(this, name);
+  gl2.getExtension = function getExtension(name2) {
+    const ext = original_getExtension.call(this, name2);
     if (ext) {
       return ext;
     }
-    if (name !== "OES_vertex_array_object") {
+    if (name2 !== "OES_vertex_array_object") {
       return null;
     }
     if (!gl2.__OESVertexArrayObject) {
@@ -1358,7 +1357,7 @@ var GLState = class {
   constructor(gl2, {
     copyState = false,
     // Copy cache from params (slow) or initialize from WebGL defaults (fast)
-    log: log10 = () => {
+    log: log9 = () => {
     }
     // Logging function, called when gl parameter change calls are actually issued
   } = {}) {
@@ -1367,7 +1366,7 @@ var GLState = class {
     this.enable = true;
     this.gl = gl2;
     this.cache = copyState ? getParameters(gl2) : Object.assign({}, GL_PARAMETER_DEFAULTS);
-    this.log = log10;
+    this.log = log9;
     this._updateCache = this._updateCache.bind(this);
     Object.seal(this);
   }
@@ -1596,7 +1595,41 @@ function isOldIE(opts = {}) {
 
 // src/adapter/converters/texture-formats.ts
 var import_core5 = require("@luma.gl/core");
+var import_constants6 = require("@luma.gl/constants");
+
+// src/adapter/converters/vertex-formats.ts
 var import_constants5 = require("@luma.gl/constants");
+function getGLFromVertexType(dataType) {
+  switch (dataType) {
+    case "uint8":
+      return import_constants5.GL.UNSIGNED_BYTE;
+    case "sint8":
+      return import_constants5.GL.BYTE;
+    case "unorm8":
+      return import_constants5.GL.UNSIGNED_BYTE;
+    case "snorm8":
+      return import_constants5.GL.BYTE;
+    case "uint16":
+      return import_constants5.GL.UNSIGNED_SHORT;
+    case "sint16":
+      return import_constants5.GL.SHORT;
+    case "unorm16":
+      return import_constants5.GL.UNSIGNED_SHORT;
+    case "snorm16":
+      return import_constants5.GL.SHORT;
+    case "uint32":
+      return import_constants5.GL.UNSIGNED_INT;
+    case "sint32":
+      return import_constants5.GL.INT;
+    case "float16":
+      return import_constants5.GL.HALF_FLOAT;
+    case "float32":
+      return import_constants5.GL.FLOAT;
+  }
+  throw new Error(String(dataType));
+}
+
+// src/adapter/converters/texture-formats.ts
 var texture_compression_bc = "texture-compression-bc";
 var texture_compression_astc = "texture-compression-astc";
 var texture_compression_etc2 = "texture-compression-etc2";
@@ -1655,206 +1688,206 @@ var TEXTURE_FORMATS = {
   // TODO - Fix bpp constants
   // 'r8unorm-unsized': {gl: GL.LUMINANCE, b: 4, c: 2, bpp: 4},
   "rgb8unorm-unsized": {
-    gl: import_constants5.GL.RGB,
-    gl1: import_constants5.GL.RGB,
+    gl: import_constants6.GL.RGB,
+    gl1: import_constants6.GL.RGB,
     b: 4,
     c: 2,
     bpp: 4,
-    dataFormat: import_constants5.GL.RGB,
-    types: [import_constants5.GL.UNSIGNED_BYTE, import_constants5.GL.UNSIGNED_SHORT_5_6_5]
+    dataFormat: import_constants6.GL.RGB,
+    types: [import_constants6.GL.UNSIGNED_BYTE, import_constants6.GL.UNSIGNED_SHORT_5_6_5]
   },
   "rgba8unorm-unsized": {
-    gl: import_constants5.GL.RGBA,
-    gl1: import_constants5.GL.RGBA,
+    gl: import_constants6.GL.RGBA,
+    gl1: import_constants6.GL.RGBA,
     b: 4,
     c: 2,
     bpp: 4,
-    dataFormat: import_constants5.GL.RGBA,
-    types: [import_constants5.GL.UNSIGNED_BYTE, import_constants5.GL.UNSIGNED_SHORT_4_4_4_4, import_constants5.GL.UNSIGNED_SHORT_5_5_5_1]
+    dataFormat: import_constants6.GL.RGBA,
+    types: [import_constants6.GL.UNSIGNED_BYTE, import_constants6.GL.UNSIGNED_SHORT_4_4_4_4, import_constants6.GL.UNSIGNED_SHORT_5_5_5_1]
   },
   // 'rgb8unorm-srgb-unsized': {gl: GL.SRGB_EXT, b: 4, c: 2, bpp: 4, gl1Ext: SRGB},
   // 'rgba8unorm-srgb-unsized': {gl: GL.SRGB_ALPHA_EXT, b: 4, c: 2, bpp: 4, gl1Ext: SRGB},
   // 8-bit formats
-  "r8unorm": { gl: import_constants5.GL.R8, b: 1, c: 1, renderbuffer: true },
-  "r8snorm": { gl: import_constants5.GL.R8_SNORM, b: 1, c: 1 },
-  "r8uint": { gl: import_constants5.GL.R8UI, b: 1, c: 1, renderbuffer: true },
-  "r8sint": { gl: import_constants5.GL.R8I, b: 1, c: 1, renderbuffer: true },
+  "r8unorm": { gl: import_constants6.GL.R8, b: 1, c: 1, renderbuffer: true },
+  "r8snorm": { gl: import_constants6.GL.R8_SNORM, b: 1, c: 1 },
+  "r8uint": { gl: import_constants6.GL.R8UI, b: 1, c: 1, renderbuffer: true },
+  "r8sint": { gl: import_constants6.GL.R8I, b: 1, c: 1, renderbuffer: true },
   // 16-bit formats
-  "rg8unorm": { gl: import_constants5.GL.RG8, b: 2, c: 2, renderbuffer: true },
-  "rg8snorm": { gl: import_constants5.GL.RG8_SNORM, b: 2, c: 2 },
-  "rg8uint": { gl: import_constants5.GL.RG8UI, b: 2, c: 2, renderbuffer: true },
-  "rg8sint": { gl: import_constants5.GL.RG8I, b: 2, c: 2, renderbuffer: true },
-  "r16uint": { gl: import_constants5.GL.R16UI, b: 2, c: 1, renderbuffer: true },
-  "r16sint": { gl: import_constants5.GL.R16I, b: 2, c: 1, renderbuffer: true },
-  "r16float": { gl: import_constants5.GL.R16F, b: 2, c: 1, render: "texture-renderable-float16-webgl", filter: "texture-filter-linear-float16-webgl", renderbuffer: true },
-  "r16unorm-webgl": { gl: import_constants5.GL.R16_EXT, b: 2, c: 1, f: "texture-formats-norm16-webgl", renderbuffer: true, x: EXT_TEXTURE_NORM16 },
-  "r16snorm-webgl": { gl: import_constants5.GL.R16_SNORM_EXT, b: 2, c: 1, f: "texture-formats-norm16-webgl", x: EXT_TEXTURE_NORM16 },
+  "rg8unorm": { gl: import_constants6.GL.RG8, b: 2, c: 2, renderbuffer: true },
+  "rg8snorm": { gl: import_constants6.GL.RG8_SNORM, b: 2, c: 2 },
+  "rg8uint": { gl: import_constants6.GL.RG8UI, b: 2, c: 2, renderbuffer: true },
+  "rg8sint": { gl: import_constants6.GL.RG8I, b: 2, c: 2, renderbuffer: true },
+  "r16uint": { gl: import_constants6.GL.R16UI, b: 2, c: 1, renderbuffer: true },
+  "r16sint": { gl: import_constants6.GL.R16I, b: 2, c: 1, renderbuffer: true },
+  "r16float": { gl: import_constants6.GL.R16F, b: 2, c: 1, render: "texture-renderable-float16-webgl", filter: "texture-filter-linear-float16-webgl", renderbuffer: true },
+  "r16unorm-webgl": { gl: import_constants6.GL.R16_EXT, b: 2, c: 1, f: "texture-formats-norm16-webgl", renderbuffer: true, x: EXT_TEXTURE_NORM16 },
+  "r16snorm-webgl": { gl: import_constants6.GL.R16_SNORM_EXT, b: 2, c: 1, f: "texture-formats-norm16-webgl", x: EXT_TEXTURE_NORM16 },
   // Packed 16-bit formats
-  "rgba4unorm-webgl": { gl: import_constants5.GL.RGBA4, b: 2, c: 4, wgpu: false, renderbuffer: true },
-  "rgb565unorm-webgl": { gl: import_constants5.GL.RGB565, b: 2, c: 4, wgpu: false, renderbuffer: true },
-  "rgb5a1unorm-webgl": { gl: import_constants5.GL.RGB5_A1, b: 2, c: 4, wgpu: false, renderbuffer: true },
+  "rgba4unorm-webgl": { gl: import_constants6.GL.RGBA4, b: 2, c: 4, wgpu: false, renderbuffer: true },
+  "rgb565unorm-webgl": { gl: import_constants6.GL.RGB565, b: 2, c: 4, wgpu: false, renderbuffer: true },
+  "rgb5a1unorm-webgl": { gl: import_constants6.GL.RGB5_A1, b: 2, c: 4, wgpu: false, renderbuffer: true },
   // 24-bit formats
-  "rgb8unorm-webgl": { gl: import_constants5.GL.RGB8, b: 3, c: 3, wgpu: false },
-  "rgb8snorm-webgl": { gl: import_constants5.GL.RGB8_SNORM, b: 3, c: 3, wgpu: false },
+  "rgb8unorm-webgl": { gl: import_constants6.GL.RGB8, b: 3, c: 3, wgpu: false },
+  "rgb8snorm-webgl": { gl: import_constants6.GL.RGB8_SNORM, b: 3, c: 3, wgpu: false },
   // 32-bit formats  
-  "rgba8unorm": { gl: import_constants5.GL.RGBA8, gl1: import_constants5.GL.RGBA, b: 4, c: 2, bpp: 4 },
-  "rgba8unorm-srgb": { gl: import_constants5.GL.SRGB8_ALPHA8, gl1: import_constants5.GL.SRGB_ALPHA_EXT, b: 4, c: 4, gl1ext: EXT_SRGB, bpp: 4 },
-  "rgba8snorm": { gl: import_constants5.GL.RGBA8_SNORM, b: 4, c: 4 },
-  "rgba8uint": { gl: import_constants5.GL.RGBA8UI, b: 4, c: 4, bpp: 4 },
-  "rgba8sint": { gl: import_constants5.GL.RGBA8I, b: 4, c: 4, bpp: 4 },
+  "rgba8unorm": { gl: import_constants6.GL.RGBA8, gl1: import_constants6.GL.RGBA, b: 4, c: 2, bpp: 4 },
+  "rgba8unorm-srgb": { gl: import_constants6.GL.SRGB8_ALPHA8, gl1: import_constants6.GL.SRGB_ALPHA_EXT, b: 4, c: 4, gl1ext: EXT_SRGB, bpp: 4 },
+  "rgba8snorm": { gl: import_constants6.GL.RGBA8_SNORM, b: 4, c: 4 },
+  "rgba8uint": { gl: import_constants6.GL.RGBA8UI, b: 4, c: 4, bpp: 4 },
+  "rgba8sint": { gl: import_constants6.GL.RGBA8I, b: 4, c: 4, bpp: 4 },
   // reverse colors, webgpu only
   "bgra8unorm": { b: 4, c: 4 },
   "bgra8unorm-srgb": { b: 4, c: 4 },
-  "rg16uint": { gl: import_constants5.GL.RG16UI, b: 4, c: 1, bpp: 4 },
-  "rg16sint": { gl: import_constants5.GL.RG16I, b: 4, c: 2, bpp: 4 },
+  "rg16uint": { gl: import_constants6.GL.RG16UI, b: 4, c: 1, bpp: 4 },
+  "rg16sint": { gl: import_constants6.GL.RG16I, b: 4, c: 2, bpp: 4 },
   // When using a WebGL 2 context and the EXT_color_buffer_float WebGL2 extension
-  "rg16float": { gl: import_constants5.GL.RG16F, bpp: 4, b: 4, c: 2, render: "texture-renderable-float16-webgl", filter: "texture-filter-linear-float16-webgl", renderbuffer: true },
-  "rg16unorm-webgl": { gl: import_constants5.GL.RG16_EXT, b: 2, c: 2, f: "texture-formats-norm16-webgl", x: EXT_TEXTURE_NORM16 },
-  "rg16snorm-webgl": { gl: import_constants5.GL.RG16_SNORM_EXT, b: 2, c: 2, f: "texture-formats-norm16-webgl", x: EXT_TEXTURE_NORM16 },
-  "r32uint": { gl: import_constants5.GL.R32UI, b: 4, c: 1, bpp: 4, renderbuffer: true },
-  "r32sint": { gl: import_constants5.GL.R32I, b: 4, c: 1, bpp: 4, renderbuffer: true },
-  "r32float": { gl: import_constants5.GL.R32F, bpp: 4, b: 4, c: 1, render: "texture-renderable-float32-webgl", filter: "texture-filter-linear-float32-webgl" },
+  "rg16float": { gl: import_constants6.GL.RG16F, bpp: 4, b: 4, c: 2, render: "texture-renderable-float16-webgl", filter: "texture-filter-linear-float16-webgl", renderbuffer: true },
+  "rg16unorm-webgl": { gl: import_constants6.GL.RG16_EXT, b: 2, c: 2, f: "texture-formats-norm16-webgl", x: EXT_TEXTURE_NORM16 },
+  "rg16snorm-webgl": { gl: import_constants6.GL.RG16_SNORM_EXT, b: 2, c: 2, f: "texture-formats-norm16-webgl", x: EXT_TEXTURE_NORM16 },
+  "r32uint": { gl: import_constants6.GL.R32UI, b: 4, c: 1, bpp: 4, renderbuffer: true },
+  "r32sint": { gl: import_constants6.GL.R32I, b: 4, c: 1, bpp: 4, renderbuffer: true },
+  "r32float": { gl: import_constants6.GL.R32F, bpp: 4, b: 4, c: 1, render: "texture-renderable-float32-webgl", filter: "texture-filter-linear-float32-webgl" },
   // Packed 32-bit formats
-  "rgb9e5ufloat": { gl: import_constants5.GL.RGB9_E5, b: 4, c: 3, p: 1, render: "texture-renderable-float16-webgl", filter: "texture-filter-linear-float16-webgl" },
-  "rg11b10ufloat": { gl: import_constants5.GL.R11F_G11F_B10F, b: 4, c: 3, p: 1, render: "texture-renderable-float32-webgl", renderbuffer: true },
-  "rgb10a2unorm": { gl: import_constants5.GL.RGB10_A2, b: 4, c: 4, p: 1, renderbuffer: true },
+  "rgb9e5ufloat": { gl: import_constants6.GL.RGB9_E5, b: 4, c: 3, p: 1, render: "texture-renderable-float16-webgl", filter: "texture-filter-linear-float16-webgl" },
+  "rg11b10ufloat": { gl: import_constants6.GL.R11F_G11F_B10F, b: 4, c: 3, p: 1, render: "texture-renderable-float32-webgl", renderbuffer: true },
+  "rgb10a2unorm": { gl: import_constants6.GL.RGB10_A2, b: 4, c: 4, p: 1, renderbuffer: true },
   // webgl2 only
-  "rgb10a2unorm-webgl": { b: 4, c: 4, gl: import_constants5.GL.RGB10_A2UI, p: 1, wgpu: false, bpp: 4, renderbuffer: true },
+  "rgb10a2unorm-webgl": { b: 4, c: 4, gl: import_constants6.GL.RGB10_A2UI, p: 1, wgpu: false, bpp: 4, renderbuffer: true },
   // 48-bit formats
-  "rgb16unorm-webgl": { gl: import_constants5.GL.RGB16_EXT, b: 2, c: 3, f: "texture-formats-norm16-webgl", x: EXT_TEXTURE_NORM16 },
-  "rgb16snorm-webgl": { gl: import_constants5.GL.RGB16_SNORM_EXT, b: 2, c: 3, f: "texture-formats-norm16-webgl", x: EXT_TEXTURE_NORM16 },
+  "rgb16unorm-webgl": { gl: import_constants6.GL.RGB16_EXT, b: 2, c: 3, f: "texture-formats-norm16-webgl", x: EXT_TEXTURE_NORM16 },
+  "rgb16snorm-webgl": { gl: import_constants6.GL.RGB16_SNORM_EXT, b: 2, c: 3, f: "texture-formats-norm16-webgl", x: EXT_TEXTURE_NORM16 },
   // 64-bit formats
-  "rg32uint": { gl: import_constants5.GL.RG32UI, b: 8, c: 2, renderbuffer: true },
-  "rg32sint": { gl: import_constants5.GL.RG32I, b: 8, c: 2, renderbuffer: true },
-  "rg32float": { gl: import_constants5.GL.RG32F, b: 8, c: 2, render: "texture-renderable-float32-webgl", filter: "texture-filter-linear-float32-webgl", renderbuffer: true },
-  "rgba16uint": { gl: import_constants5.GL.RGBA16UI, b: 8, c: 4, renderbuffer: true },
-  "rgba16sint": { gl: import_constants5.GL.RGBA16I, b: 8, c: 4, renderbuffer: true },
-  "rgba16float": { gl: import_constants5.GL.RGBA16F, gl1: import_constants5.GL.RGBA, b: 8, c: 4, render: "texture-renderable-float16-webgl", filter: "texture-filter-linear-float16-webgl" },
-  "rgba16unorm-webgl": { gl: import_constants5.GL.RGBA16_EXT, b: 2, c: 4, f: "texture-formats-norm16-webgl", renderbuffer: true, x: EXT_TEXTURE_NORM16 },
-  "rgba16snorm-webgl": { gl: import_constants5.GL.RGBA16_SNORM_EXT, b: 2, c: 4, f: "texture-formats-norm16-webgl", x: EXT_TEXTURE_NORM16 },
+  "rg32uint": { gl: import_constants6.GL.RG32UI, b: 8, c: 2, renderbuffer: true },
+  "rg32sint": { gl: import_constants6.GL.RG32I, b: 8, c: 2, renderbuffer: true },
+  "rg32float": { gl: import_constants6.GL.RG32F, b: 8, c: 2, render: "texture-renderable-float32-webgl", filter: "texture-filter-linear-float32-webgl", renderbuffer: true },
+  "rgba16uint": { gl: import_constants6.GL.RGBA16UI, b: 8, c: 4, renderbuffer: true },
+  "rgba16sint": { gl: import_constants6.GL.RGBA16I, b: 8, c: 4, renderbuffer: true },
+  "rgba16float": { gl: import_constants6.GL.RGBA16F, gl1: import_constants6.GL.RGBA, b: 8, c: 4, render: "texture-renderable-float16-webgl", filter: "texture-filter-linear-float16-webgl" },
+  "rgba16unorm-webgl": { gl: import_constants6.GL.RGBA16_EXT, b: 2, c: 4, f: "texture-formats-norm16-webgl", renderbuffer: true, x: EXT_TEXTURE_NORM16 },
+  "rgba16snorm-webgl": { gl: import_constants6.GL.RGBA16_SNORM_EXT, b: 2, c: 4, f: "texture-formats-norm16-webgl", x: EXT_TEXTURE_NORM16 },
   // 96-bit formats (deprecated!)
   "rgb32float-webgl": {
-    gl: import_constants5.GL.RGB32F,
-    gl1: import_constants5.GL.RGB,
+    gl: import_constants6.GL.RGB32F,
+    gl1: import_constants6.GL.RGB,
     render: "texture-renderable-float32-webgl",
     filter: "texture-filter-linear-float32-webgl",
     gl2ext: EXT_FLOAT_RENDER_WEBGL2,
     gl1ext: EXT_FLOAT_WEBGL1,
     // WebGL1 render buffers are supported with GL.RGB32F
-    dataFormat: import_constants5.GL.RGB,
-    types: [import_constants5.GL.FLOAT]
+    dataFormat: import_constants6.GL.RGB,
+    types: [import_constants6.GL.FLOAT]
   },
   // 128-bit formats
-  "rgba32uint": { gl: import_constants5.GL.RGBA32UI, b: 16, c: 4, renderbuffer: true },
-  "rgba32sint": { gl: import_constants5.GL.RGBA32I, b: 16, c: 4, renderbuffer: true },
-  "rgba32float": { gl: import_constants5.GL.RGBA32F, b: 16, c: 4, render: "texture-renderable-float32-webgl", filter: "texture-filter-linear-float32-webgl", renderbuffer: true },
+  "rgba32uint": { gl: import_constants6.GL.RGBA32UI, b: 16, c: 4, renderbuffer: true },
+  "rgba32sint": { gl: import_constants6.GL.RGBA32I, b: 16, c: 4, renderbuffer: true },
+  "rgba32float": { gl: import_constants6.GL.RGBA32F, b: 16, c: 4, render: "texture-renderable-float32-webgl", filter: "texture-filter-linear-float32-webgl", renderbuffer: true },
   // Depth and stencil formats
-  "stencil8": { gl: import_constants5.GL.STENCIL_INDEX8, gl1: import_constants5.GL.STENCIL_INDEX8, b: 1, c: 1, attachment: import_constants5.GL.STENCIL_ATTACHMENT, renderbuffer: true },
+  "stencil8": { gl: import_constants6.GL.STENCIL_INDEX8, gl1: import_constants6.GL.STENCIL_INDEX8, b: 1, c: 1, attachment: import_constants6.GL.STENCIL_ATTACHMENT, renderbuffer: true },
   // 8 stencil bits
-  "depth16unorm": { gl: import_constants5.GL.DEPTH_COMPONENT16, gl1: import_constants5.GL.DEPTH_COMPONENT16, b: 2, c: 1, attachment: import_constants5.GL.DEPTH_ATTACHMENT, renderbuffer: true },
+  "depth16unorm": { gl: import_constants6.GL.DEPTH_COMPONENT16, gl1: import_constants6.GL.DEPTH_COMPONENT16, b: 2, c: 1, attachment: import_constants6.GL.DEPTH_ATTACHMENT, renderbuffer: true },
   // 16 depth bits
-  "depth24plus": { gl: import_constants5.GL.DEPTH_COMPONENT24, b: 3, c: 1, attachment: import_constants5.GL.DEPTH_ATTACHMENT },
-  "depth32float": { gl: import_constants5.GL.DEPTH_COMPONENT32F, b: 4, c: 1, attachment: import_constants5.GL.DEPTH_ATTACHMENT, renderbuffer: true },
+  "depth24plus": { gl: import_constants6.GL.DEPTH_COMPONENT24, b: 3, c: 1, attachment: import_constants6.GL.DEPTH_ATTACHMENT },
+  "depth32float": { gl: import_constants6.GL.DEPTH_COMPONENT32F, b: 4, c: 1, attachment: import_constants6.GL.DEPTH_ATTACHMENT, renderbuffer: true },
   // The depth component of the "depth24plus" and "depth24plus-stencil8" formats may be implemented as either a 24-bit depth value or a "depth32float" value.
-  "depth24plus-stencil8": { gl: import_constants5.GL.DEPTH_STENCIL, gl1: import_constants5.GL.DEPTH_STENCIL, b: 4, c: 2, p: 1, attachment: import_constants5.GL.DEPTH_STENCIL_ATTACHMENT, renderbuffer: true, depthTexture: true },
+  "depth24plus-stencil8": { gl: import_constants6.GL.DEPTH_STENCIL, gl1: import_constants6.GL.DEPTH_STENCIL, b: 4, c: 2, p: 1, attachment: import_constants6.GL.DEPTH_STENCIL_ATTACHMENT, renderbuffer: true, depthTexture: true },
   // "depth24unorm-stencil8" feature
-  "depth24unorm-stencil8": { gl: import_constants5.GL.DEPTH24_STENCIL8, b: 4, c: 2, p: 1, attachment: import_constants5.GL.DEPTH_STENCIL_ATTACHMENT, renderbuffer: true },
+  "depth24unorm-stencil8": { gl: import_constants6.GL.DEPTH24_STENCIL8, b: 4, c: 2, p: 1, attachment: import_constants6.GL.DEPTH_STENCIL_ATTACHMENT, renderbuffer: true },
   // "depth32float-stencil8" feature
-  "depth32float-stencil8": { gl: import_constants5.GL.DEPTH32F_STENCIL8, b: 5, c: 2, p: 1, attachment: import_constants5.GL.DEPTH_STENCIL_ATTACHMENT, renderbuffer: true },
+  "depth32float-stencil8": { gl: import_constants6.GL.DEPTH32F_STENCIL8, b: 5, c: 2, p: 1, attachment: import_constants6.GL.DEPTH_STENCIL_ATTACHMENT, renderbuffer: true },
   // BC compressed formats: check device.features.has("texture-compression-bc");
-  "bc1-rgb-unorm-webgl": { gl: import_constants5.GL.COMPRESSED_RGB_S3TC_DXT1_EXT, x: X_S3TC, f: texture_compression_bc },
-  "bc1-rgb-unorm-srgb-webgl": { gl: import_constants5.GL.COMPRESSED_SRGB_S3TC_DXT1_EXT, x: X_S3TC_SRGB, f: texture_compression_bc },
-  "bc1-rgba-unorm": { gl: import_constants5.GL.COMPRESSED_RGBA_S3TC_DXT1_EXT, x: X_S3TC, f: texture_compression_bc },
-  "bc1-rgba-unorm-srgb": { gl: import_constants5.GL.COMPRESSED_SRGB_S3TC_DXT1_EXT, x: X_S3TC_SRGB, f: texture_compression_bc },
-  "bc2-rgba-unorm": { gl: import_constants5.GL.COMPRESSED_RGBA_S3TC_DXT3_EXT, x: X_S3TC, f: texture_compression_bc },
-  "bc2-rgba-unorm-srgb": { gl: import_constants5.GL.COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT, x: X_S3TC_SRGB, f: texture_compression_bc },
-  "bc3-rgba-unorm": { gl: import_constants5.GL.COMPRESSED_RGBA_S3TC_DXT5_EXT, x: X_S3TC, f: texture_compression_bc },
-  "bc3-rgba-unorm-srgb": { gl: import_constants5.GL.COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT, x: X_S3TC_SRGB, f: texture_compression_bc },
-  "bc4-r-unorm": { gl: import_constants5.GL.COMPRESSED_RED_RGTC1_EXT, x: X_RGTC, f: texture_compression_bc },
-  "bc4-r-snorm": { gl: import_constants5.GL.COMPRESSED_SIGNED_RED_RGTC1_EXT, x: X_RGTC, f: texture_compression_bc },
-  "bc5-rg-unorm": { gl: import_constants5.GL.COMPRESSED_RED_GREEN_RGTC2_EXT, x: X_RGTC, f: texture_compression_bc },
-  "bc5-rg-snorm": { gl: import_constants5.GL.COMPRESSED_SIGNED_RED_GREEN_RGTC2_EXT, x: X_RGTC, f: texture_compression_bc },
-  "bc6h-rgb-ufloat": { gl: import_constants5.GL.COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT_EXT, x: X_BPTC, f: texture_compression_bc },
-  "bc6h-rgb-float": { gl: import_constants5.GL.COMPRESSED_RGB_BPTC_SIGNED_FLOAT_EXT, x: X_BPTC, f: texture_compression_bc },
-  "bc7-rgba-unorm": { gl: import_constants5.GL.COMPRESSED_RGBA_BPTC_UNORM_EXT, x: X_BPTC, f: texture_compression_bc },
-  "bc7-rgba-unorm-srgb": { gl: import_constants5.GL.COMPRESSED_SRGB_ALPHA_BPTC_UNORM_EXT, x: X_BPTC, f: texture_compression_bc },
+  "bc1-rgb-unorm-webgl": { gl: import_constants6.GL.COMPRESSED_RGB_S3TC_DXT1_EXT, x: X_S3TC, f: texture_compression_bc },
+  "bc1-rgb-unorm-srgb-webgl": { gl: import_constants6.GL.COMPRESSED_SRGB_S3TC_DXT1_EXT, x: X_S3TC_SRGB, f: texture_compression_bc },
+  "bc1-rgba-unorm": { gl: import_constants6.GL.COMPRESSED_RGBA_S3TC_DXT1_EXT, x: X_S3TC, f: texture_compression_bc },
+  "bc1-rgba-unorm-srgb": { gl: import_constants6.GL.COMPRESSED_SRGB_S3TC_DXT1_EXT, x: X_S3TC_SRGB, f: texture_compression_bc },
+  "bc2-rgba-unorm": { gl: import_constants6.GL.COMPRESSED_RGBA_S3TC_DXT3_EXT, x: X_S3TC, f: texture_compression_bc },
+  "bc2-rgba-unorm-srgb": { gl: import_constants6.GL.COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT, x: X_S3TC_SRGB, f: texture_compression_bc },
+  "bc3-rgba-unorm": { gl: import_constants6.GL.COMPRESSED_RGBA_S3TC_DXT5_EXT, x: X_S3TC, f: texture_compression_bc },
+  "bc3-rgba-unorm-srgb": { gl: import_constants6.GL.COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT, x: X_S3TC_SRGB, f: texture_compression_bc },
+  "bc4-r-unorm": { gl: import_constants6.GL.COMPRESSED_RED_RGTC1_EXT, x: X_RGTC, f: texture_compression_bc },
+  "bc4-r-snorm": { gl: import_constants6.GL.COMPRESSED_SIGNED_RED_RGTC1_EXT, x: X_RGTC, f: texture_compression_bc },
+  "bc5-rg-unorm": { gl: import_constants6.GL.COMPRESSED_RED_GREEN_RGTC2_EXT, x: X_RGTC, f: texture_compression_bc },
+  "bc5-rg-snorm": { gl: import_constants6.GL.COMPRESSED_SIGNED_RED_GREEN_RGTC2_EXT, x: X_RGTC, f: texture_compression_bc },
+  "bc6h-rgb-ufloat": { gl: import_constants6.GL.COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT_EXT, x: X_BPTC, f: texture_compression_bc },
+  "bc6h-rgb-float": { gl: import_constants6.GL.COMPRESSED_RGB_BPTC_SIGNED_FLOAT_EXT, x: X_BPTC, f: texture_compression_bc },
+  "bc7-rgba-unorm": { gl: import_constants6.GL.COMPRESSED_RGBA_BPTC_UNORM_EXT, x: X_BPTC, f: texture_compression_bc },
+  "bc7-rgba-unorm-srgb": { gl: import_constants6.GL.COMPRESSED_SRGB_ALPHA_BPTC_UNORM_EXT, x: X_BPTC, f: texture_compression_bc },
   // WEBGL_compressed_texture_etc: device.features.has("texture-compression-etc2")
   // Note: Supposedly guaranteed availability compressed formats in WebGL2, but through CPU decompression
-  "etc2-rgb8unorm": { gl: import_constants5.GL.COMPRESSED_RGB8_ETC2, f: texture_compression_etc2 },
-  "etc2-rgb8unorm-srgb": { gl: import_constants5.GL.COMPRESSED_SRGB8_ETC2, f: texture_compression_etc2 },
-  "etc2-rgb8a1unorm": { gl: import_constants5.GL.COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2, f: texture_compression_etc2 },
-  "etc2-rgb8a1unorm-srgb": { gl: import_constants5.GL.COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2, f: texture_compression_etc2 },
-  "etc2-rgba8unorm": { gl: import_constants5.GL.COMPRESSED_RGBA8_ETC2_EAC, f: texture_compression_etc2 },
-  "etc2-rgba8unorm-srgb": { gl: import_constants5.GL.COMPRESSED_SRGB8_ALPHA8_ETC2_EAC, f: texture_compression_etc2 },
-  "eac-r11unorm": { gl: import_constants5.GL.COMPRESSED_R11_EAC, f: texture_compression_etc2 },
-  "eac-r11snorm": { gl: import_constants5.GL.COMPRESSED_SIGNED_R11_EAC, f: texture_compression_etc2 },
-  "eac-rg11unorm": { gl: import_constants5.GL.COMPRESSED_RG11_EAC, f: texture_compression_etc2 },
-  "eac-rg11snorm": { gl: import_constants5.GL.COMPRESSED_SIGNED_RG11_EAC, f: texture_compression_etc2 },
+  "etc2-rgb8unorm": { gl: import_constants6.GL.COMPRESSED_RGB8_ETC2, f: texture_compression_etc2 },
+  "etc2-rgb8unorm-srgb": { gl: import_constants6.GL.COMPRESSED_SRGB8_ETC2, f: texture_compression_etc2 },
+  "etc2-rgb8a1unorm": { gl: import_constants6.GL.COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2, f: texture_compression_etc2 },
+  "etc2-rgb8a1unorm-srgb": { gl: import_constants6.GL.COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2, f: texture_compression_etc2 },
+  "etc2-rgba8unorm": { gl: import_constants6.GL.COMPRESSED_RGBA8_ETC2_EAC, f: texture_compression_etc2 },
+  "etc2-rgba8unorm-srgb": { gl: import_constants6.GL.COMPRESSED_SRGB8_ALPHA8_ETC2_EAC, f: texture_compression_etc2 },
+  "eac-r11unorm": { gl: import_constants6.GL.COMPRESSED_R11_EAC, f: texture_compression_etc2 },
+  "eac-r11snorm": { gl: import_constants6.GL.COMPRESSED_SIGNED_R11_EAC, f: texture_compression_etc2 },
+  "eac-rg11unorm": { gl: import_constants6.GL.COMPRESSED_RG11_EAC, f: texture_compression_etc2 },
+  "eac-rg11snorm": { gl: import_constants6.GL.COMPRESSED_SIGNED_RG11_EAC, f: texture_compression_etc2 },
   // X_ASTC compressed formats: device.features.has("texture-compression-astc")
-  "astc-4x4-unorm": { gl: import_constants5.GL.COMPRESSED_RGBA_ASTC_4x4_KHR, f: texture_compression_astc },
-  "astc-4x4-unorm-srgb": { gl: import_constants5.GL.COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR, f: texture_compression_astc },
-  "astc-5x4-unorm": { gl: import_constants5.GL.COMPRESSED_RGBA_ASTC_5x4_KHR, f: texture_compression_astc },
-  "astc-5x4-unorm-srgb": { gl: import_constants5.GL.COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR, f: texture_compression_astc },
-  "astc-5x5-unorm": { gl: import_constants5.GL.COMPRESSED_RGBA_ASTC_5x5_KHR, f: texture_compression_astc },
-  "astc-5x5-unorm-srgb": { gl: import_constants5.GL.COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR, f: texture_compression_astc },
-  "astc-6x5-unorm": { gl: import_constants5.GL.COMPRESSED_RGBA_ASTC_6x5_KHR, f: texture_compression_astc },
-  "astc-6x5-unorm-srgb": { gl: import_constants5.GL.COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR, f: texture_compression_astc },
-  "astc-6x6-unorm": { gl: import_constants5.GL.COMPRESSED_RGBA_ASTC_6x6_KHR, f: texture_compression_astc },
-  "astc-6x6-unorm-srgb": { gl: import_constants5.GL.COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR, f: texture_compression_astc },
-  "astc-8x5-unorm": { gl: import_constants5.GL.COMPRESSED_RGBA_ASTC_8x5_KHR, f: texture_compression_astc },
-  "astc-8x5-unorm-srgb": { gl: import_constants5.GL.COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR, f: texture_compression_astc },
-  "astc-8x6-unorm": { gl: import_constants5.GL.COMPRESSED_RGBA_ASTC_8x6_KHR, f: texture_compression_astc },
-  "astc-8x6-unorm-srgb": { gl: import_constants5.GL.COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR, f: texture_compression_astc },
-  "astc-8x8-unorm": { gl: import_constants5.GL.COMPRESSED_RGBA_ASTC_8x8_KHR, f: texture_compression_astc },
-  "astc-8x8-unorm-srgb": { gl: import_constants5.GL.COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR, f: texture_compression_astc },
-  "astc-10x5-unorm": { gl: import_constants5.GL.COMPRESSED_RGBA_ASTC_10x10_KHR, f: texture_compression_astc },
-  "astc-10x5-unorm-srgb": { gl: import_constants5.GL.COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR, f: texture_compression_astc },
-  "astc-10x6-unorm": { gl: import_constants5.GL.COMPRESSED_RGBA_ASTC_10x6_KHR, f: texture_compression_astc },
-  "astc-10x6-unorm-srgb": { gl: import_constants5.GL.COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR, f: texture_compression_astc },
-  "astc-10x8-unorm": { gl: import_constants5.GL.COMPRESSED_RGBA_ASTC_10x8_KHR, f: texture_compression_astc },
-  "astc-10x8-unorm-srgb": { gl: import_constants5.GL.COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR, f: texture_compression_astc },
-  "astc-10x10-unorm": { gl: import_constants5.GL.COMPRESSED_RGBA_ASTC_10x10_KHR, f: texture_compression_astc },
-  "astc-10x10-unorm-srgb": { gl: import_constants5.GL.COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR, f: texture_compression_astc },
-  "astc-12x10-unorm": { gl: import_constants5.GL.COMPRESSED_RGBA_ASTC_12x10_KHR, f: texture_compression_astc },
-  "astc-12x10-unorm-srgb": { gl: import_constants5.GL.COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR, f: texture_compression_astc },
-  "astc-12x12-unorm": { gl: import_constants5.GL.COMPRESSED_RGBA_ASTC_12x12_KHR, f: texture_compression_astc },
-  "astc-12x12-unorm-srgb": { gl: import_constants5.GL.COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR, f: texture_compression_astc },
+  "astc-4x4-unorm": { gl: import_constants6.GL.COMPRESSED_RGBA_ASTC_4x4_KHR, f: texture_compression_astc },
+  "astc-4x4-unorm-srgb": { gl: import_constants6.GL.COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR, f: texture_compression_astc },
+  "astc-5x4-unorm": { gl: import_constants6.GL.COMPRESSED_RGBA_ASTC_5x4_KHR, f: texture_compression_astc },
+  "astc-5x4-unorm-srgb": { gl: import_constants6.GL.COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR, f: texture_compression_astc },
+  "astc-5x5-unorm": { gl: import_constants6.GL.COMPRESSED_RGBA_ASTC_5x5_KHR, f: texture_compression_astc },
+  "astc-5x5-unorm-srgb": { gl: import_constants6.GL.COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR, f: texture_compression_astc },
+  "astc-6x5-unorm": { gl: import_constants6.GL.COMPRESSED_RGBA_ASTC_6x5_KHR, f: texture_compression_astc },
+  "astc-6x5-unorm-srgb": { gl: import_constants6.GL.COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR, f: texture_compression_astc },
+  "astc-6x6-unorm": { gl: import_constants6.GL.COMPRESSED_RGBA_ASTC_6x6_KHR, f: texture_compression_astc },
+  "astc-6x6-unorm-srgb": { gl: import_constants6.GL.COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR, f: texture_compression_astc },
+  "astc-8x5-unorm": { gl: import_constants6.GL.COMPRESSED_RGBA_ASTC_8x5_KHR, f: texture_compression_astc },
+  "astc-8x5-unorm-srgb": { gl: import_constants6.GL.COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR, f: texture_compression_astc },
+  "astc-8x6-unorm": { gl: import_constants6.GL.COMPRESSED_RGBA_ASTC_8x6_KHR, f: texture_compression_astc },
+  "astc-8x6-unorm-srgb": { gl: import_constants6.GL.COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR, f: texture_compression_astc },
+  "astc-8x8-unorm": { gl: import_constants6.GL.COMPRESSED_RGBA_ASTC_8x8_KHR, f: texture_compression_astc },
+  "astc-8x8-unorm-srgb": { gl: import_constants6.GL.COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR, f: texture_compression_astc },
+  "astc-10x5-unorm": { gl: import_constants6.GL.COMPRESSED_RGBA_ASTC_10x10_KHR, f: texture_compression_astc },
+  "astc-10x5-unorm-srgb": { gl: import_constants6.GL.COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR, f: texture_compression_astc },
+  "astc-10x6-unorm": { gl: import_constants6.GL.COMPRESSED_RGBA_ASTC_10x6_KHR, f: texture_compression_astc },
+  "astc-10x6-unorm-srgb": { gl: import_constants6.GL.COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR, f: texture_compression_astc },
+  "astc-10x8-unorm": { gl: import_constants6.GL.COMPRESSED_RGBA_ASTC_10x8_KHR, f: texture_compression_astc },
+  "astc-10x8-unorm-srgb": { gl: import_constants6.GL.COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR, f: texture_compression_astc },
+  "astc-10x10-unorm": { gl: import_constants6.GL.COMPRESSED_RGBA_ASTC_10x10_KHR, f: texture_compression_astc },
+  "astc-10x10-unorm-srgb": { gl: import_constants6.GL.COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR, f: texture_compression_astc },
+  "astc-12x10-unorm": { gl: import_constants6.GL.COMPRESSED_RGBA_ASTC_12x10_KHR, f: texture_compression_astc },
+  "astc-12x10-unorm-srgb": { gl: import_constants6.GL.COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR, f: texture_compression_astc },
+  "astc-12x12-unorm": { gl: import_constants6.GL.COMPRESSED_RGBA_ASTC_12x12_KHR, f: texture_compression_astc },
+  "astc-12x12-unorm-srgb": { gl: import_constants6.GL.COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR, f: texture_compression_astc },
   // WEBGL_compressed_texture_pvrtc
-  "pvrtc-rgb4unorm-webgl": { gl: import_constants5.GL.COMPRESSED_RGB_PVRTC_4BPPV1_IMG, f: texture_compression_pvrtc_webgl },
-  "pvrtc-rgba4unorm-webgl": { gl: import_constants5.GL.COMPRESSED_RGBA_PVRTC_4BPPV1_IMG, f: texture_compression_pvrtc_webgl },
-  "pvrtc-rbg2unorm-webgl": { gl: import_constants5.GL.COMPRESSED_RGB_PVRTC_2BPPV1_IMG, f: texture_compression_pvrtc_webgl },
-  "pvrtc-rgba2unorm-webgl": { gl: import_constants5.GL.COMPRESSED_RGBA_PVRTC_2BPPV1_IMG, f: texture_compression_pvrtc_webgl },
+  "pvrtc-rgb4unorm-webgl": { gl: import_constants6.GL.COMPRESSED_RGB_PVRTC_4BPPV1_IMG, f: texture_compression_pvrtc_webgl },
+  "pvrtc-rgba4unorm-webgl": { gl: import_constants6.GL.COMPRESSED_RGBA_PVRTC_4BPPV1_IMG, f: texture_compression_pvrtc_webgl },
+  "pvrtc-rbg2unorm-webgl": { gl: import_constants6.GL.COMPRESSED_RGB_PVRTC_2BPPV1_IMG, f: texture_compression_pvrtc_webgl },
+  "pvrtc-rgba2unorm-webgl": { gl: import_constants6.GL.COMPRESSED_RGBA_PVRTC_2BPPV1_IMG, f: texture_compression_pvrtc_webgl },
   // WEBGL_compressed_texture_etc1
-  "etc1-rbg-unorm-webgl": { gl: import_constants5.GL.COMPRESSED_RGB_ETC1_WEBGL, f: texture_compression_etc1_webgl },
+  "etc1-rbg-unorm-webgl": { gl: import_constants6.GL.COMPRESSED_RGB_ETC1_WEBGL, f: texture_compression_etc1_webgl },
   // WEBGL_compressed_texture_atc
-  "atc-rgb-unorm-webgl": { gl: import_constants5.GL.COMPRESSED_RGB_ATC_WEBGL, f: texture_compression_atc_webgl },
-  "atc-rgba-unorm-webgl": { gl: import_constants5.GL.COMPRESSED_RGBA_ATC_EXPLICIT_ALPHA_WEBGL, f: texture_compression_atc_webgl },
-  "atc-rgbai-unorm-webgl": { gl: import_constants5.GL.COMPRESSED_RGBA_ATC_INTERPOLATED_ALPHA_WEBGL, f: texture_compression_atc_webgl }
+  "atc-rgb-unorm-webgl": { gl: import_constants6.GL.COMPRESSED_RGB_ATC_WEBGL, f: texture_compression_atc_webgl },
+  "atc-rgba-unorm-webgl": { gl: import_constants6.GL.COMPRESSED_RGBA_ATC_EXPLICIT_ALPHA_WEBGL, f: texture_compression_atc_webgl },
+  "atc-rgbai-unorm-webgl": { gl: import_constants6.GL.COMPRESSED_RGBA_ATC_INTERPOLATED_ALPHA_WEBGL, f: texture_compression_atc_webgl }
 };
 var DATA_FORMAT_CHANNELS = {
-  [import_constants5.GL.RED]: 1,
-  [import_constants5.GL.RED_INTEGER]: 1,
-  [import_constants5.GL.RG]: 2,
-  [import_constants5.GL.RG_INTEGER]: 2,
-  [import_constants5.GL.RGB]: 3,
-  [import_constants5.GL.RGB_INTEGER]: 3,
-  [import_constants5.GL.RGBA]: 4,
-  [import_constants5.GL.RGBA_INTEGER]: 4,
-  [import_constants5.GL.DEPTH_COMPONENT]: 1,
-  [import_constants5.GL.DEPTH_STENCIL]: 1,
-  [import_constants5.GL.ALPHA]: 1,
-  [import_constants5.GL.LUMINANCE]: 1,
-  [import_constants5.GL.LUMINANCE_ALPHA]: 2
+  [import_constants6.GL.RED]: 1,
+  [import_constants6.GL.RED_INTEGER]: 1,
+  [import_constants6.GL.RG]: 2,
+  [import_constants6.GL.RG_INTEGER]: 2,
+  [import_constants6.GL.RGB]: 3,
+  [import_constants6.GL.RGB_INTEGER]: 3,
+  [import_constants6.GL.RGBA]: 4,
+  [import_constants6.GL.RGBA_INTEGER]: 4,
+  [import_constants6.GL.DEPTH_COMPONENT]: 1,
+  [import_constants6.GL.DEPTH_STENCIL]: 1,
+  [import_constants6.GL.ALPHA]: 1,
+  [import_constants6.GL.LUMINANCE]: 1,
+  [import_constants6.GL.LUMINANCE_ALPHA]: 2
 };
 var TYPE_SIZES = {
-  [import_constants5.GL.FLOAT]: 4,
-  [import_constants5.GL.UNSIGNED_INT]: 4,
-  [import_constants5.GL.INT]: 4,
-  [import_constants5.GL.UNSIGNED_SHORT]: 2,
-  [import_constants5.GL.SHORT]: 2,
-  [import_constants5.GL.HALF_FLOAT]: 2,
-  [import_constants5.GL.BYTE]: 1,
-  [import_constants5.GL.UNSIGNED_BYTE]: 1
+  [import_constants6.GL.FLOAT]: 4,
+  [import_constants6.GL.UNSIGNED_INT]: 4,
+  [import_constants6.GL.INT]: 4,
+  [import_constants6.GL.UNSIGNED_SHORT]: 2,
+  [import_constants6.GL.SHORT]: 2,
+  [import_constants6.GL.HALF_FLOAT]: 2,
+  [import_constants6.GL.BYTE]: 1,
+  [import_constants6.GL.UNSIGNED_BYTE]: 1
 };
 function isTextureFormatSupported(gl2, formatOrGL) {
   const format = convertGLToTextureFormat(formatOrGL);
@@ -1938,7 +1971,8 @@ function getWebGLTextureParameters(formatOrGL, isWebGL23) {
       decoded.normalized,
       webglFormat
     ),
-    type: getWebGLDataType(decoded.dataType),
+    // depth formats don't have a type
+    type: decoded.dataType ? getGLFromVertexType(decoded.dataType) : import_constants6.GL.UNSIGNED_BYTE,
     // @ts-expect-error
     compressed: decoded.compressed
   };
@@ -1950,12 +1984,12 @@ function getDepthStencilAttachmentWebGL(format) {
   }
   return info.attachment;
 }
-function _checkFloat32ColorAttachment(gl2, internalFormat = gl2.RGBA, srcFormat = import_constants5.GL.RGBA, srcType = import_constants5.GL.UNSIGNED_BYTE) {
+function _checkFloat32ColorAttachment(gl2, internalFormat = gl2.RGBA, srcFormat = import_constants6.GL.RGBA, srcType = import_constants6.GL.UNSIGNED_BYTE) {
   let texture = null;
   let framebuffer = null;
   try {
     texture = gl2.createTexture();
-    gl2.bindTexture(import_constants5.GL.TEXTURE_2D, texture);
+    gl2.bindTexture(import_constants6.GL.TEXTURE_2D, texture);
     const level = 0;
     const width = 1;
     const height = 1;
@@ -1973,10 +2007,10 @@ function _checkFloat32ColorAttachment(gl2, internalFormat = gl2.RGBA, srcFormat
       pixel
     );
     framebuffer = gl2.createFramebuffer();
-    gl2.bindFramebuffer(import_constants5.GL.FRAMEBUFFER, framebuffer);
-    gl2.framebufferTexture2D(import_constants5.GL.FRAMEBUFFER, import_constants5.GL.COLOR_ATTACHMENT0, import_constants5.GL.TEXTURE_2D, texture, 0);
-    const status = gl2.checkFramebufferStatus(import_constants5.GL.FRAMEBUFFER) === import_constants5.GL.FRAMEBUFFER_COMPLETE;
-    gl2.bindTexture(import_constants5.GL.TEXTURE_2D, null);
+    gl2.bindFramebuffer(import_constants6.GL.FRAMEBUFFER, framebuffer);
+    gl2.framebufferTexture2D(import_constants6.GL.FRAMEBUFFER, import_constants6.GL.COLOR_ATTACHMENT0, import_constants6.GL.TEXTURE_2D, texture, 0);
+    const status = gl2.checkFramebufferStatus(import_constants6.GL.FRAMEBUFFER) === import_constants6.GL.FRAMEBUFFER_COMPLETE;
+    gl2.bindTexture(import_constants6.GL.TEXTURE_2D, null);
     return status;
   } finally {
     gl2.deleteTexture(texture);
@@ -1991,42 +2025,20 @@ function getTextureFormatBytesPerPixel(formatOrGL, isWebGL23) {
   return channels * channelSize;
 }
 function getWebGLPixelDataFormat(dataFormat, integer, normalized, format) {
-  if (format === import_constants5.GL.RGBA || format === import_constants5.GL.RGB) {
+  if (format === import_constants6.GL.RGBA || format === import_constants6.GL.RGB) {
     return format;
   }
   switch (dataFormat) {
     case "r":
-      return integer && !normalized ? import_constants5.GL.RED_INTEGER : import_constants5.GL.RED;
+      return integer && !normalized ? import_constants6.GL.RED_INTEGER : import_constants6.GL.RED;
     case "rg":
-      return integer && !normalized ? import_constants5.GL.RG_INTEGER : import_constants5.GL.RG;
+      return integer && !normalized ? import_constants6.GL.RG_INTEGER : import_constants6.GL.RG;
     case "rgb":
-      return integer && !normalized ? import_constants5.GL.RGB_INTEGER : import_constants5.GL.RGB;
+      return integer && !normalized ? import_constants6.GL.RGB_INTEGER : import_constants6.GL.RGB;
     case "rgba":
-      return integer && !normalized ? import_constants5.GL.RGBA_INTEGER : import_constants5.GL.RGBA;
-    default:
-      return import_constants5.GL.RGBA;
-  }
-}
-function getWebGLDataType(dataType) {
-  switch (dataType) {
-    case "uint8":
-      return import_constants5.GL.UNSIGNED_BYTE;
-    case "sint8":
-      return import_constants5.GL.BYTE;
-    case "uint16":
-      return import_constants5.GL.UNSIGNED_SHORT;
-    case "sint16":
-      return import_constants5.GL.SHORT;
-    case "uint32":
-      return import_constants5.GL.UNSIGNED_INT;
-    case "sint32":
-      return import_constants5.GL.INT;
-    case "float16":
-      return import_constants5.GL.HALF_FLOAT;
-    case "float32":
-      return import_constants5.GL.FLOAT;
+      return integer && !normalized ? import_constants6.GL.RGBA_INTEGER : import_constants6.GL.RGBA;
     default:
-      return import_constants5.GL.UNSIGNED_BYTE;
+      return import_constants6.GL.RGBA;
   }
 }
 
@@ -2128,39 +2140,39 @@ var WEBGL_FEATURES = {
 };
 
 // src/adapter/device-helpers/device-limits.ts
-var import_constants6 = require("@luma.gl/constants");
+var import_constants7 = require("@luma.gl/constants");
 function getDeviceLimits(gl2) {
   const gl22 = getWebGL2Context(gl2);
   return {
     maxTextureDimension1D: 0,
     // WebGL does not support 1D textures
-    maxTextureDimension2D: gl2.getParameter(import_constants6.GL.MAX_TEXTURE_SIZE),
-    maxTextureDimension3D: gl22 ? gl22.getParameter(import_constants6.GL.MAX_3D_TEXTURE_SIZE) : 0,
-    maxTextureArrayLayers: gl22 ? gl22.getParameter(import_constants6.GL.MAX_ARRAY_TEXTURE_LAYERS) : 0,
+    maxTextureDimension2D: gl2.getParameter(import_constants7.GL.MAX_TEXTURE_SIZE),
+    maxTextureDimension3D: gl22 ? gl22.getParameter(import_constants7.GL.MAX_3D_TEXTURE_SIZE) : 0,
+    maxTextureArrayLayers: gl22 ? gl22.getParameter(import_constants7.GL.MAX_ARRAY_TEXTURE_LAYERS) : 0,
     maxBindGroups: 1,
     // TBD
     maxDynamicUniformBuffersPerPipelineLayout: 0,
     // TBD
     maxDynamicStorageBuffersPerPipelineLayout: 0,
     // TBD
-    maxSampledTexturesPerShaderStage: gl2.getParameter(import_constants6.GL.MAX_VERTEX_TEXTURE_IMAGE_UNITS),
+    maxSampledTexturesPerShaderStage: gl2.getParameter(import_constants7.GL.MAX_VERTEX_TEXTURE_IMAGE_UNITS),
     // TBD
-    maxSamplersPerShaderStage: gl2.getParameter(import_constants6.GL.MAX_COMBINED_TEXTURE_IMAGE_UNITS),
+    maxSamplersPerShaderStage: gl2.getParameter(import_constants7.GL.MAX_COMBINED_TEXTURE_IMAGE_UNITS),
     maxStorageBuffersPerShaderStage: 0,
     // TBD
     maxStorageTexturesPerShaderStage: 0,
     // TBD
-    maxUniformBuffersPerShaderStage: gl22 ? gl22.getParameter(import_constants6.GL.MAX_UNIFORM_BUFFER_BINDINGS) : 0,
-    maxUniformBufferBindingSize: gl22 ? gl22.getParameter(import_constants6.GL.MAX_UNIFORM_BLOCK_SIZE) : 0,
+    maxUniformBuffersPerShaderStage: gl22 ? gl22.getParameter(import_constants7.GL.MAX_UNIFORM_BUFFER_BINDINGS) : 0,
+    maxUniformBufferBindingSize: gl22 ? gl22.getParameter(import_constants7.GL.MAX_UNIFORM_BLOCK_SIZE) : 0,
     maxStorageBufferBindingSize: 0,
-    minUniformBufferOffsetAlignment: gl22 ? gl22.getParameter(import_constants6.GL.UNIFORM_BUFFER_OFFSET_ALIGNMENT) : 0,
+    minUniformBufferOffsetAlignment: gl22 ? gl22.getParameter(import_constants7.GL.UNIFORM_BUFFER_OFFSET_ALIGNMENT) : 0,
     minStorageBufferOffsetAlignment: 0,
     // TBD
     maxVertexBuffers: 0,
-    maxVertexAttributes: gl2.getParameter(import_constants6.GL.MAX_VERTEX_ATTRIBS),
+    maxVertexAttributes: gl2.getParameter(import_constants7.GL.MAX_VERTEX_ATTRIBS),
     maxVertexBufferArrayStride: 2048,
     // TBD, this is just the default value from WebGPU
-    maxInterStageShaderComponents: gl22 ? gl22.getParameter(import_constants6.GL.MAX_VARYING_COMPONENTS) : 0,
+    maxInterStageShaderComponents: gl22 ? gl22.getParameter(import_constants7.GL.MAX_VARYING_COMPONENTS) : 0,
     maxComputeWorkgroupStorageSize: 0,
     // WebGL does not support compute shaders
     maxComputeInvocationsPerWorkgroup: 0,
@@ -2184,89 +2196,89 @@ function getWebGLLimits(gl2) {
     return gl22 ? gl22.getParameter(pname) : defaultValue || 0;
   }
   return {
-    [import_constants6.GL.ALIASED_LINE_WIDTH_RANGE]: get(import_constants6.GL.ALIASED_LINE_WIDTH_RANGE),
-    [import_constants6.GL.ALIASED_POINT_SIZE_RANGE]: get(import_constants6.GL.ALIASED_POINT_SIZE_RANGE),
-    [import_constants6.GL.MAX_TEXTURE_SIZE]: get(import_constants6.GL.MAX_TEXTURE_SIZE),
-    [import_constants6.GL.MAX_CUBE_MAP_TEXTURE_SIZE]: get(import_constants6.GL.MAX_CUBE_MAP_TEXTURE_SIZE),
+    [import_constants7.GL.ALIASED_LINE_WIDTH_RANGE]: get(import_constants7.GL.ALIASED_LINE_WIDTH_RANGE),
+    [import_constants7.GL.ALIASED_POINT_SIZE_RANGE]: get(import_constants7.GL.ALIASED_POINT_SIZE_RANGE),
+    [import_constants7.GL.MAX_TEXTURE_SIZE]: get(import_constants7.GL.MAX_TEXTURE_SIZE),
+    [import_constants7.GL.MAX_CUBE_MAP_TEXTURE_SIZE]: get(import_constants7.GL.MAX_CUBE_MAP_TEXTURE_SIZE),
     // GLint
-    [import_constants6.GL.MAX_TEXTURE_IMAGE_UNITS]: get(import_constants6.GL.MAX_TEXTURE_IMAGE_UNITS),
+    [import_constants7.GL.MAX_TEXTURE_IMAGE_UNITS]: get(import_constants7.GL.MAX_TEXTURE_IMAGE_UNITS),
     // GLint
-    [import_constants6.GL.MAX_COMBINED_TEXTURE_IMAGE_UNITS]: get(import_constants6.GL.MAX_COMBINED_TEXTURE_IMAGE_UNITS),
+    [import_constants7.GL.MAX_COMBINED_TEXTURE_IMAGE_UNITS]: get(import_constants7.GL.MAX_COMBINED_TEXTURE_IMAGE_UNITS),
     // GLint
-    [import_constants6.GL.MAX_VERTEX_TEXTURE_IMAGE_UNITS]: get(import_constants6.GL.MAX_VERTEX_TEXTURE_IMAGE_UNITS),
+    [import_constants7.GL.MAX_VERTEX_TEXTURE_IMAGE_UNITS]: get(import_constants7.GL.MAX_VERTEX_TEXTURE_IMAGE_UNITS),
     // GLint
-    [import_constants6.GL.MAX_RENDERBUFFER_SIZE]: get(import_constants6.GL.MAX_RENDERBUFFER_SIZE),
+    [import_constants7.GL.MAX_RENDERBUFFER_SIZE]: get(import_constants7.GL.MAX_RENDERBUFFER_SIZE),
     // GLint
-    [import_constants6.GL.MAX_VARYING_VECTORS]: get(import_constants6.GL.MAX_VARYING_VECTORS),
+    [import_constants7.GL.MAX_VARYING_VECTORS]: get(import_constants7.GL.MAX_VARYING_VECTORS),
     // GLint
-    [import_constants6.GL.MAX_VERTEX_ATTRIBS]: get(import_constants6.GL.MAX_VERTEX_ATTRIBS),
+    [import_constants7.GL.MAX_VERTEX_ATTRIBS]: get(import_constants7.GL.MAX_VERTEX_ATTRIBS),
     // GLint
-    [import_constants6.GL.MAX_VERTEX_UNIFORM_VECTORS]: get(import_constants6.GL.MAX_VERTEX_UNIFORM_VECTORS),
+    [import_constants7.GL.MAX_VERTEX_UNIFORM_VECTORS]: get(import_constants7.GL.MAX_VERTEX_UNIFORM_VECTORS),
     // GLint
-    [import_constants6.GL.MAX_FRAGMENT_UNIFORM_VECTORS]: get(import_constants6.GL.MAX_FRAGMENT_UNIFORM_VECTORS),
+    [import_constants7.GL.MAX_FRAGMENT_UNIFORM_VECTORS]: get(import_constants7.GL.MAX_FRAGMENT_UNIFORM_VECTORS),
     // GLint
-    [import_constants6.GL.MAX_VIEWPORT_DIMS]: get(import_constants6.GL.MAX_VIEWPORT_DIMS),
+    [import_constants7.GL.MAX_VIEWPORT_DIMS]: get(import_constants7.GL.MAX_VIEWPORT_DIMS),
     // Extensions
-    [import_constants6.GL.MAX_TEXTURE_MAX_ANISOTROPY_EXT]: get(import_constants6.GL.MAX_TEXTURE_MAX_ANISOTROPY_EXT),
+    [import_constants7.GL.MAX_TEXTURE_MAX_ANISOTROPY_EXT]: get(import_constants7.GL.MAX_TEXTURE_MAX_ANISOTROPY_EXT),
     // getMaxAnistropy(),
     // WebGL2 Limits
-    [import_constants6.GL.MAX_3D_TEXTURE_SIZE]: get2(import_constants6.GL.MAX_3D_TEXTURE_SIZE),
+    [import_constants7.GL.MAX_3D_TEXTURE_SIZE]: get2(import_constants7.GL.MAX_3D_TEXTURE_SIZE),
     //  GLint
-    [import_constants6.GL.MAX_ARRAY_TEXTURE_LAYERS]: get2(import_constants6.GL.MAX_ARRAY_TEXTURE_LAYERS),
+    [import_constants7.GL.MAX_ARRAY_TEXTURE_LAYERS]: get2(import_constants7.GL.MAX_ARRAY_TEXTURE_LAYERS),
     // GLint
-    [import_constants6.GL.MAX_CLIENT_WAIT_TIMEOUT_WEBGL]: get2(import_constants6.GL.MAX_CLIENT_WAIT_TIMEOUT_WEBGL),
+    [import_constants7.GL.MAX_CLIENT_WAIT_TIMEOUT_WEBGL]: get2(import_constants7.GL.MAX_CLIENT_WAIT_TIMEOUT_WEBGL),
     //  GLint64
-    [import_constants6.GL.MAX_COLOR_ATTACHMENTS]: get2(import_constants6.GL.MAX_COLOR_ATTACHMENTS),
+    [import_constants7.GL.MAX_COLOR_ATTACHMENTS]: get2(import_constants7.GL.MAX_COLOR_ATTACHMENTS),
     //  GLint
-    [import_constants6.GL.MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS]: get2(import_constants6.GL.MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS),
+    [import_constants7.GL.MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS]: get2(import_constants7.GL.MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS),
     // GLint64
-    [import_constants6.GL.MAX_COMBINED_UNIFORM_BLOCKS]: get2(import_constants6.GL.MAX_COMBINED_UNIFORM_BLOCKS),
+    [import_constants7.GL.MAX_COMBINED_UNIFORM_BLOCKS]: get2(import_constants7.GL.MAX_COMBINED_UNIFORM_BLOCKS),
     //  GLint
-    [import_constants6.GL.MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS]: get2(import_constants6.GL.MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS),
+    [import_constants7.GL.MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS]: get2(import_constants7.GL.MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS),
     // GLint64
-    [import_constants6.GL.MAX_DRAW_BUFFERS]: get2(import_constants6.GL.MAX_DRAW_BUFFERS),
+    [import_constants7.GL.MAX_DRAW_BUFFERS]: get2(import_constants7.GL.MAX_DRAW_BUFFERS),
     // GLint
-    [import_constants6.GL.MAX_ELEMENT_INDEX]: get2(import_constants6.GL.MAX_ELEMENT_INDEX),
+    [import_constants7.GL.MAX_ELEMENT_INDEX]: get2(import_constants7.GL.MAX_ELEMENT_INDEX),
     //  GLint64
-    [import_constants6.GL.MAX_ELEMENTS_INDICES]: get2(import_constants6.GL.MAX_ELEMENTS_INDICES),
+    [import_constants7.GL.MAX_ELEMENTS_INDICES]: get2(import_constants7.GL.MAX_ELEMENTS_INDICES),
     // GLint
-    [import_constants6.GL.MAX_ELEMENTS_VERTICES]: get2(import_constants6.GL.MAX_ELEMENTS_VERTICES),
+    [import_constants7.GL.MAX_ELEMENTS_VERTICES]: get2(import_constants7.GL.MAX_ELEMENTS_VERTICES),
     //  GLint
-    [import_constants6.GL.MAX_FRAGMENT_INPUT_COMPONENTS]: get2(import_constants6.GL.MAX_FRAGMENT_INPUT_COMPONENTS),
+    [import_constants7.GL.MAX_FRAGMENT_INPUT_COMPONENTS]: get2(import_constants7.GL.MAX_FRAGMENT_INPUT_COMPONENTS),
     //  GLint
-    [import_constants6.GL.MAX_FRAGMENT_UNIFORM_BLOCKS]: get2(import_constants6.GL.MAX_FRAGMENT_UNIFORM_BLOCKS),
+    [import_constants7.GL.MAX_FRAGMENT_UNIFORM_BLOCKS]: get2(import_constants7.GL.MAX_FRAGMENT_UNIFORM_BLOCKS),
     //  GLint
-    [import_constants6.GL.MAX_FRAGMENT_UNIFORM_COMPONENTS]: get2(import_constants6.GL.MAX_FRAGMENT_UNIFORM_COMPONENTS),
+    [import_constants7.GL.MAX_FRAGMENT_UNIFORM_COMPONENTS]: get2(import_constants7.GL.MAX_FRAGMENT_UNIFORM_COMPONENTS),
     //  GLint
-    [import_constants6.GL.MAX_SAMPLES]: get2(import_constants6.GL.MAX_SAMPLES),
+    [import_constants7.GL.MAX_SAMPLES]: get2(import_constants7.GL.MAX_SAMPLES),
     //  GLint
-    [import_constants6.GL.MAX_SERVER_WAIT_TIMEOUT]: get2(import_constants6.GL.MAX_SERVER_WAIT_TIMEOUT),
+    [import_constants7.GL.MAX_SERVER_WAIT_TIMEOUT]: get2(import_constants7.GL.MAX_SERVER_WAIT_TIMEOUT),
     //  GLint64
-    [import_constants6.GL.MAX_TEXTURE_LOD_BIAS]: get2(import_constants6.GL.MAX_TEXTURE_LOD_BIAS),
+    [import_constants7.GL.MAX_TEXTURE_LOD_BIAS]: get2(import_constants7.GL.MAX_TEXTURE_LOD_BIAS),
     // GLfloat
-    [import_constants6.GL.MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS]: get2(import_constants6.GL.MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS),
+    [import_constants7.GL.MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS]: get2(import_constants7.GL.MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS),
     //  GLint
-    [import_constants6.GL.MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS]: get2(import_constants6.GL.MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS),
+    [import_constants7.GL.MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS]: get2(import_constants7.GL.MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS),
     //  GLint
-    [import_constants6.GL.MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS]: get2(import_constants6.GL.MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS),
+    [import_constants7.GL.MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS]: get2(import_constants7.GL.MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS),
     // GLint
-    [import_constants6.GL.MAX_UNIFORM_BLOCK_SIZE]: get2(import_constants6.GL.MAX_UNIFORM_BLOCK_SIZE),
+    [import_constants7.GL.MAX_UNIFORM_BLOCK_SIZE]: get2(import_constants7.GL.MAX_UNIFORM_BLOCK_SIZE),
     // GLint64
-    [import_constants6.GL.MAX_UNIFORM_BUFFER_BINDINGS]: get2(import_constants6.GL.MAX_UNIFORM_BUFFER_BINDINGS),
+    [import_constants7.GL.MAX_UNIFORM_BUFFER_BINDINGS]: get2(import_constants7.GL.MAX_UNIFORM_BUFFER_BINDINGS),
     //  GLint
-    [import_constants6.GL.MAX_VARYING_COMPONENTS]: get2(import_constants6.GL.MAX_VARYING_COMPONENTS),
+    [import_constants7.GL.MAX_VARYING_COMPONENTS]: get2(import_constants7.GL.MAX_VARYING_COMPONENTS),
     // GLint
-    [import_constants6.GL.MAX_VERTEX_OUTPUT_COMPONENTS]: get2(import_constants6.GL.MAX_VERTEX_OUTPUT_COMPONENTS),
+    [import_constants7.GL.MAX_VERTEX_OUTPUT_COMPONENTS]: get2(import_constants7.GL.MAX_VERTEX_OUTPUT_COMPONENTS),
     // GLint
-    [import_constants6.GL.MAX_VERTEX_UNIFORM_BLOCKS]: get2(import_constants6.GL.MAX_VERTEX_UNIFORM_BLOCKS),
+    [import_constants7.GL.MAX_VERTEX_UNIFORM_BLOCKS]: get2(import_constants7.GL.MAX_VERTEX_UNIFORM_BLOCKS),
     //  GLint
-    [import_constants6.GL.MAX_VERTEX_UNIFORM_COMPONENTS]: get2(import_constants6.GL.MAX_VERTEX_UNIFORM_COMPONENTS),
+    [import_constants7.GL.MAX_VERTEX_UNIFORM_COMPONENTS]: get2(import_constants7.GL.MAX_VERTEX_UNIFORM_COMPONENTS),
     //  GLint
-    [import_constants6.GL.MIN_PROGRAM_TEXEL_OFFSET]: get2(import_constants6.GL.MIN_PROGRAM_TEXEL_OFFSET),
+    [import_constants7.GL.MIN_PROGRAM_TEXEL_OFFSET]: get2(import_constants7.GL.MIN_PROGRAM_TEXEL_OFFSET),
     // GLint
-    [import_constants6.GL.MAX_PROGRAM_TEXEL_OFFSET]: get2(import_constants6.GL.MAX_PROGRAM_TEXEL_OFFSET),
+    [import_constants7.GL.MAX_PROGRAM_TEXEL_OFFSET]: get2(import_constants7.GL.MAX_PROGRAM_TEXEL_OFFSET),
     // GLint
-    [import_constants6.GL.UNIFORM_BUFFER_OFFSET_ALIGNMENT]: get2(import_constants6.GL.UNIFORM_BUFFER_OFFSET_ALIGNMENT)
+    [import_constants7.GL.UNIFORM_BUFFER_OFFSET_ALIGNMENT]: get2(import_constants7.GL.UNIFORM_BUFFER_OFFSET_ALIGNMENT)
     // GLint
   };
 }
@@ -2276,12 +2288,12 @@ var import_core15 = require("@luma.gl/core");
 
 // src/adapter/resources/webgl-framebuffer.ts
 var import_core14 = require("@luma.gl/core");
-var import_constants13 = require("@luma.gl/constants");
+var import_constants14 = require("@luma.gl/constants");
 
 // src/adapter/resources/webgl-texture.ts
 var import_core9 = require("@luma.gl/core");
 var import_core10 = require("@luma.gl/core");
-var import_constants11 = require("@luma.gl/constants");
+var import_constants12 = require("@luma.gl/constants");
 
 // src/context/state-tracker/with-parameters.ts
 function withParameters(device, parameters, func) {
@@ -2314,11 +2326,11 @@ function isObjectEmpty2(object) {
 }
 
 // src/adapter/converters/sampler-parameters.ts
-var import_constants8 = require("@luma.gl/constants");
+var import_constants9 = require("@luma.gl/constants");
 
 // src/adapter/converters/device-parameters.ts
 var import_core6 = require("@luma.gl/core");
-var import_constants7 = require("@luma.gl/constants");
+var import_constants8 = require("@luma.gl/constants");
 function withGLParameters(device, parameters, func) {
   if ((0, import_core6.isObjectEmpty)(parameters)) {
     return func(device);
@@ -2349,23 +2361,23 @@ function setDeviceParameters(device, parameters) {
   if (parameters.cullMode) {
     switch (parameters.cullMode) {
       case "none":
-        gl2.disable(import_constants7.GL.CULL_FACE);
+        gl2.disable(import_constants8.GL.CULL_FACE);
         break;
       case "front":
-        gl2.enable(import_constants7.GL.CULL_FACE);
-        gl2.cullFace(import_constants7.GL.FRONT);
+        gl2.enable(import_constants8.GL.CULL_FACE);
+        gl2.cullFace(import_constants8.GL.FRONT);
         break;
       case "back":
-        gl2.enable(import_constants7.GL.CULL_FACE);
-        gl2.cullFace(import_constants7.GL.BACK);
+        gl2.enable(import_constants8.GL.CULL_FACE);
+        gl2.cullFace(import_constants8.GL.BACK);
         break;
     }
   }
   if (parameters.frontFace) {
     gl2.frontFace(
       map("frontFace", parameters.frontFace, {
-        ccw: import_constants7.GL.CCW,
-        cw: import_constants7.GL.CW
+        ccw: import_constants8.GL.CCW,
+        cw: import_constants8.GL.CW
       })
     );
   }
@@ -2376,13 +2388,13 @@ function setDeviceParameters(device, parameters) {
     gl2.depthMask(mapBoolean("depthWriteEnabled", parameters.depthWriteEnabled));
   }
   if (parameters.depthCompare) {
-    parameters.depthCompare !== "always" ? gl2.enable(import_constants7.GL.DEPTH_TEST) : gl2.disable(import_constants7.GL.DEPTH_TEST);
+    parameters.depthCompare !== "always" ? gl2.enable(import_constants8.GL.DEPTH_TEST) : gl2.disable(import_constants8.GL.DEPTH_TEST);
     gl2.depthFunc(convertCompareFunction("depthCompare", parameters.depthCompare));
   }
   if (parameters.stencilWriteMask) {
     const mask = parameters.stencilWriteMask;
-    gl2.stencilMaskSeparate(import_constants7.GL.FRONT, mask);
-    gl2.stencilMaskSeparate(import_constants7.GL.BACK, mask);
+    gl2.stencilMaskSeparate(import_constants8.GL.FRONT, mask);
+    gl2.stencilMaskSeparate(import_constants8.GL.BACK, mask);
   }
   if (parameters.stencilReadMask) {
     import_core6.log.warn("stencilReadMask not supported under WebGL");
@@ -2390,9 +2402,9 @@ function setDeviceParameters(device, parameters) {
   if (parameters.stencilCompare) {
     const mask = parameters.stencilReadMask || 4294967295;
     const glValue = convertCompareFunction("depthCompare", parameters.stencilCompare);
-    parameters.stencilCompare !== "always" ? gl2.enable(import_constants7.GL.STENCIL_TEST) : gl2.disable(import_constants7.GL.STENCIL_TEST);
-    gl2.stencilFuncSeparate(import_constants7.GL.FRONT, glValue, 0, mask);
-    gl2.stencilFuncSeparate(import_constants7.GL.BACK, glValue, 0, mask);
+    parameters.stencilCompare !== "always" ? gl2.enable(import_constants8.GL.STENCIL_TEST) : gl2.disable(import_constants8.GL.STENCIL_TEST);
+    gl2.stencilFuncSeparate(import_constants8.GL.FRONT, glValue, 0, mask);
+    gl2.stencilFuncSeparate(import_constants8.GL.BACK, glValue, 0, mask);
   }
   if (parameters.stencilPassOperation && parameters.stencilFailOperation && parameters.stencilDepthFailOperation) {
     const dppass = convertStencilOperation("stencilPassOperation", parameters.stencilPassOperation);
@@ -2401,32 +2413,32 @@ function setDeviceParameters(device, parameters) {
       "stencilDepthFailOperation",
       parameters.stencilDepthFailOperation
     );
-    gl2.stencilOpSeparate(import_constants7.GL.FRONT, sfail, dpfail, dppass);
-    gl2.stencilOpSeparate(import_constants7.GL.BACK, sfail, dpfail, dppass);
+    gl2.stencilOpSeparate(import_constants8.GL.FRONT, sfail, dpfail, dppass);
+    gl2.stencilOpSeparate(import_constants8.GL.BACK, sfail, dpfail, dppass);
   }
 }
 function convertCompareFunction(parameter, value) {
   return map(parameter, value, {
-    never: import_constants7.GL.NEVER,
-    less: import_constants7.GL.LESS,
-    equal: import_constants7.GL.EQUAL,
-    "less-equal": import_constants7.GL.LEQUAL,
-    greater: import_constants7.GL.GREATER,
-    "not-equal": import_constants7.GL.NOTEQUAL,
-    "greater-equal": import_constants7.GL.GEQUAL,
-    always: import_constants7.GL.ALWAYS
+    never: import_constants8.GL.NEVER,
+    less: import_constants8.GL.LESS,
+    equal: import_constants8.GL.EQUAL,
+    "less-equal": import_constants8.GL.LEQUAL,
+    greater: import_constants8.GL.GREATER,
+    "not-equal": import_constants8.GL.NOTEQUAL,
+    "greater-equal": import_constants8.GL.GEQUAL,
+    always: import_constants8.GL.ALWAYS
   });
 }
 function convertStencilOperation(parameter, value) {
   return map(parameter, value, {
-    keep: import_constants7.GL.KEEP,
-    zero: import_constants7.GL.ZERO,
-    replace: import_constants7.GL.REPLACE,
-    invert: import_constants7.GL.INVERT,
-    "increment-clamp": import_constants7.GL.INCR,
-    "decrement-clamp": import_constants7.GL.DECR,
-    "increment-wrap": import_constants7.GL.INCR_WRAP,
-    "decrement-wrap": import_constants7.GL.DECR_WRAP
+    keep: import_constants8.GL.KEEP,
+    zero: import_constants8.GL.ZERO,
+    replace: import_constants8.GL.REPLACE,
+    invert: import_constants8.GL.INVERT,
+    "increment-clamp": import_constants8.GL.INCR,
+    "decrement-clamp": import_constants8.GL.DECR,
+    "increment-wrap": import_constants8.GL.INCR_WRAP,
+    "decrement-wrap": import_constants8.GL.DECR_WRAP
   });
 }
 function message(parameter, value) {
@@ -2446,53 +2458,53 @@ function mapBoolean(parameter, value) {
 function convertSamplerParametersToWebGL(props) {
   const params = {};
   if (props.addressModeU) {
-    params[import_constants8.GL.TEXTURE_WRAP_S] = convertAddressMode(props.addressModeU);
+    params[import_constants9.GL.TEXTURE_WRAP_S] = convertAddressMode(props.addressModeU);
   }
   if (props.addressModeV) {
-    params[import_constants8.GL.TEXTURE_WRAP_T] = convertAddressMode(props.addressModeV);
+    params[import_constants9.GL.TEXTURE_WRAP_T] = convertAddressMode(props.addressModeV);
   }
   if (props.addressModeW) {
-    params[import_constants8.GL.TEXTURE_WRAP_R] = convertAddressMode(props.addressModeW);
+    params[import_constants9.GL.TEXTURE_WRAP_R] = convertAddressMode(props.addressModeW);
   }
   if (props.magFilter) {
-    params[import_constants8.GL.TEXTURE_MAG_FILTER] = convertMaxFilterMode(props.magFilter);
+    params[import_constants9.GL.TEXTURE_MAG_FILTER] = convertMaxFilterMode(props.magFilter);
   }
   if (props.minFilter || props.mipmapFilter) {
-    params[import_constants8.GL.TEXTURE_MIN_FILTER] = convertMinFilterMode(props.minFilter || "linear", props.mipmapFilter);
+    params[import_constants9.GL.TEXTURE_MIN_FILTER] = convertMinFilterMode(props.minFilter || "linear", props.mipmapFilter);
   }
   if (props.lodMinClamp !== void 0) {
-    params[import_constants8.GL.TEXTURE_MIN_LOD] = props.lodMinClamp;
+    params[import_constants9.GL.TEXTURE_MIN_LOD] = props.lodMinClamp;
   }
   if (props.lodMaxClamp !== void 0) {
-    params[import_constants8.GL.TEXTURE_MAX_LOD] = props.lodMaxClamp;
+    params[import_constants9.GL.TEXTURE_MAX_LOD] = props.lodMaxClamp;
   }
   if (props.type === "comparison-sampler") {
-    params[import_constants8.GL.TEXTURE_COMPARE_MODE] = import_constants8.GL.COMPARE_REF_TO_TEXTURE;
+    params[import_constants9.GL.TEXTURE_COMPARE_MODE] = import_constants9.GL.COMPARE_REF_TO_TEXTURE;
   }
   if (props.compare) {
-    params[import_constants8.GL.TEXTURE_COMPARE_FUNC] = convertCompareFunction("compare", props.compare);
+    params[import_constants9.GL.TEXTURE_COMPARE_FUNC] = convertCompareFunction("compare", props.compare);
   }
   if (props.maxAnisotropy) {
-    params[import_constants8.GL.TEXTURE_MAX_ANISOTROPY_EXT] = props.maxAnisotropy;
+    params[import_constants9.GL.TEXTURE_MAX_ANISOTROPY_EXT] = props.maxAnisotropy;
   }
   return params;
 }
 function convertAddressMode(addressMode) {
   switch (addressMode) {
     case "clamp-to-edge":
-      return import_constants8.GL.CLAMP_TO_EDGE;
+      return import_constants9.GL.CLAMP_TO_EDGE;
     case "repeat":
-      return import_constants8.GL.REPEAT;
+      return import_constants9.GL.REPEAT;
     case "mirror-repeat":
-      return import_constants8.GL.MIRRORED_REPEAT;
+      return import_constants9.GL.MIRRORED_REPEAT;
   }
 }
 function convertMaxFilterMode(maxFilter) {
   switch (maxFilter) {
     case "nearest":
-      return import_constants8.GL.NEAREST;
+      return import_constants9.GL.NEAREST;
     case "linear":
-      return import_constants8.GL.LINEAR;
+      return import_constants9.GL.LINEAR;
   }
 }
 function convertMinFilterMode(minFilter, mipmapFilter) {
@@ -2501,30 +2513,30 @@ function convertMinFilterMode(minFilter, mipmapFilter) {
   }
   switch (minFilter) {
     case "nearest":
-      return mipmapFilter === "nearest" ? import_constants8.GL.NEAREST_MIPMAP_NEAREST : import_constants8.GL.NEAREST_MIPMAP_LINEAR;
+      return mipmapFilter === "nearest" ? import_constants9.GL.NEAREST_MIPMAP_NEAREST : import_constants9.GL.NEAREST_MIPMAP_LINEAR;
     case "linear":
-      return mipmapFilter === "nearest" ? import_constants8.GL.LINEAR_MIPMAP_NEAREST : import_constants8.GL.LINEAR_MIPMAP_LINEAR;
+      return mipmapFilter === "nearest" ? import_constants9.GL.LINEAR_MIPMAP_NEAREST : import_constants9.GL.LINEAR_MIPMAP_LINEAR;
   }
 }
 function updateSamplerParametersForNPOT(parameters) {
   const newParameters = __spreadValues({}, parameters);
-  if (parameters[import_constants8.GL.TEXTURE_MIN_FILTER] !== import_constants8.GL.NEAREST) {
-    newParameters[import_constants8.GL.TEXTURE_MIN_FILTER] = import_constants8.GL.LINEAR;
+  if (parameters[import_constants9.GL.TEXTURE_MIN_FILTER] !== import_constants9.GL.NEAREST) {
+    newParameters[import_constants9.GL.TEXTURE_MIN_FILTER] = import_constants9.GL.LINEAR;
   }
-  newParameters[import_constants8.GL.TEXTURE_WRAP_S] = import_constants8.GL.CLAMP_TO_EDGE;
-  newParameters[import_constants8.GL.TEXTURE_WRAP_T] = import_constants8.GL.CLAMP_TO_EDGE;
+  newParameters[import_constants9.GL.TEXTURE_WRAP_S] = import_constants9.GL.CLAMP_TO_EDGE;
+  newParameters[import_constants9.GL.TEXTURE_WRAP_T] = import_constants9.GL.CLAMP_TO_EDGE;
   return newParameters;
 }
 
 // src/adapter/resources/webgl-buffer.ts
 var import_core7 = require("@luma.gl/core");
-var import_constants9 = require("@luma.gl/constants");
+var import_constants10 = require("@luma.gl/constants");
 var DEBUG_DATA_LENGTH = 10;
 var WEBGLBuffer = class extends import_core7.Buffer {
   constructor(device, props = {}) {
     super(device, props);
     /** Index type is needed when issuing draw calls, so we pre-compute it */
-    this.glIndexType = import_constants9.GL.UNSIGNED_SHORT;
+    this.glIndexType = import_constants10.GL.UNSIGNED_SHORT;
     /** A partial CPU-side copy of the data in this buffer, for debugging purposes */
     this.debugData = null;
     this.device = device;
@@ -2535,7 +2547,7 @@ var WEBGLBuffer = class extends import_core7.Buffer {
     device.setSpectorMetadata(this.handle, __spreadProps(__spreadValues({}, this.props), { data: typeof this.props.data }));
     this.glTarget = getWebGLTarget(this.props.usage);
     this.glUsage = getWebGLUsage(this.props.usage);
-    this.glIndexType = this.props.indexType === "uint32" ? import_constants9.GL.UNSIGNED_INT : import_constants9.GL.UNSIGNED_SHORT;
+    this.glIndexType = this.props.indexType === "uint32" ? import_constants10.GL.UNSIGNED_INT : import_constants10.GL.UNSIGNED_SHORT;
     this.debugData = null;
     if (props.data) {
       this._initWithData(props.data, props.byteOffset, props.byteLength);
@@ -2586,7 +2598,7 @@ var WEBGLBuffer = class extends import_core7.Buffer {
   write(data, byteOffset = 0) {
     const srcOffset = 0;
     const byteLength = void 0;
-    const glTarget = this.device.isWebGL2 ? import_constants9.GL.COPY_WRITE_BUFFER : this.glTarget;
+    const glTarget = this.device.isWebGL2 ? import_constants10.GL.COPY_WRITE_BUFFER : this.glTarget;
     this.gl.bindBuffer(glTarget, this.handle);
     if (srcOffset !== 0 || byteLength !== void 0) {
       this.device.assertWebGL2();
@@ -2602,9 +2614,9 @@ var WEBGLBuffer = class extends import_core7.Buffer {
       this.device.assertWebGL2();
       const data = new Uint8Array(byteLength);
       const dstOffset = 0;
-      this.gl.bindBuffer(import_constants9.GL.COPY_READ_BUFFER, this.handle);
-      this.gl2.getBufferSubData(import_constants9.GL.COPY_READ_BUFFER, byteOffset, data, dstOffset, byteLength);
-      this.gl.bindBuffer(import_constants9.GL.COPY_READ_BUFFER, null);
+      this.gl.bindBuffer(import_constants10.GL.COPY_READ_BUFFER, this.handle);
+      this.gl2.getBufferSubData(import_constants10.GL.COPY_READ_BUFFER, byteOffset, data, dstOffset, byteLength);
+      this.gl.bindBuffer(import_constants10.GL.COPY_READ_BUFFER, null);
       return data;
     });
   }
@@ -2621,32 +2633,32 @@ var WEBGLBuffer = class extends import_core7.Buffer {
 };
 function getWebGLTarget(usage) {
   if (usage & import_core7.Buffer.INDEX) {
-    return import_constants9.GL.ELEMENT_ARRAY_BUFFER;
+    return import_constants10.GL.ELEMENT_ARRAY_BUFFER;
   }
   if (usage & import_core7.Buffer.VERTEX) {
-    return import_constants9.GL.ARRAY_BUFFER;
+    return import_constants10.GL.ARRAY_BUFFER;
   }
   if (usage & import_core7.Buffer.UNIFORM) {
-    return import_constants9.GL.UNIFORM_BUFFER;
+    return import_constants10.GL.UNIFORM_BUFFER;
   }
-  return import_constants9.GL.ARRAY_BUFFER;
+  return import_constants10.GL.ARRAY_BUFFER;
 }
 function getWebGLUsage(usage) {
   if (usage & import_core7.Buffer.INDEX) {
-    return import_constants9.GL.STATIC_DRAW;
+    return import_constants10.GL.STATIC_DRAW;
   }
   if (usage & import_core7.Buffer.VERTEX) {
-    return import_constants9.GL.STATIC_DRAW;
+    return import_constants10.GL.STATIC_DRAW;
   }
   if (usage & import_core7.Buffer.UNIFORM) {
-    return import_constants9.GL.DYNAMIC_DRAW;
+    return import_constants10.GL.DYNAMIC_DRAW;
   }
-  return import_constants9.GL.STATIC_DRAW;
+  return import_constants10.GL.STATIC_DRAW;
 }
 
 // src/adapter/resources/webgl-sampler.ts
 var import_core8 = require("@luma.gl/core");
-var import_constants10 = require("@luma.gl/constants");
+var import_constants11 = require("@luma.gl/constants");
 var WEBGLSampler = class extends import_core8.Sampler {
   constructor(device, props) {
     super(device, props);
@@ -2671,8 +2683,8 @@ var WEBGLSampler = class extends import_core8.Sampler {
     for (const [pname, value] of Object.entries(parameters)) {
       const param = Number(pname);
       switch (param) {
-        case import_constants10.GL.TEXTURE_MIN_LOD:
-        case import_constants10.GL.TEXTURE_MAX_LOD:
+        case import_constants11.GL.TEXTURE_MIN_LOD:
+        case import_constants11.GL.TEXTURE_MAX_LOD:
           this.device.gl2.samplerParameterf(this.handle, param, value);
           break;
         default:
@@ -2717,7 +2729,7 @@ var _WEBGLTexture = class extends import_core10.Texture {
     this.gl2 = this.device.gl2;
     this.handle = this.props.handle || this.gl.createTexture();
     this.device.setSpectorMetadata(this.handle, __spreadProps(__spreadValues({}, this.props), { data: typeof this.props.data }));
-    this.glFormat = import_constants11.GL.RGBA;
+    this.glFormat = import_constants12.GL.RGBA;
     this.target = getWebGLTextureTarget(this.props);
     this.loaded = false;
     if (typeof ((_a = this.props) == null ? void 0 : _a.data) === "string") {
@@ -2788,7 +2800,7 @@ var _WEBGLTexture = class extends import_core10.Texture {
     this.dataFormat = dataFormat;
     this.textureUnit = textureUnit;
     if (Number.isFinite(this.textureUnit)) {
-      this.gl.activeTexture(import_constants11.GL.TEXTURE0 + this.textureUnit);
+      this.gl.activeTexture(import_constants12.GL.TEXTURE0 + this.textureUnit);
       this.gl.bindTexture(this.target, this.handle);
     }
     if (mipmaps && this.device.isWebGL1 && isNPOT(this.width, this.height)) {
@@ -2979,7 +2991,7 @@ var _WEBGLTexture = class extends import_core10.Texture {
           break;
         case "buffer":
           gl22 = this.device.assertWebGL2();
-          gl22.bindBuffer(import_constants11.GL.PIXEL_UNPACK_BUFFER, data.handle || data);
+          gl22.bindBuffer(import_constants12.GL.PIXEL_UNPACK_BUFFER, data.handle || data);
           gl22.texImage2D(
             target,
             level,
@@ -2991,7 +3003,7 @@ var _WEBGLTexture = class extends import_core10.Texture {
             type,
             offset
           );
-          gl22.bindBuffer(import_constants11.GL.PIXEL_UNPACK_BUFFER, null);
+          gl22.bindBuffer(import_constants12.GL.PIXEL_UNPACK_BUFFER, null);
           break;
         case "browser-object":
           if (this.device.isWebGL2) {
@@ -3089,9 +3101,9 @@ var _WEBGLTexture = class extends import_core10.Texture {
         this.gl.texSubImage2D(target, level, x, y, width, height, dataFormat, type, data, offset);
       } else if (typeof WebGLBuffer !== "undefined" && data instanceof WebGLBuffer) {
         const gl2 = this.device.assertWebGL2();
-        gl2.bindBuffer(import_constants11.GL.PIXEL_UNPACK_BUFFER, data);
+        gl2.bindBuffer(import_constants12.GL.PIXEL_UNPACK_BUFFER, data);
         gl2.texSubImage2D(target, level, x, y, width, height, dataFormat, type, offset);
-        gl2.bindBuffer(import_constants11.GL.PIXEL_UNPACK_BUFFER, null);
+        gl2.bindBuffer(import_constants12.GL.PIXEL_UNPACK_BUFFER, null);
       } else if (this.device.isWebGL2) {
         const gl2 = this.device.assertWebGL2();
         gl2.texSubImage2D(target, level, x, y, width, height, dataFormat, type, data);
@@ -3116,7 +3128,7 @@ var _WEBGLTexture = class extends import_core10.Texture {
     return null;
   }
   getActiveUnit() {
-    return this.gl.getParameter(import_constants11.GL.ACTIVE_TEXTURE) - import_constants11.GL.TEXTURE0;
+    return this.gl.getParameter(import_constants12.GL.ACTIVE_TEXTURE) - import_constants12.GL.TEXTURE0;
   }
   bind(textureUnit = this.textureUnit) {
     const { gl: gl2 } = this;
@@ -3200,7 +3212,7 @@ var _WEBGLTexture = class extends import_core10.Texture {
   setCubeMapImageData(options) {
     return __async(this, null, function* () {
       const { gl: gl2 } = this;
-      const { width, height, pixels, data, format = import_constants11.GL.RGBA, type = import_constants11.GL.UNSIGNED_BYTE } = options;
+      const { width, height, pixels, data, format = import_constants12.GL.RGBA, type = import_constants12.GL.UNSIGNED_BYTE } = options;
       const imageDataMap = pixels || data;
       const resolvedFaces = yield Promise.all(
         _WEBGLTexture.FACES.map((face) => {
@@ -3232,8 +3244,8 @@ var _WEBGLTexture = class extends import_core10.Texture {
       height,
       pixels,
       data,
-      format = import_constants11.GL.RGBA,
-      type = import_constants11.GL.UNSIGNED_BYTE
+      format = import_constants12.GL.RGBA,
+      type = import_constants12.GL.UNSIGNED_BYTE
       // generateMipmap = false // TODO
     } = options;
     const { gl: gl2 } = this;
@@ -3291,7 +3303,7 @@ var _WEBGLTexture = class extends import_core10.Texture {
         );
       }
       if (data instanceof WEBGLBuffer) {
-        this.gl.bindBuffer(import_constants11.GL.PIXEL_UNPACK_BUFFER, data.handle);
+        this.gl.bindBuffer(import_constants12.GL.PIXEL_UNPACK_BUFFER, data.handle);
         this.gl.texImage3D(
           this.target,
           level,
@@ -3333,8 +3345,8 @@ var _WEBGLTexture = class extends import_core10.Texture {
       const param = Number(pname);
       const value = pvalue;
       switch (param) {
-        case import_constants11.GL.TEXTURE_MIN_LOD:
-        case import_constants11.GL.TEXTURE_MAX_LOD:
+        case import_constants12.GL.TEXTURE_MIN_LOD:
+        case import_constants12.GL.TEXTURE_MAX_LOD:
           this.gl.texParameterf(this.target, param, value);
           break;
         default:
@@ -3350,14 +3362,14 @@ var _WEBGLTexture = class extends import_core10.Texture {
     const npot = this.device.isWebGL1 && isNPOT(this.width, this.height);
     if (npot) {
       switch (pname) {
-        case import_constants11.GL.TEXTURE_MIN_FILTER:
-          if (value !== import_constants11.GL.LINEAR && value !== import_constants11.GL.NEAREST) {
-            return import_constants11.GL.LINEAR;
+        case import_constants12.GL.TEXTURE_MIN_FILTER:
+          if (value !== import_constants12.GL.LINEAR && value !== import_constants12.GL.NEAREST) {
+            return import_constants12.GL.LINEAR;
           }
           break;
-        case import_constants11.GL.TEXTURE_WRAP_S:
-        case import_constants11.GL.TEXTURE_WRAP_T:
-          return import_constants11.GL.CLAMP_TO_EDGE;
+        case import_constants12.GL.TEXTURE_WRAP_S:
+        case import_constants12.GL.TEXTURE_WRAP_T:
+          return import_constants12.GL.CLAMP_TO_EDGE;
         default:
           break;
       }
@@ -3368,23 +3380,23 @@ var _WEBGLTexture = class extends import_core10.Texture {
 var WEBGLTexture = _WEBGLTexture;
 // TODO - remove?
 WEBGLTexture.FACES = [
-  import_constants11.GL.TEXTURE_CUBE_MAP_POSITIVE_X,
-  import_constants11.GL.TEXTURE_CUBE_MAP_NEGATIVE_X,
-  import_constants11.GL.TEXTURE_CUBE_MAP_POSITIVE_Y,
-  import_constants11.GL.TEXTURE_CUBE_MAP_NEGATIVE_Y,
-  import_constants11.GL.TEXTURE_CUBE_MAP_POSITIVE_Z,
-  import_constants11.GL.TEXTURE_CUBE_MAP_NEGATIVE_Z
+  import_constants12.GL.TEXTURE_CUBE_MAP_POSITIVE_X,
+  import_constants12.GL.TEXTURE_CUBE_MAP_NEGATIVE_X,
+  import_constants12.GL.TEXTURE_CUBE_MAP_POSITIVE_Y,
+  import_constants12.GL.TEXTURE_CUBE_MAP_NEGATIVE_Y,
+  import_constants12.GL.TEXTURE_CUBE_MAP_POSITIVE_Z,
+  import_constants12.GL.TEXTURE_CUBE_MAP_NEGATIVE_Z
 ];
 function getWebGLTextureTarget(props) {
   switch (props.dimension) {
     case "2d":
-      return import_constants11.GL.TEXTURE_2D;
+      return import_constants12.GL.TEXTURE_2D;
     case "cube":
-      return import_constants11.GL.TEXTURE_CUBE_MAP;
+      return import_constants12.GL.TEXTURE_CUBE_MAP;
     case "2d-array":
-      return import_constants11.GL.TEXTURE_2D_ARRAY;
+      return import_constants12.GL.TEXTURE_2D_ARRAY;
     case "3d":
-      return import_constants11.GL.TEXTURE_3D;
+      return import_constants12.GL.TEXTURE_3D;
     case "1d":
     case "cube-array":
     default:
@@ -3403,24 +3415,24 @@ function logParameters(parameters) {
 
 // src/adapter/objects/webgl-renderbuffer.ts
 var import_core13 = require("@luma.gl/core");
-var import_constants12 = require("@luma.gl/constants");
+var import_constants13 = require("@luma.gl/constants");
 
 // src/adapter/objects/webgl-resource.ts
 var import_core12 = require("@luma.gl/core");
 
 // src/adapter/objects/constants-to-keys.ts
 var import_core11 = require("@luma.gl/core");
-function getKeyValue(gl2, name) {
-  if (typeof name !== "string") {
-    return name;
+function getKeyValue(gl2, name2) {
+  if (typeof name2 !== "string") {
+    return name2;
   }
-  const number = Number(name);
+  const number = Number(name2);
   if (!isNaN(number)) {
     return number;
   }
-  name = name.replace(/^.*\./, "");
-  const value = gl2[name];
-  (0, import_core11.assert)(value !== void 0, `Accessing undefined constant GL.${name}`);
+  name2 = name2.replace(/^.*\./, "");
+  const value = gl2[name2];
+  (0, import_core11.assert)(value !== void 0, `Accessing undefined constant GL.${name2}`);
   return value;
 }
 
@@ -3669,13 +3681,13 @@ var _WEBGLRenderbuffer = class extends WebGLResource {
     const { format, width, height, samples } = props;
     (0, import_core13.assert)(format, "Needs format");
     this.trackDeallocatedMemory();
-    this.gl.bindRenderbuffer(import_constants12.GL.RENDERBUFFER, this.handle);
+    this.gl.bindRenderbuffer(import_constants13.GL.RENDERBUFFER, this.handle);
     if (samples !== 0 && this.device.isWebGL2) {
-      this.gl2.renderbufferStorageMultisample(import_constants12.GL.RENDERBUFFER, samples, this.glFormat, width, height);
+      this.gl2.renderbufferStorageMultisample(import_constants13.GL.RENDERBUFFER, samples, this.glFormat, width, height);
     } else {
-      this.gl.renderbufferStorage(import_constants12.GL.RENDERBUFFER, this.glFormat, width, height);
+      this.gl.renderbufferStorage(import_constants13.GL.RENDERBUFFER, this.glFormat, width, height);
     }
-    this.gl.bindRenderbuffer(import_constants12.GL.RENDERBUFFER, null);
+    this.gl.bindRenderbuffer(import_constants13.GL.RENDERBUFFER, null);
     this.trackAllocatedMemory(
       width * height * (samples || 1) * getTextureFormatBytesPerPixel(this.glFormat, this.device.isWebGL2)
     );
@@ -3689,7 +3701,7 @@ var _WEBGLRenderbuffer = class extends WebGLResource {
     this.trackDeallocatedMemory();
   }
   _bindHandle(handle) {
-    this.gl.bindRenderbuffer(import_constants12.GL.RENDERBUFFER, handle);
+    this.gl.bindRenderbuffer(import_constants13.GL.RENDERBUFFER, handle);
   }
 };
 var WEBGLRenderbuffer = _WEBGLRenderbuffer;
@@ -3715,10 +3727,10 @@ var WEBGLFramebuffer = class extends import_core14.Framebuffer {
     if (!isDefaultFramebuffer) {
       device.setSpectorMetadata(this.handle, { id: this.props.id, props: this.props });
       this.autoCreateAttachmentTextures();
-      this.gl.bindFramebuffer(import_constants13.GL.FRAMEBUFFER, this.handle);
+      this.gl.bindFramebuffer(import_constants14.GL.FRAMEBUFFER, this.handle);
       for (let i = 0; i < this.colorAttachments.length; ++i) {
         const attachment = this.colorAttachments[i];
-        const attachmentPoint = import_constants13.GL.COLOR_ATTACHMENT0 + i;
+        const attachmentPoint = import_constants14.GL.COLOR_ATTACHMENT0 + i;
         if (attachment) {
           this._attachOne(attachmentPoint, attachment);
         }
@@ -3729,7 +3741,7 @@ var WEBGLFramebuffer = class extends import_core14.Framebuffer {
           this.depthStencilAttachment
         );
       }
-      this.gl.bindFramebuffer(import_constants13.GL.FRAMEBUFFER, null);
+      this.gl.bindFramebuffer(import_constants14.GL.FRAMEBUFFER, null);
     }
     if (props.check !== false) {
       this._checkStatus();
@@ -3749,9 +3761,9 @@ var WEBGLFramebuffer = class extends import_core14.Framebuffer {
   /** Check the status */
   _checkStatus() {
     const { gl: gl2 } = this;
-    const prevHandle2 = gl2.bindFramebuffer(import_constants13.GL.FRAMEBUFFER, this.handle);
-    const status = gl2.checkFramebufferStatus(import_constants13.GL.FRAMEBUFFER);
-    gl2.bindFramebuffer(import_constants13.GL.FRAMEBUFFER, prevHandle2 || null);
+    const prevHandle2 = gl2.bindFramebuffer(import_constants14.GL.FRAMEBUFFER, this.handle);
+    const status = gl2.checkFramebufferStatus(import_constants14.GL.FRAMEBUFFER);
+    gl2.bindFramebuffer(import_constants14.GL.FRAMEBUFFER, prevHandle2 || null);
     if (status !== gl2.FRAMEBUFFER_COMPLETE) {
       throw new Error(`Framebuffer ${_getFrameBufferStatus(status)}`);
     }
@@ -3808,9 +3820,9 @@ var WEBGLFramebuffer = class extends import_core14.Framebuffer {
   }
   _attachWEBGLRenderbuffer(attachment, renderbuffer) {
     this.gl.framebufferRenderbuffer(
-      import_constants13.GL.FRAMEBUFFER,
+      import_constants14.GL.FRAMEBUFFER,
       attachment,
-      import_constants13.GL.RENDERBUFFER,
+      import_constants14.GL.RENDERBUFFER,
       renderbuffer.handle
     );
   }
@@ -3824,17 +3836,17 @@ var WEBGLFramebuffer = class extends import_core14.Framebuffer {
     const { gl: gl2, gl2: gl22 } = this.device;
     gl2.bindTexture(texture.target, texture.handle);
     switch (texture.target) {
-      case import_constants13.GL.TEXTURE_2D_ARRAY:
-      case import_constants13.GL.TEXTURE_3D:
+      case import_constants14.GL.TEXTURE_2D_ARRAY:
+      case import_constants14.GL.TEXTURE_3D:
         this.device.assertWebGL2();
-        gl22 == null ? void 0 : gl22.framebufferTextureLayer(import_constants13.GL.FRAMEBUFFER, attachment, texture.target, level, layer);
+        gl22 == null ? void 0 : gl22.framebufferTextureLayer(import_constants14.GL.FRAMEBUFFER, attachment, texture.target, level, layer);
         break;
-      case import_constants13.GL.TEXTURE_CUBE_MAP:
+      case import_constants14.GL.TEXTURE_CUBE_MAP:
         const face = mapIndexToCubeMapFace(layer);
-        gl2.framebufferTexture2D(import_constants13.GL.FRAMEBUFFER, attachment, face, texture.handle, level);
+        gl2.framebufferTexture2D(import_constants14.GL.FRAMEBUFFER, attachment, face, texture.handle, level);
         break;
-      case import_constants13.GL.TEXTURE_2D:
-        gl2.framebufferTexture2D(import_constants13.GL.FRAMEBUFFER, attachment, import_constants13.GL.TEXTURE_2D, texture.handle, level);
+      case import_constants14.GL.TEXTURE_2D:
+        gl2.framebufferTexture2D(import_constants14.GL.FRAMEBUFFER, attachment, import_constants14.GL.TEXTURE_2D, texture.handle, level);
         break;
       default:
         (0, import_core14.assert)(false, "Illegal texture type");
@@ -3843,21 +3855,21 @@ var WEBGLFramebuffer = class extends import_core14.Framebuffer {
   }
 };
 function mapIndexToCubeMapFace(layer) {
-  return layer < import_constants13.GL.TEXTURE_CUBE_MAP_POSITIVE_X ? layer + import_constants13.GL.TEXTURE_CUBE_MAP_POSITIVE_X : layer;
+  return layer < import_constants14.GL.TEXTURE_CUBE_MAP_POSITIVE_X ? layer + import_constants14.GL.TEXTURE_CUBE_MAP_POSITIVE_X : layer;
 }
 function _getFrameBufferStatus(status) {
   switch (status) {
-    case import_constants13.GL.FRAMEBUFFER_COMPLETE:
+    case import_constants14.GL.FRAMEBUFFER_COMPLETE:
       return "success";
-    case import_constants13.GL.FRAMEBUFFER_INCOMPLETE_ATTACHMENT:
+    case import_constants14.GL.FRAMEBUFFER_INCOMPLETE_ATTACHMENT:
       return "Mismatched attachments";
-    case import_constants13.GL.FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT:
+    case import_constants14.GL.FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT:
       return "No attachments";
-    case import_constants13.GL.FRAMEBUFFER_INCOMPLETE_DIMENSIONS:
+    case import_constants14.GL.FRAMEBUFFER_INCOMPLETE_DIMENSIONS:
       return "Height/width mismatch";
-    case import_constants13.GL.FRAMEBUFFER_UNSUPPORTED:
+    case import_constants14.GL.FRAMEBUFFER_UNSUPPORTED:
       return "Unsupported or split attachments";
-    case import_constants13.GL.FRAMEBUFFER_INCOMPLETE_MULTISAMPLE:
+    case import_constants14.GL.FRAMEBUFFER_INCOMPLETE_MULTISAMPLE:
       return "Samples mismatch";
     default:
       return `${status}`;
@@ -3975,7 +3987,7 @@ function initializeSpectorJS(props) {
 
 // src/context/debug/webgl-developer-tools.ts
 var import_core17 = require("@luma.gl/core");
-var import_constants14 = require("@luma.gl/constants");
+var import_constants15 = require("@luma.gl/constants");
 var import_env = require("@probe.gl/env");
 var WEBGL_DEBUG_CDN_URL = "https://unpkg.com/webgl-debug@2.0.1/index.js";
 function getContextData2(gl2) {
@@ -4010,15 +4022,15 @@ function getDebugContext(gl2, props) {
   if (data.debugContext) {
     return data.debugContext;
   }
-  globalThis.WebGLDebugUtils.init(__spreadValues(__spreadValues({}, import_constants14.GL), gl2));
+  globalThis.WebGLDebugUtils.init(__spreadValues(__spreadValues({}, import_constants15.GL), gl2));
   const glDebug = globalThis.WebGLDebugUtils.makeDebugContext(
     gl2,
     onGLError.bind(null, props),
     onValidateGLFunc.bind(null, props)
   );
-  for (const key in import_constants14.GL) {
-    if (!(key in glDebug) && typeof import_constants14.GL[key] === "number") {
-      glDebug[key] = import_constants14.GL[key];
+  for (const key in import_constants15.GL) {
+    if (!(key in glDebug) && typeof import_constants15.GL[key] === "number") {
+      glDebug[key] = import_constants15.GL[key];
     }
   }
   class WebGLDebugContext {
@@ -4077,34 +4089,34 @@ function onValidateGLFunc(props, functionName, functionArgs) {
 
 // src/classic/buffer-with-accessor.ts
 var import_core19 = require("@luma.gl/core");
-var import_constants17 = require("@luma.gl/constants");
+var import_constants18 = require("@luma.gl/constants");
 
 // src/classic/accessor.ts
 var import_core18 = require("@luma.gl/core");
-var import_constants16 = require("@luma.gl/constants");
+var import_constants17 = require("@luma.gl/constants");
 
 // src/classic/typed-array-utils.ts
-var import_constants15 = require("@luma.gl/constants");
+var import_constants16 = require("@luma.gl/constants");
 var ERR_TYPE_DEDUCTION = "Failed to deduce GL constant from typed array";
 function getGLTypeFromTypedArray(arrayOrType) {
   const type = ArrayBuffer.isView(arrayOrType) ? arrayOrType.constructor : arrayOrType;
   switch (type) {
     case Float32Array:
-      return import_constants15.GL.FLOAT;
+      return import_constants16.GL.FLOAT;
     case Uint16Array:
-      return import_constants15.GL.UNSIGNED_SHORT;
+      return import_constants16.GL.UNSIGNED_SHORT;
     case Uint32Array:
-      return import_constants15.GL.UNSIGNED_INT;
+      return import_constants16.GL.UNSIGNED_INT;
     case Uint8Array:
-      return import_constants15.GL.UNSIGNED_BYTE;
+      return import_constants16.GL.UNSIGNED_BYTE;
     case Uint8ClampedArray:
-      return import_constants15.GL.UNSIGNED_BYTE;
+      return import_constants16.GL.UNSIGNED_BYTE;
     case Int8Array:
-      return import_constants15.GL.BYTE;
+      return import_constants16.GL.BYTE;
     case Int16Array:
-      return import_constants15.GL.SHORT;
+      return import_constants16.GL.SHORT;
     case Int32Array:
-      return import_constants15.GL.INT;
+      return import_constants16.GL.INT;
     default:
       throw new Error(ERR_TYPE_DEDUCTION);
   }
@@ -4112,22 +4124,22 @@ function getGLTypeFromTypedArray(arrayOrType) {
 function getTypedArrayFromGLType(glType, options) {
   const { clamped = true } = options || {};
   switch (glType) {
-    case import_constants15.GL.FLOAT:
+    case import_constants16.GL.FLOAT:
       return Float32Array;
-    case import_constants15.GL.UNSIGNED_SHORT:
-    case import_constants15.GL.UNSIGNED_SHORT_5_6_5:
-    case import_constants15.GL.UNSIGNED_SHORT_4_4_4_4:
-    case import_constants15.GL.UNSIGNED_SHORT_5_5_5_1:
+    case import_constants16.GL.UNSIGNED_SHORT:
+    case import_constants16.GL.UNSIGNED_SHORT_5_6_5:
+    case import_constants16.GL.UNSIGNED_SHORT_4_4_4_4:
+    case import_constants16.GL.UNSIGNED_SHORT_5_5_5_1:
       return Uint16Array;
-    case import_constants15.GL.UNSIGNED_INT:
+    case import_constants16.GL.UNSIGNED_INT:
       return Uint32Array;
-    case import_constants15.GL.UNSIGNED_BYTE:
+    case import_constants16.GL.UNSIGNED_BYTE:
       return clamped ? Uint8ClampedArray : Uint8Array;
-    case import_constants15.GL.BYTE:
+    case import_constants16.GL.BYTE:
       return Int8Array;
-    case import_constants15.GL.SHORT:
+    case import_constants16.GL.SHORT:
       return Int16Array;
-    case import_constants15.GL.INT:
+    case import_constants16.GL.INT:
       return Int32Array;
     default:
       throw new Error("Failed to deduce typed array type from GL constant");
@@ -4138,7 +4150,7 @@ function getTypedArrayFromGLType(glType, options) {
 var DEFAULT_ACCESSOR_VALUES = {
   offset: 0,
   stride: 0,
-  type: import_constants16.GL.FLOAT,
+  type: import_constants17.GL.FLOAT,
   size: 1,
   divisor: 0,
   normalized: false,
@@ -4152,12 +4164,12 @@ var PROP_CHECKS = {
 };
 var Accessor = class {
   static getBytesPerElement(accessor) {
-    const ArrayType = getTypedArrayFromGLType(accessor.type || import_constants16.GL.FLOAT);
+    const ArrayType = getTypedArrayFromGLType(accessor.type || import_constants17.GL.FLOAT);
     return ArrayType.BYTES_PER_ELEMENT;
   }
   static getBytesPerVertex(accessor) {
     (0, import_core18.assert)(accessor.size);
-    const ArrayType = getTypedArrayFromGLType(accessor.type || import_constants16.GL.FLOAT);
+    const ArrayType = getTypedArrayFromGLType(accessor.type || import_constants17.GL.FLOAT);
     return ArrayType.BYTES_PER_ELEMENT * accessor.size;
   }
   // Combines (merges) a list of accessors. On top of default values
@@ -4188,7 +4200,7 @@ var Accessor = class {
     props = (0, import_core18.checkProps)("Accessor", props, PROP_CHECKS);
     if (props.type !== void 0) {
       this.type = props.type;
-      if (props.type === import_constants16.GL.INT || props.type === import_constants16.GL.UNSIGNED_INT) {
+      if (props.type === import_constants17.GL.INT || props.type === import_constants17.GL.UNSIGNED_INT) {
         this.integer = true;
       }
     }
@@ -4320,7 +4332,7 @@ var BufferWithAccessor = class extends WEBGLBuffer {
       props = { byteLength: props };
     }
     props = (0, import_core19.checkProps)("Buffer", props, PROP_CHECKS_INITIALIZE);
-    this.glUsage = props.glUsage || import_constants17.GL.STATIC_DRAW;
+    this.glUsage = props.glUsage || import_constants18.GL.STATIC_DRAW;
     this.debugData = null;
     this.setAccessor(Object.assign({}, props, props.accessor));
     if (props.data) {
@@ -4374,7 +4386,7 @@ var BufferWithAccessor = class extends WEBGLBuffer {
     const { data, offset = 0, srcOffset = 0 } = options;
     const byteLength = options.byteLength || options.length;
     (0, import_core19.assert)(data);
-    const glTarget = this.gl.webgl2 ? import_constants17.GL.COPY_WRITE_BUFFER : this.glTarget;
+    const glTarget = this.gl.webgl2 ? import_constants18.GL.COPY_WRITE_BUFFER : this.glTarget;
     this.gl.bindBuffer(glTarget, this.handle);
     if (srcOffset !== 0 || byteLength !== void 0) {
       assertWebGL2Context(this.gl);
@@ -4395,11 +4407,11 @@ var BufferWithAccessor = class extends WEBGLBuffer {
     const { sourceBuffer, readOffset = 0, writeOffset = 0, size } = options;
     const { gl: gl2, gl2: gl22 } = this;
     assertWebGL2Context(gl2);
-    gl2.bindBuffer(import_constants17.GL.COPY_READ_BUFFER, sourceBuffer.handle);
-    gl2.bindBuffer(import_constants17.GL.COPY_WRITE_BUFFER, this.handle);
-    gl22 == null ? void 0 : gl22.copyBufferSubData(import_constants17.GL.COPY_READ_BUFFER, import_constants17.GL.COPY_WRITE_BUFFER, readOffset, writeOffset, size);
-    gl2.bindBuffer(import_constants17.GL.COPY_READ_BUFFER, null);
-    gl2.bindBuffer(import_constants17.GL.COPY_WRITE_BUFFER, null);
+    gl2.bindBuffer(import_constants18.GL.COPY_READ_BUFFER, sourceBuffer.handle);
+    gl2.bindBuffer(import_constants18.GL.COPY_WRITE_BUFFER, this.handle);
+    gl22 == null ? void 0 : gl22.copyBufferSubData(import_constants18.GL.COPY_READ_BUFFER, import_constants18.GL.COPY_WRITE_BUFFER, readOffset, writeOffset, size);
+    gl2.bindBuffer(import_constants18.GL.COPY_READ_BUFFER, null);
+    gl2.bindBuffer(import_constants18.GL.COPY_WRITE_BUFFER, null);
     this.debugData = null;
     return this;
   }
@@ -4412,7 +4424,7 @@ var BufferWithAccessor = class extends WEBGLBuffer {
     let { dstData = null, length = 0 } = options || {};
     const { srcByteOffset = 0, dstOffset = 0 } = options || {};
     assertWebGL2Context(this.gl);
-    const ArrayType = getTypedArrayFromGLType(this.accessor.type || import_constants17.GL.FLOAT, { clamped: false });
+    const ArrayType = getTypedArrayFromGLType(this.accessor.type || import_constants18.GL.FLOAT, { clamped: false });
     const sourceAvailableElementCount = this._getAvailableElementCount(srcByteOffset);
     const dstElementOffset = dstOffset;
     let dstAvailableElementCount;
@@ -4431,9 +4443,9 @@ var BufferWithAccessor = class extends WEBGLBuffer {
     length = length || copyElementCount;
     (0, import_core19.assert)(length <= copyElementCount);
     dstData = dstData || new ArrayType(dstElementCount);
-    this.gl.bindBuffer(import_constants17.GL.COPY_READ_BUFFER, this.handle);
-    (_a = this.gl2) == null ? void 0 : _a.getBufferSubData(import_constants17.GL.COPY_READ_BUFFER, srcByteOffset, dstData, dstOffset, length);
-    this.gl.bindBuffer(import_constants17.GL.COPY_READ_BUFFER, null);
+    this.gl.bindBuffer(import_constants18.GL.COPY_READ_BUFFER, this.handle);
+    (_a = this.gl2) == null ? void 0 : _a.getBufferSubData(import_constants18.GL.COPY_READ_BUFFER, srcByteOffset, dstData, dstOffset, length);
+    this.gl.bindBuffer(import_constants18.GL.COPY_READ_BUFFER, null);
     return dstData;
   }
   /**
@@ -4453,7 +4465,7 @@ var BufferWithAccessor = class extends WEBGLBuffer {
       offset = 0,
       size
     } = options || {};
-    if (glTarget === import_constants17.GL.UNIFORM_BUFFER || glTarget === import_constants17.GL.TRANSFORM_FEEDBACK_BUFFER) {
+    if (glTarget === import_constants18.GL.UNIFORM_BUFFER || glTarget === import_constants18.GL.TRANSFORM_FEEDBACK_BUFFER) {
       if (size !== void 0) {
         (_a = this.gl2) == null ? void 0 : _a.bindBufferRange(glTarget, index, this.handle, offset, size);
       } else {
@@ -4468,7 +4480,7 @@ var BufferWithAccessor = class extends WEBGLBuffer {
   unbind(options) {
     var _a;
     const { glTarget = this.glTarget, index = this.accessor && this.accessor.index } = options || {};
-    const isIndexedBuffer = glTarget === import_constants17.GL.UNIFORM_BUFFER || glTarget === import_constants17.GL.TRANSFORM_FEEDBACK_BUFFER;
+    const isIndexedBuffer = glTarget === import_constants18.GL.UNIFORM_BUFFER || glTarget === import_constants18.GL.TRANSFORM_FEEDBACK_BUFFER;
     if (isIndexedBuffer) {
       (_a = this.gl2) == null ? void 0 : _a.bindBufferBase(glTarget, index, null);
     } else {
@@ -4528,10 +4540,10 @@ var BufferWithAccessor = class extends WEBGLBuffer {
   // Binding a buffer for the first time locks the type
   // In WebGL2, use GL.COPY_WRITE_BUFFER to avoid locking the type
   _getTarget() {
-    return this.gl.webgl2 ? import_constants17.GL.COPY_WRITE_BUFFER : this.glTarget;
+    return this.gl.webgl2 ? import_constants18.GL.COPY_WRITE_BUFFER : this.glTarget;
   }
   _getAvailableElementCount(srcByteOffset) {
-    const ArrayType = getTypedArrayFromGLType(this.accessor.type || import_constants17.GL.FLOAT, { clamped: false });
+    const ArrayType = getTypedArrayFromGLType(this.accessor.type || import_constants18.GL.FLOAT, { clamped: false });
     const sourceElementOffset = srcByteOffset / ArrayType.BYTES_PER_ELEMENT;
     return this.getElementCount() - sourceElementOffset;
   }
@@ -4558,7 +4570,7 @@ var BufferWithAccessor = class extends WEBGLBuffer {
 
 // src/adapter/resources/webgl-shader.ts
 var import_core20 = require("@luma.gl/core");
-var import_constants18 = require("@luma.gl/constants");
+var import_constants19 = require("@luma.gl/constants");
 
 // src/adapter/helpers/get-shader-info.ts
 function getShaderInfo(source, defaultName) {
@@ -4624,10 +4636,10 @@ var WEBGLShader = class extends import_core20.Shader {
     this.device = device;
     switch (this.props.stage) {
       case "vertex":
-        this.handle = this.props.handle || this.device.gl.createShader(import_constants18.GL.VERTEX_SHADER);
+        this.handle = this.props.handle || this.device.gl.createShader(import_constants19.GL.VERTEX_SHADER);
         break;
       case "fragment":
-        this.handle = this.props.handle || this.device.gl.createShader(import_constants18.GL.FRAGMENT_SHADER);
+        this.handle = this.props.handle || this.device.gl.createShader(import_constants19.GL.FRAGMENT_SHADER);
         break;
       default:
         throw new Error(this.props.stage);
@@ -4643,8 +4655,8 @@ var WEBGLShader = class extends import_core20.Shader {
   }
   compilationInfo() {
     return __async(this, null, function* () {
-      const log10 = this.device.gl.getShaderInfoLog(this.handle);
-      return log10 ? parseShaderCompilerLog(log10) : [];
+      const log9 = this.device.gl.getShaderInfoLog(this.handle);
+      return log9 ? parseShaderCompilerLog(log9) : [];
     });
   }
   // PRIVATE METHODS
@@ -4655,7 +4667,7 @@ ${source2}`;
     const { gl: gl2 } = this.device;
     gl2.shaderSource(this.handle, source);
     gl2.compileShader(this.handle);
-    const compileStatus = gl2.getShaderParameter(this.handle, import_constants18.GL.COMPILE_STATUS);
+    const compileStatus = gl2.getShaderParameter(this.handle, import_constants19.GL.COMPILE_STATUS);
     if (!compileStatus) {
       const shaderLog = gl2.getShaderInfoLog(this.handle);
       const parsedLog = shaderLog ? parseShaderCompilerLog(shaderLog) : [];
@@ -4675,7 +4687,7 @@ function getShaderIdFromProps(props) {
 
 // src/adapter/resources/webgl-render-pass.ts
 var import_core21 = require("@luma.gl/core");
-var import_constants19 = require("@luma.gl/constants");
+var import_constants20 = require("@luma.gl/constants");
 var GL_DEPTH_BUFFER_BIT = 256;
 var GL_STENCIL_BUFFER_BIT = 1024;
 var GL_COLOR_BUFFER_BIT = 16384;
@@ -4711,7 +4723,7 @@ var WEBGLRenderPass = class extends import_core21.RenderPass {
       glParameters.depthMask = !this.props.depthReadOnly;
     }
     glParameters.stencilMask = this.props.stencilReadOnly ? 0 : 1;
-    glParameters[import_constants19.GL.RASTERIZER_DISCARD] = this.props.discard;
+    glParameters[import_constants20.GL.RASTERIZER_DISCARD] = this.props.discard;
     if (parameters.viewport) {
       if (parameters.viewport.length >= 6) {
         glParameters.viewport = parameters.viewport.slice(0, 4);
@@ -4729,7 +4741,7 @@ var WEBGLRenderPass = class extends import_core21.RenderPass {
     }
     if (parameters.stencilReference) {
       console.warn("RenderPassParameters.stencilReference not yet implemented in WebGL");
-      parameters[import_constants19.GL.STENCIL_REF] = parameters.stencilReference;
+      parameters[import_constants20.GL.STENCIL_REF] = parameters.stencilReference;
     }
     this.glParameters = glParameters;
   }
@@ -4798,116 +4810,88 @@ var WEBGLRenderPass = class extends import_core21.RenderPass {
 };
 
 // src/adapter/resources/webgl-render-pipeline.ts
+var import_core23 = require("@luma.gl/core");
 var import_core24 = require("@luma.gl/core");
 var import_constants25 = require("@luma.gl/constants");
 
 // src/adapter/helpers/get-shader-layout.ts
-var import_core22 = require("@luma.gl/core");
 var import_constants22 = require("@luma.gl/constants");
 
-// src/adapter/helpers/uniforms.ts
-var import_constants20 = require("@luma.gl/constants");
+// src/adapter/helpers/decode-webgl-types.ts
+var import_constants21 = require("@luma.gl/constants");
 function isSamplerUniform(type) {
   return SAMPLER_TYPES.includes(type);
 }
 var SAMPLER_TYPES = [
-  import_constants20.GL.SAMPLER_2D,
-  import_constants20.GL.SAMPLER_CUBE,
-  import_constants20.GL.SAMPLER_3D,
-  import_constants20.GL.SAMPLER_2D_SHADOW,
-  import_constants20.GL.SAMPLER_2D_ARRAY,
-  import_constants20.GL.SAMPLER_2D_ARRAY_SHADOW,
-  import_constants20.GL.SAMPLER_CUBE_SHADOW,
-  import_constants20.GL.INT_SAMPLER_2D,
-  import_constants20.GL.INT_SAMPLER_3D,
-  import_constants20.GL.INT_SAMPLER_CUBE,
-  import_constants20.GL.INT_SAMPLER_2D_ARRAY,
-  import_constants20.GL.UNSIGNED_INT_SAMPLER_2D,
-  import_constants20.GL.UNSIGNED_INT_SAMPLER_3D,
-  import_constants20.GL.UNSIGNED_INT_SAMPLER_CUBE,
-  import_constants20.GL.UNSIGNED_INT_SAMPLER_2D_ARRAY
+  import_constants21.GL.SAMPLER_2D,
+  import_constants21.GL.SAMPLER_CUBE,
+  import_constants21.GL.SAMPLER_3D,
+  import_constants21.GL.SAMPLER_2D_SHADOW,
+  import_constants21.GL.SAMPLER_2D_ARRAY,
+  import_constants21.GL.SAMPLER_2D_ARRAY_SHADOW,
+  import_constants21.GL.SAMPLER_CUBE_SHADOW,
+  import_constants21.GL.INT_SAMPLER_2D,
+  import_constants21.GL.INT_SAMPLER_3D,
+  import_constants21.GL.INT_SAMPLER_CUBE,
+  import_constants21.GL.INT_SAMPLER_2D_ARRAY,
+  import_constants21.GL.UNSIGNED_INT_SAMPLER_2D,
+  import_constants21.GL.UNSIGNED_INT_SAMPLER_3D,
+  import_constants21.GL.UNSIGNED_INT_SAMPLER_CUBE,
+  import_constants21.GL.UNSIGNED_INT_SAMPLER_2D_ARRAY
 ];
 var COMPOSITE_GL_TYPES = {
-  [import_constants20.GL.FLOAT]: [import_constants20.GL.FLOAT, 1, "float", "f32", "float32"],
-  [import_constants20.GL.FLOAT_VEC2]: [import_constants20.GL.FLOAT, 2, "vec2", "vec2<f32>", "float32x2"],
-  [import_constants20.GL.FLOAT_VEC3]: [import_constants20.GL.FLOAT, 3, "vec3", "vec3<f32>", "float32x3"],
-  [import_constants20.GL.FLOAT_VEC4]: [import_constants20.GL.FLOAT, 4, "vec4", "vec4<f32>", "float32x4"],
-  [import_constants20.GL.INT]: [import_constants20.GL.INT, 1, "int", "i32", "sint32"],
-  [import_constants20.GL.INT_VEC2]: [import_constants20.GL.INT, 2, "ivec2", "vec2<i32>", "sint32x2"],
-  [import_constants20.GL.INT_VEC3]: [import_constants20.GL.INT, 3, "ivec3", "vec3<i32>", "sint32x3"],
-  [import_constants20.GL.INT_VEC4]: [import_constants20.GL.INT, 4, "ivec4", "vec4<i32>", "sint32x4"],
-  [import_constants20.GL.UNSIGNED_INT]: [import_constants20.GL.UNSIGNED_INT, 1, "uint", "u32", "uint32"],
-  [import_constants20.GL.UNSIGNED_INT_VEC2]: [import_constants20.GL.UNSIGNED_INT, 2, "uvec2", "vec2<u32>", "uint32x2"],
-  [import_constants20.GL.UNSIGNED_INT_VEC3]: [import_constants20.GL.UNSIGNED_INT, 3, "uvec3", "vec3<u32>", "uint32x3"],
-  [import_constants20.GL.UNSIGNED_INT_VEC4]: [import_constants20.GL.UNSIGNED_INT, 4, "uvec4", "vec4<u32>", "uint32x4"],
-  [import_constants20.GL.BOOL]: [import_constants20.GL.FLOAT, 1, "bool", "f32", "float32x2"],
-  [import_constants20.GL.BOOL_VEC2]: [import_constants20.GL.FLOAT, 2, "bvec2", "vec2<f32>"],
-  [import_constants20.GL.BOOL_VEC3]: [import_constants20.GL.FLOAT, 3, "bvec3", "vec3<f32>"],
-  [import_constants20.GL.BOOL_VEC4]: [import_constants20.GL.FLOAT, 4, "bvec4", "vec4<f32>"],
-  [import_constants20.GL.FLOAT_MAT2]: [import_constants20.GL.FLOAT, 8, "mat2", "mat2x2<f32>"],
+  [import_constants21.GL.FLOAT]: [import_constants21.GL.FLOAT, 1, "float", "f32", "float32"],
+  [import_constants21.GL.FLOAT_VEC2]: [import_constants21.GL.FLOAT, 2, "vec2", "vec2<f32>", "float32x2"],
+  [import_constants21.GL.FLOAT_VEC3]: [import_constants21.GL.FLOAT, 3, "vec3", "vec3<f32>", "float32x3"],
+  [import_constants21.GL.FLOAT_VEC4]: [import_constants21.GL.FLOAT, 4, "vec4", "vec4<f32>", "float32x4"],
+  [import_constants21.GL.INT]: [import_constants21.GL.INT, 1, "int", "i32", "sint32"],
+  [import_constants21.GL.INT_VEC2]: [import_constants21.GL.INT, 2, "ivec2", "vec2<i32>", "sint32x2"],
+  [import_constants21.GL.INT_VEC3]: [import_constants21.GL.INT, 3, "ivec3", "vec3<i32>", "sint32x3"],
+  [import_constants21.GL.INT_VEC4]: [import_constants21.GL.INT, 4, "ivec4", "vec4<i32>", "sint32x4"],
+  [import_constants21.GL.UNSIGNED_INT]: [import_constants21.GL.UNSIGNED_INT, 1, "uint", "u32", "uint32"],
+  [import_constants21.GL.UNSIGNED_INT_VEC2]: [import_constants21.GL.UNSIGNED_INT, 2, "uvec2", "vec2<u32>", "uint32x2"],
+  [import_constants21.GL.UNSIGNED_INT_VEC3]: [import_constants21.GL.UNSIGNED_INT, 3, "uvec3", "vec3<u32>", "uint32x3"],
+  [import_constants21.GL.UNSIGNED_INT_VEC4]: [import_constants21.GL.UNSIGNED_INT, 4, "uvec4", "vec4<u32>", "uint32x4"],
+  [import_constants21.GL.BOOL]: [import_constants21.GL.FLOAT, 1, "bool", "f32", "float32"],
+  [import_constants21.GL.BOOL_VEC2]: [import_constants21.GL.FLOAT, 2, "bvec2", "vec2<f32>", "float32x2"],
+  [import_constants21.GL.BOOL_VEC3]: [import_constants21.GL.FLOAT, 3, "bvec3", "vec3<f32>", "float32x3"],
+  [import_constants21.GL.BOOL_VEC4]: [import_constants21.GL.FLOAT, 4, "bvec4", "vec4<f32>", "float32x4"],
+  // TODO - are sizes/components below correct?
+  [import_constants21.GL.FLOAT_MAT2]: [import_constants21.GL.FLOAT, 8, "mat2", "mat2x2<f32>"],
   // 4
-  [import_constants20.GL.FLOAT_MAT2x3]: [import_constants20.GL.FLOAT, 8, "mat2x3", "mat2x3<f32>"],
+  [import_constants21.GL.FLOAT_MAT2x3]: [import_constants21.GL.FLOAT, 8, "mat2x3", "mat2x3<f32>"],
   // 6
-  [import_constants20.GL.FLOAT_MAT2x4]: [import_constants20.GL.FLOAT, 8, "mat2x4", "mat2x4<f32>"],
+  [import_constants21.GL.FLOAT_MAT2x4]: [import_constants21.GL.FLOAT, 8, "mat2x4", "mat2x4<f32>"],
   // 8
-  [import_constants20.GL.FLOAT_MAT3x2]: [import_constants20.GL.FLOAT, 12, "mat3x2", "mat3x2<f32>"],
+  [import_constants21.GL.FLOAT_MAT3x2]: [import_constants21.GL.FLOAT, 12, "mat3x2", "mat3x2<f32>"],
   // 6
-  [import_constants20.GL.FLOAT_MAT3]: [import_constants20.GL.FLOAT, 12, "mat3", "mat3x3<f32>"],
+  [import_constants21.GL.FLOAT_MAT3]: [import_constants21.GL.FLOAT, 12, "mat3", "mat3x3<f32>"],
   // 9
-  [import_constants20.GL.FLOAT_MAT3x4]: [import_constants20.GL.FLOAT, 12, "mat3x4", "mat3x4<f32>"],
+  [import_constants21.GL.FLOAT_MAT3x4]: [import_constants21.GL.FLOAT, 12, "mat3x4", "mat3x4<f32>"],
   // 12
-  [import_constants20.GL.FLOAT_MAT4x2]: [import_constants20.GL.FLOAT, 16, "mat4x2", "mat4x2<f32>"],
+  [import_constants21.GL.FLOAT_MAT4x2]: [import_constants21.GL.FLOAT, 16, "mat4x2", "mat4x2<f32>"],
   // 8
-  [import_constants20.GL.FLOAT_MAT4x3]: [import_constants20.GL.FLOAT, 16, "mat4x3", "mat4x3<f32>"],
+  [import_constants21.GL.FLOAT_MAT4x3]: [import_constants21.GL.FLOAT, 16, "mat4x3", "mat4x3<f32>"],
   // 12
-  [import_constants20.GL.FLOAT_MAT4]: [import_constants20.GL.FLOAT, 16, "mat4", "mat4x4<f32>"]
+  [import_constants21.GL.FLOAT_MAT4]: [import_constants21.GL.FLOAT, 16, "mat4", "mat4x4<f32>"]
   // 16
 };
-function decodeUniformType(uniformType) {
-  const typeAndSize = COMPOSITE_GL_TYPES[uniformType];
+function decodeGLUniformType(glUniformType) {
+  const typeAndSize = COMPOSITE_GL_TYPES[glUniformType];
   if (!typeAndSize) {
     throw new Error("uniform");
   }
   const [glType, components, , format] = typeAndSize;
   return { format, components, glType };
 }
-function decodeAttributeType(attributeType) {
-  const typeAndSize = COMPOSITE_GL_TYPES[attributeType];
+function decodeGLAttributeType(glAttributeType) {
+  const typeAndSize = COMPOSITE_GL_TYPES[glAttributeType];
   if (!typeAndSize) {
     throw new Error("attribute");
   }
-  const [glType, components, , , format] = typeAndSize;
-  return { format, components, glType };
-}
-
-// src/adapter/converters/vertex-formats.ts
-var import_constants21 = require("@luma.gl/constants");
-function getVertexFormat(type, components) {
-  const base = getDataFormat(type);
-  switch (components) {
-    case 1:
-      return base;
-    case 2:
-      return `${base}x2`;
-    case 3:
-      return `${base}x3`;
-    case 4:
-      return `${base}x4`;
-    default:
-      throw new Error(String(components));
-  }
-}
-function getDataFormat(type) {
-  switch (type) {
-    case import_constants21.GL.INT:
-      return "sint32";
-    case import_constants21.GL.UNSIGNED_INT:
-      return "uint32";
-    case import_constants21.GL.FLOAT:
-      return "float32";
-    default:
-      throw new Error(String(type));
-  }
+  const [, components, , shaderType, vertexFormat] = typeAndSize;
+  const attributeType = shaderType;
+  return { attributeType, vertexFormat, components };
 }
 
 // src/adapter/helpers/get-shader-layout.ts
@@ -4916,20 +4900,7 @@ function getShaderLayout(gl2, program) {
     attributes: [],
     bindings: []
   };
-  const attributes = readAttributeBindings(gl2, program);
-  for (const attribute of attributes) {
-    const size = Math.min(attribute.accessor.size, 4);
-    const format = (
-      // attribute.accessor.format ||
-      getVertexFormat(attribute.accessor.type || import_constants22.GL.FLOAT, size)
-    );
-    shaderLayout.attributes.push({
-      name: attribute.name,
-      location: attribute.location,
-      format,
-      stepMode: attribute.accessor.divisor === 1 ? "instance" : "vertex"
-    });
-  }
+  shaderLayout.attributes = readAttributeDeclarations(gl2, program);
   const uniformBlocks = readUniformBlocks(gl2, program);
   for (const uniformBlock of uniformBlocks) {
     const uniforms2 = uniformBlock.uniforms.map((uniform) => ({
@@ -4973,52 +4944,7 @@ function getShaderLayout(gl2, program) {
   }
   return shaderLayout;
 }
-function mergeShaderLayout(baseLayout, overrideLayout) {
-  const mergedLayout = __spreadProps(__spreadValues({}, baseLayout), {
-    attributes: baseLayout.attributes.map((attribute) => __spreadValues({}, attribute))
-  });
-  for (const attribute of (overrideLayout == null ? void 0 : overrideLayout.attributes) || []) {
-    const baseAttribute = mergedLayout.attributes.find((attr) => attr.name === attribute.name);
-    if (!baseAttribute) {
-      import_core22.log.warn(`shader layout attribute ${attribute.name} not present in shader`);
-    } else {
-      baseAttribute.format = attribute.format || baseAttribute.format;
-      baseAttribute.stepMode = attribute.stepMode || baseAttribute.stepMode;
-    }
-  }
-  return mergedLayout;
-}
-function mergeBufferMap(baseLayout, bufferMap) {
-  const mergedLayout = __spreadProps(__spreadValues({}, baseLayout), {
-    attributes: baseLayout.attributes.map((attribute) => __spreadValues({}, attribute))
-  });
-  for (const bufferMapping of bufferMap) {
-    switch (bufferMapping.type) {
-      case "interleave":
-        for (const attributeOverride of bufferMapping.attributes) {
-          overrideShaderLayoutAttribute(mergedLayout, attributeOverride);
-        }
-        break;
-      default:
-        overrideShaderLayoutAttribute(mergedLayout, bufferMapping);
-    }
-  }
-  return mergedLayout;
-}
-function overrideShaderLayoutAttribute(layout, attributeOverride) {
-  const attribute = getAttributeFromLayout(layout, attributeOverride.name);
-  if (attribute && attributeOverride.format) {
-    attribute.format = attributeOverride.format;
-  }
-}
-function getAttributeFromLayout(shaderLayout, name) {
-  const attribute = shaderLayout.attributes.find((attr) => attr.name === name);
-  if (!attribute) {
-    import_core22.log.warn(`shader layout attribute "${name}" not present in shader`);
-  }
-  return attribute || null;
-}
-function readAttributeBindings(gl2, program) {
+function readAttributeDeclarations(gl2, program) {
   const attributes = [];
   const count = gl2.getProgramParameter(program, gl2.ACTIVE_ATTRIBUTES);
   for (let index = 0; index < count; index++) {
@@ -5026,16 +4952,22 @@ function readAttributeBindings(gl2, program) {
     if (!activeInfo) {
       throw new Error("activeInfo");
     }
-    const { name, type: compositeType, size } = activeInfo;
-    const location = gl2.getAttribLocation(program, name);
+    const {
+      name: name2,
+      type: compositeType
+      /* , size*/
+    } = activeInfo;
+    const location = gl2.getAttribLocation(program, name2);
     if (location >= 0) {
-      const { glType, components } = decodeAttributeType(compositeType);
-      const accessor = { type: glType, size: size * components };
-      if (/instance/i.test(name)) {
-        accessor.divisor = 1;
-      }
-      const attributeInfo = { location, name, accessor: new Accessor(accessor) };
-      attributes.push(attributeInfo);
+      const { attributeType } = decodeGLAttributeType(compositeType);
+      const stepMode = /instance/i.test(name2) ? "instance" : "vertex";
+      attributes.push({
+        name: name2,
+        location,
+        stepMode,
+        type: attributeType
+        // size - for arrays, size is the number of elements in the array
+      });
     }
   }
   attributes.sort((a, b) => a.location - b.location);
@@ -5053,10 +4985,10 @@ function readVaryings(gl2, program) {
     if (!activeInfo) {
       throw new Error("activeInfo");
     }
-    const { name, type: compositeType, size } = activeInfo;
-    const { glType, components } = decodeUniformType(compositeType);
+    const { name: name2, type: compositeType, size } = activeInfo;
+    const { glType, components } = decodeGLUniformType(compositeType);
     const accessor = new Accessor({ type: glType, size: size * components });
-    const varying = { location, name, accessor };
+    const varying = { location, name: name2, accessor };
     varyings.push(varying);
   }
   varyings.sort((a, b) => a.location - b.location);
@@ -5071,12 +5003,12 @@ function readUniformBindings(gl2, program) {
       throw new Error("activeInfo");
     }
     const { name: rawName, size, type } = activeInfo;
-    const { name, isArray: isArray2 } = parseUniformName(rawName);
-    let webglLocation = gl2.getUniformLocation(program, name);
+    const { name: name2, isArray: isArray2 } = parseUniformName(rawName);
+    let webglLocation = gl2.getUniformLocation(program, name2);
     const uniformInfo = {
       // WebGL locations are uniquely typed but just numbers
       location: webglLocation,
-      name,
+      name: name2,
       size,
       type,
       isArray: isArray2
@@ -5084,7 +5016,7 @@ function readUniformBindings(gl2, program) {
     uniforms.push(uniformInfo);
     if (uniformInfo.size > 1) {
       for (let j = 0; j < uniformInfo.size; j++) {
-        const elementName = `${name}[${j}]`;
+        const elementName = `${name2}[${j}]`;
         webglLocation = gl2.getUniformLocation(program, elementName);
         const arrayElementUniformInfo = __spreadProps(__spreadValues({}, uniformInfo), {
           name: elementName,
@@ -5126,7 +5058,7 @@ function readUniformBlocks(gl2, program) {
       }
       blockInfo.uniforms.push({
         name: activeInfo.name,
-        format: decodeUniformType(uniformType[i]).format,
+        format: decodeGLUniformType(uniformType[i]).format,
         type: uniformType[i],
         arrayLength: uniformArrayLength[i],
         byteOffset: uniformOffset[i],
@@ -5165,18 +5097,18 @@ function getSamplerInfo(type) {
   const [viewDimension, sampleType] = sampler;
   return { viewDimension, sampleType };
 }
-function parseUniformName(name) {
-  if (name[name.length - 1] !== "]") {
+function parseUniformName(name2) {
+  if (name2[name2.length - 1] !== "]") {
     return {
-      name,
+      name: name2,
       length: 1,
       isArray: false
     };
   }
   const UNIFORM_NAME_REGEXP = /([^[]*)(\[[0-9]+\])?/;
-  const matches = UNIFORM_NAME_REGEXP.exec(name);
+  const matches = UNIFORM_NAME_REGEXP.exec(name2);
   if (!matches || matches.length < 2) {
-    throw new Error(`Failed to parse GLSL uniform name ${name}`);
+    throw new Error(`Failed to parse GLSL uniform name ${name2}`);
   }
   return {
     name: matches[1],
@@ -5189,34 +5121,34 @@ function parseUniformName(name) {
 var import_constants23 = require("@luma.gl/constants");
 function setUniform(gl2, location, type, value) {
   const gl22 = gl2;
-  if (typeof value === "number") {
-    switch (type) {
-      case import_constants23.GL.SAMPLER_2D:
-      case import_constants23.GL.SAMPLER_CUBE:
-      case import_constants23.GL.SAMPLER_3D:
-      case import_constants23.GL.SAMPLER_2D_SHADOW:
-      case import_constants23.GL.SAMPLER_2D_ARRAY:
-      case import_constants23.GL.SAMPLER_2D_ARRAY_SHADOW:
-      case import_constants23.GL.SAMPLER_CUBE_SHADOW:
-      case import_constants23.GL.INT_SAMPLER_2D:
-      case import_constants23.GL.INT_SAMPLER_3D:
-      case import_constants23.GL.INT_SAMPLER_CUBE:
-      case import_constants23.GL.INT_SAMPLER_2D_ARRAY:
-      case import_constants23.GL.UNSIGNED_INT_SAMPLER_2D:
-      case import_constants23.GL.UNSIGNED_INT_SAMPLER_3D:
-      case import_constants23.GL.UNSIGNED_INT_SAMPLER_CUBE:
-      case import_constants23.GL.UNSIGNED_INT_SAMPLER_2D_ARRAY:
-        return gl2.uniform1i(location, value);
-    }
-  }
-  if (value === true) {
-    value = 1;
-  }
-  if (value === false) {
-    value = 0;
-  }
-  const arrayValue = typeof value === "number" ? [value] : value;
+  let uniformValue = value;
+  if (uniformValue === true) {
+    uniformValue = 1;
+  }
+  if (uniformValue === false) {
+    uniformValue = 0;
+  }
+  const arrayValue = typeof uniformValue === "number" ? [uniformValue] : uniformValue;
   switch (type) {
+    case import_constants23.GL.SAMPLER_2D:
+    case import_constants23.GL.SAMPLER_CUBE:
+    case import_constants23.GL.SAMPLER_3D:
+    case import_constants23.GL.SAMPLER_2D_SHADOW:
+    case import_constants23.GL.SAMPLER_2D_ARRAY:
+    case import_constants23.GL.SAMPLER_2D_ARRAY_SHADOW:
+    case import_constants23.GL.SAMPLER_CUBE_SHADOW:
+    case import_constants23.GL.INT_SAMPLER_2D:
+    case import_constants23.GL.INT_SAMPLER_3D:
+    case import_constants23.GL.INT_SAMPLER_CUBE:
+    case import_constants23.GL.INT_SAMPLER_2D_ARRAY:
+    case import_constants23.GL.UNSIGNED_INT_SAMPLER_2D:
+    case import_constants23.GL.UNSIGNED_INT_SAMPLER_3D:
+    case import_constants23.GL.UNSIGNED_INT_SAMPLER_CUBE:
+    case import_constants23.GL.UNSIGNED_INT_SAMPLER_2D_ARRAY:
+      if (typeof value !== "number") {
+        throw new Error("samplers must be set to integers");
+      }
+      return gl2.uniform1i(location, value);
     case import_constants23.GL.FLOAT:
       return gl2.uniform1fv(location, arrayValue);
     case import_constants23.GL.FLOAT_VEC2:
@@ -5272,14 +5204,14 @@ function setUniform(gl2, location, type, value) {
 }
 
 // src/adapter/objects/webgl-vertex-array-object.ts
-var import_core23 = require("@luma.gl/core");
+var import_core22 = require("@luma.gl/core");
 var import_constants24 = require("@luma.gl/constants");
 var import_env2 = require("@probe.gl/env");
 var ERR_ELEMENTS = "elements must be GL.ELEMENT_ARRAY_BUFFER";
 var WEBGLVertexArrayObject = class extends WebGLResource {
   // Create a VertexArray
   constructor(device, props) {
-    super(device, props, __spreadProps(__spreadValues({}, import_core23.Resource.defaultProps), { constantAttributeZero: false }));
+    super(device, props, __spreadProps(__spreadValues({}, import_core22.Resource.defaultProps), { constantAttributeZero: false }));
     /** Buffer constant */
     this.buffer = null;
     this.bufferValue = null;
@@ -5327,7 +5259,7 @@ var WEBGLVertexArrayObject = class extends WebGLResource {
   // Set (bind) an elements buffer, for indexed rendering.
   // Must be a Buffer bound to GL.ELEMENT_ARRAY_BUFFER. Constants not supported
   setElementBuffer(elementBuffer = null, opts = {}) {
-    (0, import_core23.assert)(!elementBuffer || elementBuffer.glTarget === import_constants24.GL.ELEMENT_ARRAY_BUFFER, ERR_ELEMENTS);
+    (0, import_core22.assert)(!elementBuffer || elementBuffer.glTarget === import_constants24.GL.ELEMENT_ARRAY_BUFFER, ERR_ELEMENTS);
     this.bind(() => {
       this.gl.bindBuffer(import_constants24.GL.ELEMENT_ARRAY_BUFFER, elementBuffer ? elementBuffer.handle : null);
     });
@@ -5376,7 +5308,7 @@ var WEBGLVertexArrayObject = class extends WebGLResource {
         setConstantUintArray(this.device, location, array);
         break;
       default:
-        (0, import_core23.assert)(false);
+        (0, import_core22.assert)(false);
     }
   }
   /**
@@ -5394,8 +5326,8 @@ var WEBGLVertexArrayObject = class extends WebGLResource {
     updateNeeded = updateNeeded || this.buffer.reallocate(byteLength);
     updateNeeded = updateNeeded || !compareConstantArrayValues(constantValue, this.bufferValue);
     if (updateNeeded) {
-      const typedArray = (0, import_core23.getScratchArray)(value.constructor, length);
-      (0, import_core23.fillArray)({ target: typedArray, source: constantValue, start: 0, count: length });
+      const typedArray = (0, import_core22.getScratchArray)(value.constructor, length);
+      (0, import_core22.fillArray)({ target: typedArray, source: constantValue, start: 0, count: length });
       this.buffer.subData(typedArray);
       this.bufferValue = value;
     }
@@ -5417,7 +5349,7 @@ function setConstantFloatArray(device, location, array) {
       device.gl.vertexAttrib4fv(location, array);
       break;
     default:
-      (0, import_core23.assert)(false);
+      (0, import_core22.assert)(false);
   }
 }
 function setConstantIntArray(device, location, array) {
@@ -5450,7 +5382,7 @@ function compareConstantArrayValues(v1, v2) {
 
 // src/adapter/resources/webgl-render-pipeline.ts
 var LOG_PROGRAM_PERF_PRIORITY = 4;
-var WEBGLRenderPipeline = class extends import_core24.RenderPipeline {
+var WEBGLRenderPipeline = class extends import_core23.RenderPipeline {
   // TODO are these used?
   constructor(device, props) {
     var _a;
@@ -5470,8 +5402,8 @@ var WEBGLRenderPipeline = class extends import_core24.RenderPipeline {
     this.device = device;
     this.handle = this.props.handle || this.device.gl.createProgram();
     this.device.setSpectorMetadata(this.handle, { id: this.props.id });
-    this.vs = (0, import_core24.cast)(props.vs);
-    this.fs = (0, import_core24.cast)(props.fs);
+    this.vs = (0, import_core23.cast)(props.vs);
+    this.fs = (0, import_core23.cast)(props.fs);
     const { varyings, bufferMode = import_constants25.GL.SEPARATE_ATTRIBS } = props;
     if (varyings && varyings.length > 0) {
       this.device.assertWebGL2();
@@ -5480,9 +5412,8 @@ var WEBGLRenderPipeline = class extends import_core24.RenderPipeline {
     }
     this._compileAndLink();
     this.introspectedLayout = getShaderLayout(this.device.gl, this.handle);
-    this.layout = mergeShaderLayout(this.introspectedLayout, props.layout);
-    this.bufferMap = props.bufferMap || [];
-    this.layout = mergeBufferMap(this.layout, this.bufferMap);
+    this.shaderLayout = (0, import_core24.mergeShaderLayout)(this.introspectedLayout, props.shaderLayout);
+    this.bufferLayout = props.bufferLayout || [];
     this.vertexArrayObject = new WEBGLVertexArrayObject(this.device);
   }
   destroy() {
@@ -5492,75 +5423,82 @@ var WEBGLRenderPipeline = class extends import_core24.RenderPipeline {
     }
   }
   setIndexBuffer(indexBuffer) {
-    const webglBuffer = (0, import_core24.cast)(indexBuffer);
+    const webglBuffer = (0, import_core23.cast)(indexBuffer);
     this.vertexArrayObject.setElementBuffer(webglBuffer);
     this._indexBuffer = webglBuffer;
   }
   /** @todo needed for portable model */
-  setAttributes(attributes) {
-    for (const [name, buffer] of Object.entries(attributes)) {
-      const webglBuffer = (0, import_core24.cast)(buffer);
-      const attribute = getAttributeLayout(this.layout, name);
-      if (!attribute) {
-        import_core24.log.warn(`Ignoring buffer supplied for unknown attribute "${name}" in pipeline "${this.id}" (buffer "${buffer.id}")`)();
-        continue;
+  setAttributes(buffers) {
+    const attributeInfos = (0, import_core24.getAttributeInfosFromLayouts)(this.shaderLayout, this.bufferLayout);
+    for (const [bufferName, buffer] of Object.entries(buffers)) {
+      let set = false;
+      for (const attributeInfo of Object.values(attributeInfos)) {
+        if (attributeInfo.bufferName !== bufferName) {
+          continue;
+        }
+        const webglBuffer = (0, import_core23.cast)(buffer);
+        const glType = getGLFromVertexType(attributeInfo.bufferDataType);
+        import_core23.log.log(1, {
+          setAttribute: attributeInfo.name,
+          toBuffer: bufferName,
+          size: attributeInfo.bufferComponents,
+          type: glType,
+          stride: attributeInfo.byteStride,
+          offset: attributeInfo.byteOffset,
+          normalized: attributeInfo.normalized,
+          // it is the shader attribute declaration, not the vertex memory format,
+          // that determines if the data in the buffer will be treated as integers.
+          // /
+          // Also note that WebGL supports assigning non-normalized integer data to floating point attributes,
+          // but as far as we can tell, WebGPU does not.
+          integer: attributeInfo.integer,
+          divisor: attributeInfo.stepMode === "instance" ? 1 : 0
+        })();
+        this.vertexArrayObject.setBuffer(attributeInfo.location, webglBuffer, {
+          size: attributeInfo.bufferComponents,
+          type: glType,
+          stride: attributeInfo.byteStride,
+          offset: attributeInfo.byteOffset,
+          normalized: attributeInfo.normalized,
+          // it is the shader attribute declaration, not the vertex memory format,
+          // that determines if the data in the buffer will be treated as integers.
+          // /
+          // Also note that WebGL supports assigning non-normalized integer data to floating point attributes,
+          // but as far as we can tell, WebGPU does not.
+          integer: attributeInfo.integer,
+          divisor: attributeInfo.stepMode === "instance" ? 1 : 0
+        });
+        set = true;
+      }
+      if (!set) {
+        import_core23.log.warn(
+          `setAttributes(): Ignoring (buffer "${buffer.id}" for unknown attribute "${name}" in pipeline "${this.id}"`
+        )();
       }
-      const decoded = (0, import_core24.decodeVertexFormat)(attribute.format);
-      const {
-        type: typeString,
-        components: size,
-        byteLength: stride,
-        normalized
-        /* , integer*/
-      } = decoded;
-      const divisor = attribute.stepMode === "instance" ? 1 : 0;
-      const type = getWebGLDataType(typeString);
-      this.vertexArrayObject.setBuffer(attribute.location, webglBuffer, {
-        size,
-        type,
-        stride,
-        offset: 0,
-        normalized,
-        // it is the shader attribute declaration, not the vertex memory format, 
-        // that determines if the data in the buffer will be treated as integers.
-        // /
-        // Also note that WebGL supports assigning non-normalized integer data to floating point attributes,
-        // but as far as we can tell, WebGPU does not.
-        integer: false,
-        divisor
-      });
     }
   }
   /**
    * Constant attributes are only supported in WebGL, not in WebGPU
    * Any attribute that is disabled in the current vertex array object
    * is read from the context's global constant value for that attribute location.
-   * @param attributes 
+   * @param attributes
    */
   setConstantAttributes(attributes) {
-    for (const [name, value] of Object.entries(attributes)) {
-      const attribute = getAttributeLayout(this.layout, name);
-      if (!attribute) {
-        import_core24.log.warn(`Ignoring constant value supplied for unknown attribute "${name}" in pipeline "${this.id}"`)();
-        continue;
-      }
-      this.vertexArrayObject.setConstant(attribute.location, value);
-    }
     Object.assign(this.constantAttributes, attributes);
   }
-  /** 
+  /**
    * Bindings include: textures, samplers and uniform buffers
-   * @todo needed for portable model 
+   * @todo needed for portable model
    */
   setBindings(bindings) {
-    for (const [name, value] of Object.entries(bindings)) {
-      const binding = this.layout.bindings.find((binding2) => binding2.name === name);
+    for (const [name2, value] of Object.entries(bindings)) {
+      const binding = this.shaderLayout.bindings.find((binding2) => binding2.name === name2);
       if (!binding) {
-        import_core24.log.warn(`Unknown binding ${name} in render pipeline ${this.id}`)();
+        import_core23.log.warn(`Unknown binding ${name2} in render pipeline ${this.id}`)();
         continue;
       }
       if (!value) {
-        import_core24.log.warn(`Unsetting binding ${name} in render pipeline ${this.id}`)();
+        import_core23.log.warn(`Unsetting binding ${name2} in render pipeline ${this.id}`)();
       }
       switch (binding.type) {
         case "uniform":
@@ -5574,12 +5512,12 @@ var WEBGLRenderPipeline = class extends import_core24.RenderPipeline {
           }
           break;
         case "sampler":
-          import_core24.log.warn(`Ignoring sampler ${name}`)();
+          import_core23.log.warn(`Ignoring sampler ${name2}`)();
           break;
         default:
           throw new Error(binding.type);
       }
-      this.bindings[name] = value;
+      this.bindings[name2] = value;
     }
   }
   setUniforms(uniforms) {
@@ -5601,7 +5539,7 @@ var WEBGLRenderPipeline = class extends import_core24.RenderPipeline {
       // firstInstance,
       // baseVertex
     } = options;
-    const drawMode = getDrawMode(this.props.topology);
+    const drawMode = getGLDrawMode(this.props.topology);
     const isIndexed = Boolean(this._indexBuffer);
     const indexType = (_a = this._indexBuffer) == null ? void 0 : _a.glIndexType;
     const isInstanced = Number(options.instanceCount) > 0;
@@ -5634,7 +5572,12 @@ var WEBGLRenderPipeline = class extends import_core24.RenderPipeline {
           } else if (isIndexed) {
             this.device.gl.drawElements(drawMode, vertexCount || 0, indexType, firstVertex);
           } else if (isInstanced) {
-            (_b = this.device.gl2) == null ? void 0 : _b.drawArraysInstanced(drawMode, firstVertex, vertexCount || 0, instanceCount || 0);
+            (_b = this.device.gl2) == null ? void 0 : _b.drawArraysInstanced(
+              drawMode,
+              firstVertex,
+              vertexCount || 0,
+              instanceCount || 0
+            );
           } else {
             this.device.gl.drawArrays(drawMode, firstVertex, vertexCount || 0);
           }
@@ -5652,10 +5595,10 @@ var WEBGLRenderPipeline = class extends import_core24.RenderPipeline {
     const { gl: gl2 } = this.device;
     gl2.attachShader(this.handle, this.vs.handle);
     gl2.attachShader(this.handle, this.fs.handle);
-    import_core24.log.time(LOG_PROGRAM_PERF_PRIORITY, `linkProgram for ${this.id}`)();
+    import_core23.log.time(LOG_PROGRAM_PERF_PRIORITY, `linkProgram for ${this.id}`)();
     gl2.linkProgram(this.handle);
-    import_core24.log.timeEnd(LOG_PROGRAM_PERF_PRIORITY, `linkProgram for ${this.id}`)();
-    if (gl2.debug || import_core24.log.level > 0) {
+    import_core23.log.timeEnd(LOG_PROGRAM_PERF_PRIORITY, `linkProgram for ${this.id}`)();
+    if (gl2.debug || import_core23.log.level > 0) {
       const linked = gl2.getProgramParameter(this.handle, gl2.LINK_STATUS);
       if (!linked) {
         throw new Error(`Error linking: ${gl2.getProgramInfoLog(this.handle)}`);
@@ -5686,7 +5629,26 @@ var WEBGLRenderPipeline = class extends import_core24.RenderPipeline {
     }
     return texturesRenderable;
   }
-  /** Apply any bindings */
+  /**
+   * Constant attributes need to be reset before every draw call
+   * Any attribute that is disabled in the current vertex array object
+   * is read from the context's global constant value for that attribute location.
+   * @note Constant attributes are only supported in WebGL, not in WebGPU
+   */
+  _applyConstantAttributes() {
+    const attributeInfos = (0, import_core24.getAttributeInfosFromLayouts)(this.shaderLayout, this.bufferLayout);
+    for (const [name2, value] of Object.entries(this.constantAttributes)) {
+      const attributeInfo = attributeInfos[name2];
+      if (!attributeInfo) {
+        import_core23.log.warn(
+          `Ignoring constant value supplied for unknown attribute "${name2}" in pipeline "${this.id}"`
+        )();
+        continue;
+      }
+      this.vertexArrayObject.setConstant(attributeInfo.location, value);
+    }
+  }
+  /** Apply any bindings (before each draw call) */
   _applyBindings() {
     this.device.gl.useProgram(this.handle);
     const { gl2 } = this.device;
@@ -5695,17 +5657,17 @@ var WEBGLRenderPipeline = class extends import_core24.RenderPipeline {
     }
     let textureUnit = 0;
     let uniformBufferIndex = 0;
-    for (const binding of this.layout.bindings) {
+    for (const binding of this.shaderLayout.bindings) {
       const value = this.bindings[binding.name];
       if (!value) {
         throw new Error(`No value for binding ${binding.name} in ${this.id}`);
       }
       switch (binding.type) {
         case "uniform":
-          const { name } = binding;
-          const location = gl2.getUniformBlockIndex(this.handle, name);
+          const { name: name2 } = binding;
+          const location = gl2.getUniformBlockIndex(this.handle, name2);
           if (location === import_constants25.GL.INVALID_INDEX) {
-            throw new Error(`Invalid uniform block name ${name}`);
+            throw new Error(`Invalid uniform block name ${name2}`);
           }
           gl2.uniformBlockBinding(this.handle, uniformBufferIndex, location);
           if (value instanceof WEBGLBuffer) {
@@ -5738,33 +5700,22 @@ var WEBGLRenderPipeline = class extends import_core24.RenderPipeline {
       }
     }
   }
+  /**
+   * Due to program sharing, uniforms need to be reset before every draw call
+   * (though caching will avoid redundant WebGL calls)
+   */
   _applyUniforms() {
     var _a;
-    for (const uniformLayout of this.layout.uniforms || []) {
-      const { name, location, type, textureUnit } = uniformLayout;
-      const value = (_a = this.uniforms[name]) != null ? _a : textureUnit;
+    for (const uniformLayout of this.shaderLayout.uniforms || []) {
+      const { name: name2, location, type, textureUnit } = uniformLayout;
+      const value = (_a = this.uniforms[name2]) != null ? _a : textureUnit;
       if (value !== void 0) {
         setUniform(this.device.gl, location, type, value);
       }
     }
   }
-  /**
-   * Constant attributes are only supported in WebGL, not in WebGPU
-   * Any attribute that is disabled in the current vertex array object
-   * is read from the context's global constant value for that attribute location.
-   */
-  _applyConstantAttributes() {
-    for (const [name, value] of Object.entries(this.constantAttributes)) {
-      const attribute = getAttributeLayout(this.layout, name);
-      if (!attribute) {
-        import_core24.log.warn(`Ignoring constant value supplied for unknown attribute "${name}" in pipeline "${this.id}"`)();
-        continue;
-      }
-      this.vertexArrayObject.setConstant(attribute.location, value);
-    }
-  }
 };
-function getDrawMode(topology) {
+function getGLDrawMode(topology) {
   switch (topology) {
     case "point-list":
       return import_constants25.GL.POINTS;
@@ -5804,9 +5755,6 @@ function getGLPrimitive(topology) {
       throw new Error(topology);
   }
 }
-function getAttributeLayout(layout, name) {
-  return layout.attributes.find((binding) => binding.name === name) || null;
-}
 
 // src/adapter/resources/webgl-command-encoder.ts
 var import_core26 = require("@luma.gl/core");
@@ -6011,7 +5959,7 @@ function getFramebuffer(source) {
 // src/adapter/resources/webgl-command-encoder.ts
 var WEBGLCommandEncoder = class extends import_core26.CommandEncoder {
   constructor(device, props) {
-    super(props);
+    super(device, props);
     this.device = device;
     this.commandBuffer = new WEBGLCommandBuffer(device);
   }