@luma.gl/webgl 9.0.0-alpha.21 → 9.0.0-alpha.23

package/dist/index.cjs

@@ -83,9 +83,11 @@ __export(src_exports, {
   WebGLCanvasContext: () => WebGLCanvasContext,
   WebGLDevice: () => WebGLDevice,
   WebGLResource: () => WebGLResource,
+  _TEXTURE_FORMATS: () => TEXTURE_FORMATS,
   _checkFloat32ColorAttachment: () => _checkFloat32ColorAttachment,
   assertWebGL2Context: () => assertWebGL2Context,
   assertWebGLContext: () => assertWebGLContext,
+  convertGLToTextureFormat: () => convertGLToTextureFormat,
   getParameters: () => getParameters,
   getProgramBindings: () => getProgramBindings,
   getShaderLayout: () => getShaderLayout,
@@ -138,7 +140,7 @@ function createHeadlessContext(options) {
 }
 
 // src/adapter/webgl-device.ts
-var import_api24 = require("@luma.gl/api");
+var import_api26 = require("@luma.gl/api");
 var import_env2 = require("@probe.gl/env");
 
 // src/context/polyfill/polyfill-context.ts
@@ -781,109 +783,109 @@ function installOverrides(gl, { target, target2 }) {
 var import_api4 = require("@luma.gl/api");
 
 // src/context/parameters/webgl-parameter-tables.ts
-var import_constants3 = __toESM(require("@luma.gl/constants"), 1);
+var import_constants3 = require("@luma.gl/constants");
 var GL_PARAMETER_DEFAULTS = {
-  [import_constants3.default.BLEND]: false,
-  [import_constants3.default.BLEND_COLOR]: new Float32Array([0, 0, 0, 0]),
-  [import_constants3.default.BLEND_EQUATION_RGB]: import_constants3.default.FUNC_ADD,
-  [import_constants3.default.BLEND_EQUATION_ALPHA]: import_constants3.default.FUNC_ADD,
-  [import_constants3.default.BLEND_SRC_RGB]: import_constants3.default.ONE,
-  [import_constants3.default.BLEND_DST_RGB]: import_constants3.default.ZERO,
-  [import_constants3.default.BLEND_SRC_ALPHA]: import_constants3.default.ONE,
-  [import_constants3.default.BLEND_DST_ALPHA]: import_constants3.default.ZERO,
-  [import_constants3.default.COLOR_CLEAR_VALUE]: new Float32Array([0, 0, 0, 0]),
+  [import_constants3.GL.BLEND]: false,
+  [import_constants3.GL.BLEND_COLOR]: new Float32Array([0, 0, 0, 0]),
+  [import_constants3.GL.BLEND_EQUATION_RGB]: import_constants3.GL.FUNC_ADD,
+  [import_constants3.GL.BLEND_EQUATION_ALPHA]: import_constants3.GL.FUNC_ADD,
+  [import_constants3.GL.BLEND_SRC_RGB]: import_constants3.GL.ONE,
+  [import_constants3.GL.BLEND_DST_RGB]: import_constants3.GL.ZERO,
+  [import_constants3.GL.BLEND_SRC_ALPHA]: import_constants3.GL.ONE,
+  [import_constants3.GL.BLEND_DST_ALPHA]: import_constants3.GL.ZERO,
+  [import_constants3.GL.COLOR_CLEAR_VALUE]: new Float32Array([0, 0, 0, 0]),
   // TBD
-  [import_constants3.default.COLOR_WRITEMASK]: [true, true, true, true],
-  [import_constants3.default.CULL_FACE]: false,
-  [import_constants3.default.CULL_FACE_MODE]: import_constants3.default.BACK,
-  [import_constants3.default.DEPTH_TEST]: false,
-  [import_constants3.default.DEPTH_CLEAR_VALUE]: 1,
-  [import_constants3.default.DEPTH_FUNC]: import_constants3.default.LESS,
-  [import_constants3.default.DEPTH_RANGE]: new Float32Array([0, 1]),
+  [import_constants3.GL.COLOR_WRITEMASK]: [true, true, true, true],
+  [import_constants3.GL.CULL_FACE]: false,
+  [import_constants3.GL.CULL_FACE_MODE]: import_constants3.GL.BACK,
+  [import_constants3.GL.DEPTH_TEST]: false,
+  [import_constants3.GL.DEPTH_CLEAR_VALUE]: 1,
+  [import_constants3.GL.DEPTH_FUNC]: import_constants3.GL.LESS,
+  [import_constants3.GL.DEPTH_RANGE]: new Float32Array([0, 1]),
   // TBD
-  [import_constants3.default.DEPTH_WRITEMASK]: true,
-  [import_constants3.default.DITHER]: true,
-  [import_constants3.default.CURRENT_PROGRAM]: null,
+  [import_constants3.GL.DEPTH_WRITEMASK]: true,
+  [import_constants3.GL.DITHER]: true,
+  [import_constants3.GL.CURRENT_PROGRAM]: null,
   // FRAMEBUFFER_BINDING and DRAW_FRAMEBUFFER_BINDING(WebGL2) refer same state.
-  [import_constants3.default.FRAMEBUFFER_BINDING]: null,
-  [import_constants3.default.RENDERBUFFER_BINDING]: null,
-  [import_constants3.default.VERTEX_ARRAY_BINDING]: null,
-  [import_constants3.default.ARRAY_BUFFER_BINDING]: null,
-  [import_constants3.default.FRONT_FACE]: import_constants3.default.CCW,
-  [import_constants3.default.GENERATE_MIPMAP_HINT]: import_constants3.default.DONT_CARE,
-  [import_constants3.default.LINE_WIDTH]: 1,
-  [import_constants3.default.POLYGON_OFFSET_FILL]: false,
-  [import_constants3.default.POLYGON_OFFSET_FACTOR]: 0,
-  [import_constants3.default.POLYGON_OFFSET_UNITS]: 0,
-  [import_constants3.default.SAMPLE_ALPHA_TO_COVERAGE]: false,
-  [import_constants3.default.SAMPLE_COVERAGE]: false,
-  [import_constants3.default.SAMPLE_COVERAGE_VALUE]: 1,
-  [import_constants3.default.SAMPLE_COVERAGE_INVERT]: false,
-  [import_constants3.default.SCISSOR_TEST]: false,
+  [import_constants3.GL.FRAMEBUFFER_BINDING]: null,
+  [import_constants3.GL.RENDERBUFFER_BINDING]: null,
+  [import_constants3.GL.VERTEX_ARRAY_BINDING]: null,
+  [import_constants3.GL.ARRAY_BUFFER_BINDING]: null,
+  [import_constants3.GL.FRONT_FACE]: import_constants3.GL.CCW,
+  [import_constants3.GL.GENERATE_MIPMAP_HINT]: import_constants3.GL.DONT_CARE,
+  [import_constants3.GL.LINE_WIDTH]: 1,
+  [import_constants3.GL.POLYGON_OFFSET_FILL]: false,
+  [import_constants3.GL.POLYGON_OFFSET_FACTOR]: 0,
+  [import_constants3.GL.POLYGON_OFFSET_UNITS]: 0,
+  [import_constants3.GL.SAMPLE_ALPHA_TO_COVERAGE]: false,
+  [import_constants3.GL.SAMPLE_COVERAGE]: false,
+  [import_constants3.GL.SAMPLE_COVERAGE_VALUE]: 1,
+  [import_constants3.GL.SAMPLE_COVERAGE_INVERT]: false,
+  [import_constants3.GL.SCISSOR_TEST]: false,
   // Note: Dynamic value. If scissor test enabled we expect users to set correct scissor box
-  [import_constants3.default.SCISSOR_BOX]: new Int32Array([0, 0, 1024, 1024]),
-  [import_constants3.default.STENCIL_TEST]: false,
-  [import_constants3.default.STENCIL_CLEAR_VALUE]: 0,
-  [import_constants3.default.STENCIL_WRITEMASK]: 4294967295,
-  [import_constants3.default.STENCIL_BACK_WRITEMASK]: 4294967295,
-  [import_constants3.default.STENCIL_FUNC]: import_constants3.default.ALWAYS,
-  [import_constants3.default.STENCIL_REF]: 0,
-  [import_constants3.default.STENCIL_VALUE_MASK]: 4294967295,
-  [import_constants3.default.STENCIL_BACK_FUNC]: import_constants3.default.ALWAYS,
-  [import_constants3.default.STENCIL_BACK_REF]: 0,
-  [import_constants3.default.STENCIL_BACK_VALUE_MASK]: 4294967295,
-  [import_constants3.default.STENCIL_FAIL]: import_constants3.default.KEEP,
-  [import_constants3.default.STENCIL_PASS_DEPTH_FAIL]: import_constants3.default.KEEP,
-  [import_constants3.default.STENCIL_PASS_DEPTH_PASS]: import_constants3.default.KEEP,
-  [import_constants3.default.STENCIL_BACK_FAIL]: import_constants3.default.KEEP,
-  [import_constants3.default.STENCIL_BACK_PASS_DEPTH_FAIL]: import_constants3.default.KEEP,
-  [import_constants3.default.STENCIL_BACK_PASS_DEPTH_PASS]: import_constants3.default.KEEP,
+  [import_constants3.GL.SCISSOR_BOX]: new Int32Array([0, 0, 1024, 1024]),
+  [import_constants3.GL.STENCIL_TEST]: false,
+  [import_constants3.GL.STENCIL_CLEAR_VALUE]: 0,
+  [import_constants3.GL.STENCIL_WRITEMASK]: 4294967295,
+  [import_constants3.GL.STENCIL_BACK_WRITEMASK]: 4294967295,
+  [import_constants3.GL.STENCIL_FUNC]: import_constants3.GL.ALWAYS,
+  [import_constants3.GL.STENCIL_REF]: 0,
+  [import_constants3.GL.STENCIL_VALUE_MASK]: 4294967295,
+  [import_constants3.GL.STENCIL_BACK_FUNC]: import_constants3.GL.ALWAYS,
+  [import_constants3.GL.STENCIL_BACK_REF]: 0,
+  [import_constants3.GL.STENCIL_BACK_VALUE_MASK]: 4294967295,
+  [import_constants3.GL.STENCIL_FAIL]: import_constants3.GL.KEEP,
+  [import_constants3.GL.STENCIL_PASS_DEPTH_FAIL]: import_constants3.GL.KEEP,
+  [import_constants3.GL.STENCIL_PASS_DEPTH_PASS]: import_constants3.GL.KEEP,
+  [import_constants3.GL.STENCIL_BACK_FAIL]: import_constants3.GL.KEEP,
+  [import_constants3.GL.STENCIL_BACK_PASS_DEPTH_FAIL]: import_constants3.GL.KEEP,
+  [import_constants3.GL.STENCIL_BACK_PASS_DEPTH_PASS]: import_constants3.GL.KEEP,
   // Dynamic value: We use [0, 0, 1024, 1024] as default, but usually this is updated in each frame.
-  [import_constants3.default.VIEWPORT]: [0, 0, 1024, 1024],
+  [import_constants3.GL.VIEWPORT]: [0, 0, 1024, 1024],
   // WEBGL1 PIXEL PACK/UNPACK MODES
-  [import_constants3.default.PACK_ALIGNMENT]: 4,
-  [import_constants3.default.UNPACK_ALIGNMENT]: 4,
-  [import_constants3.default.UNPACK_FLIP_Y_WEBGL]: false,
-  [import_constants3.default.UNPACK_PREMULTIPLY_ALPHA_WEBGL]: false,
-  [import_constants3.default.UNPACK_COLORSPACE_CONVERSION_WEBGL]: import_constants3.default.BROWSER_DEFAULT_WEBGL,
+  [import_constants3.GL.PACK_ALIGNMENT]: 4,
+  [import_constants3.GL.UNPACK_ALIGNMENT]: 4,
+  [import_constants3.GL.UNPACK_FLIP_Y_WEBGL]: false,
+  [import_constants3.GL.UNPACK_PREMULTIPLY_ALPHA_WEBGL]: false,
+  [import_constants3.GL.UNPACK_COLORSPACE_CONVERSION_WEBGL]: import_constants3.GL.BROWSER_DEFAULT_WEBGL,
   // WEBGL2 / EXTENSIONS
   // gl1: 'OES_standard_derivatives'
-  [import_constants3.default.TRANSFORM_FEEDBACK_BINDING]: null,
-  [import_constants3.default.COPY_READ_BUFFER_BINDING]: null,
-  [import_constants3.default.COPY_WRITE_BUFFER_BINDING]: null,
-  [import_constants3.default.PIXEL_PACK_BUFFER_BINDING]: null,
-  [import_constants3.default.PIXEL_UNPACK_BUFFER_BINDING]: null,
-  [import_constants3.default.FRAGMENT_SHADER_DERIVATIVE_HINT]: import_constants3.default.DONT_CARE,
-  [import_constants3.default.READ_FRAMEBUFFER_BINDING]: null,
-  [import_constants3.default.RASTERIZER_DISCARD]: false,
-  [import_constants3.default.PACK_ROW_LENGTH]: 0,
-  [import_constants3.default.PACK_SKIP_PIXELS]: 0,
-  [import_constants3.default.PACK_SKIP_ROWS]: 0,
-  [import_constants3.default.UNPACK_ROW_LENGTH]: 0,
-  [import_constants3.default.UNPACK_IMAGE_HEIGHT]: 0,
-  [import_constants3.default.UNPACK_SKIP_PIXELS]: 0,
-  [import_constants3.default.UNPACK_SKIP_ROWS]: 0,
-  [import_constants3.default.UNPACK_SKIP_IMAGES]: 0
+  [import_constants3.GL.TRANSFORM_FEEDBACK_BINDING]: null,
+  [import_constants3.GL.COPY_READ_BUFFER_BINDING]: null,
+  [import_constants3.GL.COPY_WRITE_BUFFER_BINDING]: null,
+  [import_constants3.GL.PIXEL_PACK_BUFFER_BINDING]: null,
+  [import_constants3.GL.PIXEL_UNPACK_BUFFER_BINDING]: null,
+  [import_constants3.GL.FRAGMENT_SHADER_DERIVATIVE_HINT]: import_constants3.GL.DONT_CARE,
+  [import_constants3.GL.READ_FRAMEBUFFER_BINDING]: null,
+  [import_constants3.GL.RASTERIZER_DISCARD]: false,
+  [import_constants3.GL.PACK_ROW_LENGTH]: 0,
+  [import_constants3.GL.PACK_SKIP_PIXELS]: 0,
+  [import_constants3.GL.PACK_SKIP_ROWS]: 0,
+  [import_constants3.GL.UNPACK_ROW_LENGTH]: 0,
+  [import_constants3.GL.UNPACK_IMAGE_HEIGHT]: 0,
+  [import_constants3.GL.UNPACK_SKIP_PIXELS]: 0,
+  [import_constants3.GL.UNPACK_SKIP_ROWS]: 0,
+  [import_constants3.GL.UNPACK_SKIP_IMAGES]: 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) => {
   let target;
-  if (key === import_constants3.default.FRAMEBUFFER_BINDING) {
-    target = isWebGL2(gl) ? import_constants3.default.DRAW_FRAMEBUFFER : import_constants3.default.FRAMEBUFFER;
+  if (key === import_constants3.GL.FRAMEBUFFER_BINDING) {
+    target = isWebGL2(gl) ? import_constants3.GL.DRAW_FRAMEBUFFER : import_constants3.GL.FRAMEBUFFER;
   } else {
-    target = import_constants3.default.READ_FRAMEBUFFER;
+    target = import_constants3.GL.READ_FRAMEBUFFER;
   }
   return gl.bindFramebuffer(target, value);
 };
 var bindBuffer = (gl, value, key) => {
   const bindingMap = {
-    [import_constants3.default.ARRAY_BUFFER_BINDING]: import_constants3.default.ARRAY_BUFFER,
-    [import_constants3.default.COPY_READ_BUFFER_BINDING]: import_constants3.default.COPY_READ_BUFFER,
-    [import_constants3.default.COPY_WRITE_BUFFER_BINDING]: import_constants3.default.COPY_WRITE_BUFFER,
-    [import_constants3.default.PIXEL_PACK_BUFFER_BINDING]: import_constants3.default.PIXEL_PACK_BUFFER,
-    [import_constants3.default.PIXEL_UNPACK_BUFFER_BINDING]: import_constants3.default.PIXEL_UNPACK_BUFFER
+    [import_constants3.GL.ARRAY_BUFFER_BINDING]: import_constants3.GL.ARRAY_BUFFER,
+    [import_constants3.GL.COPY_READ_BUFFER_BINDING]: import_constants3.GL.COPY_READ_BUFFER,
+    [import_constants3.GL.COPY_WRITE_BUFFER_BINDING]: import_constants3.GL.COPY_WRITE_BUFFER,
+    [import_constants3.GL.PIXEL_PACK_BUFFER_BINDING]: import_constants3.GL.PIXEL_PACK_BUFFER,
+    [import_constants3.GL.PIXEL_UNPACK_BUFFER_BINDING]: import_constants3.GL.PIXEL_UNPACK_BUFFER
   };
   const target = bindingMap[key];
   gl.bindBuffer(target, value);
@@ -892,93 +894,93 @@ function isArray(array) {
   return Array.isArray(array) || ArrayBuffer.isView(array) && !(array instanceof DataView);
 }
 var GL_PARAMETER_SETTERS = {
-  [import_constants3.default.BLEND]: enable,
-  [import_constants3.default.BLEND_COLOR]: (gl, value) => gl.blendColor(...value),
-  [import_constants3.default.BLEND_EQUATION_RGB]: "blendEquation",
-  [import_constants3.default.BLEND_EQUATION_ALPHA]: "blendEquation",
-  [import_constants3.default.BLEND_SRC_RGB]: "blendFunc",
-  [import_constants3.default.BLEND_DST_RGB]: "blendFunc",
-  [import_constants3.default.BLEND_SRC_ALPHA]: "blendFunc",
-  [import_constants3.default.BLEND_DST_ALPHA]: "blendFunc",
-  [import_constants3.default.COLOR_CLEAR_VALUE]: (gl, value) => gl.clearColor(...value),
-  [import_constants3.default.COLOR_WRITEMASK]: (gl, value) => gl.colorMask(...value),
-  [import_constants3.default.CULL_FACE]: enable,
-  [import_constants3.default.CULL_FACE_MODE]: (gl, value) => gl.cullFace(value),
-  [import_constants3.default.DEPTH_TEST]: enable,
-  [import_constants3.default.DEPTH_CLEAR_VALUE]: (gl, value) => gl.clearDepth(value),
-  [import_constants3.default.DEPTH_FUNC]: (gl, value) => gl.depthFunc(value),
-  [import_constants3.default.DEPTH_RANGE]: (gl, value) => gl.depthRange(...value),
-  [import_constants3.default.DEPTH_WRITEMASK]: (gl, value) => gl.depthMask(value),
-  [import_constants3.default.DITHER]: enable,
-  [import_constants3.default.FRAGMENT_SHADER_DERIVATIVE_HINT]: hint,
-  [import_constants3.default.CURRENT_PROGRAM]: (gl, value) => gl.useProgram(value),
-  [import_constants3.default.RENDERBUFFER_BINDING]: (gl, value) => gl.bindRenderbuffer(import_constants3.default.RENDERBUFFER, value),
-  [import_constants3.default.TRANSFORM_FEEDBACK_BINDING]: (gl, value) => {
+  [import_constants3.GL.BLEND]: enable,
+  [import_constants3.GL.BLEND_COLOR]: (gl, value) => gl.blendColor(...value),
+  [import_constants3.GL.BLEND_EQUATION_RGB]: "blendEquation",
+  [import_constants3.GL.BLEND_EQUATION_ALPHA]: "blendEquation",
+  [import_constants3.GL.BLEND_SRC_RGB]: "blendFunc",
+  [import_constants3.GL.BLEND_DST_RGB]: "blendFunc",
+  [import_constants3.GL.BLEND_SRC_ALPHA]: "blendFunc",
+  [import_constants3.GL.BLEND_DST_ALPHA]: "blendFunc",
+  [import_constants3.GL.COLOR_CLEAR_VALUE]: (gl, value) => gl.clearColor(...value),
+  [import_constants3.GL.COLOR_WRITEMASK]: (gl, value) => gl.colorMask(...value),
+  [import_constants3.GL.CULL_FACE]: enable,
+  [import_constants3.GL.CULL_FACE_MODE]: (gl, value) => gl.cullFace(value),
+  [import_constants3.GL.DEPTH_TEST]: enable,
+  [import_constants3.GL.DEPTH_CLEAR_VALUE]: (gl, value) => gl.clearDepth(value),
+  [import_constants3.GL.DEPTH_FUNC]: (gl, value) => gl.depthFunc(value),
+  [import_constants3.GL.DEPTH_RANGE]: (gl, value) => gl.depthRange(...value),
+  [import_constants3.GL.DEPTH_WRITEMASK]: (gl, value) => gl.depthMask(value),
+  [import_constants3.GL.DITHER]: enable,
+  [import_constants3.GL.FRAGMENT_SHADER_DERIVATIVE_HINT]: hint,
+  [import_constants3.GL.CURRENT_PROGRAM]: (gl, value) => gl.useProgram(value),
+  [import_constants3.GL.RENDERBUFFER_BINDING]: (gl, value) => gl.bindRenderbuffer(import_constants3.GL.RENDERBUFFER, value),
+  [import_constants3.GL.TRANSFORM_FEEDBACK_BINDING]: (gl, value) => {
     var _a;
-    return (_a = gl.bindTransformFeedback) == null ? void 0 : _a.call(gl, import_constants3.default.TRANSFORM_FEEDBACK, value);
+    return (_a = gl.bindTransformFeedback) == null ? void 0 : _a.call(gl, import_constants3.GL.TRANSFORM_FEEDBACK, value);
   },
-  [import_constants3.default.VERTEX_ARRAY_BINDING]: (gl, value) => gl.bindVertexArray(value),
+  [import_constants3.GL.VERTEX_ARRAY_BINDING]: (gl, value) => gl.bindVertexArray(value),
   // NOTE: FRAMEBUFFER_BINDING and DRAW_FRAMEBUFFER_BINDING(WebGL2) refer same state.
-  [import_constants3.default.FRAMEBUFFER_BINDING]: bindFramebuffer,
-  [import_constants3.default.READ_FRAMEBUFFER_BINDING]: bindFramebuffer,
+  [import_constants3.GL.FRAMEBUFFER_BINDING]: bindFramebuffer,
+  [import_constants3.GL.READ_FRAMEBUFFER_BINDING]: bindFramebuffer,
   // Buffers
-  [import_constants3.default.ARRAY_BUFFER_BINDING]: bindBuffer,
-  [import_constants3.default.COPY_READ_BUFFER_BINDING]: bindBuffer,
-  [import_constants3.default.COPY_WRITE_BUFFER_BINDING]: bindBuffer,
-  [import_constants3.default.PIXEL_PACK_BUFFER_BINDING]: bindBuffer,
-  [import_constants3.default.PIXEL_UNPACK_BUFFER_BINDING]: bindBuffer,
-  [import_constants3.default.FRONT_FACE]: (gl, value) => gl.frontFace(value),
-  [import_constants3.default.GENERATE_MIPMAP_HINT]: hint,
-  [import_constants3.default.LINE_WIDTH]: (gl, value) => gl.lineWidth(value),
-  [import_constants3.default.POLYGON_OFFSET_FILL]: enable,
-  [import_constants3.default.POLYGON_OFFSET_FACTOR]: "polygonOffset",
-  [import_constants3.default.POLYGON_OFFSET_UNITS]: "polygonOffset",
-  [import_constants3.default.RASTERIZER_DISCARD]: enable,
-  [import_constants3.default.SAMPLE_ALPHA_TO_COVERAGE]: enable,
-  [import_constants3.default.SAMPLE_COVERAGE]: enable,
-  [import_constants3.default.SAMPLE_COVERAGE_VALUE]: "sampleCoverage",
-  [import_constants3.default.SAMPLE_COVERAGE_INVERT]: "sampleCoverage",
-  [import_constants3.default.SCISSOR_TEST]: enable,
-  [import_constants3.default.SCISSOR_BOX]: (gl, value) => gl.scissor(...value),
-  [import_constants3.default.STENCIL_TEST]: enable,
-  [import_constants3.default.STENCIL_CLEAR_VALUE]: (gl, value) => gl.clearStencil(value),
-  [import_constants3.default.STENCIL_WRITEMASK]: (gl, value) => gl.stencilMaskSeparate(import_constants3.default.FRONT, value),
-  [import_constants3.default.STENCIL_BACK_WRITEMASK]: (gl, value) => gl.stencilMaskSeparate(import_constants3.default.BACK, value),
-  [import_constants3.default.STENCIL_FUNC]: "stencilFuncFront",
-  [import_constants3.default.STENCIL_REF]: "stencilFuncFront",
-  [import_constants3.default.STENCIL_VALUE_MASK]: "stencilFuncFront",
-  [import_constants3.default.STENCIL_BACK_FUNC]: "stencilFuncBack",
-  [import_constants3.default.STENCIL_BACK_REF]: "stencilFuncBack",
-  [import_constants3.default.STENCIL_BACK_VALUE_MASK]: "stencilFuncBack",
-  [import_constants3.default.STENCIL_FAIL]: "stencilOpFront",
-  [import_constants3.default.STENCIL_PASS_DEPTH_FAIL]: "stencilOpFront",
-  [import_constants3.default.STENCIL_PASS_DEPTH_PASS]: "stencilOpFront",
-  [import_constants3.default.STENCIL_BACK_FAIL]: "stencilOpBack",
-  [import_constants3.default.STENCIL_BACK_PASS_DEPTH_FAIL]: "stencilOpBack",
-  [import_constants3.default.STENCIL_BACK_PASS_DEPTH_PASS]: "stencilOpBack",
-  [import_constants3.default.VIEWPORT]: (gl, value) => gl.viewport(...value),
+  [import_constants3.GL.ARRAY_BUFFER_BINDING]: bindBuffer,
+  [import_constants3.GL.COPY_READ_BUFFER_BINDING]: bindBuffer,
+  [import_constants3.GL.COPY_WRITE_BUFFER_BINDING]: bindBuffer,
+  [import_constants3.GL.PIXEL_PACK_BUFFER_BINDING]: bindBuffer,
+  [import_constants3.GL.PIXEL_UNPACK_BUFFER_BINDING]: bindBuffer,
+  [import_constants3.GL.FRONT_FACE]: (gl, value) => gl.frontFace(value),
+  [import_constants3.GL.GENERATE_MIPMAP_HINT]: hint,
+  [import_constants3.GL.LINE_WIDTH]: (gl, value) => gl.lineWidth(value),
+  [import_constants3.GL.POLYGON_OFFSET_FILL]: enable,
+  [import_constants3.GL.POLYGON_OFFSET_FACTOR]: "polygonOffset",
+  [import_constants3.GL.POLYGON_OFFSET_UNITS]: "polygonOffset",
+  [import_constants3.GL.RASTERIZER_DISCARD]: enable,
+  [import_constants3.GL.SAMPLE_ALPHA_TO_COVERAGE]: enable,
+  [import_constants3.GL.SAMPLE_COVERAGE]: enable,
+  [import_constants3.GL.SAMPLE_COVERAGE_VALUE]: "sampleCoverage",
+  [import_constants3.GL.SAMPLE_COVERAGE_INVERT]: "sampleCoverage",
+  [import_constants3.GL.SCISSOR_TEST]: enable,
+  [import_constants3.GL.SCISSOR_BOX]: (gl, value) => gl.scissor(...value),
+  [import_constants3.GL.STENCIL_TEST]: enable,
+  [import_constants3.GL.STENCIL_CLEAR_VALUE]: (gl, value) => gl.clearStencil(value),
+  [import_constants3.GL.STENCIL_WRITEMASK]: (gl, value) => gl.stencilMaskSeparate(import_constants3.GL.FRONT, value),
+  [import_constants3.GL.STENCIL_BACK_WRITEMASK]: (gl, value) => gl.stencilMaskSeparate(import_constants3.GL.BACK, value),
+  [import_constants3.GL.STENCIL_FUNC]: "stencilFuncFront",
+  [import_constants3.GL.STENCIL_REF]: "stencilFuncFront",
+  [import_constants3.GL.STENCIL_VALUE_MASK]: "stencilFuncFront",
+  [import_constants3.GL.STENCIL_BACK_FUNC]: "stencilFuncBack",
+  [import_constants3.GL.STENCIL_BACK_REF]: "stencilFuncBack",
+  [import_constants3.GL.STENCIL_BACK_VALUE_MASK]: "stencilFuncBack",
+  [import_constants3.GL.STENCIL_FAIL]: "stencilOpFront",
+  [import_constants3.GL.STENCIL_PASS_DEPTH_FAIL]: "stencilOpFront",
+  [import_constants3.GL.STENCIL_PASS_DEPTH_PASS]: "stencilOpFront",
+  [import_constants3.GL.STENCIL_BACK_FAIL]: "stencilOpBack",
+  [import_constants3.GL.STENCIL_BACK_PASS_DEPTH_FAIL]: "stencilOpBack",
+  [import_constants3.GL.STENCIL_BACK_PASS_DEPTH_PASS]: "stencilOpBack",
+  [import_constants3.GL.VIEWPORT]: (gl, value) => gl.viewport(...value),
   // WEBGL1 PIXEL PACK/UNPACK MODES
-  [import_constants3.default.PACK_ALIGNMENT]: pixelStorei,
-  [import_constants3.default.UNPACK_ALIGNMENT]: pixelStorei,
-  [import_constants3.default.UNPACK_FLIP_Y_WEBGL]: pixelStorei,
-  [import_constants3.default.UNPACK_PREMULTIPLY_ALPHA_WEBGL]: pixelStorei,
-  [import_constants3.default.UNPACK_COLORSPACE_CONVERSION_WEBGL]: pixelStorei,
+  [import_constants3.GL.PACK_ALIGNMENT]: pixelStorei,
+  [import_constants3.GL.UNPACK_ALIGNMENT]: pixelStorei,
+  [import_constants3.GL.UNPACK_FLIP_Y_WEBGL]: pixelStorei,
+  [import_constants3.GL.UNPACK_PREMULTIPLY_ALPHA_WEBGL]: pixelStorei,
+  [import_constants3.GL.UNPACK_COLORSPACE_CONVERSION_WEBGL]: pixelStorei,
   // WEBGL2 PIXEL PACK/UNPACK MODES
   // RASTERIZER_DISCARD ...
-  [import_constants3.default.PACK_ROW_LENGTH]: pixelStorei,
-  [import_constants3.default.PACK_SKIP_PIXELS]: pixelStorei,
-  [import_constants3.default.PACK_SKIP_ROWS]: pixelStorei,
-  [import_constants3.default.UNPACK_ROW_LENGTH]: pixelStorei,
-  [import_constants3.default.UNPACK_IMAGE_HEIGHT]: pixelStorei,
-  [import_constants3.default.UNPACK_SKIP_PIXELS]: pixelStorei,
-  [import_constants3.default.UNPACK_SKIP_ROWS]: pixelStorei,
-  [import_constants3.default.UNPACK_SKIP_IMAGES]: pixelStorei,
+  [import_constants3.GL.PACK_ROW_LENGTH]: pixelStorei,
+  [import_constants3.GL.PACK_SKIP_PIXELS]: pixelStorei,
+  [import_constants3.GL.PACK_SKIP_ROWS]: pixelStorei,
+  [import_constants3.GL.UNPACK_ROW_LENGTH]: pixelStorei,
+  [import_constants3.GL.UNPACK_IMAGE_HEIGHT]: pixelStorei,
+  [import_constants3.GL.UNPACK_SKIP_PIXELS]: pixelStorei,
+  [import_constants3.GL.UNPACK_SKIP_ROWS]: pixelStorei,
+  [import_constants3.GL.UNPACK_SKIP_IMAGES]: pixelStorei,
   // Function-style setters
   framebuffer: (gl, framebuffer) => {
     const handle = framebuffer && "handle" in framebuffer ? framebuffer.handle : framebuffer;
-    return gl.bindFramebuffer(import_constants3.default.FRAMEBUFFER, handle);
+    return gl.bindFramebuffer(import_constants3.GL.FRAMEBUFFER, handle);
   },
-  blend: (gl, value) => value ? gl.enable(import_constants3.default.BLEND) : gl.disable(import_constants3.default.BLEND),
+  blend: (gl, value) => value ? gl.enable(import_constants3.GL.BLEND) : gl.disable(import_constants3.GL.BLEND),
   blendColor: (gl, value) => gl.blendColor(...value),
   blendEquation: (gl, args) => {
     const separateModes = typeof args === "number" ? [args, args] : args;
@@ -992,42 +994,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_constants3.default.CULL_FACE) : gl.disable(import_constants3.default.CULL_FACE),
+  cull: (gl, value) => value ? gl.enable(import_constants3.GL.CULL_FACE) : gl.disable(import_constants3.GL.CULL_FACE),
   cullFace: (gl, value) => gl.cullFace(value),
-  depthTest: (gl, value) => value ? gl.enable(import_constants3.default.DEPTH_TEST) : gl.disable(import_constants3.default.DEPTH_TEST),
+  depthTest: (gl, value) => value ? gl.enable(import_constants3.GL.DEPTH_TEST) : gl.disable(import_constants3.GL.DEPTH_TEST),
   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_constants3.default.DITHER) : gl.disable(import_constants3.default.DITHER),
+  dither: (gl, value) => value ? gl.enable(import_constants3.GL.DITHER) : gl.disable(import_constants3.GL.DITHER),
   derivativeHint: (gl, value) => {
-    gl.hint(import_constants3.default.FRAGMENT_SHADER_DERIVATIVE_HINT, value);
+    gl.hint(import_constants3.GL.FRAGMENT_SHADER_DERIVATIVE_HINT, value);
   },
   frontFace: (gl, value) => gl.frontFace(value),
-  mipmapHint: (gl, value) => gl.hint(import_constants3.default.GENERATE_MIPMAP_HINT, value),
+  mipmapHint: (gl, value) => gl.hint(import_constants3.GL.GENERATE_MIPMAP_HINT, value),
   lineWidth: (gl, value) => gl.lineWidth(value),
-  polygonOffsetFill: (gl, value) => value ? gl.enable(import_constants3.default.POLYGON_OFFSET_FILL) : gl.disable(import_constants3.default.POLYGON_OFFSET_FILL),
+  polygonOffsetFill: (gl, value) => value ? gl.enable(import_constants3.GL.POLYGON_OFFSET_FILL) : gl.disable(import_constants3.GL.POLYGON_OFFSET_FILL),
   polygonOffset: (gl, value) => gl.polygonOffset(...value),
   sampleCoverage: (gl, value) => gl.sampleCoverage(...value),
-  scissorTest: (gl, value) => value ? gl.enable(import_constants3.default.SCISSOR_TEST) : gl.disable(import_constants3.default.SCISSOR_TEST),
+  scissorTest: (gl, value) => value ? gl.enable(import_constants3.GL.SCISSOR_TEST) : gl.disable(import_constants3.GL.SCISSOR_TEST),
   scissor: (gl, value) => gl.scissor(...value),
-  stencilTest: (gl, value) => value ? gl.enable(import_constants3.default.STENCIL_TEST) : gl.disable(import_constants3.default.STENCIL_TEST),
+  stencilTest: (gl, value) => value ? gl.enable(import_constants3.GL.STENCIL_TEST) : gl.disable(import_constants3.GL.STENCIL_TEST),
   stencilMask: (gl, value) => {
     value = isArray(value) ? value : [value, value];
     const [mask, backMask] = value;
-    gl.stencilMaskSeparate(import_constants3.default.FRONT, mask);
-    gl.stencilMaskSeparate(import_constants3.default.BACK, backMask);
+    gl.stencilMaskSeparate(import_constants3.GL.FRONT, mask);
+    gl.stencilMaskSeparate(import_constants3.GL.BACK, backMask);
   },
   stencilFunc: (gl, args) => {
     args = isArray(args) && args.length === 3 ? [...args, ...args] : args;
     const [func, ref, mask, backFunc, backRef, backMask] = args;
-    gl.stencilFuncSeparate(import_constants3.default.FRONT, func, ref, mask);
-    gl.stencilFuncSeparate(import_constants3.default.BACK, backFunc, backRef, backMask);
+    gl.stencilFuncSeparate(import_constants3.GL.FRONT, func, ref, mask);
+    gl.stencilFuncSeparate(import_constants3.GL.BACK, 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_constants3.default.FRONT, sfail, dpfail, dppass);
-    gl.stencilOpSeparate(import_constants3.default.BACK, backSfail, backDpfail, backDppass);
+    gl.stencilOpSeparate(import_constants3.GL.FRONT, sfail, dpfail, dppass);
+    gl.stencilOpSeparate(import_constants3.GL.BACK, backSfail, backDpfail, backDppass);
   },
   viewport: (gl, value) => gl.viewport(...value)
 };
@@ -1036,46 +1038,46 @@ function getValue(glEnum, values, cache) {
 }
 var GL_COMPOSITE_PARAMETER_SETTERS = {
   blendEquation: (gl, values, cache) => gl.blendEquationSeparate(
-    getValue(import_constants3.default.BLEND_EQUATION_RGB, values, cache),
-    getValue(import_constants3.default.BLEND_EQUATION_ALPHA, values, cache)
+    getValue(import_constants3.GL.BLEND_EQUATION_RGB, values, cache),
+    getValue(import_constants3.GL.BLEND_EQUATION_ALPHA, values, cache)
   ),
   blendFunc: (gl, values, cache) => gl.blendFuncSeparate(
-    getValue(import_constants3.default.BLEND_SRC_RGB, values, cache),
-    getValue(import_constants3.default.BLEND_DST_RGB, values, cache),
-    getValue(import_constants3.default.BLEND_SRC_ALPHA, values, cache),
-    getValue(import_constants3.default.BLEND_DST_ALPHA, values, cache)
+    getValue(import_constants3.GL.BLEND_SRC_RGB, values, cache),
+    getValue(import_constants3.GL.BLEND_DST_RGB, values, cache),
+    getValue(import_constants3.GL.BLEND_SRC_ALPHA, values, cache),
+    getValue(import_constants3.GL.BLEND_DST_ALPHA, values, cache)
   ),
   polygonOffset: (gl, values, cache) => gl.polygonOffset(
-    getValue(import_constants3.default.POLYGON_OFFSET_FACTOR, values, cache),
-    getValue(import_constants3.default.POLYGON_OFFSET_UNITS, values, cache)
+    getValue(import_constants3.GL.POLYGON_OFFSET_FACTOR, values, cache),
+    getValue(import_constants3.GL.POLYGON_OFFSET_UNITS, values, cache)
   ),
   sampleCoverage: (gl, values, cache) => gl.sampleCoverage(
-    getValue(import_constants3.default.SAMPLE_COVERAGE_VALUE, values, cache),
-    getValue(import_constants3.default.SAMPLE_COVERAGE_INVERT, values, cache)
+    getValue(import_constants3.GL.SAMPLE_COVERAGE_VALUE, values, cache),
+    getValue(import_constants3.GL.SAMPLE_COVERAGE_INVERT, values, cache)
   ),
   stencilFuncFront: (gl, values, cache) => gl.stencilFuncSeparate(
-    import_constants3.default.FRONT,
-    getValue(import_constants3.default.STENCIL_FUNC, values, cache),
-    getValue(import_constants3.default.STENCIL_REF, values, cache),
-    getValue(import_constants3.default.STENCIL_VALUE_MASK, values, cache)
+    import_constants3.GL.FRONT,
+    getValue(import_constants3.GL.STENCIL_FUNC, values, cache),
+    getValue(import_constants3.GL.STENCIL_REF, values, cache),
+    getValue(import_constants3.GL.STENCIL_VALUE_MASK, values, cache)
   ),
   stencilFuncBack: (gl, values, cache) => gl.stencilFuncSeparate(
-    import_constants3.default.BACK,
-    getValue(import_constants3.default.STENCIL_BACK_FUNC, values, cache),
-    getValue(import_constants3.default.STENCIL_BACK_REF, values, cache),
-    getValue(import_constants3.default.STENCIL_BACK_VALUE_MASK, values, cache)
+    import_constants3.GL.BACK,
+    getValue(import_constants3.GL.STENCIL_BACK_FUNC, values, cache),
+    getValue(import_constants3.GL.STENCIL_BACK_REF, values, cache),
+    getValue(import_constants3.GL.STENCIL_BACK_VALUE_MASK, values, cache)
   ),
   stencilOpFront: (gl, values, cache) => gl.stencilOpSeparate(
-    import_constants3.default.FRONT,
-    getValue(import_constants3.default.STENCIL_FAIL, values, cache),
-    getValue(import_constants3.default.STENCIL_PASS_DEPTH_FAIL, values, cache),
-    getValue(import_constants3.default.STENCIL_PASS_DEPTH_PASS, values, cache)
+    import_constants3.GL.FRONT,
+    getValue(import_constants3.GL.STENCIL_FAIL, values, cache),
+    getValue(import_constants3.GL.STENCIL_PASS_DEPTH_FAIL, values, cache),
+    getValue(import_constants3.GL.STENCIL_PASS_DEPTH_PASS, values, cache)
   ),
   stencilOpBack: (gl, values, cache) => gl.stencilOpSeparate(
-    import_constants3.default.BACK,
-    getValue(import_constants3.default.STENCIL_BACK_FAIL, values, cache),
-    getValue(import_constants3.default.STENCIL_BACK_PASS_DEPTH_FAIL, values, cache),
-    getValue(import_constants3.default.STENCIL_BACK_PASS_DEPTH_PASS, values, cache)
+    import_constants3.GL.BACK,
+    getValue(import_constants3.GL.STENCIL_BACK_FAIL, values, cache),
+    getValue(import_constants3.GL.STENCIL_BACK_PASS_DEPTH_FAIL, values, cache),
+    getValue(import_constants3.GL.STENCIL_BACK_PASS_DEPTH_PASS, values, cache)
   )
 };
 var GL_HOOKED_SETTERS = {
@@ -1094,39 +1096,39 @@ var GL_HOOKED_SETTERS = {
   }),
   // SPECIFIC SETTERS
   useProgram: (update, value) => update({
-    [import_constants3.default.CURRENT_PROGRAM]: value
+    [import_constants3.GL.CURRENT_PROGRAM]: value
   }),
   bindRenderbuffer: (update, target, value) => update({
-    [import_constants3.default.RENDERBUFFER_BINDING]: value
+    [import_constants3.GL.RENDERBUFFER_BINDING]: value
   }),
   bindTransformFeedback: (update, target, value) => update({
-    [import_constants3.default.TRANSFORM_FEEDBACK_BINDING]: value
+    [import_constants3.GL.TRANSFORM_FEEDBACK_BINDING]: value
   }),
   bindVertexArray: (update, value) => update({
-    [import_constants3.default.VERTEX_ARRAY_BINDING]: value
+    [import_constants3.GL.VERTEX_ARRAY_BINDING]: value
   }),
   bindFramebuffer: (update, target, framebuffer) => {
     switch (target) {
-      case import_constants3.default.FRAMEBUFFER:
+      case import_constants3.GL.FRAMEBUFFER:
         return update({
-          [import_constants3.default.DRAW_FRAMEBUFFER_BINDING]: framebuffer,
-          [import_constants3.default.READ_FRAMEBUFFER_BINDING]: framebuffer
+          [import_constants3.GL.DRAW_FRAMEBUFFER_BINDING]: framebuffer,
+          [import_constants3.GL.READ_FRAMEBUFFER_BINDING]: framebuffer
         });
-      case import_constants3.default.DRAW_FRAMEBUFFER:
-        return update({ [import_constants3.default.DRAW_FRAMEBUFFER_BINDING]: framebuffer });
-      case import_constants3.default.READ_FRAMEBUFFER:
-        return update({ [import_constants3.default.READ_FRAMEBUFFER_BINDING]: framebuffer });
+      case import_constants3.GL.DRAW_FRAMEBUFFER:
+        return update({ [import_constants3.GL.DRAW_FRAMEBUFFER_BINDING]: framebuffer });
+      case import_constants3.GL.READ_FRAMEBUFFER:
+        return update({ [import_constants3.GL.READ_FRAMEBUFFER_BINDING]: framebuffer });
       default:
         return null;
     }
   },
   bindBuffer: (update, target, buffer) => {
     const pname = {
-      [import_constants3.default.ARRAY_BUFFER]: [import_constants3.default.ARRAY_BUFFER_BINDING],
-      [import_constants3.default.COPY_READ_BUFFER]: [import_constants3.default.COPY_READ_BUFFER_BINDING],
-      [import_constants3.default.COPY_WRITE_BUFFER]: [import_constants3.default.COPY_WRITE_BUFFER_BINDING],
-      [import_constants3.default.PIXEL_PACK_BUFFER]: [import_constants3.default.PIXEL_PACK_BUFFER_BINDING],
-      [import_constants3.default.PIXEL_UNPACK_BUFFER]: [import_constants3.default.PIXEL_UNPACK_BUFFER_BINDING]
+      [import_constants3.GL.ARRAY_BUFFER]: [import_constants3.GL.ARRAY_BUFFER_BINDING],
+      [import_constants3.GL.COPY_READ_BUFFER]: [import_constants3.GL.COPY_READ_BUFFER_BINDING],
+      [import_constants3.GL.COPY_WRITE_BUFFER]: [import_constants3.GL.COPY_WRITE_BUFFER_BINDING],
+      [import_constants3.GL.PIXEL_PACK_BUFFER]: [import_constants3.GL.PIXEL_PACK_BUFFER_BINDING],
+      [import_constants3.GL.PIXEL_UNPACK_BUFFER]: [import_constants3.GL.PIXEL_UNPACK_BUFFER_BINDING]
     }[target];
     if (pname) {
       return update({ [pname]: buffer });
@@ -1134,157 +1136,157 @@ var GL_HOOKED_SETTERS = {
     return { valueChanged: true };
   },
   blendColor: (update, r, g, b, a) => update({
-    [import_constants3.default.BLEND_COLOR]: new Float32Array([r, g, b, a])
+    [import_constants3.GL.BLEND_COLOR]: new Float32Array([r, g, b, a])
   }),
   blendEquation: (update, mode) => update({
-    [import_constants3.default.BLEND_EQUATION_RGB]: mode,
-    [import_constants3.default.BLEND_EQUATION_ALPHA]: mode
+    [import_constants3.GL.BLEND_EQUATION_RGB]: mode,
+    [import_constants3.GL.BLEND_EQUATION_ALPHA]: mode
   }),
   blendEquationSeparate: (update, modeRGB, modeAlpha) => update({
-    [import_constants3.default.BLEND_EQUATION_RGB]: modeRGB,
-    [import_constants3.default.BLEND_EQUATION_ALPHA]: modeAlpha
+    [import_constants3.GL.BLEND_EQUATION_RGB]: modeRGB,
+    [import_constants3.GL.BLEND_EQUATION_ALPHA]: modeAlpha
   }),
   blendFunc: (update, src, dst) => update({
-    [import_constants3.default.BLEND_SRC_RGB]: src,
-    [import_constants3.default.BLEND_DST_RGB]: dst,
-    [import_constants3.default.BLEND_SRC_ALPHA]: src,
-    [import_constants3.default.BLEND_DST_ALPHA]: dst
+    [import_constants3.GL.BLEND_SRC_RGB]: src,
+    [import_constants3.GL.BLEND_DST_RGB]: dst,
+    [import_constants3.GL.BLEND_SRC_ALPHA]: src,
+    [import_constants3.GL.BLEND_DST_ALPHA]: dst
   }),
   blendFuncSeparate: (update, srcRGB, dstRGB, srcAlpha, dstAlpha) => update({
-    [import_constants3.default.BLEND_SRC_RGB]: srcRGB,
-    [import_constants3.default.BLEND_DST_RGB]: dstRGB,
-    [import_constants3.default.BLEND_SRC_ALPHA]: srcAlpha,
-    [import_constants3.default.BLEND_DST_ALPHA]: dstAlpha
+    [import_constants3.GL.BLEND_SRC_RGB]: srcRGB,
+    [import_constants3.GL.BLEND_DST_RGB]: dstRGB,
+    [import_constants3.GL.BLEND_SRC_ALPHA]: srcAlpha,
+    [import_constants3.GL.BLEND_DST_ALPHA]: dstAlpha
   }),
   clearColor: (update, r, g, b, a) => update({
-    [import_constants3.default.COLOR_CLEAR_VALUE]: new Float32Array([r, g, b, a])
+    [import_constants3.GL.COLOR_CLEAR_VALUE]: new Float32Array([r, g, b, a])
   }),
   clearDepth: (update, depth) => update({
-    [import_constants3.default.DEPTH_CLEAR_VALUE]: depth
+    [import_constants3.GL.DEPTH_CLEAR_VALUE]: depth
   }),
   clearStencil: (update, s) => update({
-    [import_constants3.default.STENCIL_CLEAR_VALUE]: s
+    [import_constants3.GL.STENCIL_CLEAR_VALUE]: s
   }),
   colorMask: (update, r, g, b, a) => update({
-    [import_constants3.default.COLOR_WRITEMASK]: [r, g, b, a]
+    [import_constants3.GL.COLOR_WRITEMASK]: [r, g, b, a]
   }),
   cullFace: (update, mode) => update({
-    [import_constants3.default.CULL_FACE_MODE]: mode
+    [import_constants3.GL.CULL_FACE_MODE]: mode
   }),
   depthFunc: (update, func) => update({
-    [import_constants3.default.DEPTH_FUNC]: func
+    [import_constants3.GL.DEPTH_FUNC]: func
   }),
   depthRange: (update, zNear, zFar) => update({
-    [import_constants3.default.DEPTH_RANGE]: new Float32Array([zNear, zFar])
+    [import_constants3.GL.DEPTH_RANGE]: new Float32Array([zNear, zFar])
   }),
   depthMask: (update, mask) => update({
-    [import_constants3.default.DEPTH_WRITEMASK]: mask
+    [import_constants3.GL.DEPTH_WRITEMASK]: mask
   }),
   frontFace: (update, face) => update({
-    [import_constants3.default.FRONT_FACE]: face
+    [import_constants3.GL.FRONT_FACE]: face
   }),
   lineWidth: (update, width) => update({
-    [import_constants3.default.LINE_WIDTH]: width
+    [import_constants3.GL.LINE_WIDTH]: width
   }),
   polygonOffset: (update, factor, units) => update({
-    [import_constants3.default.POLYGON_OFFSET_FACTOR]: factor,
-    [import_constants3.default.POLYGON_OFFSET_UNITS]: units
+    [import_constants3.GL.POLYGON_OFFSET_FACTOR]: factor,
+    [import_constants3.GL.POLYGON_OFFSET_UNITS]: units
   }),
   sampleCoverage: (update, value, invert) => update({
-    [import_constants3.default.SAMPLE_COVERAGE_VALUE]: value,
-    [import_constants3.default.SAMPLE_COVERAGE_INVERT]: invert
+    [import_constants3.GL.SAMPLE_COVERAGE_VALUE]: value,
+    [import_constants3.GL.SAMPLE_COVERAGE_INVERT]: invert
   }),
   scissor: (update, x, y, width, height) => update({
-    [import_constants3.default.SCISSOR_BOX]: new Int32Array([x, y, width, height])
+    [import_constants3.GL.SCISSOR_BOX]: new Int32Array([x, y, width, height])
   }),
   stencilMask: (update, mask) => update({
-    [import_constants3.default.STENCIL_WRITEMASK]: mask,
-    [import_constants3.default.STENCIL_BACK_WRITEMASK]: mask
+    [import_constants3.GL.STENCIL_WRITEMASK]: mask,
+    [import_constants3.GL.STENCIL_BACK_WRITEMASK]: mask
   }),
   stencilMaskSeparate: (update, face, mask) => update({
-    [face === import_constants3.default.FRONT ? import_constants3.default.STENCIL_WRITEMASK : import_constants3.default.STENCIL_BACK_WRITEMASK]: mask
+    [face === import_constants3.GL.FRONT ? import_constants3.GL.STENCIL_WRITEMASK : import_constants3.GL.STENCIL_BACK_WRITEMASK]: mask
   }),
   stencilFunc: (update, func, ref, mask) => update({
-    [import_constants3.default.STENCIL_FUNC]: func,
-    [import_constants3.default.STENCIL_REF]: ref,
-    [import_constants3.default.STENCIL_VALUE_MASK]: mask,
-    [import_constants3.default.STENCIL_BACK_FUNC]: func,
-    [import_constants3.default.STENCIL_BACK_REF]: ref,
-    [import_constants3.default.STENCIL_BACK_VALUE_MASK]: mask
+    [import_constants3.GL.STENCIL_FUNC]: func,
+    [import_constants3.GL.STENCIL_REF]: ref,
+    [import_constants3.GL.STENCIL_VALUE_MASK]: mask,
+    [import_constants3.GL.STENCIL_BACK_FUNC]: func,
+    [import_constants3.GL.STENCIL_BACK_REF]: ref,
+    [import_constants3.GL.STENCIL_BACK_VALUE_MASK]: mask
   }),
   stencilFuncSeparate: (update, face, func, ref, mask) => update({
-    [face === import_constants3.default.FRONT ? import_constants3.default.STENCIL_FUNC : import_constants3.default.STENCIL_BACK_FUNC]: func,
-    [face === import_constants3.default.FRONT ? import_constants3.default.STENCIL_REF : import_constants3.default.STENCIL_BACK_REF]: ref,
-    [face === import_constants3.default.FRONT ? import_constants3.default.STENCIL_VALUE_MASK : import_constants3.default.STENCIL_BACK_VALUE_MASK]: mask
+    [face === import_constants3.GL.FRONT ? import_constants3.GL.STENCIL_FUNC : import_constants3.GL.STENCIL_BACK_FUNC]: func,
+    [face === import_constants3.GL.FRONT ? import_constants3.GL.STENCIL_REF : import_constants3.GL.STENCIL_BACK_REF]: ref,
+    [face === import_constants3.GL.FRONT ? import_constants3.GL.STENCIL_VALUE_MASK : import_constants3.GL.STENCIL_BACK_VALUE_MASK]: mask
   }),
   stencilOp: (update, fail, zfail, zpass) => update({
-    [import_constants3.default.STENCIL_FAIL]: fail,
-    [import_constants3.default.STENCIL_PASS_DEPTH_FAIL]: zfail,
-    [import_constants3.default.STENCIL_PASS_DEPTH_PASS]: zpass,
-    [import_constants3.default.STENCIL_BACK_FAIL]: fail,
-    [import_constants3.default.STENCIL_BACK_PASS_DEPTH_FAIL]: zfail,
-    [import_constants3.default.STENCIL_BACK_PASS_DEPTH_PASS]: zpass
+    [import_constants3.GL.STENCIL_FAIL]: fail,
+    [import_constants3.GL.STENCIL_PASS_DEPTH_FAIL]: zfail,
+    [import_constants3.GL.STENCIL_PASS_DEPTH_PASS]: zpass,
+    [import_constants3.GL.STENCIL_BACK_FAIL]: fail,
+    [import_constants3.GL.STENCIL_BACK_PASS_DEPTH_FAIL]: zfail,
+    [import_constants3.GL.STENCIL_BACK_PASS_DEPTH_PASS]: zpass
   }),
   stencilOpSeparate: (update, face, fail, zfail, zpass) => update({
-    [face === import_constants3.default.FRONT ? import_constants3.default.STENCIL_FAIL : import_constants3.default.STENCIL_BACK_FAIL]: fail,
-    [face === import_constants3.default.FRONT ? import_constants3.default.STENCIL_PASS_DEPTH_FAIL : import_constants3.default.STENCIL_BACK_PASS_DEPTH_FAIL]: zfail,
-    [face === import_constants3.default.FRONT ? import_constants3.default.STENCIL_PASS_DEPTH_PASS : import_constants3.default.STENCIL_BACK_PASS_DEPTH_PASS]: zpass
+    [face === import_constants3.GL.FRONT ? import_constants3.GL.STENCIL_FAIL : import_constants3.GL.STENCIL_BACK_FAIL]: fail,
+    [face === import_constants3.GL.FRONT ? import_constants3.GL.STENCIL_PASS_DEPTH_FAIL : import_constants3.GL.STENCIL_BACK_PASS_DEPTH_FAIL]: zfail,
+    [face === import_constants3.GL.FRONT ? import_constants3.GL.STENCIL_PASS_DEPTH_PASS : import_constants3.GL.STENCIL_BACK_PASS_DEPTH_PASS]: zpass
   }),
   viewport: (update, x, y, width, height) => update({
-    [import_constants3.default.VIEWPORT]: [x, y, width, height]
+    [import_constants3.GL.VIEWPORT]: [x, y, width, height]
   })
 };
 var isEnabled = (gl, key) => gl.isEnabled(key);
 var GL_PARAMETER_GETTERS = {
-  [import_constants3.default.BLEND]: isEnabled,
-  [import_constants3.default.CULL_FACE]: isEnabled,
-  [import_constants3.default.DEPTH_TEST]: isEnabled,
-  [import_constants3.default.DITHER]: isEnabled,
-  [import_constants3.default.POLYGON_OFFSET_FILL]: isEnabled,
-  [import_constants3.default.SAMPLE_ALPHA_TO_COVERAGE]: isEnabled,
-  [import_constants3.default.SAMPLE_COVERAGE]: isEnabled,
-  [import_constants3.default.SCISSOR_TEST]: isEnabled,
-  [import_constants3.default.STENCIL_TEST]: isEnabled,
+  [import_constants3.GL.BLEND]: isEnabled,
+  [import_constants3.GL.CULL_FACE]: isEnabled,
+  [import_constants3.GL.DEPTH_TEST]: isEnabled,
+  [import_constants3.GL.DITHER]: isEnabled,
+  [import_constants3.GL.POLYGON_OFFSET_FILL]: isEnabled,
+  [import_constants3.GL.SAMPLE_ALPHA_TO_COVERAGE]: isEnabled,
+  [import_constants3.GL.SAMPLE_COVERAGE]: isEnabled,
+  [import_constants3.GL.SCISSOR_TEST]: isEnabled,
+  [import_constants3.GL.STENCIL_TEST]: isEnabled,
   // WebGL 2
-  [import_constants3.default.RASTERIZER_DISCARD]: isEnabled
+  [import_constants3.GL.RASTERIZER_DISCARD]: isEnabled
 };
 var NON_CACHE_PARAMETERS = /* @__PURE__ */ new Set([
   // setter not intercepted
-  import_constants3.default.ACTIVE_TEXTURE,
-  import_constants3.default.TRANSFORM_FEEDBACK_ACTIVE,
-  import_constants3.default.TRANSFORM_FEEDBACK_PAUSED,
+  import_constants3.GL.ACTIVE_TEXTURE,
+  import_constants3.GL.TRANSFORM_FEEDBACK_ACTIVE,
+  import_constants3.GL.TRANSFORM_FEEDBACK_PAUSED,
   // setters bindBufferRange/bindBufferBase cannot be pruned based on cache
-  import_constants3.default.TRANSFORM_FEEDBACK_BUFFER_BINDING,
-  import_constants3.default.UNIFORM_BUFFER_BINDING,
+  import_constants3.GL.TRANSFORM_FEEDBACK_BUFFER_BINDING,
+  import_constants3.GL.UNIFORM_BUFFER_BINDING,
   // states depending on VERTEX_ARRAY_BINDING
-  import_constants3.default.ELEMENT_ARRAY_BUFFER_BINDING,
+  import_constants3.GL.ELEMENT_ARRAY_BUFFER_BINDING,
   // states depending on READ_FRAMEBUFFER_BINDING
-  import_constants3.default.IMPLEMENTATION_COLOR_READ_FORMAT,
-  import_constants3.default.IMPLEMENTATION_COLOR_READ_TYPE,
+  import_constants3.GL.IMPLEMENTATION_COLOR_READ_FORMAT,
+  import_constants3.GL.IMPLEMENTATION_COLOR_READ_TYPE,
   // states depending on FRAMEBUFFER_BINDING
-  import_constants3.default.READ_BUFFER,
-  import_constants3.default.DRAW_BUFFER0,
-  import_constants3.default.DRAW_BUFFER1,
-  import_constants3.default.DRAW_BUFFER2,
-  import_constants3.default.DRAW_BUFFER3,
-  import_constants3.default.DRAW_BUFFER4,
-  import_constants3.default.DRAW_BUFFER5,
-  import_constants3.default.DRAW_BUFFER6,
-  import_constants3.default.DRAW_BUFFER7,
-  import_constants3.default.DRAW_BUFFER8,
-  import_constants3.default.DRAW_BUFFER9,
-  import_constants3.default.DRAW_BUFFER10,
-  import_constants3.default.DRAW_BUFFER11,
-  import_constants3.default.DRAW_BUFFER12,
-  import_constants3.default.DRAW_BUFFER13,
-  import_constants3.default.DRAW_BUFFER14,
-  import_constants3.default.DRAW_BUFFER15,
+  import_constants3.GL.READ_BUFFER,
+  import_constants3.GL.DRAW_BUFFER0,
+  import_constants3.GL.DRAW_BUFFER1,
+  import_constants3.GL.DRAW_BUFFER2,
+  import_constants3.GL.DRAW_BUFFER3,
+  import_constants3.GL.DRAW_BUFFER4,
+  import_constants3.GL.DRAW_BUFFER5,
+  import_constants3.GL.DRAW_BUFFER6,
+  import_constants3.GL.DRAW_BUFFER7,
+  import_constants3.GL.DRAW_BUFFER8,
+  import_constants3.GL.DRAW_BUFFER9,
+  import_constants3.GL.DRAW_BUFFER10,
+  import_constants3.GL.DRAW_BUFFER11,
+  import_constants3.GL.DRAW_BUFFER12,
+  import_constants3.GL.DRAW_BUFFER13,
+  import_constants3.GL.DRAW_BUFFER14,
+  import_constants3.GL.DRAW_BUFFER15,
   // states depending on ACTIVE_TEXTURE
-  import_constants3.default.SAMPLER_BINDING,
-  import_constants3.default.TEXTURE_BINDING_2D,
-  import_constants3.default.TEXTURE_BINDING_2D_ARRAY,
-  import_constants3.default.TEXTURE_BINDING_3D,
-  import_constants3.default.TEXTURE_BINDING_CUBE_MAP
+  import_constants3.GL.SAMPLER_BINDING,
+  import_constants3.GL.TEXTURE_BINDING_2D,
+  import_constants3.GL.TEXTURE_BINDING_2D_ARRAY,
+  import_constants3.GL.TEXTURE_BINDING_3D,
+  import_constants3.GL.TEXTURE_BINDING_CUBE_MAP
 ]);
 
 // src/context/parameters/unified-parameter-api.ts
@@ -1363,7 +1365,7 @@ var GLState = class {
   constructor(gl, {
     copyState = false,
     // Copy cache from params (slow) or initialize from WebGL defaults (fast)
-    log: log10 = () => {
+    log: log9 = () => {
     }
     // Logging function, called when gl parameter change calls are actually issued
   } = {}) {
@@ -1372,7 +1374,7 @@ var GLState = class {
     this.enable = true;
     this.gl = gl;
     this.cache = copyState ? getParameters(gl) : Object.assign({}, GL_PARAMETER_DEFAULTS);
-    this.log = log10;
+    this.log = log9;
     this._updateCache = this._updateCache.bind(this);
     Object.seal(this);
   }
@@ -1676,27 +1678,27 @@ var TEXTURE_FORMATS = {
   // 'rgb8unorm-srgb-unsized': {gl: GL.SRGB_EXT, b: 4, c: 2, bpp: 4, gl1Ext: SRGB},
   // 'rgba8unorm-srgb-unsized': {gl: GL.SRGB_ALPHA_EXT, b: 4, c: 2, bpp: 4, gl1Ext: SRGB},
   // 8-bit formats
-  "r8unorm": { gl: import_constants5.default.R8, b: 1, c: 1 },
+  "r8unorm": { gl: import_constants5.default.R8, b: 1, c: 1, renderbuffer: true },
   "r8snorm": { gl: import_constants5.default.R8_SNORM, b: 1, c: 1 },
-  "r8uint": { gl: import_constants5.default.R8UI, b: 1, c: 1 },
-  "r8sint": { gl: import_constants5.default.R8I, b: 1, c: 1 },
+  "r8uint": { gl: import_constants5.default.R8UI, b: 1, c: 1, renderbuffer: true },
+  "r8sint": { gl: import_constants5.default.R8I, b: 1, c: 1, renderbuffer: true },
   // 16-bit formats
-  "rg8unorm": { gl: import_constants5.default.RG8, b: 2, c: 2 },
+  "rg8unorm": { gl: import_constants5.default.RG8, b: 2, c: 2, renderbuffer: true },
   "rg8snorm": { gl: import_constants5.default.RG8_SNORM, b: 2, c: 2 },
-  "rg8uint": { gl: import_constants5.default.RG8UI, b: 2, c: 2 },
-  "rg8sint": { gl: import_constants5.default.RG8I, b: 2, c: 2 },
-  "r16uint": { gl: import_constants5.default.R16UI, b: 2, c: 1 },
-  "r16sint": { gl: import_constants5.default.R16I, b: 2, c: 1 },
-  "r16float": { gl: import_constants5.default.R16F, b: 2, c: 1, render: "texture-renderable-float16-webgl", filter: "texture-filter-linear-float16-webgl" },
-  "r16unorm-webgl": { gl: import_constants5.default.R16_EXT, b: 2, c: 1, f: "texture-formats-norm16-webgl" },
-  "r16snorm-webgl": { gl: import_constants5.default.R16_SNORM_EXT, b: 2, c: 1, f: "texture-formats-norm16-webgl" },
+  "rg8uint": { gl: import_constants5.default.RG8UI, b: 2, c: 2, renderbuffer: true },
+  "rg8sint": { gl: import_constants5.default.RG8I, b: 2, c: 2, renderbuffer: true },
+  "r16uint": { gl: import_constants5.default.R16UI, b: 2, c: 1, renderbuffer: true },
+  "r16sint": { gl: import_constants5.default.R16I, b: 2, c: 1, renderbuffer: true },
+  "r16float": { gl: import_constants5.default.R16F, b: 2, c: 1, render: "texture-renderable-float16-webgl", filter: "texture-filter-linear-float16-webgl", renderbuffer: true },
+  "r16unorm-webgl": { gl: import_constants5.default.R16_EXT, b: 2, c: 1, f: "texture-formats-norm16-webgl", renderbuffer: true, x: EXT_TEXTURE_NORM16 },
+  "r16snorm-webgl": { gl: import_constants5.default.R16_SNORM_EXT, b: 2, c: 1, f: "texture-formats-norm16-webgl", x: EXT_TEXTURE_NORM16 },
   // Packed 16-bit formats
-  "rgba4unorm-webgl": { gl: import_constants5.default.RGBA4, b: 2, c: 4, wgpu: false },
-  "rgb565unorm-webgl": { gl: import_constants5.default.RGB565, b: 2, c: 4, wgpu: false },
-  "rgb5a1unorm-webgl": { gl: import_constants5.default.RGB5_A1, b: 2, c: 4, wgpu: false },
+  "rgba4unorm-webgl": { gl: import_constants5.default.RGBA4, b: 2, c: 4, wgpu: false, renderbuffer: true },
+  "rgb565unorm-webgl": { gl: import_constants5.default.RGB565, b: 2, c: 4, wgpu: false, renderbuffer: true },
+  "rgb5a1unorm-webgl": { gl: import_constants5.default.RGB5_A1, b: 2, c: 4, wgpu: false, renderbuffer: true },
   // 24-bit formats
-  "rbg8unorm-webgl": { gl: import_constants5.default.RGB8, b: 3, c: 3, wgpu: false },
-  "rbg8snorm-webgl": { gl: import_constants5.default.RGB8_SNORM, b: 3, c: 3, wgpu: false },
+  "rgb8unorm-webgl": { gl: import_constants5.default.RGB8, b: 3, c: 3, wgpu: false },
+  "rgb8snorm-webgl": { gl: import_constants5.default.RGB8_SNORM, b: 3, c: 3, wgpu: false },
   // 32-bit formats  
   "rgba8unorm": { gl: import_constants5.default.RGBA8, gl1: import_constants5.default.RGBA, b: 4, c: 2, bpp: 4 },
   "rgba8unorm-srgb": { gl: import_constants5.default.SRGB8_ALPHA8, gl1: import_constants5.default.SRGB_ALPHA_EXT, b: 4, c: 4, gl1ext: EXT_SRGB, bpp: 4 },
@@ -1709,30 +1711,30 @@ var TEXTURE_FORMATS = {
   "rg16uint": { gl: import_constants5.default.RG16UI, b: 4, c: 1, bpp: 4 },
   "rg16sint": { gl: import_constants5.default.RG16I, b: 4, c: 2, bpp: 4 },
   // When using a WebGL 2 context and the EXT_color_buffer_float WebGL2 extension
-  "rg16float": { gl: import_constants5.default.RG16F, bpp: 4, b: 4, c: 2, render: "texture-renderable-float16-webgl", filter: "texture-filter-linear-float16-webgl" },
-  "rg16unorm-webgl": { gl: import_constants5.default.RG16_EXT, b: 2, c: 2, f: "texture-formats-norm16-webgl" },
-  "rg16snorm-webgl": { gl: import_constants5.default.RG16_SNORM_EXT, b: 2, c: 2, f: "texture-formats-norm16-webgl" },
-  "r32uint": { gl: import_constants5.default.R32UI, b: 4, c: 1, bpp: 4 },
-  "r32sint": { gl: import_constants5.default.R32I, b: 4, c: 1, bpp: 4 },
+  "rg16float": { gl: import_constants5.default.RG16F, bpp: 4, b: 4, c: 2, render: "texture-renderable-float16-webgl", filter: "texture-filter-linear-float16-webgl", renderbuffer: true },
+  "rg16unorm-webgl": { gl: import_constants5.default.RG16_EXT, b: 2, c: 2, f: "texture-formats-norm16-webgl", x: EXT_TEXTURE_NORM16 },
+  "rg16snorm-webgl": { gl: import_constants5.default.RG16_SNORM_EXT, b: 2, c: 2, f: "texture-formats-norm16-webgl", x: EXT_TEXTURE_NORM16 },
+  "r32uint": { gl: import_constants5.default.R32UI, b: 4, c: 1, bpp: 4, renderbuffer: true },
+  "r32sint": { gl: import_constants5.default.R32I, b: 4, c: 1, bpp: 4, renderbuffer: true },
   "r32float": { gl: import_constants5.default.R32F, bpp: 4, b: 4, c: 1, render: "texture-renderable-float32-webgl", filter: "texture-filter-linear-float32-webgl" },
   // Packed 32-bit formats
   "rgb9e5ufloat": { gl: import_constants5.default.RGB9_E5, b: 4, c: 3, p: 1, render: "texture-renderable-float16-webgl", filter: "texture-filter-linear-float16-webgl" },
-  "rg11b10ufloat": { gl: import_constants5.default.R11F_G11F_B10F, b: 4, c: 3, p: 1, render: "texture-renderable-float32-webgl" },
-  "rgb10a2unorm": { gl: import_constants5.default.RGB10_A2, b: 4, c: 4, p: 1 },
+  "rg11b10ufloat": { gl: import_constants5.default.R11F_G11F_B10F, b: 4, c: 3, p: 1, render: "texture-renderable-float32-webgl", renderbuffer: true },
+  "rgb10a2unorm": { gl: import_constants5.default.RGB10_A2, b: 4, c: 4, p: 1, renderbuffer: true },
   // webgl2 only
-  "rgb10a2unorm-webgl": { b: 4, c: 4, gl: import_constants5.default.RGB10_A2UI, p: 1, wgpu: false, bpp: 4 },
+  "rgb10a2unorm-webgl": { b: 4, c: 4, gl: import_constants5.default.RGB10_A2UI, p: 1, wgpu: false, bpp: 4, renderbuffer: true },
   // 48-bit formats
-  "rgb16unorm-webgl": { gl: import_constants5.default.RGB16_EXT, b: 2, c: 3, f: "texture-formats-norm16-webgl" },
-  "rgb16snorm-webgl": { gl: import_constants5.default.RGB16_SNORM_EXT, b: 2, c: 3, f: "texture-formats-norm16-webgl" },
+  "rgb16unorm-webgl": { gl: import_constants5.default.RGB16_EXT, b: 2, c: 3, f: "texture-formats-norm16-webgl", x: EXT_TEXTURE_NORM16 },
+  "rgb16snorm-webgl": { gl: import_constants5.default.RGB16_SNORM_EXT, b: 2, c: 3, f: "texture-formats-norm16-webgl", x: EXT_TEXTURE_NORM16 },
   // 64-bit formats
-  "rg32uint": { gl: import_constants5.default.RG32UI, b: 8, c: 2 },
-  "rg32sint": { gl: import_constants5.default.RG32I, b: 8, c: 2 },
-  "rg32float": { gl: import_constants5.default.RG32F, b: 8, c: 2, render: "texture-renderable-float32-webgl", filter: "texture-filter-linear-float32-webgl" },
-  "rgba16uint": { gl: import_constants5.default.RGBA16UI, b: 8, c: 4 },
-  "rgba16sint": { gl: import_constants5.default.RGBA16I, b: 8, c: 4 },
+  "rg32uint": { gl: import_constants5.default.RG32UI, b: 8, c: 2, renderbuffer: true },
+  "rg32sint": { gl: import_constants5.default.RG32I, b: 8, c: 2, renderbuffer: true },
+  "rg32float": { gl: import_constants5.default.RG32F, b: 8, c: 2, render: "texture-renderable-float32-webgl", filter: "texture-filter-linear-float32-webgl", renderbuffer: true },
+  "rgba16uint": { gl: import_constants5.default.RGBA16UI, b: 8, c: 4, renderbuffer: true },
+  "rgba16sint": { gl: import_constants5.default.RGBA16I, b: 8, c: 4, renderbuffer: true },
   "rgba16float": { gl: import_constants5.default.RGBA16F, gl1: import_constants5.default.RGBA, b: 8, c: 4, render: "texture-renderable-float16-webgl", filter: "texture-filter-linear-float16-webgl" },
-  "rgba16unorm-webgl": { gl: import_constants5.default.RGBA16_EXT, b: 2, c: 4, f: "texture-formats-norm16-webgl" },
-  "rgba16snorm-webgl": { gl: import_constants5.default.RGBA16_SNORM_EXT, b: 2, c: 4, f: "texture-formats-norm16-webgl" },
+  "rgba16unorm-webgl": { gl: import_constants5.default.RGBA16_EXT, b: 2, c: 4, f: "texture-formats-norm16-webgl", renderbuffer: true, x: EXT_TEXTURE_NORM16 },
+  "rgba16snorm-webgl": { gl: import_constants5.default.RGBA16_SNORM_EXT, b: 2, c: 4, f: "texture-formats-norm16-webgl", x: EXT_TEXTURE_NORM16 },
   // 96-bit formats (deprecated!)
   "rgb32float-webgl": {
     gl: import_constants5.default.RGB32F,
@@ -1746,21 +1748,22 @@ var TEXTURE_FORMATS = {
     types: [import_constants5.default.FLOAT]
   },
   // 128-bit formats
-  "rgba32uint": { gl: import_constants5.default.RGBA32UI, b: 16, c: 4 },
-  "rgba32sint": { gl: import_constants5.default.RGBA32I, b: 16, c: 4 },
-  "rgba32float": { gl: import_constants5.default.RGBA32F, gl1: import_constants5.default.RGBA, b: 16, c: 4, render: "texture-renderable-float32-webgl", filter: "texture-filter-linear-float32-webgl" },
+  "rgba32uint": { gl: import_constants5.default.RGBA32UI, b: 16, c: 4, renderbuffer: true },
+  "rgba32sint": { gl: import_constants5.default.RGBA32I, b: 16, c: 4, renderbuffer: true },
+  "rgba32float": { gl: import_constants5.default.RGBA32F, b: 16, c: 4, render: "texture-renderable-float32-webgl", filter: "texture-filter-linear-float32-webgl", renderbuffer: true },
   // Depth and stencil formats
-  "stencil8": { gl: import_constants5.default.STENCIL_INDEX8, b: 1, c: 1, attachment: import_constants5.default.STENCIL_ATTACHMENT },
+  "stencil8": { gl: import_constants5.default.STENCIL_INDEX8, gl1: import_constants5.default.STENCIL_INDEX8, b: 1, c: 1, attachment: import_constants5.default.STENCIL_ATTACHMENT, renderbuffer: true },
   // 8 stencil bits
-  "depth16unorm": { gl: import_constants5.default.DEPTH_COMPONENT16, gl1: import_constants5.default.DEPTH_COMPONENT16, b: 2, c: 1, attachment: import_constants5.default.DEPTH_ATTACHMENT },
+  "depth16unorm": { gl: import_constants5.default.DEPTH_COMPONENT16, gl1: import_constants5.default.DEPTH_COMPONENT16, b: 2, c: 1, attachment: import_constants5.default.DEPTH_ATTACHMENT, renderbuffer: true },
   // 16 depth bits
   "depth24plus": { gl: import_constants5.default.DEPTH_COMPONENT24, b: 3, c: 1, attachment: import_constants5.default.DEPTH_ATTACHMENT },
-  "depth32float": { gl: import_constants5.default.DEPTH_COMPONENT32F, b: 4, c: 1, attachment: import_constants5.default.DEPTH_ATTACHMENT },
-  "depth24plus-stencil8": { b: 4, gl: import_constants5.default.UNSIGNED_INT_24_8, gl1: import_constants5.default.DEPTH_STENCIL, c: 2, p: 1, attachment: import_constants5.default.DEPTH_STENCIL_ATTACHMENT },
+  "depth32float": { gl: import_constants5.default.DEPTH_COMPONENT32F, b: 4, c: 1, attachment: import_constants5.default.DEPTH_ATTACHMENT, renderbuffer: true },
+  // The depth component of the "depth24plus" and "depth24plus-stencil8" formats may be implemented as either a 24-bit depth value or a "depth32float" value.
+  "depth24plus-stencil8": { gl: import_constants5.default.DEPTH_STENCIL, gl1: import_constants5.default.DEPTH_STENCIL, b: 4, c: 2, p: 1, attachment: import_constants5.default.DEPTH_STENCIL_ATTACHMENT, renderbuffer: true, depthTexture: true },
   // "depth24unorm-stencil8" feature
-  "depth24unorm-stencil8": { gl: import_constants5.default.DEPTH24_STENCIL8, b: 4, c: 2, p: 1, attachment: import_constants5.default.DEPTH_STENCIL_ATTACHMENT },
+  "depth24unorm-stencil8": { gl: import_constants5.default.DEPTH24_STENCIL8, b: 4, c: 2, p: 1, attachment: import_constants5.default.DEPTH_STENCIL_ATTACHMENT, renderbuffer: true },
   // "depth32float-stencil8" feature
-  "depth32float-stencil8": { gl: import_constants5.default.DEPTH32F_STENCIL8, b: 5, c: 2, p: 1, attachment: import_constants5.default.DEPTH_STENCIL_ATTACHMENT },
+  "depth32float-stencil8": { gl: import_constants5.default.DEPTH32F_STENCIL8, b: 5, c: 2, p: 1, attachment: import_constants5.default.DEPTH_STENCIL_ATTACHMENT, renderbuffer: true },
   // BC compressed formats: check device.features.has("texture-compression-bc");
   "bc1-rgb-unorm-webgl": { gl: import_constants5.default.COMPRESSED_RGB_S3TC_DXT1_EXT, x: X_S3TC, f: texture_compression_bc },
   "bc1-rgb-unorm-srgb-webgl": { gl: import_constants5.default.COMPRESSED_SRGB_S3TC_DXT1_EXT, x: X_S3TC_SRGB, f: texture_compression_bc },
@@ -1831,18 +1834,33 @@ var TEXTURE_FORMATS = {
   "atc-rgba-unorm-webgl": { gl: import_constants5.default.COMPRESSED_RGBA_ATC_EXPLICIT_ALPHA_WEBGL, f: texture_compression_atc_webgl },
   "atc-rgbai-unorm-webgl": { gl: import_constants5.default.COMPRESSED_RGBA_ATC_INTERPOLATED_ALPHA_WEBGL, f: texture_compression_atc_webgl }
 };
-function getTextureFormat(format) {
-  if (typeof format === "string") {
-    return format;
-  }
-  const entry = Object.entries(TEXTURE_FORMATS).find(([, entry2]) => entry2.gl === format || entry2.gl1 === format);
-  if (!entry) {
-    throw new Error(`Unknown texture format ${format}`);
-  }
-  return entry[0];
-}
+var DATA_FORMAT_CHANNELS = {
+  [import_constants5.default.RED]: 1,
+  [import_constants5.default.RED_INTEGER]: 1,
+  [import_constants5.default.RG]: 2,
+  [import_constants5.default.RG_INTEGER]: 2,
+  [import_constants5.default.RGB]: 3,
+  [import_constants5.default.RGB_INTEGER]: 3,
+  [import_constants5.default.RGBA]: 4,
+  [import_constants5.default.RGBA_INTEGER]: 4,
+  [import_constants5.default.DEPTH_COMPONENT]: 1,
+  [import_constants5.default.DEPTH_STENCIL]: 1,
+  [import_constants5.default.ALPHA]: 1,
+  [import_constants5.default.LUMINANCE]: 1,
+  [import_constants5.default.LUMINANCE_ALPHA]: 2
+};
+var TYPE_SIZES = {
+  [import_constants5.default.FLOAT]: 4,
+  [import_constants5.default.UNSIGNED_INT]: 4,
+  [import_constants5.default.INT]: 4,
+  [import_constants5.default.UNSIGNED_SHORT]: 2,
+  [import_constants5.default.SHORT]: 2,
+  [import_constants5.default.HALF_FLOAT]: 2,
+  [import_constants5.default.BYTE]: 1,
+  [import_constants5.default.UNSIGNED_BYTE]: 1
+};
 function isTextureFormatSupported(gl, formatOrGL) {
-  const format = getTextureFormat(formatOrGL);
+  const format = convertGLToTextureFormat(formatOrGL);
   const info = TEXTURE_FORMATS[format];
   if (!info) {
     return false;
@@ -1856,8 +1874,32 @@ function isTextureFormatSupported(gl, formatOrGL) {
   }
   return true;
 }
+function isRenderbufferFormatSupported(gl, format) {
+  var _a;
+  return isTextureFormatSupported(gl, format) && ((_a = TEXTURE_FORMATS[format]) == null ? void 0 : _a.renderbuffer);
+}
+function convertGLToTextureFormat(format) {
+  if (typeof format === "string") {
+    return format;
+  }
+  const entry = Object.entries(TEXTURE_FORMATS).find(
+    ([, entry2]) => entry2.gl === format || entry2.gl1 === format
+  );
+  if (!entry) {
+    throw new Error(`Unknown texture format ${format}`);
+  }
+  return entry[0];
+}
+function convertTextureFormatToGL(format, isWebGL23) {
+  const formatInfo = TEXTURE_FORMATS[format];
+  const webglFormat = isWebGL23 ? formatInfo == null ? void 0 : formatInfo.gl : formatInfo == null ? void 0 : formatInfo.gl1;
+  if (webglFormat === void 0) {
+    throw new Error(`Unsupported texture format ${format}`);
+  }
+  return webglFormat;
+}
 function isTextureFormatFilterable(gl, formatOrGL) {
-  const format = getTextureFormat(formatOrGL);
+  const format = convertGLToTextureFormat(formatOrGL);
   if (!isTextureFormatSupported(gl, format)) {
     return false;
   }
@@ -1878,7 +1920,7 @@ function isTextureFormatFilterable(gl, formatOrGL) {
   return true;
 }
 function isTextureFormatRenderable(gl, formatOrGL) {
-  const format = getTextureFormat(formatOrGL);
+  const format = convertGLToTextureFormat(formatOrGL);
   if (!isTextureFormatSupported(gl, format)) {
     return false;
   }
@@ -1887,21 +1929,9 @@ function isTextureFormatRenderable(gl, formatOrGL) {
   }
   return true;
 }
-function getWebGLTextureFormat(gl, formatOrGL) {
-  const format = getTextureFormat(formatOrGL);
-  const formatInfo = TEXTURE_FORMATS[format];
-  const webglFormat = isWebGL2(gl) ? formatInfo == null ? void 0 : formatInfo.gl : formatInfo == null ? void 0 : formatInfo.gl1;
-  if (typeof format === "number") {
-    return webglFormat || format;
-  }
-  if (webglFormat === void 0) {
-    throw new Error(`Unsupported texture format ${format}`);
-  }
-  return webglFormat;
-}
-function getWebGLTextureParameters(gl, formatOrGL) {
-  const format = getTextureFormat(formatOrGL);
-  const webglFormat = getWebGLTextureFormat(gl, format);
+function getWebGLTextureParameters(formatOrGL, isWebGL23) {
+  const format = convertGLToTextureFormat(formatOrGL);
+  const webglFormat = convertTextureFormatToGL(format, isWebGL23);
   const decoded = (0, import_api5.decodeTextureFormat)(format);
   return {
     format: webglFormat,
@@ -1916,17 +1946,12 @@ function getWebGLTextureParameters(gl, formatOrGL) {
     compressed: decoded.compressed
   };
 }
-function getWebGLDepthStencilAttachment(formatOrGL) {
-  const format = getTextureFormat(formatOrGL);
-  if (typeof format === "number") {
-    throw new Error("unsupported depth stencil format");
-  }
+function getDepthStencilAttachmentWebGL(format) {
   const info = TEXTURE_FORMATS[format];
-  const attachment = info.attachment;
-  if (!attachment) {
-    throw new Error("not a depth stencil format");
+  if (!(info == null ? void 0 : info.attachment)) {
+    throw new Error(`${format} is not a depth stencil format`);
   }
-  return attachment;
+  return info.attachment;
 }
 function _checkFloat32ColorAttachment(gl, internalFormat = gl.RGBA, srcFormat = import_constants5.default.RGBA, srcType = import_constants5.default.UNSIGNED_BYTE) {
   let texture = null;
@@ -1961,34 +1986,9 @@ function _checkFloat32ColorAttachment(gl, internalFormat = gl.RGBA, srcFormat =
     gl.deleteFramebuffer(framebuffer);
   }
 }
-var DATA_FORMAT_CHANNELS = {
-  [import_constants5.default.RED]: 1,
-  [import_constants5.default.RED_INTEGER]: 1,
-  [import_constants5.default.RG]: 2,
-  [import_constants5.default.RG_INTEGER]: 2,
-  [import_constants5.default.RGB]: 3,
-  [import_constants5.default.RGB_INTEGER]: 3,
-  [import_constants5.default.RGBA]: 4,
-  [import_constants5.default.RGBA_INTEGER]: 4,
-  [import_constants5.default.DEPTH_COMPONENT]: 1,
-  [import_constants5.default.DEPTH_STENCIL]: 1,
-  [import_constants5.default.ALPHA]: 1,
-  [import_constants5.default.LUMINANCE]: 1,
-  [import_constants5.default.LUMINANCE_ALPHA]: 2
-};
-var TYPE_SIZES = {
-  [import_constants5.default.FLOAT]: 4,
-  [import_constants5.default.UNSIGNED_INT]: 4,
-  [import_constants5.default.INT]: 4,
-  [import_constants5.default.UNSIGNED_SHORT]: 2,
-  [import_constants5.default.SHORT]: 2,
-  [import_constants5.default.HALF_FLOAT]: 2,
-  [import_constants5.default.BYTE]: 1,
-  [import_constants5.default.UNSIGNED_BYTE]: 1
-};
-function getTextureFormatBytesPerPixel(gl, formatOrGL) {
-  const format = getTextureFormat(formatOrGL);
-  const params = getWebGLTextureParameters(gl, format);
+function getTextureFormatBytesPerPixel(formatOrGL, isWebGL23) {
+  const format = convertGLToTextureFormat(formatOrGL);
+  const params = getWebGLTextureParameters(format, isWebGL23);
   const channels = DATA_FORMAT_CHANNELS[params.dataFormat] || 4;
   const channelSize = TYPE_SIZES[params.type] || 1;
   return channels * channelSize;
@@ -2279,12 +2279,12 @@ var import_api15 = require("@luma.gl/api");
 
 // src/adapter/resources/webgl-framebuffer.ts
 var import_api14 = require("@luma.gl/api");
-var import_constants14 = __toESM(require("@luma.gl/constants"), 1);
+var import_constants13 = __toESM(require("@luma.gl/constants"), 1);
 
 // src/adapter/resources/webgl-texture.ts
 var import_api9 = require("@luma.gl/api");
 var import_api10 = require("@luma.gl/api");
-var import_constants11 = __toESM(require("@luma.gl/constants"), 1);
+var import_constants11 = require("@luma.gl/constants");
 
 // src/context/state-tracker/with-parameters.ts
 function withParameters(device, parameters, func) {
@@ -2317,7 +2317,7 @@ function isObjectEmpty2(object) {
 }
 
 // src/adapter/converters/sampler-parameters.ts
-var import_constants8 = __toESM(require("@luma.gl/constants"), 1);
+var import_constants8 = require("@luma.gl/constants");
 
 // src/adapter/converters/device-parameters.ts
 var import_api6 = require("@luma.gl/api");
@@ -2365,10 +2365,12 @@ function setDeviceParameters(device, parameters) {
     }
   }
   if (parameters.frontFace) {
-    gl.frontFace(map("frontFace", parameters.frontFace, {
-      ccw: import_constants7.default.CCW,
-      cw: import_constants7.default.CW
-    }));
+    gl.frontFace(
+      map("frontFace", parameters.frontFace, {
+        ccw: import_constants7.default.CCW,
+        cw: import_constants7.default.CW
+      })
+    );
   }
   if (parameters.depthBias !== void 0) {
     gl.polygonOffset(parameters.depthBias, parameters.depthBiasSlopeScale || 0);
@@ -2398,29 +2400,32 @@ function setDeviceParameters(device, parameters) {
   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);
+    const dpfail = convertStencilOperation(
+      "stencilDepthFailOperation",
+      parameters.stencilDepthFailOperation
+    );
     gl.stencilOpSeparate(import_constants7.default.FRONT, sfail, dpfail, dppass);
     gl.stencilOpSeparate(import_constants7.default.BACK, sfail, dpfail, dppass);
   }
 }
 function convertCompareFunction(parameter, value) {
   return map(parameter, value, {
-    "never": import_constants7.default.NEVER,
-    "less": import_constants7.default.LESS,
-    "equal": import_constants7.default.EQUAL,
+    never: import_constants7.default.NEVER,
+    less: import_constants7.default.LESS,
+    equal: import_constants7.default.EQUAL,
     "less-equal": import_constants7.default.LEQUAL,
-    "greater": import_constants7.default.GREATER,
+    greater: import_constants7.default.GREATER,
     "not-equal": import_constants7.default.NOTEQUAL,
     "greater-equal": import_constants7.default.GEQUAL,
-    "always": import_constants7.default.ALWAYS
+    always: import_constants7.default.ALWAYS
   });
 }
 function convertStencilOperation(parameter, value) {
   return map(parameter, value, {
-    "keep": import_constants7.default.KEEP,
-    "zero": import_constants7.default.ZERO,
-    "replace": import_constants7.default.REPLACE,
-    "invert": import_constants7.default.INVERT,
+    keep: import_constants7.default.KEEP,
+    zero: import_constants7.default.ZERO,
+    replace: import_constants7.default.REPLACE,
+    invert: import_constants7.default.INVERT,
     "increment-clamp": import_constants7.default.INCR,
     "decrement-clamp": import_constants7.default.DECR,
     "increment-wrap": import_constants7.default.INCR_WRAP,
@@ -2444,53 +2449,53 @@ function mapBoolean(parameter, value) {
 function convertSamplerParametersToWebGL(props) {
   const params = {};
   if (props.addressModeU) {
-    params[import_constants8.default.TEXTURE_WRAP_S] = convertAddressMode(props.addressModeU);
+    params[import_constants8.GL.TEXTURE_WRAP_S] = convertAddressMode(props.addressModeU);
   }
   if (props.addressModeV) {
-    params[import_constants8.default.TEXTURE_WRAP_T] = convertAddressMode(props.addressModeV);
+    params[import_constants8.GL.TEXTURE_WRAP_T] = convertAddressMode(props.addressModeV);
   }
   if (props.addressModeW) {
-    params[import_constants8.default.TEXTURE_WRAP_R] = convertAddressMode(props.addressModeW);
+    params[import_constants8.GL.TEXTURE_WRAP_R] = convertAddressMode(props.addressModeW);
   }
   if (props.magFilter) {
-    params[import_constants8.default.TEXTURE_MAG_FILTER] = convertMaxFilterMode(props.magFilter);
+    params[import_constants8.GL.TEXTURE_MAG_FILTER] = convertMaxFilterMode(props.magFilter);
   }
   if (props.minFilter || props.mipmapFilter) {
-    params[import_constants8.default.TEXTURE_MIN_FILTER] = convertMinFilterMode(props.minFilter || "linear", props.mipmapFilter);
+    params[import_constants8.GL.TEXTURE_MIN_FILTER] = convertMinFilterMode(props.minFilter || "linear", props.mipmapFilter);
   }
   if (props.lodMinClamp !== void 0) {
-    params[import_constants8.default.TEXTURE_MIN_LOD] = props.lodMinClamp;
+    params[import_constants8.GL.TEXTURE_MIN_LOD] = props.lodMinClamp;
   }
   if (props.lodMaxClamp !== void 0) {
-    params[import_constants8.default.TEXTURE_MAX_LOD] = props.lodMaxClamp;
+    params[import_constants8.GL.TEXTURE_MAX_LOD] = props.lodMaxClamp;
   }
   if (props.type === "comparison-sampler") {
-    params[import_constants8.default.TEXTURE_COMPARE_MODE] = import_constants8.default.COMPARE_REF_TO_TEXTURE;
+    params[import_constants8.GL.TEXTURE_COMPARE_MODE] = import_constants8.GL.COMPARE_REF_TO_TEXTURE;
   }
   if (props.compare) {
-    params[import_constants8.default.TEXTURE_COMPARE_FUNC] = convertCompareFunction("compare", props.compare);
+    params[import_constants8.GL.TEXTURE_COMPARE_FUNC] = convertCompareFunction("compare", props.compare);
   }
   if (props.maxAnisotropy) {
-    params[import_constants8.default.TEXTURE_MAX_ANISOTROPY_EXT] = props.maxAnisotropy;
+    params[import_constants8.GL.TEXTURE_MAX_ANISOTROPY_EXT] = props.maxAnisotropy;
   }
   return params;
 }
 function convertAddressMode(addressMode) {
   switch (addressMode) {
     case "clamp-to-edge":
-      return import_constants8.default.CLAMP_TO_EDGE;
+      return import_constants8.GL.CLAMP_TO_EDGE;
     case "repeat":
-      return import_constants8.default.REPEAT;
+      return import_constants8.GL.REPEAT;
     case "mirror-repeat":
-      return import_constants8.default.MIRRORED_REPEAT;
+      return import_constants8.GL.MIRRORED_REPEAT;
   }
 }
 function convertMaxFilterMode(maxFilter) {
   switch (maxFilter) {
     case "nearest":
-      return import_constants8.default.NEAREST;
+      return import_constants8.GL.NEAREST;
     case "linear":
-      return import_constants8.default.LINEAR;
+      return import_constants8.GL.LINEAR;
   }
 }
 function convertMinFilterMode(minFilter, mipmapFilter) {
@@ -2499,18 +2504,18 @@ function convertMinFilterMode(minFilter, mipmapFilter) {
   }
   switch (minFilter) {
     case "nearest":
-      return mipmapFilter === "nearest" ? import_constants8.default.NEAREST_MIPMAP_NEAREST : import_constants8.default.NEAREST_MIPMAP_LINEAR;
+      return mipmapFilter === "nearest" ? import_constants8.GL.NEAREST_MIPMAP_NEAREST : import_constants8.GL.NEAREST_MIPMAP_LINEAR;
     case "linear":
-      return mipmapFilter === "nearest" ? import_constants8.default.LINEAR_MIPMAP_NEAREST : import_constants8.default.LINEAR_MIPMAP_LINEAR;
+      return mipmapFilter === "nearest" ? import_constants8.GL.LINEAR_MIPMAP_NEAREST : import_constants8.GL.LINEAR_MIPMAP_LINEAR;
   }
 }
 function updateSamplerParametersForNPOT(parameters) {
   const newParameters = __spreadValues({}, parameters);
-  if (parameters[import_constants8.default.TEXTURE_MIN_FILTER] !== import_constants8.default.NEAREST) {
-    newParameters[import_constants8.default.TEXTURE_MIN_FILTER] = import_constants8.default.LINEAR;
+  if (parameters[import_constants8.GL.TEXTURE_MIN_FILTER] !== import_constants8.GL.NEAREST) {
+    newParameters[import_constants8.GL.TEXTURE_MIN_FILTER] = import_constants8.GL.LINEAR;
   }
-  newParameters[import_constants8.default.TEXTURE_WRAP_S] = import_constants8.default.CLAMP_TO_EDGE;
-  newParameters[import_constants8.default.TEXTURE_WRAP_T] = import_constants8.default.CLAMP_TO_EDGE;
+  newParameters[import_constants8.GL.TEXTURE_WRAP_S] = import_constants8.GL.CLAMP_TO_EDGE;
+  newParameters[import_constants8.GL.TEXTURE_WRAP_T] = import_constants8.GL.CLAMP_TO_EDGE;
   return newParameters;
 }
 
@@ -2575,16 +2580,17 @@ var WEBGLBuffer = class extends import_api7.Buffer {
       this.trackDeallocatedMemory();
       this.gl.deleteBuffer(this.handle);
       this.destroyed = true;
+      this.handle = null;
     }
   }
   write(data, byteOffset = 0) {
     const srcOffset = 0;
-    const byteLength = data.byteLength;
+    const byteLength = void 0;
     const target = this.device.isWebGL2 ? import_constants9.default.COPY_WRITE_BUFFER : this.target;
     this.gl.bindBuffer(target, this.handle);
     if (srcOffset !== 0 || byteLength !== void 0) {
       this.device.assertWebGL2();
-      this.gl.bufferSubData(this.target, byteOffset, data, srcOffset, byteLength);
+      this.gl2.bufferSubData(target, byteOffset, data, srcOffset, byteLength);
     } else {
       this.gl.bufferSubData(target, byteOffset, data);
     }
@@ -2640,7 +2646,7 @@ function getWebGLUsage(usage) {
 
 // src/adapter/resources/webgl-sampler.ts
 var import_api8 = require("@luma.gl/api");
-var import_constants10 = __toESM(require("@luma.gl/constants"), 1);
+var import_constants10 = require("@luma.gl/constants");
 var WEBGLSampler = class extends import_api8.Sampler {
   constructor(device, props) {
     super(device, props);
@@ -2665,8 +2671,8 @@ var WEBGLSampler = class extends import_api8.Sampler {
     for (const [pname, value] of Object.entries(parameters)) {
       const param = Number(pname);
       switch (param) {
-        case import_constants10.default.TEXTURE_MIN_LOD:
-        case import_constants10.default.TEXTURE_MAX_LOD:
+        case import_constants10.GL.TEXTURE_MIN_LOD:
+        case import_constants10.GL.TEXTURE_MAX_LOD:
           this.device.gl2.samplerParameterf(this.handle, param, value);
           break;
         default:
@@ -2678,20 +2684,28 @@ var WEBGLSampler = class extends import_api8.Sampler {
 };
 
 // src/adapter/resources/webgl-texture.ts
+var DEFAULT_WEBGL_TEXTURE_PROPS = {
+  // deprecated
+  parameters: {},
+  pixelStore: {},
+  pixels: null,
+  border: 0,
+  dataFormat: void 0,
+  textureUnit: void 0,
+  target: void 0
+};
 var _WEBGLTexture = class extends import_api10.Texture {
   constructor(device, props) {
     var _a;
-    super(device, __spreadValues({ format: import_constants11.default.RGBA }, props));
-    this.width = void 0;
-    this.height = void 0;
-    this.depth = void 0;
-    this.format = void 0;
+    super(device, __spreadValues(__spreadProps(__spreadValues({}, DEFAULT_WEBGL_TEXTURE_PROPS), { format: "rgba8unorm" }), props));
+    /** Sampler object (currently unused) */
+    this.sampler = void 0;
+    // data;
+    this.glFormat = void 0;
     this.type = void 0;
     this.dataFormat = void 0;
     this.mipmaps = void 0;
     this.textureUnit = void 0;
-    /** Sampler object (currently unused) */
-    this.sampler = void 0;
     /**
      * Program.draw() checks the loaded flag of all textures to avoid
      * Textures that are still loading from promises
@@ -2703,6 +2717,7 @@ var _WEBGLTexture = class extends import_api10.Texture {
     this.gl2 = this.device.gl2;
     this.handle = this.props.handle || this.gl.createTexture();
     this.device.setSpectorMetadata(this.handle, __spreadProps(__spreadValues({}, this.props), { data: typeof this.props.data }));
+    this.glFormat = import_constants11.GL.RGBA;
     this.target = getWebGLTextureTarget(this.props);
     this.loaded = false;
     if (typeof ((_a = this.props) == null ? void 0 : _a.data) === "string") {
@@ -2748,7 +2763,6 @@ var _WEBGLTexture = class extends import_api10.Texture {
     const { parameters = {} } = props;
     const {
       pixels = null,
-      recreate = false,
       pixelStore = {},
       textureUnit = void 0
     } = props;
@@ -2757,6 +2771,7 @@ var _WEBGLTexture = class extends import_api10.Texture {
     }
     let { width, height, dataFormat, type, compressed = false, mipmaps = true } = props;
     const { depth = 0 } = props;
+    const glFormat = convertTextureFormatToGL(props.format, this.device.isWebGL2);
     ({ width, height, compressed, dataFormat, type } = this._deduceParameters({
       format: props.format,
       type,
@@ -2766,16 +2781,14 @@ var _WEBGLTexture = class extends import_api10.Texture {
       width,
       height
     }));
-    const format = getWebGLTextureFormat(this.gl, props.format);
     this.width = width;
     this.height = height;
-    this.depth = depth;
-    this.format = format;
+    this.glFormat = glFormat;
     this.type = type;
     this.dataFormat = dataFormat;
     this.textureUnit = textureUnit;
     if (Number.isFinite(this.textureUnit)) {
-      this.gl.activeTexture(import_constants11.default.TEXTURE0 + this.textureUnit);
+      this.gl.activeTexture(import_constants11.GL.TEXTURE0 + this.textureUnit);
       this.gl.bindTexture(this.target, this.handle);
     }
     if (mipmaps && this.device.isWebGL1 && isNPOT(this.width, this.height)) {
@@ -2788,7 +2801,7 @@ var _WEBGLTexture = class extends import_api10.Texture {
       width,
       height,
       depth,
-      format,
+      format: glFormat,
       type,
       dataFormat,
       // @ts-expect-error 
@@ -2800,9 +2813,6 @@ var _WEBGLTexture = class extends import_api10.Texture {
     if (mipmaps) {
       this.generateMipmap();
     }
-    if (recreate) {
-      this.data = data;
-    }
     if (isVideo) {
       this._video = {
         video: data,
@@ -2909,7 +2919,7 @@ var _WEBGLTexture = class extends import_api10.Texture {
    */
   // eslint-disable-next-line max-statements, complexity
   setImageData(options) {
-    if (this.props.dimension === "3d") {
+    if (this.props.dimension === "3d" || this.props.dimension === "2d-array") {
       return this.setImageData3D(options);
     }
     this.trackDeallocatedMemory("Texture");
@@ -2917,7 +2927,7 @@ var _WEBGLTexture = class extends import_api10.Texture {
       target = this.target,
       pixels = null,
       level = 0,
-      format = this.format,
+      glFormat = this.glFormat,
       offset = 0,
       parameters = {}
     } = options;
@@ -2949,13 +2959,13 @@ var _WEBGLTexture = class extends import_api10.Texture {
     withParameters(this.gl, parameters, () => {
       switch (dataType) {
         case "null":
-          gl.texImage2D(target, level, format, width, height, 0, dataFormat, type, data);
+          gl.texImage2D(target, level, glFormat, width, height, 0, dataFormat, type, data);
           break;
         case "typed-array":
           gl.texImage2D(
             target,
             level,
-            format,
+            glFormat,
             width,
             height,
             0,
@@ -2969,11 +2979,11 @@ var _WEBGLTexture = class extends import_api10.Texture {
           break;
         case "buffer":
           gl2 = this.device.assertWebGL2();
-          gl2.bindBuffer(import_constants11.default.PIXEL_UNPACK_BUFFER, data.handle || data);
+          gl2.bindBuffer(import_constants11.GL.PIXEL_UNPACK_BUFFER, data.handle || data);
           gl2.texImage2D(
             target,
             level,
-            format,
+            glFormat,
             width,
             height,
             0,
@@ -2981,14 +2991,14 @@ var _WEBGLTexture = class extends import_api10.Texture {
             type,
             offset
           );
-          gl2.bindBuffer(import_constants11.default.PIXEL_UNPACK_BUFFER, null);
+          gl2.bindBuffer(import_constants11.GL.PIXEL_UNPACK_BUFFER, null);
           break;
         case "browser-object":
           if (this.device.isWebGL2) {
             gl.texImage2D(
               target,
               level,
-              format,
+              glFormat,
               width,
               height,
               0,
@@ -2997,7 +3007,7 @@ var _WEBGLTexture = class extends import_api10.Texture {
               data
             );
           } else {
-            gl.texImage2D(target, level, format, dataFormat, type, data);
+            gl.texImage2D(target, level, glFormat, dataFormat, type, data);
           }
           break;
         case "compressed":
@@ -3020,7 +3030,7 @@ var _WEBGLTexture = class extends import_api10.Texture {
     if (data && data.byteLength) {
       this.trackAllocatedMemory(data.byteLength, "Texture");
     } else {
-      const bytesPerPixel = getTextureFormatBytesPerPixel(this.gl, this.props.format);
+      const bytesPerPixel = getTextureFormatBytesPerPixel(this.props.format, this.device.isWebGL2);
       this.trackAllocatedMemory(this.width * this.height * bytesPerPixel, "Texture");
     }
     this.loaded = true;
@@ -3040,7 +3050,7 @@ var _WEBGLTexture = class extends import_api10.Texture {
     width = this.width,
     height = this.height,
     level = 0,
-    format = this.format,
+    glFormat = this.glFormat,
     type = this.type,
     dataFormat = this.dataFormat,
     compressed = false,
@@ -3072,16 +3082,16 @@ var _WEBGLTexture = class extends import_api10.Texture {
     this.gl.bindTexture(this.target, this.handle);
     withParameters(this.gl, parameters, () => {
       if (compressed) {
-        this.gl.compressedTexSubImage2D(target, level, x, y, width, height, format, data);
+        this.gl.compressedTexSubImage2D(target, level, x, y, width, height, glFormat, data);
       } else if (data === null) {
         this.gl.texSubImage2D(target, level, x, y, width, height, dataFormat, type, null);
       } 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) {
         const gl2 = this.device.assertWebGL2();
-        gl2.bindBuffer(import_constants11.default.PIXEL_UNPACK_BUFFER, data);
+        gl2.bindBuffer(import_constants11.GL.PIXEL_UNPACK_BUFFER, data);
         gl2.texSubImage2D(target, level, x, y, width, height, dataFormat, type, offset);
-        gl2.bindBuffer(import_constants11.default.PIXEL_UNPACK_BUFFER, null);
+        gl2.bindBuffer(import_constants11.GL.PIXEL_UNPACK_BUFFER, null);
       } else if (this.device.isWebGL2) {
         const gl2 = this.device.assertWebGL2();
         gl2.texSubImage2D(target, level, x, y, width, height, dataFormat, type, data);
@@ -3106,7 +3116,7 @@ var _WEBGLTexture = class extends import_api10.Texture {
     return null;
   }
   getActiveUnit() {
-    return this.gl.getParameter(import_constants11.default.ACTIVE_TEXTURE) - import_constants11.default.TEXTURE0;
+    return this.gl.getParameter(import_constants11.GL.ACTIVE_TEXTURE) - import_constants11.GL.TEXTURE0;
   }
   bind(textureUnit = this.textureUnit) {
     const { gl } = this;
@@ -3149,7 +3159,7 @@ var _WEBGLTexture = class extends import_api10.Texture {
   _deduceParameters(opts) {
     const { format, data } = opts;
     let { width, height, dataFormat, type, compressed } = opts;
-    const parameters = getWebGLTextureParameters(this.gl, format);
+    const parameters = getWebGLTextureParameters(format, this.device.isWebGL2);
     dataFormat = dataFormat || parameters.dataFormat;
     type = type || parameters.type;
     compressed = compressed || parameters.compressed;
@@ -3190,7 +3200,7 @@ var _WEBGLTexture = class extends import_api10.Texture {
   setCubeMapImageData(options) {
     return __async(this, null, function* () {
       const { gl } = this;
-      const { width, height, pixels, data, format = import_constants11.default.RGBA, type = import_constants11.default.UNSIGNED_BYTE } = options;
+      const { width, height, pixels, data, format = import_constants11.GL.RGBA, type = import_constants11.GL.UNSIGNED_BYTE } = options;
       const imageDataMap = pixels || data;
       const resolvedFaces = yield Promise.all(
         _WEBGLTexture.FACES.map((face) => {
@@ -3222,8 +3232,8 @@ var _WEBGLTexture = class extends import_api10.Texture {
       height,
       pixels,
       data,
-      format = import_constants11.default.RGBA,
-      type = import_constants11.default.UNSIGNED_BYTE
+      format = import_constants11.GL.RGBA,
+      type = import_constants11.GL.UNSIGNED_BYTE
       // generateMipmap = false // TODO
     } = options;
     const { gl } = this;
@@ -3263,7 +3273,7 @@ var _WEBGLTexture = class extends import_api10.Texture {
     } = options;
     this.trackDeallocatedMemory("Texture");
     this.gl.bindTexture(this.target, this.handle);
-    const webglTextureFormat = getWebGLTextureParameters(this.gl, format);
+    const webglTextureFormat = getWebGLTextureParameters(format, this.device.isWebGL2);
     withParameters(this.gl, parameters, () => {
       if (ArrayBuffer.isView(data)) {
         this.gl.texImage3D(
@@ -3281,7 +3291,7 @@ var _WEBGLTexture = class extends import_api10.Texture {
         );
       }
       if (data instanceof WEBGLBuffer) {
-        this.gl.bindBuffer(import_constants11.default.PIXEL_UNPACK_BUFFER, data.handle);
+        this.gl.bindBuffer(import_constants11.GL.PIXEL_UNPACK_BUFFER, data.handle);
         this.gl.texImage3D(
           this.target,
           level,
@@ -3299,7 +3309,7 @@ var _WEBGLTexture = class extends import_api10.Texture {
     if (data && data.byteLength) {
       this.trackAllocatedMemory(data.byteLength, "Texture");
     } else {
-      const bytesPerPixel = getTextureFormatBytesPerPixel(this.gl, this.props.format);
+      const bytesPerPixel = getTextureFormatBytesPerPixel(this.props.format, this.device.isWebGL2);
       this.trackAllocatedMemory(this.width * this.height * this.depth * bytesPerPixel, "Texture");
     }
     this.loaded = true;
@@ -3323,8 +3333,8 @@ var _WEBGLTexture = class extends import_api10.Texture {
       const param = Number(pname);
       const value = pvalue;
       switch (param) {
-        case import_constants11.default.TEXTURE_MIN_LOD:
-        case import_constants11.default.TEXTURE_MAX_LOD:
+        case import_constants11.GL.TEXTURE_MIN_LOD:
+        case import_constants11.GL.TEXTURE_MAX_LOD:
           this.gl.texParameterf(this.target, param, value);
           break;
         default:
@@ -3340,14 +3350,14 @@ var _WEBGLTexture = class extends import_api10.Texture {
     const npot = this.device.isWebGL1 && isNPOT(this.width, this.height);
     if (npot) {
       switch (pname) {
-        case import_constants11.default.TEXTURE_MIN_FILTER:
-          if (value !== import_constants11.default.LINEAR && value !== import_constants11.default.NEAREST) {
-            return import_constants11.default.LINEAR;
+        case import_constants11.GL.TEXTURE_MIN_FILTER:
+          if (value !== import_constants11.GL.LINEAR && value !== import_constants11.GL.NEAREST) {
+            return import_constants11.GL.LINEAR;
           }
           break;
-        case import_constants11.default.TEXTURE_WRAP_S:
-        case import_constants11.default.TEXTURE_WRAP_T:
-          return import_constants11.default.CLAMP_TO_EDGE;
+        case import_constants11.GL.TEXTURE_WRAP_S:
+        case import_constants11.GL.TEXTURE_WRAP_T:
+          return import_constants11.GL.CLAMP_TO_EDGE;
         default:
           break;
       }
@@ -3358,23 +3368,23 @@ var _WEBGLTexture = class extends import_api10.Texture {
 var WEBGLTexture = _WEBGLTexture;
 // TODO - remove?
 WEBGLTexture.FACES = [
-  import_constants11.default.TEXTURE_CUBE_MAP_POSITIVE_X,
-  import_constants11.default.TEXTURE_CUBE_MAP_NEGATIVE_X,
-  import_constants11.default.TEXTURE_CUBE_MAP_POSITIVE_Y,
-  import_constants11.default.TEXTURE_CUBE_MAP_NEGATIVE_Y,
-  import_constants11.default.TEXTURE_CUBE_MAP_POSITIVE_Z,
-  import_constants11.default.TEXTURE_CUBE_MAP_NEGATIVE_Z
+  import_constants11.GL.TEXTURE_CUBE_MAP_POSITIVE_X,
+  import_constants11.GL.TEXTURE_CUBE_MAP_NEGATIVE_X,
+  import_constants11.GL.TEXTURE_CUBE_MAP_POSITIVE_Y,
+  import_constants11.GL.TEXTURE_CUBE_MAP_NEGATIVE_Y,
+  import_constants11.GL.TEXTURE_CUBE_MAP_POSITIVE_Z,
+  import_constants11.GL.TEXTURE_CUBE_MAP_NEGATIVE_Z
 ];
 function getWebGLTextureTarget(props) {
   switch (props.dimension) {
     case "2d":
-      return import_constants11.default.TEXTURE_2D;
+      return import_constants11.GL.TEXTURE_2D;
     case "cube":
-      return import_constants11.default.TEXTURE_CUBE_MAP;
+      return import_constants11.GL.TEXTURE_CUBE_MAP;
     case "2d-array":
-      return import_constants11.default.TEXTURE_2D_ARRAY;
+      return import_constants11.GL.TEXTURE_2D_ARRAY;
     case "3d":
-      return import_constants11.default.TEXTURE_3D;
+      return import_constants11.GL.TEXTURE_3D;
     case "1d":
     case "cube-array":
     default:
@@ -3393,7 +3403,7 @@ function logParameters(parameters) {
 
 // src/adapter/objects/webgl-renderbuffer.ts
 var import_api13 = require("@luma.gl/api");
-var import_constants13 = __toESM(require("@luma.gl/constants"), 1);
+var import_constants12 = __toESM(require("@luma.gl/constants"), 1);
 
 // src/adapter/objects/webgl-resource.ts
 var import_api12 = require("@luma.gl/api");
@@ -3413,16 +3423,6 @@ function getKeyValue(gl, name) {
   (0, import_api11.assert)(value !== void 0, `Accessing undefined constant GL.${name}`);
   return value;
 }
-function getKey(gl, value) {
-  gl = gl.gl || gl;
-  value = Number(value);
-  for (const key in gl) {
-    if (gl[key] === value) {
-      return `GL.${key}`;
-    }
-  }
-  return String(value);
-}
 
 // src/adapter/objects/webgl-resource.ts
 var ERR_RESOURCE_METHOD_UNDEFINED = "Resource subclass must define virtual methods";
@@ -3451,9 +3451,6 @@ var WebGLResource = class extends import_api12.Resource {
   get handle() {
     return this._handle;
   }
-  destroy() {
-    this.delete();
-  }
   delete({ deleteChildren = false } = {}) {
     const children = this._handle && this._deleteHandle(this._handle);
     if (this._handle) {
@@ -3461,7 +3458,7 @@ var WebGLResource = class extends import_api12.Resource {
     }
     this._handle = null;
     if (children && deleteChildren) {
-      children.filter(Boolean).forEach((child) => child.delete());
+      children.filter(Boolean).forEach((child) => child.destroy());
     }
     return this;
   }
@@ -3521,10 +3518,10 @@ var WebGLResource = class extends import_api12.Resource {
       const parameter = PARAMETERS[pname];
       const parameterAvailable = parameter && (!("webgl2" in parameter) || isWebgl2) && (!("extension" in parameter) || this.gl.getExtension(parameter.extension));
       if (parameterAvailable) {
-        const key = keys ? getKey(this.gl, pname) : pname;
+        const key = keys ? this.device.getGLKey(pname) : pname;
         values[key] = this.getParameter(pname, options);
         if (keys && parameter.type === "GLenum") {
-          values[key] = getKey(this.gl, values[key]);
+          values[key] = this.device.getGLKey(values[key]);
         }
       }
     }
@@ -3629,88 +3626,16 @@ var WebGLResource = class extends import_api12.Resource {
     */
 };
 
-// src/adapter/converters/renderbuffer-formats.ts
-var import_constants12 = __toESM(require("@luma.gl/constants"), 1);
-function isRenderbufferFormatSupported(gl, format) {
-  const info = RENDERBUFFER_FORMATS[format];
-  if (!info) {
-    return false;
-  }
-  if (info.ext) {
-    return Boolean(gl.getExtension(info.ext));
-  }
-  if (info.gl2) {
-    return isWebGL2(gl);
-  }
-  return true;
-}
-function getRenderbufferFormatBytesPerPixel(format) {
-  return RENDERBUFFER_FORMATS[format].bpp;
-}
-var EXT_FLOAT_WEBGL2 = "EXT_color_buffer_float";
-var RENDERBUFFER_FORMATS = {
-  [import_constants12.default.DEPTH_COMPONENT16]: { bpp: 2 },
-  // 16 depth bits.
-  [import_constants12.default.DEPTH_COMPONENT24]: { gl2: true, bpp: 3 },
-  [import_constants12.default.DEPTH_COMPONENT32F]: { gl2: true, bpp: 4 },
-  [import_constants12.default.STENCIL_INDEX8]: { bpp: 1 },
-  // 8 stencil bits.
-  [import_constants12.default.DEPTH_STENCIL]: { bpp: 4 },
-  [import_constants12.default.DEPTH24_STENCIL8]: { gl2: true, bpp: 4 },
-  [import_constants12.default.DEPTH32F_STENCIL8]: { gl2: true, bpp: 5 },
-  // When using a WebGL 1 context, color renderbuffer formats are limited
-  [import_constants12.default.RGBA4]: { bpp: 2 },
-  [import_constants12.default.RGB565]: { bpp: 2 },
-  [import_constants12.default.RGB5_A1]: { bpp: 2 },
-  // When using a WebGL 2 context, the following values are available additionally:
-  [import_constants12.default.R8]: { gl2: true, bpp: 1 },
-  [import_constants12.default.R8UI]: { gl2: true, bpp: 1 },
-  [import_constants12.default.R8I]: { gl2: true, bpp: 1 },
-  [import_constants12.default.R16UI]: { gl2: true, bpp: 2 },
-  [import_constants12.default.R16I]: { gl2: true, bpp: 2 },
-  [import_constants12.default.R32UI]: { gl2: true, bpp: 4 },
-  [import_constants12.default.R32I]: { gl2: true, bpp: 4 },
-  [import_constants12.default.RG8]: { gl2: true, bpp: 2 },
-  [import_constants12.default.RG8UI]: { gl2: true, bpp: 2 },
-  [import_constants12.default.RG8I]: { gl2: true, bpp: 2 },
-  [import_constants12.default.RG16UI]: { gl2: true, bpp: 4 },
-  [import_constants12.default.RG16I]: { gl2: true, bpp: 4 },
-  [import_constants12.default.RG32UI]: { gl2: true, bpp: 8 },
-  [import_constants12.default.RG32I]: { gl2: true, bpp: 8 },
-  [import_constants12.default.RGB8]: { gl2: true, bpp: 3 },
-  [import_constants12.default.RGBA8]: { gl2: true, bpp: 4 },
-  // [GL.SRGB8_ALPHA8]: {gl2: true, gl1: SRGB}, // When using the EXT_sRGB WebGL1 extension
-  [import_constants12.default.RGB10_A2]: { gl2: true, bpp: 4 },
-  [import_constants12.default.RGBA8UI]: { gl2: true, bpp: 4 },
-  [import_constants12.default.RGBA8I]: { gl2: true, bpp: 4 },
-  [import_constants12.default.RGB10_A2UI]: { gl2: true, bpp: 4 },
-  [import_constants12.default.RGBA16UI]: { gl2: true, bpp: 8 },
-  [import_constants12.default.RGBA16I]: { gl2: true, bpp: 8 },
-  [import_constants12.default.RGBA32I]: { gl2: true, bpp: 16 },
-  [import_constants12.default.RGBA32UI]: { gl2: true, bpp: 16 },
-  // When using a WebGL 2 context and the EXT_color_buffer_float WebGL2 extension
-  [import_constants12.default.R16F]: { ext: EXT_FLOAT_WEBGL2, bpp: 2 },
-  [import_constants12.default.RG16F]: { ext: EXT_FLOAT_WEBGL2, bpp: 4 },
-  [import_constants12.default.RGBA16F]: { ext: EXT_FLOAT_WEBGL2, bpp: 8 },
-  [import_constants12.default.R32F]: { ext: EXT_FLOAT_WEBGL2, bpp: 4 },
-  [import_constants12.default.RG32F]: { ext: EXT_FLOAT_WEBGL2, bpp: 8 },
-  // TODO - can't get WEBGL_color_buffer_float to work on renderbuffers
-  [import_constants12.default.RGBA32F]: { ext: EXT_FLOAT_WEBGL2, bpp: 16 },
-  // [GL.RGBA32F]: {ext: EXT_FLOAT_WEBGL2, gl1: EXT_FLOAT_WEBGL1},
-  [import_constants12.default.R11F_G11F_B10F]: { ext: EXT_FLOAT_WEBGL2, bpp: 4 }
-};
-
 // src/adapter/objects/webgl-renderbuffer.ts
-var DEFAULT_RENDERBUFFER_PROPS = {
-  id: void 0,
-  handle: void 0,
-  userData: void 0,
-  format: 0,
-  width: 1,
-  height: 1,
-  samples: 0
-};
-var WEBGLRenderbuffer = class extends WebGLResource {
+var _WEBGLRenderbuffer = class extends WebGLResource {
+  constructor(device, props) {
+    if (typeof props.format === "number") {
+      throw new Error("Renderbuffer");
+    }
+    super(device, props, _WEBGLRenderbuffer.defaultProps);
+    this.glFormat = convertTextureFormatToGL(this.props.format, device.isWebGL2);
+    this._initialize(this.props);
+  }
   get [Symbol.toStringTag]() {
     return "Renderbuffer";
   }
@@ -3726,19 +3651,17 @@ var WEBGLRenderbuffer = class extends WebGLResource {
   get samples() {
     return this.props.samples;
   }
-  static isSupported(gl, options) {
-    return !(options == null ? void 0 : options.format) || isRenderbufferFormatSupported(gl, options.format);
+  get attachment() {
+    return;
   }
-  constructor(device, props) {
-    super(device, props, DEFAULT_RENDERBUFFER_PROPS);
-    this._initialize(this.props);
+  static isTextureFormatSupported(device, format) {
+    return isRenderbufferFormatSupported(device.gl, format);
   }
   resize(size) {
     if (size.width !== this.width || size.height !== this.height) {
       Object.assign(this.props, __spreadProps(__spreadValues({}, size), { format: this.format, samples: this.samples }));
       this._initialize(this.props);
     }
-    return this;
   }
   // PRIVATE METHODS
   /** Creates and initializes a renderbuffer object's data store */
@@ -3746,17 +3669,16 @@ var WEBGLRenderbuffer = class extends WebGLResource {
     const { format, width, height, samples } = props;
     (0, import_api13.assert)(format, "Needs format");
     this.trackDeallocatedMemory();
-    this.gl.bindRenderbuffer(import_constants13.default.RENDERBUFFER, this.handle);
+    this.gl.bindRenderbuffer(import_constants12.default.RENDERBUFFER, this.handle);
     if (samples !== 0 && this.device.isWebGL2) {
-      this.gl.renderbufferStorageMultisample(import_constants13.default.RENDERBUFFER, samples, format, width, height);
+      this.gl2.renderbufferStorageMultisample(import_constants12.default.RENDERBUFFER, samples, this.glFormat, width, height);
     } else {
-      this.gl.renderbufferStorage(import_constants13.default.RENDERBUFFER, format, width, height);
+      this.gl.renderbufferStorage(import_constants12.default.RENDERBUFFER, this.glFormat, width, height);
     }
-    this.gl.bindRenderbuffer(import_constants13.default.RENDERBUFFER, null);
+    this.gl.bindRenderbuffer(import_constants12.default.RENDERBUFFER, null);
     this.trackAllocatedMemory(
-      width * height * (samples || 1) * getRenderbufferFormatBytesPerPixel(format)
+      width * height * (samples || 1) * getTextureFormatBytesPerPixel(this.glFormat, this.device.isWebGL2)
     );
-    return this;
   }
   // RESOURCE IMPLEMENTATION
   _createHandle() {
@@ -3767,37 +3689,48 @@ var WEBGLRenderbuffer = class extends WebGLResource {
     this.trackDeallocatedMemory();
   }
   _bindHandle(handle) {
-    this.gl.bindRenderbuffer(import_constants13.default.RENDERBUFFER, handle);
+    this.gl.bindRenderbuffer(import_constants12.default.RENDERBUFFER, handle);
   }
 };
+var WEBGLRenderbuffer = _WEBGLRenderbuffer;
+WEBGLRenderbuffer.defaultProps = {
+  id: void 0,
+  handle: void 0,
+  userData: void 0,
+  format: void 0,
+  // 'depth16unorm'
+  width: 1,
+  height: 1,
+  samples: 0
+};
 
 // src/adapter/resources/webgl-framebuffer.ts
 var WEBGLFramebuffer = class extends import_api14.Framebuffer {
   constructor(device, props) {
     super(device, props);
-    this.colorAttachments = [];
-    this.depthStencilAttachment = null;
-    this._ownResources = [];
+    const isDefaultFramebuffer = props.handle === null;
     this.device = device;
     this.gl = device.gl;
-    this.handle = this.props.handle !== void 0 ? this.props.handle : this.gl.createFramebuffer();
-    if (this.handle) {
+    this.handle = this.props.handle || isDefaultFramebuffer ? this.props.handle : this.gl.createFramebuffer();
+    if (!isDefaultFramebuffer) {
       device.setSpectorMetadata(this.handle, { id: this.props.id, props: this.props });
-    }
-    this.colorAttachments = this._createColorAttachments();
-    this.depthStencilAttachment = this._createDepthStencilAttachment();
-    const prevHandle = this.gl.bindFramebuffer(import_constants14.default.FRAMEBUFFER, this.handle);
-    for (let i = 0; i < this.colorAttachments.length; ++i) {
-      const attachment = this.colorAttachments[i];
-      const attachmentPoint = import_constants14.default.COLOR_ATTACHMENT0 + i;
-      if (attachment) {
-        this._attachOne(attachmentPoint, attachment);
+      this.autoCreateAttachmentTextures();
+      this.gl.bindFramebuffer(import_constants13.default.FRAMEBUFFER, this.handle);
+      for (let i = 0; i < this.colorAttachments.length; ++i) {
+        const attachment = this.colorAttachments[i];
+        const attachmentPoint = import_constants13.default.COLOR_ATTACHMENT0 + i;
+        if (attachment) {
+          this._attachOne(attachmentPoint, attachment);
+        }
       }
+      if (this.depthStencilAttachment) {
+        this._attachOne(
+          getDepthStencilAttachmentWebGL(this.depthStencilAttachment.format),
+          this.depthStencilAttachment
+        );
+      }
+      this.gl.bindFramebuffer(import_constants13.default.FRAMEBUFFER, null);
     }
-    if (this.props.depthStencilAttachment) {
-      this._attachOne(getWebGLDepthStencilAttachment(this.depthStencilAttachment.format), this.depthStencilAttachment);
-    }
-    this.gl.bindFramebuffer(import_constants14.default.FRAMEBUFFER, prevHandle || null);
     if (props.check !== false) {
       this._checkStatus();
     }
@@ -3805,98 +3738,40 @@ var WEBGLFramebuffer = class extends import_api14.Framebuffer {
   get texture() {
     return this.colorAttachments[0];
   }
+  /** destroys any auto created resources etc. */
   destroy() {
-    if (this.handle !== null) {
-      for (const resource of this._ownResources) {
-        resource.destroy();
-      }
+    super.destroy();
+    if (!this.destroyed && this.handle !== null) {
       this.gl.deleteFramebuffer(this.handle);
-      this.destroyed = true;
     }
   }
   // PRIVATE
   /** Check the status */
   _checkStatus() {
     const { gl } = this;
-    const prevHandle = gl.bindFramebuffer(import_constants14.default.FRAMEBUFFER, this.handle);
-    const status = gl.checkFramebufferStatus(import_constants14.default.FRAMEBUFFER);
-    gl.bindFramebuffer(import_constants14.default.FRAMEBUFFER, prevHandle || null);
+    const prevHandle2 = gl.bindFramebuffer(import_constants13.default.FRAMEBUFFER, this.handle);
+    const status = gl.checkFramebufferStatus(import_constants13.default.FRAMEBUFFER);
+    gl.bindFramebuffer(import_constants13.default.FRAMEBUFFER, prevHandle2 || null);
     if (status !== gl.FRAMEBUFFER_COMPLETE) {
       throw new Error(`Framebuffer ${_getFrameBufferStatus(status)}`);
     }
   }
-  _createColorAttachments() {
-    return this.props.colorAttachments.map((colorAttachment) => {
-      if (!colorAttachment) {
-        return void 0;
-      }
-      if (colorAttachment instanceof WEBGLTexture) {
-        return colorAttachment;
-      }
-      return this._createColorAttachment(colorAttachment, this.width, this.height);
-    });
-  }
-  /** Create a color attachment */
-  _createColorAttachment(format, width, height) {
-    const texture = this.device._createTexture({
-      id: `${this.id}-color`,
-      data: null,
-      // reserves texture memory, but texels are undefined
-      format,
-      // type: GL.UNSIGNED_BYTE,
-      width,
-      height,
-      // Note: Mipmapping can be disabled by texture resource when we resize the texture
-      // to a non-power-of-two dimenstion (NPOT texture) under WebGL1. To have consistant
-      // behavior we always disable mipmaps.
-      mipmaps: false,
-      // Set MIN and MAG filtering parameters so mipmaps are not used in sampling.
-      // Use LINEAR so subpixel algos like fxaa work.
-      // Set WRAP modes that support NPOT textures too.
-      sampler: {
-        minFilter: "linear",
-        magFilter: "linear",
-        addressModeU: "clamp-to-edge",
-        addressModeV: "clamp-to-edge"
-      }
-      // parameters: {
-      //   [GL.TEXTURE_MIN_FILTER]: GL.LINEAR,
-      //   [GL.TEXTURE_MAG_FILTER]: GL.LINEAR,
-      //   [GL.TEXTURE_WRAP_S]: GL.CLAMP_TO_EDGE,
-      //   [GL.TEXTURE_WRAP_T]: GL.CLAMP_TO_EDGE
-      // }
-    });
-    this._ownResources.push(texture);
-    return texture;
-  }
-  /** Create a depth stencil attachment GL.DEPTH24_STENCIL8 */
-  _createDepthStencilAttachment() {
-    if (!this.props.depthStencilAttachment) {
-      return void 0;
-    }
-    if (this.props.depthStencilAttachment instanceof WEBGLRenderbuffer) {
-      return this.props.depthStencilAttachment;
-    }
-    if (this.props.depthStencilAttachment instanceof import_api14.Texture) {
-      return this.props.depthStencilAttachment;
-    }
-    const format = this.props.depthStencilAttachment;
-    const webglFormat = getWebGLTextureFormat(this.gl, format);
-    const texture = new WEBGLRenderbuffer(this.device, {
+  /** In WebGL we must use renderbuffers for depth/stencil attachments (unless we have extensions) */
+  createDepthStencilTexture(format) {
+    return new WEBGLRenderbuffer(this.device, {
       id: `${this.id}-depth-stencil`,
       // TODO misleading if not depth and stencil?
-      format: webglFormat,
+      format,
       // dataFormat: GL.DEPTH_STENCIL,
       // type: GL.UNSIGNED_INT_24_8,
       width: this.width,
       height: this.height
     });
-    this._ownResources.push(texture);
-    return texture;
   }
-  /** Attachment resize is expected to be a noop if size is same */
-  _resizeAttachments(width, height) {
-    var _a;
+  /** 
+   * Attachment resize is expected to be a noop if size is same 
+   */
+  resizeAttachments(width, height) {
     if (this.handle === null) {
       this.width = this.gl.drawingBufferWidth;
       this.height = this.gl.drawingBufferHeight;
@@ -3908,13 +3783,12 @@ var WEBGLFramebuffer = class extends import_api14.Framebuffer {
     if (height === void 0) {
       height = this.gl.drawingBufferHeight;
     }
-    if (width !== this.width && height !== this.height) {
-      import_api14.log.log(2, `Resizing framebuffer ${this.id} to ${width}x${height}`)();
-    }
     for (const colorAttachment of this.colorAttachments) {
       colorAttachment.resize({ width, height });
     }
-    (_a = this.depthStencilAttachment) == null ? void 0 : _a.resize({ width, height });
+    if (this.depthStencilAttachment) {
+      this.depthStencilAttachment.resize({ width, height });
+    }
     return this;
   }
   /** Attach one attachment */
@@ -3934,9 +3808,9 @@ var WEBGLFramebuffer = class extends import_api14.Framebuffer {
   }
   _attachWEBGLRenderbuffer(attachment, renderbuffer) {
     this.gl.framebufferRenderbuffer(
-      import_constants14.default.FRAMEBUFFER,
+      import_constants13.default.FRAMEBUFFER,
       attachment,
-      import_constants14.default.RENDERBUFFER,
+      import_constants13.default.RENDERBUFFER,
       renderbuffer.handle
     );
   }
@@ -3950,17 +3824,17 @@ var WEBGLFramebuffer = class extends import_api14.Framebuffer {
     const { gl, gl2 } = this.device;
     gl.bindTexture(texture.target, texture.handle);
     switch (texture.target) {
-      case import_constants14.default.TEXTURE_2D_ARRAY:
-      case import_constants14.default.TEXTURE_3D:
+      case import_constants13.default.TEXTURE_2D_ARRAY:
+      case import_constants13.default.TEXTURE_3D:
         this.device.assertWebGL2();
-        gl2 == null ? void 0 : gl2.framebufferTextureLayer(import_constants14.default.FRAMEBUFFER, attachment, texture.target, level, layer);
+        gl2 == null ? void 0 : gl2.framebufferTextureLayer(import_constants13.default.FRAMEBUFFER, attachment, texture.target, level, layer);
         break;
-      case import_constants14.default.TEXTURE_CUBE_MAP:
+      case import_constants13.default.TEXTURE_CUBE_MAP:
         const face = mapIndexToCubeMapFace(layer);
-        gl.framebufferTexture2D(import_constants14.default.FRAMEBUFFER, attachment, face, texture.handle, level);
+        gl.framebufferTexture2D(import_constants13.default.FRAMEBUFFER, attachment, face, texture.handle, level);
         break;
-      case import_constants14.default.TEXTURE_2D:
-        gl.framebufferTexture2D(import_constants14.default.FRAMEBUFFER, attachment, import_constants14.default.TEXTURE_2D, texture.handle, level);
+      case import_constants13.default.TEXTURE_2D:
+        gl.framebufferTexture2D(import_constants13.default.FRAMEBUFFER, attachment, import_constants13.default.TEXTURE_2D, texture.handle, level);
         break;
       default:
         (0, import_api14.assert)(false, "Illegal texture type");
@@ -3969,21 +3843,21 @@ var WEBGLFramebuffer = class extends import_api14.Framebuffer {
   }
 };
 function mapIndexToCubeMapFace(layer) {
-  return layer < import_constants14.default.TEXTURE_CUBE_MAP_POSITIVE_X ? layer + import_constants14.default.TEXTURE_CUBE_MAP_POSITIVE_X : layer;
+  return layer < import_constants13.default.TEXTURE_CUBE_MAP_POSITIVE_X ? layer + import_constants13.default.TEXTURE_CUBE_MAP_POSITIVE_X : layer;
 }
 function _getFrameBufferStatus(status) {
   switch (status) {
-    case import_constants14.default.FRAMEBUFFER_COMPLETE:
+    case import_constants13.default.FRAMEBUFFER_COMPLETE:
       return "success";
-    case import_constants14.default.FRAMEBUFFER_INCOMPLETE_ATTACHMENT:
+    case import_constants13.default.FRAMEBUFFER_INCOMPLETE_ATTACHMENT:
       return "Mismatched attachments";
-    case import_constants14.default.FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT:
+    case import_constants13.default.FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT:
       return "No attachments";
-    case import_constants14.default.FRAMEBUFFER_INCOMPLETE_DIMENSIONS:
+    case import_constants13.default.FRAMEBUFFER_INCOMPLETE_DIMENSIONS:
       return "Height/width mismatch";
-    case import_constants14.default.FRAMEBUFFER_UNSUPPORTED:
+    case import_constants13.default.FRAMEBUFFER_UNSUPPORTED:
       return "Unsupported or split attachments";
-    case import_constants14.default.FRAMEBUFFER_INCOMPLETE_MULTISAMPLE:
+    case import_constants13.default.FRAMEBUFFER_INCOMPLETE_MULTISAMPLE:
       return "Samples mismatch";
     default:
       return `${status}`;
@@ -4100,7 +3974,7 @@ function initializeSpectorJS(props) {
 
 // src/context/debug/webgl-developer-tools.ts
 var import_api17 = require("@luma.gl/api");
-var import_constants15 = __toESM(require("@luma.gl/constants"), 1);
+var import_constants14 = __toESM(require("@luma.gl/constants"), 1);
 var WEBGL_DEBUG_CDN_URL = "https://unpkg.com/webgl-debug@2.0.1/index.js";
 function getContextData2(gl) {
   gl.luma = gl.luma || {};
@@ -4134,15 +4008,15 @@ function getDebugContext(gl, props) {
   if (data.debugContext) {
     return data.debugContext;
   }
-  globalThis.WebGLDebugUtils.init(__spreadValues(__spreadValues({}, import_constants15.default), gl));
+  globalThis.WebGLDebugUtils.init(__spreadValues(__spreadValues({}, import_constants14.default), gl));
   const glDebug = globalThis.WebGLDebugUtils.makeDebugContext(
     gl,
     onGLError.bind(null, props),
     onValidateGLFunc.bind(null, props)
   );
-  for (const key in import_constants15.default) {
-    if (!(key in glDebug) && typeof import_constants15.default[key] === "number") {
-      glDebug[key] = import_constants15.default[key];
+  for (const key in import_constants14.default) {
+    if (!(key in glDebug) && typeof import_constants14.default[key] === "number") {
+      glDebug[key] = import_constants14.default[key];
     }
   }
   class WebGLDebugContext {
@@ -4201,34 +4075,34 @@ function onValidateGLFunc(props, functionName, functionArgs) {
 
 // src/classic/buffer.ts
 var import_api19 = require("@luma.gl/api");
-var import_constants18 = __toESM(require("@luma.gl/constants"), 1);
+var import_constants17 = __toESM(require("@luma.gl/constants"), 1);
 
 // src/classic/accessor.ts
 var import_api18 = require("@luma.gl/api");
-var import_constants17 = __toESM(require("@luma.gl/constants"), 1);
+var import_constants16 = __toESM(require("@luma.gl/constants"), 1);
 
 // src/classic/typed-array-utils.ts
-var import_constants16 = __toESM(require("@luma.gl/constants"), 1);
+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.default.FLOAT;
+      return import_constants15.GL.FLOAT;
     case Uint16Array:
-      return import_constants16.default.UNSIGNED_SHORT;
+      return import_constants15.GL.UNSIGNED_SHORT;
     case Uint32Array:
-      return import_constants16.default.UNSIGNED_INT;
+      return import_constants15.GL.UNSIGNED_INT;
     case Uint8Array:
-      return import_constants16.default.UNSIGNED_BYTE;
+      return import_constants15.GL.UNSIGNED_BYTE;
     case Uint8ClampedArray:
-      return import_constants16.default.UNSIGNED_BYTE;
+      return import_constants15.GL.UNSIGNED_BYTE;
     case Int8Array:
-      return import_constants16.default.BYTE;
+      return import_constants15.GL.BYTE;
     case Int16Array:
-      return import_constants16.default.SHORT;
+      return import_constants15.GL.SHORT;
     case Int32Array:
-      return import_constants16.default.INT;
+      return import_constants15.GL.INT;
     default:
       throw new Error(ERR_TYPE_DEDUCTION);
   }
@@ -4236,22 +4110,22 @@ function getGLTypeFromTypedArray(arrayOrType) {
 function getTypedArrayFromGLType(glType, options) {
   const { clamped = true } = options || {};
   switch (glType) {
-    case import_constants16.default.FLOAT:
+    case import_constants15.GL.FLOAT:
       return Float32Array;
-    case import_constants16.default.UNSIGNED_SHORT:
-    case import_constants16.default.UNSIGNED_SHORT_5_6_5:
-    case import_constants16.default.UNSIGNED_SHORT_4_4_4_4:
-    case import_constants16.default.UNSIGNED_SHORT_5_5_5_1:
+    case import_constants15.GL.UNSIGNED_SHORT:
+    case import_constants15.GL.UNSIGNED_SHORT_5_6_5:
+    case import_constants15.GL.UNSIGNED_SHORT_4_4_4_4:
+    case import_constants15.GL.UNSIGNED_SHORT_5_5_5_1:
       return Uint16Array;
-    case import_constants16.default.UNSIGNED_INT:
+    case import_constants15.GL.UNSIGNED_INT:
       return Uint32Array;
-    case import_constants16.default.UNSIGNED_BYTE:
+    case import_constants15.GL.UNSIGNED_BYTE:
       return clamped ? Uint8ClampedArray : Uint8Array;
-    case import_constants16.default.BYTE:
+    case import_constants15.GL.BYTE:
       return Int8Array;
-    case import_constants16.default.SHORT:
+    case import_constants15.GL.SHORT:
       return Int16Array;
-    case import_constants16.default.INT:
+    case import_constants15.GL.INT:
       return Int32Array;
     default:
       throw new Error("Failed to deduce typed array type from GL constant");
@@ -4262,7 +4136,7 @@ function getTypedArrayFromGLType(glType, options) {
 var DEFAULT_ACCESSOR_VALUES = {
   offset: 0,
   stride: 0,
-  type: import_constants17.default.FLOAT,
+  type: import_constants16.default.FLOAT,
   size: 1,
   divisor: 0,
   normalized: false,
@@ -4276,12 +4150,12 @@ var PROP_CHECKS = {
 };
 var Accessor = class {
   static getBytesPerElement(accessor) {
-    const ArrayType = getTypedArrayFromGLType(accessor.type || import_constants17.default.FLOAT);
+    const ArrayType = getTypedArrayFromGLType(accessor.type || import_constants16.default.FLOAT);
     return ArrayType.BYTES_PER_ELEMENT;
   }
   static getBytesPerVertex(accessor) {
     (0, import_api18.assert)(accessor.size);
-    const ArrayType = getTypedArrayFromGLType(accessor.type || import_constants17.default.FLOAT);
+    const ArrayType = getTypedArrayFromGLType(accessor.type || import_constants16.default.FLOAT);
     return ArrayType.BYTES_PER_ELEMENT * accessor.size;
   }
   // Combines (merges) a list of accessors. On top of default values
@@ -4312,7 +4186,7 @@ var Accessor = class {
     props = (0, import_api18.checkProps)("Accessor", props, PROP_CHECKS);
     if (props.type !== void 0) {
       this.type = props.type;
-      if (props.type === import_constants17.default.INT || props.type === import_constants17.default.UNSIGNED_INT) {
+      if (props.type === import_constants16.default.INT || props.type === import_constants16.default.UNSIGNED_INT) {
         this.integer = true;
       }
     }
@@ -4424,9 +4298,9 @@ var ClassicBuffer = class extends WEBGLBuffer {
     }
     Object.seal(this);
   }
-  write(data, byteOffset) {
-    this.subData({ data, offset: byteOffset });
-  }
+  // override write(data: TypedArray, byteOffset: number = 0): void {
+  //   this.subData({data, offset: byteOffset});
+  // }
   // returns number of elements in the buffer (assuming that the full buffer is used)
   getElementCount(accessor = this.accessor) {
     return Math.round(this.byteLength / Accessor.getBytesPerElement(accessor));
@@ -4447,7 +4321,7 @@ var ClassicBuffer = class extends WEBGLBuffer {
       props = { byteLength: props };
     }
     props = (0, import_api19.checkProps)("Buffer", props, PROP_CHECKS_INITIALIZE);
-    this.webglUsage = props.webglUsage || import_constants18.default.STATIC_DRAW;
+    this.webglUsage = props.webglUsage || import_constants17.default.STATIC_DRAW;
     this.debugData = null;
     this.setAccessor(Object.assign({}, props, props.accessor));
     if (props.data) {
@@ -4501,7 +4375,7 @@ var ClassicBuffer = class extends WEBGLBuffer {
     const { data, offset = 0, srcOffset = 0 } = options;
     const byteLength = options.byteLength || options.length;
     (0, import_api19.assert)(data);
-    const target = this.gl.webgl2 ? import_constants18.default.COPY_WRITE_BUFFER : this.target;
+    const target = this.gl.webgl2 ? import_constants17.default.COPY_WRITE_BUFFER : this.target;
     this.gl.bindBuffer(target, this.handle);
     if (srcOffset !== 0 || byteLength !== void 0) {
       assertWebGL2Context(this.gl);
@@ -4522,11 +4396,11 @@ var ClassicBuffer = class extends WEBGLBuffer {
     const { sourceBuffer, readOffset = 0, writeOffset = 0, size } = options;
     const { gl, gl2 } = this;
     assertWebGL2Context(gl);
-    gl.bindBuffer(import_constants18.default.COPY_READ_BUFFER, sourceBuffer.handle);
-    gl.bindBuffer(import_constants18.default.COPY_WRITE_BUFFER, this.handle);
-    gl2 == null ? void 0 : gl2.copyBufferSubData(import_constants18.default.COPY_READ_BUFFER, import_constants18.default.COPY_WRITE_BUFFER, readOffset, writeOffset, size);
-    gl.bindBuffer(import_constants18.default.COPY_READ_BUFFER, null);
-    gl.bindBuffer(import_constants18.default.COPY_WRITE_BUFFER, null);
+    gl.bindBuffer(import_constants17.default.COPY_READ_BUFFER, sourceBuffer.handle);
+    gl.bindBuffer(import_constants17.default.COPY_WRITE_BUFFER, this.handle);
+    gl2 == null ? void 0 : gl2.copyBufferSubData(import_constants17.default.COPY_READ_BUFFER, import_constants17.default.COPY_WRITE_BUFFER, readOffset, writeOffset, size);
+    gl.bindBuffer(import_constants17.default.COPY_READ_BUFFER, null);
+    gl.bindBuffer(import_constants17.default.COPY_WRITE_BUFFER, null);
     this.debugData = null;
     return this;
   }
@@ -4539,7 +4413,7 @@ var ClassicBuffer = class extends WEBGLBuffer {
     let { dstData = null, length = 0 } = options || {};
     const { srcByteOffset = 0, dstOffset = 0 } = options || {};
     assertWebGL2Context(this.gl);
-    const ArrayType = getTypedArrayFromGLType(this.accessor.type || import_constants18.default.FLOAT, { clamped: false });
+    const ArrayType = getTypedArrayFromGLType(this.accessor.type || import_constants17.default.FLOAT, { clamped: false });
     const sourceAvailableElementCount = this._getAvailableElementCount(srcByteOffset);
     const dstElementOffset = dstOffset;
     let dstAvailableElementCount;
@@ -4558,9 +4432,9 @@ var ClassicBuffer = class extends WEBGLBuffer {
     length = length || copyElementCount;
     (0, import_api19.assert)(length <= copyElementCount);
     dstData = dstData || new ArrayType(dstElementCount);
-    this.gl.bindBuffer(import_constants18.default.COPY_READ_BUFFER, this.handle);
-    (_a = this.gl2) == null ? void 0 : _a.getBufferSubData(import_constants18.default.COPY_READ_BUFFER, srcByteOffset, dstData, dstOffset, length);
-    this.gl.bindBuffer(import_constants18.default.COPY_READ_BUFFER, null);
+    this.gl.bindBuffer(import_constants17.default.COPY_READ_BUFFER, this.handle);
+    (_a = this.gl2) == null ? void 0 : _a.getBufferSubData(import_constants17.default.COPY_READ_BUFFER, srcByteOffset, dstData, dstOffset, length);
+    this.gl.bindBuffer(import_constants17.default.COPY_READ_BUFFER, null);
     return dstData;
   }
   /**
@@ -4580,7 +4454,7 @@ var ClassicBuffer = class extends WEBGLBuffer {
       offset = 0,
       size
     } = options || {};
-    if (target === import_constants18.default.UNIFORM_BUFFER || target === import_constants18.default.TRANSFORM_FEEDBACK_BUFFER) {
+    if (target === import_constants17.default.UNIFORM_BUFFER || target === import_constants17.default.TRANSFORM_FEEDBACK_BUFFER) {
       if (size !== void 0) {
         (_a = this.gl2) == null ? void 0 : _a.bindBufferRange(target, index, this.handle, offset, size);
       } else {
@@ -4595,7 +4469,7 @@ var ClassicBuffer = class extends WEBGLBuffer {
   unbind(options) {
     var _a;
     const { target = this.target, index = this.accessor && this.accessor.index } = options || {};
-    const isIndexedBuffer = target === import_constants18.default.UNIFORM_BUFFER || target === import_constants18.default.TRANSFORM_FEEDBACK_BUFFER;
+    const isIndexedBuffer = target === import_constants17.default.UNIFORM_BUFFER || target === import_constants17.default.TRANSFORM_FEEDBACK_BUFFER;
     if (isIndexedBuffer) {
       (_a = this.gl2) == null ? void 0 : _a.bindBufferBase(target, index, null);
     } else {
@@ -4656,10 +4530,10 @@ var ClassicBuffer = class extends WEBGLBuffer {
   // Binding a buffer for the first time locks the type
   // In WebGL2, use GL.COPY_WRITE_BUFFER to avoid locking the type
   _getTarget() {
-    return this.gl.webgl2 ? import_constants18.default.COPY_WRITE_BUFFER : this.target;
+    return this.gl.webgl2 ? import_constants17.default.COPY_WRITE_BUFFER : this.target;
   }
   _getAvailableElementCount(srcByteOffset) {
-    const ArrayType = getTypedArrayFromGLType(this.accessor.type || import_constants18.default.FLOAT, { clamped: false });
+    const ArrayType = getTypedArrayFromGLType(this.accessor.type || import_constants17.default.FLOAT, { clamped: false });
     const sourceElementOffset = srcByteOffset / ArrayType.BYTES_PER_ELEMENT;
     return this.getElementCount() - sourceElementOffset;
   }
@@ -4686,7 +4560,7 @@ var ClassicBuffer = class extends WEBGLBuffer {
 
 // src/adapter/resources/webgl-shader.ts
 var import_api20 = require("@luma.gl/api");
-var import_constants19 = __toESM(require("@luma.gl/constants"), 1);
+var import_constants18 = __toESM(require("@luma.gl/constants"), 1);
 
 // src/adapter/helpers/get-shader-info.ts
 function getShaderInfo(source, defaultName) {
@@ -4752,10 +4626,10 @@ var WEBGLShader = class extends import_api20.Shader {
     this.device = device;
     switch (this.props.stage) {
       case "vertex":
-        this.handle = this.props.handle || this.device.gl.createShader(import_constants19.default.VERTEX_SHADER);
+        this.handle = this.props.handle || this.device.gl.createShader(import_constants18.default.VERTEX_SHADER);
         break;
       case "fragment":
-        this.handle = this.props.handle || this.device.gl.createShader(import_constants19.default.FRAGMENT_SHADER);
+        this.handle = this.props.handle || this.device.gl.createShader(import_constants18.default.FRAGMENT_SHADER);
         break;
       default:
         throw new Error(this.props.stage);
@@ -4771,8 +4645,8 @@ var WEBGLShader = class extends import_api20.Shader {
   }
   compilationInfo() {
     return __async(this, null, function* () {
-      const log10 = this.device.gl.getShaderInfoLog(this.handle);
-      return log10 ? parseShaderCompilerLog(log10) : [];
+      const log9 = this.device.gl.getShaderInfoLog(this.handle);
+      return log9 ? parseShaderCompilerLog(log9) : [];
     });
   }
   // PRIVATE METHODS
@@ -4783,7 +4657,7 @@ ${source2}`;
     const { gl } = this.device;
     gl.shaderSource(this.handle, source);
     gl.compileShader(this.handle);
-    const compileStatus = gl.getShaderParameter(this.handle, import_constants19.default.COMPILE_STATUS);
+    const compileStatus = gl.getShaderParameter(this.handle, import_constants18.default.COMPILE_STATUS);
     if (!compileStatus) {
       const shaderLog = gl.getShaderInfoLog(this.handle);
       const parsedLog = shaderLog ? parseShaderCompilerLog(shaderLog) : [];
@@ -4803,10 +4677,17 @@ function getShaderIdFromProps(props) {
 
 // src/adapter/resources/webgl-render-pass.ts
 var import_api21 = require("@luma.gl/api");
+var import_constants19 = 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_api21.RenderPass {
   constructor(device, props) {
     super(device, props);
     this.device = device;
+    this.setParameters(this.props.parameters);
+    this.clear();
   }
   end() {
   }
@@ -4820,6 +4701,98 @@ var WEBGLRenderPass = class extends import_api21.RenderPass {
   // beginOcclusionQuery(queryIndex: number): void;
   // endOcclusionQuery(): void;
   // executeBundles(bundles: Iterable<GPURenderBundle>): void;
+  /**
+   * Maps RenderPass parameters to GL parameters
+   */
+  setParameters(parameters = {}) {
+    const glParameters = {};
+    if (this.props.framebuffer) {
+      glParameters.framebuffer = this.props.framebuffer;
+    }
+    if (this.props.depthReadOnly) {
+      glParameters.depthMask = !this.props.depthReadOnly;
+    }
+    glParameters.stencilMask = this.props.stencilReadOnly ? 0 : 1;
+    glParameters[import_constants19.GL.RASTERIZER_DISCARD] = this.props.discard;
+    if (parameters.viewport) {
+      glParameters.viewport = parameters.viewport;
+      glParameters.depthRange = [parameters.viewport[4], parameters.viewport[5]];
+    }
+    glParameters.scissorTest = Boolean(parameters.scissorRect);
+    if (parameters.scissorRect) {
+      glParameters.scissor = parameters.scissorRect;
+    }
+    if (parameters.blendConstant) {
+      glParameters.blendColor = parameters.blendConstant;
+    }
+    if (parameters.stencilReference) {
+      console.warn("RenderPassParameters.stencilReference not yet implemented in WebGL");
+      parameters[import_constants19.GL.STENCIL_REF] = parameters.stencilReference;
+    }
+    this.glParameters = glParameters;
+  }
+  // Internal
+  /**
+   * Optionally clears depth, color and stencil buffers based on parameters
+   */
+  clear() {
+    const glParameters = __spreadValues({}, this.glParameters);
+    let clearMask = 0;
+    if (this.props.clearColor !== false) {
+      clearMask |= GL_COLOR_BUFFER_BIT;
+      glParameters.clearColor = this.props.clearColor;
+    }
+    if (this.props.clearDepth !== false) {
+      clearMask |= GL_DEPTH_BUFFER_BIT;
+      glParameters.clearDepth = this.props.clearDepth;
+    }
+    if (this.props.clearStencil !== false) {
+      clearMask |= GL_STENCIL_BUFFER_BIT;
+      glParameters.clearStencil = this.props.clearStencil;
+    }
+    if (clearMask !== 0) {
+      withParameters(this.device, glParameters, () => {
+        this.device.gl.clear(clearMask);
+      });
+    }
+  }
+  /** 
+   * WebGL2 - clear a specific color buffer 
+   */
+  clearColorBuffer(drawBuffer = 0, value = [0, 0, 0, 0]) {
+    withParameters(this.device.gl2, { framebuffer: this.props.framebuffer }, () => {
+      switch (value.constructor) {
+        case Int32Array:
+          this.device.gl2.clearBufferiv(GL_COLOR, drawBuffer, value);
+          break;
+        case Uint32Array:
+          this.device.gl2.clearBufferuiv(GL_COLOR, drawBuffer, value);
+          break;
+        case Float32Array:
+        default:
+          this.device.gl2.clearBufferfv(GL_COLOR, drawBuffer, value);
+          break;
+      }
+    });
+  }
+  // clearDepthStencil() {
+  // const GL_DEPTH = 0x1801;
+  // const GL_STENCIL = 0x1802;
+  // const GL_DEPTH_STENCIL = 0x84f9;
+  //     case GL_DEPTH:
+  //       this.device.gl2.clearBufferfv(GL_DEPTH, 0, [value]);
+  //       break;
+  //     case GL_STENCIL:
+  //       this.device.gl2.clearBufferiv(GL_STENCIL, 0, [value]);
+  //       break;
+  //     case GL_DEPTH_STENCIL:
+  //       const [depth, stencil] = value;
+  //       this.device.gl2.clearBufferfi(GL_DEPTH_STENCIL, 0, depth, stencil);
+  //       break;
+  //     default:
+  //       assert(false, ERR_ARGUMENTS);
+  //   }
+  // });
 };
 
 // src/adapter/resources/webgl-render-pipeline.ts
@@ -4830,61 +4803,61 @@ var import_constants25 = __toESM(require("@luma.gl/constants"), 1);
 var import_constants22 = __toESM(require("@luma.gl/constants"), 1);
 
 // src/adapter/helpers/uniforms.ts
-var import_constants20 = __toESM(require("@luma.gl/constants"), 1);
+var import_constants20 = require("@luma.gl/constants");
 function isSamplerUniform(type) {
   return SAMPLER_TYPES.includes(type);
 }
 var SAMPLER_TYPES = [
-  import_constants20.default.SAMPLER_2D,
-  import_constants20.default.SAMPLER_CUBE,
-  import_constants20.default.SAMPLER_3D,
-  import_constants20.default.SAMPLER_2D_SHADOW,
-  import_constants20.default.SAMPLER_2D_ARRAY,
-  import_constants20.default.SAMPLER_2D_ARRAY_SHADOW,
-  import_constants20.default.SAMPLER_CUBE_SHADOW,
-  import_constants20.default.INT_SAMPLER_2D,
-  import_constants20.default.INT_SAMPLER_3D,
-  import_constants20.default.INT_SAMPLER_CUBE,
-  import_constants20.default.INT_SAMPLER_2D_ARRAY,
-  import_constants20.default.UNSIGNED_INT_SAMPLER_2D,
-  import_constants20.default.UNSIGNED_INT_SAMPLER_3D,
-  import_constants20.default.UNSIGNED_INT_SAMPLER_CUBE,
-  import_constants20.default.UNSIGNED_INT_SAMPLER_2D_ARRAY
+  import_constants20.GL.SAMPLER_2D,
+  import_constants20.GL.SAMPLER_CUBE,
+  import_constants20.GL.SAMPLER_3D,
+  import_constants20.GL.SAMPLER_2D_SHADOW,
+  import_constants20.GL.SAMPLER_2D_ARRAY,
+  import_constants20.GL.SAMPLER_2D_ARRAY_SHADOW,
+  import_constants20.GL.SAMPLER_CUBE_SHADOW,
+  import_constants20.GL.INT_SAMPLER_2D,
+  import_constants20.GL.INT_SAMPLER_3D,
+  import_constants20.GL.INT_SAMPLER_CUBE,
+  import_constants20.GL.INT_SAMPLER_2D_ARRAY,
+  import_constants20.GL.UNSIGNED_INT_SAMPLER_2D,
+  import_constants20.GL.UNSIGNED_INT_SAMPLER_3D,
+  import_constants20.GL.UNSIGNED_INT_SAMPLER_CUBE,
+  import_constants20.GL.UNSIGNED_INT_SAMPLER_2D_ARRAY
 ];
 var COMPOSITE_GL_TYPES = {
-  [import_constants20.default.FLOAT]: [import_constants20.default.FLOAT, 1, "float", "f32", "float32"],
-  [import_constants20.default.FLOAT_VEC2]: [import_constants20.default.FLOAT, 2, "vec2", "vec2<f32>", "float32x2"],
-  [import_constants20.default.FLOAT_VEC3]: [import_constants20.default.FLOAT, 3, "vec3", "vec3<f32>", "float32x3"],
-  [import_constants20.default.FLOAT_VEC4]: [import_constants20.default.FLOAT, 4, "vec4", "vec4<f32>", "float32x4"],
-  [import_constants20.default.INT]: [import_constants20.default.INT, 1, "int", "i32", "sint32"],
-  [import_constants20.default.INT_VEC2]: [import_constants20.default.INT, 2, "ivec2", "vec2<i32>", "sint32x2"],
-  [import_constants20.default.INT_VEC3]: [import_constants20.default.INT, 3, "ivec3", "vec3<i32>", "sint32x3"],
-  [import_constants20.default.INT_VEC4]: [import_constants20.default.INT, 4, "ivec4", "vec4<i32>", "sint32x4"],
-  [import_constants20.default.UNSIGNED_INT]: [import_constants20.default.UNSIGNED_INT, 1, "uint", "u32", "uint32"],
-  [import_constants20.default.UNSIGNED_INT_VEC2]: [import_constants20.default.UNSIGNED_INT, 2, "uvec2", "vec2<u32>", "uint32x2"],
-  [import_constants20.default.UNSIGNED_INT_VEC3]: [import_constants20.default.UNSIGNED_INT, 3, "uvec3", "vec3<u32>", "uint32x3"],
-  [import_constants20.default.UNSIGNED_INT_VEC4]: [import_constants20.default.UNSIGNED_INT, 4, "uvec4", "vec4<u32>", "uint32x4"],
-  [import_constants20.default.BOOL]: [import_constants20.default.FLOAT, 1, "bool", "f32", "float32x2"],
-  [import_constants20.default.BOOL_VEC2]: [import_constants20.default.FLOAT, 2, "bvec2", "vec2<f32>"],
-  [import_constants20.default.BOOL_VEC3]: [import_constants20.default.FLOAT, 3, "bvec3", "vec3<f32>"],
-  [import_constants20.default.BOOL_VEC4]: [import_constants20.default.FLOAT, 4, "bvec4", "vec4<f32>"],
-  [import_constants20.default.FLOAT_MAT2]: [import_constants20.default.FLOAT, 8, "mat2", "mat2x2<f32>"],
+  [import_constants20.GL.FLOAT]: [import_constants20.GL.FLOAT, 1, "float", "f32", "float32"],
+  [import_constants20.GL.FLOAT_VEC2]: [import_constants20.GL.FLOAT, 2, "vec2", "vec2<f32>", "float32x2"],
+  [import_constants20.GL.FLOAT_VEC3]: [import_constants20.GL.FLOAT, 3, "vec3", "vec3<f32>", "float32x3"],
+  [import_constants20.GL.FLOAT_VEC4]: [import_constants20.GL.FLOAT, 4, "vec4", "vec4<f32>", "float32x4"],
+  [import_constants20.GL.INT]: [import_constants20.GL.INT, 1, "int", "i32", "sint32"],
+  [import_constants20.GL.INT_VEC2]: [import_constants20.GL.INT, 2, "ivec2", "vec2<i32>", "sint32x2"],
+  [import_constants20.GL.INT_VEC3]: [import_constants20.GL.INT, 3, "ivec3", "vec3<i32>", "sint32x3"],
+  [import_constants20.GL.INT_VEC4]: [import_constants20.GL.INT, 4, "ivec4", "vec4<i32>", "sint32x4"],
+  [import_constants20.GL.UNSIGNED_INT]: [import_constants20.GL.UNSIGNED_INT, 1, "uint", "u32", "uint32"],
+  [import_constants20.GL.UNSIGNED_INT_VEC2]: [import_constants20.GL.UNSIGNED_INT, 2, "uvec2", "vec2<u32>", "uint32x2"],
+  [import_constants20.GL.UNSIGNED_INT_VEC3]: [import_constants20.GL.UNSIGNED_INT, 3, "uvec3", "vec3<u32>", "uint32x3"],
+  [import_constants20.GL.UNSIGNED_INT_VEC4]: [import_constants20.GL.UNSIGNED_INT, 4, "uvec4", "vec4<u32>", "uint32x4"],
+  [import_constants20.GL.BOOL]: [import_constants20.GL.FLOAT, 1, "bool", "f32", "float32x2"],
+  [import_constants20.GL.BOOL_VEC2]: [import_constants20.GL.FLOAT, 2, "bvec2", "vec2<f32>"],
+  [import_constants20.GL.BOOL_VEC3]: [import_constants20.GL.FLOAT, 3, "bvec3", "vec3<f32>"],
+  [import_constants20.GL.BOOL_VEC4]: [import_constants20.GL.FLOAT, 4, "bvec4", "vec4<f32>"],
+  [import_constants20.GL.FLOAT_MAT2]: [import_constants20.GL.FLOAT, 8, "mat2", "mat2x2<f32>"],
   // 4
-  [import_constants20.default.FLOAT_MAT2x3]: [import_constants20.default.FLOAT, 8, "mat2x3", "mat2x3<f32>"],
+  [import_constants20.GL.FLOAT_MAT2x3]: [import_constants20.GL.FLOAT, 8, "mat2x3", "mat2x3<f32>"],
   // 6
-  [import_constants20.default.FLOAT_MAT2x4]: [import_constants20.default.FLOAT, 8, "mat2x4", "mat2x4<f32>"],
+  [import_constants20.GL.FLOAT_MAT2x4]: [import_constants20.GL.FLOAT, 8, "mat2x4", "mat2x4<f32>"],
   // 8
-  [import_constants20.default.FLOAT_MAT3x2]: [import_constants20.default.FLOAT, 12, "mat3x2", "mat3x2<f32>"],
+  [import_constants20.GL.FLOAT_MAT3x2]: [import_constants20.GL.FLOAT, 12, "mat3x2", "mat3x2<f32>"],
   // 6
-  [import_constants20.default.FLOAT_MAT3]: [import_constants20.default.FLOAT, 12, "mat3", "mat3x3<f32>"],
+  [import_constants20.GL.FLOAT_MAT3]: [import_constants20.GL.FLOAT, 12, "mat3", "mat3x3<f32>"],
   // 9
-  [import_constants20.default.FLOAT_MAT3x4]: [import_constants20.default.FLOAT, 12, "mat3x4", "mat3x4<f32>"],
+  [import_constants20.GL.FLOAT_MAT3x4]: [import_constants20.GL.FLOAT, 12, "mat3x4", "mat3x4<f32>"],
   // 12
-  [import_constants20.default.FLOAT_MAT4x2]: [import_constants20.default.FLOAT, 16, "mat4x2", "mat4x2<f32>"],
+  [import_constants20.GL.FLOAT_MAT4x2]: [import_constants20.GL.FLOAT, 16, "mat4x2", "mat4x2<f32>"],
   // 8
-  [import_constants20.default.FLOAT_MAT4x3]: [import_constants20.default.FLOAT, 16, "mat4x3", "mat4x3<f32>"],
+  [import_constants20.GL.FLOAT_MAT4x3]: [import_constants20.GL.FLOAT, 16, "mat4x3", "mat4x3<f32>"],
   // 12
-  [import_constants20.default.FLOAT_MAT4]: [import_constants20.default.FLOAT, 16, "mat4", "mat4x4<f32>"]
+  [import_constants20.GL.FLOAT_MAT4]: [import_constants20.GL.FLOAT, 16, "mat4", "mat4x4<f32>"]
   // 16
 };
 function decodeUniformType(uniformType) {
@@ -5437,7 +5410,7 @@ var WEBGLRenderPipeline = class extends import_api23.RenderPipeline {
   draw(options) {
     var _a;
     const {
-      renderPass = this.device.getDefaultRenderPass(),
+      renderPass,
       vertexCount,
       // indexCount,
       instanceCount,
@@ -5462,8 +5435,9 @@ var WEBGLRenderPipeline = class extends import_api23.RenderPipeline {
       }
       this._applyBindings();
       this._applyUniforms();
+      const webglRenderPass = renderPass;
       withDeviceParameters(this.device, this.props.parameters, () => {
-        withGLParameters(this.device, { framebuffer: renderPass.props.framebuffer }, () => {
+        withGLParameters(this.device, webglRenderPass.glParameters, () => {
           var _a2, _b;
           if (isIndexed && isInstanced) {
             (_a2 = this.device.gl2) == null ? void 0 : _a2.drawElementsInstanced(
@@ -5635,15 +5609,258 @@ function getAttributeLayout(layout, name) {
   return layout.attributes.find((binding) => binding.name === name) || null;
 }
 
+// src/adapter/resources/webgl-command-encoder.ts
+var import_api25 = require("@luma.gl/api");
+
+// src/adapter/resources/webgl-command-buffer.ts
+var import_api24 = require("@luma.gl/api");
+var import_constants26 = __toESM(require("@luma.gl/constants"), 1);
+function cast3(value) {
+  return value;
+}
+var WEBGLCommandBuffer = class extends import_api24.CommandBuffer {
+  constructor(device) {
+    super({});
+    this.commands = [];
+    this.device = device;
+  }
+  submitCommands(commands = this.commands) {
+    for (const command of commands) {
+      switch (command.name) {
+        case "copy-buffer-to-buffer":
+          _copyBufferToBuffer(this.device, command.options);
+          break;
+        case "copy-buffer-to-texture":
+          _copyBufferToTexture(this.device, command.options);
+          break;
+        case "copy-texture-to-buffer":
+          _copyTextureToBuffer(this.device, command.options);
+          break;
+        case "copy-texture-to-texture":
+          _copyTextureToTexture(this.device, command.options);
+          break;
+      }
+    }
+  }
+};
+function _copyBufferToBuffer(device, options) {
+  var _a, _b;
+  const source = cast3(options.source);
+  const destination = cast3(options.destination);
+  const gl2 = device.assertWebGL2();
+  if (gl2) {
+    gl2.bindBuffer(import_constants26.default.COPY_READ_BUFFER, source.handle);
+    gl2.bindBuffer(import_constants26.default.COPY_WRITE_BUFFER, destination.handle);
+    gl2.copyBufferSubData(
+      import_constants26.default.COPY_READ_BUFFER,
+      import_constants26.default.COPY_WRITE_BUFFER,
+      (_a = options.sourceOffset) != null ? _a : 0,
+      (_b = options.destinationOffset) != null ? _b : 0,
+      options.size
+    );
+    gl2.bindBuffer(import_constants26.default.COPY_READ_BUFFER, null);
+    gl2.bindBuffer(import_constants26.default.COPY_WRITE_BUFFER, null);
+  } else {
+    throw new Error("copyBufferToBuffer not implemented in WebGL1");
+  }
+}
+function _copyBufferToTexture(device, options) {
+  throw new Error("Not implemented");
+}
+function _copyTextureToBuffer(device, options) {
+  const {
+    /** Texture to copy to/from. */
+    source,
+    /**  Mip-map level of the texture to copy to/from. (Default 0) */
+    mipLevel = 0,
+    /** Defines which aspects of the texture to copy to/from. */
+    aspect = "all",
+    /** Width to copy */
+    width = options.source.width,
+    /** Height to copy */
+    height = options.source.height,
+    depthOrArrayLayers = 0,
+    /** Defines the origin of the copy - the minimum corner of the texture sub-region to copy to/from. */
+    origin = [0, 0],
+    /** Destination buffer */
+    destination,
+    /** Offset, in bytes, from the beginning of the buffer to the start of the image data (default 0) */
+    byteOffset = 0,
+    /**
+     * The stride, in bytes, between the beginning of each block row and the subsequent block row.
+     * Required if there are multiple block rows (i.e. the copy height or depth is more than one block).
+     */
+    bytesPerRow,
+    /**
+     * Number of block rows per single image of the texture.
+     * rowsPerImage &times; bytesPerRow is the stride, in bytes, between the beginning of each image of data and the subsequent image.
+     * Required if there are multiple images (i.e. the copy depth is more than one).
+     */
+    rowsPerImage
+  } = options;
+  if (aspect !== "all") {
+    throw new Error("not supported");
+  }
+  if (mipLevel !== 0 || depthOrArrayLayers !== void 0 || bytesPerRow || rowsPerImage) {
+    throw new Error("not implemented");
+  }
+  const gl2 = device.assertWebGL2();
+  const { framebuffer, destroyFramebuffer } = getFramebuffer(source);
+  try {
+    const webglBuffer = destination;
+    const sourceWidth = width || framebuffer.width;
+    const sourceHeight = height || framebuffer.height;
+    const sourceFormat = import_constants26.default.RGBA;
+    const sourceType = import_constants26.default.UNSIGNED_BYTE;
+    gl2.bindBuffer(import_constants26.default.PIXEL_PACK_BUFFER, webglBuffer.handle);
+    gl2.bindFramebuffer(import_constants26.default.FRAMEBUFFER, framebuffer.handle);
+    gl2.readPixels(
+      origin[0],
+      origin[1],
+      sourceWidth,
+      sourceHeight,
+      sourceFormat,
+      sourceType,
+      byteOffset
+    );
+  } finally {
+    gl2.bindBuffer(import_constants26.default.PIXEL_PACK_BUFFER, null);
+    gl2.bindFramebuffer(import_constants26.default.FRAMEBUFFER, null);
+    if (destroyFramebuffer) {
+      framebuffer.destroy();
+    }
+  }
+}
+function _copyTextureToTexture(device, options) {
+  const {
+    /** Texture to copy to/from. */
+    source,
+    /**  Mip-map level of the texture to copy to/from. (Default 0) */
+    // mipLevel = 0,
+    /** Defines which aspects of the texture to copy to/from. */
+    // aspect = 'all',
+    /** Defines the origin of the copy - the minimum corner of the texture sub-region to copy to/from. */
+    origin = [0, 0],
+    /** Texture to copy to/from. */
+    destination
+    /**  Mip-map level of the texture to copy to/from. (Default 0) */
+    // destinationMipLevel = options.mipLevel,
+    /** Defines the origin of the copy - the minimum corner of the texture sub-region to copy to/from. */
+    // destinationOrigin = [0, 0],
+    /** Defines which aspects of the texture to copy to/from. */
+    // destinationAspect = options.aspect,
+  } = options;
+  let {
+    width = options.destination.width,
+    height = options.destination.width
+    // depthOrArrayLayers = 0
+  } = options;
+  const destinationMipmaplevel = 0;
+  const destinationInternalFormat = import_constants26.default.RGBA;
+  const { framebuffer, destroyFramebuffer } = getFramebuffer(source);
+  const [sourceX, sourceY] = origin;
+  const isSubCopy = false;
+  device.gl.bindFramebuffer(import_constants26.default.FRAMEBUFFER, framebuffer.handle);
+  let texture = null;
+  let textureTarget;
+  if (destination instanceof WEBGLTexture) {
+    texture = destination;
+    width = Number.isFinite(width) ? width : texture.width;
+    height = Number.isFinite(height) ? height : texture.height;
+    texture.bind(0);
+    textureTarget = texture.destination;
+  } else {
+    throw new Error("whoops");
+  }
+  if (!isSubCopy) {
+    device.gl.copyTexImage2D(
+      textureTarget,
+      destinationMipmaplevel,
+      destinationInternalFormat,
+      sourceX,
+      sourceY,
+      width,
+      height,
+      0
+      /* border must be 0 */
+    );
+  } else {
+  }
+  if (texture) {
+    texture.unbind();
+  }
+  device.gl.bindFramebuffer(import_constants26.default.FRAMEBUFFER, prevHandle || null);
+  if (destroyFramebuffer) {
+    framebuffer.destroy();
+  }
+  return texture;
+}
+function getFramebuffer(source) {
+  if (source instanceof import_api24.Texture) {
+    const { width, height, id } = source;
+    const framebuffer = source.device.createFramebuffer({
+      id: `framebuffer-for-${id}`,
+      width,
+      height,
+      colorAttachments: [source]
+    });
+    return { framebuffer, destroyFramebuffer: true };
+  }
+  return { framebuffer: source, destroyFramebuffer: false };
+}
+
+// src/adapter/resources/webgl-command-encoder.ts
+var WEBGLCommandEncoder = class extends import_api25.CommandEncoder {
+  constructor(device, props) {
+    super(props);
+    this.device = device;
+    this.commandBuffer = new WEBGLCommandBuffer(device);
+  }
+  destroy() {
+  }
+  finish() {
+    this.commandBuffer.submitCommands();
+  }
+  // beginRenderPass(GPURenderPassDescriptor descriptor): GPURenderPassEncoder;
+  // beginComputePass(optional GPUComputePassDescriptor descriptor = {}): GPUComputePassEncoder;
+  // finish(options?: {id?: string}): GPUCommandBuffer;
+  copyBufferToBuffer(options) {
+    this.commandBuffer.commands.push({ name: "copy-buffer-to-buffer", options });
+  }
+  copyBufferToTexture(options) {
+    this.commandBuffer.commands.push({ name: "copy-buffer-to-texture", options });
+  }
+  copyTextureToBuffer(options) {
+    this.commandBuffer.commands.push({ name: "copy-texture-to-buffer", options });
+  }
+  copyTextureToTexture(options) {
+    this.commandBuffer.commands.push({ name: "copy-texture-to-texture", options });
+  }
+  pushDebugGroup(groupLabel) {
+  }
+  popDebugGroup() {
+  }
+  insertDebugMarker(markerLabel) {
+  }
+  // writeTimestamp(querySet: Query, queryIndex: number): void {}
+  // resolveQuerySet(options: {
+  //   querySet: GPUQuerySet,
+  //   firstQuery: number,
+  //   queryCount: number,
+  //   destination: Buffer,
+  //   destinationOffset?: number;
+  // }): void;
+};
+
 // src/adapter/webgl-device.ts
 var LOG_LEVEL2 = 1;
-var _WebGLDevice = class extends import_api24.Device {
+var _WebGLDevice = class extends import_api26.Device {
   //
   // Public API
   //
   constructor(props) {
     var _a;
-    super(__spreadProps(__spreadValues({}, props), { id: props.id || (0, import_api24.uid)("webgl-device") }));
+    super(__spreadProps(__spreadValues({}, props), { id: props.id || (0, import_api26.uid)("webgl-device") }));
     this.renderPass = null;
     /** WebGL2 typed context. Need to check isWebGL2 or isWebGL1 before using. */
     this.gl2 = null;
@@ -5687,22 +5904,22 @@ var _WebGLDevice = class extends import_api24.Device {
     trackContextState(this.gl, {
       enable: enable2,
       copyState,
-      log: (...args) => import_api24.log.log(1, ...args)()
+      log: (...args) => import_api26.log.log(1, ...args)()
     });
     if ((0, import_env2.isBrowser)() && props.debug) {
       this.gl = makeDebugContext(this.gl, __spreadProps(__spreadValues({}, props), { webgl2: this.isWebGL2, throwOnError: true }));
       this.gl2 = this.gl;
       this.debug = true;
-      import_api24.log.level = Math.max(import_api24.log.level, 1);
-      import_api24.log.warn("WebGL debug mode activated. Performance reduced.")();
+      import_api26.log.level = Math.max(import_api26.log.level, 1);
+      import_api26.log.warn("WebGL debug mode activated. Performance reduced.")();
     }
     if ((0, import_env2.isBrowser)() && props.spector) {
       const canvas = this.handle.canvas || props.canvas;
       this.spector = initializeSpectorJS(__spreadProps(__spreadValues({}, this.props), { canvas }));
     }
     const message2 = `Created ${this.info.type}${this.debug ? " debug" : ""} context: ${this.info.vendor}, ${this.info.renderer} for canvas: ${this.canvasContext.id}`;
-    import_api24.log.probe(LOG_LEVEL2, message2)();
-    import_api24.log.groupEnd(LOG_LEVEL2)();
+    import_api26.log.probe(LOG_LEVEL2, message2)();
+    import_api26.log.groupEnd(LOG_LEVEL2)();
   }
   static isSupported() {
     return typeof WebGLRenderingContext !== "undefined" || isHeadlessGLRegistered();
@@ -5728,7 +5945,7 @@ var _WebGLDevice = class extends import_api24.Device {
     if (gl instanceof _WebGLDevice) {
       return gl;
     }
-    if ((gl == null ? void 0 : gl.device) instanceof import_api24.Device) {
+    if ((gl == null ? void 0 : gl.device) instanceof import_api26.Device) {
       return gl.device;
     }
     if (!isWebGL3(gl)) {
@@ -5738,9 +5955,9 @@ var _WebGLDevice = class extends import_api24.Device {
   }
   static create() {
     return __async(this, arguments, function* (props = {}) {
-      import_api24.log.groupCollapsed(LOG_LEVEL2, "WebGLDevice created");
+      import_api26.log.groupCollapsed(LOG_LEVEL2, "WebGLDevice created");
       if (typeof props.canvas === "string") {
-        yield import_api24.CanvasContext.pageLoaded;
+        yield import_api26.CanvasContext.pageLoaded;
       }
       if (props.debug) {
         yield loadWebGLDeveloperTools();
@@ -5748,7 +5965,7 @@ var _WebGLDevice = class extends import_api24.Device {
       if (props.spector) {
         yield loadSpectorJS();
       }
-      import_api24.log.probe(LOG_LEVEL2 + 1, "DOM is loaded")();
+      import_api26.log.probe(LOG_LEVEL2 + 1, "DOM is loaded")();
       if (props.gl && props.gl.device) {
         return _WebGLDevice.attach(props.gl);
       }
@@ -5792,8 +6009,9 @@ var _WebGLDevice = class extends import_api24.Device {
   createCanvasContext(props) {
     throw new Error("WebGL only supports a single canvas");
   }
-  _createBuffer(props) {
-    return new ClassicBuffer(this, props);
+  createBuffer(props) {
+    const newProps = this._getBufferProps(props);
+    return new ClassicBuffer(this, newProps);
   }
   _createTexture(props) {
     return new WEBGLTexture(this, props);
@@ -5828,6 +6046,9 @@ var _WebGLDevice = class extends import_api24.Device {
     });
     return this.renderPass;
   }
+  createCommandEncoder(props) {
+    return new WEBGLCommandEncoder(this, props);
+  }
   /**
    * Offscreen Canvas Support: Commit the frame
    * https://developer.mozilla.org/en-US/docs/Web/API/WebGLRenderingContext/commit
@@ -5844,20 +6065,22 @@ var _WebGLDevice = class extends import_api24.Device {
     return this._webglLimits;
   }
   /**
-   * Loses the context
-   * @note Triggers context loss, mainly for testing
-   * @todo Promote to `Device` API?
+   * Triggers device (or WebGL context) loss.
+   * @note primarily intended for testing how application reacts to device loss
    */
   loseDevice() {
     var _a;
+    let deviceLossTriggered = false;
     const ext = this.gl.getExtension("WEBGL_lose_context");
     if (ext) {
+      deviceLossTriggered = true;
       ext.loseContext();
     }
     (_a = this._resolveContextLost) == null ? void 0 : _a.call(this, {
       reason: "destroyed",
       message: "Application triggered context loss"
     });
+    return deviceLossTriggered;
   }
   /** Save current WebGL context state onto an internal stack */
   pushState() {
@@ -5874,6 +6097,21 @@ var _WebGLDevice = class extends import_api24.Device {
   setSpectorMetadata(handle, props) {
     handle.__SPECTOR_Metadata = props;
   }
+  /** 
+   * Returns the GL.<KEY> constant that corresponds to a numeric value of a GL constant
+   * Be aware that there are some duplicates especially for constants that are 0,
+   * so this isn't guaranteed to return the right key in all cases.
+   */
+  getGLKey(value, gl) {
+    gl = gl || this.gl2 || this.gl;
+    const number = Number(value);
+    for (const key in gl) {
+      if (gl[key] === number) {
+        return `GL.${key}`;
+      }
+    }
+    return String(value);
+  }
 };
 var WebGLDevice = _WebGLDevice;
 //
@@ -5895,54 +6133,3 @@ function isWebGL22(gl) {
   }
   return Boolean(gl && gl._version === 2);
 }
-
-// src/adapter/resources/webgl-command-encoder.ts
-var import_api25 = require("@luma.gl/api");
-
-// src/adapter/resources/webgl-command-buffer.ts
-var import_constants26 = __toESM(require("@luma.gl/constants"), 1);
-var CommandBuffer = class {
-  constructor() {
-    this.commands = [];
-  }
-};
-
-// src/adapter/resources/webgl-command-encoder.ts
-var WEBGLCommandEncoder = class extends import_api25.CommandEncoder {
-  constructor(device, props) {
-    super(props);
-    this.commandBuffer = new CommandBuffer();
-    this.device = device;
-  }
-  destroy() {
-  }
-  // beginRenderPass(GPURenderPassDescriptor descriptor): GPURenderPassEncoder;
-  // beginComputePass(optional GPUComputePassDescriptor descriptor = {}): GPUComputePassEncoder;
-  // finish(options?: {id?: string}): GPUCommandBuffer;
-  copyBufferToBuffer(options) {
-    this.commandBuffer.commands.push({ name: "copy-buffer-to-buffer", options });
-  }
-  copyBufferToTexture(options) {
-    this.commandBuffer.commands.push({ name: "copy-buffer-to-texture", options });
-  }
-  copyTextureToBuffer(options) {
-    this.commandBuffer.commands.push({ name: "copy-texture-to-buffer", options });
-  }
-  copyTextureToTexture(options) {
-    this.commandBuffer.commands.push({ name: "copy-texture-to-texture", options });
-  }
-  pushDebugGroup(groupLabel) {
-  }
-  popDebugGroup() {
-  }
-  insertDebugMarker(markerLabel) {
-  }
-  // writeTimestamp(querySet: Query, queryIndex: number): void {}
-  // resolveQuerySet(options: {
-  //   querySet: GPUQuerySet,
-  //   firstQuery: number,
-  //   queryCount: number,
-  //   destination: Buffer,
-  //   destinationOffset?: number;
-  // }): void;
-};