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

package/dist/index.cjs

@@ -30,7 +30,6 @@ __export(dist_exports, {
   WEBGLFramebuffer: () => WEBGLFramebuffer,
   WEBGLRenderPass: () => WEBGLRenderPass,
   WEBGLRenderPipeline: () => WEBGLRenderPipeline,
-  WEBGLRenderbuffer: () => WEBGLRenderbuffer,
   WEBGLResource: () => WebGLResource,
   WEBGLSampler: () => WEBGLSampler,
   WEBGLShader: () => WEBGLShader,
@@ -41,6 +40,7 @@ __export(dist_exports, {
   WebGLDevice: () => WebGLDevice,
   WebGLResource: () => WebGLResource,
   _TEXTURE_FORMATS: () => TEXTURE_FORMATS,
+  _WEBGLRenderbuffer: () => WEBGLRenderbuffer,
   convertGLToTextureFormat: () => convertGLToTextureFormat,
   getGLParameters: () => getGLParameters,
   getShaderLayout: () => getShaderLayout,
@@ -56,7 +56,7 @@ __export(dist_exports, {
 module.exports = __toCommonJS(dist_exports);
 
 // dist/adapter/webgl-device.js
-var import_core29 = require("@luma.gl/core");
+var import_core27 = require("@luma.gl/core");
 
 // dist/context/state-tracker/track-context-state.js
 var import_core = require("@luma.gl/core");
@@ -64,99 +64,99 @@ var import_core = require("@luma.gl/core");
 // dist/context/parameters/webgl-parameter-tables.js
 var import_constants = require("@luma.gl/constants");
 var GL_PARAMETER_DEFAULTS = {
-  [import_constants.GL.BLEND]: false,
-  [import_constants.GL.BLEND_COLOR]: new Float32Array([0, 0, 0, 0]),
-  [import_constants.GL.BLEND_EQUATION_RGB]: import_constants.GL.FUNC_ADD,
-  [import_constants.GL.BLEND_EQUATION_ALPHA]: import_constants.GL.FUNC_ADD,
-  [import_constants.GL.BLEND_SRC_RGB]: import_constants.GL.ONE,
-  [import_constants.GL.BLEND_DST_RGB]: import_constants.GL.ZERO,
-  [import_constants.GL.BLEND_SRC_ALPHA]: import_constants.GL.ONE,
-  [import_constants.GL.BLEND_DST_ALPHA]: import_constants.GL.ZERO,
-  [import_constants.GL.COLOR_CLEAR_VALUE]: new Float32Array([0, 0, 0, 0]),
+  [3042]: false,
+  [32773]: new Float32Array([0, 0, 0, 0]),
+  [32777]: 32774,
+  [34877]: 32774,
+  [32969]: 1,
+  [32968]: 0,
+  [32971]: 1,
+  [32970]: 0,
+  [3106]: new Float32Array([0, 0, 0, 0]),
   // TBD
-  [import_constants.GL.COLOR_WRITEMASK]: [true, true, true, true],
-  [import_constants.GL.CULL_FACE]: false,
-  [import_constants.GL.CULL_FACE_MODE]: import_constants.GL.BACK,
-  [import_constants.GL.DEPTH_TEST]: false,
-  [import_constants.GL.DEPTH_CLEAR_VALUE]: 1,
-  [import_constants.GL.DEPTH_FUNC]: import_constants.GL.LESS,
-  [import_constants.GL.DEPTH_RANGE]: new Float32Array([0, 1]),
+  [3107]: [true, true, true, true],
+  [2884]: false,
+  [2885]: 1029,
+  [2929]: false,
+  [2931]: 1,
+  [2932]: 513,
+  [2928]: new Float32Array([0, 1]),
   // TBD
-  [import_constants.GL.DEPTH_WRITEMASK]: true,
-  [import_constants.GL.DITHER]: true,
-  [import_constants.GL.CURRENT_PROGRAM]: null,
+  [2930]: true,
+  [3024]: true,
+  [35725]: null,
   // FRAMEBUFFER_BINDING and DRAW_FRAMEBUFFER_BINDING(WebGL2) refer same state.
-  [import_constants.GL.FRAMEBUFFER_BINDING]: null,
-  [import_constants.GL.RENDERBUFFER_BINDING]: null,
-  [import_constants.GL.VERTEX_ARRAY_BINDING]: null,
-  [import_constants.GL.ARRAY_BUFFER_BINDING]: null,
-  [import_constants.GL.FRONT_FACE]: import_constants.GL.CCW,
-  [import_constants.GL.GENERATE_MIPMAP_HINT]: import_constants.GL.DONT_CARE,
-  [import_constants.GL.LINE_WIDTH]: 1,
-  [import_constants.GL.POLYGON_OFFSET_FILL]: false,
-  [import_constants.GL.POLYGON_OFFSET_FACTOR]: 0,
-  [import_constants.GL.POLYGON_OFFSET_UNITS]: 0,
-  [import_constants.GL.SAMPLE_ALPHA_TO_COVERAGE]: false,
-  [import_constants.GL.SAMPLE_COVERAGE]: false,
-  [import_constants.GL.SAMPLE_COVERAGE_VALUE]: 1,
-  [import_constants.GL.SAMPLE_COVERAGE_INVERT]: false,
-  [import_constants.GL.SCISSOR_TEST]: false,
+  [36006]: null,
+  [36007]: null,
+  [34229]: null,
+  [34964]: null,
+  [2886]: 2305,
+  [33170]: 4352,
+  [2849]: 1,
+  [32823]: false,
+  [32824]: 0,
+  [10752]: 0,
+  [32926]: false,
+  [32928]: false,
+  [32938]: 1,
+  [32939]: false,
+  [3089]: false,
   // Note: Dynamic value. If scissor test enabled we expect users to set correct scissor box
-  [import_constants.GL.SCISSOR_BOX]: new Int32Array([0, 0, 1024, 1024]),
-  [import_constants.GL.STENCIL_TEST]: false,
-  [import_constants.GL.STENCIL_CLEAR_VALUE]: 0,
-  [import_constants.GL.STENCIL_WRITEMASK]: 4294967295,
-  [import_constants.GL.STENCIL_BACK_WRITEMASK]: 4294967295,
-  [import_constants.GL.STENCIL_FUNC]: import_constants.GL.ALWAYS,
-  [import_constants.GL.STENCIL_REF]: 0,
-  [import_constants.GL.STENCIL_VALUE_MASK]: 4294967295,
-  [import_constants.GL.STENCIL_BACK_FUNC]: import_constants.GL.ALWAYS,
-  [import_constants.GL.STENCIL_BACK_REF]: 0,
-  [import_constants.GL.STENCIL_BACK_VALUE_MASK]: 4294967295,
-  [import_constants.GL.STENCIL_FAIL]: import_constants.GL.KEEP,
-  [import_constants.GL.STENCIL_PASS_DEPTH_FAIL]: import_constants.GL.KEEP,
-  [import_constants.GL.STENCIL_PASS_DEPTH_PASS]: import_constants.GL.KEEP,
-  [import_constants.GL.STENCIL_BACK_FAIL]: import_constants.GL.KEEP,
-  [import_constants.GL.STENCIL_BACK_PASS_DEPTH_FAIL]: import_constants.GL.KEEP,
-  [import_constants.GL.STENCIL_BACK_PASS_DEPTH_PASS]: import_constants.GL.KEEP,
+  [3088]: new Int32Array([0, 0, 1024, 1024]),
+  [2960]: false,
+  [2961]: 0,
+  [2968]: 4294967295,
+  [36005]: 4294967295,
+  [2962]: 519,
+  [2967]: 0,
+  [2963]: 4294967295,
+  [34816]: 519,
+  [36003]: 0,
+  [36004]: 4294967295,
+  [2964]: 7680,
+  [2965]: 7680,
+  [2966]: 7680,
+  [34817]: 7680,
+  [34818]: 7680,
+  [34819]: 7680,
   // Dynamic value: We use [0, 0, 1024, 1024] as default, but usually this is updated in each frame.
-  [import_constants.GL.VIEWPORT]: [0, 0, 1024, 1024],
-  [import_constants.GL.TRANSFORM_FEEDBACK_BINDING]: null,
-  [import_constants.GL.COPY_READ_BUFFER_BINDING]: null,
-  [import_constants.GL.COPY_WRITE_BUFFER_BINDING]: null,
-  [import_constants.GL.PIXEL_PACK_BUFFER_BINDING]: null,
-  [import_constants.GL.PIXEL_UNPACK_BUFFER_BINDING]: null,
-  [import_constants.GL.FRAGMENT_SHADER_DERIVATIVE_HINT]: import_constants.GL.DONT_CARE,
-  [import_constants.GL.READ_FRAMEBUFFER_BINDING]: null,
-  [import_constants.GL.RASTERIZER_DISCARD]: false,
-  [import_constants.GL.PACK_ALIGNMENT]: 4,
-  [import_constants.GL.UNPACK_ALIGNMENT]: 4,
-  [import_constants.GL.UNPACK_FLIP_Y_WEBGL]: false,
-  [import_constants.GL.UNPACK_PREMULTIPLY_ALPHA_WEBGL]: false,
-  [import_constants.GL.UNPACK_COLORSPACE_CONVERSION_WEBGL]: import_constants.GL.BROWSER_DEFAULT_WEBGL,
-  [import_constants.GL.PACK_ROW_LENGTH]: 0,
-  [import_constants.GL.PACK_SKIP_PIXELS]: 0,
-  [import_constants.GL.PACK_SKIP_ROWS]: 0,
-  [import_constants.GL.UNPACK_ROW_LENGTH]: 0,
-  [import_constants.GL.UNPACK_IMAGE_HEIGHT]: 0,
-  [import_constants.GL.UNPACK_SKIP_PIXELS]: 0,
-  [import_constants.GL.UNPACK_SKIP_ROWS]: 0,
-  [import_constants.GL.UNPACK_SKIP_IMAGES]: 0
+  [2978]: [0, 0, 1024, 1024],
+  [36389]: null,
+  [36662]: null,
+  [36663]: null,
+  [35053]: null,
+  [35055]: null,
+  [35723]: 4352,
+  [36010]: null,
+  [35977]: false,
+  [3333]: 4,
+  [3317]: 4,
+  [37440]: false,
+  [37441]: false,
+  [37443]: 37444,
+  [3330]: 0,
+  [3332]: 0,
+  [3331]: 0,
+  [3314]: 0,
+  [32878]: 0,
+  [3316]: 0,
+  [3315]: 0,
+  [32877]: 0
 };
 var enable = (gl, value, key) => value ? gl.enable(key) : gl.disable(key);
 var hint = (gl, value, key) => gl.hint(key, value);
 var pixelStorei = (gl, value, key) => gl.pixelStorei(key, value);
 var bindFramebuffer = (gl, value, key) => {
-  const target = key === import_constants.GL.FRAMEBUFFER_BINDING ? import_constants.GL.DRAW_FRAMEBUFFER : import_constants.GL.READ_FRAMEBUFFER;
+  const target = key === 36006 ? 36009 : 36008;
   return gl.bindFramebuffer(target, value);
 };
 var bindBuffer = (gl, value, key) => {
   const bindingMap = {
-    [import_constants.GL.ARRAY_BUFFER_BINDING]: import_constants.GL.ARRAY_BUFFER,
-    [import_constants.GL.COPY_READ_BUFFER_BINDING]: import_constants.GL.COPY_READ_BUFFER,
-    [import_constants.GL.COPY_WRITE_BUFFER_BINDING]: import_constants.GL.COPY_WRITE_BUFFER,
-    [import_constants.GL.PIXEL_PACK_BUFFER_BINDING]: import_constants.GL.PIXEL_PACK_BUFFER,
-    [import_constants.GL.PIXEL_UNPACK_BUFFER_BINDING]: import_constants.GL.PIXEL_UNPACK_BUFFER
+    [34964]: 34962,
+    [36662]: 36662,
+    [36663]: 36663,
+    [35053]: 35051,
+    [35055]: 35052
   };
   const glTarget = bindingMap[key];
   gl.bindBuffer(glTarget, value);
@@ -165,108 +165,108 @@ function isArray(array) {
   return Array.isArray(array) || ArrayBuffer.isView(array) && !(array instanceof DataView);
 }
 var GL_PARAMETER_SETTERS = {
-  [import_constants.GL.BLEND]: enable,
-  [import_constants.GL.BLEND_COLOR]: (gl, value) => gl.blendColor(...value),
-  [import_constants.GL.BLEND_EQUATION_RGB]: "blendEquation",
-  [import_constants.GL.BLEND_EQUATION_ALPHA]: "blendEquation",
-  [import_constants.GL.BLEND_SRC_RGB]: "blendFunc",
-  [import_constants.GL.BLEND_DST_RGB]: "blendFunc",
-  [import_constants.GL.BLEND_SRC_ALPHA]: "blendFunc",
-  [import_constants.GL.BLEND_DST_ALPHA]: "blendFunc",
-  [import_constants.GL.COLOR_CLEAR_VALUE]: (gl, value) => gl.clearColor(...value),
-  [import_constants.GL.COLOR_WRITEMASK]: (gl, value) => gl.colorMask(...value),
-  [import_constants.GL.CULL_FACE]: enable,
-  [import_constants.GL.CULL_FACE_MODE]: (gl, value) => gl.cullFace(value),
-  [import_constants.GL.DEPTH_TEST]: enable,
-  [import_constants.GL.DEPTH_CLEAR_VALUE]: (gl, value) => gl.clearDepth(value),
-  [import_constants.GL.DEPTH_FUNC]: (gl, value) => gl.depthFunc(value),
-  [import_constants.GL.DEPTH_RANGE]: (gl, value) => gl.depthRange(...value),
-  [import_constants.GL.DEPTH_WRITEMASK]: (gl, value) => gl.depthMask(value),
-  [import_constants.GL.DITHER]: enable,
-  [import_constants.GL.FRAGMENT_SHADER_DERIVATIVE_HINT]: hint,
-  [import_constants.GL.CURRENT_PROGRAM]: (gl, value) => gl.useProgram(value),
-  [import_constants.GL.RENDERBUFFER_BINDING]: (gl, value) => gl.bindRenderbuffer(import_constants.GL.RENDERBUFFER, value),
-  [import_constants.GL.TRANSFORM_FEEDBACK_BINDING]: (gl, value) => {
+  [3042]: enable,
+  [32773]: (gl, value) => gl.blendColor(...value),
+  [32777]: "blendEquation",
+  [34877]: "blendEquation",
+  [32969]: "blendFunc",
+  [32968]: "blendFunc",
+  [32971]: "blendFunc",
+  [32970]: "blendFunc",
+  [3106]: (gl, value) => gl.clearColor(...value),
+  [3107]: (gl, value) => gl.colorMask(...value),
+  [2884]: enable,
+  [2885]: (gl, value) => gl.cullFace(value),
+  [2929]: enable,
+  [2931]: (gl, value) => gl.clearDepth(value),
+  [2932]: (gl, value) => gl.depthFunc(value),
+  [2928]: (gl, value) => gl.depthRange(...value),
+  [2930]: (gl, value) => gl.depthMask(value),
+  [3024]: enable,
+  [35723]: hint,
+  [35725]: (gl, value) => gl.useProgram(value),
+  [36007]: (gl, value) => gl.bindRenderbuffer(36161, value),
+  [36389]: (gl, value) => {
     var _a;
-    return (_a = gl.bindTransformFeedback) == null ? void 0 : _a.call(gl, import_constants.GL.TRANSFORM_FEEDBACK, value);
+    return (_a = gl.bindTransformFeedback) == null ? void 0 : _a.call(gl, 36386, value);
   },
-  [import_constants.GL.VERTEX_ARRAY_BINDING]: (gl, value) => gl.bindVertexArray(value),
+  [34229]: (gl, value) => gl.bindVertexArray(value),
   // NOTE: FRAMEBUFFER_BINDING and DRAW_FRAMEBUFFER_BINDING(WebGL2) refer same state.
-  [import_constants.GL.FRAMEBUFFER_BINDING]: bindFramebuffer,
-  [import_constants.GL.READ_FRAMEBUFFER_BINDING]: bindFramebuffer,
+  [36006]: bindFramebuffer,
+  [36010]: bindFramebuffer,
   // Buffers
-  [import_constants.GL.ARRAY_BUFFER_BINDING]: bindBuffer,
-  [import_constants.GL.COPY_READ_BUFFER_BINDING]: bindBuffer,
-  [import_constants.GL.COPY_WRITE_BUFFER_BINDING]: bindBuffer,
-  [import_constants.GL.PIXEL_PACK_BUFFER_BINDING]: bindBuffer,
-  [import_constants.GL.PIXEL_UNPACK_BUFFER_BINDING]: bindBuffer,
-  [import_constants.GL.FRONT_FACE]: (gl, value) => gl.frontFace(value),
-  [import_constants.GL.GENERATE_MIPMAP_HINT]: hint,
-  [import_constants.GL.LINE_WIDTH]: (gl, value) => gl.lineWidth(value),
-  [import_constants.GL.POLYGON_OFFSET_FILL]: enable,
-  [import_constants.GL.POLYGON_OFFSET_FACTOR]: "polygonOffset",
-  [import_constants.GL.POLYGON_OFFSET_UNITS]: "polygonOffset",
-  [import_constants.GL.RASTERIZER_DISCARD]: enable,
-  [import_constants.GL.SAMPLE_ALPHA_TO_COVERAGE]: enable,
-  [import_constants.GL.SAMPLE_COVERAGE]: enable,
-  [import_constants.GL.SAMPLE_COVERAGE_VALUE]: "sampleCoverage",
-  [import_constants.GL.SAMPLE_COVERAGE_INVERT]: "sampleCoverage",
-  [import_constants.GL.SCISSOR_TEST]: enable,
-  [import_constants.GL.SCISSOR_BOX]: (gl, value) => gl.scissor(...value),
-  [import_constants.GL.STENCIL_TEST]: enable,
-  [import_constants.GL.STENCIL_CLEAR_VALUE]: (gl, value) => gl.clearStencil(value),
-  [import_constants.GL.STENCIL_WRITEMASK]: (gl, value) => gl.stencilMaskSeparate(import_constants.GL.FRONT, value),
-  [import_constants.GL.STENCIL_BACK_WRITEMASK]: (gl, value) => gl.stencilMaskSeparate(import_constants.GL.BACK, value),
-  [import_constants.GL.STENCIL_FUNC]: "stencilFuncFront",
-  [import_constants.GL.STENCIL_REF]: "stencilFuncFront",
-  [import_constants.GL.STENCIL_VALUE_MASK]: "stencilFuncFront",
-  [import_constants.GL.STENCIL_BACK_FUNC]: "stencilFuncBack",
-  [import_constants.GL.STENCIL_BACK_REF]: "stencilFuncBack",
-  [import_constants.GL.STENCIL_BACK_VALUE_MASK]: "stencilFuncBack",
-  [import_constants.GL.STENCIL_FAIL]: "stencilOpFront",
-  [import_constants.GL.STENCIL_PASS_DEPTH_FAIL]: "stencilOpFront",
-  [import_constants.GL.STENCIL_PASS_DEPTH_PASS]: "stencilOpFront",
-  [import_constants.GL.STENCIL_BACK_FAIL]: "stencilOpBack",
-  [import_constants.GL.STENCIL_BACK_PASS_DEPTH_FAIL]: "stencilOpBack",
-  [import_constants.GL.STENCIL_BACK_PASS_DEPTH_PASS]: "stencilOpBack",
-  [import_constants.GL.VIEWPORT]: (gl, value) => gl.viewport(...value),
+  [34964]: bindBuffer,
+  [36662]: bindBuffer,
+  [36663]: bindBuffer,
+  [35053]: bindBuffer,
+  [35055]: bindBuffer,
+  [2886]: (gl, value) => gl.frontFace(value),
+  [33170]: hint,
+  [2849]: (gl, value) => gl.lineWidth(value),
+  [32823]: enable,
+  [32824]: "polygonOffset",
+  [10752]: "polygonOffset",
+  [35977]: enable,
+  [32926]: enable,
+  [32928]: enable,
+  [32938]: "sampleCoverage",
+  [32939]: "sampleCoverage",
+  [3089]: enable,
+  [3088]: (gl, value) => gl.scissor(...value),
+  [2960]: enable,
+  [2961]: (gl, value) => gl.clearStencil(value),
+  [2968]: (gl, value) => gl.stencilMaskSeparate(1028, value),
+  [36005]: (gl, value) => gl.stencilMaskSeparate(1029, value),
+  [2962]: "stencilFuncFront",
+  [2967]: "stencilFuncFront",
+  [2963]: "stencilFuncFront",
+  [34816]: "stencilFuncBack",
+  [36003]: "stencilFuncBack",
+  [36004]: "stencilFuncBack",
+  [2964]: "stencilOpFront",
+  [2965]: "stencilOpFront",
+  [2966]: "stencilOpFront",
+  [34817]: "stencilOpBack",
+  [34818]: "stencilOpBack",
+  [34819]: "stencilOpBack",
+  [2978]: (gl, value) => gl.viewport(...value),
   // WEBGL2 EXTENSIONS
   // EXT_depth_clamp https://registry.khronos.org/webgl/extensions/EXT_depth_clamp/
-  [import_constants.GL.DEPTH_CLAMP_EXT]: enable,
+  [34383]: enable,
   // WEBGL_provoking_vertex https://registry.khronos.org/webgl/extensions/WEBGL_provoking_vertex/
   // [GL.PROVOKING_VERTEX_WEBL]: TODO - extension function needed
   // WEBGL_polygon_mode https://registry.khronos.org/webgl/extensions/WEBGL_polygon_mode/
   // POLYGON_MODE_WEBGL  TODO - extension function needed
-  [import_constants.GL.POLYGON_OFFSET_LINE_WEBGL]: enable,
+  [10754]: enable,
   // WEBGL_clip_cull_distance https://registry.khronos.org/webgl/extensions/WEBGL_clip_cull_distance/
-  [import_constants.GL.CLIP_DISTANCE0_WEBGL]: enable,
-  [import_constants.GL.CLIP_DISTANCE1_WEBGL]: enable,
-  [import_constants.GL.CLIP_DISTANCE2_WEBGL]: enable,
-  [import_constants.GL.CLIP_DISTANCE3_WEBGL]: enable,
-  [import_constants.GL.CLIP_DISTANCE4_WEBGL]: enable,
-  [import_constants.GL.CLIP_DISTANCE5_WEBGL]: enable,
-  [import_constants.GL.CLIP_DISTANCE6_WEBGL]: enable,
-  [import_constants.GL.CLIP_DISTANCE7_WEBGL]: enable,
+  [12288]: enable,
+  [12289]: enable,
+  [12290]: enable,
+  [12291]: enable,
+  [12292]: enable,
+  [12293]: enable,
+  [12294]: enable,
+  [12295]: enable,
   // PIXEL PACK/UNPACK MODES
-  [import_constants.GL.PACK_ALIGNMENT]: pixelStorei,
-  [import_constants.GL.UNPACK_ALIGNMENT]: pixelStorei,
-  [import_constants.GL.UNPACK_FLIP_Y_WEBGL]: pixelStorei,
-  [import_constants.GL.UNPACK_PREMULTIPLY_ALPHA_WEBGL]: pixelStorei,
-  [import_constants.GL.UNPACK_COLORSPACE_CONVERSION_WEBGL]: pixelStorei,
-  [import_constants.GL.PACK_ROW_LENGTH]: pixelStorei,
-  [import_constants.GL.PACK_SKIP_PIXELS]: pixelStorei,
-  [import_constants.GL.PACK_SKIP_ROWS]: pixelStorei,
-  [import_constants.GL.UNPACK_ROW_LENGTH]: pixelStorei,
-  [import_constants.GL.UNPACK_IMAGE_HEIGHT]: pixelStorei,
-  [import_constants.GL.UNPACK_SKIP_PIXELS]: pixelStorei,
-  [import_constants.GL.UNPACK_SKIP_ROWS]: pixelStorei,
-  [import_constants.GL.UNPACK_SKIP_IMAGES]: pixelStorei,
+  [3333]: pixelStorei,
+  [3317]: pixelStorei,
+  [37440]: pixelStorei,
+  [37441]: pixelStorei,
+  [37443]: pixelStorei,
+  [3330]: pixelStorei,
+  [3332]: pixelStorei,
+  [3331]: pixelStorei,
+  [3314]: pixelStorei,
+  [32878]: pixelStorei,
+  [3316]: pixelStorei,
+  [3315]: pixelStorei,
+  [32877]: pixelStorei,
   // Function-style setters
   framebuffer: (gl, framebuffer) => {
     const handle = framebuffer && "handle" in framebuffer ? framebuffer.handle : framebuffer;
-    return gl.bindFramebuffer(import_constants.GL.FRAMEBUFFER, handle);
+    return gl.bindFramebuffer(36160, handle);
   },
-  blend: (gl, value) => value ? gl.enable(import_constants.GL.BLEND) : gl.disable(import_constants.GL.BLEND),
+  blend: (gl, value) => value ? gl.enable(3042) : gl.disable(3042),
   blendColor: (gl, value) => gl.blendColor(...value),
   blendEquation: (gl, args) => {
     const separateModes = typeof args === "number" ? [args, args] : args;
@@ -280,42 +280,42 @@ var GL_PARAMETER_SETTERS = {
   clearDepth: (gl, value) => gl.clearDepth(value),
   clearStencil: (gl, value) => gl.clearStencil(value),
   colorMask: (gl, value) => gl.colorMask(...value),
-  cull: (gl, value) => value ? gl.enable(import_constants.GL.CULL_FACE) : gl.disable(import_constants.GL.CULL_FACE),
+  cull: (gl, value) => value ? gl.enable(2884) : gl.disable(2884),
   cullFace: (gl, value) => gl.cullFace(value),
-  depthTest: (gl, value) => value ? gl.enable(import_constants.GL.DEPTH_TEST) : gl.disable(import_constants.GL.DEPTH_TEST),
+  depthTest: (gl, value) => value ? gl.enable(2929) : gl.disable(2929),
   depthFunc: (gl, value) => gl.depthFunc(value),
   depthMask: (gl, value) => gl.depthMask(value),
   depthRange: (gl, value) => gl.depthRange(...value),
-  dither: (gl, value) => value ? gl.enable(import_constants.GL.DITHER) : gl.disable(import_constants.GL.DITHER),
+  dither: (gl, value) => value ? gl.enable(3024) : gl.disable(3024),
   derivativeHint: (gl, value) => {
-    gl.hint(import_constants.GL.FRAGMENT_SHADER_DERIVATIVE_HINT, value);
+    gl.hint(35723, value);
   },
   frontFace: (gl, value) => gl.frontFace(value),
-  mipmapHint: (gl, value) => gl.hint(import_constants.GL.GENERATE_MIPMAP_HINT, value),
+  mipmapHint: (gl, value) => gl.hint(33170, value),
   lineWidth: (gl, value) => gl.lineWidth(value),
-  polygonOffsetFill: (gl, value) => value ? gl.enable(import_constants.GL.POLYGON_OFFSET_FILL) : gl.disable(import_constants.GL.POLYGON_OFFSET_FILL),
+  polygonOffsetFill: (gl, value) => value ? gl.enable(32823) : gl.disable(32823),
   polygonOffset: (gl, value) => gl.polygonOffset(...value),
   sampleCoverage: (gl, value) => gl.sampleCoverage(...value),
-  scissorTest: (gl, value) => value ? gl.enable(import_constants.GL.SCISSOR_TEST) : gl.disable(import_constants.GL.SCISSOR_TEST),
+  scissorTest: (gl, value) => value ? gl.enable(3089) : gl.disable(3089),
   scissor: (gl, value) => gl.scissor(...value),
-  stencilTest: (gl, value) => value ? gl.enable(import_constants.GL.STENCIL_TEST) : gl.disable(import_constants.GL.STENCIL_TEST),
+  stencilTest: (gl, value) => value ? gl.enable(2960) : gl.disable(2960),
   stencilMask: (gl, value) => {
     value = isArray(value) ? value : [value, value];
     const [mask, backMask] = value;
-    gl.stencilMaskSeparate(import_constants.GL.FRONT, mask);
-    gl.stencilMaskSeparate(import_constants.GL.BACK, backMask);
+    gl.stencilMaskSeparate(1028, mask);
+    gl.stencilMaskSeparate(1029, backMask);
   },
   stencilFunc: (gl, args) => {
     args = isArray(args) && args.length === 3 ? [...args, ...args] : args;
     const [func, ref, mask, backFunc, backRef, backMask] = args;
-    gl.stencilFuncSeparate(import_constants.GL.FRONT, func, ref, mask);
-    gl.stencilFuncSeparate(import_constants.GL.BACK, backFunc, backRef, backMask);
+    gl.stencilFuncSeparate(1028, func, ref, mask);
+    gl.stencilFuncSeparate(1029, backFunc, backRef, backMask);
   },
   stencilOp: (gl, args) => {
     args = isArray(args) && args.length === 3 ? [...args, ...args] : args;
     const [sfail, dpfail, dppass, backSfail, backDpfail, backDppass] = args;
-    gl.stencilOpSeparate(import_constants.GL.FRONT, sfail, dpfail, dppass);
-    gl.stencilOpSeparate(import_constants.GL.BACK, backSfail, backDpfail, backDppass);
+    gl.stencilOpSeparate(1028, sfail, dpfail, dppass);
+    gl.stencilOpSeparate(1029, backSfail, backDpfail, backDppass);
   },
   viewport: (gl, value) => gl.viewport(...value)
 };
@@ -323,14 +323,14 @@ function getValue(glEnum, values, cache) {
   return values[glEnum] !== void 0 ? values[glEnum] : cache[glEnum];
 }
 var GL_COMPOSITE_PARAMETER_SETTERS = {
-  blendEquation: (gl, values, cache) => gl.blendEquationSeparate(getValue(import_constants.GL.BLEND_EQUATION_RGB, values, cache), getValue(import_constants.GL.BLEND_EQUATION_ALPHA, values, cache)),
-  blendFunc: (gl, values, cache) => gl.blendFuncSeparate(getValue(import_constants.GL.BLEND_SRC_RGB, values, cache), getValue(import_constants.GL.BLEND_DST_RGB, values, cache), getValue(import_constants.GL.BLEND_SRC_ALPHA, values, cache), getValue(import_constants.GL.BLEND_DST_ALPHA, values, cache)),
-  polygonOffset: (gl, values, cache) => gl.polygonOffset(getValue(import_constants.GL.POLYGON_OFFSET_FACTOR, values, cache), getValue(import_constants.GL.POLYGON_OFFSET_UNITS, values, cache)),
-  sampleCoverage: (gl, values, cache) => gl.sampleCoverage(getValue(import_constants.GL.SAMPLE_COVERAGE_VALUE, values, cache), getValue(import_constants.GL.SAMPLE_COVERAGE_INVERT, values, cache)),
-  stencilFuncFront: (gl, values, cache) => gl.stencilFuncSeparate(import_constants.GL.FRONT, getValue(import_constants.GL.STENCIL_FUNC, values, cache), getValue(import_constants.GL.STENCIL_REF, values, cache), getValue(import_constants.GL.STENCIL_VALUE_MASK, values, cache)),
-  stencilFuncBack: (gl, values, cache) => gl.stencilFuncSeparate(import_constants.GL.BACK, getValue(import_constants.GL.STENCIL_BACK_FUNC, values, cache), getValue(import_constants.GL.STENCIL_BACK_REF, values, cache), getValue(import_constants.GL.STENCIL_BACK_VALUE_MASK, values, cache)),
-  stencilOpFront: (gl, values, cache) => gl.stencilOpSeparate(import_constants.GL.FRONT, getValue(import_constants.GL.STENCIL_FAIL, values, cache), getValue(import_constants.GL.STENCIL_PASS_DEPTH_FAIL, values, cache), getValue(import_constants.GL.STENCIL_PASS_DEPTH_PASS, values, cache)),
-  stencilOpBack: (gl, values, cache) => gl.stencilOpSeparate(import_constants.GL.BACK, getValue(import_constants.GL.STENCIL_BACK_FAIL, values, cache), getValue(import_constants.GL.STENCIL_BACK_PASS_DEPTH_FAIL, values, cache), getValue(import_constants.GL.STENCIL_BACK_PASS_DEPTH_PASS, values, cache))
+  blendEquation: (gl, values, cache) => gl.blendEquationSeparate(getValue(32777, values, cache), getValue(34877, values, cache)),
+  blendFunc: (gl, values, cache) => gl.blendFuncSeparate(getValue(32969, values, cache), getValue(32968, values, cache), getValue(32971, values, cache), getValue(32970, values, cache)),
+  polygonOffset: (gl, values, cache) => gl.polygonOffset(getValue(32824, values, cache), getValue(10752, values, cache)),
+  sampleCoverage: (gl, values, cache) => gl.sampleCoverage(getValue(32938, values, cache), getValue(32939, values, cache)),
+  stencilFuncFront: (gl, values, cache) => gl.stencilFuncSeparate(1028, getValue(2962, values, cache), getValue(2967, values, cache), getValue(2963, values, cache)),
+  stencilFuncBack: (gl, values, cache) => gl.stencilFuncSeparate(1029, getValue(34816, values, cache), getValue(36003, values, cache), getValue(36004, values, cache)),
+  stencilOpFront: (gl, values, cache) => gl.stencilOpSeparate(1028, getValue(2964, values, cache), getValue(2965, values, cache), getValue(2966, values, cache)),
+  stencilOpBack: (gl, values, cache) => gl.stencilOpSeparate(1029, getValue(34817, values, cache), getValue(34818, values, cache), getValue(34819, values, cache))
 };
 var GL_HOOKED_SETTERS = {
   // GENERIC SETTERS
@@ -348,39 +348,39 @@ var GL_HOOKED_SETTERS = {
   }),
   // SPECIFIC SETTERS
   useProgram: (update, value) => update({
-    [import_constants.GL.CURRENT_PROGRAM]: value
+    [35725]: value
   }),
   bindRenderbuffer: (update, target, value) => update({
-    [import_constants.GL.RENDERBUFFER_BINDING]: value
+    [36007]: value
   }),
   bindTransformFeedback: (update, target, value) => update({
-    [import_constants.GL.TRANSFORM_FEEDBACK_BINDING]: value
+    [36389]: value
   }),
   bindVertexArray: (update, value) => update({
-    [import_constants.GL.VERTEX_ARRAY_BINDING]: value
+    [34229]: value
   }),
   bindFramebuffer: (update, target, framebuffer) => {
     switch (target) {
-      case import_constants.GL.FRAMEBUFFER:
+      case 36160:
         return update({
-          [import_constants.GL.DRAW_FRAMEBUFFER_BINDING]: framebuffer,
-          [import_constants.GL.READ_FRAMEBUFFER_BINDING]: framebuffer
+          [36006]: framebuffer,
+          [36010]: framebuffer
         });
-      case import_constants.GL.DRAW_FRAMEBUFFER:
-        return update({ [import_constants.GL.DRAW_FRAMEBUFFER_BINDING]: framebuffer });
-      case import_constants.GL.READ_FRAMEBUFFER:
-        return update({ [import_constants.GL.READ_FRAMEBUFFER_BINDING]: framebuffer });
+      case 36009:
+        return update({ [36006]: framebuffer });
+      case 36008:
+        return update({ [36010]: framebuffer });
       default:
         return null;
     }
   },
   bindBuffer: (update, target, buffer) => {
     const pname = {
-      [import_constants.GL.ARRAY_BUFFER]: [import_constants.GL.ARRAY_BUFFER_BINDING],
-      [import_constants.GL.COPY_READ_BUFFER]: [import_constants.GL.COPY_READ_BUFFER_BINDING],
-      [import_constants.GL.COPY_WRITE_BUFFER]: [import_constants.GL.COPY_WRITE_BUFFER_BINDING],
-      [import_constants.GL.PIXEL_PACK_BUFFER]: [import_constants.GL.PIXEL_PACK_BUFFER_BINDING],
-      [import_constants.GL.PIXEL_UNPACK_BUFFER]: [import_constants.GL.PIXEL_UNPACK_BUFFER_BINDING]
+      [34962]: [34964],
+      [36662]: [36662],
+      [36663]: [36663],
+      [35051]: [35053],
+      [35052]: [35055]
     }[target];
     if (pname) {
       return update({ [pname]: buffer });
@@ -388,162 +388,154 @@ var GL_HOOKED_SETTERS = {
     return { valueChanged: true };
   },
   blendColor: (update, r, g, b, a) => update({
-    [import_constants.GL.BLEND_COLOR]: new Float32Array([r, g, b, a])
+    [32773]: new Float32Array([r, g, b, a])
   }),
   blendEquation: (update, mode) => update({
-    [import_constants.GL.BLEND_EQUATION_RGB]: mode,
-    [import_constants.GL.BLEND_EQUATION_ALPHA]: mode
+    [32777]: mode,
+    [34877]: mode
   }),
   blendEquationSeparate: (update, modeRGB, modeAlpha) => update({
-    [import_constants.GL.BLEND_EQUATION_RGB]: modeRGB,
-    [import_constants.GL.BLEND_EQUATION_ALPHA]: modeAlpha
+    [32777]: modeRGB,
+    [34877]: modeAlpha
   }),
   blendFunc: (update, src, dst) => update({
-    [import_constants.GL.BLEND_SRC_RGB]: src,
-    [import_constants.GL.BLEND_DST_RGB]: dst,
-    [import_constants.GL.BLEND_SRC_ALPHA]: src,
-    [import_constants.GL.BLEND_DST_ALPHA]: dst
+    [32969]: src,
+    [32968]: dst,
+    [32971]: src,
+    [32970]: dst
   }),
   blendFuncSeparate: (update, srcRGB, dstRGB, srcAlpha, dstAlpha) => update({
-    [import_constants.GL.BLEND_SRC_RGB]: srcRGB,
-    [import_constants.GL.BLEND_DST_RGB]: dstRGB,
-    [import_constants.GL.BLEND_SRC_ALPHA]: srcAlpha,
-    [import_constants.GL.BLEND_DST_ALPHA]: dstAlpha
+    [32969]: srcRGB,
+    [32968]: dstRGB,
+    [32971]: srcAlpha,
+    [32970]: dstAlpha
   }),
   clearColor: (update, r, g, b, a) => update({
-    [import_constants.GL.COLOR_CLEAR_VALUE]: new Float32Array([r, g, b, a])
+    [3106]: new Float32Array([r, g, b, a])
   }),
   clearDepth: (update, depth) => update({
-    [import_constants.GL.DEPTH_CLEAR_VALUE]: depth
+    [2931]: depth
   }),
   clearStencil: (update, s) => update({
-    [import_constants.GL.STENCIL_CLEAR_VALUE]: s
+    [2961]: s
   }),
   colorMask: (update, r, g, b, a) => update({
-    [import_constants.GL.COLOR_WRITEMASK]: [r, g, b, a]
+    [3107]: [r, g, b, a]
   }),
   cullFace: (update, mode) => update({
-    [import_constants.GL.CULL_FACE_MODE]: mode
+    [2885]: mode
   }),
   depthFunc: (update, func) => update({
-    [import_constants.GL.DEPTH_FUNC]: func
+    [2932]: func
   }),
   depthRange: (update, zNear, zFar) => update({
-    [import_constants.GL.DEPTH_RANGE]: new Float32Array([zNear, zFar])
+    [2928]: new Float32Array([zNear, zFar])
   }),
   depthMask: (update, mask) => update({
-    [import_constants.GL.DEPTH_WRITEMASK]: mask
+    [2930]: mask
   }),
   frontFace: (update, face) => update({
-    [import_constants.GL.FRONT_FACE]: face
+    [2886]: face
   }),
   lineWidth: (update, width) => update({
-    [import_constants.GL.LINE_WIDTH]: width
+    [2849]: width
   }),
   polygonOffset: (update, factor, units) => update({
-    [import_constants.GL.POLYGON_OFFSET_FACTOR]: factor,
-    [import_constants.GL.POLYGON_OFFSET_UNITS]: units
+    [32824]: factor,
+    [10752]: units
   }),
   sampleCoverage: (update, value, invert) => update({
-    [import_constants.GL.SAMPLE_COVERAGE_VALUE]: value,
-    [import_constants.GL.SAMPLE_COVERAGE_INVERT]: invert
+    [32938]: value,
+    [32939]: invert
   }),
   scissor: (update, x, y, width, height) => update({
-    [import_constants.GL.SCISSOR_BOX]: new Int32Array([x, y, width, height])
+    [3088]: new Int32Array([x, y, width, height])
   }),
   stencilMask: (update, mask) => update({
-    [import_constants.GL.STENCIL_WRITEMASK]: mask,
-    [import_constants.GL.STENCIL_BACK_WRITEMASK]: mask
+    [2968]: mask,
+    [36005]: mask
   }),
   stencilMaskSeparate: (update, face, mask) => update({
-    [face === import_constants.GL.FRONT ? import_constants.GL.STENCIL_WRITEMASK : import_constants.GL.STENCIL_BACK_WRITEMASK]: mask
+    [face === 1028 ? 2968 : 36005]: mask
   }),
   stencilFunc: (update, func, ref, mask) => update({
-    [import_constants.GL.STENCIL_FUNC]: func,
-    [import_constants.GL.STENCIL_REF]: ref,
-    [import_constants.GL.STENCIL_VALUE_MASK]: mask,
-    [import_constants.GL.STENCIL_BACK_FUNC]: func,
-    [import_constants.GL.STENCIL_BACK_REF]: ref,
-    [import_constants.GL.STENCIL_BACK_VALUE_MASK]: mask
+    [2962]: func,
+    [2967]: ref,
+    [2963]: mask,
+    [34816]: func,
+    [36003]: ref,
+    [36004]: mask
   }),
   stencilFuncSeparate: (update, face, func, ref, mask) => update({
-    [face === import_constants.GL.FRONT ? import_constants.GL.STENCIL_FUNC : import_constants.GL.STENCIL_BACK_FUNC]: func,
-    [face === import_constants.GL.FRONT ? import_constants.GL.STENCIL_REF : import_constants.GL.STENCIL_BACK_REF]: ref,
-    [face === import_constants.GL.FRONT ? import_constants.GL.STENCIL_VALUE_MASK : import_constants.GL.STENCIL_BACK_VALUE_MASK]: mask
+    [face === 1028 ? 2962 : 34816]: func,
+    [face === 1028 ? 2967 : 36003]: ref,
+    [face === 1028 ? 2963 : 36004]: mask
   }),
   stencilOp: (update, fail, zfail, zpass) => update({
-    [import_constants.GL.STENCIL_FAIL]: fail,
-    [import_constants.GL.STENCIL_PASS_DEPTH_FAIL]: zfail,
-    [import_constants.GL.STENCIL_PASS_DEPTH_PASS]: zpass,
-    [import_constants.GL.STENCIL_BACK_FAIL]: fail,
-    [import_constants.GL.STENCIL_BACK_PASS_DEPTH_FAIL]: zfail,
-    [import_constants.GL.STENCIL_BACK_PASS_DEPTH_PASS]: zpass
+    [2964]: fail,
+    [2965]: zfail,
+    [2966]: zpass,
+    [34817]: fail,
+    [34818]: zfail,
+    [34819]: zpass
   }),
   stencilOpSeparate: (update, face, fail, zfail, zpass) => update({
-    [face === import_constants.GL.FRONT ? import_constants.GL.STENCIL_FAIL : import_constants.GL.STENCIL_BACK_FAIL]: fail,
-    [face === import_constants.GL.FRONT ? import_constants.GL.STENCIL_PASS_DEPTH_FAIL : import_constants.GL.STENCIL_BACK_PASS_DEPTH_FAIL]: zfail,
-    [face === import_constants.GL.FRONT ? import_constants.GL.STENCIL_PASS_DEPTH_PASS : import_constants.GL.STENCIL_BACK_PASS_DEPTH_PASS]: zpass
+    [face === 1028 ? 2964 : 34817]: fail,
+    [face === 1028 ? 2965 : 34818]: zfail,
+    [face === 1028 ? 2966 : 34819]: zpass
   }),
   viewport: (update, x, y, width, height) => update({
-    [import_constants.GL.VIEWPORT]: [x, y, width, height]
+    [2978]: [x, y, width, height]
   })
 };
 var isEnabled = (gl, key) => gl.isEnabled(key);
 var GL_PARAMETER_GETTERS = {
-  [import_constants.GL.BLEND]: isEnabled,
-  [import_constants.GL.CULL_FACE]: isEnabled,
-  [import_constants.GL.DEPTH_TEST]: isEnabled,
-  [import_constants.GL.DITHER]: isEnabled,
-  [import_constants.GL.POLYGON_OFFSET_FILL]: isEnabled,
-  [import_constants.GL.SAMPLE_ALPHA_TO_COVERAGE]: isEnabled,
-  [import_constants.GL.SAMPLE_COVERAGE]: isEnabled,
-  [import_constants.GL.SCISSOR_TEST]: isEnabled,
-  [import_constants.GL.STENCIL_TEST]: isEnabled,
-  [import_constants.GL.RASTERIZER_DISCARD]: isEnabled
+  [3042]: isEnabled,
+  [2884]: isEnabled,
+  [2929]: isEnabled,
+  [3024]: isEnabled,
+  [32823]: isEnabled,
+  [32926]: isEnabled,
+  [32928]: isEnabled,
+  [3089]: isEnabled,
+  [2960]: isEnabled,
+  [35977]: isEnabled
 };
 var NON_CACHE_PARAMETERS = /* @__PURE__ */ new Set([
-  // setter not intercepted
-  import_constants.GL.ACTIVE_TEXTURE,
-  import_constants.GL.TRANSFORM_FEEDBACK_ACTIVE,
-  import_constants.GL.TRANSFORM_FEEDBACK_PAUSED,
-  // setters bindBufferRange/bindBufferBase cannot be pruned based on cache
-  import_constants.GL.TRANSFORM_FEEDBACK_BUFFER_BINDING,
-  import_constants.GL.UNIFORM_BUFFER_BINDING,
-  // states depending on VERTEX_ARRAY_BINDING
-  import_constants.GL.ELEMENT_ARRAY_BUFFER_BINDING,
-  // states depending on READ_FRAMEBUFFER_BINDING
-  import_constants.GL.IMPLEMENTATION_COLOR_READ_FORMAT,
-  import_constants.GL.IMPLEMENTATION_COLOR_READ_TYPE,
-  // states depending on FRAMEBUFFER_BINDING
-  import_constants.GL.READ_BUFFER,
-  import_constants.GL.DRAW_BUFFER0,
-  import_constants.GL.DRAW_BUFFER1,
-  import_constants.GL.DRAW_BUFFER2,
-  import_constants.GL.DRAW_BUFFER3,
-  import_constants.GL.DRAW_BUFFER4,
-  import_constants.GL.DRAW_BUFFER5,
-  import_constants.GL.DRAW_BUFFER6,
-  import_constants.GL.DRAW_BUFFER7,
-  import_constants.GL.DRAW_BUFFER8,
-  import_constants.GL.DRAW_BUFFER9,
-  import_constants.GL.DRAW_BUFFER10,
-  import_constants.GL.DRAW_BUFFER11,
-  import_constants.GL.DRAW_BUFFER12,
-  import_constants.GL.DRAW_BUFFER13,
-  import_constants.GL.DRAW_BUFFER14,
-  import_constants.GL.DRAW_BUFFER15,
-  // states depending on ACTIVE_TEXTURE
-  import_constants.GL.SAMPLER_BINDING,
-  import_constants.GL.TEXTURE_BINDING_2D,
-  import_constants.GL.TEXTURE_BINDING_2D_ARRAY,
-  import_constants.GL.TEXTURE_BINDING_3D,
-  import_constants.GL.TEXTURE_BINDING_CUBE_MAP
+  34016,
+  36388,
+  36387,
+  35983,
+  35368,
+  34965,
+  35739,
+  35738,
+  3074,
+  34853,
+  34854,
+  34855,
+  34856,
+  34857,
+  34858,
+  34859,
+  34860,
+  34861,
+  34862,
+  34863,
+  34864,
+  34865,
+  34866,
+  34867,
+  34868,
+  35097,
+  32873,
+  35869,
+  32874,
+  34068
 ]);
 
 // dist/context/parameters/unified-parameter-api.js
-function setGLParameters(device, parameters) {
-  const webglDevice = WebGLDevice.attach(device);
-  const gl = webglDevice.gl;
+function setGLParameters(gl, parameters) {
   if (isObjectEmpty(parameters)) {
     return;
   }
@@ -567,9 +559,7 @@ function setGLParameters(device, parameters) {
     }
   }
 }
-function getGLParameters(device, parameters = GL_PARAMETER_DEFAULTS) {
-  const webglDevice = WebGLDevice.attach(device);
-  const gl = webglDevice.gl;
+function getGLParameters(gl, parameters = GL_PARAMETER_DEFAULTS) {
   if (typeof parameters === "number") {
     const key = parameters;
     const getter = GL_PARAMETER_GETTERS[key];
@@ -583,8 +573,8 @@ function getGLParameters(device, parameters = GL_PARAMETER_DEFAULTS) {
   }
   return state;
 }
-function resetGLParameters(device) {
-  setGLParameters(device, GL_PARAMETER_DEFAULTS);
+function resetGLParameters(gl) {
+  setGLParameters(gl, GL_PARAMETER_DEFAULTS);
 }
 function isObjectEmpty(object) {
   for (const key in object) {
@@ -796,15 +786,15 @@ function getWebGLExtension(gl, name, extensions) {
 
 // dist/adapter/device-helpers/webgl-device-info.js
 function getDeviceInfo(gl, extensions) {
-  const vendorMasked = gl.getParameter(import_constants2.GL.VENDOR);
-  const rendererMasked = gl.getParameter(import_constants2.GL.RENDERER);
+  const vendorMasked = gl.getParameter(7936);
+  const rendererMasked = gl.getParameter(7937);
   getWebGLExtension(gl, "WEBGL_debug_renderer_info", extensions);
   const ext = extensions.WEBGL_debug_renderer_info;
-  const vendorUnmasked = gl.getParameter(ext ? ext.UNMASKED_VENDOR_WEBGL : import_constants2.GL.VENDOR);
-  const rendererUnmasked = gl.getParameter(ext ? ext.UNMASKED_RENDERER_WEBGL : import_constants2.GL.RENDERER);
+  const vendorUnmasked = gl.getParameter(ext ? ext.UNMASKED_VENDOR_WEBGL : 7936);
+  const rendererUnmasked = gl.getParameter(ext ? ext.UNMASKED_RENDERER_WEBGL : 7937);
   const vendor = vendorUnmasked || vendorMasked;
   const renderer = rendererUnmasked || rendererMasked;
-  const version = gl.getParameter(import_constants2.GL.VERSION);
+  const version = gl.getParameter(7938);
   const gpu = identifyGPUVendor(vendor, renderer);
   const gpuBackend = identifyGPUBackend(vendor, renderer);
   const gpuType = identifyGPUType(vendor, renderer);
@@ -878,29 +868,29 @@ var import_constants3 = require("@luma.gl/constants");
 function getGLFromVertexType(dataType) {
   switch (dataType) {
     case "uint8":
-      return import_constants3.GL.UNSIGNED_BYTE;
+      return 5121;
     case "sint8":
-      return import_constants3.GL.BYTE;
+      return 5120;
     case "unorm8":
-      return import_constants3.GL.UNSIGNED_BYTE;
+      return 5121;
     case "snorm8":
-      return import_constants3.GL.BYTE;
+      return 5120;
     case "uint16":
-      return import_constants3.GL.UNSIGNED_SHORT;
+      return 5123;
     case "sint16":
-      return import_constants3.GL.SHORT;
+      return 5122;
     case "unorm16":
-      return import_constants3.GL.UNSIGNED_SHORT;
+      return 5123;
     case "snorm16":
-      return import_constants3.GL.SHORT;
+      return 5122;
     case "uint32":
-      return import_constants3.GL.UNSIGNED_INT;
+      return 5125;
     case "sint32":
-      return import_constants3.GL.INT;
+      return 5124;
     case "float16":
-      return import_constants3.GL.HALF_FLOAT;
+      return 5131;
     case "float32":
-      return import_constants3.GL.FLOAT;
+      return 5126;
   }
   throw new Error(String(dataType));
 }
@@ -962,210 +952,259 @@ function checkTextureFeature(gl, feature, extensions) {
   return textureExtensions.every((extension) => getWebGLExtension(gl, extension, extensions));
 }
 var TEXTURE_FORMATS = {
-  // Unsized formats that leave the precision up to the driver.
-  // TODO - Fix bpp constants
-  // 'r8unorm-unsized': {gl: GL.LUMINANCE, b: 4, c: 2, bpp: 4},
+  // Unsized formats that leave the precision up to the driver. TODO - Fix bpp constants
   "rgb8unorm-unsized": {
-    gl: import_constants4.GL.RGB,
+    gl: 6407,
     b: 4,
     c: 2,
     bpp: 4,
-    dataFormat: import_constants4.GL.RGB,
-    types: [import_constants4.GL.UNSIGNED_BYTE, import_constants4.GL.UNSIGNED_SHORT_5_6_5]
+    dataFormat: 6407,
+    types: [5121, 33635]
   },
   "rgba8unorm-unsized": {
-    gl: import_constants4.GL.RGBA,
+    gl: 6408,
     b: 4,
     c: 2,
     bpp: 4,
-    dataFormat: import_constants4.GL.RGBA,
-    types: [import_constants4.GL.UNSIGNED_BYTE, import_constants4.GL.UNSIGNED_SHORT_4_4_4_4, import_constants4.GL.UNSIGNED_SHORT_5_5_5_1]
+    dataFormat: 6408,
+    types: [5121, 32819, 32820]
   },
+  // 'r8unorm-unsized': {gl: GL.LUMINANCE, b: 4, c: 2, bpp: 4},
   // '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_constants4.GL.R8, b: 1, c: 1, renderbuffer: true },
-  "r8snorm": { gl: import_constants4.GL.R8_SNORM, b: 1, c: 1, render: snorm8_renderable },
-  "r8uint": { gl: import_constants4.GL.R8UI, b: 1, c: 1, renderbuffer: true },
-  "r8sint": { gl: import_constants4.GL.R8I, b: 1, c: 1, renderbuffer: true },
+  "r8unorm": { gl: 33321, b: 1, c: 1, rb: true },
+  "r8snorm": { gl: 36756, b: 1, c: 1, render: snorm8_renderable },
+  "r8uint": { gl: 33330, b: 1, c: 1, rb: true },
+  "r8sint": { gl: 33329, b: 1, c: 1, rb: true },
   // 16-bit formats
-  "rg8unorm": { gl: import_constants4.GL.RG8, b: 2, c: 2, renderbuffer: true },
-  "rg8snorm": { gl: import_constants4.GL.RG8_SNORM, b: 2, c: 2, render: snorm8_renderable },
-  "rg8uint": { gl: import_constants4.GL.RG8UI, b: 2, c: 2, renderbuffer: true },
-  "rg8sint": { gl: import_constants4.GL.RG8I, b: 2, c: 2, renderbuffer: true },
-  "r16uint": { gl: import_constants4.GL.R16UI, b: 2, c: 1, renderbuffer: true },
-  "r16sint": { gl: import_constants4.GL.R16I, b: 2, c: 1, renderbuffer: true },
-  "r16float": { gl: import_constants4.GL.R16F, b: 2, c: 1, render: float16_renderable, filter: "float16-filterable-webgl", renderbuffer: true },
-  "r16unorm-webgl": { gl: import_constants4.GL.R16_EXT, b: 2, c: 1, f: norm16_renderable, renderbuffer: true },
-  "r16snorm-webgl": { gl: import_constants4.GL.R16_SNORM_EXT, b: 2, c: 1, f: snorm16_renderable },
+  "rg8unorm": { gl: 33323, b: 2, c: 2, rb: true },
+  "rg8snorm": { gl: 36757, b: 2, c: 2, render: snorm8_renderable },
+  "rg8uint": { gl: 33336, b: 2, c: 2, rb: true },
+  "rg8sint": { gl: 33335, b: 2, c: 2, rb: true },
+  "r16uint": { gl: 33332, b: 2, c: 1, rb: true },
+  "r16sint": { gl: 33331, b: 2, c: 1, rb: true },
+  "r16float": { gl: 33325, b: 2, c: 1, render: float16_renderable, filter: "float16-filterable-webgl", rb: true },
+  "r16unorm-webgl": { gl: 33322, b: 2, c: 1, f: norm16_renderable, rb: true },
+  "r16snorm-webgl": { gl: 36760, b: 2, c: 1, f: snorm16_renderable },
   // Packed 16-bit formats
-  "rgba4unorm-webgl": { gl: import_constants4.GL.RGBA4, b: 2, c: 4, wgpu: false, renderbuffer: true },
-  "rgb565unorm-webgl": { gl: import_constants4.GL.RGB565, b: 2, c: 4, wgpu: false, renderbuffer: true },
-  "rgb5a1unorm-webgl": { gl: import_constants4.GL.RGB5_A1, b: 2, c: 4, wgpu: false, renderbuffer: true },
+  "rgba4unorm-webgl": { gl: 32854, b: 2, c: 4, wgpu: false, rb: true },
+  "rgb565unorm-webgl": { gl: 36194, b: 2, c: 4, wgpu: false, rb: true },
+  "rgb5a1unorm-webgl": { gl: 32855, b: 2, c: 4, wgpu: false, rb: true },
   // 24-bit formats
-  "rgb8unorm-webgl": { gl: import_constants4.GL.RGB8, b: 3, c: 3, wgpu: false },
-  "rgb8snorm-webgl": { gl: import_constants4.GL.RGB8_SNORM, b: 3, c: 3, wgpu: false },
+  "rgb8unorm-webgl": { gl: 32849, b: 3, c: 3, wgpu: false },
+  "rgb8snorm-webgl": { gl: 36758, b: 3, c: 3, wgpu: false },
   // 32-bit formats  
-  "rgba8unorm": { gl: import_constants4.GL.RGBA8, b: 4, c: 2, bpp: 4 },
-  "rgba8unorm-srgb": { gl: import_constants4.GL.SRGB8_ALPHA8, b: 4, c: 4, bpp: 4 },
-  "rgba8snorm": { gl: import_constants4.GL.RGBA8_SNORM, b: 4, c: 4, render: snorm8_renderable },
-  "rgba8uint": { gl: import_constants4.GL.RGBA8UI, b: 4, c: 4, bpp: 4 },
-  "rgba8sint": { gl: import_constants4.GL.RGBA8I, b: 4, c: 4, bpp: 4 },
+  "rgba8unorm": { gl: 32856, b: 4, c: 2, bpp: 4 },
+  "rgba8unorm-srgb": { gl: 35907, b: 4, c: 4, bpp: 4 },
+  "rgba8snorm": { gl: 36759, b: 4, c: 4, render: snorm8_renderable },
+  "rgba8uint": { gl: 36220, b: 4, c: 4, bpp: 4 },
+  "rgba8sint": { gl: 36238, b: 4, c: 4, bpp: 4 },
   // reverse colors, webgpu only
   "bgra8unorm": { b: 4, c: 4 },
   "bgra8unorm-srgb": { b: 4, c: 4 },
-  "rg16uint": { gl: import_constants4.GL.RG16UI, b: 4, c: 1, bpp: 4 },
-  "rg16sint": { gl: import_constants4.GL.RG16I, b: 4, c: 2, bpp: 4 },
+  "rg16uint": { gl: 33338, b: 4, c: 1, bpp: 4 },
+  "rg16sint": { gl: 33337, b: 4, c: 2, bpp: 4 },
   // When using a WebGL 2 context and the EXT_color_buffer_float WebGL2 extension
-  "rg16float": { gl: import_constants4.GL.RG16F, bpp: 4, b: 4, c: 2, render: float16_renderable, filter: float16_filterable, renderbuffer: true },
-  "rg16unorm-webgl": { gl: import_constants4.GL.RG16_EXT, b: 2, c: 2, render: norm16_renderable },
-  "rg16snorm-webgl": { gl: import_constants4.GL.RG16_SNORM_EXT, b: 2, c: 2, render: snorm16_renderable },
-  "r32uint": { gl: import_constants4.GL.R32UI, b: 4, c: 1, bpp: 4, renderbuffer: true },
-  "r32sint": { gl: import_constants4.GL.R32I, b: 4, c: 1, bpp: 4, renderbuffer: true },
-  "r32float": { gl: import_constants4.GL.R32F, bpp: 4, b: 4, c: 1, render: float32_renderable, filter: float32_filterable },
+  "rg16float": { gl: 33327, bpp: 4, b: 4, c: 2, render: float16_renderable, filter: float16_filterable, rb: true },
+  "rg16unorm-webgl": { gl: 33324, b: 2, c: 2, render: norm16_renderable },
+  "rg16snorm-webgl": { gl: 36761, b: 2, c: 2, render: snorm16_renderable },
+  "r32uint": { gl: 33334, b: 4, c: 1, bpp: 4, rb: true },
+  "r32sint": { gl: 33333, b: 4, c: 1, bpp: 4, rb: true },
+  "r32float": { gl: 33326, bpp: 4, b: 4, c: 1, render: float32_renderable, filter: float32_filterable },
   // Packed 32-bit formats
-  "rgb9e5ufloat": { gl: import_constants4.GL.RGB9_E5, b: 4, c: 3, p: 1, render: rgb9e5ufloat_renderable },
+  "rgb9e5ufloat": { gl: 35901, b: 4, c: 3, p: 1, render: rgb9e5ufloat_renderable },
   // , filter: true},
-  "rg11b10ufloat": { gl: import_constants4.GL.R11F_G11F_B10F, b: 4, c: 3, p: 1, render: float32_renderable, renderbuffer: true },
-  "rgb10a2unorm": { gl: import_constants4.GL.RGB10_A2, b: 4, c: 4, p: 1, renderbuffer: true },
-  "rgb10a2uint-webgl": { b: 4, c: 4, gl: import_constants4.GL.RGB10_A2UI, p: 1, wgpu: false, bpp: 4, renderbuffer: true },
+  "rg11b10ufloat": { gl: 35898, b: 4, c: 3, p: 1, render: float32_renderable, rb: true },
+  "rgb10a2unorm": { gl: 32857, b: 4, c: 4, p: 1, rb: true },
+  "rgb10a2uint-webgl": { b: 4, c: 4, gl: 36975, p: 1, wgpu: false, bpp: 4, rb: true },
   // 48-bit formats
-  "rgb16unorm-webgl": { gl: import_constants4.GL.RGB16_EXT, b: 2, c: 3, f: norm16_renderable },
+  "rgb16unorm-webgl": { gl: 32852, b: 2, c: 3, f: norm16_renderable },
   // rgb not renderable
-  "rgb16snorm-webgl": { gl: import_constants4.GL.RGB16_SNORM_EXT, b: 2, c: 3, f: norm16_renderable },
+  "rgb16snorm-webgl": { gl: 36762, b: 2, c: 3, f: norm16_renderable },
   // rgb not renderable
   // 64-bit formats
-  "rg32uint": { gl: import_constants4.GL.RG32UI, b: 8, c: 2, renderbuffer: true },
-  "rg32sint": { gl: import_constants4.GL.RG32I, b: 8, c: 2, renderbuffer: true },
-  "rg32float": { gl: import_constants4.GL.RG32F, b: 8, c: 2, render: float32_renderable, filter: float32_filterable, renderbuffer: true },
-  "rgba16uint": { gl: import_constants4.GL.RGBA16UI, b: 8, c: 4, renderbuffer: true },
-  "rgba16sint": { gl: import_constants4.GL.RGBA16I, b: 8, c: 4, renderbuffer: true },
-  "rgba16float": { gl: import_constants4.GL.RGBA16F, b: 8, c: 4, render: float16_renderable, filter: float16_filterable },
-  "rgba16unorm-webgl": { gl: import_constants4.GL.RGBA16_EXT, b: 2, c: 4, render: norm16_renderable, renderbuffer: true },
-  "rgba16snorm-webgl": { gl: import_constants4.GL.RGBA16_SNORM_EXT, b: 2, c: 4, render: snorm16_renderable },
+  "rg32uint": { gl: 33340, b: 8, c: 2, rb: true },
+  "rg32sint": { gl: 33339, b: 8, c: 2, rb: true },
+  "rg32float": { gl: 33328, b: 8, c: 2, render: float32_renderable, filter: float32_filterable, rb: true },
+  "rgba16uint": { gl: 36214, b: 8, c: 4, rb: true },
+  "rgba16sint": { gl: 36232, b: 8, c: 4, rb: true },
+  "rgba16float": { gl: 34842, b: 8, c: 4, render: float16_renderable, filter: float16_filterable },
+  "rgba16unorm-webgl": { gl: 32859, b: 2, c: 4, render: norm16_renderable, rb: true },
+  "rgba16snorm-webgl": { gl: 36763, b: 2, c: 4, render: snorm16_renderable },
   // 96-bit formats (deprecated!)
   "rgb32float-webgl": {
-    gl: import_constants4.GL.RGB32F,
+    gl: 34837,
     render: float32_renderable,
     filter: float32_filterable,
     gl2ext: EXT_color_buffer_float,
-    dataFormat: import_constants4.GL.RGB,
-    types: [import_constants4.GL.FLOAT]
+    dataFormat: 6407,
+    types: [5126]
   },
   // 128-bit formats
-  "rgba32uint": { gl: import_constants4.GL.RGBA32UI, b: 16, c: 4, renderbuffer: true },
-  "rgba32sint": { gl: import_constants4.GL.RGBA32I, b: 16, c: 4, renderbuffer: true },
-  "rgba32float": { gl: import_constants4.GL.RGBA32F, b: 16, c: 4, render: float32_renderable, filter: float32_filterable, renderbuffer: true },
+  "rgba32uint": { gl: 36208, b: 16, c: 4, rb: true },
+  "rgba32sint": { gl: 36226, b: 16, c: 4, rb: true },
+  "rgba32float": { gl: 34836, b: 16, c: 4, render: float32_renderable, filter: float32_filterable, rb: true },
   // Depth and stencil formats
-  "stencil8": { gl: import_constants4.GL.STENCIL_INDEX8, b: 1, c: 1, attachment: import_constants4.GL.STENCIL_ATTACHMENT, renderbuffer: true },
+  "stencil8": { gl: 36168, b: 1, c: 1, attachment: 36128, rb: true },
   // 8 stencil bits
-  "depth16unorm": { gl: import_constants4.GL.DEPTH_COMPONENT16, b: 2, c: 1, attachment: import_constants4.GL.DEPTH_ATTACHMENT, renderbuffer: true },
+  "depth16unorm": {
+    gl: 33189,
+    b: 2,
+    c: 1,
+    attachment: 36096,
+    dataFormat: 6402,
+    types: [5123],
+    rb: true
+  },
   // 16 depth bits
-  "depth24plus": { gl: import_constants4.GL.DEPTH_COMPONENT24, b: 3, c: 1, attachment: import_constants4.GL.DEPTH_ATTACHMENT },
-  "depth32float": { gl: import_constants4.GL.DEPTH_COMPONENT32F, b: 4, c: 1, attachment: import_constants4.GL.DEPTH_ATTACHMENT, renderbuffer: true },
+  "depth24plus": {
+    gl: 33190,
+    b: 3,
+    c: 1,
+    attachment: 36096,
+    dataFormat: 6402,
+    types: [5125]
+  },
+  "depth32float": {
+    gl: 36012,
+    b: 4,
+    c: 1,
+    attachment: 36096,
+    dataFormat: 6402,
+    types: [5126],
+    rb: 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_constants4.GL.DEPTH_STENCIL, b: 4, c: 2, p: 1, attachment: import_constants4.GL.DEPTH_STENCIL_ATTACHMENT, renderbuffer: true, depthTexture: true },
+  "depth24plus-stencil8": {
+    gl: 35056,
+    b: 4,
+    c: 2,
+    p: 1,
+    attachment: 33306,
+    rb: true,
+    depthTexture: true,
+    dataFormat: 34041,
+    types: [34042]
+  },
   // "depth24unorm-stencil8" feature
-  "depth24unorm-stencil8": { gl: import_constants4.GL.DEPTH24_STENCIL8, b: 4, c: 2, p: 1, attachment: import_constants4.GL.DEPTH_STENCIL_ATTACHMENT, renderbuffer: true },
-  // "depth32float-stencil8" feature
-  "depth32float-stencil8": { gl: import_constants4.GL.DEPTH32F_STENCIL8, b: 5, c: 2, p: 1, attachment: import_constants4.GL.DEPTH_STENCIL_ATTACHMENT, renderbuffer: true },
+  "depth24unorm-stencil8": {
+    gl: 35056,
+    b: 4,
+    c: 2,
+    p: 1,
+    attachment: 33306,
+    dataFormat: 34041,
+    types: [34042],
+    rb: true
+  },
+  // "depth32float-stencil8" feature - TODO below is render buffer only?
+  "depth32float-stencil8": {
+    gl: 36013,
+    b: 5,
+    c: 2,
+    p: 1,
+    attachment: 33306,
+    dataFormat: 34041,
+    types: [36269],
+    rb: true
+  },
   // BC compressed formats: check device.features.has("texture-compression-bc");
-  "bc1-rgb-unorm-webgl": { gl: import_constants4.GL.COMPRESSED_RGB_S3TC_DXT1_EXT, x: X_S3TC, f: texture_compression_bc },
-  "bc1-rgb-unorm-srgb-webgl": { gl: import_constants4.GL.COMPRESSED_SRGB_S3TC_DXT1_EXT, x: X_S3TC_SRGB, f: texture_compression_bc },
-  "bc1-rgba-unorm": { gl: import_constants4.GL.COMPRESSED_RGBA_S3TC_DXT1_EXT, x: X_S3TC, f: texture_compression_bc },
-  "bc1-rgba-unorm-srgb": { gl: import_constants4.GL.COMPRESSED_SRGB_S3TC_DXT1_EXT, x: X_S3TC_SRGB, f: texture_compression_bc },
-  "bc2-rgba-unorm": { gl: import_constants4.GL.COMPRESSED_RGBA_S3TC_DXT3_EXT, x: X_S3TC, f: texture_compression_bc },
-  "bc2-rgba-unorm-srgb": { gl: import_constants4.GL.COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT, x: X_S3TC_SRGB, f: texture_compression_bc },
-  "bc3-rgba-unorm": { gl: import_constants4.GL.COMPRESSED_RGBA_S3TC_DXT5_EXT, x: X_S3TC, f: texture_compression_bc },
-  "bc3-rgba-unorm-srgb": { gl: import_constants4.GL.COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT, x: X_S3TC_SRGB, f: texture_compression_bc },
-  "bc4-r-unorm": { gl: import_constants4.GL.COMPRESSED_RED_RGTC1_EXT, x: X_RGTC, f: texture_compression_bc },
-  "bc4-r-snorm": { gl: import_constants4.GL.COMPRESSED_SIGNED_RED_RGTC1_EXT, x: X_RGTC, f: texture_compression_bc },
-  "bc5-rg-unorm": { gl: import_constants4.GL.COMPRESSED_RED_GREEN_RGTC2_EXT, x: X_RGTC, f: texture_compression_bc },
-  "bc5-rg-snorm": { gl: import_constants4.GL.COMPRESSED_SIGNED_RED_GREEN_RGTC2_EXT, x: X_RGTC, f: texture_compression_bc },
-  "bc6h-rgb-ufloat": { gl: import_constants4.GL.COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT_EXT, x: X_BPTC, f: texture_compression_bc },
-  "bc6h-rgb-float": { gl: import_constants4.GL.COMPRESSED_RGB_BPTC_SIGNED_FLOAT_EXT, x: X_BPTC, f: texture_compression_bc },
-  "bc7-rgba-unorm": { gl: import_constants4.GL.COMPRESSED_RGBA_BPTC_UNORM_EXT, x: X_BPTC, f: texture_compression_bc },
-  "bc7-rgba-unorm-srgb": { gl: import_constants4.GL.COMPRESSED_SRGB_ALPHA_BPTC_UNORM_EXT, x: X_BPTC, f: texture_compression_bc },
+  "bc1-rgb-unorm-webgl": { gl: 33776, x: X_S3TC, f: texture_compression_bc },
+  "bc1-rgb-unorm-srgb-webgl": { gl: 35916, x: X_S3TC_SRGB, f: texture_compression_bc },
+  "bc1-rgba-unorm": { gl: 33777, x: X_S3TC, f: texture_compression_bc },
+  "bc1-rgba-unorm-srgb": { gl: 35916, x: X_S3TC_SRGB, f: texture_compression_bc },
+  "bc2-rgba-unorm": { gl: 33778, x: X_S3TC, f: texture_compression_bc },
+  "bc2-rgba-unorm-srgb": { gl: 35918, x: X_S3TC_SRGB, f: texture_compression_bc },
+  "bc3-rgba-unorm": { gl: 33779, x: X_S3TC, f: texture_compression_bc },
+  "bc3-rgba-unorm-srgb": { gl: 35919, x: X_S3TC_SRGB, f: texture_compression_bc },
+  "bc4-r-unorm": { gl: 36283, x: X_RGTC, f: texture_compression_bc },
+  "bc4-r-snorm": { gl: 36284, x: X_RGTC, f: texture_compression_bc },
+  "bc5-rg-unorm": { gl: 36285, x: X_RGTC, f: texture_compression_bc },
+  "bc5-rg-snorm": { gl: 36286, x: X_RGTC, f: texture_compression_bc },
+  "bc6h-rgb-ufloat": { gl: 36495, x: X_BPTC, f: texture_compression_bc },
+  "bc6h-rgb-float": { gl: 36494, x: X_BPTC, f: texture_compression_bc },
+  "bc7-rgba-unorm": { gl: 36492, x: X_BPTC, f: texture_compression_bc },
+  "bc7-rgba-unorm-srgb": { gl: 36493, 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_constants4.GL.COMPRESSED_RGB8_ETC2, f: texture_compression_etc2 },
-  "etc2-rgb8unorm-srgb": { gl: import_constants4.GL.COMPRESSED_SRGB8_ETC2, f: texture_compression_etc2 },
-  "etc2-rgb8a1unorm": { gl: import_constants4.GL.COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2, f: texture_compression_etc2 },
-  "etc2-rgb8a1unorm-srgb": { gl: import_constants4.GL.COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2, f: texture_compression_etc2 },
-  "etc2-rgba8unorm": { gl: import_constants4.GL.COMPRESSED_RGBA8_ETC2_EAC, f: texture_compression_etc2 },
-  "etc2-rgba8unorm-srgb": { gl: import_constants4.GL.COMPRESSED_SRGB8_ALPHA8_ETC2_EAC, f: texture_compression_etc2 },
-  "eac-r11unorm": { gl: import_constants4.GL.COMPRESSED_R11_EAC, f: texture_compression_etc2 },
-  "eac-r11snorm": { gl: import_constants4.GL.COMPRESSED_SIGNED_R11_EAC, f: texture_compression_etc2 },
-  "eac-rg11unorm": { gl: import_constants4.GL.COMPRESSED_RG11_EAC, f: texture_compression_etc2 },
-  "eac-rg11snorm": { gl: import_constants4.GL.COMPRESSED_SIGNED_RG11_EAC, f: texture_compression_etc2 },
+  "etc2-rgb8unorm": { gl: 37492, f: texture_compression_etc2 },
+  "etc2-rgb8unorm-srgb": { gl: 37494, f: texture_compression_etc2 },
+  "etc2-rgb8a1unorm": { gl: 37496, f: texture_compression_etc2 },
+  "etc2-rgb8a1unorm-srgb": { gl: 37497, f: texture_compression_etc2 },
+  "etc2-rgba8unorm": { gl: 37493, f: texture_compression_etc2 },
+  "etc2-rgba8unorm-srgb": { gl: 37495, f: texture_compression_etc2 },
+  "eac-r11unorm": { gl: 37488, f: texture_compression_etc2 },
+  "eac-r11snorm": { gl: 37489, f: texture_compression_etc2 },
+  "eac-rg11unorm": { gl: 37490, f: texture_compression_etc2 },
+  "eac-rg11snorm": { gl: 37491, f: texture_compression_etc2 },
   // X_ASTC compressed formats: device.features.has("texture-compression-astc")
-  "astc-4x4-unorm": { gl: import_constants4.GL.COMPRESSED_RGBA_ASTC_4x4_KHR, f: texture_compression_astc },
-  "astc-4x4-unorm-srgb": { gl: import_constants4.GL.COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR, f: texture_compression_astc },
-  "astc-5x4-unorm": { gl: import_constants4.GL.COMPRESSED_RGBA_ASTC_5x4_KHR, f: texture_compression_astc },
-  "astc-5x4-unorm-srgb": { gl: import_constants4.GL.COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR, f: texture_compression_astc },
-  "astc-5x5-unorm": { gl: import_constants4.GL.COMPRESSED_RGBA_ASTC_5x5_KHR, f: texture_compression_astc },
-  "astc-5x5-unorm-srgb": { gl: import_constants4.GL.COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR, f: texture_compression_astc },
-  "astc-6x5-unorm": { gl: import_constants4.GL.COMPRESSED_RGBA_ASTC_6x5_KHR, f: texture_compression_astc },
-  "astc-6x5-unorm-srgb": { gl: import_constants4.GL.COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR, f: texture_compression_astc },
-  "astc-6x6-unorm": { gl: import_constants4.GL.COMPRESSED_RGBA_ASTC_6x6_KHR, f: texture_compression_astc },
-  "astc-6x6-unorm-srgb": { gl: import_constants4.GL.COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR, f: texture_compression_astc },
-  "astc-8x5-unorm": { gl: import_constants4.GL.COMPRESSED_RGBA_ASTC_8x5_KHR, f: texture_compression_astc },
-  "astc-8x5-unorm-srgb": { gl: import_constants4.GL.COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR, f: texture_compression_astc },
-  "astc-8x6-unorm": { gl: import_constants4.GL.COMPRESSED_RGBA_ASTC_8x6_KHR, f: texture_compression_astc },
-  "astc-8x6-unorm-srgb": { gl: import_constants4.GL.COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR, f: texture_compression_astc },
-  "astc-8x8-unorm": { gl: import_constants4.GL.COMPRESSED_RGBA_ASTC_8x8_KHR, f: texture_compression_astc },
-  "astc-8x8-unorm-srgb": { gl: import_constants4.GL.COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR, f: texture_compression_astc },
-  "astc-10x5-unorm": { gl: import_constants4.GL.COMPRESSED_RGBA_ASTC_10x10_KHR, f: texture_compression_astc },
-  "astc-10x5-unorm-srgb": { gl: import_constants4.GL.COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR, f: texture_compression_astc },
-  "astc-10x6-unorm": { gl: import_constants4.GL.COMPRESSED_RGBA_ASTC_10x6_KHR, f: texture_compression_astc },
-  "astc-10x6-unorm-srgb": { gl: import_constants4.GL.COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR, f: texture_compression_astc },
-  "astc-10x8-unorm": { gl: import_constants4.GL.COMPRESSED_RGBA_ASTC_10x8_KHR, f: texture_compression_astc },
-  "astc-10x8-unorm-srgb": { gl: import_constants4.GL.COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR, f: texture_compression_astc },
-  "astc-10x10-unorm": { gl: import_constants4.GL.COMPRESSED_RGBA_ASTC_10x10_KHR, f: texture_compression_astc },
-  "astc-10x10-unorm-srgb": { gl: import_constants4.GL.COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR, f: texture_compression_astc },
-  "astc-12x10-unorm": { gl: import_constants4.GL.COMPRESSED_RGBA_ASTC_12x10_KHR, f: texture_compression_astc },
-  "astc-12x10-unorm-srgb": { gl: import_constants4.GL.COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR, f: texture_compression_astc },
-  "astc-12x12-unorm": { gl: import_constants4.GL.COMPRESSED_RGBA_ASTC_12x12_KHR, f: texture_compression_astc },
-  "astc-12x12-unorm-srgb": { gl: import_constants4.GL.COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR, f: texture_compression_astc },
+  "astc-4x4-unorm": { gl: 37808, f: texture_compression_astc },
+  "astc-4x4-unorm-srgb": { gl: 37840, f: texture_compression_astc },
+  "astc-5x4-unorm": { gl: 37809, f: texture_compression_astc },
+  "astc-5x4-unorm-srgb": { gl: 37841, f: texture_compression_astc },
+  "astc-5x5-unorm": { gl: 37810, f: texture_compression_astc },
+  "astc-5x5-unorm-srgb": { gl: 37842, f: texture_compression_astc },
+  "astc-6x5-unorm": { gl: 37811, f: texture_compression_astc },
+  "astc-6x5-unorm-srgb": { gl: 37843, f: texture_compression_astc },
+  "astc-6x6-unorm": { gl: 37812, f: texture_compression_astc },
+  "astc-6x6-unorm-srgb": { gl: 37844, f: texture_compression_astc },
+  "astc-8x5-unorm": { gl: 37813, f: texture_compression_astc },
+  "astc-8x5-unorm-srgb": { gl: 37845, f: texture_compression_astc },
+  "astc-8x6-unorm": { gl: 37814, f: texture_compression_astc },
+  "astc-8x6-unorm-srgb": { gl: 37846, f: texture_compression_astc },
+  "astc-8x8-unorm": { gl: 37815, f: texture_compression_astc },
+  "astc-8x8-unorm-srgb": { gl: 37847, f: texture_compression_astc },
+  "astc-10x5-unorm": { gl: 37819, f: texture_compression_astc },
+  "astc-10x5-unorm-srgb": { gl: 37851, f: texture_compression_astc },
+  "astc-10x6-unorm": { gl: 37817, f: texture_compression_astc },
+  "astc-10x6-unorm-srgb": { gl: 37849, f: texture_compression_astc },
+  "astc-10x8-unorm": { gl: 37818, f: texture_compression_astc },
+  "astc-10x8-unorm-srgb": { gl: 37850, f: texture_compression_astc },
+  "astc-10x10-unorm": { gl: 37819, f: texture_compression_astc },
+  "astc-10x10-unorm-srgb": { gl: 37851, f: texture_compression_astc },
+  "astc-12x10-unorm": { gl: 37820, f: texture_compression_astc },
+  "astc-12x10-unorm-srgb": { gl: 37852, f: texture_compression_astc },
+  "astc-12x12-unorm": { gl: 37821, f: texture_compression_astc },
+  "astc-12x12-unorm-srgb": { gl: 37853, f: texture_compression_astc },
   // WEBGL_compressed_texture_pvrtc
-  "pvrtc-rgb4unorm-webgl": { gl: import_constants4.GL.COMPRESSED_RGB_PVRTC_4BPPV1_IMG, f: texture_compression_pvrtc_webgl },
-  "pvrtc-rgba4unorm-webgl": { gl: import_constants4.GL.COMPRESSED_RGBA_PVRTC_4BPPV1_IMG, f: texture_compression_pvrtc_webgl },
-  "pvrtc-rbg2unorm-webgl": { gl: import_constants4.GL.COMPRESSED_RGB_PVRTC_2BPPV1_IMG, f: texture_compression_pvrtc_webgl },
-  "pvrtc-rgba2unorm-webgl": { gl: import_constants4.GL.COMPRESSED_RGBA_PVRTC_2BPPV1_IMG, f: texture_compression_pvrtc_webgl },
+  "pvrtc-rgb4unorm-webgl": { gl: 35840, f: texture_compression_pvrtc_webgl },
+  "pvrtc-rgba4unorm-webgl": { gl: 35842, f: texture_compression_pvrtc_webgl },
+  "pvrtc-rbg2unorm-webgl": { gl: 35841, f: texture_compression_pvrtc_webgl },
+  "pvrtc-rgba2unorm-webgl": { gl: 35843, f: texture_compression_pvrtc_webgl },
   // WEBGL_compressed_texture_etc1
-  "etc1-rbg-unorm-webgl": { gl: import_constants4.GL.COMPRESSED_RGB_ETC1_WEBGL, f: texture_compression_etc1_webgl },
+  "etc1-rbg-unorm-webgl": { gl: 36196, f: texture_compression_etc1_webgl },
   // WEBGL_compressed_texture_atc
-  "atc-rgb-unorm-webgl": { gl: import_constants4.GL.COMPRESSED_RGB_ATC_WEBGL, f: texture_compression_atc_webgl },
-  "atc-rgba-unorm-webgl": { gl: import_constants4.GL.COMPRESSED_RGBA_ATC_EXPLICIT_ALPHA_WEBGL, f: texture_compression_atc_webgl },
-  "atc-rgbai-unorm-webgl": { gl: import_constants4.GL.COMPRESSED_RGBA_ATC_INTERPOLATED_ALPHA_WEBGL, f: texture_compression_atc_webgl }
+  "atc-rgb-unorm-webgl": { gl: 35986, f: texture_compression_atc_webgl },
+  "atc-rgba-unorm-webgl": { gl: 35986, f: texture_compression_atc_webgl },
+  "atc-rgbai-unorm-webgl": { gl: 34798, f: texture_compression_atc_webgl }
 };
 var DATA_FORMAT_CHANNELS = {
-  [import_constants4.GL.RED]: 1,
-  [import_constants4.GL.RED_INTEGER]: 1,
-  [import_constants4.GL.RG]: 2,
-  [import_constants4.GL.RG_INTEGER]: 2,
-  [import_constants4.GL.RGB]: 3,
-  [import_constants4.GL.RGB_INTEGER]: 3,
-  [import_constants4.GL.RGBA]: 4,
-  [import_constants4.GL.RGBA_INTEGER]: 4,
-  [import_constants4.GL.DEPTH_COMPONENT]: 1,
-  [import_constants4.GL.DEPTH_STENCIL]: 1,
-  [import_constants4.GL.ALPHA]: 1,
-  [import_constants4.GL.LUMINANCE]: 1,
-  [import_constants4.GL.LUMINANCE_ALPHA]: 2
+  [6403]: 1,
+  [36244]: 1,
+  [33319]: 2,
+  [33320]: 2,
+  [6407]: 3,
+  [36248]: 3,
+  [6408]: 4,
+  [36249]: 4,
+  [6402]: 1,
+  [34041]: 1,
+  [6406]: 1,
+  [6409]: 1,
+  [6410]: 2
 };
 var TYPE_SIZES = {
-  [import_constants4.GL.FLOAT]: 4,
-  [import_constants4.GL.UNSIGNED_INT]: 4,
-  [import_constants4.GL.INT]: 4,
-  [import_constants4.GL.UNSIGNED_SHORT]: 2,
-  [import_constants4.GL.SHORT]: 2,
-  [import_constants4.GL.HALF_FLOAT]: 2,
-  [import_constants4.GL.BYTE]: 1,
-  [import_constants4.GL.UNSIGNED_BYTE]: 1
+  [5126]: 4,
+  [5125]: 4,
+  [5124]: 4,
+  [5123]: 2,
+  [5122]: 2,
+  [5131]: 2,
+  [5120]: 1,
+  [5121]: 1
 };
-function isTextureFormatSupported(gl, formatOrGL, extensions) {
-  const format = convertGLToTextureFormat(formatOrGL);
+function isTextureFormatSupported(gl, format, extensions) {
   const info = TEXTURE_FORMATS[format];
   if (!info) {
     return false;
@@ -1181,7 +1220,7 @@ function isTextureFormatSupported(gl, formatOrGL, extensions) {
 }
 function isRenderbufferFormatSupported(gl, format, extensions) {
   var _a;
-  return isTextureFormatSupported(gl, format, extensions) && ((_a = TEXTURE_FORMATS[format]) == null ? void 0 : _a.renderbuffer);
+  return isTextureFormatSupported(gl, format, extensions) && ((_a = TEXTURE_FORMATS[format]) == null ? void 0 : _a.rb);
 }
 function convertGLToTextureFormat(format) {
   if (typeof format === "string") {
@@ -1201,11 +1240,13 @@ function convertTextureFormatToGL(format) {
   }
   return webglFormat;
 }
-function isTextureFormatFilterable(gl, formatOrGL, extensions) {
-  const format = convertGLToTextureFormat(formatOrGL);
+function isTextureFormatFilterable(gl, format, extensions) {
   if (!isTextureFormatSupported(gl, format, extensions)) {
     return false;
   }
+  if (format.startsWith("depth") || format.startsWith("stencil")) {
+    return false;
+  }
   try {
     const decoded = (0, import_core2.decodeTextureFormat)(format);
     if (decoded.signed) {
@@ -1222,8 +1263,7 @@ function isTextureFormatFilterable(gl, formatOrGL, extensions) {
   }
   return true;
 }
-function isTextureFormatRenderable(gl, formatOrGL, extensions) {
-  const format = convertGLToTextureFormat(formatOrGL);
+function isTextureFormatRenderable(gl, format, extensions) {
   if (!isTextureFormatSupported(gl, format, extensions)) {
     return false;
   }
@@ -1232,15 +1272,16 @@ function isTextureFormatRenderable(gl, formatOrGL, extensions) {
   }
   return true;
 }
-function getWebGLTextureParameters(formatOrGL) {
-  const format = convertGLToTextureFormat(formatOrGL);
+function getWebGLTextureParameters(format) {
+  var _a;
+  const formatData = TEXTURE_FORMATS[format];
   const webglFormat = convertTextureFormatToGL(format);
   const decoded = (0, import_core2.decodeTextureFormat)(format);
   return {
     format: webglFormat,
-    dataFormat: getWebGLPixelDataFormat(decoded.format, decoded.integer, decoded.normalized, webglFormat),
+    dataFormat: (formatData == null ? void 0 : formatData.dataFormat) || getWebGLPixelDataFormat(decoded.format, decoded.integer, decoded.normalized, webglFormat),
     // depth formats don't have a type
-    type: decoded.dataType ? getGLFromVertexType(decoded.dataType) : import_constants4.GL.UNSIGNED_BYTE,
+    type: decoded.dataType ? getGLFromVertexType(decoded.dataType) : ((_a = formatData == null ? void 0 : formatData.types) == null ? void 0 : _a[0]) || 5121,
     // @ts-expect-error
     compressed: decoded.compressed
   };
@@ -1252,28 +1293,27 @@ function getDepthStencilAttachmentWebGL(format) {
   }
   return info.attachment;
 }
-function getTextureFormatBytesPerPixel(formatOrGL) {
-  const format = convertGLToTextureFormat(formatOrGL);
+function getTextureFormatBytesPerPixel(format) {
   const params = getWebGLTextureParameters(format);
   const channels = DATA_FORMAT_CHANNELS[params.dataFormat] || 4;
   const channelSize = TYPE_SIZES[params.type] || 1;
   return channels * channelSize;
 }
 function getWebGLPixelDataFormat(dataFormat, integer, normalized, format) {
-  if (format === import_constants4.GL.RGBA || format === import_constants4.GL.RGB) {
+  if (format === 6408 || format === 6407) {
     return format;
   }
   switch (dataFormat) {
     case "r":
-      return integer && !normalized ? import_constants4.GL.RED_INTEGER : import_constants4.GL.RED;
+      return integer && !normalized ? 36244 : 6403;
     case "rg":
-      return integer && !normalized ? import_constants4.GL.RG_INTEGER : import_constants4.GL.RG;
+      return integer && !normalized ? 33320 : 33319;
     case "rgb":
-      return integer && !normalized ? import_constants4.GL.RGB_INTEGER : import_constants4.GL.RGB;
+      return integer && !normalized ? 36248 : 6407;
     case "rgba":
-      return integer && !normalized ? import_constants4.GL.RGBA_INTEGER : import_constants4.GL.RGBA;
+      return integer && !normalized ? 36249 : 6408;
     default:
-      return import_constants4.GL.RGBA;
+      return 6408;
   }
 }
 
@@ -1301,8 +1341,8 @@ var WebGLDeviceFeatures = class extends import_core3.DeviceFeatures {
   gl;
   extensions;
   testedFeatures = /* @__PURE__ */ new Set();
-  constructor(gl, extensions) {
-    super();
+  constructor(gl, extensions, disabledFeatures) {
+    super([], disabledFeatures);
     this.gl = gl;
     this.extensions = extensions;
     getWebGLExtension(gl, "EXT_color_buffer_float", extensions);
@@ -1321,6 +1361,9 @@ var WebGLDeviceFeatures = class extends import_core3.DeviceFeatures {
     return [];
   }
   has(feature) {
+    if (this.disabledFeatures[feature]) {
+      return false;
+    }
     if (!this.testedFeatures.has(feature)) {
       this.testedFeatures.add(feature);
       if (isTextureFeature(feature) && checkTextureFeature(this.gl, feature, this.extensions)) {
@@ -1332,6 +1375,12 @@ var WebGLDeviceFeatures = class extends import_core3.DeviceFeatures {
     }
     return this.features.has(feature);
   }
+  // FOR DEVICE
+  initializeFeatures() {
+    for (const feature of this) {
+    }
+  }
+  // IMPLEMENTATION
   /** Extract all WebGL features */
   getWebGLFeature(feature) {
     const featureInfo = WEBGL_FEATURES[feature];
@@ -1349,13 +1398,13 @@ var WebGLDeviceLimits = class extends import_core4.DeviceLimits {
   }
   // WebGL does not support 1D textures
   get maxTextureDimension2D() {
-    return this.getParameter(import_constants5.GL.MAX_TEXTURE_SIZE);
+    return this.getParameter(3379);
   }
   get maxTextureDimension3D() {
-    return this.getParameter(import_constants5.GL.MAX_3D_TEXTURE_SIZE);
+    return this.getParameter(32883);
   }
   get maxTextureArrayLayers() {
-    return this.getParameter(import_constants5.GL.MAX_ARRAY_TEXTURE_LAYERS);
+    return this.getParameter(35071);
   }
   get maxBindGroups() {
     return 0;
@@ -1369,11 +1418,11 @@ var WebGLDeviceLimits = class extends import_core4.DeviceLimits {
   }
   // TBD
   get maxSampledTexturesPerShaderStage() {
-    return this.getParameter(import_constants5.GL.MAX_VERTEX_TEXTURE_IMAGE_UNITS);
+    return this.getParameter(35660);
   }
   // ) TBD
   get maxSamplersPerShaderStage() {
-    return this.getParameter(import_constants5.GL.MAX_COMBINED_TEXTURE_IMAGE_UNITS);
+    return this.getParameter(35661);
   }
   get maxStorageBuffersPerShaderStage() {
     return 0;
@@ -1384,16 +1433,16 @@ var WebGLDeviceLimits = class extends import_core4.DeviceLimits {
   }
   // TBD
   get maxUniformBuffersPerShaderStage() {
-    return this.getParameter(import_constants5.GL.MAX_UNIFORM_BUFFER_BINDINGS);
+    return this.getParameter(35375);
   }
   get maxUniformBufferBindingSize() {
-    return this.getParameter(import_constants5.GL.MAX_UNIFORM_BLOCK_SIZE);
+    return this.getParameter(35376);
   }
   get maxStorageBufferBindingSize() {
     return 0;
   }
   get minUniformBufferOffsetAlignment() {
-    return this.getParameter(import_constants5.GL.UNIFORM_BUFFER_OFFSET_ALIGNMENT);
+    return this.getParameter(35380);
   }
   get minStorageBufferOffsetAlignment() {
     return 0;
@@ -1403,14 +1452,14 @@ var WebGLDeviceLimits = class extends import_core4.DeviceLimits {
   }
   // WebGL 2 supports 16 buffers, see https://github.com/gpuweb/gpuweb/issues/4284
   get maxVertexAttributes() {
-    return this.getParameter(import_constants5.GL.MAX_VERTEX_ATTRIBS);
+    return this.getParameter(34921);
   }
   get maxVertexBufferArrayStride() {
     return 2048;
   }
   // TBD, this is just the default value from WebGPU
   get maxInterStageShaderComponents() {
-    return this.getParameter(import_constants5.GL.MAX_VARYING_COMPONENTS);
+    return this.getParameter(35659);
   }
   get maxComputeWorkgroupStorageSize() {
     return 0;
@@ -1452,22 +1501,20 @@ var WebGLDeviceLimits = class extends import_core4.DeviceLimits {
 };
 
 // dist/adapter/webgl-canvas-context.js
-var import_core13 = require("@luma.gl/core");
+var import_core11 = require("@luma.gl/core");
 
 // dist/adapter/resources/webgl-framebuffer.js
-var import_core12 = require("@luma.gl/core");
-var import_constants12 = require("@luma.gl/constants");
+var import_core10 = require("@luma.gl/core");
+var import_constants11 = require("@luma.gl/constants");
 
 // dist/adapter/resources/webgl-texture.js
 var import_core9 = require("@luma.gl/core");
 var import_constants10 = require("@luma.gl/constants");
 
 // dist/context/state-tracker/with-parameters.js
-function withGLParameters(device, parameters, func) {
-  const webglDevice = WebGLDevice.attach(device);
-  const gl = webglDevice.gl;
+function withGLParameters(gl, parameters, func) {
   if (isObjectEmpty2(parameters)) {
-    return func(device);
+    return func(gl);
   }
   const { nocatch = true } = parameters;
   pushContextState(gl);
@@ -1502,13 +1549,14 @@ function withDeviceAndGLParameters(device, parameters, glParameters, func) {
   if ((0, import_core5.isObjectEmpty)(parameters)) {
     return func(device);
   }
-  pushContextState(device.gl);
+  const webglDevice = device;
+  pushContextState(webglDevice.gl);
   try {
     setDeviceParameters(device, parameters);
-    setGLParameters(device, glParameters);
+    setGLParameters(webglDevice.gl, glParameters);
     return func(device);
   } finally {
-    popContextState(device.gl);
+    popContextState(webglDevice.gl);
   }
 }
 function withDeviceParameters(device, parameters, func) {
@@ -1524,32 +1572,32 @@ function withDeviceParameters(device, parameters, func) {
   }
 }
 function setDeviceParameters(device, parameters) {
-  const webglDevice = WebGLDevice.attach(device);
+  const webglDevice = device;
   const { gl } = webglDevice;
   if (parameters.cullMode) {
     switch (parameters.cullMode) {
       case "none":
-        gl.disable(import_constants6.GL.CULL_FACE);
+        gl.disable(2884);
         break;
       case "front":
-        gl.enable(import_constants6.GL.CULL_FACE);
-        gl.cullFace(import_constants6.GL.FRONT);
+        gl.enable(2884);
+        gl.cullFace(1028);
         break;
       case "back":
-        gl.enable(import_constants6.GL.CULL_FACE);
-        gl.cullFace(import_constants6.GL.BACK);
+        gl.enable(2884);
+        gl.cullFace(1029);
         break;
     }
   }
   if (parameters.frontFace) {
     gl.frontFace(map("frontFace", parameters.frontFace, {
-      ccw: import_constants6.GL.CCW,
-      cw: import_constants6.GL.CW
+      ccw: 2305,
+      cw: 2304
     }));
   }
   if (parameters.unclippedDepth) {
     if (device.features.has("depth-clip-control")) {
-      gl.enable(import_constants6.GL.DEPTH_CLAMP_EXT);
+      gl.enable(34383);
     }
   }
   if (parameters.depthBias !== void 0) {
@@ -1560,8 +1608,8 @@ function setDeviceParameters(device, parameters) {
     const ext = extensions.WEBGL_provoking_vertex;
     if (parameters.provokingVertex) {
       const vertex = map("provokingVertex", parameters.provokingVertex, {
-        first: import_constants6.GL.FIRST_VERTEX_CONVENTION_WEBGL,
-        last: import_constants6.GL.LAST_VERTEX_CONVENTION_WEBGL
+        first: 36429,
+        last: 36430
       });
       ext == null ? void 0 : ext.provokingVertexWEBGL(vertex);
     }
@@ -1571,53 +1619,53 @@ function setDeviceParameters(device, parameters) {
     const ext = extensions.WEBGL_polygon_mode;
     if (parameters.polygonMode) {
       const mode = map("polygonMode", parameters.provokingVertex, {
-        fill: import_constants6.GL.FILL_WEBGL,
-        lint: import_constants6.GL.LINE_WEBGL
+        fill: 6914,
+        lint: 6913
       });
-      ext == null ? void 0 : ext.polygonModeWEBGL(import_constants6.GL.FRONT, mode);
-      ext == null ? void 0 : ext.polygonModeWEBGL(import_constants6.GL.BACK, mode);
+      ext == null ? void 0 : ext.polygonModeWEBGL(1028, mode);
+      ext == null ? void 0 : ext.polygonModeWEBGL(1029, mode);
     }
     if (parameters.polygonOffsetLine) {
-      gl.enable(import_constants6.GL.POLYGON_OFFSET_LINE_WEBGL);
+      gl.enable(10754);
     }
   }
   if (device.features.has("shader-clip-cull-distance-webgl")) {
     if (parameters.clipDistance0) {
-      gl.enable(import_constants6.GL.CLIP_DISTANCE0_WEBGL);
+      gl.enable(12288);
     }
     if (parameters.clipDistance1) {
-      gl.enable(import_constants6.GL.CLIP_DISTANCE1_WEBGL);
+      gl.enable(12289);
     }
     if (parameters.clipDistance2) {
-      gl.enable(import_constants6.GL.CLIP_DISTANCE2_WEBGL);
+      gl.enable(12290);
     }
     if (parameters.clipDistance3) {
-      gl.enable(import_constants6.GL.CLIP_DISTANCE3_WEBGL);
+      gl.enable(12291);
     }
     if (parameters.clipDistance4) {
-      gl.enable(import_constants6.GL.CLIP_DISTANCE4_WEBGL);
+      gl.enable(12292);
     }
     if (parameters.clipDistance5) {
-      gl.enable(import_constants6.GL.CLIP_DISTANCE5_WEBGL);
+      gl.enable(12293);
     }
     if (parameters.clipDistance6) {
-      gl.enable(import_constants6.GL.CLIP_DISTANCE6_WEBGL);
+      gl.enable(12294);
     }
     if (parameters.clipDistance7) {
-      gl.enable(import_constants6.GL.CLIP_DISTANCE7_WEBGL);
+      gl.enable(12295);
     }
   }
   if (parameters.depthWriteEnabled !== void 0) {
     gl.depthMask(mapBoolean("depthWriteEnabled", parameters.depthWriteEnabled));
   }
   if (parameters.depthCompare) {
-    parameters.depthCompare !== "always" ? gl.enable(import_constants6.GL.DEPTH_TEST) : gl.disable(import_constants6.GL.DEPTH_TEST);
+    parameters.depthCompare !== "always" ? gl.enable(2929) : gl.disable(2929);
     gl.depthFunc(convertCompareFunction("depthCompare", parameters.depthCompare));
   }
   if (parameters.stencilWriteMask) {
     const mask = parameters.stencilWriteMask;
-    gl.stencilMaskSeparate(import_constants6.GL.FRONT, mask);
-    gl.stencilMaskSeparate(import_constants6.GL.BACK, mask);
+    gl.stencilMaskSeparate(1028, mask);
+    gl.stencilMaskSeparate(1029, mask);
   }
   if (parameters.stencilReadMask) {
     import_core5.log.warn("stencilReadMask not supported under WebGL");
@@ -1625,19 +1673,19 @@ function setDeviceParameters(device, parameters) {
   if (parameters.stencilCompare) {
     const mask = parameters.stencilReadMask || 4294967295;
     const glValue = convertCompareFunction("depthCompare", parameters.stencilCompare);
-    parameters.stencilCompare !== "always" ? gl.enable(import_constants6.GL.STENCIL_TEST) : gl.disable(import_constants6.GL.STENCIL_TEST);
-    gl.stencilFuncSeparate(import_constants6.GL.FRONT, glValue, 0, mask);
-    gl.stencilFuncSeparate(import_constants6.GL.BACK, glValue, 0, mask);
+    parameters.stencilCompare !== "always" ? gl.enable(2960) : gl.disable(2960);
+    gl.stencilFuncSeparate(1028, glValue, 0, mask);
+    gl.stencilFuncSeparate(1029, glValue, 0, mask);
   }
   if (parameters.stencilPassOperation && parameters.stencilFailOperation && parameters.stencilDepthFailOperation) {
     const dppass = convertStencilOperation("stencilPassOperation", parameters.stencilPassOperation);
     const sfail = convertStencilOperation("stencilFailOperation", parameters.stencilFailOperation);
     const dpfail = convertStencilOperation("stencilDepthFailOperation", parameters.stencilDepthFailOperation);
-    gl.stencilOpSeparate(import_constants6.GL.FRONT, sfail, dpfail, dppass);
-    gl.stencilOpSeparate(import_constants6.GL.BACK, sfail, dpfail, dppass);
+    gl.stencilOpSeparate(1028, sfail, dpfail, dppass);
+    gl.stencilOpSeparate(1029, sfail, dpfail, dppass);
   }
   if (parameters.blendColorOperation || parameters.blendAlphaOperation) {
-    gl.enable(import_constants6.GL.BLEND);
+    gl.enable(3042);
     const colorEquation = convertBlendOperationToEquation("blendColorOperation", parameters.blendColorOperation || "add");
     const alphaEquation = convertBlendOperationToEquation("blendAlphaOperation", parameters.blendAlphaOperation || "add");
     gl.blendEquationSeparate(colorEquation, alphaEquation);
@@ -1650,49 +1698,49 @@ function setDeviceParameters(device, parameters) {
 }
 function convertCompareFunction(parameter, value) {
   return map(parameter, value, {
-    never: import_constants6.GL.NEVER,
-    less: import_constants6.GL.LESS,
-    equal: import_constants6.GL.EQUAL,
-    "less-equal": import_constants6.GL.LEQUAL,
-    greater: import_constants6.GL.GREATER,
-    "not-equal": import_constants6.GL.NOTEQUAL,
-    "greater-equal": import_constants6.GL.GEQUAL,
-    always: import_constants6.GL.ALWAYS
+    never: 512,
+    less: 513,
+    equal: 514,
+    "less-equal": 515,
+    greater: 516,
+    "not-equal": 517,
+    "greater-equal": 518,
+    always: 519
   });
 }
 function convertStencilOperation(parameter, value) {
   return map(parameter, value, {
-    keep: import_constants6.GL.KEEP,
-    zero: import_constants6.GL.ZERO,
-    replace: import_constants6.GL.REPLACE,
-    invert: import_constants6.GL.INVERT,
-    "increment-clamp": import_constants6.GL.INCR,
-    "decrement-clamp": import_constants6.GL.DECR,
-    "increment-wrap": import_constants6.GL.INCR_WRAP,
-    "decrement-wrap": import_constants6.GL.DECR_WRAP
+    keep: 7680,
+    zero: 0,
+    replace: 7681,
+    invert: 5386,
+    "increment-clamp": 7682,
+    "decrement-clamp": 7683,
+    "increment-wrap": 34055,
+    "decrement-wrap": 34056
   });
 }
 function convertBlendOperationToEquation(parameter, value) {
   return map(parameter, value, {
-    add: import_constants6.GL.FUNC_ADD,
-    subtract: import_constants6.GL.FUNC_SUBTRACT,
-    "reverse-subtract": import_constants6.GL.FUNC_REVERSE_SUBTRACT,
-    min: import_constants6.GL.MIN,
-    max: import_constants6.GL.MAX
+    add: 32774,
+    subtract: 32778,
+    "reverse-subtract": 32779,
+    min: 32775,
+    max: 32776
   });
 }
 function convertBlendFactorToFunction(parameter, value) {
   return map(parameter, value, {
-    one: import_constants6.GL.ONE,
-    zero: import_constants6.GL.ZERO,
-    "src-color": import_constants6.GL.SRC_COLOR,
-    "one-minus-src-color": import_constants6.GL.ONE_MINUS_SRC_COLOR,
-    "dst-color": import_constants6.GL.DST_COLOR,
-    "one-minus-dst-color": import_constants6.GL.ONE_MINUS_DST_COLOR,
-    "src-alpha": import_constants6.GL.SRC_ALPHA,
-    "one-minus-src-alpha": import_constants6.GL.ONE_MINUS_SRC_ALPHA,
-    "dst-alpha": import_constants6.GL.DST_ALPHA,
-    "one-minus-dst-alpha": import_constants6.GL.ONE_MINUS_DST_ALPHA
+    one: 1,
+    zero: 0,
+    "src-color": 768,
+    "one-minus-src-color": 769,
+    "dst-color": 774,
+    "one-minus-dst-color": 775,
+    "src-alpha": 770,
+    "one-minus-src-alpha": 771,
+    "dst-alpha": 772,
+    "one-minus-dst-alpha": 773
   });
 }
 function message(parameter, value) {
@@ -1712,53 +1760,53 @@ function mapBoolean(parameter, value) {
 function convertSamplerParametersToWebGL(props) {
   const params = {};
   if (props.addressModeU) {
-    params[import_constants7.GL.TEXTURE_WRAP_S] = convertAddressMode(props.addressModeU);
+    params[10242] = convertAddressMode(props.addressModeU);
   }
   if (props.addressModeV) {
-    params[import_constants7.GL.TEXTURE_WRAP_T] = convertAddressMode(props.addressModeV);
+    params[10243] = convertAddressMode(props.addressModeV);
   }
   if (props.addressModeW) {
-    params[import_constants7.GL.TEXTURE_WRAP_R] = convertAddressMode(props.addressModeW);
+    params[32882] = convertAddressMode(props.addressModeW);
   }
   if (props.magFilter) {
-    params[import_constants7.GL.TEXTURE_MAG_FILTER] = convertMaxFilterMode(props.magFilter);
+    params[10240] = convertMaxFilterMode(props.magFilter);
   }
   if (props.minFilter || props.mipmapFilter) {
-    params[import_constants7.GL.TEXTURE_MIN_FILTER] = convertMinFilterMode(props.minFilter || "linear", props.mipmapFilter);
+    params[10241] = convertMinFilterMode(props.minFilter || "linear", props.mipmapFilter);
   }
   if (props.lodMinClamp !== void 0) {
-    params[import_constants7.GL.TEXTURE_MIN_LOD] = props.lodMinClamp;
+    params[33082] = props.lodMinClamp;
   }
   if (props.lodMaxClamp !== void 0) {
-    params[import_constants7.GL.TEXTURE_MAX_LOD] = props.lodMaxClamp;
+    params[33083] = props.lodMaxClamp;
   }
   if (props.type === "comparison-sampler") {
-    params[import_constants7.GL.TEXTURE_COMPARE_MODE] = import_constants7.GL.COMPARE_REF_TO_TEXTURE;
+    params[34892] = 34894;
   }
   if (props.compare) {
-    params[import_constants7.GL.TEXTURE_COMPARE_FUNC] = convertCompareFunction("compare", props.compare);
+    params[34893] = convertCompareFunction("compare", props.compare);
   }
   if (props.maxAnisotropy) {
-    params[import_constants7.GL.TEXTURE_MAX_ANISOTROPY_EXT] = props.maxAnisotropy;
+    params[34046] = props.maxAnisotropy;
   }
   return params;
 }
 function convertAddressMode(addressMode) {
   switch (addressMode) {
     case "clamp-to-edge":
-      return import_constants7.GL.CLAMP_TO_EDGE;
+      return 33071;
     case "repeat":
-      return import_constants7.GL.REPEAT;
+      return 10497;
     case "mirror-repeat":
-      return import_constants7.GL.MIRRORED_REPEAT;
+      return 33648;
   }
 }
 function convertMaxFilterMode(maxFilter) {
   switch (maxFilter) {
     case "nearest":
-      return import_constants7.GL.NEAREST;
+      return 9728;
     case "linear":
-      return import_constants7.GL.LINEAR;
+      return 9729;
   }
 }
 function convertMinFilterMode(minFilter, mipmapFilter) {
@@ -1767,9 +1815,9 @@ function convertMinFilterMode(minFilter, mipmapFilter) {
   }
   switch (minFilter) {
     case "nearest":
-      return mipmapFilter === "nearest" ? import_constants7.GL.NEAREST_MIPMAP_NEAREST : import_constants7.GL.NEAREST_MIPMAP_LINEAR;
+      return mipmapFilter === "nearest" ? 9984 : 9986;
     case "linear":
-      return mipmapFilter === "nearest" ? import_constants7.GL.LINEAR_MIPMAP_NEAREST : import_constants7.GL.LINEAR_MIPMAP_LINEAR;
+      return mipmapFilter === "nearest" ? 9985 : 9987;
   }
 }
 
@@ -1785,7 +1833,7 @@ var WEBGLBuffer = class extends import_core6.Buffer {
   /** Usage is a hint on how frequently the buffer will be updates */
   glUsage;
   /** Index type is needed when issuing draw calls, so we pre-compute it */
-  glIndexType = import_constants8.GL.UNSIGNED_SHORT;
+  glIndexType = 5123;
   /** Number of bytes allocated on the GPU for this buffer */
   byteLength;
   /** Number of bytes used */
@@ -1799,7 +1847,7 @@ var WEBGLBuffer = class extends import_core6.Buffer {
     device.setSpectorMetadata(this.handle, { ...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_constants8.GL.UNSIGNED_INT : import_constants8.GL.UNSIGNED_SHORT;
+    this.glIndexType = this.props.indexType === "uint32" ? 5125 : 5123;
     if (props.data) {
       this._initWithData(props.data, props.byteOffset, props.byteLength);
     } else {
@@ -1848,7 +1896,7 @@ var WEBGLBuffer = class extends import_core6.Buffer {
   write(data, byteOffset = 0) {
     const srcOffset = 0;
     const byteLength = void 0;
-    const glTarget = import_constants8.GL.COPY_WRITE_BUFFER;
+    const glTarget = 36663;
     this.gl.bindBuffer(glTarget, this.handle);
     if (srcOffset !== 0 || byteLength !== void 0) {
       this.gl.bufferSubData(glTarget, byteOffset, data, srcOffset, byteLength);
@@ -1867,36 +1915,36 @@ var WEBGLBuffer = class extends import_core6.Buffer {
     byteLength = byteLength ?? this.byteLength - byteOffset;
     const data = new Uint8Array(byteLength);
     const dstOffset = 0;
-    this.gl.bindBuffer(import_constants8.GL.COPY_READ_BUFFER, this.handle);
-    this.gl.getBufferSubData(import_constants8.GL.COPY_READ_BUFFER, byteOffset, data, dstOffset, byteLength);
-    this.gl.bindBuffer(import_constants8.GL.COPY_READ_BUFFER, null);
+    this.gl.bindBuffer(36662, this.handle);
+    this.gl.getBufferSubData(36662, byteOffset, data, dstOffset, byteLength);
+    this.gl.bindBuffer(36662, null);
     this._setDebugData(data, byteOffset, byteLength);
     return data;
   }
 };
 function getWebGLTarget(usage) {
   if (usage & import_core6.Buffer.INDEX) {
-    return import_constants8.GL.ELEMENT_ARRAY_BUFFER;
+    return 34963;
   }
   if (usage & import_core6.Buffer.VERTEX) {
-    return import_constants8.GL.ARRAY_BUFFER;
+    return 34962;
   }
   if (usage & import_core6.Buffer.UNIFORM) {
-    return import_constants8.GL.UNIFORM_BUFFER;
+    return 35345;
   }
-  return import_constants8.GL.ARRAY_BUFFER;
+  return 34962;
 }
 function getWebGLUsage(usage) {
   if (usage & import_core6.Buffer.INDEX) {
-    return import_constants8.GL.STATIC_DRAW;
+    return 35044;
   }
   if (usage & import_core6.Buffer.VERTEX) {
-    return import_constants8.GL.STATIC_DRAW;
+    return 35044;
   }
   if (usage & import_core6.Buffer.UNIFORM) {
-    return import_constants8.GL.DYNAMIC_DRAW;
+    return 35048;
   }
-  return import_constants8.GL.STATIC_DRAW;
+  return 35044;
 }
 
 // dist/adapter/resources/webgl-sampler.js
@@ -1927,8 +1975,8 @@ var WEBGLSampler = class extends import_core7.Sampler {
     for (const [pname, value] of Object.entries(parameters)) {
       const param = Number(pname);
       switch (param) {
-        case import_constants9.GL.TEXTURE_MIN_LOD:
-        case import_constants9.GL.TEXTURE_MAX_LOD:
+        case 33082:
+        case 33083:
           this.device.gl.samplerParameterf(this.handle, param, value);
           break;
         default:
@@ -2004,7 +2052,7 @@ var _WEBGLTexture = class extends import_core9.Texture {
     this.gl = this.device.gl;
     this.handle = this.props.handle || this.gl.createTexture();
     this.device.setSpectorMetadata(this.handle, { ...this.props, data: typeof this.props.data });
-    this.glFormat = import_constants10.GL.RGBA;
+    this.glFormat = 6408;
     this.target = getWebGLTextureTarget(this.props);
     this.loaded = false;
     if (typeof ((_a = this.props) == null ? void 0 : _a.data) === "string") {
@@ -2024,6 +2072,9 @@ var _WEBGLTexture = class extends import_core9.Texture {
   toString() {
     return `Texture(${this.id},${this.width}x${this.height})`;
   }
+  createView(props) {
+    return new WEBGLTextureView(this.device, { ...props, texture: this });
+  }
   // eslint-disable-next-line max-statements
   initialize(props = {}) {
     if (this.props.dimension === "cube") {
@@ -2067,7 +2118,7 @@ var _WEBGLTexture = class extends import_core9.Texture {
     this.dataFormat = dataFormat;
     this.textureUnit = textureUnit;
     if (Number.isFinite(this.textureUnit)) {
-      this.gl.activeTexture(import_constants10.GL.TEXTURE0 + this.textureUnit);
+      this.gl.activeTexture(33984 + this.textureUnit);
       this.gl.bindTexture(this.target, this.handle);
     }
     this.mipmaps = mipmaps;
@@ -2085,8 +2136,8 @@ var _WEBGLTexture = class extends import_core9.Texture {
     });
     this.setSampler(props.sampler);
     this._setSamplerParameters(parameters);
-    this.view = new WEBGLTextureView(this.device, { ...this.props, texture: this });
-    if (mipmaps) {
+    this.view = this.createView({ ...this.props, mipLevelCount: 1, arrayLayerCount: 1 });
+    if (mipmaps && this.device.isTextureFormatFilterable(props.format)) {
       this.generateMipmap();
     }
     if (isVideo) {
@@ -2234,9 +2285,9 @@ var _WEBGLTexture = class extends import_core9.Texture {
           );
           break;
         case "buffer":
-          this.device.gl.bindBuffer(import_constants10.GL.PIXEL_UNPACK_BUFFER, data.handle || data);
+          this.device.gl.bindBuffer(35052, data.handle || data);
           this.device.gl.texImage2D(target, level, glFormat, width, height, 0, dataFormat, type, offset);
-          this.device.gl.bindBuffer(import_constants10.GL.PIXEL_UNPACK_BUFFER, null);
+          this.device.gl.bindBuffer(35052, null);
           break;
         case "browser-object":
           gl.texImage2D(target, level, glFormat, width, height, 0, dataFormat, type, data);
@@ -2296,9 +2347,9 @@ var _WEBGLTexture = class extends import_core9.Texture {
       } else if (ArrayBuffer.isView(data)) {
         this.gl.texSubImage2D(target, level, x, y, width, height, dataFormat, type, data, offset);
       } else if (typeof WebGLBuffer !== "undefined" && data instanceof WebGLBuffer) {
-        this.device.gl.bindBuffer(import_constants10.GL.PIXEL_UNPACK_BUFFER, data);
+        this.device.gl.bindBuffer(35052, data);
         this.device.gl.texSubImage2D(target, level, x, y, width, height, dataFormat, type, offset);
-        this.device.gl.bindBuffer(import_constants10.GL.PIXEL_UNPACK_BUFFER, null);
+        this.device.gl.bindBuffer(35052, null);
       } else {
         this.device.gl.texSubImage2D(target, level, x, y, width, height, dataFormat, type, data);
       }
@@ -2318,13 +2369,13 @@ var _WEBGLTexture = class extends import_core9.Texture {
     return null;
   }
   getActiveUnit() {
-    return this.gl.getParameter(import_constants10.GL.ACTIVE_TEXTURE) - import_constants10.GL.TEXTURE0;
+    return this.gl.getParameter(34016) - 33984;
   }
   bind(textureUnit = this.textureUnit) {
     const { gl } = this;
     if (textureUnit !== void 0) {
       this.textureUnit = textureUnit;
-      gl.activeTexture(gl.TEXTURE0 + textureUnit);
+      gl.activeTexture(33984 + textureUnit);
     }
     gl.bindTexture(this.target, this.handle);
     return textureUnit;
@@ -2333,7 +2384,7 @@ var _WEBGLTexture = class extends import_core9.Texture {
     const { gl } = this;
     if (textureUnit !== void 0) {
       this.textureUnit = textureUnit;
-      gl.activeTexture(gl.TEXTURE0 + textureUnit);
+      gl.activeTexture(33984 + textureUnit);
     }
     gl.bindTexture(this.target, null);
     return textureUnit;
@@ -2395,7 +2446,7 @@ var _WEBGLTexture = class extends import_core9.Texture {
   /* eslint-disable max-statements, max-len */
   async setCubeMapImageData(options) {
     const { gl } = this;
-    const { width, height, pixels, data, format = import_constants10.GL.RGBA, type = import_constants10.GL.UNSIGNED_BYTE } = options;
+    const { width, height, pixels, data, format = 6408, type = 5121 } = options;
     const imageDataMap = pixels || data;
     const resolvedFaces = await Promise.all(_WEBGLTexture.FACES.map((face) => {
       const facePixels = imageDataMap[face];
@@ -2424,8 +2475,8 @@ var _WEBGLTexture = class extends import_core9.Texture {
       height,
       pixels,
       data,
-      format = import_constants10.GL.RGBA,
-      type = import_constants10.GL.UNSIGNED_BYTE
+      format = 6408,
+      type = 5121
       // generateMipmap = false // TODO
     } = options;
     const { gl } = this;
@@ -2479,7 +2530,7 @@ var _WEBGLTexture = class extends import_core9.Texture {
         );
       }
       if (data instanceof WEBGLBuffer) {
-        this.gl.bindBuffer(import_constants10.GL.PIXEL_UNPACK_BUFFER, data.handle);
+        this.gl.bindBuffer(35052, data.handle);
         this.gl.texImage3D(this.target, level, dataFormat, width, height, depth, 0, format, type, offset);
       }
     });
@@ -2506,8 +2557,8 @@ var _WEBGLTexture = class extends import_core9.Texture {
       const param = Number(pname);
       const value = pvalue;
       switch (param) {
-        case import_constants10.GL.TEXTURE_MIN_LOD:
-        case import_constants10.GL.TEXTURE_MAX_LOD:
+        case 33082:
+        case 33083:
           this.gl.texParameterf(this.target, param, value);
           break;
         default:
@@ -2522,23 +2573,23 @@ var _WEBGLTexture = class extends import_core9.Texture {
 var WEBGLTexture = _WEBGLTexture;
 // TODO - remove?
 __publicField(WEBGLTexture, "FACES", [
-  import_constants10.GL.TEXTURE_CUBE_MAP_POSITIVE_X,
-  import_constants10.GL.TEXTURE_CUBE_MAP_NEGATIVE_X,
-  import_constants10.GL.TEXTURE_CUBE_MAP_POSITIVE_Y,
-  import_constants10.GL.TEXTURE_CUBE_MAP_NEGATIVE_Y,
-  import_constants10.GL.TEXTURE_CUBE_MAP_POSITIVE_Z,
-  import_constants10.GL.TEXTURE_CUBE_MAP_NEGATIVE_Z
+  34069,
+  34070,
+  34071,
+  34072,
+  34073,
+  34074
 ]);
 function getWebGLTextureTarget(props) {
   switch (props.dimension) {
     case "2d":
-      return import_constants10.GL.TEXTURE_2D;
+      return 3553;
     case "cube":
-      return import_constants10.GL.TEXTURE_CUBE_MAP;
+      return 34067;
     case "2d-array":
-      return import_constants10.GL.TEXTURE_2D_ARRAY;
+      return 35866;
     case "3d":
-      return import_constants10.GL.TEXTURE_3D;
+      return 32879;
     case "1d":
     case "cube-array":
     default:
@@ -2549,180 +2600,8 @@ function logParameters(parameters) {
   import_core9.log.log(1, "texture sampler parameters", parameters)();
 }
 
-// dist/adapter/objects/webgl-renderbuffer.js
-var import_core11 = require("@luma.gl/core");
-var import_constants11 = require("@luma.gl/constants");
-
-// dist/adapter/objects/webgl-resource.js
-var import_core10 = require("@luma.gl/core");
-var ERR_RESOURCE_METHOD_UNDEFINED = "Resource subclass must define virtual methods";
-var WebGLResource = class extends import_core10.Resource {
-  device;
-  gl;
-  gl2;
-  _handle;
-  _bound = false;
-  // Only meaningful for resources that allocate GPU memory
-  byteLength = 0;
-  constructor(device, props, defaultProps) {
-    super(device, props, defaultProps);
-    this.device = WebGLDevice.attach(device);
-    const gl = this.device.gl;
-    const { id } = props || {};
-    this.gl = gl;
-    this.gl2 = gl;
-    this.id = id || (0, import_core10.uid)(this.constructor.name);
-    this._handle = props == null ? void 0 : props.handle;
-    if (this._handle === void 0) {
-      this._handle = this._createHandle();
-    }
-    this.byteLength = 0;
-  }
-  toString() {
-    return `${this.constructor.name}(${this.id})`;
-  }
-  get handle() {
-    return this._handle;
-  }
-  delete({ deleteChildren = false } = {}) {
-    const children = this._handle && this._deleteHandle(this._handle);
-    if (this._handle) {
-      this.removeStats();
-    }
-    this._handle = null;
-    if (children && deleteChildren) {
-      children.filter(Boolean).forEach((child) => child.destroy());
-    }
-    return this;
-  }
-  bind(funcOrHandle = this.handle) {
-    if (typeof funcOrHandle !== "function") {
-      this._bindHandle(funcOrHandle);
-      return this;
-    }
-    let value;
-    if (!this._bound) {
-      this._bindHandle(this.handle);
-      this._bound = true;
-      value = funcOrHandle();
-      this._bound = false;
-      this._bindHandle(null);
-    } else {
-      value = funcOrHandle();
-    }
-    return value;
-  }
-  unbind() {
-    this.bind(null);
-  }
-  // Install stubs for removed methods
-  stubRemovedMethods(className, version, methodNames) {
-    return (0, import_core10.stubRemovedMethods)(this, className, version, methodNames);
-  }
-  // PUBLIC VIRTUAL METHODS
-  initialize(props) {
-  }
-  // PROTECTED METHODS - These must be overridden by subclass
-  _createHandle() {
-    throw new Error(ERR_RESOURCE_METHOD_UNDEFINED);
-  }
-  _deleteHandle() {
-    throw new Error(ERR_RESOURCE_METHOD_UNDEFINED);
-  }
-  _bindHandle(handle) {
-    throw new Error(ERR_RESOURCE_METHOD_UNDEFINED);
-  }
-  _getOptsFromHandle() {
-    throw new Error(ERR_RESOURCE_METHOD_UNDEFINED);
-  }
-  _getParameter(pname, props) {
-    throw new Error(ERR_RESOURCE_METHOD_UNDEFINED);
-  }
-  _setParameter(pname, value) {
-    throw new Error(ERR_RESOURCE_METHOD_UNDEFINED);
-  }
-};
-
-// dist/adapter/objects/webgl-renderbuffer.js
-var _WEBGLRenderbuffer = class extends WebGLResource {
-  get [Symbol.toStringTag]() {
-    return "Renderbuffer";
-  }
-  get width() {
-    return this.props.width;
-  }
-  get height() {
-    return this.props.height;
-  }
-  get format() {
-    return this.props.format;
-  }
-  get samples() {
-    return this.props.samples;
-  }
-  get attachment() {
-    return;
-  }
-  /** WebGL format constant */
-  glFormat;
-  static isTextureFormatSupported(device, format) {
-    return isRenderbufferFormatSupported(device.gl, format, device._extensions);
-  }
-  constructor(device, props) {
-    if (typeof props.format === "number") {
-      throw new Error("Renderbuffer");
-    }
-    super(device, props, _WEBGLRenderbuffer.defaultProps);
-    this.glFormat = convertTextureFormatToGL(this.props.format);
-    this._initialize(this.props);
-  }
-  resize(size) {
-    if (size.width !== this.width || size.height !== this.height) {
-      Object.assign(this.props, { ...size, format: this.format, samples: this.samples });
-      this._initialize(this.props);
-    }
-  }
-  // PRIVATE METHODS
-  /** Creates and initializes a renderbuffer object's data store */
-  _initialize(props) {
-    const { format, width, height, samples } = props;
-    (0, import_core11.assert)(format, "Needs format");
-    this.trackDeallocatedMemory();
-    this.gl.bindRenderbuffer(import_constants11.GL.RENDERBUFFER, this.handle);
-    if (samples !== 0) {
-      this.gl.renderbufferStorageMultisample(import_constants11.GL.RENDERBUFFER, samples, this.glFormat, width, height);
-    } else {
-      this.gl.renderbufferStorage(import_constants11.GL.RENDERBUFFER, this.glFormat, width, height);
-    }
-    this.gl.bindRenderbuffer(import_constants11.GL.RENDERBUFFER, null);
-    this.trackAllocatedMemory(width * height * (samples || 1) * getTextureFormatBytesPerPixel(this.glFormat));
-  }
-  // RESOURCE IMPLEMENTATION
-  _createHandle() {
-    return this.gl.createRenderbuffer();
-  }
-  _deleteHandle() {
-    this.gl.deleteRenderbuffer(this.handle);
-    this.trackDeallocatedMemory();
-  }
-  _bindHandle(handle) {
-    this.gl.bindRenderbuffer(import_constants11.GL.RENDERBUFFER, handle);
-  }
-};
-var WEBGLRenderbuffer = _WEBGLRenderbuffer;
-__publicField(WEBGLRenderbuffer, "defaultProps", {
-  id: void 0,
-  handle: void 0,
-  userData: void 0,
-  format: void 0,
-  // 'depth16unorm'
-  width: 1,
-  height: 1,
-  samples: 0
-});
-
 // dist/adapter/resources/webgl-framebuffer.js
-var WEBGLFramebuffer = class extends import_core12.Framebuffer {
+var WEBGLFramebuffer = class extends import_core10.Framebuffer {
   device;
   gl;
   handle;
@@ -2738,10 +2617,10 @@ var WEBGLFramebuffer = class extends import_core12.Framebuffer {
     if (!isDefaultFramebuffer) {
       device.setSpectorMetadata(this.handle, { id: this.props.id, props: this.props });
       this.autoCreateAttachmentTextures();
-      this.gl.bindFramebuffer(import_constants12.GL.FRAMEBUFFER, this.handle);
+      this.gl.bindFramebuffer(36160, this.handle);
       for (let i = 0; i < this.colorAttachments.length; ++i) {
         const attachment = this.colorAttachments[i];
-        const attachmentPoint = import_constants12.GL.COLOR_ATTACHMENT0 + i;
+        const attachmentPoint = 36064 + i;
         if (attachment) {
           this._attachOne(attachmentPoint, attachment);
         }
@@ -2750,12 +2629,12 @@ var WEBGLFramebuffer = class extends import_core12.Framebuffer {
         this._attachOne(getDepthStencilAttachmentWebGL(this.depthStencilAttachment.props.format), this.depthStencilAttachment);
       }
       if (props.check !== false) {
-        const status = this.gl.checkFramebufferStatus(import_constants12.GL.FRAMEBUFFER);
-        if (status !== import_constants12.GL.FRAMEBUFFER_COMPLETE) {
+        const status = this.gl.checkFramebufferStatus(36160);
+        if (status !== 36053) {
           throw new Error(`Framebuffer ${_getFrameBufferStatus(status)}`);
         }
       }
-      this.gl.bindFramebuffer(import_constants12.GL.FRAMEBUFFER, null);
+      this.gl.bindFramebuffer(36160, null);
     }
   }
   /** destroys any auto created resources etc. */
@@ -2768,14 +2647,12 @@ var WEBGLFramebuffer = class extends import_core12.Framebuffer {
   // PRIVATE
   /** In WebGL we must use renderbuffers for depth/stencil attachments (unless we have extensions) */
   createDepthStencilTexture(format) {
-    return new WEBGLRenderbuffer(this.device, {
+    return new WEBGLTexture(this.device, {
       id: `${this.id}-depth-stencil`,
-      // TODO misleading if not depth and stencil?
       format,
-      // dataFormat: GL.DEPTH_STENCIL,
-      // type: GL.UNSIGNED_INT_24_8,
       width: this.width,
-      height: this.height
+      height: this.height,
+      mipmaps: false
     });
   }
   /**
@@ -2803,26 +2680,31 @@ var WEBGLFramebuffer = class extends import_core12.Framebuffer {
   }
   /** Attach one attachment */
   _attachOne(attachmentPoint, attachment) {
-    if (attachment instanceof WEBGLRenderbuffer) {
-      this._attachWEBGLRenderbuffer(attachmentPoint, attachment);
-      return attachment;
-    } else if (Array.isArray(attachment)) {
+    if (Array.isArray(attachment)) {
       const [texture, layer = 0, level = 0] = attachment;
       this._attachTexture(attachmentPoint, texture, layer, level);
       return texture;
-    } else if (attachment instanceof WEBGLTexture) {
+    }
+    if (attachment instanceof WEBGLTexture) {
       this._attachTexture(attachmentPoint, attachment, 0, 0);
       return attachment;
-    } else if (attachment instanceof WEBGLTextureView) {
+    }
+    if (attachment instanceof WEBGLTextureView) {
       const textureView = attachment;
       this._attachTexture(attachmentPoint, textureView.texture, textureView.props.baseMipLevel, textureView.props.baseArrayLayer);
       return attachment.texture;
     }
     throw new Error("attach");
   }
-  _attachWEBGLRenderbuffer(attachment, renderbuffer) {
-    this.gl.framebufferRenderbuffer(import_constants12.GL.FRAMEBUFFER, attachment, import_constants12.GL.RENDERBUFFER, renderbuffer.handle);
-  }
+  // TODO - we do not seem to need render buffers in WebGL 2
+  // protected _attachWEBGLRenderbuffer(attachment: GL, renderbuffer: WEBGLRenderbuffer): void {
+  //   this.gl.framebufferRenderbuffer(
+  //     GL.FRAMEBUFFER,
+  //     attachment,
+  //     GL.RENDERBUFFER,
+  //     renderbuffer.handle
+  //   );
+  // }
   /**
    * @param attachment
    * @param texture
@@ -2833,39 +2715,39 @@ var WEBGLFramebuffer = class extends import_core12.Framebuffer {
     const { gl } = this.device;
     gl.bindTexture(texture.target, texture.handle);
     switch (texture.target) {
-      case import_constants12.GL.TEXTURE_2D_ARRAY:
-      case import_constants12.GL.TEXTURE_3D:
-        gl.framebufferTextureLayer(import_constants12.GL.FRAMEBUFFER, attachment, texture.target, level, layer);
+      case 35866:
+      case 32879:
+        gl.framebufferTextureLayer(36160, attachment, texture.target, level, layer);
         break;
-      case import_constants12.GL.TEXTURE_CUBE_MAP:
+      case 34067:
         const face = mapIndexToCubeMapFace(layer);
-        gl.framebufferTexture2D(import_constants12.GL.FRAMEBUFFER, attachment, face, texture.handle, level);
+        gl.framebufferTexture2D(36160, attachment, face, texture.handle, level);
         break;
-      case import_constants12.GL.TEXTURE_2D:
-        gl.framebufferTexture2D(import_constants12.GL.FRAMEBUFFER, attachment, import_constants12.GL.TEXTURE_2D, texture.handle, level);
+      case 3553:
+        gl.framebufferTexture2D(36160, attachment, 3553, texture.handle, level);
         break;
       default:
-        (0, import_core12.assert)(false, "Illegal texture type");
+        (0, import_core10.assert)(false, "Illegal texture type");
     }
     gl.bindTexture(texture.target, null);
   }
 };
 function mapIndexToCubeMapFace(layer) {
-  return layer < import_constants12.GL.TEXTURE_CUBE_MAP_POSITIVE_X ? layer + import_constants12.GL.TEXTURE_CUBE_MAP_POSITIVE_X : layer;
+  return layer < 34069 ? layer + 34069 : layer;
 }
 function _getFrameBufferStatus(status) {
   switch (status) {
-    case import_constants12.GL.FRAMEBUFFER_COMPLETE:
+    case 36053:
       return "success";
-    case import_constants12.GL.FRAMEBUFFER_INCOMPLETE_ATTACHMENT:
+    case 36054:
       return "Mismatched attachments";
-    case import_constants12.GL.FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT:
+    case 36055:
       return "No attachments";
-    case import_constants12.GL.FRAMEBUFFER_INCOMPLETE_DIMENSIONS:
+    case 36057:
       return "Height/width mismatch";
-    case import_constants12.GL.FRAMEBUFFER_UNSUPPORTED:
+    case 36061:
       return "Unsupported or split attachments";
-    case import_constants12.GL.FRAMEBUFFER_INCOMPLETE_MULTISAMPLE:
+    case 36182:
       return "Samples mismatch";
     default:
       return `${status}`;
@@ -2873,7 +2755,7 @@ function _getFrameBufferStatus(status) {
 }
 
 // dist/adapter/webgl-canvas-context.js
-var WebGLCanvasContext = class extends import_core13.CanvasContext {
+var WebGLCanvasContext = class extends import_core11.CanvasContext {
   device;
   presentationSize;
   _framebuffer = null;
@@ -2924,9 +2806,9 @@ var WebGLCanvasContext = class extends import_core13.CanvasContext {
 };
 
 // dist/context/debug/spector.js
-var import_core14 = require("@luma.gl/core");
+var import_core12 = require("@luma.gl/core");
 var DEFAULT_SPECTOR_PROPS = {
-  spector: import_core14.log.get("spector") || import_core14.log.get("inspect")
+  spector: import_core12.log.get("spector") || import_core12.log.get("inspect")
 };
 var SPECTOR_CDN_URL = "https://spectorcdn.babylonjs.com/spector.bundle.js";
 var LOG_LEVEL = 1;
@@ -2935,9 +2817,9 @@ var initialized = false;
 async function loadSpectorJS(props) {
   if (!globalThis.SPECTOR) {
     try {
-      await (0, import_core14.loadScript)(SPECTOR_CDN_URL);
+      await (0, import_core12.loadScript)(SPECTOR_CDN_URL);
     } catch (error) {
-      import_core14.log.warn(String(error));
+      import_core12.log.warn(String(error));
     }
   }
 }
@@ -2947,7 +2829,7 @@ function initializeSpectorJS(props) {
     return null;
   }
   if (!spector && globalThis.SPECTOR) {
-    import_core14.log.probe(LOG_LEVEL, "SPECTOR found and initialized")();
+    import_core12.log.probe(LOG_LEVEL, "SPECTOR found and initialized")();
     spector = new globalThis.SPECTOR.Spector();
     if (globalThis.luma) {
       globalThis.luma.spector = spector;
@@ -2959,9 +2841,9 @@ function initializeSpectorJS(props) {
   if (!initialized) {
     initialized = true;
     spector.spyCanvases();
-    spector == null ? void 0 : spector.onCaptureStarted.add((capture) => import_core14.log.info("Spector capture started:", capture)());
+    spector == null ? void 0 : spector.onCaptureStarted.add((capture) => import_core12.log.info("Spector capture started:", capture)());
     spector == null ? void 0 : spector.onCapture.add((capture) => {
-      import_core14.log.info("Spector capture complete:", capture)();
+      import_core12.log.info("Spector capture complete:", capture)();
       spector == null ? void 0 : spector.getResultUI();
       spector == null ? void 0 : spector.resultView.display();
       spector == null ? void 0 : spector.resultView.addCapture(capture);
@@ -2973,7 +2855,7 @@ function initializeSpectorJS(props) {
     }
     spector == null ? void 0 : spector.startCapture(props == null ? void 0 : props.canvas, 500);
     new Promise((resolve) => setTimeout(resolve, 2e3)).then((_) => {
-      import_core14.log.info("Spector capture stopped after 2 seconds")();
+      import_core12.log.info("Spector capture stopped after 2 seconds")();
       spector == null ? void 0 : spector.stopCapture();
     });
   }
@@ -2981,8 +2863,8 @@ function initializeSpectorJS(props) {
 }
 
 // dist/context/debug/webgl-developer-tools.js
-var import_core15 = require("@luma.gl/core");
-var import_constants13 = require("@luma.gl/constants");
+var import_core13 = require("@luma.gl/core");
+var import_constants12 = 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 getWebGLContextData(gl) {
@@ -2993,7 +2875,7 @@ async function loadWebGLDeveloperTools() {
   if ((0, import_env.isBrowser)() && !globalThis.WebGLDebugUtils) {
     globalThis.global = globalThis.global || globalThis;
     globalThis.global.module = {};
-    await (0, import_core15.loadScript)(WEBGL_DEBUG_CDN_URL);
+    await (0, import_core13.loadScript)(WEBGL_DEBUG_CDN_URL);
   }
 }
 function makeDebugContext(gl, props = {}) {
@@ -3008,18 +2890,18 @@ function getRealContext(gl) {
 }
 function getDebugContext(gl, props) {
   if (!globalThis.WebGLDebugUtils) {
-    import_core15.log.warn("webgl-debug not loaded")();
+    import_core13.log.warn("webgl-debug not loaded")();
     return gl;
   }
   const data = getWebGLContextData(gl);
   if (data.debugContext) {
     return data.debugContext;
   }
-  globalThis.WebGLDebugUtils.init({ ...import_constants13.GL, ...gl });
+  globalThis.WebGLDebugUtils.init({ ...import_constants12.GL, ...gl });
   const glDebug = globalThis.WebGLDebugUtils.makeDebugContext(gl, onGLError.bind(null, props), onValidateGLFunc.bind(null, props));
-  for (const key in import_constants13.GL) {
-    if (!(key in glDebug) && typeof import_constants13.GL[key] === "number") {
-      glDebug[key] = import_constants13.GL[key];
+  for (const key in import_constants12.GL) {
+    if (!(key in glDebug) && typeof import_constants12.GL[key] === "number") {
+      glDebug[key] = import_constants12.GL[key];
     }
   }
   class WebGLDebugContext {
@@ -3043,7 +2925,7 @@ function onGLError(props, err, functionName, args) {
   const errorMessage = globalThis.WebGLDebugUtils.glEnumToString(err);
   const functionArgs = globalThis.WebGLDebugUtils.glFunctionArgsToString(functionName, args);
   const message2 = `${errorMessage} in gl.${functionName}(${functionArgs})`;
-  import_core15.log.error(message2)();
+  import_core13.log.error(message2)();
   debugger;
   if (props.throwOnError) {
     throw new Error(message2);
@@ -3051,9 +2933,9 @@ function onGLError(props, err, functionName, args) {
 }
 function onValidateGLFunc(props, functionName, functionArgs) {
   let functionString = "";
-  if (import_core15.log.level >= 1) {
+  if (import_core13.log.level >= 1) {
     functionString = getFunctionString(functionName, functionArgs);
-    import_core15.log.log(1, functionString)();
+    import_core13.log.log(1, functionString)();
   }
   if (props.break && props.break.length > 0) {
     functionString = functionString || getFunctionString(functionName, functionArgs);
@@ -3068,7 +2950,7 @@ function onValidateGLFunc(props, functionName, functionArgs) {
       if (props.throwOnError) {
         throw new Error(`Undefined argument: ${functionString}`);
       } else {
-        import_core15.log.error(`Undefined argument: ${functionString}`)();
+        import_core13.log.error(`Undefined argument: ${functionString}`)();
         debugger;
       }
     }
@@ -3076,8 +2958,8 @@ function onValidateGLFunc(props, functionName, functionArgs) {
 }
 
 // dist/adapter/resources/webgl-shader.js
-var import_core16 = require("@luma.gl/core");
-var import_constants14 = require("@luma.gl/constants");
+var import_core14 = require("@luma.gl/core");
+var import_constants13 = require("@luma.gl/constants");
 
 // dist/adapter/helpers/parse-shader-compiler-log.js
 function parseShaderCompilerLog(errLog) {
@@ -3124,7 +3006,7 @@ function getMessageType(messageType) {
 }
 
 // dist/adapter/resources/webgl-shader.js
-var WEBGLShader = class extends import_core16.Shader {
+var WEBGLShader = class extends import_core14.Shader {
   device;
   handle;
   constructor(device, props) {
@@ -3132,10 +3014,10 @@ var WEBGLShader = class extends import_core16.Shader {
     this.device = device;
     switch (this.props.stage) {
       case "vertex":
-        this.handle = this.props.handle || this.device.gl.createShader(import_constants14.GL.VERTEX_SHADER);
+        this.handle = this.props.handle || this.device.gl.createShader(35633);
         break;
       case "fragment":
-        this.handle = this.props.handle || this.device.gl.createShader(import_constants14.GL.FRAGMENT_SHADER);
+        this.handle = this.props.handle || this.device.gl.createShader(35632);
         break;
       default:
         throw new Error(this.props.stage);
@@ -3171,7 +3053,7 @@ ${source2}`;
     const { gl } = this.device;
     gl.shaderSource(this.handle, source);
     gl.compileShader(this.handle);
-    if (import_core16.log.level === 0) {
+    if (import_core14.log.level === 0) {
       this.compilationStatus = "pending";
       return;
     }
@@ -3183,9 +3065,9 @@ ${source2}`;
       this.debugShader();
       return;
     }
-    import_core16.log.once(1, "Shader compilation is asynchronous")();
+    import_core14.log.once(1, "Shader compilation is asynchronous")();
     await this._waitForCompilationComplete();
-    import_core16.log.info(2, `Shader ${this.id} - async compilation complete: ${this.compilationStatus}`)();
+    import_core14.log.info(2, `Shader ${this.id} - async compilation complete: ${this.compilationStatus}`)();
     this._getCompilationStatus();
     this.debugShader();
   }
@@ -3199,7 +3081,7 @@ ${source2}`;
     }
     const { gl } = this.device;
     for (; ; ) {
-      const complete = gl.getShaderParameter(this.handle, import_constants14.GL.COMPLETION_STATUS_KHR);
+      const complete = gl.getShaderParameter(this.handle, 37297);
       if (complete) {
         return;
       }
@@ -3212,18 +3094,18 @@ ${source2}`;
    * https://gamedev.stackexchange.com/questions/30429/how-to-detect-glsl-warnings
    */
   _getCompilationStatus() {
-    this.compilationStatus = this.device.gl.getShaderParameter(this.handle, import_constants14.GL.COMPILE_STATUS) ? "success" : "error";
+    this.compilationStatus = this.device.gl.getShaderParameter(this.handle, 35713) ? "success" : "error";
   }
 };
 
 // dist/adapter/resources/webgl-render-pass.js
-var import_core17 = require("@luma.gl/core");
-var import_constants15 = require("@luma.gl/constants");
+var import_core15 = require("@luma.gl/core");
+var import_constants14 = require("@luma.gl/constants");
 var GL_DEPTH_BUFFER_BIT = 256;
 var GL_STENCIL_BUFFER_BIT = 1024;
 var GL_COLOR_BUFFER_BIT = 16384;
 var GL_COLOR = 6144;
-var WEBGLRenderPass = class extends import_core17.RenderPass {
+var WEBGLRenderPass = class extends import_core15.RenderPass {
   device;
   /** Parameters that should be applied before each draw call */
   glParameters;
@@ -3237,7 +3119,7 @@ var WEBGLRenderPass = class extends import_core17.RenderPass {
   end() {
     popContextState(this.device.gl);
     if (this.props.framebuffer) {
-      setGLParameters(this.device, { framebuffer: null });
+      setGLParameters(this.device.gl, { framebuffer: null });
     }
   }
   pushDebugGroup(groupLabel) {
@@ -3261,7 +3143,7 @@ var WEBGLRenderPass = class extends import_core17.RenderPass {
       glParameters.depthMask = !this.props.depthReadOnly;
     }
     glParameters.stencilMask = this.props.stencilReadOnly ? 0 : 1;
-    glParameters[import_constants15.GL.RASTERIZER_DISCARD] = this.props.discard;
+    glParameters[35977] = this.props.discard;
     if (parameters.viewport) {
       if (parameters.viewport.length >= 6) {
         glParameters.viewport = parameters.viewport.slice(0, 4);
@@ -3279,10 +3161,10 @@ var WEBGLRenderPass = class extends import_core17.RenderPass {
     }
     if (parameters.stencilReference) {
       console.warn("RenderPassParameters.stencilReference not yet implemented in WebGL");
-      parameters[import_constants15.GL.STENCIL_REF] = parameters.stencilReference;
+      parameters[2967] = parameters.stencilReference;
     }
     this.glParameters = glParameters;
-    setGLParameters(this.device, glParameters);
+    setGLParameters(this.device.gl, glParameters);
   }
   beginOcclusionQuery(queryIndex) {
     const webglQuerySet = this.props.occlusionQuerySet;
@@ -3312,7 +3194,7 @@ var WEBGLRenderPass = class extends import_core17.RenderPass {
       glParameters.clearStencil = this.props.clearStencil;
     }
     if (clearMask !== 0) {
-      withGLParameters(this.device, glParameters, () => {
+      withGLParameters(this.device.gl, glParameters, () => {
         this.device.gl.clear(clearMask);
       });
     }
@@ -3339,39 +3221,39 @@ var WEBGLRenderPass = class extends import_core17.RenderPass {
 };
 
 // dist/adapter/resources/webgl-render-pipeline.js
-var import_core19 = require("@luma.gl/core");
-var import_core20 = require("@luma.gl/core");
-var import_constants22 = require("@luma.gl/constants");
+var import_core17 = require("@luma.gl/core");
+var import_core18 = require("@luma.gl/core");
+var import_constants21 = require("@luma.gl/constants");
 
 // dist/adapter/helpers/get-shader-layout.js
-var import_constants19 = require("@luma.gl/constants");
+var import_constants18 = require("@luma.gl/constants");
 
 // dist/classic/accessor.js
-var import_core18 = require("@luma.gl/core");
-var import_constants17 = require("@luma.gl/constants");
+var import_core16 = require("@luma.gl/core");
+var import_constants16 = require("@luma.gl/constants");
 
 // dist/classic/typed-array-utils.js
-var import_constants16 = require("@luma.gl/constants");
+var import_constants15 = 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_constants16.GL.FLOAT;
+      return 5126;
     case Uint16Array:
-      return import_constants16.GL.UNSIGNED_SHORT;
+      return 5123;
     case Uint32Array:
-      return import_constants16.GL.UNSIGNED_INT;
+      return 5125;
     case Uint8Array:
-      return import_constants16.GL.UNSIGNED_BYTE;
+      return 5121;
     case Uint8ClampedArray:
-      return import_constants16.GL.UNSIGNED_BYTE;
+      return 5121;
     case Int8Array:
-      return import_constants16.GL.BYTE;
+      return 5120;
     case Int16Array:
-      return import_constants16.GL.SHORT;
+      return 5122;
     case Int32Array:
-      return import_constants16.GL.INT;
+      return 5124;
     default:
       throw new Error(ERR_TYPE_DEDUCTION);
   }
@@ -3379,22 +3261,22 @@ function getGLTypeFromTypedArray(arrayOrType) {
 function getTypedArrayFromGLType(glType, options) {
   const { clamped = true } = options || {};
   switch (glType) {
-    case import_constants16.GL.FLOAT:
+    case 5126:
       return Float32Array;
-    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:
+    case 5123:
+    case 33635:
+    case 32819:
+    case 32820:
       return Uint16Array;
-    case import_constants16.GL.UNSIGNED_INT:
+    case 5125:
       return Uint32Array;
-    case import_constants16.GL.UNSIGNED_BYTE:
+    case 5121:
       return clamped ? Uint8ClampedArray : Uint8Array;
-    case import_constants16.GL.BYTE:
+    case 5120:
       return Int8Array;
-    case import_constants16.GL.SHORT:
+    case 5122:
       return Int16Array;
-    case import_constants16.GL.INT:
+    case 5124:
       return Int32Array;
     default:
       throw new Error("Failed to deduce typed array type from GL constant");
@@ -3405,7 +3287,7 @@ function getTypedArrayFromGLType(glType, options) {
 var DEFAULT_ACCESSOR_VALUES = {
   offset: 0,
   stride: 0,
-  type: import_constants17.GL.FLOAT,
+  type: 5126,
   size: 1,
   divisor: 0,
   normalized: false,
@@ -3428,12 +3310,12 @@ var Accessor = class {
   buffer;
   index;
   static getBytesPerElement(accessor) {
-    const ArrayType = getTypedArrayFromGLType(accessor.type || import_constants17.GL.FLOAT);
+    const ArrayType = getTypedArrayFromGLType(accessor.type || 5126);
     return ArrayType.BYTES_PER_ELEMENT;
   }
   static getBytesPerVertex(accessor) {
-    (0, import_core18.assert)(accessor.size);
-    const ArrayType = getTypedArrayFromGLType(accessor.type || import_constants17.GL.FLOAT);
+    (0, import_core16.assert)(accessor.size);
+    const ArrayType = getTypedArrayFromGLType(accessor.type || 5126);
     return ArrayType.BYTES_PER_ELEMENT * accessor.size;
   }
   // Combines (merges) a list of accessors. On top of default values
@@ -3461,10 +3343,10 @@ var Accessor = class {
   // PRIVATE
   // eslint-disable-next-line complexity, max-statements
   _assign(props = {}) {
-    props = (0, import_core18.checkProps)("Accessor", props, PROP_CHECKS);
+    props = (0, import_core16.checkProps)("Accessor", props, PROP_CHECKS);
     if (props.type !== void 0) {
       this.type = props.type;
-      if (props.type === import_constants17.GL.INT || props.type === import_constants17.GL.UNSIGNED_INT) {
+      if (props.type === 5124 || props.type === 5125) {
         this.integer = true;
       }
     }
@@ -3528,62 +3410,62 @@ var Accessor = class {
 };
 
 // dist/adapter/helpers/decode-webgl-types.js
-var import_constants18 = require("@luma.gl/constants");
+var import_constants17 = require("@luma.gl/constants");
 function isSamplerUniform(type) {
   return SAMPLER_TYPES.includes(type);
 }
 var SAMPLER_TYPES = [
-  import_constants18.GL.SAMPLER_2D,
-  import_constants18.GL.SAMPLER_CUBE,
-  import_constants18.GL.SAMPLER_3D,
-  import_constants18.GL.SAMPLER_2D_SHADOW,
-  import_constants18.GL.SAMPLER_2D_ARRAY,
-  import_constants18.GL.SAMPLER_2D_ARRAY_SHADOW,
-  import_constants18.GL.SAMPLER_CUBE_SHADOW,
-  import_constants18.GL.INT_SAMPLER_2D,
-  import_constants18.GL.INT_SAMPLER_3D,
-  import_constants18.GL.INT_SAMPLER_CUBE,
-  import_constants18.GL.INT_SAMPLER_2D_ARRAY,
-  import_constants18.GL.UNSIGNED_INT_SAMPLER_2D,
-  import_constants18.GL.UNSIGNED_INT_SAMPLER_3D,
-  import_constants18.GL.UNSIGNED_INT_SAMPLER_CUBE,
-  import_constants18.GL.UNSIGNED_INT_SAMPLER_2D_ARRAY
+  35678,
+  35680,
+  35679,
+  35682,
+  36289,
+  36292,
+  36293,
+  36298,
+  36299,
+  36300,
+  36303,
+  36306,
+  36307,
+  36308,
+  36311
 ];
 var COMPOSITE_GL_TYPES = {
-  [import_constants18.GL.FLOAT]: [import_constants18.GL.FLOAT, 1, "float", "f32", "float32"],
-  [import_constants18.GL.FLOAT_VEC2]: [import_constants18.GL.FLOAT, 2, "vec2", "vec2<f32>", "float32x2"],
-  [import_constants18.GL.FLOAT_VEC3]: [import_constants18.GL.FLOAT, 3, "vec3", "vec3<f32>", "float32x3"],
-  [import_constants18.GL.FLOAT_VEC4]: [import_constants18.GL.FLOAT, 4, "vec4", "vec4<f32>", "float32x4"],
-  [import_constants18.GL.INT]: [import_constants18.GL.INT, 1, "int", "i32", "sint32"],
-  [import_constants18.GL.INT_VEC2]: [import_constants18.GL.INT, 2, "ivec2", "vec2<i32>", "sint32x2"],
-  [import_constants18.GL.INT_VEC3]: [import_constants18.GL.INT, 3, "ivec3", "vec3<i32>", "sint32x3"],
-  [import_constants18.GL.INT_VEC4]: [import_constants18.GL.INT, 4, "ivec4", "vec4<i32>", "sint32x4"],
-  [import_constants18.GL.UNSIGNED_INT]: [import_constants18.GL.UNSIGNED_INT, 1, "uint", "u32", "uint32"],
-  [import_constants18.GL.UNSIGNED_INT_VEC2]: [import_constants18.GL.UNSIGNED_INT, 2, "uvec2", "vec2<u32>", "uint32x2"],
-  [import_constants18.GL.UNSIGNED_INT_VEC3]: [import_constants18.GL.UNSIGNED_INT, 3, "uvec3", "vec3<u32>", "uint32x3"],
-  [import_constants18.GL.UNSIGNED_INT_VEC4]: [import_constants18.GL.UNSIGNED_INT, 4, "uvec4", "vec4<u32>", "uint32x4"],
-  [import_constants18.GL.BOOL]: [import_constants18.GL.FLOAT, 1, "bool", "f32", "float32"],
-  [import_constants18.GL.BOOL_VEC2]: [import_constants18.GL.FLOAT, 2, "bvec2", "vec2<f32>", "float32x2"],
-  [import_constants18.GL.BOOL_VEC3]: [import_constants18.GL.FLOAT, 3, "bvec3", "vec3<f32>", "float32x3"],
-  [import_constants18.GL.BOOL_VEC4]: [import_constants18.GL.FLOAT, 4, "bvec4", "vec4<f32>", "float32x4"],
+  [5126]: [5126, 1, "float", "f32", "float32"],
+  [35664]: [5126, 2, "vec2", "vec2<f32>", "float32x2"],
+  [35665]: [5126, 3, "vec3", "vec3<f32>", "float32x3"],
+  [35666]: [5126, 4, "vec4", "vec4<f32>", "float32x4"],
+  [5124]: [5124, 1, "int", "i32", "sint32"],
+  [35667]: [5124, 2, "ivec2", "vec2<i32>", "sint32x2"],
+  [35668]: [5124, 3, "ivec3", "vec3<i32>", "sint32x3"],
+  [35669]: [5124, 4, "ivec4", "vec4<i32>", "sint32x4"],
+  [5125]: [5125, 1, "uint", "u32", "uint32"],
+  [36294]: [5125, 2, "uvec2", "vec2<u32>", "uint32x2"],
+  [36295]: [5125, 3, "uvec3", "vec3<u32>", "uint32x3"],
+  [36296]: [5125, 4, "uvec4", "vec4<u32>", "uint32x4"],
+  [35670]: [5126, 1, "bool", "f32", "float32"],
+  [35671]: [5126, 2, "bvec2", "vec2<f32>", "float32x2"],
+  [35672]: [5126, 3, "bvec3", "vec3<f32>", "float32x3"],
+  [35673]: [5126, 4, "bvec4", "vec4<f32>", "float32x4"],
   // TODO - are sizes/components below correct?
-  [import_constants18.GL.FLOAT_MAT2]: [import_constants18.GL.FLOAT, 8, "mat2", "mat2x2<f32>"],
+  [35674]: [5126, 8, "mat2", "mat2x2<f32>"],
   // 4
-  [import_constants18.GL.FLOAT_MAT2x3]: [import_constants18.GL.FLOAT, 8, "mat2x3", "mat2x3<f32>"],
+  [35685]: [5126, 8, "mat2x3", "mat2x3<f32>"],
   // 6
-  [import_constants18.GL.FLOAT_MAT2x4]: [import_constants18.GL.FLOAT, 8, "mat2x4", "mat2x4<f32>"],
+  [35686]: [5126, 8, "mat2x4", "mat2x4<f32>"],
   // 8
-  [import_constants18.GL.FLOAT_MAT3x2]: [import_constants18.GL.FLOAT, 12, "mat3x2", "mat3x2<f32>"],
+  [35687]: [5126, 12, "mat3x2", "mat3x2<f32>"],
   // 6
-  [import_constants18.GL.FLOAT_MAT3]: [import_constants18.GL.FLOAT, 12, "mat3", "mat3x3<f32>"],
+  [35675]: [5126, 12, "mat3", "mat3x3<f32>"],
   // 9
-  [import_constants18.GL.FLOAT_MAT3x4]: [import_constants18.GL.FLOAT, 12, "mat3x4", "mat3x4<f32>"],
+  [35688]: [5126, 12, "mat3x4", "mat3x4<f32>"],
   // 12
-  [import_constants18.GL.FLOAT_MAT4x2]: [import_constants18.GL.FLOAT, 16, "mat4x2", "mat4x2<f32>"],
+  [35689]: [5126, 16, "mat4x2", "mat4x2<f32>"],
   // 8
-  [import_constants18.GL.FLOAT_MAT4x3]: [import_constants18.GL.FLOAT, 16, "mat4x3", "mat4x3<f32>"],
+  [35690]: [5126, 16, "mat4x3", "mat4x3<f32>"],
   // 12
-  [import_constants18.GL.FLOAT_MAT4]: [import_constants18.GL.FLOAT, 16, "mat4", "mat4x4<f32>"]
+  [35676]: [5126, 16, "mat4", "mat4x4<f32>"]
   // 16
 };
 function decodeGLUniformType(glUniformType) {
@@ -3656,7 +3538,7 @@ function getShaderLayout(gl, program) {
 }
 function readAttributeDeclarations(gl, program) {
   const attributes = [];
-  const count = gl.getProgramParameter(program, gl.ACTIVE_ATTRIBUTES);
+  const count = gl.getProgramParameter(program, 35721);
   for (let index = 0; index < count; index++) {
     const activeInfo = gl.getActiveAttrib(program, index);
     if (!activeInfo) {
@@ -3685,7 +3567,7 @@ function readAttributeDeclarations(gl, program) {
 }
 function readVaryings(gl, program) {
   const varyings = [];
-  const count = gl.getProgramParameter(program, import_constants19.GL.TRANSFORM_FEEDBACK_VARYINGS);
+  const count = gl.getProgramParameter(program, 35971);
   for (let location = 0; location < count; location++) {
     const activeInfo = gl.getTransformFeedbackVarying(program, location);
     if (!activeInfo) {
@@ -3702,7 +3584,7 @@ function readVaryings(gl, program) {
 }
 function readUniformBindings(gl, program) {
   const uniforms = [];
-  const uniformCount = gl.getProgramParameter(program, import_constants19.GL.ACTIVE_UNIFORMS);
+  const uniformCount = gl.getProgramParameter(program, 35718);
   for (let i = 0; i < uniformCount; i++) {
     const activeInfo = gl.getActiveUniform(program, i);
     if (!activeInfo) {
@@ -3738,22 +3620,22 @@ function readUniformBindings(gl, program) {
 function readUniformBlocks(gl, program) {
   const getBlockParameter = (blockIndex, pname) => gl.getActiveUniformBlockParameter(program, blockIndex, pname);
   const uniformBlocks = [];
-  const blockCount = gl.getProgramParameter(program, import_constants19.GL.ACTIVE_UNIFORM_BLOCKS);
+  const blockCount = gl.getProgramParameter(program, 35382);
   for (let blockIndex = 0; blockIndex < blockCount; blockIndex++) {
     const blockInfo = {
       name: gl.getActiveUniformBlockName(program, blockIndex) || "",
-      location: getBlockParameter(blockIndex, import_constants19.GL.UNIFORM_BLOCK_BINDING),
-      byteLength: getBlockParameter(blockIndex, import_constants19.GL.UNIFORM_BLOCK_DATA_SIZE),
-      vertex: getBlockParameter(blockIndex, import_constants19.GL.UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER),
-      fragment: getBlockParameter(blockIndex, import_constants19.GL.UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER),
-      uniformCount: getBlockParameter(blockIndex, import_constants19.GL.UNIFORM_BLOCK_ACTIVE_UNIFORMS),
+      location: getBlockParameter(blockIndex, 35391),
+      byteLength: getBlockParameter(blockIndex, 35392),
+      vertex: getBlockParameter(blockIndex, 35396),
+      fragment: getBlockParameter(blockIndex, 35398),
+      uniformCount: getBlockParameter(blockIndex, 35394),
       uniforms: []
     };
-    const uniformIndices = getBlockParameter(blockIndex, import_constants19.GL.UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES) || [];
-    const uniformType = gl.getActiveUniforms(program, uniformIndices, import_constants19.GL.UNIFORM_TYPE);
-    const uniformArrayLength = gl.getActiveUniforms(program, uniformIndices, import_constants19.GL.UNIFORM_SIZE);
-    const uniformOffset = gl.getActiveUniforms(program, uniformIndices, import_constants19.GL.UNIFORM_OFFSET);
-    const uniformStride = gl.getActiveUniforms(program, uniformIndices, import_constants19.GL.UNIFORM_ARRAY_STRIDE);
+    const uniformIndices = getBlockParameter(blockIndex, 35395) || [];
+    const uniformType = gl.getActiveUniforms(program, uniformIndices, 35383);
+    const uniformArrayLength = gl.getActiveUniforms(program, uniformIndices, 35384);
+    const uniformOffset = gl.getActiveUniforms(program, uniformIndices, 35387);
+    const uniformStride = gl.getActiveUniforms(program, uniformIndices, 35388);
     for (let i = 0; i < blockInfo.uniformCount; ++i) {
       const activeInfo = gl.getActiveUniform(program, uniformIndices[i]);
       if (!activeInfo) {
@@ -3776,21 +3658,21 @@ function readUniformBlocks(gl, program) {
   return uniformBlocks;
 }
 var SAMPLER_UNIFORMS_GL_TO_GPU = {
-  [import_constants19.GL.SAMPLER_2D]: ["2d", "float"],
-  [import_constants19.GL.SAMPLER_CUBE]: ["cube", "float"],
-  [import_constants19.GL.SAMPLER_3D]: ["3d", "float"],
-  [import_constants19.GL.SAMPLER_2D_SHADOW]: ["3d", "depth"],
-  [import_constants19.GL.SAMPLER_2D_ARRAY]: ["2d-array", "float"],
-  [import_constants19.GL.SAMPLER_2D_ARRAY_SHADOW]: ["2d-array", "depth"],
-  [import_constants19.GL.SAMPLER_CUBE_SHADOW]: ["cube", "float"],
-  [import_constants19.GL.INT_SAMPLER_2D]: ["2d", "sint"],
-  [import_constants19.GL.INT_SAMPLER_3D]: ["3d", "sint"],
-  [import_constants19.GL.INT_SAMPLER_CUBE]: ["cube", "sint"],
-  [import_constants19.GL.INT_SAMPLER_2D_ARRAY]: ["2d-array", "uint"],
-  [import_constants19.GL.UNSIGNED_INT_SAMPLER_2D]: ["2d", "uint"],
-  [import_constants19.GL.UNSIGNED_INT_SAMPLER_3D]: ["3d", "uint"],
-  [import_constants19.GL.UNSIGNED_INT_SAMPLER_CUBE]: ["cube", "uint"],
-  [import_constants19.GL.UNSIGNED_INT_SAMPLER_2D_ARRAY]: ["2d-array", "uint"]
+  [35678]: ["2d", "float"],
+  [35680]: ["cube", "float"],
+  [35679]: ["3d", "float"],
+  [35682]: ["3d", "depth"],
+  [36289]: ["2d-array", "float"],
+  [36292]: ["2d-array", "depth"],
+  [36293]: ["cube", "float"],
+  [36298]: ["2d", "sint"],
+  [36299]: ["3d", "sint"],
+  [36300]: ["cube", "sint"],
+  [36303]: ["2d-array", "uint"],
+  [36306]: ["2d", "uint"],
+  [36307]: ["3d", "uint"],
+  [36308]: ["cube", "uint"],
+  [36311]: ["2d-array", "uint"]
 };
 function getSamplerInfo(type) {
   const sampler = SAMPLER_UNIFORMS_GL_TO_GPU[type];
@@ -3821,7 +3703,7 @@ function parseUniformName(name) {
 }
 
 // dist/adapter/helpers/set-uniform.js
-var import_constants20 = require("@luma.gl/constants");
+var import_constants19 = require("@luma.gl/constants");
 function setUniform(gl, location, type, value) {
   const gl2 = gl;
   let uniformValue = value;
@@ -3833,97 +3715,97 @@ function setUniform(gl, location, type, value) {
   }
   const arrayValue = typeof uniformValue === "number" ? [uniformValue] : uniformValue;
   switch (type) {
-    case import_constants20.GL.SAMPLER_2D:
-    case import_constants20.GL.SAMPLER_CUBE:
-    case import_constants20.GL.SAMPLER_3D:
-    case import_constants20.GL.SAMPLER_2D_SHADOW:
-    case import_constants20.GL.SAMPLER_2D_ARRAY:
-    case import_constants20.GL.SAMPLER_2D_ARRAY_SHADOW:
-    case import_constants20.GL.SAMPLER_CUBE_SHADOW:
-    case import_constants20.GL.INT_SAMPLER_2D:
-    case import_constants20.GL.INT_SAMPLER_3D:
-    case import_constants20.GL.INT_SAMPLER_CUBE:
-    case import_constants20.GL.INT_SAMPLER_2D_ARRAY:
-    case import_constants20.GL.UNSIGNED_INT_SAMPLER_2D:
-    case import_constants20.GL.UNSIGNED_INT_SAMPLER_3D:
-    case import_constants20.GL.UNSIGNED_INT_SAMPLER_CUBE:
-    case import_constants20.GL.UNSIGNED_INT_SAMPLER_2D_ARRAY:
+    case 35678:
+    case 35680:
+    case 35679:
+    case 35682:
+    case 36289:
+    case 36292:
+    case 36293:
+    case 36298:
+    case 36299:
+    case 36300:
+    case 36303:
+    case 36306:
+    case 36307:
+    case 36308:
+    case 36311:
       if (typeof value !== "number") {
         throw new Error("samplers must be set to integers");
       }
       return gl.uniform1i(location, value);
-    case import_constants20.GL.FLOAT:
+    case 5126:
       return gl.uniform1fv(location, arrayValue);
-    case import_constants20.GL.FLOAT_VEC2:
+    case 35664:
       return gl.uniform2fv(location, arrayValue);
-    case import_constants20.GL.FLOAT_VEC3:
+    case 35665:
       return gl.uniform3fv(location, arrayValue);
-    case import_constants20.GL.FLOAT_VEC4:
+    case 35666:
       return gl.uniform4fv(location, arrayValue);
-    case import_constants20.GL.INT:
+    case 5124:
       return gl.uniform1iv(location, arrayValue);
-    case import_constants20.GL.INT_VEC2:
+    case 35667:
       return gl.uniform2iv(location, arrayValue);
-    case import_constants20.GL.INT_VEC3:
+    case 35668:
       return gl.uniform3iv(location, arrayValue);
-    case import_constants20.GL.INT_VEC4:
+    case 35669:
       return gl.uniform4iv(location, arrayValue);
-    case import_constants20.GL.BOOL:
+    case 35670:
       return gl.uniform1iv(location, arrayValue);
-    case import_constants20.GL.BOOL_VEC2:
+    case 35671:
       return gl.uniform2iv(location, arrayValue);
-    case import_constants20.GL.BOOL_VEC3:
+    case 35672:
       return gl.uniform3iv(location, arrayValue);
-    case import_constants20.GL.BOOL_VEC4:
+    case 35673:
       return gl.uniform4iv(location, arrayValue);
-    case import_constants20.GL.UNSIGNED_INT:
+    case 5125:
       return gl2.uniform1uiv(location, arrayValue, 1);
-    case import_constants20.GL.UNSIGNED_INT_VEC2:
+    case 36294:
       return gl2.uniform2uiv(location, arrayValue, 2);
-    case import_constants20.GL.UNSIGNED_INT_VEC3:
+    case 36295:
       return gl2.uniform3uiv(location, arrayValue, 3);
-    case import_constants20.GL.UNSIGNED_INT_VEC4:
+    case 36296:
       return gl2.uniform4uiv(location, arrayValue, 4);
-    case import_constants20.GL.FLOAT_MAT2:
+    case 35674:
       return gl.uniformMatrix2fv(location, false, arrayValue);
-    case import_constants20.GL.FLOAT_MAT3:
+    case 35675:
       return gl.uniformMatrix3fv(location, false, arrayValue);
-    case import_constants20.GL.FLOAT_MAT4:
+    case 35676:
       return gl.uniformMatrix4fv(location, false, arrayValue);
-    case import_constants20.GL.FLOAT_MAT2x3:
+    case 35685:
       return gl2.uniformMatrix2x3fv(location, false, arrayValue);
-    case import_constants20.GL.FLOAT_MAT2x4:
+    case 35686:
       return gl2.uniformMatrix2x4fv(location, false, arrayValue);
-    case import_constants20.GL.FLOAT_MAT3x2:
+    case 35687:
       return gl2.uniformMatrix3x2fv(location, false, arrayValue);
-    case import_constants20.GL.FLOAT_MAT3x4:
+    case 35688:
       return gl2.uniformMatrix3x4fv(location, false, arrayValue);
-    case import_constants20.GL.FLOAT_MAT4x2:
+    case 35689:
       return gl2.uniformMatrix4x2fv(location, false, arrayValue);
-    case import_constants20.GL.FLOAT_MAT4x3:
+    case 35690:
       return gl2.uniformMatrix4x3fv(location, false, arrayValue);
   }
   throw new Error("Illegal uniform");
 }
 
 // dist/adapter/helpers/webgl-topology-utils.js
-var import_constants21 = require("@luma.gl/constants");
+var import_constants20 = require("@luma.gl/constants");
 function getGLDrawMode(topology) {
   switch (topology) {
     case "point-list":
-      return import_constants21.GL.POINTS;
+      return 0;
     case "line-list":
-      return import_constants21.GL.LINES;
+      return 1;
     case "line-strip":
-      return import_constants21.GL.LINE_STRIP;
+      return 3;
     case "line-loop-webgl":
-      return import_constants21.GL.LINE_LOOP;
+      return 2;
     case "triangle-list":
-      return import_constants21.GL.TRIANGLES;
+      return 4;
     case "triangle-strip":
-      return import_constants21.GL.TRIANGLE_STRIP;
+      return 5;
     case "triangle-fan-webgl":
-      return import_constants21.GL.TRIANGLE_FAN;
+      return 6;
     default:
       throw new Error(topology);
   }
@@ -3931,19 +3813,19 @@ function getGLDrawMode(topology) {
 function getGLPrimitive(topology) {
   switch (topology) {
     case "point-list":
-      return import_constants21.GL.POINTS;
+      return 0;
     case "line-list":
-      return import_constants21.GL.LINES;
+      return 1;
     case "line-strip":
-      return import_constants21.GL.LINES;
+      return 1;
     case "line-loop-webgl":
-      return import_constants21.GL.LINES;
+      return 1;
     case "triangle-list":
-      return import_constants21.GL.TRIANGLES;
+      return 4;
     case "triangle-strip":
-      return import_constants21.GL.TRIANGLES;
+      return 4;
     case "triangle-fan-webgl":
-      return import_constants21.GL.TRIANGLES;
+      return 4;
     default:
       throw new Error(topology);
   }
@@ -3951,7 +3833,7 @@ function getGLPrimitive(topology) {
 
 // dist/adapter/resources/webgl-render-pipeline.js
 var LOG_PROGRAM_PERF_PRIORITY = 4;
-var WEBGLRenderPipeline = class extends import_core19.RenderPipeline {
+var WEBGLRenderPipeline = class extends import_core17.RenderPipeline {
   /** The WebGL device that created this render pipeline */
   device;
   /** Handle to underlying WebGL program */
@@ -3976,22 +3858,22 @@ var WEBGLRenderPipeline = class extends import_core19.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_core19.cast)(props.vs);
-    this.fs = (0, import_core19.cast)(props.fs);
-    const { varyings, bufferMode = import_constants22.GL.SEPARATE_ATTRIBS } = props;
+    this.vs = (0, import_core17.cast)(props.vs);
+    this.fs = (0, import_core17.cast)(props.fs);
+    const { varyings, bufferMode = 35981 } = props;
     if (varyings && varyings.length > 0) {
       this.varyings = varyings;
       this.device.gl.transformFeedbackVaryings(this.handle, varyings, bufferMode);
     }
     this._linkShaders();
-    import_core19.log.time(0, `RenderPipeline ${this.id} - shaderLayout introspection`)();
+    import_core17.log.time(0, `RenderPipeline ${this.id} - shaderLayout introspection`)();
     this.introspectedLayout = getShaderLayout(this.device.gl, this.handle);
-    import_core19.log.timeEnd(0, `RenderPipeline ${this.id} - shaderLayout introspection`)();
-    this.shaderLayout = (0, import_core20.mergeShaderLayout)(this.introspectedLayout, props.shaderLayout);
+    import_core17.log.timeEnd(0, `RenderPipeline ${this.id} - shaderLayout introspection`)();
+    this.shaderLayout = (0, import_core18.mergeShaderLayout)(this.introspectedLayout, props.shaderLayout);
     switch (this.props.topology) {
       case "triangle-fan-webgl":
       case "line-loop-webgl":
-        import_core19.log.warn(`Primitive topology ${this.props.topology} is deprecated and will be removed in v9.1`);
+        import_core17.log.warn(`Primitive topology ${this.props.topology} is deprecated and will be removed in v9.1`);
         break;
       default:
     }
@@ -4011,11 +3893,11 @@ var WEBGLRenderPipeline = class extends import_core19.RenderPipeline {
       const binding = this.shaderLayout.bindings.find((binding2) => binding2.name === name) || this.shaderLayout.bindings.find((binding2) => binding2.name === `${name}Uniforms`);
       if (!binding) {
         const validBindings = this.shaderLayout.bindings.map((binding2) => `"${binding2.name}"`).join(", ");
-        import_core19.log.warn(`Unknown binding "${name}" in render pipeline "${this.id}", expected one of ${validBindings}`)();
+        import_core17.log.warn(`Unknown binding "${name}" in render pipeline "${this.id}", expected one of ${validBindings}`)();
         continue;
       }
       if (!value) {
-        import_core19.log.warn(`Unsetting binding "${name}" in render pipeline "${this.id}"`)();
+        import_core17.log.warn(`Unsetting binding "${name}" in render pipeline "${this.id}"`)();
       }
       switch (binding.type) {
         case "uniform":
@@ -4029,7 +3911,7 @@ var WEBGLRenderPipeline = class extends import_core19.RenderPipeline {
           }
           break;
         case "sampler":
-          import_core19.log.warn(`Ignoring sampler ${name}`)();
+          import_core17.log.warn(`Ignoring sampler ${name}`)();
           break;
         default:
           throw new Error(binding.type);
@@ -4043,9 +3925,6 @@ var WEBGLRenderPipeline = class extends import_core19.RenderPipeline {
    */
   draw(options) {
     var _a;
-    if (this.linkStatus !== "success") {
-      return false;
-    }
     const {
       renderPass,
       vertexArray,
@@ -4062,9 +3941,18 @@ var WEBGLRenderPipeline = class extends import_core19.RenderPipeline {
     const isIndexed = Boolean(vertexArray.indexBuffer);
     const glIndexType = (_a = vertexArray.indexBuffer) == null ? void 0 : _a.glIndexType;
     const isInstanced = Number(instanceCount) > 0;
+    if (this.linkStatus !== "success") {
+      import_core17.log.info(2, `RenderPipeline:${this.id}.draw() aborted - waiting for shader linking`)();
+      return false;
+    }
     if (!this._areTexturesRenderable() || vertexCount === 0) {
+      import_core17.log.info(2, `RenderPipeline:${this.id}.draw() aborted - textures not yet loaded`)();
       return false;
     }
+    if (vertexCount === 0) {
+      import_core17.log.info(2, `RenderPipeline:${this.id}.draw() aborted - no vertices to draw`)();
+      return true;
+    }
     this.device.gl.useProgram(this.handle);
     vertexArray.bindBeforeRender(renderPass);
     if (transformFeedback) {
@@ -4099,9 +3987,9 @@ var WEBGLRenderPipeline = class extends import_core19.RenderPipeline {
   }
   // DEPRECATED METHODS
   setUniformsWebGL(uniforms) {
-    const { bindings } = (0, import_core19.splitUniformsAndBindings)(uniforms);
+    const { bindings } = (0, import_core17.splitUniformsAndBindings)(uniforms);
     Object.keys(bindings).forEach((name) => {
-      import_core19.log.warn(`Unsupported value "${JSON.stringify(bindings[name])}" used in setUniforms() for key ${name}. Use setBindings() instead?`)();
+      import_core17.log.warn(`Unsupported value "${JSON.stringify(bindings[name])}" used in setUniforms() for key ${name}. Use setBindings() instead?`)();
     });
     Object.assign(this.uniforms, uniforms);
   }
@@ -4112,19 +4000,19 @@ var WEBGLRenderPipeline = class extends import_core19.RenderPipeline {
     const { gl } = this.device;
     gl.attachShader(this.handle, this.vs.handle);
     gl.attachShader(this.handle, this.fs.handle);
-    import_core19.log.time(LOG_PROGRAM_PERF_PRIORITY, `linkProgram for ${this.id}`)();
+    import_core17.log.time(LOG_PROGRAM_PERF_PRIORITY, `linkProgram for ${this.id}`)();
     gl.linkProgram(this.handle);
-    import_core19.log.timeEnd(LOG_PROGRAM_PERF_PRIORITY, `linkProgram for ${this.id}`)();
-    if (import_core19.log.level === 0) {
+    import_core17.log.timeEnd(LOG_PROGRAM_PERF_PRIORITY, `linkProgram for ${this.id}`)();
+    if (import_core17.log.level === 0) {
     }
     if (!this.device.features.has("compilation-status-async-webgl")) {
       const status2 = this._getLinkStatus();
       this._reportLinkStatus(status2);
       return;
     }
-    import_core19.log.once(1, "RenderPipeline linking is asynchronous")();
+    import_core17.log.once(1, "RenderPipeline linking is asynchronous")();
     await this._waitForLinkComplete();
-    import_core19.log.info(2, `RenderPipeline ${this.id} - async linking complete: ${this.linkStatus}`)();
+    import_core17.log.info(2, `RenderPipeline ${this.id} - async linking complete: ${this.linkStatus}`)();
     const status = this._getLinkStatus();
     this._reportLinkStatus(status);
   }
@@ -4153,13 +4041,13 @@ var WEBGLRenderPipeline = class extends import_core19.RenderPipeline {
    */
   _getLinkStatus() {
     const { gl } = this.device;
-    const linked = gl.getProgramParameter(this.handle, gl.LINK_STATUS);
+    const linked = gl.getProgramParameter(this.handle, 35714);
     if (!linked) {
       this.linkStatus = "error";
       return "linking";
     }
     gl.validateProgram(this.handle);
-    const validated = gl.getProgramParameter(this.handle, gl.VALIDATE_STATUS);
+    const validated = gl.getProgramParameter(this.handle, 35715);
     if (!validated) {
       this.linkStatus = "error";
       return "validation";
@@ -4177,7 +4065,7 @@ var WEBGLRenderPipeline = class extends import_core19.RenderPipeline {
     }
     const { gl } = this.device;
     for (; ; ) {
-      const complete = gl.getProgramParameter(this.handle, import_constants22.GL.COMPLETION_STATUS_KHR);
+      const complete = gl.getProgramParameter(this.handle, 37297);
       if (complete) {
         return;
       }
@@ -4217,15 +4105,15 @@ var WEBGLRenderPipeline = class extends import_core19.RenderPipeline {
         case "uniform":
           const { name } = binding;
           const location = gl.getUniformBlockIndex(this.handle, name);
-          if (location === import_constants22.GL.INVALID_INDEX) {
+          if (location === 4294967295) {
             throw new Error(`Invalid uniform block name ${name}`);
           }
           gl.uniformBlockBinding(this.handle, uniformBufferIndex, location);
           if (value instanceof WEBGLBuffer) {
-            gl.bindBufferBase(import_constants22.GL.UNIFORM_BUFFER, uniformBufferIndex, value.handle);
+            gl.bindBufferBase(35345, uniformBufferIndex, value.handle);
           } else {
             gl.bindBufferRange(
-              import_constants22.GL.UNIFORM_BUFFER,
+              35345,
               uniformBufferIndex,
               // @ts-expect-error
               value.buffer.handle,
@@ -4247,12 +4135,12 @@ var WEBGLRenderPipeline = class extends import_core19.RenderPipeline {
           } else if (value instanceof WEBGLTexture) {
             texture = value;
           } else if (value instanceof WEBGLFramebuffer && value.colorAttachments[0] instanceof WEBGLTexture) {
-            import_core19.log.warn("Passing framebuffer in texture binding may be deprecated. Use fbo.colorAttachments[0] instead")();
+            import_core17.log.warn("Passing framebuffer in texture binding may be deprecated. Use fbo.colorAttachments[0] instead")();
             texture = value.colorAttachments[0];
           } else {
             throw new Error("No texture");
           }
-          gl.activeTexture(import_constants22.GL.TEXTURE0 + textureUnit);
+          gl.activeTexture(33984 + textureUnit);
           gl.bindTexture(texture.target, texture.handle);
           textureUnit += 1;
           break;
@@ -4280,15 +4168,15 @@ var WEBGLRenderPipeline = class extends import_core19.RenderPipeline {
 };
 
 // dist/adapter/resources/webgl-command-encoder.js
-var import_core22 = require("@luma.gl/core");
+var import_core20 = require("@luma.gl/core");
 
 // dist/adapter/resources/webgl-command-buffer.js
-var import_core21 = require("@luma.gl/core");
-var import_constants23 = require("@luma.gl/constants");
+var import_core19 = require("@luma.gl/core");
+var import_constants22 = require("@luma.gl/constants");
 function cast2(value) {
   return value;
 }
-var WEBGLCommandBuffer = class extends import_core21.CommandBuffer {
+var WEBGLCommandBuffer = class extends import_core19.CommandBuffer {
   device;
   commands = [];
   constructor(device) {
@@ -4317,11 +4205,11 @@ var WEBGLCommandBuffer = class extends import_core21.CommandBuffer {
 function _copyBufferToBuffer(device, options) {
   const source = cast2(options.source);
   const destination = cast2(options.destination);
-  device.gl.bindBuffer(import_constants23.GL.COPY_READ_BUFFER, source.handle);
-  device.gl.bindBuffer(import_constants23.GL.COPY_WRITE_BUFFER, destination.handle);
-  device.gl.copyBufferSubData(import_constants23.GL.COPY_READ_BUFFER, import_constants23.GL.COPY_WRITE_BUFFER, options.sourceOffset ?? 0, options.destinationOffset ?? 0, options.size);
-  device.gl.bindBuffer(import_constants23.GL.COPY_READ_BUFFER, null);
-  device.gl.bindBuffer(import_constants23.GL.COPY_WRITE_BUFFER, null);
+  device.gl.bindBuffer(36662, source.handle);
+  device.gl.bindBuffer(36663, destination.handle);
+  device.gl.copyBufferSubData(36662, 36663, options.sourceOffset ?? 0, options.destinationOffset ?? 0, options.size);
+  device.gl.bindBuffer(36662, null);
+  device.gl.bindBuffer(36663, null);
 }
 function _copyBufferToTexture(device, options) {
   throw new Error("Not implemented");
@@ -4371,12 +4259,12 @@ function _copyTextureToBuffer(device, options) {
     const sourceParams = getWebGLTextureParameters(framebuffer.texture.props.format);
     const sourceFormat = sourceParams.dataFormat;
     const sourceType = sourceParams.type;
-    device.gl.bindBuffer(import_constants23.GL.PIXEL_PACK_BUFFER, webglBuffer.handle);
-    device.gl.bindFramebuffer(import_constants23.GL.FRAMEBUFFER, framebuffer.handle);
+    device.gl.bindBuffer(35051, webglBuffer.handle);
+    device.gl.bindFramebuffer(36160, framebuffer.handle);
     device.gl.readPixels(origin[0], origin[1], sourceWidth, sourceHeight, sourceFormat, sourceType, byteOffset);
   } finally {
-    device.gl.bindBuffer(import_constants23.GL.PIXEL_PACK_BUFFER, null);
-    device.gl.bindFramebuffer(import_constants23.GL.FRAMEBUFFER, null);
+    device.gl.bindBuffer(35051, null);
+    device.gl.bindFramebuffer(36160, null);
     if (destroyFramebuffer) {
       framebuffer.destroy();
     }
@@ -4407,11 +4295,11 @@ function _copyTextureToTexture(device, options) {
     // depthOrArrayLayers = 0
   } = options;
   const destinationMipmaplevel = 0;
-  const destinationInternalFormat = import_constants23.GL.RGBA;
+  const destinationInternalFormat = 6408;
   const { framebuffer, destroyFramebuffer } = getFramebuffer(source);
   const [sourceX, sourceY] = origin;
   const isSubCopy = false;
-  device.gl.bindFramebuffer(import_constants23.GL.FRAMEBUFFER, framebuffer.handle);
+  device.gl.bindFramebuffer(36160, framebuffer.handle);
   let texture = null;
   let textureTarget;
   if (destination instanceof WEBGLTexture) {
@@ -4446,7 +4334,7 @@ function _copyTextureToTexture(device, options) {
   return texture;
 }
 function getFramebuffer(source) {
-  if (source instanceof import_core21.Texture) {
+  if (source instanceof import_core19.Texture) {
     const { width, height, id } = source;
     const framebuffer = source.device.createFramebuffer({
       id: `framebuffer-for-${id}`,
@@ -4460,7 +4348,7 @@ function getFramebuffer(source) {
 }
 
 // dist/adapter/resources/webgl-command-encoder.js
-var WEBGLCommandEncoder = class extends import_core22.CommandEncoder {
+var WEBGLCommandEncoder = class extends import_core20.CommandEncoder {
   device;
   commandBuffer;
   constructor(device, props) {
@@ -4499,10 +4387,10 @@ var WEBGLCommandEncoder = class extends import_core22.CommandEncoder {
 };
 
 // dist/adapter/resources/webgl-vertex-array.js
-var import_core23 = require("@luma.gl/core");
-var import_constants24 = require("@luma.gl/constants");
+var import_core21 = require("@luma.gl/core");
+var import_constants23 = require("@luma.gl/constants");
 var import_env2 = require("@probe.gl/env");
-var WEBGLVertexArray = class extends import_core23.VertexArray {
+var WEBGLVertexArray = class extends import_core21.VertexArray {
   get [Symbol.toStringTag]() {
     return "VertexArray";
   }
@@ -4540,22 +4428,22 @@ var WEBGLVertexArray = class extends import_core23.VertexArray {
    */
   setIndexBuffer(indexBuffer) {
     const buffer = indexBuffer;
-    if (buffer && buffer.glTarget !== import_constants24.GL.ELEMENT_ARRAY_BUFFER) {
+    if (buffer && buffer.glTarget !== 34963) {
       throw new Error("Use .setBuffer()");
     }
     this.device.gl.bindVertexArray(this.handle);
-    this.device.gl.bindBuffer(import_constants24.GL.ELEMENT_ARRAY_BUFFER, buffer ? buffer.handle : null);
+    this.device.gl.bindBuffer(34963, buffer ? buffer.handle : null);
     this.indexBuffer = buffer;
   }
   /** Set a location in vertex attributes array to a buffer, enables the location, sets divisor */
   setBuffer(location, attributeBuffer) {
     const buffer = attributeBuffer;
-    if (buffer.glTarget === import_constants24.GL.ELEMENT_ARRAY_BUFFER) {
+    if (buffer.glTarget === 34963) {
       throw new Error("Use .setIndexBuffer()");
     }
     const { size, type, stride, offset, normalized, integer, divisor } = this._getAccessor(location);
     this.device.gl.bindVertexArray(this.handle);
-    this.device.gl.bindBuffer(import_constants24.GL.ARRAY_BUFFER, buffer.handle);
+    this.device.gl.bindBuffer(34962, buffer.handle);
     if (integer) {
       this.device.gl.vertexAttribIPointer(location, size, type, stride, offset);
     } else {
@@ -4575,7 +4463,7 @@ var WEBGLVertexArray = class extends import_core23.VertexArray {
     this.device.gl.bindVertexArray(this.handle);
     if (!this.init) {
       const webglBuffer = this.indexBuffer;
-      this.device.gl.bindBuffer(import_constants24.GL.ELEMENT_ARRAY_BUFFER, (webglBuffer == null ? void 0 : webglBuffer.handle) || null);
+      this.device.gl.bindBuffer(34963, (webglBuffer == null ? void 0 : webglBuffer.handle) || null);
       this.init = true;
     }
     this._applyConstantAttributes();
@@ -4672,8 +4560,8 @@ var WEBGLVertexArray = class extends import_core23.VertexArray {
     this.buffer = this.buffer || this.device.createBuffer({ 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_core21.getScratchArray)(value.constructor, length);
+      (0, import_core21.fillArray)({ target: typedArray, source: constantValue, start: 0, count: length });
       this.buffer.write(typedArray);
       this.bufferValue = value;
     }
@@ -4699,9 +4587,9 @@ function compareConstantArrayValues(v1, v2) {
 }
 
 // dist/adapter/resources/webgl-transform-feedback.js
-var import_core24 = require("@luma.gl/core");
-var import_constants25 = require("@luma.gl/constants");
-var WEBGLTransformFeedback = class extends import_core24.TransformFeedback {
+var import_core22 = require("@luma.gl/core");
+var import_constants24 = require("@luma.gl/constants");
+var WEBGLTransformFeedback = class extends import_core22.TransformFeedback {
   device;
   gl;
   handle;
@@ -4736,7 +4624,7 @@ var WEBGLTransformFeedback = class extends import_core24.TransformFeedback {
     super.destroy();
   }
   begin(topology = "point-list") {
-    this.gl.bindTransformFeedback(import_constants25.GL.TRANSFORM_FEEDBACK, this.handle);
+    this.gl.bindTransformFeedback(36386, this.handle);
     if (this.bindOnUse) {
       this._bindBuffers();
     }
@@ -4747,7 +4635,7 @@ var WEBGLTransformFeedback = class extends import_core24.TransformFeedback {
     if (!this.bindOnUse) {
       this._unbindBuffers();
     }
-    this.gl.bindTransformFeedback(import_constants25.GL.TRANSFORM_FEEDBACK, null);
+    this.gl.bindTransformFeedback(36386, null);
   }
   // SUBCLASS
   setBuffers(buffers) {
@@ -4764,7 +4652,7 @@ var WEBGLTransformFeedback = class extends import_core24.TransformFeedback {
     const { buffer, byteLength, byteOffset } = this._getBufferRange(bufferOrRange);
     if (location < 0) {
       this.unusedBuffers[locationOrName] = buffer;
-      import_core24.log.warn(`${this.id} unusedBuffers varying buffer ${locationOrName}`)();
+      import_core22.log.warn(`${this.id} unusedBuffers varying buffer ${locationOrName}`)();
       return;
     }
     this.buffers[location] = { buffer, byteLength, byteOffset };
@@ -4781,16 +4669,16 @@ var WEBGLTransformFeedback = class extends import_core24.TransformFeedback {
   }
   bind(funcOrHandle = this.handle) {
     if (typeof funcOrHandle !== "function") {
-      this.gl.bindTransformFeedback(import_constants25.GL.TRANSFORM_FEEDBACK, funcOrHandle);
+      this.gl.bindTransformFeedback(36386, funcOrHandle);
       return this;
     }
     let value;
     if (!this._bound) {
-      this.gl.bindTransformFeedback(import_constants25.GL.TRANSFORM_FEEDBACK, this.handle);
+      this.gl.bindTransformFeedback(36386, this.handle);
       this._bound = true;
       value = funcOrHandle();
       this._bound = false;
-      this.gl.bindTransformFeedback(import_constants25.GL.TRANSFORM_FEEDBACK, null);
+      this.gl.bindTransformFeedback(36386, null);
     } else {
       value = funcOrHandle();
     }
@@ -4831,15 +4719,15 @@ var WEBGLTransformFeedback = class extends import_core24.TransformFeedback {
   }
   _unbindBuffers() {
     for (const bufferIndex in this.buffers) {
-      this.gl.bindBufferBase(import_constants25.GL.TRANSFORM_FEEDBACK_BUFFER, Number(bufferIndex), null);
+      this.gl.bindBufferBase(35982, Number(bufferIndex), null);
     }
   }
   _bindBuffer(index, buffer, byteOffset = 0, byteLength) {
     const handle = buffer && buffer.handle;
     if (!handle || byteLength === void 0) {
-      this.gl.bindBufferBase(import_constants25.GL.TRANSFORM_FEEDBACK_BUFFER, index, handle);
+      this.gl.bindBufferBase(35982, index, handle);
     } else {
-      this.gl.bindBufferRange(import_constants25.GL.TRANSFORM_FEEDBACK_BUFFER, index, handle, byteOffset, byteLength);
+      this.gl.bindBufferRange(35982, index, handle, byteOffset, byteLength);
     }
   }
 };
@@ -4851,9 +4739,9 @@ function isIndex(value) {
 }
 
 // dist/adapter/resources/webgl-query-set.js
-var import_core25 = require("@luma.gl/core");
-var import_constants26 = require("@luma.gl/constants");
-var WEBGLQuerySet = class extends import_core25.QuerySet {
+var import_core23 = require("@luma.gl/core");
+var import_constants25 = require("@luma.gl/constants");
+var WEBGLQuerySet = class extends import_core23.QuerySet {
   device;
   handle;
   target = null;
@@ -4882,21 +4770,21 @@ var WEBGLQuerySet = class extends import_core25.QuerySet {
    * GPU instruction stream.
    */
   beginTimestampQuery() {
-    return this._begin(import_constants26.GL.TIME_ELAPSED_EXT);
+    return this._begin(35007);
   }
   endTimestampQuery() {
     this._end();
   }
   // Shortcut for occlusion queries
   beginOcclusionQuery(options) {
-    return this._begin((options == null ? void 0 : options.conservative) ? import_constants26.GL.ANY_SAMPLES_PASSED_CONSERVATIVE : import_constants26.GL.ANY_SAMPLES_PASSED);
+    return this._begin((options == null ? void 0 : options.conservative) ? 36202 : 35887);
   }
   endOcclusionQuery() {
     this._end();
   }
   // Shortcut for transformFeedbackQuery
   beginTransformFeedbackQuery() {
-    return this._begin(import_constants26.GL.TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN);
+    return this._begin(35976);
   }
   endTransformFeedbackQuery() {
     this._end();
@@ -4938,7 +4826,7 @@ var WEBGLQuerySet = class extends import_core25.QuerySet {
     if (!this._queryPending) {
       return false;
     }
-    const resultAvailable = this.device.gl.getQueryParameter(this.handle, import_constants26.GL.QUERY_RESULT_AVAILABLE);
+    const resultAvailable = this.device.gl.getQueryParameter(this.handle, 34919);
     if (resultAvailable) {
       this._queryPending = false;
     }
@@ -4946,11 +4834,11 @@ var WEBGLQuerySet = class extends import_core25.QuerySet {
   }
   // Timing query is disjoint, i.e. results are invalid
   isTimerDisjoint() {
-    return this.device.gl.getParameter(import_constants26.GL.GPU_DISJOINT_EXT);
+    return this.device.gl.getParameter(36795);
   }
   // Returns query result.
   getResult() {
-    return this.device.gl.getQueryParameter(this.handle, import_constants26.GL.QUERY_RESULT);
+    return this.device.gl.getQueryParameter(this.handle, 34918);
   }
   // Returns the query result, converted to milliseconds to match JavaScript conventions.
   getTimerMilliseconds() {
@@ -4981,44 +4869,44 @@ var WEBGLQuerySet = class extends import_core25.QuerySet {
 };
 
 // dist/classic/copy-and-blit.js
-var import_core27 = require("@luma.gl/core");
-var import_constants28 = require("@luma.gl/constants");
+var import_core25 = require("@luma.gl/core");
+var import_constants27 = require("@luma.gl/constants");
 
 // dist/classic/format-utils.js
-var import_core26 = require("@luma.gl/core");
-var import_constants27 = require("@luma.gl/constants");
+var import_core24 = require("@luma.gl/core");
+var import_constants26 = require("@luma.gl/constants");
 function glFormatToComponents(format) {
   switch (format) {
-    case import_constants27.GL.ALPHA:
-    case import_constants27.GL.R32F:
-    case import_constants27.GL.RED:
+    case 6406:
+    case 33326:
+    case 6403:
       return 1;
-    case import_constants27.GL.RG32F:
-    case import_constants27.GL.RG:
+    case 33328:
+    case 33319:
       return 2;
-    case import_constants27.GL.RGB:
-    case import_constants27.GL.RGB32F:
+    case 6407:
+    case 34837:
       return 3;
-    case import_constants27.GL.RGBA:
-    case import_constants27.GL.RGBA32F:
+    case 6408:
+    case 34836:
       return 4;
     default:
-      (0, import_core26.assert)(false);
+      (0, import_core24.assert)(false);
       return 0;
   }
 }
 function glTypeToBytes(type) {
   switch (type) {
-    case import_constants27.GL.UNSIGNED_BYTE:
+    case 5121:
       return 1;
-    case import_constants27.GL.UNSIGNED_SHORT_5_6_5:
-    case import_constants27.GL.UNSIGNED_SHORT_4_4_4_4:
-    case import_constants27.GL.UNSIGNED_SHORT_5_5_5_1:
+    case 33635:
+    case 32819:
+    case 32820:
       return 2;
-    case import_constants27.GL.FLOAT:
+    case 5126:
       return 4;
     default:
-      (0, import_core26.assert)(false);
+      (0, import_core24.assert)(false);
       return 0;
   }
 }
@@ -5029,8 +4917,8 @@ function readPixelsToArray(source, options) {
   const {
     sourceX = 0,
     sourceY = 0,
-    sourceFormat = import_constants28.GL.RGBA,
-    sourceAttachment = import_constants28.GL.COLOR_ATTACHMENT0
+    sourceFormat = 6408,
+    sourceAttachment = 36064
     // TODO - support gl.readBuffer
   } = options || {};
   let {
@@ -5041,31 +4929,31 @@ function readPixelsToArray(source, options) {
     sourceType
   } = options || {};
   const { framebuffer, deleteFramebuffer } = getFramebuffer2(source);
-  (0, import_core27.assert)(framebuffer);
+  (0, import_core25.assert)(framebuffer);
   const { gl, handle } = framebuffer;
   sourceWidth = sourceWidth || framebuffer.width;
   sourceHeight = sourceHeight || framebuffer.height;
-  const attachment = sourceAttachment - import_constants28.GL.COLOR_ATTACHMENT0;
-  sourceType = sourceType || ((_b = (_a = framebuffer.colorAttachments[attachment]) == null ? void 0 : _a.texture) == null ? void 0 : _b.type) || import_constants28.GL.UNSIGNED_BYTE;
+  const attachment = sourceAttachment - 36064;
+  sourceType = sourceType || ((_b = (_a = framebuffer.colorAttachments[attachment]) == null ? void 0 : _a.texture) == null ? void 0 : _b.type) || 5121;
   target = getPixelArray(target, sourceType, sourceFormat, sourceWidth, sourceHeight);
   sourceType = sourceType || getGLTypeFromTypedArray(target);
-  const prevHandle = gl.bindFramebuffer(import_constants28.GL.FRAMEBUFFER, handle);
+  const prevHandle = gl.bindFramebuffer(36160, handle);
   gl.readPixels(sourceX, sourceY, sourceWidth, sourceHeight, sourceFormat, sourceType, target);
-  gl.bindFramebuffer(import_constants28.GL.FRAMEBUFFER, prevHandle || null);
+  gl.bindFramebuffer(36160, prevHandle || null);
   if (deleteFramebuffer) {
     framebuffer.destroy();
   }
   return target;
 }
 function readPixelsToBuffer(source, options) {
-  const { target, sourceX = 0, sourceY = 0, sourceFormat = import_constants28.GL.RGBA, targetByteOffset = 0 } = options || {};
+  const { target, sourceX = 0, sourceY = 0, sourceFormat = 6408, targetByteOffset = 0 } = options || {};
   let { sourceWidth, sourceHeight, sourceType } = options || {};
   const { framebuffer, deleteFramebuffer } = getFramebuffer2(source);
-  (0, import_core27.assert)(framebuffer);
+  (0, import_core25.assert)(framebuffer);
   sourceWidth = sourceWidth || framebuffer.width;
   sourceHeight = sourceHeight || framebuffer.height;
   const webglFramebuffer = framebuffer;
-  sourceType = sourceType || import_constants28.GL.UNSIGNED_BYTE;
+  sourceType = sourceType || 5121;
   let webglBufferTarget = target;
   if (!webglBufferTarget) {
     const components = glFormatToComponents(sourceFormat);
@@ -5089,7 +4977,7 @@ function readPixelsToBuffer(source, options) {
   return webglBufferTarget;
 }
 function getFramebuffer2(source) {
-  if (!(source instanceof import_core27.Framebuffer)) {
+  if (!(source instanceof import_core25.Framebuffer)) {
     return { framebuffer: toFramebuffer(source), deleteFramebuffer: true };
   }
   return { framebuffer: source, deleteFramebuffer: false };
@@ -5109,14 +4997,14 @@ function getPixelArray(pixelArray, type, format, width, height) {
   if (pixelArray) {
     return pixelArray;
   }
-  type = type || import_constants28.GL.UNSIGNED_BYTE;
+  type = type || 5121;
   const ArrayType = getTypedArrayFromGLType(type, { clamped: false });
   const components = glFormatToComponents(format);
   return new ArrayType(width * height * components);
 }
 
 // dist/classic/clear.js
-var import_core28 = require("@luma.gl/core");
+var import_core26 = require("@luma.gl/core");
 var GL_DEPTH_BUFFER_BIT2 = 256;
 var GL_STENCIL_BUFFER_BIT2 = 1024;
 var GL_COLOR_BUFFER_BIT2 = 16384;
@@ -5146,19 +5034,18 @@ function clear(device, options) {
       parameters.clearStencil = depth;
     }
   }
-  (0, import_core28.assert)(clearFlags !== 0, ERR_ARGUMENTS);
-  withGLParameters(device, parameters, () => {
-    const gl = device.gl;
+  (0, import_core26.assert)(clearFlags !== 0, ERR_ARGUMENTS);
+  const gl = device.gl;
+  withGLParameters(gl, parameters, () => {
     gl.clear(clearFlags);
   });
 }
 
 // dist/adapter/webgl-device.js
 var LOG_LEVEL2 = 1;
-var _WebGLDevice = class extends import_core29.Device {
-  static isSupported() {
-    return typeof WebGL2RenderingContext !== "undefined";
-  }
+var _WebGLDevice = class extends import_core27.Device {
+  /** type of this device */
+  type = "webgl";
   /** The underlying WebGL context */
   handle;
   features;
@@ -5170,6 +5057,10 @@ var _WebGLDevice = class extends import_core29.Device {
   //
   // Static methods, expected to be present by `luma.createDevice()`
   //
+  /** Check if WebGL 2 is available */
+  static isSupported() {
+    return typeof WebGL2RenderingContext !== "undefined";
+  }
   /**
    * Get a device instance from a GL context
    * Creates and instruments the device if not already created
@@ -5180,7 +5071,7 @@ var _WebGLDevice = class extends import_core29.Device {
     if (gl instanceof _WebGLDevice) {
       return gl;
     }
-    if ((gl == null ? void 0 : gl.device) instanceof import_core29.Device) {
+    if ((gl == null ? void 0 : gl.device) instanceof import_core27.Device) {
       return gl.device;
     }
     if (!isWebGL(gl)) {
@@ -5190,7 +5081,7 @@ var _WebGLDevice = class extends import_core29.Device {
   }
   static async create(props = {}) {
     var _a;
-    import_core29.log.groupCollapsed(LOG_LEVEL2, "WebGLDevice created")();
+    import_core27.log.groupCollapsed(LOG_LEVEL2, "WebGLDevice created")();
     const promises = [];
     if (props.debug) {
       promises.push(loadWebGLDeveloperTools());
@@ -5199,18 +5090,24 @@ var _WebGLDevice = class extends import_core29.Device {
       promises.push(loadSpectorJS());
     }
     if (typeof props.canvas === "string") {
-      promises.push(import_core29.CanvasContext.pageLoaded);
+      promises.push(import_core27.CanvasContext.pageLoaded);
     }
-    await Promise.all(promises);
-    import_core29.log.probe(LOG_LEVEL2 + 1, "DOM is loaded")();
+    const results = await Promise.allSettled(promises);
+    for (const result of results) {
+      if (result.status === "rejected") {
+        import_core27.log.error(`Failed to initialize debug libraries ${result.reason}`)();
+      }
+    }
+    import_core27.log.probe(LOG_LEVEL2 + 1, "DOM is loaded")();
     if ((_a = props.gl) == null ? void 0 : _a.device) {
+      import_core27.log.warn("reattaching existing device")();
       return _WebGLDevice.attach(props.gl);
     }
     const device = new _WebGLDevice(props);
-    const message2 = `Created ${device.info.type}${device.debug ? " debug" : ""} context: ${device.info.vendor}, ${device.info.renderer} for canvas: ${device.canvasContext.id}`;
-    import_core29.log.probe(LOG_LEVEL2, message2)();
-    import_core29.log.table(LOG_LEVEL2, device.info)();
-    import_core29.log.groupEnd(LOG_LEVEL2)();
+    const message2 = `Created ${device.type}${device.debug ? " debug" : ""} context: ${device.info.vendor}, ${device.info.renderer} for canvas: ${device.canvasContext.id}`;
+    import_core27.log.probe(LOG_LEVEL2, message2)();
+    import_core27.log.table(LOG_LEVEL2, device.info)();
+    import_core27.log.groupEnd(LOG_LEVEL2)();
     return device;
   }
   //
@@ -5218,7 +5115,7 @@ var _WebGLDevice = class extends import_core29.Device {
   //
   constructor(props) {
     var _a, _b;
-    super({ ...props, id: props.id || (0, import_core29.uid)("webgl-device") });
+    super({ ...props, id: props.id || (0, import_core27.uid)("webgl-device") });
     const device = (_a = props.gl) == null ? void 0 : _a.device;
     if (device) {
       throw new Error(`WebGL context already attached to device ${device.id}`);
@@ -5247,20 +5144,23 @@ var _WebGLDevice = class extends import_core29.Device {
     this.gl.device = this;
     this.gl._version = 2;
     this.info = getDeviceInfo(this.gl, this._extensions);
-    this.features = new WebGLDeviceFeatures(this.gl, this._extensions);
     this.limits = new WebGLDeviceLimits(this.gl);
+    this.features = new WebGLDeviceFeatures(this.gl, this._extensions, this.props.disabledFeatures);
+    if (this.props.initalizeFeatures) {
+      this.features.initializeFeatures();
+    }
     this.canvasContext.resize();
     const { enable: enable2 = true, copyState = false } = props;
     trackContextState(this.gl, {
       enable: enable2,
       copyState,
-      log: (...args) => import_core29.log.log(1, ...args)()
+      log: (...args) => import_core27.log.log(1, ...args)()
     });
     if (props.debug) {
       this.gl = makeDebugContext(this.gl, { ...props, throwOnError: true });
       this.debug = true;
-      import_core29.log.level = Math.max(import_core29.log.level, 1);
-      import_core29.log.warn("WebGL debug mode activated. Performance reduced.")();
+      import_core27.log.level = Math.max(import_core27.log.level, 1);
+      import_core27.log.warn("WebGL debug mode activated. Performance reduced.")();
     }
     if (props.spector) {
       this.spectorJS = initializeSpectorJS({ ...this.props, canvas: this.handle.canvas });
@@ -5332,12 +5232,6 @@ var _WebGLDevice = class extends import_core29.Device {
     throw new Error("ComputePass not supported in WebGL");
   }
   renderPass = null;
-  getDefaultRenderPass() {
-    this.renderPass = this.renderPass || this.beginRenderPass({
-      framebuffer: this.canvasContext.getCurrentFramebuffer()
-    });
-    return this.renderPass;
-  }
   createCommandEncoder(props) {
     return new WEBGLCommandEncoder(this, props);
   }
@@ -5363,13 +5257,13 @@ var _WebGLDevice = class extends import_core29.Device {
     return readPixelsToBuffer(source, options);
   }
   setParametersWebGL(parameters) {
-    setGLParameters(this, parameters);
+    setGLParameters(this.gl, parameters);
   }
   getParametersWebGL(parameters) {
-    return getGLParameters(this, parameters);
+    return getGLParameters(this.gl, parameters);
   }
   withParametersWebGL(parameters, func) {
-    withGLParameters(this, parameters, func);
+    withGLParameters(this.gl, parameters, func);
   }
   clearWebGL(options) {
     clear(this, options);
@@ -5449,7 +5343,7 @@ var _WebGLDevice = class extends import_core29.Device {
     this._constants = this._constants || new Array(maxVertexAttributes).fill(null);
     const currentConstant = this._constants[location];
     if (currentConstant && compareConstantArrayValues2(currentConstant, constant)) {
-      import_core29.log.info(1, `setConstantAttributeWebGL(${location}) could have been skipped, value unchanged`)();
+      import_core27.log.info(1, `setConstantAttributeWebGL(${location}) could have been skipped, value unchanged`)();
     }
     this._constants[location] = constant;
     switch (constant.constructor) {
@@ -5463,7 +5357,7 @@ var _WebGLDevice = class extends import_core29.Device {
         setConstantUintArray(this, location, constant);
         break;
       default:
-        (0, import_core29.assert)(false);
+        (0, import_core27.assert)(false);
     }
   }
   /** Ensure extensions are only requested once */
@@ -5476,6 +5370,7 @@ var WebGLDevice = _WebGLDevice;
 //
 // Public `Device` API
 //
+/** type of this device */
 __publicField(WebGLDevice, "type", "webgl");
 function isWebGL(gl) {
   if (typeof WebGL2RenderingContext !== "undefined" && gl instanceof WebGL2RenderingContext) {
@@ -5498,7 +5393,7 @@ function setConstantFloatArray(device, location, array) {
       device.gl.vertexAttrib4fv(location, array);
       break;
     default:
-      (0, import_core29.assert)(false);
+      (0, import_core27.assert)(false);
   }
 }
 function setConstantIntArray(device, location, array) {
@@ -5518,4 +5413,174 @@ function compareConstantArrayValues2(v1, v2) {
   }
   return true;
 }
+
+// dist/adapter/objects/webgl-resource.js
+var import_core28 = require("@luma.gl/core");
+var ERR_RESOURCE_METHOD_UNDEFINED = "Resource subclass must define virtual methods";
+var WebGLResource = class extends import_core28.Resource {
+  device;
+  gl;
+  gl2;
+  _handle;
+  _bound = false;
+  // Only meaningful for resources that allocate GPU memory
+  byteLength = 0;
+  constructor(device, props, defaultProps) {
+    super(device, props, defaultProps);
+    this.device = device;
+    const gl = this.device.gl;
+    const { id } = props || {};
+    this.gl = gl;
+    this.gl2 = gl;
+    this.id = id || (0, import_core28.uid)(this.constructor.name);
+    this._handle = props == null ? void 0 : props.handle;
+    if (this._handle === void 0) {
+      this._handle = this._createHandle();
+    }
+    this.byteLength = 0;
+  }
+  toString() {
+    return `${this.constructor.name}(${this.id})`;
+  }
+  get handle() {
+    return this._handle;
+  }
+  delete({ deleteChildren = false } = {}) {
+    const children = this._handle && this._deleteHandle(this._handle);
+    if (this._handle) {
+      this.removeStats();
+    }
+    this._handle = null;
+    if (children && deleteChildren) {
+      children.filter(Boolean).forEach((child) => child.destroy());
+    }
+    return this;
+  }
+  bind(funcOrHandle = this.handle) {
+    if (typeof funcOrHandle !== "function") {
+      this._bindHandle(funcOrHandle);
+      return this;
+    }
+    let value;
+    if (!this._bound) {
+      this._bindHandle(this.handle);
+      this._bound = true;
+      value = funcOrHandle();
+      this._bound = false;
+      this._bindHandle(null);
+    } else {
+      value = funcOrHandle();
+    }
+    return value;
+  }
+  unbind() {
+    this.bind(null);
+  }
+  // Install stubs for removed methods
+  stubRemovedMethods(className, version, methodNames) {
+    return (0, import_core28.stubRemovedMethods)(this, className, version, methodNames);
+  }
+  // PUBLIC VIRTUAL METHODS
+  initialize(props) {
+  }
+  // PROTECTED METHODS - These must be overridden by subclass
+  _createHandle() {
+    throw new Error(ERR_RESOURCE_METHOD_UNDEFINED);
+  }
+  _deleteHandle() {
+    throw new Error(ERR_RESOURCE_METHOD_UNDEFINED);
+  }
+  _bindHandle(handle) {
+    throw new Error(ERR_RESOURCE_METHOD_UNDEFINED);
+  }
+  _getOptsFromHandle() {
+    throw new Error(ERR_RESOURCE_METHOD_UNDEFINED);
+  }
+  _getParameter(pname, props) {
+    throw new Error(ERR_RESOURCE_METHOD_UNDEFINED);
+  }
+  _setParameter(pname, value) {
+    throw new Error(ERR_RESOURCE_METHOD_UNDEFINED);
+  }
+};
+
+// dist/adapter/objects/webgl-renderbuffer.js
+var import_core29 = require("@luma.gl/core");
+var import_constants28 = require("@luma.gl/constants");
+var _WEBGLRenderbuffer = class extends WebGLResource {
+  get [Symbol.toStringTag]() {
+    return "Renderbuffer";
+  }
+  get width() {
+    return this.props.width;
+  }
+  get height() {
+    return this.props.height;
+  }
+  get format() {
+    return this.props.format;
+  }
+  get samples() {
+    return this.props.samples;
+  }
+  get attachment() {
+    return;
+  }
+  /** WebGL format constant */
+  glFormat;
+  static isTextureFormatSupported(device, format) {
+    return isRenderbufferFormatSupported(device.gl, format, device._extensions);
+  }
+  constructor(device, props) {
+    if (typeof props.format === "number") {
+      throw new Error("Renderbuffer");
+    }
+    super(device, props, _WEBGLRenderbuffer.defaultProps);
+    this.glFormat = convertTextureFormatToGL(this.props.format);
+    this._initialize(this.props);
+  }
+  resize(size) {
+    if (size.width !== this.width || size.height !== this.height) {
+      Object.assign(this.props, { ...size, format: this.format, samples: this.samples });
+      this._initialize(this.props);
+    }
+  }
+  // PRIVATE METHODS
+  /** Creates and initializes a renderbuffer object's data store */
+  _initialize(props) {
+    const { format, width, height, samples } = props;
+    (0, import_core29.assert)(format, "Needs format");
+    this.trackDeallocatedMemory();
+    this.gl.bindRenderbuffer(36161, this.handle);
+    if (samples !== 0) {
+      this.gl.renderbufferStorageMultisample(36161, samples, this.glFormat, width, height);
+    } else {
+      this.gl.renderbufferStorage(36161, this.glFormat, width, height);
+    }
+    this.gl.bindRenderbuffer(36161, null);
+    this.trackAllocatedMemory(width * height * (samples || 1) * getTextureFormatBytesPerPixel(this.format));
+  }
+  // RESOURCE IMPLEMENTATION
+  _createHandle() {
+    return this.gl.createRenderbuffer();
+  }
+  _deleteHandle() {
+    this.gl.deleteRenderbuffer(this.handle);
+    this.trackDeallocatedMemory();
+  }
+  _bindHandle(handle) {
+    this.gl.bindRenderbuffer(36161, handle);
+  }
+};
+var WEBGLRenderbuffer = _WEBGLRenderbuffer;
+__publicField(WEBGLRenderbuffer, "defaultProps", {
+  id: void 0,
+  handle: void 0,
+  userData: void 0,
+  format: void 0,
+  // 'depth16unorm'
+  width: 1,
+  height: 1,
+  samples: 0
+});
 //# sourceMappingURL=index.cjs.map