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

package/dist/index.cjs

@@ -78,6 +78,7 @@ __export(src_exports, {
   assertWebGLContext: () => assertWebGLContext,
   clear: () => clear,
   convertGLToTextureFormat: () => convertGLToTextureFormat,
+  copyToTexture: () => copyToTexture,
   getParameters: () => getParameters,
   getProgramBindings: () => getProgramBindings,
   getShaderLayout: () => getShaderLayout,
@@ -124,11 +125,11 @@ function createHeadlessContext(options) {
   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;
 }
 
 // src/adapter/webgl-device.ts
@@ -156,43 +157,43 @@ function synthesizeGLError(err, opt_msg) {
     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;
@@ -202,19 +203,19 @@ WebGLVertexArrayObjectOES.VertexAttrib = function VertexAttrib(gl) {
 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;
@@ -223,53 +224,53 @@ var OESVertexArrayObject = function OESVertexArrayObject2(gl) {
     }
     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];
@@ -282,11 +283,11 @@ var OESVertexArrayObject = function OESVertexArrayObject2(gl) {
     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(
+  if (gl2.canvas) {
+    gl2.canvas.addEventListener(
       "webglcontextrestored",
       () => {
         log("OESVertexArrayObject emulation library context restored");
@@ -305,8 +306,8 @@ OESVertexArrayObject.prototype.reset_ = function reset_() {
       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;
@@ -334,10 +335,10 @@ OESVertexArrayObject.prototype.isVertexArrayOES = function isVertexArrayOES(arra
   return false;
 };
 OESVertexArrayObject.prototype.bindVertexArrayOES = function bindVertexArrayOES(arrayObject) {
-  const gl = this.gl;
+  const gl2 = this.gl;
   if (arrayObject && !arrayObject.isAlive) {
     synthesizeGLError(
-      gl.INVALID_OPERATION,
+      gl2.INVALID_OPERATION,
       "bindVertexArrayOES: attempt to bind deleted arrayObject"
     );
     return;
@@ -351,7 +352,7 @@ OESVertexArrayObject.prototype.bindVertexArrayOES = function bindVertexArrayOES(
     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);
@@ -360,23 +361,23 @@ OESVertexArrayObject.prototype.bindVertexArrayOES = function bindVertexArrayOES(
     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,
+          gl2,
           n,
           attrib.size,
           attrib.type,
@@ -388,23 +389,23 @@ OESVertexArrayObject.prototype.bindVertexArrayOES = function bindVertexArrayOES(
     }
   }
   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;
@@ -412,7 +413,7 @@ function polyfillVertexArrayObject(gl) {
     if (name !== "OES_vertex_array_object") {
       return null;
     }
-    if (!gl.__OESVertexArrayObject) {
+    if (!gl2.__OESVertexArrayObject) {
       this.__OESVertexArrayObject = new OESVertexArrayObject(this);
     }
     return this.__OESVertexArrayObject;
@@ -427,31 +428,31 @@ var import_constants2 = require("@luma.gl/constants");
 var import_api = require("@luma.gl/api");
 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) {
-  (0, import_api.assert)(isWebGL(gl), ERR_CONTEXT);
-  return gl;
+function assertWebGLContext(gl2) {
+  (0, import_api.assert)(isWebGL(gl2), ERR_CONTEXT);
+  return gl2;
 }
-function assertWebGL2Context(gl) {
-  (0, import_api.assert)(isWebGL2(gl), ERR_WEBGL2);
-  return gl;
+function assertWebGL2Context(gl2) {
+  (0, import_api.assert)(isWebGL2(gl2), ERR_WEBGL2);
+  return gl2;
 }
 
 // src/context/polyfill/get-parameter-polyfill.ts
@@ -468,40 +469,40 @@ var GL_GPU_DISJOINT_EXT = 36795;
 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 = {
-  [import_constants.GL.READ_BUFFER]: (gl) => !isWebGL2(gl) ? import_constants.GL.COLOR_ATTACHMENT0 : void 0,
+  [import_constants.GL.READ_BUFFER]: (gl2) => !isWebGL2(gl2) ? import_constants.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,
   [import_constants.GL.RASTERIZER_DISCARD]: getWebGL2ValueOrZero,
   [import_constants.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 || import_constants.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 || import_constants.GL.RENDERER);
   },
   // Extension LIMITS
-  [GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT]: (gl, getParameter) => {
+  [GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT]: (gl2, getParameter) => {
     var _a, _b;
-    const ext = ((_b = (_a = gl.luma) == null ? void 0 : _a.extensions) == null ? void 0 : _b[EXT_texture_filter_anisotropic]) || gl.getExtension("EXT_texture_filter_anisotropic");
+    const ext = ((_b = (_a = gl2.luma) == null ? void 0 : _a.extensions) == null ? void 0 : _b[EXT_texture_filter_anisotropic]) || gl2.getExtension("EXT_texture_filter_anisotropic");
     return ext ? getParameter(ext.MAX_TEXTURE_MAX_ANISOTROPY_EXT) : 1;
   },
   // WebGL2 Limits
   [import_constants.GL.MAX_3D_TEXTURE_SIZE]: getWebGL2ValueOrZero,
   [import_constants.GL.MAX_ARRAY_TEXTURE_LAYERS]: getWebGL2ValueOrZero,
   [import_constants.GL.MAX_CLIENT_WAIT_TIMEOUT_WEBGL]: getWebGL2ValueOrZero,
-  [import_constants.GL.MAX_COLOR_ATTACHMENTS]: (gl, getParameter) => {
-    if (!isWebGL2(gl)) {
-      const ext = gl.getExtension(WEBGL_draw_buffers);
+  [import_constants.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;
@@ -509,24 +510,24 @@ var WEBGL_PARAMETERS = {
   [import_constants.GL.MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS]: getWebGL2ValueOrZero,
   [import_constants.GL.MAX_COMBINED_UNIFORM_BLOCKS]: getWebGL2ValueOrZero,
   [import_constants.GL.MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS]: getWebGL2ValueOrZero,
-  [import_constants.GL.MAX_DRAW_BUFFERS]: (gl) => {
-    if (!isWebGL2(gl)) {
-      const ext = gl.getExtension(WEBGL_draw_buffers);
+  [import_constants.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;
   },
   [import_constants.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
   ),
   [import_constants.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
   ),
   [import_constants.GL.MAX_ELEMENTS_VERTICES]: (
     // Guess: "Reasonably safe" per webglstats.com - could be higher/lower (on some mobile devices)
-    (gl) => 16777216
+    (gl2) => 16777216
   ),
   [import_constants.GL.MAX_FRAGMENT_INPUT_COMPONENTS]: getWebGL2ValueOrZero,
   [import_constants.GL.MAX_FRAGMENT_UNIFORM_BLOCKS]: getWebGL2ValueOrZero,
@@ -547,24 +548,24 @@ var WEBGL_PARAMETERS = {
   [import_constants.GL.MAX_PROGRAM_TEXEL_OFFSET]: getWebGL2ValueOrZero,
   [import_constants.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
@@ -574,10 +575,10 @@ var WEBGL_draw_buffers2 = "WEBGL_draw_buffers";
 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 = {
@@ -644,15 +645,15 @@ var WEBGL2_CONTEXT_POLYFILLS = {
 };
 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) => {
-    const { webgl2, ext } = getExtensionData(gl, ANGLE_instanced_arrays);
+  getVertexAttrib: (gl2, originalFunc, location, pname) => {
+    const { webgl2, ext } = getExtensionData(gl2, ANGLE_instanced_arrays);
     let result;
     switch (pname) {
       case import_constants2.GL.VERTEX_ATTRIB_ARRAY_INTEGER:
@@ -666,8 +667,8 @@ var WEBGL2_CONTEXT_OVERRIDES = {
     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 import_constants2.GL.TRANSFORM_FEEDBACK_BUFFER_MODE:
           return import_constants2.GL.SEPARATE_ATTRIBS;
@@ -680,21 +681,21 @@ var WEBGL2_CONTEXT_OVERRIDES = {
     }
     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 import_constants2.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 import_constants2.GL.TEXTURE_MAX_ANISOTROPY_EXT:
-        const contextData = getContextData(gl);
+        const contextData = getContextData(gl2);
         const { _extensions } = contextData;
         const ext = _extensions[EXT_texture_filter_anisotropic2];
         pname = ext && ext.TEXTURE_MAX_ANISOTROPY_EXT || import_constants2.GL.TEXTURE_MAX_ANISOTROPY_EXT;
@@ -704,50 +705,50 @@ var WEBGL2_CONTEXT_OVERRIDES = {
     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, { target: contextState, target2: gl });
+    polyfillVertexArrayObject(gl2);
+    initializeExtensions(gl2);
+    installPolyfills(gl2, WEBGL2_CONTEXT_POLYFILLS);
+    installOverrides(gl2, { target: contextState, 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, { extension, target: contextState, target2: gl });
+      polyfillExtension(gl2, { extension, target: contextState, target2: gl2 });
     }
   }
 }
-function polyfillExtension(gl, { extension, target, target2 }) {
+function polyfillExtension(gl2, { extension, target, target2 }) {
   const defaults = WEBGL2_CONTEXT_POLYFILLS[extension];
   (0, import_api3.assert)(defaults);
   const { meta = {} } = defaults;
   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") {
@@ -759,12 +760,12 @@ function polyfillExtension(gl, { extension, target, target2 }) {
     }
   }
 }
-function installOverrides(gl, { target, target2 }) {
+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;
     }
@@ -859,19 +860,19 @@ var GL_PARAMETER_DEFAULTS = {
   [import_constants3.GL.UNPACK_SKIP_ROWS]: 0,
   [import_constants3.GL.UNPACK_SKIP_IMAGES]: 0
 };
-var enable = (gl, value, key) => value ? gl.enable(key) : gl.disable(key);
-var hint = (gl, value, key) => gl.hint(key, value);
-var pixelStorei = (gl, value, key) => gl.pixelStorei(key, value);
-var bindFramebuffer = (gl, value, key) => {
+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 === import_constants3.GL.FRAMEBUFFER_BINDING) {
-    target = isWebGL2(gl) ? import_constants3.GL.DRAW_FRAMEBUFFER : import_constants3.GL.FRAMEBUFFER;
+    target = isWebGL2(gl2) ? import_constants3.GL.DRAW_FRAMEBUFFER : import_constants3.GL.FRAMEBUFFER;
   } else {
     target = import_constants3.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 = {
     [import_constants3.GL.ARRAY_BUFFER_BINDING]: import_constants3.GL.ARRAY_BUFFER,
     [import_constants3.GL.COPY_READ_BUFFER_BINDING]: import_constants3.GL.COPY_READ_BUFFER,
@@ -880,38 +881,38 @@ var bindBuffer = (gl, value, key) => {
     [import_constants3.GL.PIXEL_UNPACK_BUFFER_BINDING]: import_constants3.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 = {
   [import_constants3.GL.BLEND]: enable,
-  [import_constants3.GL.BLEND_COLOR]: (gl, value) => gl.blendColor(...value),
+  [import_constants3.GL.BLEND_COLOR]: (gl2, value) => gl2.blendColor(...value),
   [import_constants3.GL.BLEND_EQUATION_RGB]: "blendEquation",
   [import_constants3.GL.BLEND_EQUATION_ALPHA]: "blendEquation",
   [import_constants3.GL.BLEND_SRC_RGB]: "blendFunc",
   [import_constants3.GL.BLEND_DST_RGB]: "blendFunc",
   [import_constants3.GL.BLEND_SRC_ALPHA]: "blendFunc",
   [import_constants3.GL.BLEND_DST_ALPHA]: "blendFunc",
-  [import_constants3.GL.COLOR_CLEAR_VALUE]: (gl, value) => gl.clearColor(...value),
-  [import_constants3.GL.COLOR_WRITEMASK]: (gl, value) => gl.colorMask(...value),
+  [import_constants3.GL.COLOR_CLEAR_VALUE]: (gl2, value) => gl2.clearColor(...value),
+  [import_constants3.GL.COLOR_WRITEMASK]: (gl2, value) => gl2.colorMask(...value),
   [import_constants3.GL.CULL_FACE]: enable,
-  [import_constants3.GL.CULL_FACE_MODE]: (gl, value) => gl.cullFace(value),
+  [import_constants3.GL.CULL_FACE_MODE]: (gl2, value) => gl2.cullFace(value),
   [import_constants3.GL.DEPTH_TEST]: enable,
-  [import_constants3.GL.DEPTH_CLEAR_VALUE]: (gl, value) => gl.clearDepth(value),
-  [import_constants3.GL.DEPTH_FUNC]: (gl, value) => gl.depthFunc(value),
-  [import_constants3.GL.DEPTH_RANGE]: (gl, value) => gl.depthRange(...value),
-  [import_constants3.GL.DEPTH_WRITEMASK]: (gl, value) => gl.depthMask(value),
+  [import_constants3.GL.DEPTH_CLEAR_VALUE]: (gl2, value) => gl2.clearDepth(value),
+  [import_constants3.GL.DEPTH_FUNC]: (gl2, value) => gl2.depthFunc(value),
+  [import_constants3.GL.DEPTH_RANGE]: (gl2, value) => gl2.depthRange(...value),
+  [import_constants3.GL.DEPTH_WRITEMASK]: (gl2, value) => gl2.depthMask(value),
   [import_constants3.GL.DITHER]: enable,
   [import_constants3.GL.FRAGMENT_SHADER_DERIVATIVE_HINT]: hint,
-  [import_constants3.GL.CURRENT_PROGRAM]: (gl, value) => gl.useProgram(value),
-  [import_constants3.GL.RENDERBUFFER_BINDING]: (gl, value) => gl.bindRenderbuffer(import_constants3.GL.RENDERBUFFER, value),
-  [import_constants3.GL.TRANSFORM_FEEDBACK_BINDING]: (gl, value) => {
+  [import_constants3.GL.CURRENT_PROGRAM]: (gl2, value) => gl2.useProgram(value),
+  [import_constants3.GL.RENDERBUFFER_BINDING]: (gl2, value) => gl2.bindRenderbuffer(import_constants3.GL.RENDERBUFFER, value),
+  [import_constants3.GL.TRANSFORM_FEEDBACK_BINDING]: (gl2, value) => {
     var _a;
-    return (_a = gl.bindTransformFeedback) == null ? void 0 : _a.call(gl, import_constants3.GL.TRANSFORM_FEEDBACK, value);
+    return (_a = gl2.bindTransformFeedback) == null ? void 0 : _a.call(gl2, import_constants3.GL.TRANSFORM_FEEDBACK, value);
   },
-  [import_constants3.GL.VERTEX_ARRAY_BINDING]: (gl, value) => gl.bindVertexArray(value),
+  [import_constants3.GL.VERTEX_ARRAY_BINDING]: (gl2, value) => gl2.bindVertexArray(value),
   // NOTE: FRAMEBUFFER_BINDING and DRAW_FRAMEBUFFER_BINDING(WebGL2) refer same state.
   [import_constants3.GL.FRAMEBUFFER_BINDING]: bindFramebuffer,
   [import_constants3.GL.READ_FRAMEBUFFER_BINDING]: bindFramebuffer,
@@ -921,9 +922,9 @@ var GL_PARAMETER_SETTERS = {
   [import_constants3.GL.COPY_WRITE_BUFFER_BINDING]: bindBuffer,
   [import_constants3.GL.PIXEL_PACK_BUFFER_BINDING]: bindBuffer,
   [import_constants3.GL.PIXEL_UNPACK_BUFFER_BINDING]: bindBuffer,
-  [import_constants3.GL.FRONT_FACE]: (gl, value) => gl.frontFace(value),
+  [import_constants3.GL.FRONT_FACE]: (gl2, value) => gl2.frontFace(value),
   [import_constants3.GL.GENERATE_MIPMAP_HINT]: hint,
-  [import_constants3.GL.LINE_WIDTH]: (gl, value) => gl.lineWidth(value),
+  [import_constants3.GL.LINE_WIDTH]: (gl2, value) => gl2.lineWidth(value),
   [import_constants3.GL.POLYGON_OFFSET_FILL]: enable,
   [import_constants3.GL.POLYGON_OFFSET_FACTOR]: "polygonOffset",
   [import_constants3.GL.POLYGON_OFFSET_UNITS]: "polygonOffset",
@@ -933,11 +934,11 @@ var GL_PARAMETER_SETTERS = {
   [import_constants3.GL.SAMPLE_COVERAGE_VALUE]: "sampleCoverage",
   [import_constants3.GL.SAMPLE_COVERAGE_INVERT]: "sampleCoverage",
   [import_constants3.GL.SCISSOR_TEST]: enable,
-  [import_constants3.GL.SCISSOR_BOX]: (gl, value) => gl.scissor(...value),
+  [import_constants3.GL.SCISSOR_BOX]: (gl2, value) => gl2.scissor(...value),
   [import_constants3.GL.STENCIL_TEST]: enable,
-  [import_constants3.GL.STENCIL_CLEAR_VALUE]: (gl, value) => gl.clearStencil(value),
-  [import_constants3.GL.STENCIL_WRITEMASK]: (gl, value) => gl.stencilMaskSeparate(import_constants3.GL.FRONT, value),
-  [import_constants3.GL.STENCIL_BACK_WRITEMASK]: (gl, value) => gl.stencilMaskSeparate(import_constants3.GL.BACK, value),
+  [import_constants3.GL.STENCIL_CLEAR_VALUE]: (gl2, value) => gl2.clearStencil(value),
+  [import_constants3.GL.STENCIL_WRITEMASK]: (gl2, value) => gl2.stencilMaskSeparate(import_constants3.GL.FRONT, value),
+  [import_constants3.GL.STENCIL_BACK_WRITEMASK]: (gl2, value) => gl2.stencilMaskSeparate(import_constants3.GL.BACK, value),
   [import_constants3.GL.STENCIL_FUNC]: "stencilFuncFront",
   [import_constants3.GL.STENCIL_REF]: "stencilFuncFront",
   [import_constants3.GL.STENCIL_VALUE_MASK]: "stencilFuncFront",
@@ -950,7 +951,7 @@ var GL_PARAMETER_SETTERS = {
   [import_constants3.GL.STENCIL_BACK_FAIL]: "stencilOpBack",
   [import_constants3.GL.STENCIL_BACK_PASS_DEPTH_FAIL]: "stencilOpBack",
   [import_constants3.GL.STENCIL_BACK_PASS_DEPTH_PASS]: "stencilOpBack",
-  [import_constants3.GL.VIEWPORT]: (gl, value) => gl.viewport(...value),
+  [import_constants3.GL.VIEWPORT]: (gl2, value) => gl2.viewport(...value),
   // WEBGL1 PIXEL PACK/UNPACK MODES
   [import_constants3.GL.PACK_ALIGNMENT]: pixelStorei,
   [import_constants3.GL.UNPACK_ALIGNMENT]: pixelStorei,
@@ -968,104 +969,104 @@ var GL_PARAMETER_SETTERS = {
   [import_constants3.GL.UNPACK_SKIP_ROWS]: pixelStorei,
   [import_constants3.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(import_constants3.GL.FRAMEBUFFER, handle);
+    return gl2.bindFramebuffer(import_constants3.GL.FRAMEBUFFER, handle);
   },
-  blend: (gl, value) => value ? gl.enable(import_constants3.GL.BLEND) : gl.disable(import_constants3.GL.BLEND),
-  blendColor: (gl, value) => gl.blendColor(...value),
-  blendEquation: (gl, args) => {
+  blend: (gl2, value) => value ? gl2.enable(import_constants3.GL.BLEND) : gl2.disable(import_constants3.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 == null ? void 0 : args.length) === 2 ? [...args, ...args] : args;
-    gl.blendFuncSeparate(...separateFuncs);
+    gl2.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(import_constants3.GL.CULL_FACE) : gl.disable(import_constants3.GL.CULL_FACE),
-  cullFace: (gl, value) => gl.cullFace(value),
-  depthTest: (gl, value) => value ? gl.enable(import_constants3.GL.DEPTH_TEST) : gl.disable(import_constants3.GL.DEPTH_TEST),
-  depthFunc: (gl, value) => gl.depthFunc(value),
-  depthMask: (gl, value) => gl.depthMask(value),
-  depthRange: (gl, value) => gl.depthRange(...value),
-  dither: (gl, value) => value ? gl.enable(import_constants3.GL.DITHER) : gl.disable(import_constants3.GL.DITHER),
-  derivativeHint: (gl, value) => {
-    gl.hint(import_constants3.GL.FRAGMENT_SHADER_DERIVATIVE_HINT, value);
+  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(import_constants3.GL.CULL_FACE) : gl2.disable(import_constants3.GL.CULL_FACE),
+  cullFace: (gl2, value) => gl2.cullFace(value),
+  depthTest: (gl2, value) => value ? gl2.enable(import_constants3.GL.DEPTH_TEST) : gl2.disable(import_constants3.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(import_constants3.GL.DITHER) : gl2.disable(import_constants3.GL.DITHER),
+  derivativeHint: (gl2, value) => {
+    gl2.hint(import_constants3.GL.FRAGMENT_SHADER_DERIVATIVE_HINT, value);
   },
-  frontFace: (gl, value) => gl.frontFace(value),
-  mipmapHint: (gl, value) => gl.hint(import_constants3.GL.GENERATE_MIPMAP_HINT, value),
-  lineWidth: (gl, value) => gl.lineWidth(value),
-  polygonOffsetFill: (gl, value) => value ? gl.enable(import_constants3.GL.POLYGON_OFFSET_FILL) : gl.disable(import_constants3.GL.POLYGON_OFFSET_FILL),
-  polygonOffset: (gl, value) => gl.polygonOffset(...value),
-  sampleCoverage: (gl, value) => gl.sampleCoverage(...value),
-  scissorTest: (gl, value) => value ? gl.enable(import_constants3.GL.SCISSOR_TEST) : gl.disable(import_constants3.GL.SCISSOR_TEST),
-  scissor: (gl, value) => gl.scissor(...value),
-  stencilTest: (gl, value) => value ? gl.enable(import_constants3.GL.STENCIL_TEST) : gl.disable(import_constants3.GL.STENCIL_TEST),
-  stencilMask: (gl, value) => {
+  frontFace: (gl2, value) => gl2.frontFace(value),
+  mipmapHint: (gl2, value) => gl2.hint(import_constants3.GL.GENERATE_MIPMAP_HINT, value),
+  lineWidth: (gl2, value) => gl2.lineWidth(value),
+  polygonOffsetFill: (gl2, value) => value ? gl2.enable(import_constants3.GL.POLYGON_OFFSET_FILL) : gl2.disable(import_constants3.GL.POLYGON_OFFSET_FILL),
+  polygonOffset: (gl2, value) => gl2.polygonOffset(...value),
+  sampleCoverage: (gl2, value) => gl2.sampleCoverage(...value),
+  scissorTest: (gl2, value) => value ? gl2.enable(import_constants3.GL.SCISSOR_TEST) : gl2.disable(import_constants3.GL.SCISSOR_TEST),
+  scissor: (gl2, value) => gl2.scissor(...value),
+  stencilTest: (gl2, value) => value ? gl2.enable(import_constants3.GL.STENCIL_TEST) : gl2.disable(import_constants3.GL.STENCIL_TEST),
+  stencilMask: (gl2, value) => {
     value = isArray(value) ? value : [value, value];
     const [mask, backMask] = value;
-    gl.stencilMaskSeparate(import_constants3.GL.FRONT, mask);
-    gl.stencilMaskSeparate(import_constants3.GL.BACK, backMask);
+    gl2.stencilMaskSeparate(import_constants3.GL.FRONT, mask);
+    gl2.stencilMaskSeparate(import_constants3.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(import_constants3.GL.FRONT, func, ref, mask);
-    gl.stencilFuncSeparate(import_constants3.GL.BACK, backFunc, backRef, backMask);
+    gl2.stencilFuncSeparate(import_constants3.GL.FRONT, func, ref, mask);
+    gl2.stencilFuncSeparate(import_constants3.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(import_constants3.GL.FRONT, sfail, dpfail, dppass);
-    gl.stencilOpSeparate(import_constants3.GL.BACK, backSfail, backDpfail, backDppass);
+    gl2.stencilOpSeparate(import_constants3.GL.FRONT, sfail, dpfail, dppass);
+    gl2.stencilOpSeparate(import_constants3.GL.BACK, backSfail, backDpfail, backDppass);
   },
-  viewport: (gl, value) => gl.viewport(...value)
+  viewport: (gl2, value) => gl2.viewport(...value)
 };
 function getValue(glEnum, values, cache) {
   return values[glEnum] !== void 0 ? values[glEnum] : cache[glEnum];
 }
 var GL_COMPOSITE_PARAMETER_SETTERS = {
-  blendEquation: (gl, values, cache) => gl.blendEquationSeparate(
+  blendEquation: (gl2, values, cache) => gl2.blendEquationSeparate(
     getValue(import_constants3.GL.BLEND_EQUATION_RGB, values, cache),
     getValue(import_constants3.GL.BLEND_EQUATION_ALPHA, values, cache)
   ),
-  blendFunc: (gl, values, cache) => gl.blendFuncSeparate(
+  blendFunc: (gl2, values, cache) => gl2.blendFuncSeparate(
     getValue(import_constants3.GL.BLEND_SRC_RGB, values, cache),
     getValue(import_constants3.GL.BLEND_DST_RGB, values, cache),
     getValue(import_constants3.GL.BLEND_SRC_ALPHA, values, cache),
     getValue(import_constants3.GL.BLEND_DST_ALPHA, values, cache)
   ),
-  polygonOffset: (gl, values, cache) => gl.polygonOffset(
+  polygonOffset: (gl2, values, cache) => gl2.polygonOffset(
     getValue(import_constants3.GL.POLYGON_OFFSET_FACTOR, values, cache),
     getValue(import_constants3.GL.POLYGON_OFFSET_UNITS, values, cache)
   ),
-  sampleCoverage: (gl, values, cache) => gl.sampleCoverage(
+  sampleCoverage: (gl2, values, cache) => gl2.sampleCoverage(
     getValue(import_constants3.GL.SAMPLE_COVERAGE_VALUE, values, cache),
     getValue(import_constants3.GL.SAMPLE_COVERAGE_INVERT, values, cache)
   ),
-  stencilFuncFront: (gl, values, cache) => gl.stencilFuncSeparate(
+  stencilFuncFront: (gl2, values, cache) => gl2.stencilFuncSeparate(
     import_constants3.GL.FRONT,
     getValue(import_constants3.GL.STENCIL_FUNC, values, cache),
     getValue(import_constants3.GL.STENCIL_REF, values, cache),
     getValue(import_constants3.GL.STENCIL_VALUE_MASK, values, cache)
   ),
-  stencilFuncBack: (gl, values, cache) => gl.stencilFuncSeparate(
+  stencilFuncBack: (gl2, values, cache) => gl2.stencilFuncSeparate(
     import_constants3.GL.BACK,
     getValue(import_constants3.GL.STENCIL_BACK_FUNC, values, cache),
     getValue(import_constants3.GL.STENCIL_BACK_REF, values, cache),
     getValue(import_constants3.GL.STENCIL_BACK_VALUE_MASK, values, cache)
   ),
-  stencilOpFront: (gl, values, cache) => gl.stencilOpSeparate(
+  stencilOpFront: (gl2, values, cache) => gl2.stencilOpSeparate(
     import_constants3.GL.FRONT,
     getValue(import_constants3.GL.STENCIL_FAIL, values, cache),
     getValue(import_constants3.GL.STENCIL_PASS_DEPTH_FAIL, values, cache),
     getValue(import_constants3.GL.STENCIL_PASS_DEPTH_PASS, values, cache)
   ),
-  stencilOpBack: (gl, values, cache) => gl.stencilOpSeparate(
+  stencilOpBack: (gl2, values, cache) => gl2.stencilOpSeparate(
     import_constants3.GL.BACK,
     getValue(import_constants3.GL.STENCIL_BACK_FAIL, values, cache),
     getValue(import_constants3.GL.STENCIL_BACK_PASS_DEPTH_FAIL, values, cache),
@@ -1228,7 +1229,7 @@ var GL_HOOKED_SETTERS = {
     [import_constants3.GL.VIEWPORT]: [x, y, width, height]
   })
 };
-var isEnabled = (gl, key) => gl.isEnabled(key);
+var isEnabled = (gl2, key) => gl2.isEnabled(key);
 var GL_PARAMETER_GETTERS = {
   [import_constants3.GL.BLEND]: isEnabled,
   [import_constants3.GL.CULL_FACE]: isEnabled,
@@ -1284,7 +1285,7 @@ var NON_CACHE_PARAMETERS = /* @__PURE__ */ new Set([
 // 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 (isObjectEmpty(parameters)) {
     return;
   }
@@ -1296,31 +1297,31 @@ function setParameters(device, parameters) {
       if (typeof setter === "string") {
         compositeSetters[setter] = true;
       } else {
-        setter(gl, parameters[key], glConstant);
+        setter(gl2, parameters[key], glConstant);
       }
     }
   }
-  const cache = gl.state && gl.state.cache;
+  const cache = gl2.state && gl2.state.cache;
   if (cache) {
     for (const key in compositeSetters) {
       const compositeSetter = GL_COMPOSITE_PARAMETER_SETTERS[key];
-      compositeSetter(gl, parameters, cache);
+      compositeSetter(gl2, parameters, cache);
     }
   }
 }
 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;
 }
@@ -1354,7 +1355,7 @@ function deepArrayEqual(x, y) {
 
 // src/context/state-tracker/track-context-state.ts
 var GLState = class {
-  constructor(gl, {
+  constructor(gl2, {
     copyState = false,
     // Copy cache from params (slow) or initialize from WebGL defaults (fast)
     log: log9 = () => {
@@ -1364,8 +1365,8 @@ var GLState = class {
     this.program = null;
     this.stateStack = [];
     this.enable = true;
-    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 = log9;
     this._updateCache = this._updateCache.bind(this);
     Object.seal(this);
@@ -1405,46 +1406,46 @@ var GLState = class {
     return { valueChanged, oldValue };
   }
 };
-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;
   (0, import_api4.assert)(copyState !== void 0);
-  if (!gl.state) {
-    gl.state = new GLState(gl, { copyState });
-    installProgramSpy(gl);
+  if (!gl2.state) {
+    gl2.state = new GLState(gl2, { copyState });
+    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, { copyState: false });
-    glState = getContextState(gl);
+    trackContextState(gl2, { copyState: false });
+    glState = getContextState(gl2);
   }
   glState.push();
 }
-function popContextState(gl) {
-  const glState = getContextState(gl);
+function popContextState(gl2) {
+  const glState = getContextState(gl2);
   (0, import_api4.assert)(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);
     }
@@ -1456,33 +1457,33 @@ function installGetterOverride(gl, functionName) {
       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 } = setter(glState._updateCache, ...params);
     if (valueChanged) {
       originalSetterFunc(...params);
     }
     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;
@@ -1508,21 +1509,21 @@ function createBrowserContext(canvas, props) {
   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 = __spreadProps(__spreadValues({}, props), { webgl1: false });
   }
   if (props.type === "webgl1") {
     props = __spreadProps(__spreadValues({}, props), { 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"}`
     );
@@ -1539,29 +1540,29 @@ function createBrowserContext(canvas, props) {
       false
     );
   }
-  return gl;
+  return gl2;
 }
 
 // src/adapter/device-helpers/get-device-info.ts
 var import_constants4 = require("@luma.gl/constants");
-function getDeviceInfo(gl) {
-  const vendorMasked = gl.getParameter(import_constants4.GL.VENDOR);
-  const rendererMasked = gl.getParameter(import_constants4.GL.RENDERER);
-  const ext = gl.getExtension("WEBGL_debug_renderer_info");
-  const vendorUnmasked = gl.getParameter(ext ? ext.UNMASKED_VENDOR_WEBGL : import_constants4.GL.VENDOR);
-  const rendererUnmasked = gl.getParameter(ext ? ext.UNMASKED_RENDERER_WEBGL : import_constants4.GL.RENDERER);
+function getDeviceInfo(gl2) {
+  const vendorMasked = gl2.getParameter(import_constants4.GL.VENDOR);
+  const rendererMasked = gl2.getParameter(import_constants4.GL.RENDERER);
+  const ext = gl2.getExtension("WEBGL_debug_renderer_info");
+  const vendorUnmasked = gl2.getParameter(ext ? ext.UNMASKED_VENDOR_WEBGL : import_constants4.GL.VENDOR);
+  const rendererUnmasked = gl2.getParameter(ext ? ext.UNMASKED_RENDERER_WEBGL : import_constants4.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(import_constants4.GL.VERSION),
+    version: gl2.getParameter(import_constants4.GL.VERSION),
     shadingLanguages: ["glsl"],
     shadingLanguageVersions: {
-      "glsl": gl.getParameter(import_constants4.GL.SHADING_LANGUAGE_VERSION)
+      "glsl": gl2.getParameter(import_constants4.GL.SHADING_LANGUAGE_VERSION)
     }
   };
 }
@@ -1615,39 +1616,39 @@ var EXT_SRGB = "EXT_sRGB";
 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) {
+function checkTextureFeature(gl2, feature) {
   var _a;
-  return ((_a = TEXTURE_FEATURE_CHECKS[feature]) == null ? void 0 : _a.call(TEXTURE_FEATURE_CHECKS, gl)) || false;
+  return ((_a = TEXTURE_FEATURE_CHECKS[feature]) == null ? void 0 : _a.call(TEXTURE_FEATURE_CHECKS, 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.
@@ -1855,24 +1856,24 @@ var TYPE_SIZES = {
   [import_constants5.GL.BYTE]: 1,
   [import_constants5.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) {
+function isRenderbufferFormatSupported(gl2, format) {
   var _a;
-  return isTextureFormatSupported(gl, format) && ((_a = TEXTURE_FORMATS[format]) == null ? void 0 : _a.renderbuffer);
+  return isTextureFormatSupported(gl2, format) && ((_a = TEXTURE_FORMATS[format]) == null ? void 0 : _a.renderbuffer);
 }
 function convertGLToTextureFormat(format) {
   if (typeof format === "string") {
@@ -1894,9 +1895,9 @@ function convertTextureFormatToGL(format, isWebGL23) {
   }
   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 {
@@ -1908,16 +1909,16 @@ function isTextureFormatFilterable(gl, formatOrGL) {
     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") {
@@ -1949,19 +1950,19 @@ function getDepthStencilAttachmentWebGL(format) {
   }
   return info.attachment;
 }
-function _checkFloat32ColorAttachment(gl, internalFormat = gl.RGBA, srcFormat = import_constants5.GL.RGBA, srcType = import_constants5.GL.UNSIGNED_BYTE) {
+function _checkFloat32ColorAttachment(gl2, internalFormat = gl2.RGBA, srcFormat = import_constants5.GL.RGBA, srcType = import_constants5.GL.UNSIGNED_BYTE) {
   let texture = null;
   let framebuffer = null;
   try {
-    texture = gl.createTexture();
-    gl.bindTexture(import_constants5.GL.TEXTURE_2D, texture);
+    texture = gl2.createTexture();
+    gl2.bindTexture(import_constants5.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,
+    gl2.texImage2D(
+      gl2.TEXTURE_2D,
       level,
       internalFormat,
       width,
@@ -1971,15 +1972,15 @@ function _checkFloat32ColorAttachment(gl, internalFormat = gl.RGBA, srcFormat =
       srcType,
       pixel
     );
-    framebuffer = gl.createFramebuffer();
-    gl.bindFramebuffer(import_constants5.GL.FRAMEBUFFER, framebuffer);
-    gl.framebufferTexture2D(import_constants5.GL.FRAMEBUFFER, import_constants5.GL.COLOR_ATTACHMENT0, import_constants5.GL.TEXTURE_2D, texture, 0);
-    const status = gl.checkFramebufferStatus(import_constants5.GL.FRAMEBUFFER) === import_constants5.GL.FRAMEBUFFER_COMPLETE;
-    gl.bindTexture(import_constants5.GL.TEXTURE_2D, null);
+    framebuffer = gl2.createFramebuffer();
+    gl2.bindFramebuffer(import_constants5.GL.FRAMEBUFFER, framebuffer);
+    gl2.framebufferTexture2D(import_constants5.GL.FRAMEBUFFER, import_constants5.GL.COLOR_ATTACHMENT0, import_constants5.GL.TEXTURE_2D, texture, 0);
+    const status = gl2.checkFramebufferStatus(import_constants5.GL.FRAMEBUFFER) === import_constants5.GL.FRAMEBUFFER_COMPLETE;
+    gl2.bindTexture(import_constants5.GL.TEXTURE_2D, null);
     return status;
   } finally {
-    gl.deleteTexture(texture);
-    gl.deleteFramebuffer(framebuffer);
+    gl2.deleteTexture(texture);
+    gl2.deleteFramebuffer(framebuffer);
   }
 }
 function getTextureFormatBytesPerPixel(formatOrGL, isWebGL23) {
@@ -2030,50 +2031,50 @@ function getWebGLDataType(dataType) {
 }
 
 // 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, { behavior: "require" });
+      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;
   }
@@ -2083,14 +2084,14 @@ function canCompileGLSLExtension(gl, extensionName, opts = {}) {
   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;
 }
@@ -2128,38 +2129,38 @@ var WEBGL_FEATURES = {
 
 // src/adapter/device-helpers/device-limits.ts
 var import_constants6 = require("@luma.gl/constants");
-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(import_constants6.GL.MAX_TEXTURE_SIZE),
-    maxTextureDimension3D: gl2 ? gl2.getParameter(import_constants6.GL.MAX_3D_TEXTURE_SIZE) : 0,
-    maxTextureArrayLayers: gl2 ? gl2.getParameter(import_constants6.GL.MAX_ARRAY_TEXTURE_LAYERS) : 0,
+    maxTextureDimension2D: gl2.getParameter(import_constants6.GL.MAX_TEXTURE_SIZE),
+    maxTextureDimension3D: gl22 ? gl22.getParameter(import_constants6.GL.MAX_3D_TEXTURE_SIZE) : 0,
+    maxTextureArrayLayers: gl22 ? gl22.getParameter(import_constants6.GL.MAX_ARRAY_TEXTURE_LAYERS) : 0,
     maxBindGroups: 1,
     // TBD
     maxDynamicUniformBuffersPerPipelineLayout: 0,
     // TBD
     maxDynamicStorageBuffersPerPipelineLayout: 0,
     // TBD
-    maxSampledTexturesPerShaderStage: gl.getParameter(import_constants6.GL.MAX_VERTEX_TEXTURE_IMAGE_UNITS),
+    maxSampledTexturesPerShaderStage: gl2.getParameter(import_constants6.GL.MAX_VERTEX_TEXTURE_IMAGE_UNITS),
     // TBD
-    maxSamplersPerShaderStage: gl.getParameter(import_constants6.GL.MAX_COMBINED_TEXTURE_IMAGE_UNITS),
+    maxSamplersPerShaderStage: gl2.getParameter(import_constants6.GL.MAX_COMBINED_TEXTURE_IMAGE_UNITS),
     maxStorageBuffersPerShaderStage: 0,
     // TBD
     maxStorageTexturesPerShaderStage: 0,
     // TBD
-    maxUniformBuffersPerShaderStage: gl2 ? gl2.getParameter(import_constants6.GL.MAX_UNIFORM_BUFFER_BINDINGS) : 0,
-    maxUniformBufferBindingSize: gl2 ? gl2.getParameter(import_constants6.GL.MAX_UNIFORM_BLOCK_SIZE) : 0,
+    maxUniformBuffersPerShaderStage: gl22 ? gl22.getParameter(import_constants6.GL.MAX_UNIFORM_BUFFER_BINDINGS) : 0,
+    maxUniformBufferBindingSize: gl22 ? gl22.getParameter(import_constants6.GL.MAX_UNIFORM_BLOCK_SIZE) : 0,
     maxStorageBufferBindingSize: 0,
-    minUniformBufferOffsetAlignment: gl2 ? gl2.getParameter(import_constants6.GL.UNIFORM_BUFFER_OFFSET_ALIGNMENT) : 0,
+    minUniformBufferOffsetAlignment: gl22 ? gl22.getParameter(import_constants6.GL.UNIFORM_BUFFER_OFFSET_ALIGNMENT) : 0,
     minStorageBufferOffsetAlignment: 0,
     // TBD
     maxVertexBuffers: 0,
-    maxVertexAttributes: gl.getParameter(import_constants6.GL.MAX_VERTEX_ATTRIBS),
+    maxVertexAttributes: gl2.getParameter(import_constants6.GL.MAX_VERTEX_ATTRIBS),
     maxVertexBufferArrayStride: 2048,
     // TBD, this is just the default value from WebGPU
-    maxInterStageShaderComponents: gl2 ? gl2.getParameter(import_constants6.GL.MAX_VARYING_COMPONENTS) : 0,
+    maxInterStageShaderComponents: gl22 ? gl22.getParameter(import_constants6.GL.MAX_VARYING_COMPONENTS) : 0,
     maxComputeWorkgroupStorageSize: 0,
     // WebGL does not support compute shaders
     maxComputeInvocationsPerWorkgroup: 0,
@@ -2174,13 +2175,13 @@ function getDeviceLimits(gl) {
     // 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 {
     [import_constants6.GL.ALIASED_LINE_WIDTH_RANGE]: get(import_constants6.GL.ALIASED_LINE_WIDTH_RANGE),
@@ -2285,22 +2286,22 @@ var import_constants11 = require("@luma.gl/constants");
 // 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 (isObjectEmpty2(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;
@@ -2344,24 +2345,24 @@ function withDeviceParameters(device, parameters, func) {
 }
 function setDeviceParameters(device, parameters) {
   const webglDevice = WebGLDevice.attach(device);
-  const { gl } = webglDevice;
+  const { gl: gl2 } = webglDevice;
   if (parameters.cullMode) {
     switch (parameters.cullMode) {
       case "none":
-        gl.disable(import_constants7.GL.CULL_FACE);
+        gl2.disable(import_constants7.GL.CULL_FACE);
         break;
       case "front":
-        gl.enable(import_constants7.GL.CULL_FACE);
-        gl.cullFace(import_constants7.GL.FRONT);
+        gl2.enable(import_constants7.GL.CULL_FACE);
+        gl2.cullFace(import_constants7.GL.FRONT);
         break;
       case "back":
-        gl.enable(import_constants7.GL.CULL_FACE);
-        gl.cullFace(import_constants7.GL.BACK);
+        gl2.enable(import_constants7.GL.CULL_FACE);
+        gl2.cullFace(import_constants7.GL.BACK);
         break;
     }
   }
   if (parameters.frontFace) {
-    gl.frontFace(
+    gl2.frontFace(
       map("frontFace", parameters.frontFace, {
         ccw: import_constants7.GL.CCW,
         cw: import_constants7.GL.CW
@@ -2369,19 +2370,19 @@ function setDeviceParameters(device, parameters) {
     );
   }
   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(import_constants7.GL.DEPTH_TEST) : gl.disable(import_constants7.GL.DEPTH_TEST);
-    gl.depthFunc(convertCompareFunction("depthCompare", parameters.depthCompare));
+    parameters.depthCompare !== "always" ? gl2.enable(import_constants7.GL.DEPTH_TEST) : gl2.disable(import_constants7.GL.DEPTH_TEST);
+    gl2.depthFunc(convertCompareFunction("depthCompare", parameters.depthCompare));
   }
   if (parameters.stencilWriteMask) {
     const mask = parameters.stencilWriteMask;
-    gl.stencilMaskSeparate(import_constants7.GL.FRONT, mask);
-    gl.stencilMaskSeparate(import_constants7.GL.BACK, mask);
+    gl2.stencilMaskSeparate(import_constants7.GL.FRONT, mask);
+    gl2.stencilMaskSeparate(import_constants7.GL.BACK, mask);
   }
   if (parameters.stencilReadMask) {
     import_api6.log.warn("stencilReadMask not supported under WebGL");
@@ -2389,9 +2390,9 @@ function setDeviceParameters(device, parameters) {
   if (parameters.stencilCompare) {
     const mask = parameters.stencilReadMask || 4294967295;
     const glValue = convertCompareFunction("depthCompare", parameters.stencilCompare);
-    parameters.stencilCompare !== "always" ? gl.enable(import_constants7.GL.STENCIL_TEST) : gl.disable(import_constants7.GL.STENCIL_TEST);
-    gl.stencilFuncSeparate(import_constants7.GL.FRONT, glValue, 0, mask);
-    gl.stencilFuncSeparate(import_constants7.GL.BACK, glValue, 0, mask);
+    parameters.stencilCompare !== "always" ? gl2.enable(import_constants7.GL.STENCIL_TEST) : gl2.disable(import_constants7.GL.STENCIL_TEST);
+    gl2.stencilFuncSeparate(import_constants7.GL.FRONT, glValue, 0, mask);
+    gl2.stencilFuncSeparate(import_constants7.GL.BACK, glValue, 0, mask);
   }
   if (parameters.stencilPassOperation && parameters.stencilFailOperation && parameters.stencilDepthFailOperation) {
     const dppass = convertStencilOperation("stencilPassOperation", parameters.stencilPassOperation);
@@ -2400,8 +2401,8 @@ function setDeviceParameters(device, parameters) {
       "stencilDepthFailOperation",
       parameters.stencilDepthFailOperation
     );
-    gl.stencilOpSeparate(import_constants7.GL.FRONT, sfail, dpfail, dppass);
-    gl.stencilOpSeparate(import_constants7.GL.BACK, sfail, dpfail, dppass);
+    gl2.stencilOpSeparate(import_constants7.GL.FRONT, sfail, dpfail, dppass);
+    gl2.stencilOpSeparate(import_constants7.GL.BACK, sfail, dpfail, dppass);
   }
 }
 function convertCompareFunction(parameter, value) {
@@ -2947,18 +2948,18 @@ var _WEBGLTexture = class extends import_api10.Texture {
       width,
       height
     }));
-    const { gl } = this;
-    gl.bindTexture(this.target, this.handle);
+    const { gl: gl2 } = this;
+    gl2.bindTexture(this.target, this.handle);
     let dataType = null;
     ({ data, dataType } = this._getDataType({ 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,
@@ -2974,9 +2975,9 @@ var _WEBGLTexture = class extends import_api10.Texture {
           );
           break;
         case "buffer":
-          gl2 = this.device.assertWebGL2();
-          gl2.bindBuffer(import_constants11.GL.PIXEL_UNPACK_BUFFER, data.handle || data);
-          gl2.texImage2D(
+          gl22 = this.device.assertWebGL2();
+          gl22.bindBuffer(import_constants11.GL.PIXEL_UNPACK_BUFFER, data.handle || data);
+          gl22.texImage2D(
             target,
             level,
             glFormat,
@@ -2987,11 +2988,11 @@ var _WEBGLTexture = class extends import_api10.Texture {
             type,
             offset
           );
-          gl2.bindBuffer(import_constants11.GL.PIXEL_UNPACK_BUFFER, null);
+          gl22.bindBuffer(import_constants11.GL.PIXEL_UNPACK_BUFFER, null);
           break;
         case "browser-object":
           if (this.device.isWebGL2) {
-            gl.texImage2D(
+            gl2.texImage2D(
               target,
               level,
               glFormat,
@@ -3003,12 +3004,12 @@ var _WEBGLTexture = class extends import_api10.Texture {
               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(
+            gl2.compressedTexImage2D(
               target,
               levelIndex,
               levelData.format,
@@ -3115,21 +3116,21 @@ var _WEBGLTexture = class extends import_api10.Texture {
     return this.gl.getParameter(import_constants11.GL.ACTIVE_TEXTURE) - import_constants11.GL.TEXTURE0;
   }
   bind(textureUnit = this.textureUnit) {
-    const { gl } = this;
+    const { 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 } = this;
+    const { 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
@@ -3195,7 +3196,7 @@ var _WEBGLTexture = class extends import_api10.Texture {
   /* eslint-disable max-statements, max-len */
   setCubeMapImageData(options) {
     return __async(this, null, function* () {
-      const { gl } = this;
+      const { gl: gl2 } = this;
       const { width, height, pixels, data, format = import_constants11.GL.RGBA, type = import_constants11.GL.UNSIGNED_BYTE } = options;
       const imageDataMap = pixels || data;
       const resolvedFaces = yield Promise.all(
@@ -3211,9 +3212,9 @@ var _WEBGLTexture = class extends import_api10.Texture {
         }
         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);
           }
         });
       });
@@ -3232,7 +3233,7 @@ var _WEBGLTexture = class extends import_api10.Texture {
       type = import_constants11.GL.UNSIGNED_BYTE
       // generateMipmap = false // TODO
     } = options;
-    const { gl } = this;
+    const { gl: gl2 } = this;
     const imageData = pixels || data;
     this.bind();
     if (imageData instanceof Promise) {
@@ -3246,9 +3247,9 @@ var _WEBGLTexture = class extends import_api10.Texture {
         )
       );
     } 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;
   }
@@ -3406,7 +3407,7 @@ var import_api12 = require("@luma.gl/api");
 
 // src/adapter/objects/constants-to-keys.ts
 var import_api11 = require("@luma.gl/api");
-function getKeyValue(gl, name) {
+function getKeyValue(gl2, name) {
   if (typeof name !== "string") {
     return name;
   }
@@ -3415,7 +3416,7 @@ function getKeyValue(gl, name) {
     return number;
   }
   name = name.replace(/^.*\./, "");
-  const value = gl[name];
+  const value = gl2[name];
   (0, import_api11.assert)(value !== void 0, `Accessing undefined constant GL.${name}`);
   return value;
 }
@@ -3429,11 +3430,11 @@ var WebGLResource = class extends import_api12.Resource {
     // Only meaningful for resources that allocate GPU memory
     this.byteLength = 0;
     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 || (0, import_api12.uid)(this.constructor.name);
     this._handle = props == null ? void 0 : props.handle;
     if (this._handle === void 0) {
@@ -3744,11 +3745,11 @@ var WEBGLFramebuffer = class extends import_api14.Framebuffer {
   // PRIVATE
   /** Check the status */
   _checkStatus() {
-    const { gl } = this;
-    const prevHandle2 = gl.bindFramebuffer(import_constants13.GL.FRAMEBUFFER, this.handle);
-    const status = gl.checkFramebufferStatus(import_constants13.GL.FRAMEBUFFER);
-    gl.bindFramebuffer(import_constants13.GL.FRAMEBUFFER, prevHandle2 || null);
-    if (status !== gl.FRAMEBUFFER_COMPLETE) {
+    const { gl: gl2 } = this;
+    const prevHandle2 = gl2.bindFramebuffer(import_constants13.GL.FRAMEBUFFER, this.handle);
+    const status = gl2.checkFramebufferStatus(import_constants13.GL.FRAMEBUFFER);
+    gl2.bindFramebuffer(import_constants13.GL.FRAMEBUFFER, prevHandle2 || null);
+    if (status !== gl2.FRAMEBUFFER_COMPLETE) {
       throw new Error(`Framebuffer ${_getFrameBufferStatus(status)}`);
     }
   }
@@ -3817,25 +3818,25 @@ var WEBGLFramebuffer = class extends import_api14.Framebuffer {
    * @param level  = 0 - mipmapLevel (must be 0 in WebGL1)
    */
   _attachTexture(attachment, texture, layer, level) {
-    const { gl, gl2 } = this.device;
-    gl.bindTexture(texture.target, texture.handle);
+    const { gl: gl2, gl2: gl22 } = this.device;
+    gl2.bindTexture(texture.target, texture.handle);
     switch (texture.target) {
       case import_constants13.GL.TEXTURE_2D_ARRAY:
       case import_constants13.GL.TEXTURE_3D:
         this.device.assertWebGL2();
-        gl2 == null ? void 0 : gl2.framebufferTextureLayer(import_constants13.GL.FRAMEBUFFER, attachment, texture.target, level, layer);
+        gl22 == null ? void 0 : gl22.framebufferTextureLayer(import_constants13.GL.FRAMEBUFFER, attachment, texture.target, level, layer);
         break;
       case import_constants13.GL.TEXTURE_CUBE_MAP:
         const face = mapIndexToCubeMapFace(layer);
-        gl.framebufferTexture2D(import_constants13.GL.FRAMEBUFFER, attachment, face, texture.handle, level);
+        gl2.framebufferTexture2D(import_constants13.GL.FRAMEBUFFER, attachment, face, texture.handle, level);
         break;
       case import_constants13.GL.TEXTURE_2D:
-        gl.framebufferTexture2D(import_constants13.GL.FRAMEBUFFER, attachment, import_constants13.GL.TEXTURE_2D, texture.handle, level);
+        gl2.framebufferTexture2D(import_constants13.GL.FRAMEBUFFER, attachment, import_constants13.GL.TEXTURE_2D, texture.handle, level);
         break;
       default:
         (0, import_api14.assert)(false, "Illegal texture type");
     }
-    gl.bindTexture(texture.target, null);
+    gl2.bindTexture(texture.target, null);
   }
 };
 function mapIndexToCubeMapFace(layer) {
@@ -3897,6 +3898,7 @@ var WebGLCanvasContext = class extends import_api15.CanvasContext {
    */
   resize(options) {
     if (this.canvas) {
+      const devicePixelRatio = this.getDevicePixelRatio(options == null ? void 0 : options.useDevicePixels);
       this.setDevicePixelRatio(devicePixelRatio, options);
       return;
     }
@@ -3972,9 +3974,9 @@ function initializeSpectorJS(props) {
 var import_api17 = require("@luma.gl/api");
 var import_constants14 = require("@luma.gl/constants");
 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;
 }
 function loadWebGLDeveloperTools() {
   return __async(this, null, function* () {
@@ -3985,28 +3987,28 @@ function loadWebGLDeveloperTools() {
     }
   });
 }
-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) {
     import_api17.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(__spreadValues(__spreadValues({}, import_constants14.GL), gl));
+  globalThis.WebGLDebugUtils.init(__spreadValues(__spreadValues({}, import_constants14.GL), gl2));
   const glDebug = globalThis.WebGLDebugUtils.makeDebugContext(
-    gl,
+    gl2,
     onGLError.bind(null, props),
     onValidateGLFunc.bind(null, props)
   );
@@ -4017,10 +4019,10 @@ function getDebugContext(gl, props) {
   }
   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;
@@ -4390,13 +4392,13 @@ var BufferWithAccessor = class extends WEBGLBuffer {
    */
   copyData(options) {
     const { sourceBuffer, readOffset = 0, writeOffset = 0, size } = options;
-    const { gl, gl2 } = this;
-    assertWebGL2Context(gl);
-    gl.bindBuffer(import_constants17.GL.COPY_READ_BUFFER, sourceBuffer.handle);
-    gl.bindBuffer(import_constants17.GL.COPY_WRITE_BUFFER, this.handle);
-    gl2 == null ? void 0 : gl2.copyBufferSubData(import_constants17.GL.COPY_READ_BUFFER, import_constants17.GL.COPY_WRITE_BUFFER, readOffset, writeOffset, size);
-    gl.bindBuffer(import_constants17.GL.COPY_READ_BUFFER, null);
-    gl.bindBuffer(import_constants17.GL.COPY_WRITE_BUFFER, null);
+    const { gl: gl2, gl2: gl22 } = this;
+    assertWebGL2Context(gl2);
+    gl2.bindBuffer(import_constants17.GL.COPY_READ_BUFFER, sourceBuffer.handle);
+    gl2.bindBuffer(import_constants17.GL.COPY_WRITE_BUFFER, this.handle);
+    gl22 == null ? void 0 : gl22.copyBufferSubData(import_constants17.GL.COPY_READ_BUFFER, import_constants17.GL.COPY_WRITE_BUFFER, readOffset, writeOffset, size);
+    gl2.bindBuffer(import_constants17.GL.COPY_READ_BUFFER, null);
+    gl2.bindBuffer(import_constants17.GL.COPY_WRITE_BUFFER, null);
     this.debugData = null;
     return this;
   }
@@ -4650,12 +4652,12 @@ var WEBGLShader = class extends import_api20.Shader {
     const addGLSLVersion = (source2) => source2.startsWith("#version ") ? source2 : `#version 100
 ${source2}`;
     source = addGLSLVersion(source);
-    const { gl } = this.device;
-    gl.shaderSource(this.handle, source);
-    gl.compileShader(this.handle);
-    const compileStatus = gl.getShaderParameter(this.handle, import_constants18.GL.COMPILE_STATUS);
+    const { gl: gl2 } = this.device;
+    gl2.shaderSource(this.handle, source);
+    gl2.compileShader(this.handle);
+    const compileStatus = gl2.getShaderParameter(this.handle, import_constants18.GL.COMPILE_STATUS);
     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 = (0, import_api20.formatCompilerLog)(messages, source);
@@ -4904,9 +4906,9 @@ function getDataFormat(type) {
 }
 
 // src/adapter/helpers/get-shader-layout.ts
-function getShaderLayout(gl, program) {
+function getShaderLayout(gl2, program) {
   var _a, _b;
-  const programBindings = getProgramBindings(gl, program);
+  const programBindings = getProgramBindings(gl2, program);
   const shaderLayout = {
     attributes: [],
     bindings: []
@@ -4965,26 +4967,26 @@ function getShaderLayout(gl, program) {
   }
   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");
     }
     const { name, type: compositeType, size } = activeInfo;
-    const location = gl.getAttribLocation(program, name);
+    const location = gl2.getAttribLocation(program, name);
     if (location >= 0) {
       const { glType, components } = decodeAttributeType(compositeType);
       const accessor = { type: glType, size: size * components };
@@ -4998,15 +5000,15 @@ function readAttributeBindings(gl, program) {
   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, import_constants22.GL.TRANSFORM_FEEDBACK_VARYINGS);
+  const count = gl2.getProgramParameter(program, import_constants22.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");
     }
@@ -5019,17 +5021,17 @@ function readVaryings(gl, program) {
   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, import_constants22.GL.ACTIVE_UNIFORMS);
+  const uniformCount = gl2.getProgramParameter(program, import_constants22.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");
     }
     const { name: rawName, size, type } = activeInfo;
     const { 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,
@@ -5042,7 +5044,7 @@ function readUniformBindings(gl, program) {
     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 = __spreadProps(__spreadValues({}, uniformInfo), {
           name: elementName,
           location: webglLocation
@@ -5053,17 +5055,17 @@ function readUniformBindings(gl, program) {
   }
   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, import_constants22.GL.ACTIVE_UNIFORM_BLOCKS);
+  const blockCount = gl22.getProgramParameter(program, import_constants22.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, import_constants22.GL.UNIFORM_BLOCK_BINDING),
       byteLength: getBlockParameter(blockIndex, import_constants22.GL.UNIFORM_BLOCK_DATA_SIZE),
       vertex: getBlockParameter(blockIndex, import_constants22.GL.UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER),
@@ -5072,12 +5074,12 @@ function readUniformBlocks(gl, program) {
       uniforms: []
     };
     const uniformIndices = getBlockParameter(blockIndex, import_constants22.GL.UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES) || [];
-    const uniformType = gl2.getActiveUniforms(program, uniformIndices, import_constants22.GL.UNIFORM_TYPE);
-    const uniformArrayLength = gl2.getActiveUniforms(program, uniformIndices, import_constants22.GL.UNIFORM_SIZE);
-    const uniformOffset = gl2.getActiveUniforms(program, uniformIndices, import_constants22.GL.UNIFORM_OFFSET);
-    const uniformStride = gl2.getActiveUniforms(program, uniformIndices, import_constants22.GL.UNIFORM_ARRAY_STRIDE);
+    const uniformType = gl22.getActiveUniforms(program, uniformIndices, import_constants22.GL.UNIFORM_TYPE);
+    const uniformArrayLength = gl22.getActiveUniforms(program, uniformIndices, import_constants22.GL.UNIFORM_SIZE);
+    const uniformOffset = gl22.getActiveUniforms(program, uniformIndices, import_constants22.GL.UNIFORM_OFFSET);
+    const uniformStride = gl22.getActiveUniforms(program, uniformIndices, import_constants22.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");
       }
@@ -5144,8 +5146,8 @@ function parseUniformName(name) {
 
 // src/adapter/helpers/set-uniform.ts
 var import_constants23 = require("@luma.gl/constants");
-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 import_constants23.GL.SAMPLER_2D:
@@ -5163,7 +5165,7 @@ function setUniform(gl, location, type, value) {
       case import_constants23.GL.UNSIGNED_INT_SAMPLER_3D:
       case import_constants23.GL.UNSIGNED_INT_SAMPLER_CUBE:
       case import_constants23.GL.UNSIGNED_INT_SAMPLER_2D_ARRAY:
-        return gl.uniform1i(location, value);
+        return gl2.uniform1i(location, value);
     }
   }
   if (value === true) {
@@ -5175,55 +5177,55 @@ function setUniform(gl, location, type, value) {
   const arrayValue = typeof value === "number" ? [value] : value;
   switch (type) {
     case import_constants23.GL.FLOAT:
-      return gl.uniform1fv(location, arrayValue);
+      return gl2.uniform1fv(location, arrayValue);
     case import_constants23.GL.FLOAT_VEC2:
-      return gl.uniform2fv(location, arrayValue);
+      return gl2.uniform2fv(location, arrayValue);
     case import_constants23.GL.FLOAT_VEC3:
-      return gl.uniform3fv(location, arrayValue);
+      return gl2.uniform3fv(location, arrayValue);
     case import_constants23.GL.FLOAT_VEC4:
-      return gl.uniform4fv(location, arrayValue);
+      return gl2.uniform4fv(location, arrayValue);
     case import_constants23.GL.INT:
-      return gl.uniform1iv(location, arrayValue);
+      return gl2.uniform1iv(location, arrayValue);
     case import_constants23.GL.INT_VEC2:
-      return gl.uniform2iv(location, arrayValue);
+      return gl2.uniform2iv(location, arrayValue);
     case import_constants23.GL.INT_VEC3:
-      return gl.uniform3iv(location, arrayValue);
+      return gl2.uniform3iv(location, arrayValue);
     case import_constants23.GL.INT_VEC4:
-      return gl.uniform4iv(location, arrayValue);
+      return gl2.uniform4iv(location, arrayValue);
     case import_constants23.GL.BOOL:
-      return gl.uniform1iv(location, arrayValue);
+      return gl2.uniform1iv(location, arrayValue);
     case import_constants23.GL.BOOL_VEC2:
-      return gl.uniform2iv(location, arrayValue);
+      return gl2.uniform2iv(location, arrayValue);
     case import_constants23.GL.BOOL_VEC3:
-      return gl.uniform3iv(location, arrayValue);
+      return gl2.uniform3iv(location, arrayValue);
     case import_constants23.GL.BOOL_VEC4:
-      return gl.uniform4iv(location, arrayValue);
+      return gl2.uniform4iv(location, arrayValue);
     case import_constants23.GL.UNSIGNED_INT:
-      return gl2.uniform1uiv(location, arrayValue, 1);
+      return gl22.uniform1uiv(location, arrayValue, 1);
     case import_constants23.GL.UNSIGNED_INT_VEC2:
-      return gl2.uniform2uiv(location, arrayValue, 2);
+      return gl22.uniform2uiv(location, arrayValue, 2);
     case import_constants23.GL.UNSIGNED_INT_VEC3:
-      return gl2.uniform3uiv(location, arrayValue, 3);
+      return gl22.uniform3uiv(location, arrayValue, 3);
     case import_constants23.GL.UNSIGNED_INT_VEC4:
-      return gl2.uniform4uiv(location, arrayValue, 4);
+      return gl22.uniform4uiv(location, arrayValue, 4);
     case import_constants23.GL.FLOAT_MAT2:
-      return gl.uniformMatrix2fv(location, false, arrayValue);
+      return gl2.uniformMatrix2fv(location, false, arrayValue);
     case import_constants23.GL.FLOAT_MAT3:
-      return gl.uniformMatrix3fv(location, false, arrayValue);
+      return gl2.uniformMatrix3fv(location, false, arrayValue);
     case import_constants23.GL.FLOAT_MAT4:
-      return gl.uniformMatrix4fv(location, false, arrayValue);
+      return gl2.uniformMatrix4fv(location, false, arrayValue);
     case import_constants23.GL.FLOAT_MAT2x3:
-      return gl2.uniformMatrix2x3fv(location, false, arrayValue);
+      return gl22.uniformMatrix2x3fv(location, false, arrayValue);
     case import_constants23.GL.FLOAT_MAT2x4:
-      return gl2.uniformMatrix2x4fv(location, false, arrayValue);
+      return gl22.uniformMatrix2x4fv(location, false, arrayValue);
     case import_constants23.GL.FLOAT_MAT3x2:
-      return gl2.uniformMatrix3x2fv(location, false, arrayValue);
+      return gl22.uniformMatrix3x2fv(location, false, arrayValue);
     case import_constants23.GL.FLOAT_MAT3x4:
-      return gl2.uniformMatrix3x4fv(location, false, arrayValue);
+      return gl22.uniformMatrix3x4fv(location, false, arrayValue);
     case import_constants23.GL.FLOAT_MAT4x2:
-      return gl2.uniformMatrix4x2fv(location, false, arrayValue);
+      return gl22.uniformMatrix4x2fv(location, false, arrayValue);
     case import_constants23.GL.FLOAT_MAT4x3:
-      return gl2.uniformMatrix4x3fv(location, false, arrayValue);
+      return gl22.uniformMatrix4x3fv(location, false, arrayValue);
   }
   throw new Error("Illegal uniform");
 }
@@ -5234,11 +5236,26 @@ var import_constants24 = require("@luma.gl/constants");
 var import_env = require("@probe.gl/env");
 var ERR_ELEMENTS = "elements must be GL.ELEMENT_ARRAY_BUFFER";
 var WEBGLVertexArrayObject = class extends WebGLResource {
+  // Create a VertexArray
+  constructor(device, props) {
+    super(device, props, __spreadProps(__spreadValues({}, import_api22.Resource.defaultProps), { constantAttributeZero: false }));
+    /** Buffer constant */
+    this.buffer = null;
+    this.bufferValue = null;
+    Object.seal(this);
+  }
   get [Symbol.toStringTag]() {
     return "BaseVertexArrayObject";
   }
-  constructor(device, props) {
-    super(device, props, {});
+  static isConstantAttributeZeroSupported(device) {
+    return device.info.type === "webgl2" || (0, import_env.getBrowser)() === "Chrome";
+  }
+  destroy() {
+    var _a;
+    super.destroy();
+    if (this.buffer) {
+      (_a = this.buffer) == null ? void 0 : _a.destroy();
+    }
   }
   _createHandle() {
     return this.gl2.createVertexArray();
@@ -5250,6 +5267,22 @@ var WEBGLVertexArrayObject = class extends WebGLResource {
   _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 || (0, import_env.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 = {}) {
@@ -5257,47 +5290,122 @@ var WEBGLVertexArrayObject = class extends WebGLResource {
     this.bind(() => {
       this.gl.bindBuffer(import_constants24.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 === import_constants24.GL.ELEMENT_ARRAY_BUFFER) {
-      return this.setElementBuffer(buffer, accessor);
+      this.setElementBuffer(buffer, accessor);
+      return;
     }
     const { size, type, stride, offset, normalized, integer, divisor } = accessor;
-    const { gl, gl2 } = this;
+    const { 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 || (0, import_env.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:
+        (0, import_api22.assert)(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 = (0, import_api22.getScratchArray)(value.constructor, length);
+      (0, import_api22.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:
+      (0, import_api22.assert)(false);
+  }
+}
+function setConstantIntArray(device, location, array) {
+  var _a;
+  device.assertWebGL2();
+  (_a = device.gl2) == null ? void 0 : _a.vertexAttribI4iv(location, array);
+}
+function setConstantUintArray(device, location, array) {
+  var _a;
+  device.assertWebGL2();
+  (_a = device.gl2) == null ? void 0 : _a.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;
@@ -5365,7 +5473,26 @@ var WEBGLRenderPipeline = class extends import_api23.RenderPipeline {
       });
     }
   }
-  /** @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) {
+        import_api23.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);
@@ -5462,21 +5589,21 @@ var WEBGLRenderPipeline = class extends import_api23.RenderPipeline {
   // setAttributes(attributes: Record<string, Buffer>): void {}
   // setBindings(bindings: Record<string, Binding>): void {}
   _compileAndLink() {
-    const { gl } = this.device;
-    gl.attachShader(this.handle, this.vs.handle);
-    gl.attachShader(this.handle, this.fs.handle);
+    const { gl: gl2 } = this.device;
+    gl2.attachShader(this.handle, this.vs.handle);
+    gl2.attachShader(this.handle, this.fs.handle);
     import_api23.log.time(LOG_PROGRAM_PERF_PRIORITY, `linkProgram for ${this.id}`)();
-    gl.linkProgram(this.handle);
+    gl2.linkProgram(this.handle);
     import_api23.log.timeEnd(LOG_PROGRAM_PERF_PRIORITY, `linkProgram for ${this.id}`)();
-    if (gl.debug || import_api23.log.level > 0) {
-      const linked = gl.getProgramParameter(this.handle, gl.LINK_STATUS);
+    if (gl2.debug || import_api23.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)}`);
       }
     }
   }
@@ -5882,13 +6009,13 @@ var _WebGLDevice = class extends import_api26.Device {
         message: "Computer entered sleep mode, or too many apps or browser tabs are using the GPU."
       });
     };
-    let gl = props.gl || null;
-    gl = gl || ((0, import_env2.isBrowser)() ? createBrowserContext(this.canvasContext.canvas, __spreadProps(__spreadValues({}, props), { onContextLost })) : null);
-    gl = gl || (!(0, import_env2.isBrowser)() ? createHeadlessContext(__spreadProps(__spreadValues({}, props), { onContextLost })) : null);
-    if (!gl) {
+    let gl2 = props.gl || null;
+    gl2 = gl2 || ((0, import_env2.isBrowser)() ? createBrowserContext(this.canvasContext.canvas, __spreadProps(__spreadValues({}, props), { onContextLost })) : null);
+    gl2 = gl2 || (!(0, import_env2.isBrowser)() ? createHeadlessContext(__spreadProps(__spreadValues({}, props), { onContextLost })) : null);
+    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);
@@ -5938,17 +6065,17 @@ var _WebGLDevice = class extends import_api26.Device {
    * @param gl
    * @returns
    */
-  static attach(gl) {
-    if (gl instanceof _WebGLDevice) {
-      return gl;
+  static attach(gl2) {
+    if (gl2 instanceof _WebGLDevice) {
+      return gl2;
     }
-    if ((gl == null ? void 0 : gl.device) instanceof import_api26.Device) {
-      return gl.device;
+    if ((gl2 == null ? void 0 : gl2.device) instanceof import_api26.Device) {
+      return gl2.device;
     }
-    if (!isWebGL3(gl)) {
+    if (!isWebGL3(gl2)) {
       throw new Error("Invalid WebGLRenderingContext");
     }
-    return new _WebGLDevice({ gl });
+    return new _WebGLDevice({ gl: gl2 });
   }
   static create() {
     return __async(this, arguments, function* (props = {}) {
@@ -6099,11 +6226,11 @@ var _WebGLDevice = class extends import_api26.Device {
    * 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}`;
       }
     }
@@ -6115,20 +6242,20 @@ var WebGLDevice = _WebGLDevice;
 // Public `Device` API
 //
 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
@@ -6137,8 +6264,8 @@ var GL_DEPTH_BUFFER_BIT2 = 256;
 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, depth = null, stencil = null } = options || {};
   const parameters = {};
   if (framebuffer) {
@@ -6226,7 +6353,7 @@ function readPixelsToArray(source, options) {
   } = options || {};
   const { framebuffer, deleteFramebuffer } = getFramebuffer2(source);
   (0, import_api29.assert)(framebuffer);
-  const { gl, handle } = framebuffer;
+  const { gl: gl2, handle } = framebuffer;
   sourceWidth = sourceWidth || framebuffer.width;
   sourceHeight = sourceHeight || framebuffer.height;
   if (sourceAttachment === import_constants28.GL.COLOR_ATTACHMENT0 && handle === null) {
@@ -6236,9 +6363,9 @@ function readPixelsToArray(source, options) {
   sourceType = sourceType || framebuffer.colorAttachments[attachment].type;
   target = getPixelArray(target, sourceType, sourceFormat, sourceWidth, sourceHeight);
   sourceType = sourceType || getGLTypeFromTypedArray(target);
-  const prevHandle2 = gl.bindFramebuffer(import_constants28.GL.FRAMEBUFFER, handle);
-  gl.readPixels(sourceX, sourceY, sourceWidth, sourceHeight, sourceFormat, sourceType, target);
-  gl.bindFramebuffer(import_constants28.GL.FRAMEBUFFER, prevHandle2 || null);
+  const prevHandle2 = gl2.bindFramebuffer(import_constants28.GL.FRAMEBUFFER, handle);
+  gl2.readPixels(sourceX, sourceY, sourceWidth, sourceHeight, sourceFormat, sourceType, target);
+  gl2.bindFramebuffer(import_constants28.GL.FRAMEBUFFER, prevHandle2 || null);
   if (deleteFramebuffer) {
     framebuffer.destroy();
   }
@@ -6278,6 +6405,98 @@ function readPixelsToBuffer(source, options) {
   }
   return target;
 }
+function copyToTexture(source, target, options) {
+  const {
+    sourceX = 0,
+    sourceY = 0,
+    // attachment = GL.COLOR_ATTACHMENT0, // TODO - support gl.readBuffer
+    targetMipmaplevel = 0,
+    targetInternalFormat = import_constants28.GL.RGBA
+  } = options || {};
+  let {
+    targetX,
+    targetY,
+    targetZ,
+    width,
+    // defaults to target width
+    height
+    // defaults to target height
+  } = options || {};
+  const { framebuffer, deleteFramebuffer } = getFramebuffer2(source);
+  (0, import_api29.assert)(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(import_constants28.GL.FRAMEBUFFER, handle);
+  (0, import_api29.assert)(target);
+  let texture = null;
+  let textureTarget;
+  if (target instanceof import_api29.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 import_constants28.GL.TEXTURE_2D:
+      case import_constants28.GL.TEXTURE_CUBE_MAP:
+        device.gl.copyTexSubImage2D(
+          textureTarget,
+          targetMipmaplevel,
+          targetX,
+          targetY,
+          sourceX,
+          sourceY,
+          width,
+          height
+        );
+        break;
+      case import_constants28.GL.TEXTURE_2D_ARRAY:
+      case import_constants28.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(import_constants28.GL.FRAMEBUFFER, prevHandle2 || null);
+  if (deleteFramebuffer) {
+    framebuffer.destroy();
+  }
+  return texture;
+}
 function getFramebuffer2(source) {
   if (!(source instanceof import_api29.Framebuffer)) {
     return { framebuffer: toFramebuffer(source), deleteFramebuffer: true };