@luma.gl/webgl 9.0.0-alpha.25 → 9.0.0-alpha.27

package/dist/dist.dev.js

@@ -53,6 +53,7 @@ var __exports__ = (() => {
     assertWebGLContext: () => assertWebGLContext,
     clear: () => clear,
     convertGLToTextureFormat: () => convertGLToTextureFormat,
+    copyToTexture: () => copyToTexture,
     getParameters: () => getParameters,
     getProgramBindings: () => getProgramBindings,
     getShaderLayout: () => getShaderLayout,
@@ -106,11 +107,11 @@ var __exports__ = (() => {
     if (!headlessGL) {
       throw new Error(ERR_HEADLESSGL_LOAD);
     }
-    const gl = headlessGL(width, height, options);
-    if (!gl) {
+    const gl2 = headlessGL(width, height, options);
+    if (!gl2) {
       throw new Error(ERR_HEADLESSGL_FAILED);
     }
-    return gl;
+    return gl2;
   }
 
   // ../../node_modules/@probe.gl/env/dist/lib/is-electron.js
@@ -1249,9 +1250,9 @@ var __exports__ = (() => {
       };
       if ((props.usage || 0) & Buffer2.INDEX && !props.indexType) {
         if (props.data instanceof Uint32Array) {
-          props.indexType = "uint32";
+          newProps.indexType = "uint32";
         } else if (props.data instanceof Uint16Array) {
-          props.indexType = "uint16";
+          newProps.indexType = "uint16";
         }
       }
       return newProps;
@@ -1403,7 +1404,7 @@ var __exports__ = (() => {
      * Use devicePixelRatio to set canvas width and height
      * @note this is a raw port of luma.gl v8 code. Might be worth a review
      */
-    setDevicePixelRatio(devicePixelRatio2, options = {}) {
+    setDevicePixelRatio(devicePixelRatio, options = {}) {
       if (!this.htmlCanvas) {
         return;
       }
@@ -1411,13 +1412,13 @@ var __exports__ = (() => {
       let clientHeight = "height" in options ? options.height : this.htmlCanvas.clientHeight;
       if (!clientWidth || !clientHeight) {
         log.log(1, "Canvas clientWidth/clientHeight is 0")();
-        devicePixelRatio2 = 1;
+        devicePixelRatio = 1;
         clientWidth = this.htmlCanvas.width || 1;
         clientHeight = this.htmlCanvas.height || 1;
       }
       const cachedSize = this._canvasSizeInfo;
-      if (cachedSize.clientWidth !== clientWidth || cachedSize.clientHeight !== clientHeight || cachedSize.devicePixelRatio !== devicePixelRatio2) {
-        let clampedPixelRatio = devicePixelRatio2;
+      if (cachedSize.clientWidth !== clientWidth || cachedSize.clientHeight !== clientHeight || cachedSize.devicePixelRatio !== devicePixelRatio) {
+        let clampedPixelRatio = devicePixelRatio;
         const canvasWidth = Math.floor(clientWidth * clampedPixelRatio);
         const canvasHeight = Math.floor(clientHeight * clampedPixelRatio);
         this.htmlCanvas.width = canvasWidth;
@@ -1431,17 +1432,17 @@ var __exports__ = (() => {
         }
         this._canvasSizeInfo.clientWidth = clientWidth;
         this._canvasSizeInfo.clientHeight = clientHeight;
-        this._canvasSizeInfo.devicePixelRatio = devicePixelRatio2;
+        this._canvasSizeInfo.devicePixelRatio = devicePixelRatio;
       }
     }
     // PRIVATE
     /** @todo Major hack done to port the CSS methods above, base canvas context should not depend on WebGL */
     getDrawingBufferSize() {
-      const gl = this.device.gl;
-      if (!gl) {
+      const gl2 = this.device.gl;
+      if (!gl2) {
         throw new Error("canvas size");
       }
-      return [gl.drawingBufferWidth, gl.drawingBufferHeight];
+      return [gl2.drawingBufferWidth, gl2.drawingBufferHeight];
     }
     /** Perform platform specific updates (WebGPU vs WebGL) */
     /**
@@ -1850,6 +1851,7 @@ var __exports__ = (() => {
   };
   /** Set attributes (stored on pipeline and set before each call) */
   /** Set attributes (stored on pipeline and set before each call) */
+  /** Set constant attributes (WebGL only) */
   /** Set bindings (stored on pipeline and set before each call) */
   /** Uniforms (only supported on WebGL devices. Reset before each call to enable pipeline sharing) */
   /** Draw call */
@@ -1864,7 +1866,11 @@ var __exports__ = (() => {
     constructor(device, props) {
       super(device, props, _RenderPass.defaultProps);
     }
-    /** A small set of parameters can be changed between every draw call (viewport, scissorRect, blendColor, stencilReference) */
+    /** Call when rendering is done in this pass. */
+    /** 
+     * A small set of parameters can be changed between every draw call 
+     * (viewport, scissorRect, blendColor, stencilReference) 
+     */
     // writeTimestamp(querySet: GPUQuerySet, queryIndex: number): void;
     // beginOcclusionQuery(queryIndex: number): void;
     // endOcclusionQuery(): void;
@@ -2251,6 +2257,43 @@ var __exports__ = (() => {
     });
   }
 
+  // ../api/src/lib/utils/array-utils-flat.ts
+  var arrayBuffer;
+  function getScratchArrayBuffer(byteLength) {
+    if (!arrayBuffer || arrayBuffer.byteLength < byteLength) {
+      arrayBuffer = new ArrayBuffer(byteLength);
+    }
+    return arrayBuffer;
+  }
+  function getScratchArray(Type, length) {
+    const scratchArrayBuffer = getScratchArrayBuffer(Type.BYTES_PER_ELEMENT * length);
+    return new Type(scratchArrayBuffer, 0, length);
+  }
+  function fillArray(options) {
+    const {
+      target,
+      source,
+      start = 0,
+      count = 1
+    } = options;
+    const length = source.length;
+    const total = count * length;
+    let copied = 0;
+    for (let i = start; copied < length; copied++) {
+      target[i++] = source[copied];
+    }
+    while (copied < total) {
+      if (copied < total - copied) {
+        target.copyWithin(start + copied, start, start + copied);
+        copied *= 2;
+      } else {
+        target.copyWithin(start + copied, start, start + total - copied);
+        copied = total;
+      }
+    }
+    return options.target;
+  }
+
   // src/context/polyfill/polyfill-vertex-array-object.ts
   var glErrorShadow = {};
   function error(msg) {
@@ -2269,43 +2312,43 @@ var __exports__ = (() => {
       error(opt_msg);
     }
   }
-  function wrapGLError(gl) {
-    const f = gl.getError;
-    gl.getError = function getError() {
+  function wrapGLError(gl2) {
+    const f = gl2.getError;
+    gl2.getError = function getError() {
       let err;
       do {
-        err = f.apply(gl);
-        if (err !== gl.NO_ERROR) {
+        err = f.apply(gl2);
+        if (err !== gl2.NO_ERROR) {
           glErrorShadow[err] = true;
         }
-      } while (err !== gl.NO_ERROR);
+      } while (err !== gl2.NO_ERROR);
       for (err in glErrorShadow) {
         if (glErrorShadow[err]) {
           delete glErrorShadow[err];
           return parseInt(err, 10);
         }
       }
-      return gl.NO_ERROR;
+      return gl2.NO_ERROR;
     };
   }
   var WebGLVertexArrayObjectOES = function WebGLVertexArrayObjectOES2(ext) {
-    const gl = ext.gl;
+    const gl2 = ext.gl;
     this.ext = ext;
     this.isAlive = true;
     this.hasBeenBound = false;
     this.elementArrayBuffer = null;
     this.attribs = new Array(ext.maxVertexAttribs);
     for (let n = 0; n < this.attribs.length; n++) {
-      const attrib = new WebGLVertexArrayObjectOES2.VertexAttrib(gl);
+      const attrib = new WebGLVertexArrayObjectOES2.VertexAttrib(gl2);
       this.attribs[n] = attrib;
     }
     this.maxAttrib = 0;
   };
-  WebGLVertexArrayObjectOES.VertexAttrib = function VertexAttrib(gl) {
+  WebGLVertexArrayObjectOES.VertexAttrib = function VertexAttrib(gl2) {
     this.enabled = false;
     this.buffer = null;
     this.size = 4;
-    this.type = gl.FLOAT;
+    this.type = gl2.FLOAT;
     this.normalized = false;
     this.stride = 16;
     this.offset = 0;
@@ -2315,19 +2358,19 @@ var __exports__ = (() => {
   WebGLVertexArrayObjectOES.VertexAttrib.prototype.recache = function recache() {
     this.cached = [this.size, this.type, this.normalized, this.stride, this.offset].join(":");
   };
-  var OESVertexArrayObject = function OESVertexArrayObject2(gl) {
+  var OESVertexArrayObject = function OESVertexArrayObject2(gl2) {
     const self = this;
-    this.gl = gl;
-    wrapGLError(gl);
+    this.gl = gl2;
+    wrapGLError(gl2);
     const original = this.original = {
-      getParameter: gl.getParameter,
-      enableVertexAttribArray: gl.enableVertexAttribArray,
-      disableVertexAttribArray: gl.disableVertexAttribArray,
-      bindBuffer: gl.bindBuffer,
-      getVertexAttrib: gl.getVertexAttrib,
-      vertexAttribPointer: gl.vertexAttribPointer
+      getParameter: gl2.getParameter,
+      enableVertexAttribArray: gl2.enableVertexAttribArray,
+      disableVertexAttribArray: gl2.disableVertexAttribArray,
+      bindBuffer: gl2.bindBuffer,
+      getVertexAttrib: gl2.getVertexAttrib,
+      vertexAttribPointer: gl2.vertexAttribPointer
     };
-    gl.getParameter = function getParameter(pname) {
+    gl2.getParameter = function getParameter(pname) {
       if (pname === self.VERTEX_ARRAY_BINDING_OES) {
         if (self.currentVertexArrayObject === self.defaultVertexArrayObject) {
           return null;
@@ -2336,53 +2379,53 @@ var __exports__ = (() => {
       }
       return original.getParameter.apply(this, arguments);
     };
-    gl.enableVertexAttribArray = function enableVertexAttribArray(index) {
+    gl2.enableVertexAttribArray = function enableVertexAttribArray(index) {
       const vao = self.currentVertexArrayObject;
       vao.maxAttrib = Math.max(vao.maxAttrib, index);
       const attrib = vao.attribs[index];
       attrib.enabled = true;
       return original.enableVertexAttribArray.apply(this, arguments);
     };
-    gl.disableVertexAttribArray = function disableVertexAttribArray(index) {
+    gl2.disableVertexAttribArray = function disableVertexAttribArray(index) {
       const vao = self.currentVertexArrayObject;
       vao.maxAttrib = Math.max(vao.maxAttrib, index);
       const attrib = vao.attribs[index];
       attrib.enabled = false;
       return original.disableVertexAttribArray.apply(this, arguments);
     };
-    gl.bindBuffer = function bindBuffer2(target, buffer) {
+    gl2.bindBuffer = function bindBuffer2(target, buffer) {
       switch (target) {
-        case gl.ARRAY_BUFFER:
+        case gl2.ARRAY_BUFFER:
           self.currentArrayBuffer = buffer;
           break;
-        case gl.ELEMENT_ARRAY_BUFFER:
+        case gl2.ELEMENT_ARRAY_BUFFER:
           self.currentVertexArrayObject.elementArrayBuffer = buffer;
           break;
         default:
       }
       return original.bindBuffer.apply(this, arguments);
     };
-    gl.getVertexAttrib = function getVertexAttrib(index, pname) {
+    gl2.getVertexAttrib = function getVertexAttrib(index, pname) {
       const vao = self.currentVertexArrayObject;
       const attrib = vao.attribs[index];
       switch (pname) {
-        case gl.VERTEX_ATTRIB_ARRAY_BUFFER_BINDING:
+        case gl2.VERTEX_ATTRIB_ARRAY_BUFFER_BINDING:
           return attrib.buffer;
-        case gl.VERTEX_ATTRIB_ARRAY_ENABLED:
+        case gl2.VERTEX_ATTRIB_ARRAY_ENABLED:
           return attrib.enabled;
-        case gl.VERTEX_ATTRIB_ARRAY_SIZE:
+        case gl2.VERTEX_ATTRIB_ARRAY_SIZE:
           return attrib.size;
-        case gl.VERTEX_ATTRIB_ARRAY_STRIDE:
+        case gl2.VERTEX_ATTRIB_ARRAY_STRIDE:
           return attrib.stride;
-        case gl.VERTEX_ATTRIB_ARRAY_TYPE:
+        case gl2.VERTEX_ATTRIB_ARRAY_TYPE:
           return attrib.type;
-        case gl.VERTEX_ATTRIB_ARRAY_NORMALIZED:
+        case gl2.VERTEX_ATTRIB_ARRAY_NORMALIZED:
           return attrib.normalized;
         default:
           return original.getVertexAttrib.apply(this, arguments);
       }
     };
-    gl.vertexAttribPointer = function vertexAttribPointer(indx, size, type, normalized, stride, offset) {
+    gl2.vertexAttribPointer = function vertexAttribPointer(indx, size, type, normalized, stride, offset) {
       const vao = self.currentVertexArrayObject;
       vao.maxAttrib = Math.max(vao.maxAttrib, indx);
       const attrib = vao.attribs[indx];
@@ -2395,11 +2438,11 @@ var __exports__ = (() => {
       attrib.recache();
       return original.vertexAttribPointer.apply(this, arguments);
     };
-    if (gl.instrumentExtension) {
-      gl.instrumentExtension(this, "OES_vertex_array_object");
+    if (gl2.instrumentExtension) {
+      gl2.instrumentExtension(this, "OES_vertex_array_object");
     }
-    if (gl.canvas) {
-      gl.canvas.addEventListener("webglcontextrestored", () => {
+    if (gl2.canvas) {
+      gl2.canvas.addEventListener("webglcontextrestored", () => {
         log2("OESVertexArrayObject emulation library context restored");
         self.reset_();
       }, true);
@@ -2414,8 +2457,8 @@ var __exports__ = (() => {
         this.vertexArrayObjects.isAlive = false;
       }
     }
-    const gl = this.gl;
-    this.maxVertexAttribs = gl.getParameter(gl.MAX_VERTEX_ATTRIBS);
+    const gl2 = this.gl;
+    this.maxVertexAttribs = gl2.getParameter(gl2.MAX_VERTEX_ATTRIBS);
     this.defaultVertexArrayObject = new WebGLVertexArrayObjectOES(this);
     this.currentVertexArrayObject = null;
     this.currentArrayBuffer = null;
@@ -2443,9 +2486,9 @@ var __exports__ = (() => {
     return false;
   };
   OESVertexArrayObject.prototype.bindVertexArrayOES = function bindVertexArrayOES(arrayObject) {
-    const gl = this.gl;
+    const gl2 = this.gl;
     if (arrayObject && !arrayObject.isAlive) {
-      synthesizeGLError(gl.INVALID_OPERATION, "bindVertexArrayOES: attempt to bind deleted arrayObject");
+      synthesizeGLError(gl2.INVALID_OPERATION, "bindVertexArrayOES: attempt to bind deleted arrayObject");
       return;
     }
     const original = this.original;
@@ -2457,7 +2500,7 @@ var __exports__ = (() => {
       return;
     }
     if (!oldVAO || newVAO.elementArrayBuffer !== oldVAO.elementArrayBuffer) {
-      original.bindBuffer.call(gl, gl.ELEMENT_ARRAY_BUFFER, newVAO.elementArrayBuffer);
+      original.bindBuffer.call(gl2, gl2.ELEMENT_ARRAY_BUFFER, newVAO.elementArrayBuffer);
     }
     let currentBinding = this.currentArrayBuffer;
     const maxAttrib = Math.max(oldVAO ? oldVAO.maxAttrib : 0, newVAO.maxAttrib);
@@ -2466,43 +2509,43 @@ var __exports__ = (() => {
       const oldAttrib = oldVAO ? oldVAO.attribs[n] : null;
       if (!oldVAO || attrib.enabled !== oldAttrib.enabled) {
         if (attrib.enabled) {
-          original.enableVertexAttribArray.call(gl, n);
+          original.enableVertexAttribArray.call(gl2, n);
         } else {
-          original.disableVertexAttribArray.call(gl, n);
+          original.disableVertexAttribArray.call(gl2, n);
         }
       }
       if (attrib.enabled) {
         let bufferChanged = false;
         if (!oldVAO || attrib.buffer !== oldAttrib.buffer) {
           if (currentBinding !== attrib.buffer) {
-            original.bindBuffer.call(gl, gl.ARRAY_BUFFER, attrib.buffer);
+            original.bindBuffer.call(gl2, gl2.ARRAY_BUFFER, attrib.buffer);
             currentBinding = attrib.buffer;
           }
           bufferChanged = true;
         }
         if (bufferChanged || attrib.cached !== oldAttrib.cached) {
-          original.vertexAttribPointer.call(gl, n, attrib.size, attrib.type, attrib.normalized, attrib.stride, attrib.offset);
+          original.vertexAttribPointer.call(gl2, n, attrib.size, attrib.type, attrib.normalized, attrib.stride, attrib.offset);
         }
       }
     }
     if (this.currentArrayBuffer !== currentBinding) {
-      original.bindBuffer.call(gl, gl.ARRAY_BUFFER, this.currentArrayBuffer);
+      original.bindBuffer.call(gl2, gl2.ARRAY_BUFFER, this.currentArrayBuffer);
     }
   };
-  function polyfillVertexArrayObject(gl) {
-    if (typeof gl.createVertexArray === "function") {
+  function polyfillVertexArrayObject(gl2) {
+    if (typeof gl2.createVertexArray === "function") {
       return;
     }
-    const original_getSupportedExtensions = gl.getSupportedExtensions;
-    gl.getSupportedExtensions = function getSupportedExtensions() {
+    const original_getSupportedExtensions = gl2.getSupportedExtensions;
+    gl2.getSupportedExtensions = function getSupportedExtensions() {
       const list = original_getSupportedExtensions.call(this) || [];
       if (list.indexOf("OES_vertex_array_object") < 0) {
         list.push("OES_vertex_array_object");
       }
       return list;
     };
-    const original_getExtension = gl.getExtension;
-    gl.getExtension = function getExtension(name) {
+    const original_getExtension = gl2.getExtension;
+    gl2.getExtension = function getExtension(name) {
       const ext = original_getExtension.call(this, name);
       if (ext) {
         return ext;
@@ -2510,7 +2553,7 @@ var __exports__ = (() => {
       if (name !== "OES_vertex_array_object") {
         return null;
       }
-      if (!gl.__OESVertexArrayObject) {
+      if (!gl2.__OESVertexArrayObject) {
         this.__OESVertexArrayObject = new OESVertexArrayObject(this);
       }
       return this.__OESVertexArrayObject;
@@ -3187,31 +3230,31 @@ var __exports__ = (() => {
   // src/context/context/webgl-checks.ts
   var ERR_CONTEXT = "Invalid WebGLRenderingContext";
   var ERR_WEBGL2 = "Requires WebGL2";
-  function isWebGL(gl) {
-    if (typeof WebGLRenderingContext !== "undefined" && gl instanceof WebGLRenderingContext) {
+  function isWebGL(gl2) {
+    if (typeof WebGLRenderingContext !== "undefined" && gl2 instanceof WebGLRenderingContext) {
       return true;
     }
-    if (typeof WebGL2RenderingContext !== "undefined" && gl instanceof WebGL2RenderingContext) {
+    if (typeof WebGL2RenderingContext !== "undefined" && gl2 instanceof WebGL2RenderingContext) {
       return true;
     }
-    return Boolean(gl && Number.isFinite(gl._version));
+    return Boolean(gl2 && Number.isFinite(gl2._version));
   }
-  function isWebGL2(gl) {
-    if (typeof WebGL2RenderingContext !== "undefined" && gl instanceof WebGL2RenderingContext) {
+  function isWebGL2(gl2) {
+    if (typeof WebGL2RenderingContext !== "undefined" && gl2 instanceof WebGL2RenderingContext) {
       return true;
     }
-    return Boolean(gl && gl._version === 2);
+    return Boolean(gl2 && gl2._version === 2);
   }
-  function getWebGL2Context(gl) {
-    return isWebGL2(gl) ? gl : null;
+  function getWebGL2Context(gl2) {
+    return isWebGL2(gl2) ? gl2 : null;
   }
-  function assertWebGLContext(gl) {
-    assert2(isWebGL(gl), ERR_CONTEXT);
-    return gl;
+  function assertWebGLContext(gl2) {
+    assert2(isWebGL(gl2), ERR_CONTEXT);
+    return gl2;
   }
-  function assertWebGL2Context(gl) {
-    assert2(isWebGL2(gl), ERR_WEBGL2);
-    return gl;
+  function assertWebGL2Context(gl2) {
+    assert2(isWebGL2(gl2), ERR_WEBGL2);
+    return gl2;
   }
 
   // src/context/polyfill/get-parameter-polyfill.ts
@@ -3227,39 +3270,39 @@ var __exports__ = (() => {
   var GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT = 34047;
   var GL_UNMASKED_VENDOR_WEBGL = 37445;
   var GL_UNMASKED_RENDERER_WEBGL = 37446;
-  var getWebGL2ValueOrZero = (gl) => !isWebGL2(gl) ? 0 : void 0;
+  var getWebGL2ValueOrZero = (gl2) => !isWebGL2(gl2) ? 0 : void 0;
   var WEBGL_PARAMETERS = {
-    [GL.READ_BUFFER]: (gl) => !isWebGL2(gl) ? GL.COLOR_ATTACHMENT0 : void 0,
+    [GL.READ_BUFFER]: (gl2) => !isWebGL2(gl2) ? GL.COLOR_ATTACHMENT0 : void 0,
     // WebGL2 context parameters
-    [GL_FRAGMENT_SHADER_DERIVATIVE_HINT]: (gl) => !isWebGL2(gl) ? GL_DONT_CARE : void 0,
+    [GL_FRAGMENT_SHADER_DERIVATIVE_HINT]: (gl2) => !isWebGL2(gl2) ? GL_DONT_CARE : void 0,
     [GL.RASTERIZER_DISCARD]: getWebGL2ValueOrZero,
     [GL.SAMPLES]: getWebGL2ValueOrZero,
     // WebGL2 extension context parameters
-    [GL_GPU_DISJOINT_EXT]: (gl, getParameter) => {
-      const ext = isWebGL2(gl) ? gl.getExtension(EXT_disjoint_timer_query_webgl2) : gl.getExtension(EXT_disjoint_timer_query);
+    [GL_GPU_DISJOINT_EXT]: (gl2, getParameter) => {
+      const ext = isWebGL2(gl2) ? gl2.getExtension(EXT_disjoint_timer_query_webgl2) : gl2.getExtension(EXT_disjoint_timer_query);
       return ext && ext.GPU_DISJOINT_EXT ? getParameter(ext.GPU_DISJOINT_EXT) : 0;
     },
     // Extension fixed values
-    [GL_UNMASKED_VENDOR_WEBGL]: (gl, getParameter) => {
-      const ext = gl.getExtension(WEBGL_debug_renderer_info);
+    [GL_UNMASKED_VENDOR_WEBGL]: (gl2, getParameter) => {
+      const ext = gl2.getExtension(WEBGL_debug_renderer_info);
       return getParameter(ext && ext.UNMASKED_VENDOR_WEBGL || GL.VENDOR);
     },
-    [GL_UNMASKED_RENDERER_WEBGL]: (gl, getParameter) => {
-      const ext = gl.getExtension(WEBGL_debug_renderer_info);
+    [GL_UNMASKED_RENDERER_WEBGL]: (gl2, getParameter) => {
+      const ext = gl2.getExtension(WEBGL_debug_renderer_info);
       return getParameter(ext && ext.UNMASKED_RENDERER_WEBGL || GL.RENDERER);
     },
     // Extension LIMITS
-    [GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT]: (gl, getParameter) => {
-      const ext = gl.luma?.extensions?.[EXT_texture_filter_anisotropic] || gl.getExtension("EXT_texture_filter_anisotropic");
+    [GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT]: (gl2, getParameter) => {
+      const ext = gl2.luma?.extensions?.[EXT_texture_filter_anisotropic] || gl2.getExtension("EXT_texture_filter_anisotropic");
       return ext ? getParameter(ext.MAX_TEXTURE_MAX_ANISOTROPY_EXT) : 1;
     },
     // WebGL2 Limits
     [GL.MAX_3D_TEXTURE_SIZE]: getWebGL2ValueOrZero,
     [GL.MAX_ARRAY_TEXTURE_LAYERS]: getWebGL2ValueOrZero,
     [GL.MAX_CLIENT_WAIT_TIMEOUT_WEBGL]: getWebGL2ValueOrZero,
-    [GL.MAX_COLOR_ATTACHMENTS]: (gl, getParameter) => {
-      if (!isWebGL2(gl)) {
-        const ext = gl.getExtension(WEBGL_draw_buffers);
+    [GL.MAX_COLOR_ATTACHMENTS]: (gl2, getParameter) => {
+      if (!isWebGL2(gl2)) {
+        const ext = gl2.getExtension(WEBGL_draw_buffers);
         return ext ? getParameter(ext.MAX_COLOR_ATTACHMENTS_WEBGL) : 0;
       }
       return void 0;
@@ -3267,24 +3310,24 @@ var __exports__ = (() => {
     [GL.MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS]: getWebGL2ValueOrZero,
     [GL.MAX_COMBINED_UNIFORM_BLOCKS]: getWebGL2ValueOrZero,
     [GL.MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS]: getWebGL2ValueOrZero,
-    [GL.MAX_DRAW_BUFFERS]: (gl) => {
-      if (!isWebGL2(gl)) {
-        const ext = gl.getExtension(WEBGL_draw_buffers);
+    [GL.MAX_DRAW_BUFFERS]: (gl2) => {
+      if (!isWebGL2(gl2)) {
+        const ext = gl2.getExtension(WEBGL_draw_buffers);
         return ext ? ext.MAX_DRAW_BUFFERS_WEBGL : 0;
       }
       return void 0;
     },
     [GL.MAX_ELEMENT_INDEX]: (
       // Guess: per webglstats.com 99.6% of webgl2 supports 2147483647
-      (gl) => gl.getExtension(OES_element_index) ? 2147483647 : 65535
+      (gl2) => gl2.getExtension(OES_element_index) ? 2147483647 : 65535
     ),
     [GL.MAX_ELEMENTS_INDICES]: (
       // Guess: "Reasonably safe" per webglstats.com - could be higher/lower (on some mobile devices)
-      (gl) => gl.getExtension(OES_element_index) ? 16777216 : 65535
+      (gl2) => gl2.getExtension(OES_element_index) ? 16777216 : 65535
     ),
     [GL.MAX_ELEMENTS_VERTICES]: (
       // Guess: "Reasonably safe" per webglstats.com - could be higher/lower (on some mobile devices)
-      (gl) => 16777216
+      (gl2) => 16777216
     ),
     [GL.MAX_FRAGMENT_INPUT_COMPONENTS]: getWebGL2ValueOrZero,
     [GL.MAX_FRAGMENT_UNIFORM_BLOCKS]: getWebGL2ValueOrZero,
@@ -3305,24 +3348,24 @@ var __exports__ = (() => {
     [GL.MAX_PROGRAM_TEXEL_OFFSET]: getWebGL2ValueOrZero,
     [GL.UNIFORM_BUFFER_OFFSET_ALIGNMENT]: getWebGL2ValueOrZero
   };
-  function getParameterPolyfill(gl, originalGetParameter, pname) {
+  function getParameterPolyfill(gl2, originalGetParameter, pname) {
     const limit = WEBGL_PARAMETERS[pname];
-    const value = typeof limit === "function" ? limit(gl, originalGetParameter, pname) : limit;
+    const value = typeof limit === "function" ? limit(gl2, originalGetParameter, pname) : limit;
     const result = value !== void 0 ? value : originalGetParameter(pname);
     return result;
   }
 
   // src/context/polyfill/context-data.ts
-  function getContextData(gl) {
-    const luma = gl.luma;
+  function getContextData(gl2) {
+    const luma = gl2.luma;
     if (!luma) {
       const contextState = {
         _polyfilled: false,
         _extensions: {}
       };
-      gl.luma = contextState;
+      gl2.luma = contextState;
     }
-    return gl.luma;
+    return gl2.luma;
   }
 
   // src/context/polyfill/polyfill-table.ts
@@ -3332,10 +3375,10 @@ var __exports__ = (() => {
   var EXT_disjoint_timer_query2 = "EXT_disjoint_timer_query";
   var EXT_texture_filter_anisotropic2 = "EXT_texture_filter_anisotropic";
   var ERR_VAO_NOT_SUPPORTED = "VertexArray requires WebGL2 or OES_vertex_array_object extension";
-  function getExtensionData(gl, extension) {
+  function getExtensionData(gl2, extension) {
     return {
-      webgl2: isWebGL2(gl),
-      ext: gl.getExtension(extension)
+      webgl2: isWebGL2(gl2),
+      ext: gl2.getExtension(extension)
     };
   }
   var WEBGL2_CONTEXT_POLYFILLS = {
@@ -3406,18 +3449,18 @@ var __exports__ = (() => {
   };
   var WEBGL2_CONTEXT_OVERRIDES = {
     // Ensure readBuffer is a no-op
-    readBuffer: (gl, originalFunc, attachment) => {
-      if (isWebGL2(gl)) {
+    readBuffer: (gl2, originalFunc, attachment) => {
+      if (isWebGL2(gl2)) {
         originalFunc(attachment);
       } else {
       }
     },
     // Override for getVertexAttrib that returns sane values for non-WebGL1 constants
-    getVertexAttrib: (gl, originalFunc, location, pname) => {
+    getVertexAttrib: (gl2, originalFunc, location, pname) => {
       const {
         webgl2,
         ext
-      } = getExtensionData(gl, ANGLE_instanced_arrays);
+      } = getExtensionData(gl2, ANGLE_instanced_arrays);
       let result;
       switch (pname) {
         case GL.VERTEX_ATTRIB_ARRAY_INTEGER:
@@ -3431,8 +3474,8 @@ var __exports__ = (() => {
       return result !== void 0 ? result : originalFunc(location, pname);
     },
     // Handle transform feedback and uniform block queries in WebGL1
-    getProgramParameter: (gl, originalFunc, program, pname) => {
-      if (!isWebGL2(gl)) {
+    getProgramParameter: (gl2, originalFunc, program, pname) => {
+      if (!isWebGL2(gl2)) {
         switch (pname) {
           case GL.TRANSFORM_FEEDBACK_BUFFER_MODE:
             return GL.SEPARATE_ATTRIBS;
@@ -3445,21 +3488,21 @@ var __exports__ = (() => {
       }
       return originalFunc(program, pname);
     },
-    getInternalformatParameter: (gl, originalFunc, target, format, pname) => {
-      if (!isWebGL2(gl)) {
+    getInternalformatParameter: (gl2, originalFunc, target, format, pname) => {
+      if (!isWebGL2(gl2)) {
         switch (pname) {
           case GL.SAMPLES:
             return new Int32Array([0]);
           default:
         }
       }
-      const gl2 = gl;
-      return gl2.getInternalformatParameter(target, format, pname);
+      const gl22 = gl2;
+      return gl22.getInternalformatParameter(target, format, pname);
     },
-    getTexParameter(gl, originalFunc, target, pname) {
+    getTexParameter(gl2, originalFunc, target, pname) {
       switch (pname) {
         case GL.TEXTURE_MAX_ANISOTROPY_EXT:
-          const contextData = getContextData(gl);
+          const contextData = getContextData(gl2);
           const {
             _extensions
           } = contextData;
@@ -3471,47 +3514,47 @@ var __exports__ = (() => {
       return originalFunc(target, pname);
     },
     getParameter: getParameterPolyfill,
-    hint(gl, originalFunc, pname, value) {
+    hint(gl2, originalFunc, pname, value) {
       return originalFunc(pname, value);
     }
   };
 
   // src/context/polyfill/polyfill-context.ts
-  function polyfillContext(gl) {
-    const contextState = getContextData(gl);
+  function polyfillContext(gl2) {
+    const contextState = getContextData(gl2);
     if (!contextState._polyfilled) {
-      polyfillVertexArrayObject(gl);
-      initializeExtensions(gl);
-      installPolyfills(gl, WEBGL2_CONTEXT_POLYFILLS);
-      installOverrides(gl, {
+      polyfillVertexArrayObject(gl2);
+      initializeExtensions(gl2);
+      installPolyfills(gl2, WEBGL2_CONTEXT_POLYFILLS);
+      installOverrides(gl2, {
         target: contextState,
-        target2: gl
+        target2: gl2
       });
       contextState._polyfilled = true;
     }
-    return gl;
+    return gl2;
   }
-  function initializeExtensions(gl) {
-    const contextState = getContextData(gl);
-    const EXTENSIONS = gl.getSupportedExtensions() || [];
+  function initializeExtensions(gl2) {
+    const contextState = getContextData(gl2);
+    const EXTENSIONS = gl2.getSupportedExtensions() || [];
     for (const extensionName of EXTENSIONS) {
-      const extension = gl.getExtension(extensionName);
+      const extension = gl2.getExtension(extensionName);
       contextState._extensions[extensionName] = extension;
     }
   }
-  function installPolyfills(gl, polyfills) {
-    const contextState = getContextData(gl);
+  function installPolyfills(gl2, polyfills) {
+    const contextState = getContextData(gl2);
     for (const extension of Object.getOwnPropertyNames(polyfills)) {
       if (extension !== "overrides") {
-        polyfillExtension(gl, {
+        polyfillExtension(gl2, {
           extension,
           target: contextState,
-          target2: gl
+          target2: gl2
         });
       }
     }
   }
-  function polyfillExtension(gl, {
+  function polyfillExtension(gl2, {
     extension,
     target,
     target2
@@ -3524,12 +3567,12 @@ var __exports__ = (() => {
     const {
       suffix = ""
     } = meta;
-    const ext = gl.getExtension(extension);
+    const ext = gl2.getExtension(extension);
     for (const key of Object.keys(defaults)) {
       const extKey = `${key}${suffix}`;
       let polyfill = null;
       if (key === "meta") {
-      } else if (typeof gl[key] === "function") {
+      } else if (typeof gl2[key] === "function") {
       } else if (ext && typeof ext[extKey] === "function") {
         polyfill = (...args) => ext[extKey](...args);
       } else if (typeof defaults[key] === "function") {
@@ -3541,15 +3584,15 @@ var __exports__ = (() => {
       }
     }
   }
-  function installOverrides(gl, {
+  function installOverrides(gl2, {
     target,
     target2
   }) {
     Object.keys(WEBGL2_CONTEXT_OVERRIDES).forEach((key) => {
       if (typeof WEBGL2_CONTEXT_OVERRIDES[key] === "function") {
-        const originalFunc = gl[key] ? gl[key].bind(gl) : () => {
+        const originalFunc = gl2[key] ? gl2[key].bind(gl2) : () => {
         };
-        const polyfill = WEBGL2_CONTEXT_OVERRIDES[key].bind(null, gl, originalFunc);
+        const polyfill = WEBGL2_CONTEXT_OVERRIDES[key].bind(null, gl2, originalFunc);
         target[key] = polyfill;
         target2[key] = polyfill;
       }
@@ -3640,19 +3683,19 @@ var __exports__ = (() => {
     [GL.UNPACK_SKIP_ROWS]: 0,
     [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) => {
+  var enable = (gl2, value, key) => value ? gl2.enable(key) : gl2.disable(key);
+  var hint = (gl2, value, key) => gl2.hint(key, value);
+  var pixelStorei = (gl2, value, key) => gl2.pixelStorei(key, value);
+  var bindFramebuffer = (gl2, value, key) => {
     let target;
     if (key === GL.FRAMEBUFFER_BINDING) {
-      target = isWebGL2(gl) ? GL.DRAW_FRAMEBUFFER : GL.FRAMEBUFFER;
+      target = isWebGL2(gl2) ? GL.DRAW_FRAMEBUFFER : GL.FRAMEBUFFER;
     } else {
       target = GL.READ_FRAMEBUFFER;
     }
-    return gl.bindFramebuffer(target, value);
+    return gl2.bindFramebuffer(target, value);
   };
-  var bindBuffer = (gl, value, key) => {
+  var bindBuffer = (gl2, value, key) => {
     const bindingMap = {
       [GL.ARRAY_BUFFER_BINDING]: GL.ARRAY_BUFFER,
       [GL.COPY_READ_BUFFER_BINDING]: GL.COPY_READ_BUFFER,
@@ -3661,35 +3704,35 @@ var __exports__ = (() => {
       [GL.PIXEL_UNPACK_BUFFER_BINDING]: GL.PIXEL_UNPACK_BUFFER
     };
     const target = bindingMap[key];
-    gl.bindBuffer(target, value);
+    gl2.bindBuffer(target, value);
   };
   function isArray(array) {
     return Array.isArray(array) || ArrayBuffer.isView(array) && !(array instanceof DataView);
   }
   var GL_PARAMETER_SETTERS = {
     [GL.BLEND]: enable,
-    [GL.BLEND_COLOR]: (gl, value) => gl.blendColor(...value),
+    [GL.BLEND_COLOR]: (gl2, value) => gl2.blendColor(...value),
     [GL.BLEND_EQUATION_RGB]: "blendEquation",
     [GL.BLEND_EQUATION_ALPHA]: "blendEquation",
     [GL.BLEND_SRC_RGB]: "blendFunc",
     [GL.BLEND_DST_RGB]: "blendFunc",
     [GL.BLEND_SRC_ALPHA]: "blendFunc",
     [GL.BLEND_DST_ALPHA]: "blendFunc",
-    [GL.COLOR_CLEAR_VALUE]: (gl, value) => gl.clearColor(...value),
-    [GL.COLOR_WRITEMASK]: (gl, value) => gl.colorMask(...value),
+    [GL.COLOR_CLEAR_VALUE]: (gl2, value) => gl2.clearColor(...value),
+    [GL.COLOR_WRITEMASK]: (gl2, value) => gl2.colorMask(...value),
     [GL.CULL_FACE]: enable,
-    [GL.CULL_FACE_MODE]: (gl, value) => gl.cullFace(value),
+    [GL.CULL_FACE_MODE]: (gl2, value) => gl2.cullFace(value),
     [GL.DEPTH_TEST]: enable,
-    [GL.DEPTH_CLEAR_VALUE]: (gl, value) => gl.clearDepth(value),
-    [GL.DEPTH_FUNC]: (gl, value) => gl.depthFunc(value),
-    [GL.DEPTH_RANGE]: (gl, value) => gl.depthRange(...value),
-    [GL.DEPTH_WRITEMASK]: (gl, value) => gl.depthMask(value),
+    [GL.DEPTH_CLEAR_VALUE]: (gl2, value) => gl2.clearDepth(value),
+    [GL.DEPTH_FUNC]: (gl2, value) => gl2.depthFunc(value),
+    [GL.DEPTH_RANGE]: (gl2, value) => gl2.depthRange(...value),
+    [GL.DEPTH_WRITEMASK]: (gl2, value) => gl2.depthMask(value),
     [GL.DITHER]: enable,
     [GL.FRAGMENT_SHADER_DERIVATIVE_HINT]: hint,
-    [GL.CURRENT_PROGRAM]: (gl, value) => gl.useProgram(value),
-    [GL.RENDERBUFFER_BINDING]: (gl, value) => gl.bindRenderbuffer(GL.RENDERBUFFER, value),
-    [GL.TRANSFORM_FEEDBACK_BINDING]: (gl, value) => gl.bindTransformFeedback?.(GL.TRANSFORM_FEEDBACK, value),
-    [GL.VERTEX_ARRAY_BINDING]: (gl, value) => gl.bindVertexArray(value),
+    [GL.CURRENT_PROGRAM]: (gl2, value) => gl2.useProgram(value),
+    [GL.RENDERBUFFER_BINDING]: (gl2, value) => gl2.bindRenderbuffer(GL.RENDERBUFFER, value),
+    [GL.TRANSFORM_FEEDBACK_BINDING]: (gl2, value) => gl2.bindTransformFeedback?.(GL.TRANSFORM_FEEDBACK, value),
+    [GL.VERTEX_ARRAY_BINDING]: (gl2, value) => gl2.bindVertexArray(value),
     // NOTE: FRAMEBUFFER_BINDING and DRAW_FRAMEBUFFER_BINDING(WebGL2) refer same state.
     [GL.FRAMEBUFFER_BINDING]: bindFramebuffer,
     [GL.READ_FRAMEBUFFER_BINDING]: bindFramebuffer,
@@ -3699,9 +3742,9 @@ var __exports__ = (() => {
     [GL.COPY_WRITE_BUFFER_BINDING]: bindBuffer,
     [GL.PIXEL_PACK_BUFFER_BINDING]: bindBuffer,
     [GL.PIXEL_UNPACK_BUFFER_BINDING]: bindBuffer,
-    [GL.FRONT_FACE]: (gl, value) => gl.frontFace(value),
+    [GL.FRONT_FACE]: (gl2, value) => gl2.frontFace(value),
     [GL.GENERATE_MIPMAP_HINT]: hint,
-    [GL.LINE_WIDTH]: (gl, value) => gl.lineWidth(value),
+    [GL.LINE_WIDTH]: (gl2, value) => gl2.lineWidth(value),
     [GL.POLYGON_OFFSET_FILL]: enable,
     [GL.POLYGON_OFFSET_FACTOR]: "polygonOffset",
     [GL.POLYGON_OFFSET_UNITS]: "polygonOffset",
@@ -3711,11 +3754,11 @@ var __exports__ = (() => {
     [GL.SAMPLE_COVERAGE_VALUE]: "sampleCoverage",
     [GL.SAMPLE_COVERAGE_INVERT]: "sampleCoverage",
     [GL.SCISSOR_TEST]: enable,
-    [GL.SCISSOR_BOX]: (gl, value) => gl.scissor(...value),
+    [GL.SCISSOR_BOX]: (gl2, value) => gl2.scissor(...value),
     [GL.STENCIL_TEST]: enable,
-    [GL.STENCIL_CLEAR_VALUE]: (gl, value) => gl.clearStencil(value),
-    [GL.STENCIL_WRITEMASK]: (gl, value) => gl.stencilMaskSeparate(GL.FRONT, value),
-    [GL.STENCIL_BACK_WRITEMASK]: (gl, value) => gl.stencilMaskSeparate(GL.BACK, value),
+    [GL.STENCIL_CLEAR_VALUE]: (gl2, value) => gl2.clearStencil(value),
+    [GL.STENCIL_WRITEMASK]: (gl2, value) => gl2.stencilMaskSeparate(GL.FRONT, value),
+    [GL.STENCIL_BACK_WRITEMASK]: (gl2, value) => gl2.stencilMaskSeparate(GL.BACK, value),
     [GL.STENCIL_FUNC]: "stencilFuncFront",
     [GL.STENCIL_REF]: "stencilFuncFront",
     [GL.STENCIL_VALUE_MASK]: "stencilFuncFront",
@@ -3728,7 +3771,7 @@ var __exports__ = (() => {
     [GL.STENCIL_BACK_FAIL]: "stencilOpBack",
     [GL.STENCIL_BACK_PASS_DEPTH_FAIL]: "stencilOpBack",
     [GL.STENCIL_BACK_PASS_DEPTH_PASS]: "stencilOpBack",
-    [GL.VIEWPORT]: (gl, value) => gl.viewport(...value),
+    [GL.VIEWPORT]: (gl2, value) => gl2.viewport(...value),
     // WEBGL1 PIXEL PACK/UNPACK MODES
     [GL.PACK_ALIGNMENT]: pixelStorei,
     [GL.UNPACK_ALIGNMENT]: pixelStorei,
@@ -3746,75 +3789,75 @@ var __exports__ = (() => {
     [GL.UNPACK_SKIP_ROWS]: pixelStorei,
     [GL.UNPACK_SKIP_IMAGES]: pixelStorei,
     // Function-style setters
-    framebuffer: (gl, framebuffer) => {
+    framebuffer: (gl2, framebuffer) => {
       const handle = framebuffer && "handle" in framebuffer ? framebuffer.handle : framebuffer;
-      return gl.bindFramebuffer(GL.FRAMEBUFFER, handle);
+      return gl2.bindFramebuffer(GL.FRAMEBUFFER, handle);
     },
-    blend: (gl, value) => value ? gl.enable(GL.BLEND) : gl.disable(GL.BLEND),
-    blendColor: (gl, value) => gl.blendColor(...value),
-    blendEquation: (gl, args) => {
+    blend: (gl2, value) => value ? gl2.enable(GL.BLEND) : gl2.disable(GL.BLEND),
+    blendColor: (gl2, value) => gl2.blendColor(...value),
+    blendEquation: (gl2, args) => {
       const separateModes = typeof args === "number" ? [args, args] : args;
-      gl.blendEquationSeparate(...separateModes);
+      gl2.blendEquationSeparate(...separateModes);
     },
-    blendFunc: (gl, args) => {
+    blendFunc: (gl2, args) => {
       const separateFuncs = args?.length === 2 ? [...args, ...args] : args;
-      gl.blendFuncSeparate(...separateFuncs);
-    },
-    clearColor: (gl, value) => gl.clearColor(...value),
-    clearDepth: (gl, value) => gl.clearDepth(value),
-    clearStencil: (gl, value) => gl.clearStencil(value),
-    colorMask: (gl, value) => gl.colorMask(...value),
-    cull: (gl, value) => value ? gl.enable(GL.CULL_FACE) : gl.disable(GL.CULL_FACE),
-    cullFace: (gl, value) => gl.cullFace(value),
-    depthTest: (gl, value) => value ? gl.enable(GL.DEPTH_TEST) : gl.disable(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(GL.DITHER) : gl.disable(GL.DITHER),
-    derivativeHint: (gl, value) => {
-      gl.hint(GL.FRAGMENT_SHADER_DERIVATIVE_HINT, value);
-    },
-    frontFace: (gl, value) => gl.frontFace(value),
-    mipmapHint: (gl, value) => gl.hint(GL.GENERATE_MIPMAP_HINT, value),
-    lineWidth: (gl, value) => gl.lineWidth(value),
-    polygonOffsetFill: (gl, value) => value ? gl.enable(GL.POLYGON_OFFSET_FILL) : gl.disable(GL.POLYGON_OFFSET_FILL),
-    polygonOffset: (gl, value) => gl.polygonOffset(...value),
-    sampleCoverage: (gl, value) => gl.sampleCoverage(...value),
-    scissorTest: (gl, value) => value ? gl.enable(GL.SCISSOR_TEST) : gl.disable(GL.SCISSOR_TEST),
-    scissor: (gl, value) => gl.scissor(...value),
-    stencilTest: (gl, value) => value ? gl.enable(GL.STENCIL_TEST) : gl.disable(GL.STENCIL_TEST),
-    stencilMask: (gl, value) => {
+      gl2.blendFuncSeparate(...separateFuncs);
+    },
+    clearColor: (gl2, value) => gl2.clearColor(...value),
+    clearDepth: (gl2, value) => gl2.clearDepth(value),
+    clearStencil: (gl2, value) => gl2.clearStencil(value),
+    colorMask: (gl2, value) => gl2.colorMask(...value),
+    cull: (gl2, value) => value ? gl2.enable(GL.CULL_FACE) : gl2.disable(GL.CULL_FACE),
+    cullFace: (gl2, value) => gl2.cullFace(value),
+    depthTest: (gl2, value) => value ? gl2.enable(GL.DEPTH_TEST) : gl2.disable(GL.DEPTH_TEST),
+    depthFunc: (gl2, value) => gl2.depthFunc(value),
+    depthMask: (gl2, value) => gl2.depthMask(value),
+    depthRange: (gl2, value) => gl2.depthRange(...value),
+    dither: (gl2, value) => value ? gl2.enable(GL.DITHER) : gl2.disable(GL.DITHER),
+    derivativeHint: (gl2, value) => {
+      gl2.hint(GL.FRAGMENT_SHADER_DERIVATIVE_HINT, value);
+    },
+    frontFace: (gl2, value) => gl2.frontFace(value),
+    mipmapHint: (gl2, value) => gl2.hint(GL.GENERATE_MIPMAP_HINT, value),
+    lineWidth: (gl2, value) => gl2.lineWidth(value),
+    polygonOffsetFill: (gl2, value) => value ? gl2.enable(GL.POLYGON_OFFSET_FILL) : gl2.disable(GL.POLYGON_OFFSET_FILL),
+    polygonOffset: (gl2, value) => gl2.polygonOffset(...value),
+    sampleCoverage: (gl2, value) => gl2.sampleCoverage(...value),
+    scissorTest: (gl2, value) => value ? gl2.enable(GL.SCISSOR_TEST) : gl2.disable(GL.SCISSOR_TEST),
+    scissor: (gl2, value) => gl2.scissor(...value),
+    stencilTest: (gl2, value) => value ? gl2.enable(GL.STENCIL_TEST) : gl2.disable(GL.STENCIL_TEST),
+    stencilMask: (gl2, value) => {
       value = isArray(value) ? value : [value, value];
       const [mask, backMask] = value;
-      gl.stencilMaskSeparate(GL.FRONT, mask);
-      gl.stencilMaskSeparate(GL.BACK, backMask);
+      gl2.stencilMaskSeparate(GL.FRONT, mask);
+      gl2.stencilMaskSeparate(GL.BACK, backMask);
     },
-    stencilFunc: (gl, args) => {
+    stencilFunc: (gl2, args) => {
       args = isArray(args) && args.length === 3 ? [...args, ...args] : args;
       const [func, ref, mask, backFunc, backRef, backMask] = args;
-      gl.stencilFuncSeparate(GL.FRONT, func, ref, mask);
-      gl.stencilFuncSeparate(GL.BACK, backFunc, backRef, backMask);
+      gl2.stencilFuncSeparate(GL.FRONT, func, ref, mask);
+      gl2.stencilFuncSeparate(GL.BACK, backFunc, backRef, backMask);
     },
-    stencilOp: (gl, args) => {
+    stencilOp: (gl2, args) => {
       args = isArray(args) && args.length === 3 ? [...args, ...args] : args;
       const [sfail, dpfail, dppass, backSfail, backDpfail, backDppass] = args;
-      gl.stencilOpSeparate(GL.FRONT, sfail, dpfail, dppass);
-      gl.stencilOpSeparate(GL.BACK, backSfail, backDpfail, backDppass);
+      gl2.stencilOpSeparate(GL.FRONT, sfail, dpfail, dppass);
+      gl2.stencilOpSeparate(GL.BACK, backSfail, backDpfail, backDppass);
     },
-    viewport: (gl, value) => gl.viewport(...value)
+    viewport: (gl2, value) => gl2.viewport(...value)
   };
   function getValue(glEnum, values, cache2) {
     return values[glEnum] !== void 0 ? values[glEnum] : cache2[glEnum];
   }
   var GL_COMPOSITE_PARAMETER_SETTERS = {
-    blendEquation: (gl, values, cache2) => gl.blendEquationSeparate(getValue(GL.BLEND_EQUATION_RGB, values, cache2), getValue(GL.BLEND_EQUATION_ALPHA, values, cache2)),
-    blendFunc: (gl, values, cache2) => gl.blendFuncSeparate(getValue(GL.BLEND_SRC_RGB, values, cache2), getValue(GL.BLEND_DST_RGB, values, cache2), getValue(GL.BLEND_SRC_ALPHA, values, cache2), getValue(GL.BLEND_DST_ALPHA, values, cache2)),
-    polygonOffset: (gl, values, cache2) => gl.polygonOffset(getValue(GL.POLYGON_OFFSET_FACTOR, values, cache2), getValue(GL.POLYGON_OFFSET_UNITS, values, cache2)),
-    sampleCoverage: (gl, values, cache2) => gl.sampleCoverage(getValue(GL.SAMPLE_COVERAGE_VALUE, values, cache2), getValue(GL.SAMPLE_COVERAGE_INVERT, values, cache2)),
-    stencilFuncFront: (gl, values, cache2) => gl.stencilFuncSeparate(GL.FRONT, getValue(GL.STENCIL_FUNC, values, cache2), getValue(GL.STENCIL_REF, values, cache2), getValue(GL.STENCIL_VALUE_MASK, values, cache2)),
-    stencilFuncBack: (gl, values, cache2) => gl.stencilFuncSeparate(GL.BACK, getValue(GL.STENCIL_BACK_FUNC, values, cache2), getValue(GL.STENCIL_BACK_REF, values, cache2), getValue(GL.STENCIL_BACK_VALUE_MASK, values, cache2)),
-    stencilOpFront: (gl, values, cache2) => gl.stencilOpSeparate(GL.FRONT, getValue(GL.STENCIL_FAIL, values, cache2), getValue(GL.STENCIL_PASS_DEPTH_FAIL, values, cache2), getValue(GL.STENCIL_PASS_DEPTH_PASS, values, cache2)),
-    stencilOpBack: (gl, values, cache2) => gl.stencilOpSeparate(GL.BACK, getValue(GL.STENCIL_BACK_FAIL, values, cache2), getValue(GL.STENCIL_BACK_PASS_DEPTH_FAIL, values, cache2), getValue(GL.STENCIL_BACK_PASS_DEPTH_PASS, values, cache2))
+    blendEquation: (gl2, values, cache2) => gl2.blendEquationSeparate(getValue(GL.BLEND_EQUATION_RGB, values, cache2), getValue(GL.BLEND_EQUATION_ALPHA, values, cache2)),
+    blendFunc: (gl2, values, cache2) => gl2.blendFuncSeparate(getValue(GL.BLEND_SRC_RGB, values, cache2), getValue(GL.BLEND_DST_RGB, values, cache2), getValue(GL.BLEND_SRC_ALPHA, values, cache2), getValue(GL.BLEND_DST_ALPHA, values, cache2)),
+    polygonOffset: (gl2, values, cache2) => gl2.polygonOffset(getValue(GL.POLYGON_OFFSET_FACTOR, values, cache2), getValue(GL.POLYGON_OFFSET_UNITS, values, cache2)),
+    sampleCoverage: (gl2, values, cache2) => gl2.sampleCoverage(getValue(GL.SAMPLE_COVERAGE_VALUE, values, cache2), getValue(GL.SAMPLE_COVERAGE_INVERT, values, cache2)),
+    stencilFuncFront: (gl2, values, cache2) => gl2.stencilFuncSeparate(GL.FRONT, getValue(GL.STENCIL_FUNC, values, cache2), getValue(GL.STENCIL_REF, values, cache2), getValue(GL.STENCIL_VALUE_MASK, values, cache2)),
+    stencilFuncBack: (gl2, values, cache2) => gl2.stencilFuncSeparate(GL.BACK, getValue(GL.STENCIL_BACK_FUNC, values, cache2), getValue(GL.STENCIL_BACK_REF, values, cache2), getValue(GL.STENCIL_BACK_VALUE_MASK, values, cache2)),
+    stencilOpFront: (gl2, values, cache2) => gl2.stencilOpSeparate(GL.FRONT, getValue(GL.STENCIL_FAIL, values, cache2), getValue(GL.STENCIL_PASS_DEPTH_FAIL, values, cache2), getValue(GL.STENCIL_PASS_DEPTH_PASS, values, cache2)),
+    stencilOpBack: (gl2, values, cache2) => gl2.stencilOpSeparate(GL.BACK, getValue(GL.STENCIL_BACK_FAIL, values, cache2), getValue(GL.STENCIL_BACK_PASS_DEPTH_FAIL, values, cache2), getValue(GL.STENCIL_BACK_PASS_DEPTH_PASS, values, cache2))
   };
   var GL_HOOKED_SETTERS = {
     // GENERIC SETTERS
@@ -3980,7 +4023,7 @@ var __exports__ = (() => {
       [GL.VIEWPORT]: [x, y, width, height]
     })
   };
-  var isEnabled = (gl, key) => gl.isEnabled(key);
+  var isEnabled = (gl2, key) => gl2.isEnabled(key);
   var GL_PARAMETER_GETTERS = {
     [GL.BLEND]: isEnabled,
     [GL.CULL_FACE]: isEnabled,
@@ -4036,7 +4079,7 @@ var __exports__ = (() => {
   // src/context/parameters/unified-parameter-api.ts
   function setParameters(device, parameters) {
     const webglDevice = WebGLDevice.attach(device);
-    const gl = webglDevice.gl;
+    const gl2 = webglDevice.gl;
     if (isObjectEmpty2(parameters)) {
       return;
     }
@@ -4048,31 +4091,31 @@ var __exports__ = (() => {
         if (typeof setter === "string") {
           compositeSetters[setter] = true;
         } else {
-          setter(gl, parameters[key], glConstant);
+          setter(gl2, parameters[key], glConstant);
         }
       }
     }
-    const cache2 = gl.state && gl.state.cache;
+    const cache2 = gl2.state && gl2.state.cache;
     if (cache2) {
       for (const key in compositeSetters) {
         const compositeSetter = GL_COMPOSITE_PARAMETER_SETTERS[key];
-        compositeSetter(gl, parameters, cache2);
+        compositeSetter(gl2, parameters, cache2);
       }
     }
   }
   function getParameters(device, parameters = GL_PARAMETER_DEFAULTS) {
     const webglDevice = WebGLDevice.attach(device);
-    const gl = webglDevice.gl;
+    const gl2 = webglDevice.gl;
     if (typeof parameters === "number") {
       const key = parameters;
       const getter = GL_PARAMETER_GETTERS[key];
-      return getter ? getter(gl, key) : gl.getParameter(key);
+      return getter ? getter(gl2, key) : gl2.getParameter(key);
     }
     const parameterKeys = Array.isArray(parameters) ? parameters : Object.keys(parameters);
     const state = {};
     for (const key of parameterKeys) {
       const getter = GL_PARAMETER_GETTERS[key];
-      state[key] = getter ? getter(gl, Number(key)) : gl.getParameter(Number(key));
+      state[key] = getter ? getter(gl2, Number(key)) : gl2.getParameter(Number(key));
     }
     return state;
   }
@@ -4109,15 +4152,15 @@ var __exports__ = (() => {
     program = null;
     stateStack = [];
     enable = true;
-    constructor(gl, {
+    constructor(gl2, {
       copyState = false,
       // Copy cache from params (slow) or initialize from WebGL defaults (fast)
       log: log3 = () => {
       }
       // Logging function, called when gl parameter change calls are actually issued
     } = {}) {
-      this.gl = gl;
-      this.cache = copyState ? getParameters(gl) : Object.assign({}, GL_PARAMETER_DEFAULTS);
+      this.gl = gl2;
+      this.cache = copyState ? getParameters(gl2) : Object.assign({}, GL_PARAMETER_DEFAULTS);
       this.log = log3;
       this._updateCache = this._updateCache.bind(this);
       Object.seal(this);
@@ -4160,53 +4203,53 @@ var __exports__ = (() => {
       };
     }
   };
-  function getContextState(gl) {
-    return gl.state;
+  function getContextState(gl2) {
+    return gl2.state;
   }
-  function trackContextState(gl, options) {
+  function trackContextState(gl2, options) {
     const {
       enable: enable2 = true,
       copyState
     } = options;
     assert2(copyState !== void 0);
-    if (!gl.state) {
-      gl.state = new GLState(gl, {
+    if (!gl2.state) {
+      gl2.state = new GLState(gl2, {
         copyState
       });
-      installProgramSpy(gl);
+      installProgramSpy(gl2);
       for (const key in GL_HOOKED_SETTERS) {
         const setter = GL_HOOKED_SETTERS[key];
-        installSetterSpy(gl, key, setter);
+        installSetterSpy(gl2, key, setter);
       }
-      installGetterOverride(gl, "getParameter");
-      installGetterOverride(gl, "isEnabled");
+      installGetterOverride(gl2, "getParameter");
+      installGetterOverride(gl2, "isEnabled");
     }
-    const glState = getContextState(gl);
+    const glState = getContextState(gl2);
     glState.enable = enable2;
-    return gl;
+    return gl2;
   }
-  function pushContextState(gl) {
-    let glState = getContextState(gl);
+  function pushContextState(gl2) {
+    let glState = getContextState(gl2);
     if (!glState) {
-      trackContextState(gl, {
+      trackContextState(gl2, {
         copyState: false
       });
-      glState = getContextState(gl);
+      glState = getContextState(gl2);
     }
     glState.push();
   }
-  function popContextState(gl) {
-    const glState = getContextState(gl);
+  function popContextState(gl2) {
+    const glState = getContextState(gl2);
     assert2(glState);
     glState.pop();
   }
-  function installGetterOverride(gl, functionName) {
-    const originalGetterFunc = gl[functionName].bind(gl);
-    gl[functionName] = function get(pname) {
+  function installGetterOverride(gl2, functionName) {
+    const originalGetterFunc = gl2[functionName].bind(gl2);
+    gl2[functionName] = function get(pname) {
       if (pname === void 0 || NON_CACHE_PARAMETERS.has(pname)) {
         return originalGetterFunc(pname);
       }
-      const glState = getContextState(gl);
+      const glState = getContextState(gl2);
       if (!(pname in glState.cache)) {
         glState.cache[pname] = originalGetterFunc(pname);
       }
@@ -4218,18 +4261,18 @@ var __exports__ = (() => {
         originalGetterFunc(pname)
       );
     };
-    Object.defineProperty(gl[functionName], "name", {
+    Object.defineProperty(gl2[functionName], "name", {
       value: `${functionName}-from-cache`,
       configurable: false
     });
   }
-  function installSetterSpy(gl, functionName, setter) {
-    if (!gl[functionName]) {
+  function installSetterSpy(gl2, functionName, setter) {
+    if (!gl2[functionName]) {
       return;
     }
-    const originalSetterFunc = gl[functionName].bind(gl);
-    gl[functionName] = function set(...params) {
-      const glState = getContextState(gl);
+    const originalSetterFunc = gl2[functionName].bind(gl2);
+    gl2[functionName] = function set(...params) {
+      const glState = getContextState(gl2);
       const {
         valueChanged,
         oldValue
@@ -4239,15 +4282,15 @@ var __exports__ = (() => {
       }
       return oldValue;
     };
-    Object.defineProperty(gl[functionName], "name", {
+    Object.defineProperty(gl2[functionName], "name", {
       value: `${functionName}-to-cache`,
       configurable: false
     });
   }
-  function installProgramSpy(gl) {
-    const originalUseProgram = gl.useProgram.bind(gl);
-    gl.useProgram = function useProgramLuma(handle) {
-      const glState = getContextState(gl);
+  function installProgramSpy(gl2) {
+    const originalUseProgram = gl2.useProgram.bind(gl2);
+    gl2.useProgram = function useProgramLuma(handle) {
+      const glState = getContextState(gl2);
       if (glState.program !== handle) {
         originalUseProgram(handle);
         glState.program = handle;
@@ -4276,7 +4319,7 @@ var __exports__ = (() => {
     let errorMessage = null;
     const onCreateError = (error2) => errorMessage = error2.statusMessage || errorMessage;
     canvas.addEventListener("webglcontextcreationerror", onCreateError, false);
-    let gl = null;
+    let gl2 = null;
     if (props.type === "webgl2") {
       props = {
         ...props,
@@ -4289,14 +4332,14 @@ var __exports__ = (() => {
         webgl2: false
       };
     }
-    if (!gl && props.webgl2) {
-      gl = canvas.getContext("webgl2", props);
+    if (!gl2 && props.webgl2) {
+      gl2 = canvas.getContext("webgl2", props);
     }
-    if (!gl && props.webgl1) {
-      gl = canvas.getContext("webgl", props);
+    if (!gl2 && props.webgl1) {
+      gl2 = canvas.getContext("webgl", props);
     }
     canvas.removeEventListener("webglcontextcreationerror", onCreateError, false);
-    if (!gl) {
+    if (!gl2) {
       throw new Error(`Failed to create ${props.webgl2 && !props.webgl1 ? "WebGL2" : "WebGL"} context: ${errorMessage || "Unknown error"}`);
     }
     if (props.onContextLost) {
@@ -4311,28 +4354,28 @@ var __exports__ = (() => {
       } = props;
       canvas.addEventListener("webglcontextrestored", (event) => onContextRestored(event), false);
     }
-    return gl;
+    return gl2;
   }
 
   // src/adapter/device-helpers/get-device-info.ts
-  function getDeviceInfo(gl) {
-    const vendorMasked = gl.getParameter(GL.VENDOR);
-    const rendererMasked = gl.getParameter(GL.RENDERER);
-    const ext = gl.getExtension("WEBGL_debug_renderer_info");
-    const vendorUnmasked = gl.getParameter(ext ? ext.UNMASKED_VENDOR_WEBGL : GL.VENDOR);
-    const rendererUnmasked = gl.getParameter(ext ? ext.UNMASKED_RENDERER_WEBGL : GL.RENDERER);
+  function getDeviceInfo(gl2) {
+    const vendorMasked = gl2.getParameter(GL.VENDOR);
+    const rendererMasked = gl2.getParameter(GL.RENDERER);
+    const ext = gl2.getExtension("WEBGL_debug_renderer_info");
+    const vendorUnmasked = gl2.getParameter(ext ? ext.UNMASKED_VENDOR_WEBGL : GL.VENDOR);
+    const rendererUnmasked = gl2.getParameter(ext ? ext.UNMASKED_RENDERER_WEBGL : GL.RENDERER);
     const vendor = vendorUnmasked || vendorMasked;
     const renderer = rendererUnmasked || rendererMasked;
     const gpu = identifyGPUVendor(vendor, renderer);
     return {
-      type: isWebGL2(gl) ? "webgl2" : "webgl",
+      type: isWebGL2(gl2) ? "webgl2" : "webgl",
       gpu,
       vendor: vendorUnmasked || vendorMasked,
       renderer: rendererUnmasked || rendererMasked,
-      version: gl.getParameter(GL.VERSION),
+      version: gl2.getParameter(GL.VERSION),
       shadingLanguages: ["glsl"],
       shadingLanguageVersions: {
-        "glsl": gl.getParameter(GL.SHADING_LANGUAGE_VERSION)
+        "glsl": gl2.getParameter(GL.SHADING_LANGUAGE_VERSION)
       }
     };
   }
@@ -4384,38 +4427,38 @@ var __exports__ = (() => {
   var EXT_TEXTURE_NORM16 = "EXT_texture_norm16";
   var EXT_FLOAT_WEBGL1 = "WEBGL_color_buffer_float";
   var EXT_FLOAT_RENDER_WEBGL2 = "EXT_color_buffer_float";
-  var checkExtension = (gl, extension) => gl.getExtension(extension);
-  var checkExtensions = (gl, extensions) => extensions.every((extension) => gl.getExtension(extension));
+  var checkExtension = (gl2, extension) => gl2.getExtension(extension);
+  var checkExtensions = (gl2, extensions) => extensions.every((extension) => gl2.getExtension(extension));
   var TEXTURE_FEATURE_CHECKS = {
-    "texture-blend-float-webgl1": (gl) => isWebGL2(gl) ? true : checkExtension(gl, "EXT_float_blend"),
-    "texture-formats-srgb-webgl1": (gl) => isWebGL2(gl) ? true : checkExtension(gl, EXT_SRGB),
-    "texture-formats-depth-webgl1": (gl) => isWebGL2(gl) ? true : checkExtension(gl, "WEBGL_depth_texture"),
-    "texture-formats-float32-webgl1": (gl) => isWebGL2(gl) ? true : checkExtension(gl, "OES_texture_float"),
-    "texture-formats-float16-webgl1": (gl) => isWebGL2(gl) ? true : checkExtension(gl, "OES_texture_half_float"),
-    "texture-formats-norm16-webgl": (gl) => isWebGL2(gl) ? checkExtension(gl, EXT_TEXTURE_NORM16) : false,
-    "texture-filter-linear-float32-webgl": (gl) => checkExtension(gl, "OES_texture_float_linear"),
-    "texture-filter-linear-float16-webgl": (gl) => checkExtension(gl, "OES_texture_half_float_linear"),
-    "texture-filter-anisotropic-webgl": (gl) => checkExtension(gl, "EXT_texture_filter_anisotropic"),
-    "texture-renderable-float32-webgl": (gl) => checkExtension(gl, "EXT_color_buffer_float"),
+    "texture-blend-float-webgl1": (gl2) => isWebGL2(gl2) ? true : checkExtension(gl2, "EXT_float_blend"),
+    "texture-formats-srgb-webgl1": (gl2) => isWebGL2(gl2) ? true : checkExtension(gl2, EXT_SRGB),
+    "texture-formats-depth-webgl1": (gl2) => isWebGL2(gl2) ? true : checkExtension(gl2, "WEBGL_depth_texture"),
+    "texture-formats-float32-webgl1": (gl2) => isWebGL2(gl2) ? true : checkExtension(gl2, "OES_texture_float"),
+    "texture-formats-float16-webgl1": (gl2) => isWebGL2(gl2) ? true : checkExtension(gl2, "OES_texture_half_float"),
+    "texture-formats-norm16-webgl": (gl2) => isWebGL2(gl2) ? checkExtension(gl2, EXT_TEXTURE_NORM16) : false,
+    "texture-filter-linear-float32-webgl": (gl2) => checkExtension(gl2, "OES_texture_float_linear"),
+    "texture-filter-linear-float16-webgl": (gl2) => checkExtension(gl2, "OES_texture_half_float_linear"),
+    "texture-filter-anisotropic-webgl": (gl2) => checkExtension(gl2, "EXT_texture_filter_anisotropic"),
+    "texture-renderable-float32-webgl": (gl2) => checkExtension(gl2, "EXT_color_buffer_float"),
     // [false, 'EXT_color_buffer_float'],
-    "texture-renderable-float16-webgl": (gl) => checkExtension(gl, "EXT_color_buffer_half_float"),
-    "texture-compression-bc": (gl) => checkExtensions(gl, [X_S3TC, X_S3TC_SRGB, X_RGTC, X_BPTC]),
-    "texture-compression-bc5-webgl": (gl) => checkExtensions(gl, [X_RGTC]),
+    "texture-renderable-float16-webgl": (gl2) => checkExtension(gl2, "EXT_color_buffer_half_float"),
+    "texture-compression-bc": (gl2) => checkExtensions(gl2, [X_S3TC, X_S3TC_SRGB, X_RGTC, X_BPTC]),
+    "texture-compression-bc5-webgl": (gl2) => checkExtensions(gl2, [X_RGTC]),
     // 'texture-compression-bc7-webgl': gl => checkExtensions(gl, [X_BPTC]),
     // 'texture-compression-bc3-srgb-webgl': gl => checkExtensions(gl, [X_S3TC_SRGB]),
     // 'texture-compression-bc3-webgl': gl => checkExtensions(gl, [X_S3TC]),
-    "texture-compression-etc2": (gl) => checkExtensions(gl, [X_ETC2]),
-    "texture-compression-astc": (gl) => checkExtensions(gl, [X_ASTC]),
-    "texture-compression-etc1-webgl": (gl) => checkExtensions(gl, [X_ETC1]),
-    "texture-compression-pvrtc-webgl": (gl) => checkExtensions(gl, [X_PVRTC]),
-    "texture-compression-atc-webgl": (gl) => checkExtensions(gl, [X_ATC])
+    "texture-compression-etc2": (gl2) => checkExtensions(gl2, [X_ETC2]),
+    "texture-compression-astc": (gl2) => checkExtensions(gl2, [X_ASTC]),
+    "texture-compression-etc1-webgl": (gl2) => checkExtensions(gl2, [X_ETC1]),
+    "texture-compression-pvrtc-webgl": (gl2) => checkExtensions(gl2, [X_PVRTC]),
+    "texture-compression-atc-webgl": (gl2) => checkExtensions(gl2, [X_ATC])
   };
-  function checkTextureFeature(gl, feature) {
-    return TEXTURE_FEATURE_CHECKS[feature]?.(gl) || false;
+  function checkTextureFeature(gl2, feature) {
+    return TEXTURE_FEATURE_CHECKS[feature]?.(gl2) || false;
   }
-  function getTextureFeatures(gl) {
+  function getTextureFeatures(gl2) {
     const textureFeatures = Object.keys(TEXTURE_FEATURE_CHECKS);
-    return textureFeatures.filter((feature) => checkTextureFeature(gl, feature));
+    return textureFeatures.filter((feature) => checkTextureFeature(gl2, feature));
   }
   var TEXTURE_FORMATS = {
     // Unsized formats that leave the precision up to the driver.
@@ -5155,23 +5198,23 @@ var __exports__ = (() => {
     [GL.BYTE]: 1,
     [GL.UNSIGNED_BYTE]: 1
   };
-  function isTextureFormatSupported(gl, formatOrGL) {
+  function isTextureFormatSupported(gl2, formatOrGL) {
     const format = convertGLToTextureFormat(formatOrGL);
     const info = TEXTURE_FORMATS[format];
     if (!info) {
       return false;
     }
-    if (isWebGL2(gl) ? info.gl === void 0 : info.gl1 === void 0) {
+    if (isWebGL2(gl2) ? info.gl === void 0 : info.gl1 === void 0) {
       return false;
     }
-    const extension = info.x || (isWebGL2(gl) ? info.gl2ext || info.gl1ext : info.gl1ext);
+    const extension = info.x || (isWebGL2(gl2) ? info.gl2ext || info.gl1ext : info.gl1ext);
     if (extension) {
-      return Boolean(gl.getExtension(extension));
+      return Boolean(gl2.getExtension(extension));
     }
     return true;
   }
-  function isRenderbufferFormatSupported(gl, format) {
-    return isTextureFormatSupported(gl, format) && TEXTURE_FORMATS[format]?.renderbuffer;
+  function isRenderbufferFormatSupported(gl2, format) {
+    return isTextureFormatSupported(gl2, format) && TEXTURE_FORMATS[format]?.renderbuffer;
   }
   function convertGLToTextureFormat(format) {
     if (typeof format === "string") {
@@ -5191,9 +5234,9 @@ var __exports__ = (() => {
     }
     return webglFormat;
   }
-  function isTextureFormatFilterable(gl, formatOrGL) {
+  function isTextureFormatFilterable(gl2, formatOrGL) {
     const format = convertGLToTextureFormat(formatOrGL);
-    if (!isTextureFormatSupported(gl, format)) {
+    if (!isTextureFormatSupported(gl2, format)) {
       return false;
     }
     try {
@@ -5205,16 +5248,16 @@ var __exports__ = (() => {
       return false;
     }
     if (format.endsWith("32float")) {
-      return Boolean(gl.getExtension("OES_texture_float_linear"));
+      return Boolean(gl2.getExtension("OES_texture_float_linear"));
     }
     if (format.endsWith("16float")) {
-      return Boolean(gl.getExtension("OES_texture_half_float_linear"));
+      return Boolean(gl2.getExtension("OES_texture_half_float_linear"));
     }
     return true;
   }
-  function isTextureFormatRenderable(gl, formatOrGL) {
+  function isTextureFormatRenderable(gl2, formatOrGL) {
     const format = convertGLToTextureFormat(formatOrGL);
-    if (!isTextureFormatSupported(gl, format)) {
+    if (!isTextureFormatSupported(gl2, format)) {
       return false;
     }
     if (typeof format === "number") {
@@ -5241,27 +5284,27 @@ var __exports__ = (() => {
     }
     return info.attachment;
   }
-  function _checkFloat32ColorAttachment(gl, internalFormat = gl.RGBA, srcFormat = GL.RGBA, srcType = GL.UNSIGNED_BYTE) {
+  function _checkFloat32ColorAttachment(gl2, internalFormat = gl2.RGBA, srcFormat = GL.RGBA, srcType = GL.UNSIGNED_BYTE) {
     let texture = null;
     let framebuffer = null;
     try {
-      texture = gl.createTexture();
-      gl.bindTexture(GL.TEXTURE_2D, texture);
+      texture = gl2.createTexture();
+      gl2.bindTexture(GL.TEXTURE_2D, texture);
       const level = 0;
       const width = 1;
       const height = 1;
       const border = 0;
       const pixel = new Uint8Array([0, 0, 255, 255]);
-      gl.texImage2D(gl.TEXTURE_2D, level, internalFormat, width, height, border, srcFormat, srcType, pixel);
-      framebuffer = gl.createFramebuffer();
-      gl.bindFramebuffer(GL.FRAMEBUFFER, framebuffer);
-      gl.framebufferTexture2D(GL.FRAMEBUFFER, GL.COLOR_ATTACHMENT0, GL.TEXTURE_2D, texture, 0);
-      const status = gl.checkFramebufferStatus(GL.FRAMEBUFFER) === GL.FRAMEBUFFER_COMPLETE;
-      gl.bindTexture(GL.TEXTURE_2D, null);
+      gl2.texImage2D(gl2.TEXTURE_2D, level, internalFormat, width, height, border, srcFormat, srcType, pixel);
+      framebuffer = gl2.createFramebuffer();
+      gl2.bindFramebuffer(GL.FRAMEBUFFER, framebuffer);
+      gl2.framebufferTexture2D(GL.FRAMEBUFFER, GL.COLOR_ATTACHMENT0, GL.TEXTURE_2D, texture, 0);
+      const status = gl2.checkFramebufferStatus(GL.FRAMEBUFFER) === GL.FRAMEBUFFER_COMPLETE;
+      gl2.bindTexture(GL.TEXTURE_2D, null);
       return status;
     } finally {
-      gl.deleteTexture(texture);
-      gl.deleteFramebuffer(framebuffer);
+      gl2.deleteTexture(texture);
+      gl2.deleteFramebuffer(framebuffer);
     }
   }
   function getTextureFormatBytesPerPixel(formatOrGL, isWebGL23) {
@@ -5312,52 +5355,52 @@ var __exports__ = (() => {
   }
 
   // src/adapter/device-helpers/device-features.ts
-  function getDeviceFeatures(gl) {
-    const features = getWebGLFeatures(gl);
-    for (const textureFeature of getTextureFeatures(gl)) {
+  function getDeviceFeatures(gl2) {
+    const features = getWebGLFeatures(gl2);
+    for (const textureFeature of getTextureFeatures(gl2)) {
       features.add(textureFeature);
     }
     return features;
   }
-  function getWebGLFeatures(gl) {
-    gl.getExtension("EXT_color_buffer_float");
-    gl.getExtension("WEBGL_color_buffer_float");
-    gl.getExtension("EXT_float_blend");
+  function getWebGLFeatures(gl2) {
+    gl2.getExtension("EXT_color_buffer_float");
+    gl2.getExtension("WEBGL_color_buffer_float");
+    gl2.getExtension("EXT_float_blend");
     const features = /* @__PURE__ */ new Set();
     for (const feature of Object.keys(WEBGL_FEATURES)) {
-      if (isFeatureSupported(gl, feature)) {
+      if (isFeatureSupported(gl2, feature)) {
         features.add(feature);
       }
     }
     return features;
   }
-  function isFeatureSupported(gl, feature) {
+  function isFeatureSupported(gl2, feature) {
     const featureInfo = WEBGL_FEATURES[feature];
     if (!featureInfo) {
       return false;
     }
     const [webgl1Feature, webgl2Feature] = featureInfo || [];
-    const featureDefinition = isWebGL2(gl) ? webgl2Feature : webgl1Feature;
+    const featureDefinition = isWebGL2(gl2) ? webgl2Feature : webgl1Feature;
     if (typeof featureDefinition === "boolean") {
       return featureDefinition;
     }
     switch (feature) {
       case "texture-renderable-rgba32float-webgl":
-        return isWebGL2(gl) ? Boolean(gl.getExtension(featureDefinition)) : _checkFloat32ColorAttachment(gl);
+        return isWebGL2(gl2) ? Boolean(gl2.getExtension(featureDefinition)) : _checkFloat32ColorAttachment(gl2);
       case "glsl-derivatives":
-        return canCompileGLSLExtension(gl, featureDefinition);
+        return canCompileGLSLExtension(gl2, featureDefinition);
       case "glsl-frag-data":
-        return canCompileGLSLExtension(gl, featureDefinition, {
+        return canCompileGLSLExtension(gl2, featureDefinition, {
           behavior: "require"
         });
       case "glsl-frag-depth":
-        return canCompileGLSLExtension(gl, featureDefinition);
+        return canCompileGLSLExtension(gl2, featureDefinition);
       default:
-        return Boolean(gl.getExtension(featureDefinition));
+        return Boolean(gl2.getExtension(featureDefinition));
     }
   }
   var compiledGLSLExtensions = {};
-  function canCompileGLSLExtension(gl, extensionName, opts = {}) {
+  function canCompileGLSLExtension(gl2, extensionName, opts = {}) {
     if (!isOldIE(opts)) {
       return true;
     }
@@ -5367,14 +5410,14 @@ var __exports__ = (() => {
     const behavior = opts.behavior || "enable";
     const source = `#extension GL_${extensionName} : ${behavior}
 void main(void) {}`;
-    const shader = gl.createShader(gl.VERTEX_SHADER);
+    const shader = gl2.createShader(gl2.VERTEX_SHADER);
     if (!shader) {
       throw new Error("shader");
     }
-    gl.shaderSource(shader, source);
-    gl.compileShader(shader);
-    const canCompile = gl.getShaderParameter(shader, gl.COMPILE_STATUS);
-    gl.deleteShader(shader);
+    gl2.shaderSource(shader, source);
+    gl2.compileShader(shader);
+    const canCompile = gl2.getShaderParameter(shader, gl2.COMPILE_STATUS);
+    gl2.deleteShader(shader);
     compiledGLSLExtensions[extensionName] = canCompile;
     return canCompile;
   }
@@ -5411,38 +5454,38 @@ void main(void) {}`;
   };
 
   // src/adapter/device-helpers/device-limits.ts
-  function getDeviceLimits(gl) {
-    const gl2 = getWebGL2Context(gl);
+  function getDeviceLimits(gl2) {
+    const gl22 = getWebGL2Context(gl2);
     return {
       maxTextureDimension1D: 0,
       // WebGL does not support 1D textures
-      maxTextureDimension2D: gl.getParameter(GL.MAX_TEXTURE_SIZE),
-      maxTextureDimension3D: gl2 ? gl2.getParameter(GL.MAX_3D_TEXTURE_SIZE) : 0,
-      maxTextureArrayLayers: gl2 ? gl2.getParameter(GL.MAX_ARRAY_TEXTURE_LAYERS) : 0,
+      maxTextureDimension2D: gl2.getParameter(GL.MAX_TEXTURE_SIZE),
+      maxTextureDimension3D: gl22 ? gl22.getParameter(GL.MAX_3D_TEXTURE_SIZE) : 0,
+      maxTextureArrayLayers: gl22 ? gl22.getParameter(GL.MAX_ARRAY_TEXTURE_LAYERS) : 0,
       maxBindGroups: 1,
       // TBD
       maxDynamicUniformBuffersPerPipelineLayout: 0,
       // TBD
       maxDynamicStorageBuffersPerPipelineLayout: 0,
       // TBD
-      maxSampledTexturesPerShaderStage: gl.getParameter(GL.MAX_VERTEX_TEXTURE_IMAGE_UNITS),
+      maxSampledTexturesPerShaderStage: gl2.getParameter(GL.MAX_VERTEX_TEXTURE_IMAGE_UNITS),
       // TBD
-      maxSamplersPerShaderStage: gl.getParameter(GL.MAX_COMBINED_TEXTURE_IMAGE_UNITS),
+      maxSamplersPerShaderStage: gl2.getParameter(GL.MAX_COMBINED_TEXTURE_IMAGE_UNITS),
       maxStorageBuffersPerShaderStage: 0,
       // TBD
       maxStorageTexturesPerShaderStage: 0,
       // TBD
-      maxUniformBuffersPerShaderStage: gl2 ? gl2.getParameter(GL.MAX_UNIFORM_BUFFER_BINDINGS) : 0,
-      maxUniformBufferBindingSize: gl2 ? gl2.getParameter(GL.MAX_UNIFORM_BLOCK_SIZE) : 0,
+      maxUniformBuffersPerShaderStage: gl22 ? gl22.getParameter(GL.MAX_UNIFORM_BUFFER_BINDINGS) : 0,
+      maxUniformBufferBindingSize: gl22 ? gl22.getParameter(GL.MAX_UNIFORM_BLOCK_SIZE) : 0,
       maxStorageBufferBindingSize: 0,
-      minUniformBufferOffsetAlignment: gl2 ? gl2.getParameter(GL.UNIFORM_BUFFER_OFFSET_ALIGNMENT) : 0,
+      minUniformBufferOffsetAlignment: gl22 ? gl22.getParameter(GL.UNIFORM_BUFFER_OFFSET_ALIGNMENT) : 0,
       minStorageBufferOffsetAlignment: 0,
       // TBD
       maxVertexBuffers: 0,
-      maxVertexAttributes: gl.getParameter(GL.MAX_VERTEX_ATTRIBS),
+      maxVertexAttributes: gl2.getParameter(GL.MAX_VERTEX_ATTRIBS),
       maxVertexBufferArrayStride: 2048,
       // TBD, this is just the default value from WebGPU
-      maxInterStageShaderComponents: gl2 ? gl2.getParameter(GL.MAX_VARYING_COMPONENTS) : 0,
+      maxInterStageShaderComponents: gl22 ? gl22.getParameter(GL.MAX_VARYING_COMPONENTS) : 0,
       maxComputeWorkgroupStorageSize: 0,
       // WebGL does not support compute shaders
       maxComputeInvocationsPerWorkgroup: 0,
@@ -5457,13 +5500,13 @@ void main(void) {}`;
       // WebGL does not support compute shaders
     };
   }
-  function getWebGLLimits(gl) {
-    const gl2 = getWebGL2Context(gl);
+  function getWebGLLimits(gl2) {
+    const gl22 = getWebGL2Context(gl2);
     function get(pname) {
-      return gl.getParameter(pname);
+      return gl2.getParameter(pname);
     }
     function get2(pname, defaultValue) {
-      return gl2 ? gl2.getParameter(pname) : defaultValue || 0;
+      return gl22 ? gl22.getParameter(pname) : defaultValue || 0;
     }
     return {
       [GL.ALIASED_LINE_WIDTH_RANGE]: get(GL.ALIASED_LINE_WIDTH_RANGE),
@@ -5556,24 +5599,24 @@ void main(void) {}`;
   // src/context/state-tracker/with-parameters.ts
   function withParameters(device, parameters, func) {
     const webglDevice = WebGLDevice.attach(device);
-    const gl = webglDevice.gl;
+    const gl2 = webglDevice.gl;
     if (isObjectEmpty3(parameters)) {
       return func(device);
     }
     const {
       nocatch = true
     } = parameters;
-    pushContextState(gl);
-    setParameters(gl, parameters);
+    pushContextState(gl2);
+    setParameters(gl2, parameters);
     let value;
     if (nocatch) {
-      value = func(gl);
-      popContextState(gl);
+      value = func(gl2);
+      popContextState(gl2);
     } else {
       try {
-        value = func(gl);
+        value = func(gl2);
       } finally {
-        popContextState(gl);
+        popContextState(gl2);
       }
     }
     return value;
@@ -5613,43 +5656,43 @@ void main(void) {}`;
   function setDeviceParameters(device, parameters) {
     const webglDevice = WebGLDevice.attach(device);
     const {
-      gl
+      gl: gl2
     } = webglDevice;
     if (parameters.cullMode) {
       switch (parameters.cullMode) {
         case "none":
-          gl.disable(GL.CULL_FACE);
+          gl2.disable(GL.CULL_FACE);
           break;
         case "front":
-          gl.enable(GL.CULL_FACE);
-          gl.cullFace(GL.FRONT);
+          gl2.enable(GL.CULL_FACE);
+          gl2.cullFace(GL.FRONT);
           break;
         case "back":
-          gl.enable(GL.CULL_FACE);
-          gl.cullFace(GL.BACK);
+          gl2.enable(GL.CULL_FACE);
+          gl2.cullFace(GL.BACK);
           break;
       }
     }
     if (parameters.frontFace) {
-      gl.frontFace(map("frontFace", parameters.frontFace, {
+      gl2.frontFace(map("frontFace", parameters.frontFace, {
         ccw: GL.CCW,
         cw: GL.CW
       }));
     }
     if (parameters.depthBias !== void 0) {
-      gl.polygonOffset(parameters.depthBias, parameters.depthBiasSlopeScale || 0);
+      gl2.polygonOffset(parameters.depthBias, parameters.depthBiasSlopeScale || 0);
     }
     if (parameters.depthWriteEnabled !== void 0) {
-      gl.depthMask(mapBoolean("depthWriteEnabled", parameters.depthWriteEnabled));
+      gl2.depthMask(mapBoolean("depthWriteEnabled", parameters.depthWriteEnabled));
     }
     if (parameters.depthCompare) {
-      parameters.depthCompare !== "always" ? gl.enable(GL.DEPTH_TEST) : gl.disable(GL.DEPTH_TEST);
-      gl.depthFunc(convertCompareFunction("depthCompare", parameters.depthCompare));
+      parameters.depthCompare !== "always" ? gl2.enable(GL.DEPTH_TEST) : gl2.disable(GL.DEPTH_TEST);
+      gl2.depthFunc(convertCompareFunction("depthCompare", parameters.depthCompare));
     }
     if (parameters.stencilWriteMask) {
       const mask = parameters.stencilWriteMask;
-      gl.stencilMaskSeparate(GL.FRONT, mask);
-      gl.stencilMaskSeparate(GL.BACK, mask);
+      gl2.stencilMaskSeparate(GL.FRONT, mask);
+      gl2.stencilMaskSeparate(GL.BACK, mask);
     }
     if (parameters.stencilReadMask) {
       log.warn("stencilReadMask not supported under WebGL");
@@ -5657,16 +5700,16 @@ void main(void) {}`;
     if (parameters.stencilCompare) {
       const mask = parameters.stencilReadMask || 4294967295;
       const glValue = convertCompareFunction("depthCompare", parameters.stencilCompare);
-      parameters.stencilCompare !== "always" ? gl.enable(GL.STENCIL_TEST) : gl.disable(GL.STENCIL_TEST);
-      gl.stencilFuncSeparate(GL.FRONT, glValue, 0, mask);
-      gl.stencilFuncSeparate(GL.BACK, glValue, 0, mask);
+      parameters.stencilCompare !== "always" ? gl2.enable(GL.STENCIL_TEST) : gl2.disable(GL.STENCIL_TEST);
+      gl2.stencilFuncSeparate(GL.FRONT, glValue, 0, mask);
+      gl2.stencilFuncSeparate(GL.BACK, glValue, 0, mask);
     }
     if (parameters.stencilPassOperation && parameters.stencilFailOperation && parameters.stencilDepthFailOperation) {
       const dppass = convertStencilOperation("stencilPassOperation", parameters.stencilPassOperation);
       const sfail = convertStencilOperation("stencilFailOperation", parameters.stencilFailOperation);
       const dpfail = convertStencilOperation("stencilDepthFailOperation", parameters.stencilDepthFailOperation);
-      gl.stencilOpSeparate(GL.FRONT, sfail, dpfail, dppass);
-      gl.stencilOpSeparate(GL.BACK, sfail, dpfail, dppass);
+      gl2.stencilOpSeparate(GL.FRONT, sfail, dpfail, dppass);
+      gl2.stencilOpSeparate(GL.BACK, sfail, dpfail, dppass);
     }
   }
   function convertCompareFunction(parameter, value) {
@@ -6259,9 +6302,9 @@ void main(void) {}`;
         height
       }));
       const {
-        gl
+        gl: gl2
       } = this;
-      gl.bindTexture(this.target, this.handle);
+      gl2.bindTexture(this.target, this.handle);
       let dataType = null;
       ({
         data,
@@ -6270,14 +6313,14 @@ void main(void) {}`;
         data,
         compressed
       }));
-      let gl2;
+      let gl22;
       withParameters(this.gl, parameters, () => {
         switch (dataType) {
           case "null":
-            gl.texImage2D(target, level, glFormat, width, height, 0, dataFormat, type, data);
+            gl2.texImage2D(target, level, glFormat, width, height, 0, dataFormat, type, data);
             break;
           case "typed-array":
-            gl.texImage2D(
+            gl2.texImage2D(
               target,
               level,
               glFormat,
@@ -6293,21 +6336,21 @@ void main(void) {}`;
             );
             break;
           case "buffer":
-            gl2 = this.device.assertWebGL2();
-            gl2.bindBuffer(GL.PIXEL_UNPACK_BUFFER, data.handle || data);
-            gl2.texImage2D(target, level, glFormat, width, height, 0, dataFormat, type, offset);
-            gl2.bindBuffer(GL.PIXEL_UNPACK_BUFFER, null);
+            gl22 = this.device.assertWebGL2();
+            gl22.bindBuffer(GL.PIXEL_UNPACK_BUFFER, data.handle || data);
+            gl22.texImage2D(target, level, glFormat, width, height, 0, dataFormat, type, offset);
+            gl22.bindBuffer(GL.PIXEL_UNPACK_BUFFER, null);
             break;
           case "browser-object":
             if (this.device.isWebGL2) {
-              gl.texImage2D(target, level, glFormat, width, height, 0, dataFormat, type, data);
+              gl2.texImage2D(target, level, glFormat, width, height, 0, dataFormat, type, data);
             } else {
-              gl.texImage2D(target, level, glFormat, dataFormat, type, data);
+              gl2.texImage2D(target, level, glFormat, dataFormat, type, data);
             }
             break;
           case "compressed":
             for (const [levelIndex, levelData] of data.entries()) {
-              gl.compressedTexImage2D(target, levelIndex, levelData.format, levelData.width, levelData.height, 0, levelData.data);
+              gl2.compressedTexImage2D(target, levelIndex, levelData.format, levelData.width, levelData.height, 0, levelData.data);
             }
             break;
           default:
@@ -6411,24 +6454,24 @@ void main(void) {}`;
     }
     bind(textureUnit = this.textureUnit) {
       const {
-        gl
+        gl: gl2
       } = this;
       if (textureUnit !== void 0) {
         this.textureUnit = textureUnit;
-        gl.activeTexture(gl.TEXTURE0 + textureUnit);
+        gl2.activeTexture(gl2.TEXTURE0 + textureUnit);
       }
-      gl.bindTexture(this.target, this.handle);
+      gl2.bindTexture(this.target, this.handle);
       return textureUnit;
     }
     unbind(textureUnit = this.textureUnit) {
       const {
-        gl
+        gl: gl2
       } = this;
       if (textureUnit !== void 0) {
         this.textureUnit = textureUnit;
-        gl.activeTexture(gl.TEXTURE0 + textureUnit);
+        gl2.activeTexture(gl2.TEXTURE0 + textureUnit);
       }
-      gl.bindTexture(this.target, null);
+      gl2.bindTexture(this.target, null);
       return textureUnit;
     }
     // PRIVATE METHODS
@@ -6550,7 +6593,7 @@ void main(void) {}`;
     /* eslint-disable max-statements, max-len */
     async setCubeMapImageData(options) {
       const {
-        gl
+        gl: gl2
       } = this;
       const {
         width,
@@ -6572,9 +6615,9 @@ void main(void) {}`;
         }
         resolvedFaces[index].forEach((image, lodLevel) => {
           if (width && height) {
-            gl.texImage2D(face, lodLevel, format, width, height, 0, format, type, image);
+            gl2.texImage2D(face, lodLevel, format, width, height, 0, format, type, image);
           } else {
-            gl.texImage2D(face, lodLevel, format, format, type, image);
+            gl2.texImage2D(face, lodLevel, format, format, type, image);
           }
         });
       });
@@ -6593,7 +6636,7 @@ void main(void) {}`;
         // generateMipmap = false // TODO
       } = options;
       const {
-        gl
+        gl: gl2
       } = this;
       const imageData = pixels || data;
       this.bind();
@@ -6604,9 +6647,9 @@ void main(void) {}`;
           pixels: resolvedImageData
         })));
       } else if (this.width || this.height) {
-        gl.texImage2D(face, 0, format, width, height, 0, format, type, imageData);
+        gl2.texImage2D(face, 0, format, width, height, 0, format, type, imageData);
       } else {
-        gl.texImage2D(face, 0, format, format, type, imageData);
+        gl2.texImage2D(face, 0, format, format, type, imageData);
       }
       return this;
     }
@@ -6738,7 +6781,7 @@ void main(void) {}`;
   }
 
   // src/adapter/objects/constants-to-keys.ts
-  function getKeyValue(gl, name) {
+  function getKeyValue(gl2, name) {
     if (typeof name !== "string") {
       return name;
     }
@@ -6747,7 +6790,7 @@ void main(void) {}`;
       return number;
     }
     name = name.replace(/^.*\./, "");
-    const value = gl[name];
+    const value = gl2[name];
     assert2(value !== void 0, `Accessing undefined constant GL.${name}`);
     return value;
   }
@@ -6761,13 +6804,13 @@ void main(void) {}`;
     constructor(device, props, defaultProps) {
       super(device, props, defaultProps);
       this.device = WebGLDevice.attach(device);
-      const gl = this.device.gl;
-      assertWebGLContext(gl);
+      const gl2 = this.device.gl;
+      assertWebGLContext(gl2);
       const {
         id
       } = props || {};
-      this.gl = gl;
-      this.gl2 = gl;
+      this.gl = gl2;
+      this.gl2 = gl2;
       this.id = id || uid(this.constructor.name);
       this._handle = props?.handle;
       if (this._handle === void 0) {
@@ -7085,12 +7128,12 @@ void main(void) {}`;
     /** Check the status */
     _checkStatus() {
       const {
-        gl
+        gl: gl2
       } = this;
-      const prevHandle2 = gl.bindFramebuffer(GL.FRAMEBUFFER, this.handle);
-      const status = gl.checkFramebufferStatus(GL.FRAMEBUFFER);
-      gl.bindFramebuffer(GL.FRAMEBUFFER, prevHandle2 || null);
-      if (status !== gl.FRAMEBUFFER_COMPLETE) {
+      const prevHandle2 = gl2.bindFramebuffer(GL.FRAMEBUFFER, this.handle);
+      const status = gl2.checkFramebufferStatus(GL.FRAMEBUFFER);
+      gl2.bindFramebuffer(GL.FRAMEBUFFER, prevHandle2 || null);
+      if (status !== gl2.FRAMEBUFFER_COMPLETE) {
         throw new Error(`Framebuffer ${_getFrameBufferStatus(status)}`);
       }
     }
@@ -7161,27 +7204,27 @@ void main(void) {}`;
      */
     _attachTexture(attachment, texture, layer, level) {
       const {
-        gl,
-        gl2
+        gl: gl2,
+        gl2: gl22
       } = this.device;
-      gl.bindTexture(texture.target, texture.handle);
+      gl2.bindTexture(texture.target, texture.handle);
       switch (texture.target) {
         case GL.TEXTURE_2D_ARRAY:
         case GL.TEXTURE_3D:
           this.device.assertWebGL2();
-          gl2?.framebufferTextureLayer(GL.FRAMEBUFFER, attachment, texture.target, level, layer);
+          gl22?.framebufferTextureLayer(GL.FRAMEBUFFER, attachment, texture.target, level, layer);
           break;
         case GL.TEXTURE_CUBE_MAP:
           const face = mapIndexToCubeMapFace(layer);
-          gl.framebufferTexture2D(GL.FRAMEBUFFER, attachment, face, texture.handle, level);
+          gl2.framebufferTexture2D(GL.FRAMEBUFFER, attachment, face, texture.handle, level);
           break;
         case GL.TEXTURE_2D:
-          gl.framebufferTexture2D(GL.FRAMEBUFFER, attachment, GL.TEXTURE_2D, texture.handle, level);
+          gl2.framebufferTexture2D(GL.FRAMEBUFFER, attachment, GL.TEXTURE_2D, texture.handle, level);
           break;
         default:
           assert2(false, "Illegal texture type");
       }
-      gl.bindTexture(texture.target, null);
+      gl2.bindTexture(texture.target, null);
     }
   };
   function mapIndexToCubeMapFace(layer) {
@@ -7245,6 +7288,7 @@ void main(void) {}`;
      */
     resize(options) {
       if (this.canvas) {
+        const devicePixelRatio = this.getDevicePixelRatio(options?.useDevicePixels);
         this.setDevicePixelRatio(devicePixelRatio, options);
         return;
       }
@@ -7318,9 +7362,9 @@ void main(void) {}`;
 
   // src/context/debug/webgl-developer-tools.ts
   var WEBGL_DEBUG_CDN_URL = "https://unpkg.com/webgl-debug@2.0.1/index.js";
-  function getContextData2(gl) {
-    gl.luma = gl.luma || {};
-    return gl.luma;
+  function getContextData2(gl2) {
+    gl2.luma = gl2.luma || {};
+    return gl2.luma;
   }
   async function loadWebGLDeveloperTools() {
     if (!globalThis.WebGLDebugUtils) {
@@ -7329,30 +7373,30 @@ void main(void) {}`;
       await loadScript(WEBGL_DEBUG_CDN_URL);
     }
   }
-  function makeDebugContext(gl, props = {}) {
-    if (!gl) {
+  function makeDebugContext(gl2, props = {}) {
+    if (!gl2) {
       return null;
     }
-    return props.debug ? getDebugContext(gl, props) : getRealContext(gl);
+    return props.debug ? getDebugContext(gl2, props) : getRealContext(gl2);
   }
-  function getRealContext(gl) {
-    const data = getContextData2(gl);
-    return data.realContext ? data.realContext : gl;
+  function getRealContext(gl2) {
+    const data = getContextData2(gl2);
+    return data.realContext ? data.realContext : gl2;
   }
-  function getDebugContext(gl, props) {
+  function getDebugContext(gl2, props) {
     if (!globalThis.WebGLDebugUtils) {
       log.warn("webgl-debug not loaded")();
-      return gl;
+      return gl2;
     }
-    const data = getContextData2(gl);
+    const data = getContextData2(gl2);
     if (data.debugContext) {
       return data.debugContext;
     }
     globalThis.WebGLDebugUtils.init({
       ...GL,
-      ...gl
+      ...gl2
     });
-    const glDebug = globalThis.WebGLDebugUtils.makeDebugContext(gl, onGLError.bind(null, props), onValidateGLFunc.bind(null, props));
+    const glDebug = globalThis.WebGLDebugUtils.makeDebugContext(gl2, onGLError.bind(null, props), onValidateGLFunc.bind(null, props));
     for (const key in GL) {
       if (!(key in glDebug) && typeof GL[key] === "number") {
         glDebug[key] = GL[key];
@@ -7360,10 +7404,10 @@ void main(void) {}`;
     }
     class WebGLDebugContext {
     }
-    Object.setPrototypeOf(glDebug, Object.getPrototypeOf(gl));
+    Object.setPrototypeOf(glDebug, Object.getPrototypeOf(gl2));
     Object.setPrototypeOf(WebGLDebugContext, glDebug);
     const debugContext = Object.create(WebGLDebugContext);
-    data.realContext = gl;
+    data.realContext = gl2;
     data.debugContext = debugContext;
     debugContext.debug = true;
     return debugContext;
@@ -7750,15 +7794,15 @@ void main(void) {}`;
         size
       } = options;
       const {
-        gl,
-        gl2
+        gl: gl2,
+        gl2: gl22
       } = this;
-      assertWebGL2Context(gl);
-      gl.bindBuffer(GL.COPY_READ_BUFFER, sourceBuffer.handle);
-      gl.bindBuffer(GL.COPY_WRITE_BUFFER, this.handle);
-      gl2?.copyBufferSubData(GL.COPY_READ_BUFFER, GL.COPY_WRITE_BUFFER, readOffset, writeOffset, size);
-      gl.bindBuffer(GL.COPY_READ_BUFFER, null);
-      gl.bindBuffer(GL.COPY_WRITE_BUFFER, null);
+      assertWebGL2Context(gl2);
+      gl2.bindBuffer(GL.COPY_READ_BUFFER, sourceBuffer.handle);
+      gl2.bindBuffer(GL.COPY_WRITE_BUFFER, this.handle);
+      gl22?.copyBufferSubData(GL.COPY_READ_BUFFER, GL.COPY_WRITE_BUFFER, readOffset, writeOffset, size);
+      gl2.bindBuffer(GL.COPY_READ_BUFFER, null);
+      gl2.bindBuffer(GL.COPY_WRITE_BUFFER, null);
       this.debugData = null;
       return this;
     }
@@ -8029,13 +8073,13 @@ void main(void) {}`;
 ${source2}`;
       source = addGLSLVersion(source);
       const {
-        gl
+        gl: gl2
       } = this.device;
-      gl.shaderSource(this.handle, source);
-      gl.compileShader(this.handle);
-      const compileStatus = gl.getShaderParameter(this.handle, GL.COMPILE_STATUS);
+      gl2.shaderSource(this.handle, source);
+      gl2.compileShader(this.handle);
+      const compileStatus = gl2.getShaderParameter(this.handle, GL.COMPILE_STATUS);
       if (!compileStatus) {
-        const shaderLog = gl.getShaderInfoLog(this.handle);
+        const shaderLog = gl2.getShaderInfoLog(this.handle);
         const parsedLog = shaderLog ? parseShaderCompilerLog(shaderLog) : [];
         const messages = parsedLog.filter((message2) => message2.type === "error");
         const formattedLog = formatCompilerLog(messages, source);
@@ -8270,8 +8314,8 @@ ${formattedLog}`)();
   }
 
   // src/adapter/helpers/get-shader-layout.ts
-  function getShaderLayout(gl, program) {
-    const programBindings = getProgramBindings(gl, program);
+  function getShaderLayout(gl2, program) {
+    const programBindings = getProgramBindings(gl2, program);
     const shaderLayout = {
       attributes: [],
       bindings: []
@@ -8333,21 +8377,21 @@ ${formattedLog}`)();
     }
     return shaderLayout;
   }
-  function getProgramBindings(gl, program) {
+  function getProgramBindings(gl2, program) {
     const config = {
-      attributes: readAttributeBindings(gl, program),
-      uniforms: readUniformBindings(gl, program),
-      uniformBlocks: readUniformBlocks(gl, program),
-      varyings: readVaryings(gl, program)
+      attributes: readAttributeBindings(gl2, program),
+      uniforms: readUniformBindings(gl2, program),
+      uniformBlocks: readUniformBlocks(gl2, program),
+      varyings: readVaryings(gl2, program)
     };
     Object.seal(config);
     return config;
   }
-  function readAttributeBindings(gl, program) {
+  function readAttributeBindings(gl2, program) {
     const attributes = [];
-    const count = gl.getProgramParameter(program, gl.ACTIVE_ATTRIBUTES);
+    const count = gl2.getProgramParameter(program, gl2.ACTIVE_ATTRIBUTES);
     for (let index = 0; index < count; index++) {
-      const activeInfo = gl.getActiveAttrib(program, index);
+      const activeInfo = gl2.getActiveAttrib(program, index);
       if (!activeInfo) {
         throw new Error("activeInfo");
       }
@@ -8356,7 +8400,7 @@ ${formattedLog}`)();
         type: compositeType,
         size
       } = activeInfo;
-      const location = gl.getAttribLocation(program, name);
+      const location = gl2.getAttribLocation(program, name);
       if (location >= 0) {
         const {
           glType,
@@ -8380,15 +8424,15 @@ ${formattedLog}`)();
     attributes.sort((a, b) => a.location - b.location);
     return attributes;
   }
-  function readVaryings(gl, program) {
-    if (!isWebGL2(gl)) {
+  function readVaryings(gl2, program) {
+    if (!isWebGL2(gl2)) {
       return [];
     }
-    const gl2 = gl;
+    const gl22 = gl2;
     const varyings = [];
-    const count = gl.getProgramParameter(program, GL.TRANSFORM_FEEDBACK_VARYINGS);
+    const count = gl2.getProgramParameter(program, GL.TRANSFORM_FEEDBACK_VARYINGS);
     for (let location = 0; location < count; location++) {
-      const activeInfo = gl2.getTransformFeedbackVarying(program, location);
+      const activeInfo = gl22.getTransformFeedbackVarying(program, location);
       if (!activeInfo) {
         throw new Error("activeInfo");
       }
@@ -8415,11 +8459,11 @@ ${formattedLog}`)();
     varyings.sort((a, b) => a.location - b.location);
     return varyings;
   }
-  function readUniformBindings(gl, program) {
+  function readUniformBindings(gl2, program) {
     const uniforms = [];
-    const uniformCount = gl.getProgramParameter(program, GL.ACTIVE_UNIFORMS);
+    const uniformCount = gl2.getProgramParameter(program, GL.ACTIVE_UNIFORMS);
     for (let i = 0; i < uniformCount; i++) {
-      const activeInfo = gl.getActiveUniform(program, i);
+      const activeInfo = gl2.getActiveUniform(program, i);
       if (!activeInfo) {
         throw new Error("activeInfo");
       }
@@ -8432,7 +8476,7 @@ ${formattedLog}`)();
         name,
         isArray: isArray2
       } = parseUniformName(rawName);
-      let webglLocation = gl.getUniformLocation(program, name);
+      let webglLocation = gl2.getUniformLocation(program, name);
       const uniformInfo = {
         // WebGL locations are uniquely typed but just numbers
         location: webglLocation,
@@ -8445,7 +8489,7 @@ ${formattedLog}`)();
       if (uniformInfo.size > 1) {
         for (let j = 0; j < uniformInfo.size; j++) {
           const elementName = `${name}[${j}]`;
-          webglLocation = gl.getUniformLocation(program, elementName);
+          webglLocation = gl2.getUniformLocation(program, elementName);
           const arrayElementUniformInfo = {
             ...uniformInfo,
             name: elementName,
@@ -8457,17 +8501,17 @@ ${formattedLog}`)();
     }
     return uniforms;
   }
-  function readUniformBlocks(gl, program) {
-    if (!isWebGL2(gl)) {
+  function readUniformBlocks(gl2, program) {
+    if (!isWebGL2(gl2)) {
       return [];
     }
-    const gl2 = gl;
-    const getBlockParameter = (blockIndex, pname) => gl2.getActiveUniformBlockParameter(program, blockIndex, pname);
+    const gl22 = gl2;
+    const getBlockParameter = (blockIndex, pname) => gl22.getActiveUniformBlockParameter(program, blockIndex, pname);
     const uniformBlocks = [];
-    const blockCount = gl2.getProgramParameter(program, GL.ACTIVE_UNIFORM_BLOCKS);
+    const blockCount = gl22.getProgramParameter(program, GL.ACTIVE_UNIFORM_BLOCKS);
     for (let blockIndex = 0; blockIndex < blockCount; blockIndex++) {
       const blockInfo = {
-        name: gl2.getActiveUniformBlockName(program, blockIndex) || "",
+        name: gl22.getActiveUniformBlockName(program, blockIndex) || "",
         location: getBlockParameter(blockIndex, GL.UNIFORM_BLOCK_BINDING),
         byteLength: getBlockParameter(blockIndex, GL.UNIFORM_BLOCK_DATA_SIZE),
         vertex: getBlockParameter(blockIndex, GL.UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER),
@@ -8476,12 +8520,12 @@ ${formattedLog}`)();
         uniforms: []
       };
       const uniformIndices = getBlockParameter(blockIndex, GL.UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES) || [];
-      const uniformType = gl2.getActiveUniforms(program, uniformIndices, GL.UNIFORM_TYPE);
-      const uniformArrayLength = gl2.getActiveUniforms(program, uniformIndices, GL.UNIFORM_SIZE);
-      const uniformOffset = gl2.getActiveUniforms(program, uniformIndices, GL.UNIFORM_OFFSET);
-      const uniformStride = gl2.getActiveUniforms(program, uniformIndices, GL.UNIFORM_ARRAY_STRIDE);
+      const uniformType = gl22.getActiveUniforms(program, uniformIndices, GL.UNIFORM_TYPE);
+      const uniformArrayLength = gl22.getActiveUniforms(program, uniformIndices, GL.UNIFORM_SIZE);
+      const uniformOffset = gl22.getActiveUniforms(program, uniformIndices, GL.UNIFORM_OFFSET);
+      const uniformStride = gl22.getActiveUniforms(program, uniformIndices, GL.UNIFORM_ARRAY_STRIDE);
       for (let i = 0; i < blockInfo.uniformCount; ++i) {
-        const activeInfo = gl2.getActiveUniform(program, uniformIndices[i]);
+        const activeInfo = gl22.getActiveUniform(program, uniformIndices[i]);
         if (!activeInfo) {
           throw new Error("activeInfo");
         }
@@ -8550,8 +8594,8 @@ ${formattedLog}`)();
   }
 
   // src/adapter/helpers/set-uniform.ts
-  function setUniform(gl, location, type, value) {
-    const gl2 = gl;
+  function setUniform(gl2, location, type, value) {
+    const gl22 = gl2;
     if (typeof value === "number") {
       switch (type) {
         case GL.SAMPLER_2D:
@@ -8569,7 +8613,7 @@ ${formattedLog}`)();
         case GL.UNSIGNED_INT_SAMPLER_3D:
         case GL.UNSIGNED_INT_SAMPLER_CUBE:
         case GL.UNSIGNED_INT_SAMPLER_2D_ARRAY:
-          return gl.uniform1i(location, value);
+          return gl2.uniform1i(location, value);
       }
     }
     if (value === true) {
@@ -8581,55 +8625,55 @@ ${formattedLog}`)();
     const arrayValue = typeof value === "number" ? [value] : value;
     switch (type) {
       case GL.FLOAT:
-        return gl.uniform1fv(location, arrayValue);
+        return gl2.uniform1fv(location, arrayValue);
       case GL.FLOAT_VEC2:
-        return gl.uniform2fv(location, arrayValue);
+        return gl2.uniform2fv(location, arrayValue);
       case GL.FLOAT_VEC3:
-        return gl.uniform3fv(location, arrayValue);
+        return gl2.uniform3fv(location, arrayValue);
       case GL.FLOAT_VEC4:
-        return gl.uniform4fv(location, arrayValue);
+        return gl2.uniform4fv(location, arrayValue);
       case GL.INT:
-        return gl.uniform1iv(location, arrayValue);
+        return gl2.uniform1iv(location, arrayValue);
       case GL.INT_VEC2:
-        return gl.uniform2iv(location, arrayValue);
+        return gl2.uniform2iv(location, arrayValue);
       case GL.INT_VEC3:
-        return gl.uniform3iv(location, arrayValue);
+        return gl2.uniform3iv(location, arrayValue);
       case GL.INT_VEC4:
-        return gl.uniform4iv(location, arrayValue);
+        return gl2.uniform4iv(location, arrayValue);
       case GL.BOOL:
-        return gl.uniform1iv(location, arrayValue);
+        return gl2.uniform1iv(location, arrayValue);
       case GL.BOOL_VEC2:
-        return gl.uniform2iv(location, arrayValue);
+        return gl2.uniform2iv(location, arrayValue);
       case GL.BOOL_VEC3:
-        return gl.uniform3iv(location, arrayValue);
+        return gl2.uniform3iv(location, arrayValue);
       case GL.BOOL_VEC4:
-        return gl.uniform4iv(location, arrayValue);
+        return gl2.uniform4iv(location, arrayValue);
       case GL.UNSIGNED_INT:
-        return gl2.uniform1uiv(location, arrayValue, 1);
+        return gl22.uniform1uiv(location, arrayValue, 1);
       case GL.UNSIGNED_INT_VEC2:
-        return gl2.uniform2uiv(location, arrayValue, 2);
+        return gl22.uniform2uiv(location, arrayValue, 2);
       case GL.UNSIGNED_INT_VEC3:
-        return gl2.uniform3uiv(location, arrayValue, 3);
+        return gl22.uniform3uiv(location, arrayValue, 3);
       case GL.UNSIGNED_INT_VEC4:
-        return gl2.uniform4uiv(location, arrayValue, 4);
+        return gl22.uniform4uiv(location, arrayValue, 4);
       case GL.FLOAT_MAT2:
-        return gl.uniformMatrix2fv(location, false, arrayValue);
+        return gl2.uniformMatrix2fv(location, false, arrayValue);
       case GL.FLOAT_MAT3:
-        return gl.uniformMatrix3fv(location, false, arrayValue);
+        return gl2.uniformMatrix3fv(location, false, arrayValue);
       case GL.FLOAT_MAT4:
-        return gl.uniformMatrix4fv(location, false, arrayValue);
+        return gl2.uniformMatrix4fv(location, false, arrayValue);
       case GL.FLOAT_MAT2x3:
-        return gl2.uniformMatrix2x3fv(location, false, arrayValue);
+        return gl22.uniformMatrix2x3fv(location, false, arrayValue);
       case GL.FLOAT_MAT2x4:
-        return gl2.uniformMatrix2x4fv(location, false, arrayValue);
+        return gl22.uniformMatrix2x4fv(location, false, arrayValue);
       case GL.FLOAT_MAT3x2:
-        return gl2.uniformMatrix3x2fv(location, false, arrayValue);
+        return gl22.uniformMatrix3x2fv(location, false, arrayValue);
       case GL.FLOAT_MAT3x4:
-        return gl2.uniformMatrix3x4fv(location, false, arrayValue);
+        return gl22.uniformMatrix3x4fv(location, false, arrayValue);
       case GL.FLOAT_MAT4x2:
-        return gl2.uniformMatrix4x2fv(location, false, arrayValue);
+        return gl22.uniformMatrix4x2fv(location, false, arrayValue);
       case GL.FLOAT_MAT4x3:
-        return gl2.uniformMatrix4x3fv(location, false, arrayValue);
+        return gl22.uniformMatrix4x3fv(location, false, arrayValue);
     }
     throw new Error("Illegal uniform");
   }
@@ -8640,8 +8684,25 @@ ${formattedLog}`)();
     get [Symbol.toStringTag]() {
       return "BaseVertexArrayObject";
     }
+    /** Buffer constant */
+    buffer = null;
+    bufferValue = null;
+    static isConstantAttributeZeroSupported(device) {
+      return device.info.type === "webgl2" || getBrowser() === "Chrome";
+    }
+    // Create a VertexArray
     constructor(device, props) {
-      super(device, props, {});
+      super(device, props, {
+        ...Resource.defaultProps,
+        constantAttributeZero: false
+      });
+      Object.seal(this);
+    }
+    destroy() {
+      super.destroy();
+      if (this.buffer) {
+        this.buffer?.destroy();
+      }
     }
     _createHandle() {
       return this.gl2.createVertexArray();
@@ -8653,6 +8714,20 @@ ${formattedLog}`)();
     _bindHandle(handle) {
       this.gl2.bindVertexArray(handle);
     }
+    /**
+     * Enabling an attribute location makes it reference the currently bound buffer
+     *  Disabling an attribute location makes it reference the global constant value
+     * TODO - handle single values for size 1 attributes?
+     * TODO - convert classic arrays based on known type?
+     */
+    enable(location, enable2 = true) {
+      const canDisableAttributeZero = this.device.isWebGL2 || getBrowser() === "Chrome";
+      const canDisableAttribute = canDisableAttributeZero || location !== 0;
+      if (enable2 || canDisableAttribute) {
+        location = Number(location);
+        this.bind(() => enable2 ? this.gl.enableVertexAttribArray(location) : this.gl.disableVertexAttribArray(location));
+      }
+    }
     // Set (bind) an elements buffer, for indexed rendering.
     // Must be a Buffer bound to GL.ELEMENT_ARRAY_BUFFER. Constants not supported
     setElementBuffer(elementBuffer = null, opts = {}) {
@@ -8660,12 +8735,12 @@ ${formattedLog}`)();
       this.bind(() => {
         this.gl.bindBuffer(GL.ELEMENT_ARRAY_BUFFER, elementBuffer ? elementBuffer.handle : null);
       });
-      return this;
     }
     /** Set a location in vertex attributes array to a buffer, enables the location, sets divisor */
     setBuffer(location, buffer, accessor) {
       if (buffer.target === GL.ELEMENT_ARRAY_BUFFER) {
-        return this.setElementBuffer(buffer, accessor);
+        this.setElementBuffer(buffer, accessor);
+        return;
       }
       const {
         size,
@@ -8677,39 +8752,121 @@ ${formattedLog}`)();
         divisor
       } = accessor;
       const {
-        gl,
-        gl2
+        gl: gl2,
+        gl2: gl22
       } = this;
       location = Number(location);
       this.bind(() => {
-        gl.bindBuffer(gl.ARRAY_BUFFER, buffer.handle);
+        gl2.bindBuffer(gl2.ARRAY_BUFFER, buffer.handle);
         if (integer) {
           this.device.assertWebGL2();
-          gl2.vertexAttribIPointer(location, size, type, stride, offset);
+          gl22.vertexAttribIPointer(location, size, type, stride, offset);
         } else {
-          gl.vertexAttribPointer(location, size, type, normalized, stride, offset);
+          gl2.vertexAttribPointer(location, size, type, normalized, stride, offset);
         }
-        gl.enableVertexAttribArray(location);
-        gl2.vertexAttribDivisor(location, divisor || 0);
+        gl2.enableVertexAttribArray(location);
+        gl22.vertexAttribDivisor(location, divisor || 0);
       });
-      return this;
     }
     /**
-     * Enabling an attribute location makes it reference the currently bound buffer
-     *  Disabling an attribute location makes it reference the global constant value
-     * TODO - handle single values for size 1 attributes?
-     * TODO - convert classic arrays based on known type?
+     * Set an attribute to a constant value
+     * @param device
+     * @param location
+     * @param array
+     * 
+     * @note Constants are stored globally on the WebGL context, not the VAO
+     * so they need to be updated before every render
+     * @todo - use known type (in configuration or passed in) to allow non-typed arrays?
+     * @todo - remember/cache values to avoid setting them unnecessarily?
      */
-    enable(location, enable2 = true) {
-      const canDisableAttributeZero = this.device.isWebGL2 || getBrowser() === "Chrome";
-      const canDisableAttribute = canDisableAttributeZero || location !== 0;
-      if (enable2 || canDisableAttribute) {
-        location = Number(location);
-        this.bind(() => enable2 ? this.gl.enableVertexAttribArray(location) : this.gl.disableVertexAttribArray(location));
+    setConstant(location, array) {
+      switch (array.constructor) {
+        case Float32Array:
+          setConstantFloatArray(this.device, location, array);
+          break;
+        case Int32Array:
+          setConstantIntArray(this.device, location, array);
+          break;
+        case Uint32Array:
+          setConstantUintArray(this.device, location, array);
+          break;
+        default:
+          assert2(false);
       }
-      return this;
+    }
+    /**
+     * Provide a means to create a buffer that is equivalent to a constant.
+     * NOTE: Desktop OpenGL cannot disable attribute 0.
+     * https://stackoverflow.com/questions/20305231/webgl-warning-attribute-0-is-disabled-
+     * this-has-significant-performance-penalty
+     */
+    getConstantBuffer(elementCount, value) {
+      const constantValue = normalizeConstantArrayValue(value);
+      const byteLength = constantValue.byteLength * elementCount;
+      const length = constantValue.length * elementCount;
+      let updateNeeded = !this.buffer;
+      this.buffer = this.buffer || this.device.createBuffer({
+        byteLength
+      });
+      updateNeeded = updateNeeded || this.buffer.reallocate(byteLength);
+      updateNeeded = updateNeeded || !compareConstantArrayValues(constantValue, this.bufferValue);
+      if (updateNeeded) {
+        const typedArray = getScratchArray(value.constructor, length);
+        fillArray({
+          target: typedArray,
+          source: constantValue,
+          start: 0,
+          count: length
+        });
+        this.buffer.subData(typedArray);
+        this.bufferValue = value;
+      }
+      return this.buffer;
     }
   };
+  function setConstantFloatArray(device, location, array) {
+    switch (array.length) {
+      case 1:
+        device.gl.vertexAttrib1fv(location, array);
+        break;
+      case 2:
+        device.gl.vertexAttrib2fv(location, array);
+        break;
+      case 3:
+        device.gl.vertexAttrib3fv(location, array);
+        break;
+      case 4:
+        device.gl.vertexAttrib4fv(location, array);
+        break;
+      default:
+        assert2(false);
+    }
+  }
+  function setConstantIntArray(device, location, array) {
+    device.assertWebGL2();
+    device.gl2?.vertexAttribI4iv(location, array);
+  }
+  function setConstantUintArray(device, location, array) {
+    device.assertWebGL2();
+    device.gl2?.vertexAttribI4uiv(location, array);
+  }
+  function normalizeConstantArrayValue(arrayValue) {
+    if (Array.isArray(arrayValue)) {
+      return new Float32Array(arrayValue);
+    }
+    return arrayValue;
+  }
+  function compareConstantArrayValues(v1, v2) {
+    if (!v1 || !v2 || v1.length !== v2.length || v1.constructor !== v2.constructor) {
+      return false;
+    }
+    for (let i = 0; i < v1.length; ++i) {
+      if (v1[i] !== v2[i]) {
+        return false;
+      }
+    }
+    return true;
+  }
 
   // src/adapter/resources/webgl-render-pipeline.ts
   var LOG_PROGRAM_PERF_PRIORITY = 4;
@@ -8787,7 +8944,26 @@ ${formattedLog}`)();
         });
       }
     }
-    /** @todo needed for portable model */
+    /**
+     * Constant attributes are only supported in WebGL, not in WebGPU
+     * Any attribute that is disabled in the current vertex array object
+     * is read from the context's global constant value for that attribute location.
+     * @param attributes 
+     */
+    setConstantAttributes(attributes) {
+      for (const [name, value] of Object.entries(attributes)) {
+        const attribute = getAttributeLayout(this.layout, name);
+        if (!attribute) {
+          log.warn(`Ignoring constant value supplied for unknown attribute "${name}" in pipeline "${this.id}"`)();
+          continue;
+        }
+        this.vertexArrayObject.setConstant(attribute.location, value);
+      }
+    }
+    /** 
+     * Bindings include: textures, samplers and uniform buffers
+     * @todo needed for portable model 
+     */
     setBindings(bindings) {
       for (const [name, value] of Object.entries(bindings)) {
         const binding = this.layout.bindings.find((binding2) => binding2.name === name);
@@ -8883,22 +9059,22 @@ ${formattedLog}`)();
     // setBindings(bindings: Record<string, Binding>): void {}
     _compileAndLink() {
       const {
-        gl
+        gl: gl2
       } = this.device;
-      gl.attachShader(this.handle, this.vs.handle);
-      gl.attachShader(this.handle, this.fs.handle);
+      gl2.attachShader(this.handle, this.vs.handle);
+      gl2.attachShader(this.handle, this.fs.handle);
       log.time(LOG_PROGRAM_PERF_PRIORITY, `linkProgram for ${this.id}`)();
-      gl.linkProgram(this.handle);
+      gl2.linkProgram(this.handle);
       log.timeEnd(LOG_PROGRAM_PERF_PRIORITY, `linkProgram for ${this.id}`)();
-      if (gl.debug || log.level > 0) {
-        const linked = gl.getProgramParameter(this.handle, gl.LINK_STATUS);
+      if (gl2.debug || log.level > 0) {
+        const linked = gl2.getProgramParameter(this.handle, gl2.LINK_STATUS);
         if (!linked) {
-          throw new Error(`Error linking: ${gl.getProgramInfoLog(this.handle)}`);
+          throw new Error(`Error linking: ${gl2.getProgramInfoLog(this.handle)}`);
         }
-        gl.validateProgram(this.handle);
-        const validated = gl.getProgramParameter(this.handle, gl.VALIDATE_STATUS);
+        gl2.validateProgram(this.handle);
+        const validated = gl2.getProgramParameter(this.handle, gl2.VALIDATE_STATUS);
         if (!validated) {
-          throw new Error(`Error validating: ${gl.getProgramInfoLog(this.handle)}`);
+          throw new Error(`Error validating: ${gl2.getProgramInfoLog(this.handle)}`);
         }
       }
     }
@@ -9304,18 +9480,18 @@ ${formattedLog}`)();
      * @param gl
      * @returns
      */
-    static attach(gl) {
-      if (gl instanceof _WebGLDevice) {
-        return gl;
+    static attach(gl2) {
+      if (gl2 instanceof _WebGLDevice) {
+        return gl2;
       }
-      if (gl?.device instanceof Device) {
-        return gl.device;
+      if (gl2?.device instanceof Device) {
+        return gl2.device;
       }
-      if (!isWebGL3(gl)) {
+      if (!isWebGL3(gl2)) {
         throw new Error("Invalid WebGLRenderingContext");
       }
       return new _WebGLDevice({
-        gl
+        gl: gl2
       });
     }
     static async create(props = {}) {
@@ -9355,19 +9531,19 @@ ${formattedLog}`)();
         reason: "destroyed",
         message: "Computer entered sleep mode, or too many apps or browser tabs are using the GPU."
       });
-      let gl = props.gl || null;
-      gl = gl || (isBrowser() ? createBrowserContext(this.canvasContext.canvas, {
+      let gl2 = props.gl || null;
+      gl2 = gl2 || (isBrowser() ? createBrowserContext(this.canvasContext.canvas, {
         ...props,
         onContextLost
       }) : null);
-      gl = gl || (!isBrowser() ? createHeadlessContext({
+      gl2 = gl2 || (!isBrowser() ? createHeadlessContext({
         ...props,
         onContextLost
       }) : null);
-      if (!gl) {
+      if (!gl2) {
         throw new Error("WebGL context creation failed");
       }
-      this.handle = gl;
+      this.handle = gl2;
       this.gl = this.handle;
       this.gl2 = this.gl;
       this.isWebGL2 = isWebGL22(this.gl);
@@ -9555,11 +9731,11 @@ ${formattedLog}`)();
      * 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;
+    getGLKey(value, gl2) {
+      gl2 = gl2 || this.gl2 || this.gl;
       const number = Number(value);
-      for (const key in gl) {
-        if (gl[key] === number) {
+      for (const key in gl2) {
+        if (gl2[key] === number) {
           return `GL.${key}`;
         }
       }
@@ -9571,20 +9747,20 @@ ${formattedLog}`)();
   // Public `Device` API
   //
   __publicField(WebGLDevice, "type", "webgl");
-  function isWebGL3(gl) {
-    if (typeof WebGLRenderingContext !== "undefined" && gl instanceof WebGLRenderingContext) {
+  function isWebGL3(gl2) {
+    if (typeof WebGLRenderingContext !== "undefined" && gl2 instanceof WebGLRenderingContext) {
       return true;
     }
-    if (typeof WebGL2RenderingContext !== "undefined" && gl instanceof WebGL2RenderingContext) {
+    if (typeof WebGL2RenderingContext !== "undefined" && gl2 instanceof WebGL2RenderingContext) {
       return true;
     }
-    return Boolean(gl && Number.isFinite(gl._version));
+    return Boolean(gl2 && Number.isFinite(gl2._version));
   }
-  function isWebGL22(gl) {
-    if (typeof WebGL2RenderingContext !== "undefined" && gl instanceof WebGL2RenderingContext) {
+  function isWebGL22(gl2) {
+    if (typeof WebGL2RenderingContext !== "undefined" && gl2 instanceof WebGL2RenderingContext) {
       return true;
     }
-    return Boolean(gl && gl._version === 2);
+    return Boolean(gl2 && gl2._version === 2);
   }
 
   // src/classic/clear.ts
@@ -9592,8 +9768,8 @@ ${formattedLog}`)();
   var GL_STENCIL_BUFFER_BIT2 = 1024;
   var GL_COLOR_BUFFER_BIT2 = 16384;
   var ERR_ARGUMENTS = "clear: bad arguments";
-  function clear(gl, options) {
-    const device = WebGLDevice.attach(gl);
+  function clear(gl2, options) {
+    const device = WebGLDevice.attach(gl2);
     const {
       framebuffer = null,
       color = null,
@@ -9688,7 +9864,7 @@ ${formattedLog}`)();
     } = getFramebuffer2(source);
     assert2(framebuffer);
     const {
-      gl,
+      gl: gl2,
       handle
     } = framebuffer;
     sourceWidth = sourceWidth || framebuffer.width;
@@ -9700,9 +9876,9 @@ ${formattedLog}`)();
     sourceType = sourceType || framebuffer.colorAttachments[attachment].type;
     target = getPixelArray(target, sourceType, sourceFormat, sourceWidth, sourceHeight);
     sourceType = sourceType || getGLTypeFromTypedArray(target);
-    const prevHandle2 = gl.bindFramebuffer(GL.FRAMEBUFFER, handle);
-    gl.readPixels(sourceX, sourceY, sourceWidth, sourceHeight, sourceFormat, sourceType, target);
-    gl.bindFramebuffer(GL.FRAMEBUFFER, prevHandle2 || null);
+    const prevHandle2 = gl2.bindFramebuffer(GL.FRAMEBUFFER, handle);
+    gl2.readPixels(sourceX, sourceY, sourceWidth, sourceHeight, sourceFormat, sourceType, target);
+    gl2.bindFramebuffer(GL.FRAMEBUFFER, prevHandle2 || null);
     if (deleteFramebuffer) {
       framebuffer.destroy();
     }
@@ -9759,6 +9935,85 @@ ${formattedLog}`)();
     }
     return target;
   }
+  function copyToTexture(source, target, options) {
+    const {
+      sourceX = 0,
+      sourceY = 0,
+      // attachment = GL.COLOR_ATTACHMENT0, // TODO - support gl.readBuffer
+      targetMipmaplevel = 0,
+      targetInternalFormat = GL.RGBA
+    } = options || {};
+    let {
+      targetX,
+      targetY,
+      targetZ,
+      width,
+      // defaults to target width
+      height
+      // defaults to target height
+    } = options || {};
+    const {
+      framebuffer,
+      deleteFramebuffer
+    } = getFramebuffer2(source);
+    assert2(framebuffer);
+    const webglFramebuffer = framebuffer;
+    const {
+      device,
+      handle
+    } = webglFramebuffer;
+    const isSubCopy = typeof targetX !== "undefined" || typeof targetY !== "undefined" || typeof targetZ !== "undefined";
+    targetX = targetX || 0;
+    targetY = targetY || 0;
+    targetZ = targetZ || 0;
+    const prevHandle2 = device.gl.bindFramebuffer(GL.FRAMEBUFFER, handle);
+    assert2(target);
+    let texture = null;
+    let textureTarget;
+    if (target instanceof Texture) {
+      texture = target;
+      width = Number.isFinite(width) ? width : texture.width;
+      height = Number.isFinite(height) ? height : texture.height;
+      texture.bind(0);
+      textureTarget = texture.target;
+    } else {
+      textureTarget = target;
+    }
+    if (!isSubCopy) {
+      device.gl.copyTexImage2D(
+        textureTarget,
+        targetMipmaplevel,
+        targetInternalFormat,
+        sourceX,
+        sourceY,
+        width,
+        height,
+        0
+        /* border must be 0 */
+      );
+    } else {
+      switch (textureTarget) {
+        case GL.TEXTURE_2D:
+        case GL.TEXTURE_CUBE_MAP:
+          device.gl.copyTexSubImage2D(textureTarget, targetMipmaplevel, targetX, targetY, sourceX, sourceY, width, height);
+          break;
+        case GL.TEXTURE_2D_ARRAY:
+        case GL.TEXTURE_3D:
+          device.assertWebGL2();
+          device.gl2.copyTexSubImage3D(textureTarget, targetMipmaplevel, targetX, targetY, targetZ, sourceX, sourceY, width, height);
+          break;
+        default:
+      }
+    }
+    if (texture) {
+      texture.unbind();
+    }
+    gl.bindFramebuffer(GL.FRAMEBUFFER, prevHandle2 || null);
+    if (deleteFramebuffer) {
+      framebuffer.destroy();
+    }
+    return texture;
+  }
   function getFramebuffer2(source) {
     if (!(source instanceof Framebuffer)) {
       return {