@luma.gl/webgl 9.0.0-alpha.34 → 9.0.0-alpha.36

package/dist/index.cjs

@@ -20,8 +20,8 @@ var __spreadValues = (a, b) => {
 };
 var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
 var __export = (target, all) => {
-  for (var name2 in all)
-    __defProp(target, name2, { get: all[name2], enumerable: true });
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
 };
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
@@ -68,7 +68,7 @@ __export(src_exports, {
   WEBGLSampler: () => WEBGLSampler,
   WEBGLShader: () => WEBGLShader,
   WEBGLTexture: () => WEBGLTexture,
-  WEBGLVertexArrayObject: () => WEBGLVertexArrayObject,
+  WEBGLVertexArray: () => WEBGLVertexArray,
   WebGLCanvasContext: () => WebGLCanvasContext,
   WebGLDevice: () => WebGLDevice,
   WebGLResource: () => WebGLResource,
@@ -79,7 +79,7 @@ __export(src_exports, {
   clear: () => clear,
   convertGLToTextureFormat: () => convertGLToTextureFormat,
   copyToTexture: () => copyToTexture,
-  getParameters: () => getParameters,
+  getGLParameters: () => getGLParameters,
   getShaderLayout: () => getShaderLayout,
   getWebGL2Context: () => getWebGL2Context,
   isWebGL: () => isWebGL,
@@ -90,12 +90,12 @@ __export(src_exports, {
   readPixelsToArray: () => readPixelsToArray,
   readPixelsToBuffer: () => readPixelsToBuffer,
   registerHeadlessGL: () => registerHeadlessGL,
-  resetParameters: () => resetParameters,
+  resetGLParameters: () => resetGLParameters,
   setDeviceParameters: () => setDeviceParameters,
-  setParameters: () => setParameters,
+  setGLParameters: () => setGLParameters,
   trackContextState: () => trackContextState,
   withDeviceParameters: () => withDeviceParameters,
-  withParameters: () => withParameters
+  withGLParameters: () => withGLParameters
 });
 module.exports = __toCommonJS(src_exports);
 
@@ -124,11 +124,11 @@ function createHeadlessContext(options) {
   if (!headlessGL) {
     throw new Error(ERR_HEADLESSGL_LOAD);
   }
-  const gl2 = headlessGL(width, height, options);
-  if (!gl2) {
+  const gl = headlessGL(width, height, options);
+  if (!gl) {
     throw new Error(ERR_HEADLESSGL_FAILED);
   }
-  return gl2;
+  return gl;
 }
 
 // src/adapter/webgl-device.ts
@@ -156,43 +156,43 @@ function synthesizeGLError(err, opt_msg) {
     error(opt_msg);
   }
 }
-function wrapGLError(gl2) {
-  const f = gl2.getError;
-  gl2.getError = function getError() {
+function wrapGLError(gl) {
+  const f = gl.getError;
+  gl.getError = function getError() {
     let err;
     do {
-      err = f.apply(gl2);
-      if (err !== gl2.NO_ERROR) {
+      err = f.apply(gl);
+      if (err !== gl.NO_ERROR) {
         glErrorShadow[err] = true;
       }
-    } while (err !== gl2.NO_ERROR);
+    } while (err !== gl.NO_ERROR);
     for (err in glErrorShadow) {
       if (glErrorShadow[err]) {
         delete glErrorShadow[err];
         return parseInt(err, 10);
       }
     }
-    return gl2.NO_ERROR;
+    return gl.NO_ERROR;
   };
 }
 var WebGLVertexArrayObjectOES = function WebGLVertexArrayObjectOES2(ext) {
-  const gl2 = ext.gl;
+  const gl = 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(gl2);
+    const attrib = new WebGLVertexArrayObjectOES2.VertexAttrib(gl);
     this.attribs[n] = attrib;
   }
   this.maxAttrib = 0;
 };
-WebGLVertexArrayObjectOES.VertexAttrib = function VertexAttrib(gl2) {
+WebGLVertexArrayObjectOES.VertexAttrib = function VertexAttrib(gl) {
   this.enabled = false;
   this.buffer = null;
   this.size = 4;
-  this.type = gl2.FLOAT;
+  this.type = gl.FLOAT;
   this.normalized = false;
   this.stride = 16;
   this.offset = 0;
@@ -202,19 +202,19 @@ WebGLVertexArrayObjectOES.VertexAttrib = function VertexAttrib(gl2) {
 WebGLVertexArrayObjectOES.VertexAttrib.prototype.recache = function recache() {
   this.cached = [this.size, this.type, this.normalized, this.stride, this.offset].join(":");
 };
-var OESVertexArrayObject = function OESVertexArrayObject2(gl2) {
+var OESVertexArrayObject = function OESVertexArrayObject2(gl) {
   const self = this;
-  this.gl = gl2;
-  wrapGLError(gl2);
+  this.gl = gl;
+  wrapGLError(gl);
   const original = this.original = {
-    getParameter: gl2.getParameter,
-    enableVertexAttribArray: gl2.enableVertexAttribArray,
-    disableVertexAttribArray: gl2.disableVertexAttribArray,
-    bindBuffer: gl2.bindBuffer,
-    getVertexAttrib: gl2.getVertexAttrib,
-    vertexAttribPointer: gl2.vertexAttribPointer
+    getParameter: gl.getParameter,
+    enableVertexAttribArray: gl.enableVertexAttribArray,
+    disableVertexAttribArray: gl.disableVertexAttribArray,
+    bindBuffer: gl.bindBuffer,
+    getVertexAttrib: gl.getVertexAttrib,
+    vertexAttribPointer: gl.vertexAttribPointer
   };
-  gl2.getParameter = function getParameter(pname) {
+  gl.getParameter = function getParameter(pname) {
     if (pname === self.VERTEX_ARRAY_BINDING_OES) {
       if (self.currentVertexArrayObject === self.defaultVertexArrayObject) {
         return null;
@@ -223,53 +223,53 @@ var OESVertexArrayObject = function OESVertexArrayObject2(gl2) {
     }
     return original.getParameter.apply(this, arguments);
   };
-  gl2.enableVertexAttribArray = function enableVertexAttribArray(index) {
+  gl.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);
   };
-  gl2.disableVertexAttribArray = function disableVertexAttribArray(index) {
+  gl.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);
   };
-  gl2.bindBuffer = function bindBuffer2(target, buffer) {
+  gl.bindBuffer = function bindBuffer2(target, buffer) {
     switch (target) {
-      case gl2.ARRAY_BUFFER:
+      case gl.ARRAY_BUFFER:
         self.currentArrayBuffer = buffer;
         break;
-      case gl2.ELEMENT_ARRAY_BUFFER:
+      case gl.ELEMENT_ARRAY_BUFFER:
         self.currentVertexArrayObject.elementArrayBuffer = buffer;
         break;
       default:
     }
     return original.bindBuffer.apply(this, arguments);
   };
-  gl2.getVertexAttrib = function getVertexAttrib(index, pname) {
+  gl.getVertexAttrib = function getVertexAttrib(index, pname) {
     const vao = self.currentVertexArrayObject;
     const attrib = vao.attribs[index];
     switch (pname) {
-      case gl2.VERTEX_ATTRIB_ARRAY_BUFFER_BINDING:
+      case gl.VERTEX_ATTRIB_ARRAY_BUFFER_BINDING:
         return attrib.buffer;
-      case gl2.VERTEX_ATTRIB_ARRAY_ENABLED:
+      case gl.VERTEX_ATTRIB_ARRAY_ENABLED:
         return attrib.enabled;
-      case gl2.VERTEX_ATTRIB_ARRAY_SIZE:
+      case gl.VERTEX_ATTRIB_ARRAY_SIZE:
         return attrib.size;
-      case gl2.VERTEX_ATTRIB_ARRAY_STRIDE:
+      case gl.VERTEX_ATTRIB_ARRAY_STRIDE:
         return attrib.stride;
-      case gl2.VERTEX_ATTRIB_ARRAY_TYPE:
+      case gl.VERTEX_ATTRIB_ARRAY_TYPE:
         return attrib.type;
-      case gl2.VERTEX_ATTRIB_ARRAY_NORMALIZED:
+      case gl.VERTEX_ATTRIB_ARRAY_NORMALIZED:
         return attrib.normalized;
       default:
         return original.getVertexAttrib.apply(this, arguments);
     }
   };
-  gl2.vertexAttribPointer = function vertexAttribPointer(indx, size, type, normalized, stride, offset) {
+  gl.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 +282,11 @@ var OESVertexArrayObject = function OESVertexArrayObject2(gl2) {
     attrib.recache();
     return original.vertexAttribPointer.apply(this, arguments);
   };
-  if (gl2.instrumentExtension) {
-    gl2.instrumentExtension(this, "OES_vertex_array_object");
+  if (gl.instrumentExtension) {
+    gl.instrumentExtension(this, "OES_vertex_array_object");
   }
-  if (gl2.canvas) {
-    gl2.canvas.addEventListener(
+  if (gl.canvas) {
+    gl.canvas.addEventListener(
       "webglcontextrestored",
       () => {
         log("OESVertexArrayObject emulation library context restored");
@@ -305,8 +305,8 @@ OESVertexArrayObject.prototype.reset_ = function reset_() {
       this.vertexArrayObjects.isAlive = false;
     }
   }
-  const gl2 = this.gl;
-  this.maxVertexAttribs = gl2.getParameter(gl2.MAX_VERTEX_ATTRIBS);
+  const gl = this.gl;
+  this.maxVertexAttribs = gl.getParameter(gl.MAX_VERTEX_ATTRIBS);
   this.defaultVertexArrayObject = new WebGLVertexArrayObjectOES(this);
   this.currentVertexArrayObject = null;
   this.currentArrayBuffer = null;
@@ -334,10 +334,10 @@ OESVertexArrayObject.prototype.isVertexArrayOES = function isVertexArrayOES(arra
   return false;
 };
 OESVertexArrayObject.prototype.bindVertexArrayOES = function bindVertexArrayOES(arrayObject) {
-  const gl2 = this.gl;
+  const gl = this.gl;
   if (arrayObject && !arrayObject.isAlive) {
     synthesizeGLError(
-      gl2.INVALID_OPERATION,
+      gl.INVALID_OPERATION,
       "bindVertexArrayOES: attempt to bind deleted arrayObject"
     );
     return;
@@ -351,7 +351,7 @@ OESVertexArrayObject.prototype.bindVertexArrayOES = function bindVertexArrayOES(
     return;
   }
   if (!oldVAO || newVAO.elementArrayBuffer !== oldVAO.elementArrayBuffer) {
-    original.bindBuffer.call(gl2, gl2.ELEMENT_ARRAY_BUFFER, newVAO.elementArrayBuffer);
+    original.bindBuffer.call(gl, gl.ELEMENT_ARRAY_BUFFER, newVAO.elementArrayBuffer);
   }
   let currentBinding = this.currentArrayBuffer;
   const maxAttrib = Math.max(oldVAO ? oldVAO.maxAttrib : 0, newVAO.maxAttrib);
@@ -360,23 +360,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(gl2, n);
+        original.enableVertexAttribArray.call(gl, n);
       } else {
-        original.disableVertexAttribArray.call(gl2, n);
+        original.disableVertexAttribArray.call(gl, n);
       }
     }
     if (attrib.enabled) {
       let bufferChanged = false;
       if (!oldVAO || attrib.buffer !== oldAttrib.buffer) {
         if (currentBinding !== attrib.buffer) {
-          original.bindBuffer.call(gl2, gl2.ARRAY_BUFFER, attrib.buffer);
+          original.bindBuffer.call(gl, gl.ARRAY_BUFFER, attrib.buffer);
           currentBinding = attrib.buffer;
         }
         bufferChanged = true;
       }
       if (bufferChanged || attrib.cached !== oldAttrib.cached) {
         original.vertexAttribPointer.call(
-          gl2,
+          gl,
           n,
           attrib.size,
           attrib.type,
@@ -388,31 +388,31 @@ OESVertexArrayObject.prototype.bindVertexArrayOES = function bindVertexArrayOES(
     }
   }
   if (this.currentArrayBuffer !== currentBinding) {
-    original.bindBuffer.call(gl2, gl2.ARRAY_BUFFER, this.currentArrayBuffer);
+    original.bindBuffer.call(gl, gl.ARRAY_BUFFER, this.currentArrayBuffer);
   }
 };
-function polyfillVertexArrayObject(gl2) {
-  if (typeof gl2.createVertexArray === "function") {
+function polyfillVertexArrayObject(gl) {
+  if (typeof gl.createVertexArray === "function") {
     return;
   }
-  const original_getSupportedExtensions = gl2.getSupportedExtensions;
-  gl2.getSupportedExtensions = function getSupportedExtensions() {
+  const original_getSupportedExtensions = gl.getSupportedExtensions;
+  gl.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 = gl2.getExtension;
-  gl2.getExtension = function getExtension(name2) {
-    const ext = original_getExtension.call(this, name2);
+  const original_getExtension = gl.getExtension;
+  gl.getExtension = function getExtension(name) {
+    const ext = original_getExtension.call(this, name);
     if (ext) {
       return ext;
     }
-    if (name2 !== "OES_vertex_array_object") {
+    if (name !== "OES_vertex_array_object") {
       return null;
     }
-    if (!gl2.__OESVertexArrayObject) {
+    if (!gl.__OESVertexArrayObject) {
       this.__OESVertexArrayObject = new OESVertexArrayObject(this);
     }
     return this.__OESVertexArrayObject;
@@ -427,31 +427,31 @@ var import_constants2 = require("@luma.gl/constants");
 var import_core = require("@luma.gl/core");
 var ERR_CONTEXT = "Invalid WebGLRenderingContext";
 var ERR_WEBGL2 = "Requires WebGL2";
-function isWebGL(gl2) {
-  if (typeof WebGLRenderingContext !== "undefined" && gl2 instanceof WebGLRenderingContext) {
+function isWebGL(gl) {
+  if (typeof WebGLRenderingContext !== "undefined" && gl instanceof WebGLRenderingContext) {
     return true;
   }
-  if (typeof WebGL2RenderingContext !== "undefined" && gl2 instanceof WebGL2RenderingContext) {
+  if (typeof WebGL2RenderingContext !== "undefined" && gl instanceof WebGL2RenderingContext) {
     return true;
   }
-  return Boolean(gl2 && Number.isFinite(gl2._version));
+  return Boolean(gl && Number.isFinite(gl._version));
 }
-function isWebGL2(gl2) {
-  if (typeof WebGL2RenderingContext !== "undefined" && gl2 instanceof WebGL2RenderingContext) {
+function isWebGL2(gl) {
+  if (typeof WebGL2RenderingContext !== "undefined" && gl instanceof WebGL2RenderingContext) {
     return true;
   }
-  return Boolean(gl2 && gl2._version === 2);
+  return Boolean(gl && gl._version === 2);
 }
-function getWebGL2Context(gl2) {
-  return isWebGL2(gl2) ? gl2 : null;
+function getWebGL2Context(gl) {
+  return isWebGL2(gl) ? gl : null;
 }
-function assertWebGLContext(gl2) {
-  (0, import_core.assert)(isWebGL(gl2), ERR_CONTEXT);
-  return gl2;
+function assertWebGLContext(gl) {
+  (0, import_core.assert)(isWebGL(gl), ERR_CONTEXT);
+  return gl;
 }
-function assertWebGL2Context(gl2) {
-  (0, import_core.assert)(isWebGL2(gl2), ERR_WEBGL2);
-  return gl2;
+function assertWebGL2Context(gl) {
+  (0, import_core.assert)(isWebGL2(gl), ERR_WEBGL2);
+  return gl;
 }
 
 // src/context/polyfill/get-parameter-polyfill.ts
@@ -468,40 +468,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 = (gl2) => !isWebGL2(gl2) ? 0 : void 0;
+var getWebGL2ValueOrZero = (gl) => !isWebGL2(gl) ? 0 : void 0;
 var WEBGL_PARAMETERS = {
-  [import_constants.GL.READ_BUFFER]: (gl2) => !isWebGL2(gl2) ? import_constants.GL.COLOR_ATTACHMENT0 : void 0,
+  [import_constants.GL.READ_BUFFER]: (gl) => !isWebGL2(gl) ? import_constants.GL.COLOR_ATTACHMENT0 : void 0,
   // WebGL2 context parameters
-  [GL_FRAGMENT_SHADER_DERIVATIVE_HINT]: (gl2) => !isWebGL2(gl2) ? GL_DONT_CARE : void 0,
+  [GL_FRAGMENT_SHADER_DERIVATIVE_HINT]: (gl) => !isWebGL2(gl) ? GL_DONT_CARE : void 0,
   [import_constants.GL.RASTERIZER_DISCARD]: getWebGL2ValueOrZero,
   [import_constants.GL.SAMPLES]: getWebGL2ValueOrZero,
   // WebGL2 extension context parameters
-  [GL_GPU_DISJOINT_EXT]: (gl2, getParameter) => {
-    const ext = isWebGL2(gl2) ? gl2.getExtension(EXT_disjoint_timer_query_webgl2) : gl2.getExtension(EXT_disjoint_timer_query);
+  [GL_GPU_DISJOINT_EXT]: (gl, getParameter) => {
+    const ext = isWebGL2(gl) ? gl.getExtension(EXT_disjoint_timer_query_webgl2) : gl.getExtension(EXT_disjoint_timer_query);
     return ext && ext.GPU_DISJOINT_EXT ? getParameter(ext.GPU_DISJOINT_EXT) : 0;
   },
   // Extension fixed values
-  [GL_UNMASKED_VENDOR_WEBGL]: (gl2, getParameter) => {
-    const ext = gl2.getExtension(WEBGL_debug_renderer_info);
+  [GL_UNMASKED_VENDOR_WEBGL]: (gl, getParameter) => {
+    const ext = gl.getExtension(WEBGL_debug_renderer_info);
     return getParameter(ext && ext.UNMASKED_VENDOR_WEBGL || import_constants.GL.VENDOR);
   },
-  [GL_UNMASKED_RENDERER_WEBGL]: (gl2, getParameter) => {
-    const ext = gl2.getExtension(WEBGL_debug_renderer_info);
+  [GL_UNMASKED_RENDERER_WEBGL]: (gl, getParameter) => {
+    const ext = gl.getExtension(WEBGL_debug_renderer_info);
     return getParameter(ext && ext.UNMASKED_RENDERER_WEBGL || import_constants.GL.RENDERER);
   },
   // Extension LIMITS
-  [GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT]: (gl2, getParameter) => {
+  [GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT]: (gl, getParameter) => {
     var _a, _b;
-    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");
+    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");
     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]: (gl2, getParameter) => {
-    if (!isWebGL2(gl2)) {
-      const ext = gl2.getExtension(WEBGL_draw_buffers);
+  [import_constants.GL.MAX_COLOR_ATTACHMENTS]: (gl, getParameter) => {
+    if (!isWebGL2(gl)) {
+      const ext = gl.getExtension(WEBGL_draw_buffers);
       return ext ? getParameter(ext.MAX_COLOR_ATTACHMENTS_WEBGL) : 0;
     }
     return void 0;
@@ -509,24 +509,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]: (gl2) => {
-    if (!isWebGL2(gl2)) {
-      const ext = gl2.getExtension(WEBGL_draw_buffers);
+  [import_constants.GL.MAX_DRAW_BUFFERS]: (gl) => {
+    if (!isWebGL2(gl)) {
+      const ext = gl.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
-    (gl2) => gl2.getExtension(OES_element_index) ? 2147483647 : 65535
+    (gl) => gl.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)
-    (gl2) => gl2.getExtension(OES_element_index) ? 16777216 : 65535
+    (gl) => gl.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)
-    (gl2) => 16777216
+    (gl) => 16777216
   ),
   [import_constants.GL.MAX_FRAGMENT_INPUT_COMPONENTS]: getWebGL2ValueOrZero,
   [import_constants.GL.MAX_FRAGMENT_UNIFORM_BLOCKS]: getWebGL2ValueOrZero,
@@ -547,24 +547,24 @@ var WEBGL_PARAMETERS = {
   [import_constants.GL.MAX_PROGRAM_TEXEL_OFFSET]: getWebGL2ValueOrZero,
   [import_constants.GL.UNIFORM_BUFFER_OFFSET_ALIGNMENT]: getWebGL2ValueOrZero
 };
-function getParameterPolyfill(gl2, originalGetParameter, pname) {
+function getParameterPolyfill(gl, originalGetParameter, pname) {
   const limit = WEBGL_PARAMETERS[pname];
-  const value = typeof limit === "function" ? limit(gl2, originalGetParameter, pname) : limit;
+  const value = typeof limit === "function" ? limit(gl, originalGetParameter, pname) : limit;
   const result = value !== void 0 ? value : originalGetParameter(pname);
   return result;
 }
 
 // src/context/polyfill/context-data.ts
-function getContextData(gl2) {
-  const luma = gl2.luma;
+function getContextData(gl) {
+  const luma = gl.luma;
   if (!luma) {
     const contextState = {
       _polyfilled: false,
       _extensions: {}
     };
-    gl2.luma = contextState;
+    gl.luma = contextState;
   }
-  return gl2.luma;
+  return gl.luma;
 }
 
 // src/context/polyfill/polyfill-table.ts
@@ -574,10 +574,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(gl2, extension) {
+function getExtensionData(gl, extension) {
   return {
-    webgl2: isWebGL2(gl2),
-    ext: gl2.getExtension(extension)
+    webgl2: isWebGL2(gl),
+    ext: gl.getExtension(extension)
   };
 }
 var WEBGL2_CONTEXT_POLYFILLS = {
@@ -644,15 +644,15 @@ var WEBGL2_CONTEXT_POLYFILLS = {
 };
 var WEBGL2_CONTEXT_OVERRIDES = {
   // Ensure readBuffer is a no-op
-  readBuffer: (gl2, originalFunc, attachment) => {
-    if (isWebGL2(gl2)) {
+  readBuffer: (gl, originalFunc, attachment) => {
+    if (isWebGL2(gl)) {
       originalFunc(attachment);
     } else {
     }
   },
   // Override for getVertexAttrib that returns sane values for non-WebGL1 constants
-  getVertexAttrib: (gl2, originalFunc, location, pname) => {
-    const { webgl2, ext } = getExtensionData(gl2, ANGLE_instanced_arrays);
+  getVertexAttrib: (gl, originalFunc, location, pname) => {
+    const { webgl2, ext } = getExtensionData(gl, ANGLE_instanced_arrays);
     let result;
     switch (pname) {
       case import_constants2.GL.VERTEX_ATTRIB_ARRAY_INTEGER:
@@ -666,8 +666,8 @@ var WEBGL2_CONTEXT_OVERRIDES = {
     return result !== void 0 ? result : originalFunc(location, pname);
   },
   // Handle transform feedback and uniform block queries in WebGL1
-  getProgramParameter: (gl2, originalFunc, program, pname) => {
-    if (!isWebGL2(gl2)) {
+  getProgramParameter: (gl, originalFunc, program, pname) => {
+    if (!isWebGL2(gl)) {
       switch (pname) {
         case import_constants2.GL.TRANSFORM_FEEDBACK_BUFFER_MODE:
           return import_constants2.GL.SEPARATE_ATTRIBS;
@@ -680,21 +680,21 @@ var WEBGL2_CONTEXT_OVERRIDES = {
     }
     return originalFunc(program, pname);
   },
-  getInternalformatParameter: (gl2, originalFunc, target, format, pname) => {
-    if (!isWebGL2(gl2)) {
+  getInternalformatParameter: (gl, originalFunc, target, format, pname) => {
+    if (!isWebGL2(gl)) {
       switch (pname) {
         case import_constants2.GL.SAMPLES:
           return new Int32Array([0]);
         default:
       }
     }
-    const gl22 = gl2;
-    return gl22.getInternalformatParameter(target, format, pname);
+    const gl2 = gl;
+    return gl2.getInternalformatParameter(target, format, pname);
   },
-  getTexParameter(gl2, originalFunc, target, pname) {
+  getTexParameter(gl, originalFunc, target, pname) {
     switch (pname) {
       case import_constants2.GL.TEXTURE_MAX_ANISOTROPY_EXT:
-        const contextData = getContextData(gl2);
+        const contextData = getContextData(gl);
         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 +704,50 @@ var WEBGL2_CONTEXT_OVERRIDES = {
     return originalFunc(target, pname);
   },
   getParameter: getParameterPolyfill,
-  hint(gl2, originalFunc, pname, value) {
+  hint(gl, originalFunc, pname, value) {
     return originalFunc(pname, value);
   }
 };
 
 // src/context/polyfill/polyfill-context.ts
-function polyfillContext(gl2) {
-  const contextState = getContextData(gl2);
+function polyfillContext(gl) {
+  const contextState = getContextData(gl);
   if (!contextState._polyfilled) {
-    polyfillVertexArrayObject(gl2);
-    initializeExtensions(gl2);
-    installPolyfills(gl2, WEBGL2_CONTEXT_POLYFILLS);
-    installOverrides(gl2, { target: contextState, target2: gl2 });
+    polyfillVertexArrayObject(gl);
+    initializeExtensions(gl);
+    installPolyfills(gl, WEBGL2_CONTEXT_POLYFILLS);
+    installOverrides(gl, { target: contextState, target2: gl });
     contextState._polyfilled = true;
   }
-  return gl2;
+  return gl;
 }
-function initializeExtensions(gl2) {
-  const contextState = getContextData(gl2);
-  const EXTENSIONS = gl2.getSupportedExtensions() || [];
+function initializeExtensions(gl) {
+  const contextState = getContextData(gl);
+  const EXTENSIONS = gl.getSupportedExtensions() || [];
   for (const extensionName of EXTENSIONS) {
-    const extension = gl2.getExtension(extensionName);
+    const extension = gl.getExtension(extensionName);
     contextState._extensions[extensionName] = extension;
   }
 }
-function installPolyfills(gl2, polyfills) {
-  const contextState = getContextData(gl2);
+function installPolyfills(gl, polyfills) {
+  const contextState = getContextData(gl);
   for (const extension of Object.getOwnPropertyNames(polyfills)) {
     if (extension !== "overrides") {
-      polyfillExtension(gl2, { extension, target: contextState, target2: gl2 });
+      polyfillExtension(gl, { extension, target: contextState, target2: gl });
     }
   }
 }
-function polyfillExtension(gl2, { extension, target, target2 }) {
+function polyfillExtension(gl, { extension, target, target2 }) {
   const defaults = WEBGL2_CONTEXT_POLYFILLS[extension];
   (0, import_core3.assert)(defaults);
   const { meta = {} } = defaults;
   const { suffix = "" } = meta;
-  const ext = gl2.getExtension(extension);
+  const ext = gl.getExtension(extension);
   for (const key of Object.keys(defaults)) {
     const extKey = `${key}${suffix}`;
     let polyfill = null;
     if (key === "meta") {
-    } else if (typeof gl2[key] === "function") {
+    } else if (typeof gl[key] === "function") {
     } else if (ext && typeof ext[extKey] === "function") {
       polyfill = (...args) => ext[extKey](...args);
     } else if (typeof defaults[key] === "function") {
@@ -759,12 +759,12 @@ function polyfillExtension(gl2, { extension, target, target2 }) {
     }
   }
 }
-function installOverrides(gl2, { target, target2 }) {
+function installOverrides(gl, { target, target2 }) {
   Object.keys(WEBGL2_CONTEXT_OVERRIDES).forEach((key) => {
     if (typeof WEBGL2_CONTEXT_OVERRIDES[key] === "function") {
-      const originalFunc = gl2[key] ? gl2[key].bind(gl2) : () => {
+      const originalFunc = gl[key] ? gl[key].bind(gl) : () => {
       };
-      const polyfill = WEBGL2_CONTEXT_OVERRIDES[key].bind(null, gl2, originalFunc);
+      const polyfill = WEBGL2_CONTEXT_OVERRIDES[key].bind(null, gl, originalFunc);
       target[key] = polyfill;
       target2[key] = polyfill;
     }
@@ -859,19 +859,19 @@ var GL_PARAMETER_DEFAULTS = {
   [import_constants3.GL.UNPACK_SKIP_ROWS]: 0,
   [import_constants3.GL.UNPACK_SKIP_IMAGES]: 0
 };
-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) => {
+var enable = (gl, value, key) => value ? gl.enable(key) : gl.disable(key);
+var hint = (gl, value, key) => gl.hint(key, value);
+var pixelStorei = (gl, value, key) => gl.pixelStorei(key, value);
+var bindFramebuffer = (gl, value, key) => {
   let target;
   if (key === import_constants3.GL.FRAMEBUFFER_BINDING) {
-    target = isWebGL2(gl2) ? import_constants3.GL.DRAW_FRAMEBUFFER : import_constants3.GL.FRAMEBUFFER;
+    target = isWebGL2(gl) ? import_constants3.GL.DRAW_FRAMEBUFFER : import_constants3.GL.FRAMEBUFFER;
   } else {
     target = import_constants3.GL.READ_FRAMEBUFFER;
   }
-  return gl2.bindFramebuffer(target, value);
+  return gl.bindFramebuffer(target, value);
 };
-var bindBuffer = (gl2, value, key) => {
+var bindBuffer = (gl, 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 +880,38 @@ var bindBuffer = (gl2, value, key) => {
     [import_constants3.GL.PIXEL_UNPACK_BUFFER_BINDING]: import_constants3.GL.PIXEL_UNPACK_BUFFER
   };
   const glTarget = bindingMap[key];
-  gl2.bindBuffer(glTarget, value);
+  gl.bindBuffer(glTarget, 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]: (gl2, value) => gl2.blendColor(...value),
+  [import_constants3.GL.BLEND_COLOR]: (gl, value) => gl.blendColor(...value),
   [import_constants3.GL.BLEND_EQUATION_RGB]: "blendEquation",
   [import_constants3.GL.BLEND_EQUATION_ALPHA]: "blendEquation",
   [import_constants3.GL.BLEND_SRC_RGB]: "blendFunc",
   [import_constants3.GL.BLEND_DST_RGB]: "blendFunc",
   [import_constants3.GL.BLEND_SRC_ALPHA]: "blendFunc",
   [import_constants3.GL.BLEND_DST_ALPHA]: "blendFunc",
-  [import_constants3.GL.COLOR_CLEAR_VALUE]: (gl2, value) => gl2.clearColor(...value),
-  [import_constants3.GL.COLOR_WRITEMASK]: (gl2, value) => gl2.colorMask(...value),
+  [import_constants3.GL.COLOR_CLEAR_VALUE]: (gl, value) => gl.clearColor(...value),
+  [import_constants3.GL.COLOR_WRITEMASK]: (gl, value) => gl.colorMask(...value),
   [import_constants3.GL.CULL_FACE]: enable,
-  [import_constants3.GL.CULL_FACE_MODE]: (gl2, value) => gl2.cullFace(value),
+  [import_constants3.GL.CULL_FACE_MODE]: (gl, value) => gl.cullFace(value),
   [import_constants3.GL.DEPTH_TEST]: enable,
-  [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.DEPTH_CLEAR_VALUE]: (gl, value) => gl.clearDepth(value),
+  [import_constants3.GL.DEPTH_FUNC]: (gl, value) => gl.depthFunc(value),
+  [import_constants3.GL.DEPTH_RANGE]: (gl, value) => gl.depthRange(...value),
+  [import_constants3.GL.DEPTH_WRITEMASK]: (gl, value) => gl.depthMask(value),
   [import_constants3.GL.DITHER]: enable,
   [import_constants3.GL.FRAGMENT_SHADER_DERIVATIVE_HINT]: hint,
-  [import_constants3.GL.CURRENT_PROGRAM]: (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) => {
+  [import_constants3.GL.CURRENT_PROGRAM]: (gl, value) => gl.useProgram(value),
+  [import_constants3.GL.RENDERBUFFER_BINDING]: (gl, value) => gl.bindRenderbuffer(import_constants3.GL.RENDERBUFFER, value),
+  [import_constants3.GL.TRANSFORM_FEEDBACK_BINDING]: (gl, value) => {
     var _a;
-    return (_a = gl2.bindTransformFeedback) == null ? void 0 : _a.call(gl2, import_constants3.GL.TRANSFORM_FEEDBACK, value);
+    return (_a = gl.bindTransformFeedback) == null ? void 0 : _a.call(gl, import_constants3.GL.TRANSFORM_FEEDBACK, value);
   },
-  [import_constants3.GL.VERTEX_ARRAY_BINDING]: (gl2, value) => gl2.bindVertexArray(value),
+  [import_constants3.GL.VERTEX_ARRAY_BINDING]: (gl, value) => gl.bindVertexArray(value),
   // NOTE: FRAMEBUFFER_BINDING and DRAW_FRAMEBUFFER_BINDING(WebGL2) refer same state.
   [import_constants3.GL.FRAMEBUFFER_BINDING]: bindFramebuffer,
   [import_constants3.GL.READ_FRAMEBUFFER_BINDING]: bindFramebuffer,
@@ -921,9 +921,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]: (gl2, value) => gl2.frontFace(value),
+  [import_constants3.GL.FRONT_FACE]: (gl, value) => gl.frontFace(value),
   [import_constants3.GL.GENERATE_MIPMAP_HINT]: hint,
-  [import_constants3.GL.LINE_WIDTH]: (gl2, value) => gl2.lineWidth(value),
+  [import_constants3.GL.LINE_WIDTH]: (gl, value) => gl.lineWidth(value),
   [import_constants3.GL.POLYGON_OFFSET_FILL]: enable,
   [import_constants3.GL.POLYGON_OFFSET_FACTOR]: "polygonOffset",
   [import_constants3.GL.POLYGON_OFFSET_UNITS]: "polygonOffset",
@@ -933,11 +933,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]: (gl2, value) => gl2.scissor(...value),
+  [import_constants3.GL.SCISSOR_BOX]: (gl, value) => gl.scissor(...value),
   [import_constants3.GL.STENCIL_TEST]: enable,
-  [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_CLEAR_VALUE]: (gl, value) => gl.clearStencil(value),
+  [import_constants3.GL.STENCIL_WRITEMASK]: (gl, value) => gl.stencilMaskSeparate(import_constants3.GL.FRONT, value),
+  [import_constants3.GL.STENCIL_BACK_WRITEMASK]: (gl, value) => gl.stencilMaskSeparate(import_constants3.GL.BACK, value),
   [import_constants3.GL.STENCIL_FUNC]: "stencilFuncFront",
   [import_constants3.GL.STENCIL_REF]: "stencilFuncFront",
   [import_constants3.GL.STENCIL_VALUE_MASK]: "stencilFuncFront",
@@ -950,7 +950,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]: (gl2, value) => gl2.viewport(...value),
+  [import_constants3.GL.VIEWPORT]: (gl, value) => gl.viewport(...value),
   // WEBGL1 PIXEL PACK/UNPACK MODES
   [import_constants3.GL.PACK_ALIGNMENT]: pixelStorei,
   [import_constants3.GL.UNPACK_ALIGNMENT]: pixelStorei,
@@ -968,104 +968,104 @@ var GL_PARAMETER_SETTERS = {
   [import_constants3.GL.UNPACK_SKIP_ROWS]: pixelStorei,
   [import_constants3.GL.UNPACK_SKIP_IMAGES]: pixelStorei,
   // Function-style setters
-  framebuffer: (gl2, framebuffer) => {
+  framebuffer: (gl, framebuffer) => {
     const handle = framebuffer && "handle" in framebuffer ? framebuffer.handle : framebuffer;
-    return gl2.bindFramebuffer(import_constants3.GL.FRAMEBUFFER, handle);
+    return gl.bindFramebuffer(import_constants3.GL.FRAMEBUFFER, handle);
   },
-  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) => {
+  blend: (gl, value) => value ? gl.enable(import_constants3.GL.BLEND) : gl.disable(import_constants3.GL.BLEND),
+  blendColor: (gl, value) => gl.blendColor(...value),
+  blendEquation: (gl, args) => {
     const separateModes = typeof args === "number" ? [args, args] : args;
-    gl2.blendEquationSeparate(...separateModes);
+    gl.blendEquationSeparate(...separateModes);
   },
-  blendFunc: (gl2, args) => {
+  blendFunc: (gl, args) => {
     const separateFuncs = (args == null ? void 0 : args.length) === 2 ? [...args, ...args] : args;
-    gl2.blendFuncSeparate(...separateFuncs);
+    gl.blendFuncSeparate(...separateFuncs);
   },
-  clearColor: (gl2, value) => gl2.clearColor(...value),
-  clearDepth: (gl2, value) => gl2.clearDepth(value),
-  clearStencil: (gl2, value) => gl2.clearStencil(value),
-  colorMask: (gl2, value) => gl2.colorMask(...value),
-  cull: (gl2, value) => value ? gl2.enable(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);
+  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);
   },
-  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) => {
+  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) => {
     value = isArray(value) ? value : [value, value];
     const [mask, backMask] = value;
-    gl2.stencilMaskSeparate(import_constants3.GL.FRONT, mask);
-    gl2.stencilMaskSeparate(import_constants3.GL.BACK, backMask);
+    gl.stencilMaskSeparate(import_constants3.GL.FRONT, mask);
+    gl.stencilMaskSeparate(import_constants3.GL.BACK, backMask);
   },
-  stencilFunc: (gl2, args) => {
+  stencilFunc: (gl, args) => {
     args = isArray(args) && args.length === 3 ? [...args, ...args] : args;
     const [func, ref, mask, backFunc, backRef, backMask] = args;
-    gl2.stencilFuncSeparate(import_constants3.GL.FRONT, func, ref, mask);
-    gl2.stencilFuncSeparate(import_constants3.GL.BACK, backFunc, backRef, backMask);
+    gl.stencilFuncSeparate(import_constants3.GL.FRONT, func, ref, mask);
+    gl.stencilFuncSeparate(import_constants3.GL.BACK, backFunc, backRef, backMask);
   },
-  stencilOp: (gl2, args) => {
+  stencilOp: (gl, args) => {
     args = isArray(args) && args.length === 3 ? [...args, ...args] : args;
     const [sfail, dpfail, dppass, backSfail, backDpfail, backDppass] = args;
-    gl2.stencilOpSeparate(import_constants3.GL.FRONT, sfail, dpfail, dppass);
-    gl2.stencilOpSeparate(import_constants3.GL.BACK, backSfail, backDpfail, backDppass);
+    gl.stencilOpSeparate(import_constants3.GL.FRONT, sfail, dpfail, dppass);
+    gl.stencilOpSeparate(import_constants3.GL.BACK, backSfail, backDpfail, backDppass);
   },
-  viewport: (gl2, value) => gl2.viewport(...value)
+  viewport: (gl, value) => gl.viewport(...value)
 };
 function getValue(glEnum, values, cache) {
   return values[glEnum] !== void 0 ? values[glEnum] : cache[glEnum];
 }
 var GL_COMPOSITE_PARAMETER_SETTERS = {
-  blendEquation: (gl2, values, cache) => gl2.blendEquationSeparate(
+  blendEquation: (gl, values, cache) => gl.blendEquationSeparate(
     getValue(import_constants3.GL.BLEND_EQUATION_RGB, values, cache),
     getValue(import_constants3.GL.BLEND_EQUATION_ALPHA, values, cache)
   ),
-  blendFunc: (gl2, values, cache) => gl2.blendFuncSeparate(
+  blendFunc: (gl, values, cache) => gl.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: (gl2, values, cache) => gl2.polygonOffset(
+  polygonOffset: (gl, values, cache) => gl.polygonOffset(
     getValue(import_constants3.GL.POLYGON_OFFSET_FACTOR, values, cache),
     getValue(import_constants3.GL.POLYGON_OFFSET_UNITS, values, cache)
   ),
-  sampleCoverage: (gl2, values, cache) => gl2.sampleCoverage(
+  sampleCoverage: (gl, values, cache) => gl.sampleCoverage(
     getValue(import_constants3.GL.SAMPLE_COVERAGE_VALUE, values, cache),
     getValue(import_constants3.GL.SAMPLE_COVERAGE_INVERT, values, cache)
   ),
-  stencilFuncFront: (gl2, values, cache) => gl2.stencilFuncSeparate(
+  stencilFuncFront: (gl, values, cache) => gl.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: (gl2, values, cache) => gl2.stencilFuncSeparate(
+  stencilFuncBack: (gl, values, cache) => gl.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: (gl2, values, cache) => gl2.stencilOpSeparate(
+  stencilOpFront: (gl, values, cache) => gl.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: (gl2, values, cache) => gl2.stencilOpSeparate(
+  stencilOpBack: (gl, values, cache) => gl.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 +1228,7 @@ var GL_HOOKED_SETTERS = {
     [import_constants3.GL.VIEWPORT]: [x, y, width, height]
   })
 };
-var isEnabled = (gl2, key) => gl2.isEnabled(key);
+var isEnabled = (gl, key) => gl.isEnabled(key);
 var GL_PARAMETER_GETTERS = {
   [import_constants3.GL.BLEND]: isEnabled,
   [import_constants3.GL.CULL_FACE]: isEnabled,
@@ -1282,9 +1282,9 @@ var NON_CACHE_PARAMETERS = /* @__PURE__ */ new Set([
 ]);
 
 // src/context/parameters/unified-parameter-api.ts
-function setParameters(device, parameters) {
+function setGLParameters(device, parameters) {
   const webglDevice = WebGLDevice.attach(device);
-  const gl2 = webglDevice.gl;
+  const gl = webglDevice.gl;
   if (isObjectEmpty(parameters)) {
     return;
   }
@@ -1296,36 +1296,36 @@ function setParameters(device, parameters) {
       if (typeof setter === "string") {
         compositeSetters[setter] = true;
       } else {
-        setter(gl2, parameters[key], glConstant);
+        setter(gl, parameters[key], glConstant);
       }
     }
   }
-  const cache = gl2.state && gl2.state.cache;
+  const cache = gl.state && gl.state.cache;
   if (cache) {
     for (const key in compositeSetters) {
       const compositeSetter = GL_COMPOSITE_PARAMETER_SETTERS[key];
-      compositeSetter(gl2, parameters, cache);
+      compositeSetter(gl, parameters, cache);
     }
   }
 }
-function getParameters(device, parameters = GL_PARAMETER_DEFAULTS) {
+function getGLParameters(device, parameters = GL_PARAMETER_DEFAULTS) {
   const webglDevice = WebGLDevice.attach(device);
-  const gl2 = webglDevice.gl;
+  const gl = webglDevice.gl;
   if (typeof parameters === "number") {
     const key = parameters;
     const getter = GL_PARAMETER_GETTERS[key];
-    return getter ? getter(gl2, key) : gl2.getParameter(key);
+    return getter ? getter(gl, key) : gl.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(gl2, Number(key)) : gl2.getParameter(Number(key));
+    state[key] = getter ? getter(gl, Number(key)) : gl.getParameter(Number(key));
   }
   return state;
 }
-function resetParameters(device) {
-  setParameters(device, GL_PARAMETER_DEFAULTS);
+function resetGLParameters(device) {
+  setGLParameters(device, GL_PARAMETER_DEFAULTS);
 }
 function isObjectEmpty(object) {
   for (const key in object) {
@@ -1354,7 +1354,7 @@ function deepArrayEqual(x, y) {
 
 // src/context/state-tracker/track-context-state.ts
 var GLState = class {
-  constructor(gl2, {
+  constructor(gl, {
     copyState = false,
     // Copy cache from params (slow) or initialize from WebGL defaults (fast)
     log: log9 = () => {
@@ -1364,8 +1364,8 @@ var GLState = class {
     this.program = null;
     this.stateStack = [];
     this.enable = true;
-    this.gl = gl2;
-    this.cache = copyState ? getParameters(gl2) : Object.assign({}, GL_PARAMETER_DEFAULTS);
+    this.gl = gl;
+    this.cache = copyState ? getGLParameters(gl) : Object.assign({}, GL_PARAMETER_DEFAULTS);
     this.log = log9;
     this._updateCache = this._updateCache.bind(this);
     Object.seal(this);
@@ -1376,7 +1376,7 @@ var GLState = class {
   pop() {
     (0, import_core4.assert)(this.stateStack.length > 0);
     const oldValues = this.stateStack[this.stateStack.length - 1];
-    setParameters(this.gl, oldValues);
+    setGLParameters(this.gl, oldValues);
     this.stateStack.pop();
   }
   /**
@@ -1405,46 +1405,46 @@ var GLState = class {
     return { valueChanged, oldValue };
   }
 };
-function getContextState(gl2) {
-  return gl2.state;
+function getContextState(gl) {
+  return gl.state;
 }
-function trackContextState(gl2, options) {
+function trackContextState(gl, options) {
   const { enable: enable2 = true, copyState } = options;
   (0, import_core4.assert)(copyState !== void 0);
-  if (!gl2.state) {
-    gl2.state = new GLState(gl2, { copyState });
-    installProgramSpy(gl2);
+  if (!gl.state) {
+    gl.state = new GLState(gl, { copyState });
+    installProgramSpy(gl);
     for (const key in GL_HOOKED_SETTERS) {
       const setter = GL_HOOKED_SETTERS[key];
-      installSetterSpy(gl2, key, setter);
+      installSetterSpy(gl, key, setter);
     }
-    installGetterOverride(gl2, "getParameter");
-    installGetterOverride(gl2, "isEnabled");
+    installGetterOverride(gl, "getParameter");
+    installGetterOverride(gl, "isEnabled");
   }
-  const glState = getContextState(gl2);
+  const glState = getContextState(gl);
   glState.enable = enable2;
-  return gl2;
+  return gl;
 }
-function pushContextState(gl2) {
-  let glState = getContextState(gl2);
+function pushContextState(gl) {
+  let glState = getContextState(gl);
   if (!glState) {
-    trackContextState(gl2, { copyState: false });
-    glState = getContextState(gl2);
+    trackContextState(gl, { copyState: false });
+    glState = getContextState(gl);
   }
   glState.push();
 }
-function popContextState(gl2) {
-  const glState = getContextState(gl2);
+function popContextState(gl) {
+  const glState = getContextState(gl);
   (0, import_core4.assert)(glState);
   glState.pop();
 }
-function installGetterOverride(gl2, functionName) {
-  const originalGetterFunc = gl2[functionName].bind(gl2);
-  gl2[functionName] = function get(pname) {
+function installGetterOverride(gl, functionName) {
+  const originalGetterFunc = gl[functionName].bind(gl);
+  gl[functionName] = function get(pname) {
     if (pname === void 0 || NON_CACHE_PARAMETERS.has(pname)) {
       return originalGetterFunc(pname);
     }
-    const glState = getContextState(gl2);
+    const glState = getContextState(gl);
     if (!(pname in glState.cache)) {
       glState.cache[pname] = originalGetterFunc(pname);
     }
@@ -1456,33 +1456,33 @@ function installGetterOverride(gl2, functionName) {
       originalGetterFunc(pname)
     );
   };
-  Object.defineProperty(gl2[functionName], "name", {
+  Object.defineProperty(gl[functionName], "name", {
     value: `${functionName}-from-cache`,
     configurable: false
   });
 }
-function installSetterSpy(gl2, functionName, setter) {
-  if (!gl2[functionName]) {
+function installSetterSpy(gl, functionName, setter) {
+  if (!gl[functionName]) {
     return;
   }
-  const originalSetterFunc = gl2[functionName].bind(gl2);
-  gl2[functionName] = function set(...params) {
-    const glState = getContextState(gl2);
+  const originalSetterFunc = gl[functionName].bind(gl);
+  gl[functionName] = function set(...params) {
+    const glState = getContextState(gl);
     const { valueChanged, oldValue } = setter(glState._updateCache, ...params);
     if (valueChanged) {
       originalSetterFunc(...params);
     }
     return oldValue;
   };
-  Object.defineProperty(gl2[functionName], "name", {
+  Object.defineProperty(gl[functionName], "name", {
     value: `${functionName}-to-cache`,
     configurable: false
   });
 }
-function installProgramSpy(gl2) {
-  const originalUseProgram = gl2.useProgram.bind(gl2);
-  gl2.useProgram = function useProgramLuma(handle) {
-    const glState = getContextState(gl2);
+function installProgramSpy(gl) {
+  const originalUseProgram = gl.useProgram.bind(gl);
+  gl.useProgram = function useProgramLuma(handle) {
+    const glState = getContextState(gl);
     if (glState.program !== handle) {
       originalUseProgram(handle);
       glState.program = handle;
@@ -1508,21 +1508,21 @@ function createBrowserContext(canvas, props) {
   let errorMessage = null;
   const onCreateError = (error2) => errorMessage = error2.statusMessage || errorMessage;
   canvas.addEventListener("webglcontextcreationerror", onCreateError, false);
-  let gl2 = null;
+  let gl = null;
   if (props.type === "webgl2") {
     props = __spreadProps(__spreadValues({}, props), { webgl1: false });
   }
   if (props.type === "webgl1") {
     props = __spreadProps(__spreadValues({}, props), { webgl2: false });
   }
-  if (!gl2 && props.webgl2) {
-    gl2 = canvas.getContext("webgl2", props);
+  if (!gl && props.webgl2) {
+    gl = canvas.getContext("webgl2", props);
   }
-  if (!gl2 && props.webgl1) {
-    gl2 = canvas.getContext("webgl", props);
+  if (!gl && props.webgl1) {
+    gl = canvas.getContext("webgl", props);
   }
   canvas.removeEventListener("webglcontextcreationerror", onCreateError, false);
-  if (!gl2) {
+  if (!gl) {
     throw new Error(
       `Failed to create ${props.webgl2 && !props.webgl1 ? "WebGL2" : "WebGL"} context: ${errorMessage || "Unknown error"}`
     );
@@ -1539,29 +1539,29 @@ function createBrowserContext(canvas, props) {
       false
     );
   }
-  return gl2;
+  return gl;
 }
 
 // src/adapter/device-helpers/get-device-info.ts
 var import_constants4 = require("@luma.gl/constants");
-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);
+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);
   const vendor = vendorUnmasked || vendorMasked;
   const renderer = rendererUnmasked || rendererMasked;
   const gpu = identifyGPUVendor(vendor, renderer);
   return {
-    type: isWebGL2(gl2) ? "webgl2" : "webgl",
+    type: isWebGL2(gl) ? "webgl2" : "webgl",
     gpu,
     vendor: vendorUnmasked || vendorMasked,
     renderer: rendererUnmasked || rendererMasked,
-    version: gl2.getParameter(import_constants4.GL.VERSION),
+    version: gl.getParameter(import_constants4.GL.VERSION),
     shadingLanguages: ["glsl"],
     shadingLanguageVersions: {
-      "glsl": gl2.getParameter(import_constants4.GL.SHADING_LANGUAGE_VERSION)
+      "glsl": gl.getParameter(import_constants4.GL.SHADING_LANGUAGE_VERSION)
     }
   };
 }
@@ -1649,39 +1649,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 = (gl2, extension) => gl2.getExtension(extension);
-var checkExtensions = (gl2, extensions) => extensions.every((extension) => gl2.getExtension(extension));
+var checkExtension = (gl, extension) => gl.getExtension(extension);
+var checkExtensions = (gl, extensions) => extensions.every((extension) => gl.getExtension(extension));
 var TEXTURE_FEATURE_CHECKS = {
-  "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"),
+  "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"),
   // [false, 'EXT_color_buffer_float'],
-  "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-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-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": (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])
+  "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])
 };
-function checkTextureFeature(gl2, feature) {
+function checkTextureFeature(gl, feature) {
   var _a;
-  return ((_a = TEXTURE_FEATURE_CHECKS[feature]) == null ? void 0 : _a.call(TEXTURE_FEATURE_CHECKS, gl2)) || false;
+  return ((_a = TEXTURE_FEATURE_CHECKS[feature]) == null ? void 0 : _a.call(TEXTURE_FEATURE_CHECKS, gl)) || false;
 }
-function getTextureFeatures(gl2) {
+function getTextureFeatures(gl) {
   const textureFeatures = Object.keys(TEXTURE_FEATURE_CHECKS);
-  return textureFeatures.filter((feature) => checkTextureFeature(gl2, feature));
+  return textureFeatures.filter((feature) => checkTextureFeature(gl, feature));
 }
 var TEXTURE_FORMATS = {
   // Unsized formats that leave the precision up to the driver.
@@ -1889,24 +1889,24 @@ var TYPE_SIZES = {
   [import_constants6.GL.BYTE]: 1,
   [import_constants6.GL.UNSIGNED_BYTE]: 1
 };
-function isTextureFormatSupported(gl2, formatOrGL) {
+function isTextureFormatSupported(gl, formatOrGL) {
   const format = convertGLToTextureFormat(formatOrGL);
   const info = TEXTURE_FORMATS[format];
   if (!info) {
     return false;
   }
-  if (isWebGL2(gl2) ? info.gl === void 0 : info.gl1 === void 0) {
+  if (isWebGL2(gl) ? info.gl === void 0 : info.gl1 === void 0) {
     return false;
   }
-  const extension = info.x || (isWebGL2(gl2) ? info.gl2ext || info.gl1ext : info.gl1ext);
+  const extension = info.x || (isWebGL2(gl) ? info.gl2ext || info.gl1ext : info.gl1ext);
   if (extension) {
-    return Boolean(gl2.getExtension(extension));
+    return Boolean(gl.getExtension(extension));
   }
   return true;
 }
-function isRenderbufferFormatSupported(gl2, format) {
+function isRenderbufferFormatSupported(gl, format) {
   var _a;
-  return isTextureFormatSupported(gl2, format) && ((_a = TEXTURE_FORMATS[format]) == null ? void 0 : _a.renderbuffer);
+  return isTextureFormatSupported(gl, format) && ((_a = TEXTURE_FORMATS[format]) == null ? void 0 : _a.renderbuffer);
 }
 function convertGLToTextureFormat(format) {
   if (typeof format === "string") {
@@ -1928,9 +1928,9 @@ function convertTextureFormatToGL(format, isWebGL23) {
   }
   return webglFormat;
 }
-function isTextureFormatFilterable(gl2, formatOrGL) {
+function isTextureFormatFilterable(gl, formatOrGL) {
   const format = convertGLToTextureFormat(formatOrGL);
-  if (!isTextureFormatSupported(gl2, format)) {
+  if (!isTextureFormatSupported(gl, format)) {
     return false;
   }
   try {
@@ -1942,16 +1942,16 @@ function isTextureFormatFilterable(gl2, formatOrGL) {
     return false;
   }
   if (format.endsWith("32float")) {
-    return Boolean(gl2.getExtension("OES_texture_float_linear"));
+    return Boolean(gl.getExtension("OES_texture_float_linear"));
   }
   if (format.endsWith("16float")) {
-    return Boolean(gl2.getExtension("OES_texture_half_float_linear"));
+    return Boolean(gl.getExtension("OES_texture_half_float_linear"));
   }
   return true;
 }
-function isTextureFormatRenderable(gl2, formatOrGL) {
+function isTextureFormatRenderable(gl, formatOrGL) {
   const format = convertGLToTextureFormat(formatOrGL);
-  if (!isTextureFormatSupported(gl2, format)) {
+  if (!isTextureFormatSupported(gl, format)) {
     return false;
   }
   if (typeof format === "number") {
@@ -1984,19 +1984,19 @@ function getDepthStencilAttachmentWebGL(format) {
   }
   return info.attachment;
 }
-function _checkFloat32ColorAttachment(gl2, internalFormat = gl2.RGBA, srcFormat = import_constants6.GL.RGBA, srcType = import_constants6.GL.UNSIGNED_BYTE) {
+function _checkFloat32ColorAttachment(gl, internalFormat = gl.RGBA, srcFormat = import_constants6.GL.RGBA, srcType = import_constants6.GL.UNSIGNED_BYTE) {
   let texture = null;
   let framebuffer = null;
   try {
-    texture = gl2.createTexture();
-    gl2.bindTexture(import_constants6.GL.TEXTURE_2D, texture);
+    texture = gl.createTexture();
+    gl.bindTexture(import_constants6.GL.TEXTURE_2D, texture);
     const level = 0;
     const width = 1;
     const height = 1;
     const border = 0;
     const pixel = new Uint8Array([0, 0, 255, 255]);
-    gl2.texImage2D(
-      gl2.TEXTURE_2D,
+    gl.texImage2D(
+      gl.TEXTURE_2D,
       level,
       internalFormat,
       width,
@@ -2006,15 +2006,15 @@ function _checkFloat32ColorAttachment(gl2, internalFormat = gl2.RGBA, srcFormat
       srcType,
       pixel
     );
-    framebuffer = gl2.createFramebuffer();
-    gl2.bindFramebuffer(import_constants6.GL.FRAMEBUFFER, framebuffer);
-    gl2.framebufferTexture2D(import_constants6.GL.FRAMEBUFFER, import_constants6.GL.COLOR_ATTACHMENT0, import_constants6.GL.TEXTURE_2D, texture, 0);
-    const status = gl2.checkFramebufferStatus(import_constants6.GL.FRAMEBUFFER) === import_constants6.GL.FRAMEBUFFER_COMPLETE;
-    gl2.bindTexture(import_constants6.GL.TEXTURE_2D, null);
+    framebuffer = gl.createFramebuffer();
+    gl.bindFramebuffer(import_constants6.GL.FRAMEBUFFER, framebuffer);
+    gl.framebufferTexture2D(import_constants6.GL.FRAMEBUFFER, import_constants6.GL.COLOR_ATTACHMENT0, import_constants6.GL.TEXTURE_2D, texture, 0);
+    const status = gl.checkFramebufferStatus(import_constants6.GL.FRAMEBUFFER) === import_constants6.GL.FRAMEBUFFER_COMPLETE;
+    gl.bindTexture(import_constants6.GL.TEXTURE_2D, null);
     return status;
   } finally {
-    gl2.deleteTexture(texture);
-    gl2.deleteFramebuffer(framebuffer);
+    gl.deleteTexture(texture);
+    gl.deleteFramebuffer(framebuffer);
   }
 }
 function getTextureFormatBytesPerPixel(formatOrGL, isWebGL23) {
@@ -2043,50 +2043,50 @@ function getWebGLPixelDataFormat(dataFormat, integer, normalized, format) {
 }
 
 // src/adapter/device-helpers/device-features.ts
-function getDeviceFeatures(gl2) {
-  const features = getWebGLFeatures(gl2);
-  for (const textureFeature of getTextureFeatures(gl2)) {
+function getDeviceFeatures(gl) {
+  const features = getWebGLFeatures(gl);
+  for (const textureFeature of getTextureFeatures(gl)) {
     features.add(textureFeature);
   }
   return features;
 }
-function getWebGLFeatures(gl2) {
-  gl2.getExtension("EXT_color_buffer_float");
-  gl2.getExtension("WEBGL_color_buffer_float");
-  gl2.getExtension("EXT_float_blend");
+function getWebGLFeatures(gl) {
+  gl.getExtension("EXT_color_buffer_float");
+  gl.getExtension("WEBGL_color_buffer_float");
+  gl.getExtension("EXT_float_blend");
   const features = /* @__PURE__ */ new Set();
   for (const feature of Object.keys(WEBGL_FEATURES)) {
-    if (isFeatureSupported(gl2, feature)) {
+    if (isFeatureSupported(gl, feature)) {
       features.add(feature);
     }
   }
   return features;
 }
-function isFeatureSupported(gl2, feature) {
+function isFeatureSupported(gl, feature) {
   const featureInfo = WEBGL_FEATURES[feature];
   if (!featureInfo) {
     return false;
   }
   const [webgl1Feature, webgl2Feature] = featureInfo || [];
-  const featureDefinition = isWebGL2(gl2) ? webgl2Feature : webgl1Feature;
+  const featureDefinition = isWebGL2(gl) ? webgl2Feature : webgl1Feature;
   if (typeof featureDefinition === "boolean") {
     return featureDefinition;
   }
   switch (feature) {
     case "texture-renderable-rgba32float-webgl":
-      return isWebGL2(gl2) ? Boolean(gl2.getExtension(featureDefinition)) : _checkFloat32ColorAttachment(gl2);
+      return isWebGL2(gl) ? Boolean(gl.getExtension(featureDefinition)) : _checkFloat32ColorAttachment(gl);
     case "glsl-derivatives":
-      return canCompileGLSLExtension(gl2, featureDefinition);
+      return canCompileGLSLExtension(gl, featureDefinition);
     case "glsl-frag-data":
-      return canCompileGLSLExtension(gl2, featureDefinition, { behavior: "require" });
+      return canCompileGLSLExtension(gl, featureDefinition, { behavior: "require" });
     case "glsl-frag-depth":
-      return canCompileGLSLExtension(gl2, featureDefinition);
+      return canCompileGLSLExtension(gl, featureDefinition);
     default:
-      return Boolean(gl2.getExtension(featureDefinition));
+      return Boolean(gl.getExtension(featureDefinition));
   }
 }
 var compiledGLSLExtensions = {};
-function canCompileGLSLExtension(gl2, extensionName, opts = {}) {
+function canCompileGLSLExtension(gl, extensionName, opts = {}) {
   if (!isOldIE(opts)) {
     return true;
   }
@@ -2096,14 +2096,14 @@ function canCompileGLSLExtension(gl2, extensionName, opts = {}) {
   const behavior = opts.behavior || "enable";
   const source = `#extension GL_${extensionName} : ${behavior}
 void main(void) {}`;
-  const shader = gl2.createShader(gl2.VERTEX_SHADER);
+  const shader = gl.createShader(gl.VERTEX_SHADER);
   if (!shader) {
     throw new Error("shader");
   }
-  gl2.shaderSource(shader, source);
-  gl2.compileShader(shader);
-  const canCompile = gl2.getShaderParameter(shader, gl2.COMPILE_STATUS);
-  gl2.deleteShader(shader);
+  gl.shaderSource(shader, source);
+  gl.compileShader(shader);
+  const canCompile = gl.getShaderParameter(shader, gl.COMPILE_STATUS);
+  gl.deleteShader(shader);
   compiledGLSLExtensions[extensionName] = canCompile;
   return canCompile;
 }
@@ -2141,38 +2141,38 @@ var WEBGL_FEATURES = {
 
 // src/adapter/device-helpers/device-limits.ts
 var import_constants7 = require("@luma.gl/constants");
-function getDeviceLimits(gl2) {
-  const gl22 = getWebGL2Context(gl2);
+function getDeviceLimits(gl) {
+  const gl2 = getWebGL2Context(gl);
   return {
     maxTextureDimension1D: 0,
     // WebGL does not support 1D textures
-    maxTextureDimension2D: gl2.getParameter(import_constants7.GL.MAX_TEXTURE_SIZE),
-    maxTextureDimension3D: gl22 ? gl22.getParameter(import_constants7.GL.MAX_3D_TEXTURE_SIZE) : 0,
-    maxTextureArrayLayers: gl22 ? gl22.getParameter(import_constants7.GL.MAX_ARRAY_TEXTURE_LAYERS) : 0,
+    maxTextureDimension2D: gl.getParameter(import_constants7.GL.MAX_TEXTURE_SIZE),
+    maxTextureDimension3D: gl2 ? gl2.getParameter(import_constants7.GL.MAX_3D_TEXTURE_SIZE) : 0,
+    maxTextureArrayLayers: gl2 ? gl2.getParameter(import_constants7.GL.MAX_ARRAY_TEXTURE_LAYERS) : 0,
     maxBindGroups: 1,
     // TBD
     maxDynamicUniformBuffersPerPipelineLayout: 0,
     // TBD
     maxDynamicStorageBuffersPerPipelineLayout: 0,
     // TBD
-    maxSampledTexturesPerShaderStage: gl2.getParameter(import_constants7.GL.MAX_VERTEX_TEXTURE_IMAGE_UNITS),
+    maxSampledTexturesPerShaderStage: gl.getParameter(import_constants7.GL.MAX_VERTEX_TEXTURE_IMAGE_UNITS),
     // TBD
-    maxSamplersPerShaderStage: gl2.getParameter(import_constants7.GL.MAX_COMBINED_TEXTURE_IMAGE_UNITS),
+    maxSamplersPerShaderStage: gl.getParameter(import_constants7.GL.MAX_COMBINED_TEXTURE_IMAGE_UNITS),
     maxStorageBuffersPerShaderStage: 0,
     // TBD
     maxStorageTexturesPerShaderStage: 0,
     // TBD
-    maxUniformBuffersPerShaderStage: gl22 ? gl22.getParameter(import_constants7.GL.MAX_UNIFORM_BUFFER_BINDINGS) : 0,
-    maxUniformBufferBindingSize: gl22 ? gl22.getParameter(import_constants7.GL.MAX_UNIFORM_BLOCK_SIZE) : 0,
+    maxUniformBuffersPerShaderStage: gl2 ? gl2.getParameter(import_constants7.GL.MAX_UNIFORM_BUFFER_BINDINGS) : 0,
+    maxUniformBufferBindingSize: gl2 ? gl2.getParameter(import_constants7.GL.MAX_UNIFORM_BLOCK_SIZE) : 0,
     maxStorageBufferBindingSize: 0,
-    minUniformBufferOffsetAlignment: gl22 ? gl22.getParameter(import_constants7.GL.UNIFORM_BUFFER_OFFSET_ALIGNMENT) : 0,
+    minUniformBufferOffsetAlignment: gl2 ? gl2.getParameter(import_constants7.GL.UNIFORM_BUFFER_OFFSET_ALIGNMENT) : 0,
     minStorageBufferOffsetAlignment: 0,
     // TBD
     maxVertexBuffers: 0,
-    maxVertexAttributes: gl2.getParameter(import_constants7.GL.MAX_VERTEX_ATTRIBS),
+    maxVertexAttributes: gl.getParameter(import_constants7.GL.MAX_VERTEX_ATTRIBS),
     maxVertexBufferArrayStride: 2048,
     // TBD, this is just the default value from WebGPU
-    maxInterStageShaderComponents: gl22 ? gl22.getParameter(import_constants7.GL.MAX_VARYING_COMPONENTS) : 0,
+    maxInterStageShaderComponents: gl2 ? gl2.getParameter(import_constants7.GL.MAX_VARYING_COMPONENTS) : 0,
     maxComputeWorkgroupStorageSize: 0,
     // WebGL does not support compute shaders
     maxComputeInvocationsPerWorkgroup: 0,
@@ -2187,13 +2187,13 @@ function getDeviceLimits(gl2) {
     // WebGL does not support compute shaders
   };
 }
-function getWebGLLimits(gl2) {
-  const gl22 = getWebGL2Context(gl2);
+function getWebGLLimits(gl) {
+  const gl2 = getWebGL2Context(gl);
   function get(pname) {
-    return gl2.getParameter(pname);
+    return gl.getParameter(pname);
   }
   function get2(pname, defaultValue) {
-    return gl22 ? gl22.getParameter(pname) : defaultValue || 0;
+    return gl2 ? gl2.getParameter(pname) : defaultValue || 0;
   }
   return {
     [import_constants7.GL.ALIASED_LINE_WIDTH_RANGE]: get(import_constants7.GL.ALIASED_LINE_WIDTH_RANGE),
@@ -2296,24 +2296,24 @@ var import_core10 = require("@luma.gl/core");
 var import_constants12 = require("@luma.gl/constants");
 
 // src/context/state-tracker/with-parameters.ts
-function withParameters(device, parameters, func) {
+function withGLParameters(device, parameters, func) {
   const webglDevice = WebGLDevice.attach(device);
-  const gl2 = webglDevice.gl;
+  const gl = webglDevice.gl;
   if (isObjectEmpty2(parameters)) {
     return func(device);
   }
   const { nocatch = true } = parameters;
-  pushContextState(gl2);
-  setParameters(gl2, parameters);
+  pushContextState(gl);
+  setGLParameters(gl, parameters);
   let value;
   if (nocatch) {
-    value = func(gl2);
-    popContextState(gl2);
+    value = func(gl);
+    popContextState(gl);
   } else {
     try {
-      value = func(gl2);
+      value = func(gl);
     } finally {
-      popContextState(gl2);
+      popContextState(gl);
     }
   }
   return value;
@@ -2331,13 +2331,14 @@ var import_constants9 = require("@luma.gl/constants");
 // src/adapter/converters/device-parameters.ts
 var import_core6 = require("@luma.gl/core");
 var import_constants8 = require("@luma.gl/constants");
-function withGLParameters(device, parameters, func) {
+function withDeviceAndGLParameters(device, parameters, glParameters, func) {
   if ((0, import_core6.isObjectEmpty)(parameters)) {
     return func(device);
   }
   pushContextState(device.gl);
   try {
-    setParameters(device, parameters);
+    setDeviceParameters(device, parameters);
+    setGLParameters(device, glParameters);
     return func(device);
   } finally {
     popContextState(device.gl);
@@ -2357,24 +2358,24 @@ function withDeviceParameters(device, parameters, func) {
 }
 function setDeviceParameters(device, parameters) {
   const webglDevice = WebGLDevice.attach(device);
-  const { gl: gl2 } = webglDevice;
+  const { gl } = webglDevice;
   if (parameters.cullMode) {
     switch (parameters.cullMode) {
       case "none":
-        gl2.disable(import_constants8.GL.CULL_FACE);
+        gl.disable(import_constants8.GL.CULL_FACE);
         break;
       case "front":
-        gl2.enable(import_constants8.GL.CULL_FACE);
-        gl2.cullFace(import_constants8.GL.FRONT);
+        gl.enable(import_constants8.GL.CULL_FACE);
+        gl.cullFace(import_constants8.GL.FRONT);
         break;
       case "back":
-        gl2.enable(import_constants8.GL.CULL_FACE);
-        gl2.cullFace(import_constants8.GL.BACK);
+        gl.enable(import_constants8.GL.CULL_FACE);
+        gl.cullFace(import_constants8.GL.BACK);
         break;
     }
   }
   if (parameters.frontFace) {
-    gl2.frontFace(
+    gl.frontFace(
       map("frontFace", parameters.frontFace, {
         ccw: import_constants8.GL.CCW,
         cw: import_constants8.GL.CW
@@ -2382,19 +2383,19 @@ function setDeviceParameters(device, parameters) {
     );
   }
   if (parameters.depthBias !== void 0) {
-    gl2.polygonOffset(parameters.depthBias, parameters.depthBiasSlopeScale || 0);
+    gl.polygonOffset(parameters.depthBias, parameters.depthBiasSlopeScale || 0);
   }
   if (parameters.depthWriteEnabled !== void 0) {
-    gl2.depthMask(mapBoolean("depthWriteEnabled", parameters.depthWriteEnabled));
+    gl.depthMask(mapBoolean("depthWriteEnabled", parameters.depthWriteEnabled));
   }
   if (parameters.depthCompare) {
-    parameters.depthCompare !== "always" ? gl2.enable(import_constants8.GL.DEPTH_TEST) : gl2.disable(import_constants8.GL.DEPTH_TEST);
-    gl2.depthFunc(convertCompareFunction("depthCompare", parameters.depthCompare));
+    parameters.depthCompare !== "always" ? gl.enable(import_constants8.GL.DEPTH_TEST) : gl.disable(import_constants8.GL.DEPTH_TEST);
+    gl.depthFunc(convertCompareFunction("depthCompare", parameters.depthCompare));
   }
   if (parameters.stencilWriteMask) {
     const mask = parameters.stencilWriteMask;
-    gl2.stencilMaskSeparate(import_constants8.GL.FRONT, mask);
-    gl2.stencilMaskSeparate(import_constants8.GL.BACK, mask);
+    gl.stencilMaskSeparate(import_constants8.GL.FRONT, mask);
+    gl.stencilMaskSeparate(import_constants8.GL.BACK, mask);
   }
   if (parameters.stencilReadMask) {
     import_core6.log.warn("stencilReadMask not supported under WebGL");
@@ -2402,9 +2403,9 @@ function setDeviceParameters(device, parameters) {
   if (parameters.stencilCompare) {
     const mask = parameters.stencilReadMask || 4294967295;
     const glValue = convertCompareFunction("depthCompare", parameters.stencilCompare);
-    parameters.stencilCompare !== "always" ? gl2.enable(import_constants8.GL.STENCIL_TEST) : gl2.disable(import_constants8.GL.STENCIL_TEST);
-    gl2.stencilFuncSeparate(import_constants8.GL.FRONT, glValue, 0, mask);
-    gl2.stencilFuncSeparate(import_constants8.GL.BACK, glValue, 0, mask);
+    parameters.stencilCompare !== "always" ? gl.enable(import_constants8.GL.STENCIL_TEST) : gl.disable(import_constants8.GL.STENCIL_TEST);
+    gl.stencilFuncSeparate(import_constants8.GL.FRONT, glValue, 0, mask);
+    gl.stencilFuncSeparate(import_constants8.GL.BACK, glValue, 0, mask);
   }
   if (parameters.stencilPassOperation && parameters.stencilFailOperation && parameters.stencilDepthFailOperation) {
     const dppass = convertStencilOperation("stencilPassOperation", parameters.stencilPassOperation);
@@ -2413,8 +2414,8 @@ function setDeviceParameters(device, parameters) {
       "stencilDepthFailOperation",
       parameters.stencilDepthFailOperation
     );
-    gl2.stencilOpSeparate(import_constants8.GL.FRONT, sfail, dpfail, dppass);
-    gl2.stencilOpSeparate(import_constants8.GL.BACK, sfail, dpfail, dppass);
+    gl.stencilOpSeparate(import_constants8.GL.FRONT, sfail, dpfail, dppass);
+    gl.stencilOpSeparate(import_constants8.GL.BACK, sfail, dpfail, dppass);
   }
 }
 function convertCompareFunction(parameter, value) {
@@ -2903,7 +2904,7 @@ var _WEBGLTexture = class extends import_core10.Texture {
     }
     this.mipmaps = true;
     this.gl.bindTexture(this.target, this.handle);
-    withParameters(this.gl, params, () => {
+    withGLParameters(this.gl, params, () => {
       this.gl.generateMipmap(this.target);
     });
     this.gl.bindTexture(this.target, null);
@@ -2963,18 +2964,18 @@ var _WEBGLTexture = class extends import_core10.Texture {
       width,
       height
     }));
-    const { gl: gl2 } = this;
-    gl2.bindTexture(this.target, this.handle);
+    const { gl } = this;
+    gl.bindTexture(this.target, this.handle);
     let dataType = null;
     ({ data, dataType } = this._getDataType({ data, compressed }));
-    let gl22;
-    withParameters(this.gl, parameters, () => {
+    let gl2;
+    withGLParameters(this.gl, parameters, () => {
       switch (dataType) {
         case "null":
-          gl2.texImage2D(target, level, glFormat, width, height, 0, dataFormat, type, data);
+          gl.texImage2D(target, level, glFormat, width, height, 0, dataFormat, type, data);
           break;
         case "typed-array":
-          gl2.texImage2D(
+          gl.texImage2D(
             target,
             level,
             glFormat,
@@ -2990,9 +2991,9 @@ var _WEBGLTexture = class extends import_core10.Texture {
           );
           break;
         case "buffer":
-          gl22 = this.device.assertWebGL2();
-          gl22.bindBuffer(import_constants12.GL.PIXEL_UNPACK_BUFFER, data.handle || data);
-          gl22.texImage2D(
+          gl2 = this.device.assertWebGL2();
+          gl2.bindBuffer(import_constants12.GL.PIXEL_UNPACK_BUFFER, data.handle || data);
+          gl2.texImage2D(
             target,
             level,
             glFormat,
@@ -3003,11 +3004,11 @@ var _WEBGLTexture = class extends import_core10.Texture {
             type,
             offset
           );
-          gl22.bindBuffer(import_constants12.GL.PIXEL_UNPACK_BUFFER, null);
+          gl2.bindBuffer(import_constants12.GL.PIXEL_UNPACK_BUFFER, null);
           break;
         case "browser-object":
           if (this.device.isWebGL2) {
-            gl2.texImage2D(
+            gl.texImage2D(
               target,
               level,
               glFormat,
@@ -3019,12 +3020,12 @@ var _WEBGLTexture = class extends import_core10.Texture {
               data
             );
           } else {
-            gl2.texImage2D(target, level, glFormat, dataFormat, type, data);
+            gl.texImage2D(target, level, glFormat, dataFormat, type, data);
           }
           break;
         case "compressed":
           for (const [levelIndex, levelData] of data.entries()) {
-            gl2.compressedTexImage2D(
+            gl.compressedTexImage2D(
               target,
               levelIndex,
               levelData.format,
@@ -3092,7 +3093,7 @@ var _WEBGLTexture = class extends import_core10.Texture {
       data = data.handle;
     }
     this.gl.bindTexture(this.target, this.handle);
-    withParameters(this.gl, parameters, () => {
+    withGLParameters(this.gl, parameters, () => {
       if (compressed) {
         this.gl.compressedTexSubImage2D(target, level, x, y, width, height, glFormat, data);
       } else if (data === null) {
@@ -3131,21 +3132,21 @@ var _WEBGLTexture = class extends import_core10.Texture {
     return this.gl.getParameter(import_constants12.GL.ACTIVE_TEXTURE) - import_constants12.GL.TEXTURE0;
   }
   bind(textureUnit = this.textureUnit) {
-    const { gl: gl2 } = this;
+    const { gl } = this;
     if (textureUnit !== void 0) {
       this.textureUnit = textureUnit;
-      gl2.activeTexture(gl2.TEXTURE0 + textureUnit);
+      gl.activeTexture(gl.TEXTURE0 + textureUnit);
     }
-    gl2.bindTexture(this.target, this.handle);
+    gl.bindTexture(this.target, this.handle);
     return textureUnit;
   }
   unbind(textureUnit = this.textureUnit) {
-    const { gl: gl2 } = this;
+    const { gl } = this;
     if (textureUnit !== void 0) {
       this.textureUnit = textureUnit;
-      gl2.activeTexture(gl2.TEXTURE0 + textureUnit);
+      gl.activeTexture(gl.TEXTURE0 + textureUnit);
     }
-    gl2.bindTexture(this.target, null);
+    gl.bindTexture(this.target, null);
     return textureUnit;
   }
   // PRIVATE METHODS
@@ -3211,7 +3212,7 @@ var _WEBGLTexture = class extends import_core10.Texture {
   /* eslint-disable max-statements, max-len */
   setCubeMapImageData(options) {
     return __async(this, null, function* () {
-      const { gl: gl2 } = this;
+      const { gl } = this;
       const { width, height, pixels, data, format = import_constants12.GL.RGBA, type = import_constants12.GL.UNSIGNED_BYTE } = options;
       const imageDataMap = pixels || data;
       const resolvedFaces = yield Promise.all(
@@ -3227,9 +3228,9 @@ var _WEBGLTexture = class extends import_core10.Texture {
         }
         resolvedFaces[index].forEach((image, lodLevel) => {
           if (width && height) {
-            gl2.texImage2D(face, lodLevel, format, width, height, 0, format, type, image);
+            gl.texImage2D(face, lodLevel, format, width, height, 0, format, type, image);
           } else {
-            gl2.texImage2D(face, lodLevel, format, format, type, image);
+            gl.texImage2D(face, lodLevel, format, format, type, image);
           }
         });
       });
@@ -3248,7 +3249,7 @@ var _WEBGLTexture = class extends import_core10.Texture {
       type = import_constants12.GL.UNSIGNED_BYTE
       // generateMipmap = false // TODO
     } = options;
-    const { gl: gl2 } = this;
+    const { gl } = this;
     const imageData = pixels || data;
     this.bind();
     if (imageData instanceof Promise) {
@@ -3262,9 +3263,9 @@ var _WEBGLTexture = class extends import_core10.Texture {
         )
       );
     } else if (this.width || this.height) {
-      gl2.texImage2D(face, 0, format, width, height, 0, format, type, imageData);
+      gl.texImage2D(face, 0, format, width, height, 0, format, type, imageData);
     } else {
-      gl2.texImage2D(face, 0, format, format, type, imageData);
+      gl.texImage2D(face, 0, format, format, type, imageData);
     }
     return this;
   }
@@ -3286,7 +3287,7 @@ var _WEBGLTexture = class extends import_core10.Texture {
     this.trackDeallocatedMemory("Texture");
     this.gl.bindTexture(this.target, this.handle);
     const webglTextureFormat = getWebGLTextureParameters(format, this.device.isWebGL2);
-    withParameters(this.gl, parameters, () => {
+    withGLParameters(this.gl, parameters, () => {
       if (ArrayBuffer.isView(data)) {
         this.gl.texImage3D(
           this.target,
@@ -3422,17 +3423,17 @@ var import_core12 = require("@luma.gl/core");
 
 // src/adapter/objects/constants-to-keys.ts
 var import_core11 = require("@luma.gl/core");
-function getKeyValue(gl2, name2) {
-  if (typeof name2 !== "string") {
-    return name2;
+function getKeyValue(gl, name) {
+  if (typeof name !== "string") {
+    return name;
   }
-  const number = Number(name2);
+  const number = Number(name);
   if (!isNaN(number)) {
     return number;
   }
-  name2 = name2.replace(/^.*\./, "");
-  const value = gl2[name2];
-  (0, import_core11.assert)(value !== void 0, `Accessing undefined constant GL.${name2}`);
+  name = name.replace(/^.*\./, "");
+  const value = gl[name];
+  (0, import_core11.assert)(value !== void 0, `Accessing undefined constant GL.${name}`);
   return value;
 }
 
@@ -3445,11 +3446,11 @@ var WebGLResource = class extends import_core12.Resource {
     // Only meaningful for resources that allocate GPU memory
     this.byteLength = 0;
     this.device = WebGLDevice.attach(device);
-    const gl2 = this.device.gl;
-    assertWebGLContext(gl2);
+    const gl = this.device.gl;
+    assertWebGLContext(gl);
     const { id } = props || {};
-    this.gl = gl2;
-    this.gl2 = gl2;
+    this.gl = gl;
+    this.gl2 = gl;
     this.id = id || (0, import_core12.uid)(this.constructor.name);
     this._handle = props == null ? void 0 : props.handle;
     if (this._handle === void 0) {
@@ -3760,11 +3761,11 @@ var WEBGLFramebuffer = class extends import_core14.Framebuffer {
   // PRIVATE
   /** Check the status */
   _checkStatus() {
-    const { gl: gl2 } = this;
-    const prevHandle2 = gl2.bindFramebuffer(import_constants14.GL.FRAMEBUFFER, this.handle);
-    const status = gl2.checkFramebufferStatus(import_constants14.GL.FRAMEBUFFER);
-    gl2.bindFramebuffer(import_constants14.GL.FRAMEBUFFER, prevHandle2 || null);
-    if (status !== gl2.FRAMEBUFFER_COMPLETE) {
+    const { gl } = this;
+    const prevHandle = gl.bindFramebuffer(import_constants14.GL.FRAMEBUFFER, this.handle);
+    const status = gl.checkFramebufferStatus(import_constants14.GL.FRAMEBUFFER);
+    gl.bindFramebuffer(import_constants14.GL.FRAMEBUFFER, prevHandle || null);
+    if (status !== gl.FRAMEBUFFER_COMPLETE) {
       throw new Error(`Framebuffer ${_getFrameBufferStatus(status)}`);
     }
   }
@@ -3833,25 +3834,25 @@ var WEBGLFramebuffer = class extends import_core14.Framebuffer {
    * @param level  = 0 - mipmapLevel (must be 0 in WebGL1)
    */
   _attachTexture(attachment, texture, layer, level) {
-    const { gl: gl2, gl2: gl22 } = this.device;
-    gl2.bindTexture(texture.target, texture.handle);
+    const { gl, gl2 } = this.device;
+    gl.bindTexture(texture.target, texture.handle);
     switch (texture.target) {
       case import_constants14.GL.TEXTURE_2D_ARRAY:
       case import_constants14.GL.TEXTURE_3D:
         this.device.assertWebGL2();
-        gl22 == null ? void 0 : gl22.framebufferTextureLayer(import_constants14.GL.FRAMEBUFFER, attachment, texture.target, level, layer);
+        gl2 == null ? void 0 : gl2.framebufferTextureLayer(import_constants14.GL.FRAMEBUFFER, attachment, texture.target, level, layer);
         break;
       case import_constants14.GL.TEXTURE_CUBE_MAP:
         const face = mapIndexToCubeMapFace(layer);
-        gl2.framebufferTexture2D(import_constants14.GL.FRAMEBUFFER, attachment, face, texture.handle, level);
+        gl.framebufferTexture2D(import_constants14.GL.FRAMEBUFFER, attachment, face, texture.handle, level);
         break;
       case import_constants14.GL.TEXTURE_2D:
-        gl2.framebufferTexture2D(import_constants14.GL.FRAMEBUFFER, attachment, import_constants14.GL.TEXTURE_2D, texture.handle, level);
+        gl.framebufferTexture2D(import_constants14.GL.FRAMEBUFFER, attachment, import_constants14.GL.TEXTURE_2D, texture.handle, level);
         break;
       default:
         (0, import_core14.assert)(false, "Illegal texture type");
     }
-    gl2.bindTexture(texture.target, null);
+    gl.bindTexture(texture.target, null);
   }
 };
 function mapIndexToCubeMapFace(layer) {
@@ -3990,9 +3991,9 @@ var import_core17 = require("@luma.gl/core");
 var import_constants15 = require("@luma.gl/constants");
 var import_env = require("@probe.gl/env");
 var WEBGL_DEBUG_CDN_URL = "https://unpkg.com/webgl-debug@2.0.1/index.js";
-function getContextData2(gl2) {
-  gl2.luma = gl2.luma || {};
-  return gl2.luma;
+function getContextData2(gl) {
+  gl.luma = gl.luma || {};
+  return gl.luma;
 }
 function loadWebGLDeveloperTools() {
   return __async(this, null, function* () {
@@ -4003,28 +4004,28 @@ function loadWebGLDeveloperTools() {
     }
   });
 }
-function makeDebugContext(gl2, props = {}) {
-  if (!gl2) {
+function makeDebugContext(gl, props = {}) {
+  if (!gl) {
     return null;
   }
-  return props.debug ? getDebugContext(gl2, props) : getRealContext(gl2);
+  return props.debug ? getDebugContext(gl, props) : getRealContext(gl);
 }
-function getRealContext(gl2) {
-  const data = getContextData2(gl2);
-  return data.realContext ? data.realContext : gl2;
+function getRealContext(gl) {
+  const data = getContextData2(gl);
+  return data.realContext ? data.realContext : gl;
 }
-function getDebugContext(gl2, props) {
+function getDebugContext(gl, props) {
   if (!globalThis.WebGLDebugUtils) {
     import_core17.log.warn("webgl-debug not loaded")();
-    return gl2;
+    return gl;
   }
-  const data = getContextData2(gl2);
+  const data = getContextData2(gl);
   if (data.debugContext) {
     return data.debugContext;
   }
-  globalThis.WebGLDebugUtils.init(__spreadValues(__spreadValues({}, import_constants15.GL), gl2));
+  globalThis.WebGLDebugUtils.init(__spreadValues(__spreadValues({}, import_constants15.GL), gl));
   const glDebug = globalThis.WebGLDebugUtils.makeDebugContext(
-    gl2,
+    gl,
     onGLError.bind(null, props),
     onValidateGLFunc.bind(null, props)
   );
@@ -4035,10 +4036,10 @@ function getDebugContext(gl2, props) {
   }
   class WebGLDebugContext {
   }
-  Object.setPrototypeOf(glDebug, Object.getPrototypeOf(gl2));
+  Object.setPrototypeOf(glDebug, Object.getPrototypeOf(gl));
   Object.setPrototypeOf(WebGLDebugContext, glDebug);
   const debugContext = Object.create(WebGLDebugContext);
-  data.realContext = gl2;
+  data.realContext = gl;
   data.debugContext = debugContext;
   debugContext.debug = true;
   return debugContext;
@@ -4405,13 +4406,13 @@ var BufferWithAccessor = class extends WEBGLBuffer {
    */
   copyData(options) {
     const { sourceBuffer, readOffset = 0, writeOffset = 0, size } = options;
-    const { gl: gl2, gl2: gl22 } = this;
-    assertWebGL2Context(gl2);
-    gl2.bindBuffer(import_constants18.GL.COPY_READ_BUFFER, sourceBuffer.handle);
-    gl2.bindBuffer(import_constants18.GL.COPY_WRITE_BUFFER, this.handle);
-    gl22 == null ? void 0 : gl22.copyBufferSubData(import_constants18.GL.COPY_READ_BUFFER, import_constants18.GL.COPY_WRITE_BUFFER, readOffset, writeOffset, size);
-    gl2.bindBuffer(import_constants18.GL.COPY_READ_BUFFER, null);
-    gl2.bindBuffer(import_constants18.GL.COPY_WRITE_BUFFER, null);
+    const { gl, gl2 } = this;
+    assertWebGL2Context(gl);
+    gl.bindBuffer(import_constants18.GL.COPY_READ_BUFFER, sourceBuffer.handle);
+    gl.bindBuffer(import_constants18.GL.COPY_WRITE_BUFFER, this.handle);
+    gl2 == null ? void 0 : gl2.copyBufferSubData(import_constants18.GL.COPY_READ_BUFFER, import_constants18.GL.COPY_WRITE_BUFFER, readOffset, writeOffset, size);
+    gl.bindBuffer(import_constants18.GL.COPY_READ_BUFFER, null);
+    gl.bindBuffer(import_constants18.GL.COPY_WRITE_BUFFER, null);
     this.debugData = null;
     return this;
   }
@@ -4664,15 +4665,15 @@ var WEBGLShader = class extends import_core20.Shader {
     const addGLSLVersion = (source2) => source2.startsWith("#version ") ? source2 : `#version 100
 ${source2}`;
     source = addGLSLVersion(source);
-    const { gl: gl2 } = this.device;
-    gl2.shaderSource(this.handle, source);
-    gl2.compileShader(this.handle);
-    const compileStatus = gl2.getShaderParameter(this.handle, import_constants19.GL.COMPILE_STATUS);
+    const { gl } = this.device;
+    gl.shaderSource(this.handle, source);
+    gl.compileShader(this.handle);
+    const compileStatus = gl.getShaderParameter(this.handle, import_constants19.GL.COMPILE_STATUS);
     if (!compileStatus) {
-      const shaderLog = gl2.getShaderInfoLog(this.handle);
+      const shaderLog = gl.getShaderInfoLog(this.handle);
       const parsedLog = shaderLog ? parseShaderCompilerLog(shaderLog) : [];
       const messages = parsedLog.filter((message2) => message2.type === "error");
-      const formattedLog = (0, import_core20.formatCompilerLog)(messages, source);
+      const formattedLog = (0, import_core20.formatCompilerLog)(messages, source, { showSourceCode: true });
       const shaderName = getShaderInfo(source).name;
       const shaderDescription = `${this.stage} shader ${shaderName}`;
       import_core20.log.error(`GLSL compilation errors in ${shaderDescription}
@@ -4744,6 +4745,7 @@ var WEBGLRenderPass = class extends import_core21.RenderPass {
       parameters[import_constants20.GL.STENCIL_REF] = parameters.stencilReference;
     }
     this.glParameters = glParameters;
+    setGLParameters(this.device, glParameters);
   }
   // Internal
   /**
@@ -4765,7 +4767,7 @@ var WEBGLRenderPass = class extends import_core21.RenderPass {
       glParameters.clearStencil = this.props.clearStencil;
     }
     if (clearMask !== 0) {
-      withParameters(this.device, glParameters, () => {
+      withGLParameters(this.device, glParameters, () => {
         this.device.gl.clear(clearMask);
       });
     }
@@ -4774,7 +4776,7 @@ var WEBGLRenderPass = class extends import_core21.RenderPass {
    * WebGL2 - clear a specific color buffer 
    */
   clearColorBuffer(drawBuffer = 0, value = [0, 0, 0, 0]) {
-    withParameters(this.device.gl2, { framebuffer: this.props.framebuffer }, () => {
+    withGLParameters(this.device.gl2, { framebuffer: this.props.framebuffer }, () => {
       switch (value.constructor) {
         case Int32Array:
           this.device.gl2.clearBufferiv(GL_COLOR, drawBuffer, value);
@@ -4810,9 +4812,9 @@ var WEBGLRenderPass = class extends import_core21.RenderPass {
 };
 
 // src/adapter/resources/webgl-render-pipeline.ts
+var import_core22 = require("@luma.gl/core");
 var import_core23 = require("@luma.gl/core");
-var import_core24 = require("@luma.gl/core");
-var import_constants25 = require("@luma.gl/constants");
+var import_constants24 = require("@luma.gl/constants");
 
 // src/adapter/helpers/get-shader-layout.ts
 var import_constants22 = require("@luma.gl/constants");
@@ -4895,13 +4897,13 @@ function decodeGLAttributeType(glAttributeType) {
 }
 
 // src/adapter/helpers/get-shader-layout.ts
-function getShaderLayout(gl2, program) {
+function getShaderLayout(gl, program) {
   const shaderLayout = {
     attributes: [],
     bindings: []
   };
-  shaderLayout.attributes = readAttributeDeclarations(gl2, program);
-  const uniformBlocks = readUniformBlocks(gl2, program);
+  shaderLayout.attributes = readAttributeDeclarations(gl, program);
+  const uniformBlocks = readUniformBlocks(gl, program);
   for (const uniformBlock of uniformBlocks) {
     const uniforms2 = uniformBlock.uniforms.map((uniform) => ({
       name: uniform.name,
@@ -4919,7 +4921,7 @@ function getShaderLayout(gl2, program) {
       uniforms: uniforms2
     });
   }
-  const uniforms = readUniformBindings(gl2, program);
+  const uniforms = readUniformBindings(gl, program);
   let textureUnit = 0;
   for (const uniform of uniforms) {
     if (isSamplerUniform(uniform.type)) {
@@ -4938,31 +4940,31 @@ function getShaderLayout(gl2, program) {
   if (uniforms.length) {
     shaderLayout.uniforms = uniforms;
   }
-  const varyings = readVaryings(gl2, program);
+  const varyings = readVaryings(gl, program);
   if (varyings == null ? void 0 : varyings.length) {
     shaderLayout.varyings = varyings;
   }
   return shaderLayout;
 }
-function readAttributeDeclarations(gl2, program) {
+function readAttributeDeclarations(gl, program) {
   const attributes = [];
-  const count = gl2.getProgramParameter(program, gl2.ACTIVE_ATTRIBUTES);
+  const count = gl.getProgramParameter(program, gl.ACTIVE_ATTRIBUTES);
   for (let index = 0; index < count; index++) {
-    const activeInfo = gl2.getActiveAttrib(program, index);
+    const activeInfo = gl.getActiveAttrib(program, index);
     if (!activeInfo) {
       throw new Error("activeInfo");
     }
     const {
-      name: name2,
+      name,
       type: compositeType
       /* , size*/
     } = activeInfo;
-    const location = gl2.getAttribLocation(program, name2);
+    const location = gl.getAttribLocation(program, name);
     if (location >= 0) {
       const { attributeType } = decodeGLAttributeType(compositeType);
-      const stepMode = /instance/i.test(name2) ? "instance" : "vertex";
+      const stepMode = /instance/i.test(name) ? "instance" : "vertex";
       attributes.push({
-        name: name2,
+        name,
         location,
         stepMode,
         type: attributeType
@@ -4973,42 +4975,42 @@ function readAttributeDeclarations(gl2, program) {
   attributes.sort((a, b) => a.location - b.location);
   return attributes;
 }
-function readVaryings(gl2, program) {
-  if (!isWebGL2(gl2)) {
+function readVaryings(gl, program) {
+  if (!isWebGL2(gl)) {
     return [];
   }
-  const gl22 = gl2;
+  const gl2 = gl;
   const varyings = [];
-  const count = gl2.getProgramParameter(program, import_constants22.GL.TRANSFORM_FEEDBACK_VARYINGS);
+  const count = gl.getProgramParameter(program, import_constants22.GL.TRANSFORM_FEEDBACK_VARYINGS);
   for (let location = 0; location < count; location++) {
-    const activeInfo = gl22.getTransformFeedbackVarying(program, location);
+    const activeInfo = gl2.getTransformFeedbackVarying(program, location);
     if (!activeInfo) {
       throw new Error("activeInfo");
     }
-    const { name: name2, type: compositeType, size } = activeInfo;
+    const { name, type: compositeType, size } = activeInfo;
     const { glType, components } = decodeGLUniformType(compositeType);
     const accessor = new Accessor({ type: glType, size: size * components });
-    const varying = { location, name: name2, accessor };
+    const varying = { location, name, accessor };
     varyings.push(varying);
   }
   varyings.sort((a, b) => a.location - b.location);
   return varyings;
 }
-function readUniformBindings(gl2, program) {
+function readUniformBindings(gl, program) {
   const uniforms = [];
-  const uniformCount = gl2.getProgramParameter(program, import_constants22.GL.ACTIVE_UNIFORMS);
+  const uniformCount = gl.getProgramParameter(program, import_constants22.GL.ACTIVE_UNIFORMS);
   for (let i = 0; i < uniformCount; i++) {
-    const activeInfo = gl2.getActiveUniform(program, i);
+    const activeInfo = gl.getActiveUniform(program, i);
     if (!activeInfo) {
       throw new Error("activeInfo");
     }
     const { name: rawName, size, type } = activeInfo;
-    const { name: name2, isArray: isArray2 } = parseUniformName(rawName);
-    let webglLocation = gl2.getUniformLocation(program, name2);
+    const { name, isArray: isArray2 } = parseUniformName(rawName);
+    let webglLocation = gl.getUniformLocation(program, name);
     const uniformInfo = {
       // WebGL locations are uniquely typed but just numbers
       location: webglLocation,
-      name: name2,
+      name,
       size,
       type,
       isArray: isArray2
@@ -5016,8 +5018,8 @@ function readUniformBindings(gl2, program) {
     uniforms.push(uniformInfo);
     if (uniformInfo.size > 1) {
       for (let j = 0; j < uniformInfo.size; j++) {
-        const elementName = `${name2}[${j}]`;
-        webglLocation = gl2.getUniformLocation(program, elementName);
+        const elementName = `${name}[${j}]`;
+        webglLocation = gl.getUniformLocation(program, elementName);
         const arrayElementUniformInfo = __spreadProps(__spreadValues({}, uniformInfo), {
           name: elementName,
           location: webglLocation
@@ -5028,17 +5030,17 @@ function readUniformBindings(gl2, program) {
   }
   return uniforms;
 }
-function readUniformBlocks(gl2, program) {
-  if (!isWebGL2(gl2)) {
+function readUniformBlocks(gl, program) {
+  if (!isWebGL2(gl)) {
     return [];
   }
-  const gl22 = gl2;
-  const getBlockParameter = (blockIndex, pname) => gl22.getActiveUniformBlockParameter(program, blockIndex, pname);
+  const gl2 = gl;
+  const getBlockParameter = (blockIndex, pname) => gl2.getActiveUniformBlockParameter(program, blockIndex, pname);
   const uniformBlocks = [];
-  const blockCount = gl22.getProgramParameter(program, import_constants22.GL.ACTIVE_UNIFORM_BLOCKS);
+  const blockCount = gl2.getProgramParameter(program, import_constants22.GL.ACTIVE_UNIFORM_BLOCKS);
   for (let blockIndex = 0; blockIndex < blockCount; blockIndex++) {
     const blockInfo = {
-      name: gl22.getActiveUniformBlockName(program, blockIndex) || "",
+      name: gl2.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),
@@ -5047,12 +5049,12 @@ function readUniformBlocks(gl2, program) {
       uniforms: []
     };
     const uniformIndices = getBlockParameter(blockIndex, import_constants22.GL.UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES) || [];
-    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);
+    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);
     for (let i = 0; i < blockInfo.uniformCount; ++i) {
-      const activeInfo = gl22.getActiveUniform(program, uniformIndices[i]);
+      const activeInfo = gl2.getActiveUniform(program, uniformIndices[i]);
       if (!activeInfo) {
         throw new Error("activeInfo");
       }
@@ -5097,18 +5099,18 @@ function getSamplerInfo(type) {
   const [viewDimension, sampleType] = sampler;
   return { viewDimension, sampleType };
 }
-function parseUniformName(name2) {
-  if (name2[name2.length - 1] !== "]") {
+function parseUniformName(name) {
+  if (name[name.length - 1] !== "]") {
     return {
-      name: name2,
+      name,
       length: 1,
       isArray: false
     };
   }
   const UNIFORM_NAME_REGEXP = /([^[]*)(\[[0-9]+\])?/;
-  const matches = UNIFORM_NAME_REGEXP.exec(name2);
+  const matches = UNIFORM_NAME_REGEXP.exec(name);
   if (!matches || matches.length < 2) {
-    throw new Error(`Failed to parse GLSL uniform name ${name2}`);
+    throw new Error(`Failed to parse GLSL uniform name ${name}`);
   }
   return {
     name: matches[1],
@@ -5119,8 +5121,8 @@ function parseUniformName(name2) {
 
 // src/adapter/helpers/set-uniform.ts
 var import_constants23 = require("@luma.gl/constants");
-function setUniform(gl2, location, type, value) {
-  const gl22 = gl2;
+function setUniform(gl, location, type, value) {
+  const gl2 = gl;
   let uniformValue = value;
   if (uniformValue === true) {
     uniformValue = 1;
@@ -5148,241 +5150,64 @@ function setUniform(gl2, location, type, value) {
       if (typeof value !== "number") {
         throw new Error("samplers must be set to integers");
       }
-      return gl2.uniform1i(location, value);
+      return gl.uniform1i(location, value);
     case import_constants23.GL.FLOAT:
-      return gl2.uniform1fv(location, arrayValue);
+      return gl.uniform1fv(location, arrayValue);
     case import_constants23.GL.FLOAT_VEC2:
-      return gl2.uniform2fv(location, arrayValue);
+      return gl.uniform2fv(location, arrayValue);
     case import_constants23.GL.FLOAT_VEC3:
-      return gl2.uniform3fv(location, arrayValue);
+      return gl.uniform3fv(location, arrayValue);
     case import_constants23.GL.FLOAT_VEC4:
-      return gl2.uniform4fv(location, arrayValue);
+      return gl.uniform4fv(location, arrayValue);
     case import_constants23.GL.INT:
-      return gl2.uniform1iv(location, arrayValue);
+      return gl.uniform1iv(location, arrayValue);
     case import_constants23.GL.INT_VEC2:
-      return gl2.uniform2iv(location, arrayValue);
+      return gl.uniform2iv(location, arrayValue);
     case import_constants23.GL.INT_VEC3:
-      return gl2.uniform3iv(location, arrayValue);
+      return gl.uniform3iv(location, arrayValue);
     case import_constants23.GL.INT_VEC4:
-      return gl2.uniform4iv(location, arrayValue);
+      return gl.uniform4iv(location, arrayValue);
     case import_constants23.GL.BOOL:
-      return gl2.uniform1iv(location, arrayValue);
+      return gl.uniform1iv(location, arrayValue);
     case import_constants23.GL.BOOL_VEC2:
-      return gl2.uniform2iv(location, arrayValue);
+      return gl.uniform2iv(location, arrayValue);
     case import_constants23.GL.BOOL_VEC3:
-      return gl2.uniform3iv(location, arrayValue);
+      return gl.uniform3iv(location, arrayValue);
     case import_constants23.GL.BOOL_VEC4:
-      return gl2.uniform4iv(location, arrayValue);
+      return gl.uniform4iv(location, arrayValue);
     case import_constants23.GL.UNSIGNED_INT:
-      return gl22.uniform1uiv(location, arrayValue, 1);
+      return gl2.uniform1uiv(location, arrayValue, 1);
     case import_constants23.GL.UNSIGNED_INT_VEC2:
-      return gl22.uniform2uiv(location, arrayValue, 2);
+      return gl2.uniform2uiv(location, arrayValue, 2);
     case import_constants23.GL.UNSIGNED_INT_VEC3:
-      return gl22.uniform3uiv(location, arrayValue, 3);
+      return gl2.uniform3uiv(location, arrayValue, 3);
     case import_constants23.GL.UNSIGNED_INT_VEC4:
-      return gl22.uniform4uiv(location, arrayValue, 4);
+      return gl2.uniform4uiv(location, arrayValue, 4);
     case import_constants23.GL.FLOAT_MAT2:
-      return gl2.uniformMatrix2fv(location, false, arrayValue);
+      return gl.uniformMatrix2fv(location, false, arrayValue);
     case import_constants23.GL.FLOAT_MAT3:
-      return gl2.uniformMatrix3fv(location, false, arrayValue);
+      return gl.uniformMatrix3fv(location, false, arrayValue);
     case import_constants23.GL.FLOAT_MAT4:
-      return gl2.uniformMatrix4fv(location, false, arrayValue);
+      return gl.uniformMatrix4fv(location, false, arrayValue);
     case import_constants23.GL.FLOAT_MAT2x3:
-      return gl22.uniformMatrix2x3fv(location, false, arrayValue);
+      return gl2.uniformMatrix2x3fv(location, false, arrayValue);
     case import_constants23.GL.FLOAT_MAT2x4:
-      return gl22.uniformMatrix2x4fv(location, false, arrayValue);
+      return gl2.uniformMatrix2x4fv(location, false, arrayValue);
     case import_constants23.GL.FLOAT_MAT3x2:
-      return gl22.uniformMatrix3x2fv(location, false, arrayValue);
+      return gl2.uniformMatrix3x2fv(location, false, arrayValue);
     case import_constants23.GL.FLOAT_MAT3x4:
-      return gl22.uniformMatrix3x4fv(location, false, arrayValue);
+      return gl2.uniformMatrix3x4fv(location, false, arrayValue);
     case import_constants23.GL.FLOAT_MAT4x2:
-      return gl22.uniformMatrix4x2fv(location, false, arrayValue);
+      return gl2.uniformMatrix4x2fv(location, false, arrayValue);
     case import_constants23.GL.FLOAT_MAT4x3:
-      return gl22.uniformMatrix4x3fv(location, false, arrayValue);
+      return gl2.uniformMatrix4x3fv(location, false, arrayValue);
   }
   throw new Error("Illegal uniform");
 }
 
-// src/adapter/objects/webgl-vertex-array-object.ts
-var import_core22 = require("@luma.gl/core");
-var import_constants24 = require("@luma.gl/constants");
-var import_env2 = require("@probe.gl/env");
-var ERR_ELEMENTS = "elements must be GL.ELEMENT_ARRAY_BUFFER";
-var WEBGLVertexArrayObject = class extends WebGLResource {
-  // Create a VertexArray
-  constructor(device, props) {
-    super(device, props, __spreadProps(__spreadValues({}, import_core22.Resource.defaultProps), { constantAttributeZero: false }));
-    /** Buffer constant */
-    this.buffer = null;
-    this.bufferValue = null;
-    Object.seal(this);
-  }
-  get [Symbol.toStringTag]() {
-    return "BaseVertexArrayObject";
-  }
-  static isConstantAttributeZeroSupported(device) {
-    return device.info.type === "webgl2" || (0, import_env2.getBrowser)() === "Chrome";
-  }
-  destroy() {
-    var _a;
-    super.destroy();
-    if (this.buffer) {
-      (_a = this.buffer) == null ? void 0 : _a.destroy();
-    }
-  }
-  _createHandle() {
-    return this.gl2.createVertexArray();
-  }
-  _deleteHandle() {
-    this.gl2.deleteVertexArray(this.handle);
-    return [this.elements];
-  }
-  _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_env2.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 = {}) {
-    (0, import_core22.assert)(!elementBuffer || elementBuffer.glTarget === import_constants24.GL.ELEMENT_ARRAY_BUFFER, ERR_ELEMENTS);
-    this.bind(() => {
-      this.gl.bindBuffer(import_constants24.GL.ELEMENT_ARRAY_BUFFER, elementBuffer ? elementBuffer.handle : null);
-    });
-  }
-  /** Set a location in vertex attributes array to a buffer, enables the location, sets divisor */
-  setBuffer(location, buffer, accessor) {
-    if (buffer.glTarget === import_constants24.GL.ELEMENT_ARRAY_BUFFER) {
-      this.setElementBuffer(buffer, accessor);
-      return;
-    }
-    const { size, type, stride, offset, normalized, integer, divisor } = accessor;
-    const { gl: gl2, gl2: gl22 } = this;
-    location = Number(location);
-    this.bind(() => {
-      gl2.bindBuffer(gl2.ARRAY_BUFFER, buffer.handle);
-      if (integer) {
-        this.device.assertWebGL2();
-        gl22.vertexAttribIPointer(location, size, type, stride, offset);
-      } else {
-        gl2.vertexAttribPointer(location, size, type, normalized, stride, offset);
-      }
-      gl2.enableVertexAttribArray(location);
-      gl22.vertexAttribDivisor(location, divisor || 0);
-    });
-  }
-  /**
-   * 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?
-   */
-  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_core22.assert)(false);
-    }
-  }
-  /**
-   * 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_core22.getScratchArray)(value.constructor, length);
-      (0, import_core22.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_core22.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;
-var WEBGLRenderPipeline = class extends import_core23.RenderPipeline {
+var WEBGLRenderPipeline = class extends import_core22.RenderPipeline {
   // TODO are these used?
   constructor(device, props) {
     var _a;
@@ -5391,8 +5216,6 @@ var WEBGLRenderPipeline = class extends import_core23.RenderPipeline {
     this.uniforms = {};
     /** Bindings set on this model */
     this.bindings = {};
-    /** Any constant attributes */
-    this.constantAttributes = {};
     /** WebGL varyings */
     this.varyings = null;
     this._textureUniforms = {};
@@ -5402,9 +5225,9 @@ var WEBGLRenderPipeline = class extends import_core23.RenderPipeline {
     this.device = device;
     this.handle = this.props.handle || this.device.gl.createProgram();
     this.device.setSpectorMetadata(this.handle, { id: this.props.id });
-    this.vs = (0, import_core23.cast)(props.vs);
-    this.fs = (0, import_core23.cast)(props.fs);
-    const { varyings, bufferMode = import_constants25.GL.SEPARATE_ATTRIBS } = props;
+    this.vs = (0, import_core22.cast)(props.vs);
+    this.fs = (0, import_core22.cast)(props.fs);
+    const { varyings, bufferMode = import_constants24.GL.SEPARATE_ATTRIBS } = props;
     if (varyings && varyings.length > 0) {
       this.device.assertWebGL2();
       this.varyings = varyings;
@@ -5412,9 +5235,7 @@ var WEBGLRenderPipeline = class extends import_core23.RenderPipeline {
     }
     this._compileAndLink();
     this.introspectedLayout = getShaderLayout(this.device.gl, this.handle);
-    this.shaderLayout = (0, import_core24.mergeShaderLayout)(this.introspectedLayout, props.shaderLayout);
-    this.bufferLayout = props.bufferLayout || [];
-    this.vertexArrayObject = new WEBGLVertexArrayObject(this.device);
+    this.shaderLayout = (0, import_core23.mergeShaderLayout)(this.introspectedLayout, props.shaderLayout);
   }
   destroy() {
     if (this.handle) {
@@ -5422,83 +5243,50 @@ var WEBGLRenderPipeline = class extends import_core23.RenderPipeline {
       this.destroyed = true;
     }
   }
-  setIndexBuffer(indexBuffer) {
-    const webglBuffer = (0, import_core23.cast)(indexBuffer);
-    this.vertexArrayObject.setElementBuffer(webglBuffer);
-    this._indexBuffer = webglBuffer;
-  }
-  /** @todo needed for portable model */
-  setAttributes(buffers) {
-    const attributeInfos = (0, import_core24.getAttributeInfosFromLayouts)(this.shaderLayout, this.bufferLayout);
-    for (const [bufferName, buffer] of Object.entries(buffers)) {
-      let set = false;
-      for (const attributeInfo of Object.values(attributeInfos)) {
-        if (attributeInfo.bufferName !== bufferName) {
-          continue;
-        }
-        const webglBuffer = (0, import_core23.cast)(buffer);
-        const glType = getGLFromVertexType(attributeInfo.bufferDataType);
-        import_core23.log.log(2, {
-          setAttribute: attributeInfo.attributeName,
-          toBuffer: bufferName,
-          size: attributeInfo.bufferComponents,
-          type: glType,
-          stride: attributeInfo.byteStride,
-          offset: attributeInfo.byteOffset,
-          normalized: attributeInfo.normalized,
-          // it is the shader attribute declaration, not the vertex memory format,
-          // that determines if the data in the buffer will be treated as integers.
-          // /
-          // Also note that WebGL supports assigning non-normalized integer data to floating point attributes,
-          // but as far as we can tell, WebGPU does not.
-          integer: attributeInfo.integer,
-          divisor: attributeInfo.stepMode === "instance" ? 1 : 0
-        })();
-        this.vertexArrayObject.setBuffer(attributeInfo.location, webglBuffer, {
-          size: attributeInfo.bufferComponents,
-          type: glType,
-          stride: attributeInfo.byteStride,
-          offset: attributeInfo.byteOffset,
-          normalized: attributeInfo.normalized,
-          // it is the shader attribute declaration, not the vertex memory format,
-          // that determines if the data in the buffer will be treated as integers.
-          // /
-          // Also note that WebGL supports assigning non-normalized integer data to floating point attributes,
-          // but as far as we can tell, WebGPU does not.
-          integer: attributeInfo.integer,
-          divisor: attributeInfo.stepMode === "instance" ? 1 : 0
-        });
-        set = true;
-      }
-      if (!set) {
-        import_core23.log.warn(
-          `setAttributes(): Ignoring (buffer "${buffer.id}" for unknown attribute "${name}" in pipeline "${this.id}"`
-        )();
-      }
-    }
-  }
-  /**
-   * 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) {
-    Object.assign(this.constantAttributes, attributes);
-  }
+  // setIndexBuffer(indexBuffer: Buffer): void {
+  //   const webglBuffer = cast<WEBGLBuffer>(indexBuffer);
+  //   this.vertexArrayObject.setElementBuffer(webglBuffer);
+  //   this._indexBuffer = indexBuffer;
+  // }
+  // /** @todo needed for portable model */
+  // setAttributes(attributes: Record<string, Buffer>): void {
+  //   for (const [name, buffer] of Object.entries(attributes)) {
+  //     const webglBuffer = cast<WEBGLBuffer>(buffer);
+  //     const attribute = getAttributeLayout(this.layout, name);
+  //     if (!attribute) {
+  //       log.warn(
+  //         `Ignoring buffer supplied for unknown attribute "${name}" in pipeline "${this.id}" (buffer "${buffer.id}")`
+  //       )();
+  //       continue;
+  //     }
+  //     const decoded = decodeVertexFormat(attribute.format);
+  //     const {type: typeString, components: size, byteLength: stride, normalized, integer} = decoded;
+  //     const divisor = attribute.stepMode === 'instance' ? 1 : 0;
+  //     const type = getWebGLDataType(typeString);
+  //     this.vertexArrayObject.setBuffer(attribute.location, webglBuffer, {
+  //       size,
+  //       type,
+  //       stride,
+  //       offset: 0,
+  //       normalized,
+  //       integer,
+  //       divisor
+  //     });
+  //   }
+  // }
   /**
    * Bindings include: textures, samplers and uniform buffers
    * @todo needed for portable model
    */
   setBindings(bindings) {
-    for (const [name2, value] of Object.entries(bindings)) {
-      const binding = this.shaderLayout.bindings.find((binding2) => binding2.name === name2);
+    for (const [name, value] of Object.entries(bindings)) {
+      const binding = this.shaderLayout.bindings.find((binding2) => binding2.name === name);
       if (!binding) {
-        import_core23.log.warn(`Unknown binding ${name2} in render pipeline ${this.id}`)();
+        import_core22.log.warn(`Unknown binding ${name} in render pipeline ${this.id}`)();
         continue;
       }
       if (!value) {
-        import_core23.log.warn(`Unsetting binding ${name2} in render pipeline ${this.id}`)();
+        import_core22.log.warn(`Unsetting binding ${name} in render pipeline ${this.id}`)();
       }
       switch (binding.type) {
         case "uniform":
@@ -5512,12 +5300,12 @@ var WEBGLRenderPipeline = class extends import_core23.RenderPipeline {
           }
           break;
         case "sampler":
-          import_core23.log.warn(`Ignoring sampler ${name2}`)();
+          import_core22.log.warn(`Ignoring sampler ${name}`)();
           break;
         default:
           throw new Error(binding.type);
       }
-      this.bindings[name2] = value;
+      this.bindings[name] = value;
     }
   }
   setUniforms(uniforms) {
@@ -5531,6 +5319,7 @@ var WEBGLRenderPipeline = class extends import_core23.RenderPipeline {
     var _a;
     const {
       renderPass,
+      vertexArray,
       vertexCount,
       // indexCount,
       instanceCount,
@@ -5539,75 +5328,72 @@ var WEBGLRenderPipeline = class extends import_core23.RenderPipeline {
       // firstInstance,
       // baseVertex
     } = options;
-    const drawMode = getGLDrawMode(this.props.topology);
-    const isIndexed = Boolean(this._indexBuffer);
-    const indexType = (_a = this._indexBuffer) == null ? void 0 : _a.glIndexType;
-    const isInstanced = Number(options.instanceCount) > 0;
-    if (!this._areTexturesRenderable() || options.vertexCount === 0) {
+    const glDrawMode = getGLDrawMode(this.props.topology);
+    const isIndexed = Boolean(vertexArray.indexBuffer);
+    const glIndexType = (_a = vertexArray.indexBuffer) == null ? void 0 : _a.glIndexType;
+    const isInstanced = Number(instanceCount) > 0;
+    if (!this._areTexturesRenderable() || vertexCount === 0) {
       return false;
     }
     this.device.gl.useProgram(this.handle);
-    this.vertexArrayObject.bind(() => {
-      const primitiveMode = getGLPrimitive(this.props.topology);
-      const transformFeedback = null;
+    vertexArray.bindBeforeRender(renderPass);
+    const primitiveMode = getGLPrimitive(this.props.topology);
+    const transformFeedback = null;
+    if (transformFeedback) {
+      transformFeedback.begin(primitiveMode);
+    }
+    this._applyBindings();
+    this._applyUniforms();
+    const webglRenderPass = renderPass;
+    withDeviceAndGLParameters(this.device, this.props.parameters, webglRenderPass.glParameters, () => {
+      var _a2, _b;
+      if (isIndexed && isInstanced) {
+        (_a2 = this.device.gl2) == null ? void 0 : _a2.drawElementsInstanced(
+          glDrawMode,
+          vertexCount || 0,
+          // indexCount?
+          glIndexType,
+          firstVertex,
+          instanceCount || 0
+        );
+      } else if (isIndexed) {
+        this.device.gl.drawElements(glDrawMode, vertexCount || 0, glIndexType, firstVertex);
+      } else if (isInstanced) {
+        (_b = this.device.gl2) == null ? void 0 : _b.drawArraysInstanced(
+          glDrawMode,
+          firstVertex,
+          vertexCount || 0,
+          instanceCount || 0
+        );
+      } else {
+        this.device.gl.drawArrays(glDrawMode, firstVertex, vertexCount || 0);
+      }
       if (transformFeedback) {
-        transformFeedback.begin(primitiveMode);
+        transformFeedback.end();
       }
-      this._applyBindings();
-      this._applyUniforms();
-      this._applyConstantAttributes();
-      const webglRenderPass = renderPass;
-      withDeviceParameters(this.device, this.props.parameters, () => {
-        withGLParameters(this.device, webglRenderPass.glParameters, () => {
-          var _a2, _b;
-          if (isIndexed && isInstanced) {
-            (_a2 = this.device.gl2) == null ? void 0 : _a2.drawElementsInstanced(
-              drawMode,
-              vertexCount || 0,
-              // indexCount?
-              indexType,
-              firstVertex,
-              instanceCount || 0
-            );
-          } else if (isIndexed) {
-            this.device.gl.drawElements(drawMode, vertexCount || 0, indexType, firstVertex);
-          } else if (isInstanced) {
-            (_b = this.device.gl2) == null ? void 0 : _b.drawArraysInstanced(
-              drawMode,
-              firstVertex,
-              vertexCount || 0,
-              instanceCount || 0
-            );
-          } else {
-            this.device.gl.drawArrays(drawMode, firstVertex, vertexCount || 0);
-          }
-        });
-        if (transformFeedback) {
-          transformFeedback.end();
-        }
-      });
     });
+    vertexArray.unbindAfterRender(renderPass);
     return true;
   }
   // setAttributes(attributes: Record<string, Buffer>): void {}
   // setBindings(bindings: Record<string, Binding>): void {}
   _compileAndLink() {
-    const { gl: gl2 } = this.device;
-    gl2.attachShader(this.handle, this.vs.handle);
-    gl2.attachShader(this.handle, this.fs.handle);
-    import_core23.log.time(LOG_PROGRAM_PERF_PRIORITY, `linkProgram for ${this.id}`)();
-    gl2.linkProgram(this.handle);
-    import_core23.log.timeEnd(LOG_PROGRAM_PERF_PRIORITY, `linkProgram for ${this.id}`)();
-    if (gl2.debug || import_core23.log.level > 0) {
-      const linked = gl2.getProgramParameter(this.handle, gl2.LINK_STATUS);
-      if (!linked) {
-        throw new Error(`Error linking: ${gl2.getProgramInfoLog(this.handle)}`);
-      }
-      gl2.validateProgram(this.handle);
-      const validated = gl2.getProgramParameter(this.handle, gl2.VALIDATE_STATUS);
-      if (!validated) {
-        throw new Error(`Error validating: ${gl2.getProgramInfoLog(this.handle)}`);
-      }
+    const { gl } = this.device;
+    gl.attachShader(this.handle, this.vs.handle);
+    gl.attachShader(this.handle, this.fs.handle);
+    import_core22.log.time(LOG_PROGRAM_PERF_PRIORITY, `linkProgram for ${this.id}`)();
+    gl.linkProgram(this.handle);
+    import_core22.log.timeEnd(LOG_PROGRAM_PERF_PRIORITY, `linkProgram for ${this.id}`)();
+    if (!gl.debug && import_core22.log.level === 0) {
+    }
+    const linked = gl.getProgramParameter(this.handle, gl.LINK_STATUS);
+    if (!linked) {
+      throw new Error(`Error linking: ${gl.getProgramInfoLog(this.handle)}`);
+    }
+    gl.validateProgram(this.handle);
+    const validated = gl.getProgramParameter(this.handle, gl.VALIDATE_STATUS);
+    if (!validated) {
+      throw new Error(`Error validating: ${gl.getProgramInfoLog(this.handle)}`);
     }
   }
   // PRIVATE METHODS
@@ -5634,20 +5420,22 @@ var WEBGLRenderPipeline = class extends import_core23.RenderPipeline {
    * Any attribute that is disabled in the current vertex array object
    * is read from the context's global constant value for that attribute location.
    * @note Constant attributes are only supported in WebGL, not in WebGPU
-   */
-  _applyConstantAttributes() {
-    const attributeInfos = (0, import_core24.getAttributeInfosFromLayouts)(this.shaderLayout, this.bufferLayout);
-    for (const [name2, value] of Object.entries(this.constantAttributes)) {
-      const attributeInfo = attributeInfos[name2];
+   *
+  _applyConstantAttributes(vertexArray: WEBGLVertexArray): void {
+    const attributeInfos = getAttributeInfosFromLayouts(this.shaderLayout, this.bufferLayout);
+    for (const [name, value] of Object.entries(this.)) {
+      const attributeInfo = attributeInfos[name];
       if (!attributeInfo) {
-        import_core23.log.warn(
-          `Ignoring constant value supplied for unknown attribute "${name2}" in pipeline "${this.id}"`
+        log.warn(
+          `Ignoring constant value supplied for unknown attribute "${name}" in pipeline "${this.id}"`
         )();
-        continue;
+        continue; // eslint-disable-line no-continue
       }
-      this.vertexArrayObject.setConstant(attributeInfo.location, value);
+      vertexArray.setConstant(attributeInfo.location, value);
+      vertexArray.enable(attributeInfo.location, false);
     }
   }
+  */
   /** Apply any bindings (before each draw call) */
   _applyBindings() {
     this.device.gl.useProgram(this.handle);
@@ -5664,20 +5452,23 @@ var WEBGLRenderPipeline = class extends import_core23.RenderPipeline {
       }
       switch (binding.type) {
         case "uniform":
-          const { name: name2 } = binding;
-          const location = gl2.getUniformBlockIndex(this.handle, name2);
-          if (location === import_constants25.GL.INVALID_INDEX) {
-            throw new Error(`Invalid uniform block name ${name2}`);
+          const { name } = binding;
+          const location = gl2.getUniformBlockIndex(this.handle, name);
+          if (location === import_constants24.GL.INVALID_INDEX) {
+            throw new Error(`Invalid uniform block name ${name}`);
           }
           gl2.uniformBlockBinding(this.handle, uniformBufferIndex, location);
           if (value instanceof WEBGLBuffer) {
-            gl2.bindBufferBase(import_constants25.GL.UNIFORM_BUFFER, uniformBufferIndex, value.handle);
+            gl2.bindBufferBase(import_constants24.GL.UNIFORM_BUFFER, uniformBufferIndex, value.handle);
           } else {
             gl2.bindBufferRange(
-              import_constants25.GL.UNIFORM_BUFFER,
+              import_constants24.GL.UNIFORM_BUFFER,
               uniformBufferIndex,
+              // @ts-expect-error
               value.buffer.handle,
+              // @ts-expect-error
               value.offset || 0,
+              // @ts-expect-error
               value.size || value.buffer.byteLength - value.offset
             );
           }
@@ -5688,7 +5479,7 @@ var WEBGLRenderPipeline = class extends import_core23.RenderPipeline {
             throw new Error("texture");
           }
           const texture = value;
-          gl2.activeTexture(import_constants25.GL.TEXTURE0 + textureUnit);
+          gl2.activeTexture(import_constants24.GL.TEXTURE0 + textureUnit);
           gl2.bindTexture(texture.target, texture.handle);
           textureUnit += 1;
           break;
@@ -5707,8 +5498,8 @@ var WEBGLRenderPipeline = class extends import_core23.RenderPipeline {
   _applyUniforms() {
     var _a;
     for (const uniformLayout of this.shaderLayout.uniforms || []) {
-      const { name: name2, location, type, textureUnit } = uniformLayout;
-      const value = (_a = this.uniforms[name2]) != null ? _a : textureUnit;
+      const { name, location, type, textureUnit } = uniformLayout;
+      const value = (_a = this.uniforms[name]) != null ? _a : textureUnit;
       if (value !== void 0) {
         setUniform(this.device.gl, location, type, value);
       }
@@ -5718,19 +5509,19 @@ var WEBGLRenderPipeline = class extends import_core23.RenderPipeline {
 function getGLDrawMode(topology) {
   switch (topology) {
     case "point-list":
-      return import_constants25.GL.POINTS;
+      return import_constants24.GL.POINTS;
     case "line-list":
-      return import_constants25.GL.LINES;
+      return import_constants24.GL.LINES;
     case "line-strip":
-      return import_constants25.GL.LINE_STRIP;
+      return import_constants24.GL.LINE_STRIP;
     case "line-loop-webgl":
-      return import_constants25.GL.LINE_LOOP;
+      return import_constants24.GL.LINE_LOOP;
     case "triangle-list":
-      return import_constants25.GL.TRIANGLES;
+      return import_constants24.GL.TRIANGLES;
     case "triangle-strip":
-      return import_constants25.GL.TRIANGLE_STRIP;
+      return import_constants24.GL.TRIANGLE_STRIP;
     case "triangle-fan-webgl":
-      return import_constants25.GL.TRIANGLE_FAN;
+      return import_constants24.GL.TRIANGLE_FAN;
     default:
       throw new Error(topology);
   }
@@ -5738,34 +5529,34 @@ function getGLDrawMode(topology) {
 function getGLPrimitive(topology) {
   switch (topology) {
     case "point-list":
-      return import_constants25.GL.POINTS;
+      return import_constants24.GL.POINTS;
     case "line-list":
-      return import_constants25.GL.LINES;
+      return import_constants24.GL.LINES;
     case "line-strip":
-      return import_constants25.GL.LINES;
+      return import_constants24.GL.LINES;
     case "line-loop-webgl":
-      return import_constants25.GL.LINES;
+      return import_constants24.GL.LINES;
     case "triangle-list":
-      return import_constants25.GL.TRIANGLES;
+      return import_constants24.GL.TRIANGLES;
     case "triangle-strip":
-      return import_constants25.GL.TRIANGLES;
+      return import_constants24.GL.TRIANGLES;
     case "triangle-fan-webgl":
-      return import_constants25.GL.TRIANGLES;
+      return import_constants24.GL.TRIANGLES;
     default:
       throw new Error(topology);
   }
 }
 
 // src/adapter/resources/webgl-command-encoder.ts
-var import_core26 = require("@luma.gl/core");
+var import_core25 = require("@luma.gl/core");
 
 // src/adapter/resources/webgl-command-buffer.ts
-var import_core25 = require("@luma.gl/core");
-var import_constants26 = require("@luma.gl/constants");
+var import_core24 = require("@luma.gl/core");
+var import_constants25 = require("@luma.gl/constants");
 function cast3(value) {
   return value;
 }
-var WEBGLCommandBuffer = class extends import_core25.CommandBuffer {
+var WEBGLCommandBuffer = class extends import_core24.CommandBuffer {
   constructor(device) {
     super({});
     this.commands = [];
@@ -5796,17 +5587,17 @@ function _copyBufferToBuffer(device, options) {
   const destination = cast3(options.destination);
   const gl2 = device.assertWebGL2();
   if (gl2) {
-    gl2.bindBuffer(import_constants26.GL.COPY_READ_BUFFER, source.handle);
-    gl2.bindBuffer(import_constants26.GL.COPY_WRITE_BUFFER, destination.handle);
+    gl2.bindBuffer(import_constants25.GL.COPY_READ_BUFFER, source.handle);
+    gl2.bindBuffer(import_constants25.GL.COPY_WRITE_BUFFER, destination.handle);
     gl2.copyBufferSubData(
-      import_constants26.GL.COPY_READ_BUFFER,
-      import_constants26.GL.COPY_WRITE_BUFFER,
+      import_constants25.GL.COPY_READ_BUFFER,
+      import_constants25.GL.COPY_WRITE_BUFFER,
       (_a = options.sourceOffset) != null ? _a : 0,
       (_b = options.destinationOffset) != null ? _b : 0,
       options.size
     );
-    gl2.bindBuffer(import_constants26.GL.COPY_READ_BUFFER, null);
-    gl2.bindBuffer(import_constants26.GL.COPY_WRITE_BUFFER, null);
+    gl2.bindBuffer(import_constants25.GL.COPY_READ_BUFFER, null);
+    gl2.bindBuffer(import_constants25.GL.COPY_WRITE_BUFFER, null);
   } else {
     throw new Error("copyBufferToBuffer not implemented in WebGL1");
   }
@@ -5857,10 +5648,10 @@ function _copyTextureToBuffer(device, options) {
     const webglBuffer = destination;
     const sourceWidth = width || framebuffer.width;
     const sourceHeight = height || framebuffer.height;
-    const sourceFormat = import_constants26.GL.RGBA;
-    const sourceType = import_constants26.GL.UNSIGNED_BYTE;
-    gl2.bindBuffer(import_constants26.GL.PIXEL_PACK_BUFFER, webglBuffer.handle);
-    gl2.bindFramebuffer(import_constants26.GL.FRAMEBUFFER, framebuffer.handle);
+    const sourceFormat = import_constants25.GL.RGBA;
+    const sourceType = import_constants25.GL.UNSIGNED_BYTE;
+    gl2.bindBuffer(import_constants25.GL.PIXEL_PACK_BUFFER, webglBuffer.handle);
+    gl2.bindFramebuffer(import_constants25.GL.FRAMEBUFFER, framebuffer.handle);
     gl2.readPixels(
       origin[0],
       origin[1],
@@ -5871,8 +5662,8 @@ function _copyTextureToBuffer(device, options) {
       byteOffset
     );
   } finally {
-    gl2.bindBuffer(import_constants26.GL.PIXEL_PACK_BUFFER, null);
-    gl2.bindFramebuffer(import_constants26.GL.FRAMEBUFFER, null);
+    gl2.bindBuffer(import_constants25.GL.PIXEL_PACK_BUFFER, null);
+    gl2.bindFramebuffer(import_constants25.GL.FRAMEBUFFER, null);
     if (destroyFramebuffer) {
       framebuffer.destroy();
     }
@@ -5903,11 +5694,11 @@ function _copyTextureToTexture(device, options) {
     // depthOrArrayLayers = 0
   } = options;
   const destinationMipmaplevel = 0;
-  const destinationInternalFormat = import_constants26.GL.RGBA;
+  const destinationInternalFormat = import_constants25.GL.RGBA;
   const { framebuffer, destroyFramebuffer } = getFramebuffer(source);
   const [sourceX, sourceY] = origin;
   const isSubCopy = false;
-  device.gl.bindFramebuffer(import_constants26.GL.FRAMEBUFFER, framebuffer.handle);
+  device.gl.bindFramebuffer(import_constants25.GL.FRAMEBUFFER, framebuffer.handle);
   let texture = null;
   let textureTarget;
   if (destination instanceof WEBGLTexture) {
@@ -5936,14 +5727,13 @@ function _copyTextureToTexture(device, options) {
   if (texture) {
     texture.unbind();
   }
-  device.gl.bindFramebuffer(import_constants26.GL.FRAMEBUFFER, prevHandle || null);
   if (destroyFramebuffer) {
     framebuffer.destroy();
   }
   return texture;
 }
 function getFramebuffer(source) {
-  if (source instanceof import_core25.Texture) {
+  if (source instanceof import_core24.Texture) {
     const { width, height, id } = source;
     const framebuffer = source.device.createFramebuffer({
       id: `framebuffer-for-${id}`,
@@ -5957,7 +5747,7 @@ function getFramebuffer(source) {
 }
 
 // src/adapter/resources/webgl-command-encoder.ts
-var WEBGLCommandEncoder = class extends import_core26.CommandEncoder {
+var WEBGLCommandEncoder = class extends import_core25.CommandEncoder {
   constructor(device, props) {
     super(device, props);
     this.device = device;
@@ -5999,6 +5789,204 @@ var WEBGLCommandEncoder = class extends import_core26.CommandEncoder {
   // }): void;
 };
 
+// src/adapter/resources/webgl-vertex-array.ts
+var import_core26 = require("@luma.gl/core");
+var import_constants26 = require("@luma.gl/constants");
+var import_env2 = require("@probe.gl/env");
+var WEBGLVertexArray = class extends import_core26.VertexArray {
+  // Create a VertexArray
+  constructor(device, props) {
+    super(device, props);
+    /** Attribute 0 buffer constant */
+    this.buffer = null;
+    this.bufferValue = null;
+    this.init = false;
+    this.device = device;
+    this.handle = this.device.gl2.createVertexArray();
+  }
+  get [Symbol.toStringTag]() {
+    return "VertexArray";
+  }
+  /** * Attribute 0 can not be disable on most desktop OpenGL based browsers */
+  static isConstantAttributeZeroSupported(device) {
+    return device.info.type === "webgl2" || (0, import_env2.getBrowser)() === "Chrome";
+  }
+  destroy() {
+    var _a;
+    super.destroy();
+    if (this.buffer) {
+      (_a = this.buffer) == null ? void 0 : _a.destroy();
+    }
+    if (this.handle) {
+      this.device.gl2.deleteVertexArray(this.handle);
+      this.handle = void 0;
+    }
+  }
+  /**
+  // Set (bind) an elements buffer, for indexed rendering.
+  // Must be a Buffer bound to GL.ELEMENT_ARRAY_BUFFER. Constants not supported
+   * 
+   * @param elementBuffer 
+   */
+  setIndexBuffer(indexBuffer) {
+    const buffer = indexBuffer;
+    if (buffer && buffer.glTarget !== import_constants26.GL.ELEMENT_ARRAY_BUFFER) {
+      throw new Error("Use .setBuffer()");
+    }
+    this.device.gl2.bindVertexArray(this.handle);
+    this.device.gl2.bindBuffer(import_constants26.GL.ELEMENT_ARRAY_BUFFER, buffer ? buffer.handle : null);
+    this.indexBuffer = buffer;
+  }
+  /** Set a location in vertex attributes array to a buffer, enables the location, sets divisor */
+  setBuffer(location, attributeBuffer) {
+    const buffer = attributeBuffer;
+    if (buffer.glTarget === import_constants26.GL.ELEMENT_ARRAY_BUFFER) {
+      throw new Error("Use .setIndexBuffer()");
+    }
+    const { size, type, stride, offset, normalized, integer, divisor } = this._getAccessor(location);
+    this.device.gl2.bindVertexArray(this.handle);
+    this.device.gl.bindBuffer(import_constants26.GL.ARRAY_BUFFER, buffer.handle);
+    if (integer) {
+      this.device.assertWebGL2();
+      this.device.gl2.vertexAttribIPointer(location, size, type, stride, offset);
+    } else {
+      this.device.gl.vertexAttribPointer(location, size, type, normalized, stride, offset);
+    }
+    this.device.gl.enableVertexAttribArray(location);
+    this.device.gl2.vertexAttribDivisor(location, divisor || 0);
+    this.attributes[location] = buffer;
+  }
+  /** Set a location in vertex attributes array to a constant value, disables the location */
+  setConstant(location, value) {
+    this._enable(location, false);
+    this.attributes[location] = value;
+  }
+  bindBeforeRender() {
+    this.device.gl2.bindVertexArray(this.handle);
+    if (!this.init) {
+      const webglBuffer = this.indexBuffer;
+      this.device.gl2.bindBuffer(import_constants26.GL.ELEMENT_ARRAY_BUFFER, (webglBuffer == null ? void 0 : webglBuffer.handle) || null);
+      this.init = true;
+    }
+    this._applyConstantAttributes();
+  }
+  unbindAfterRender() {
+    this.device.gl2.bindVertexArray(null);
+  }
+  // Internal methods
+  /**
+   * Constant attributes need to be reset before every draw call
+   * Any attribute that is disabled in the current vertex array object
+   * is read from the context's global constant value for that attribute location.
+   * @note Constant attributes are only supported in WebGL, not in WebGPU
+   */
+  _applyConstantAttributes() {
+    for (let location = 0; location < this.maxVertexAttributes; ++location) {
+      const constant = this.attributes[location];
+      if (ArrayBuffer.isView(constant)) {
+        this.device.setConstantAttribute(location, constant);
+      }
+    }
+  }
+  /**
+   * Set a location in vertex attributes array to a buffer, enables the location, sets divisor
+   * @note requires vertex array to be bound
+   */
+  // protected _setAttributeLayout(location: number): void {
+  //   const {size, type, stride, offset, normalized, integer, divisor} = this._getAccessor(location);
+  //   // WebGL2 supports *integer* data formats, i.e. GPU will see integer values
+  //   if (integer) {
+  //     this.device.assertWebGL2();
+  //     this.device.gl2.vertexAttribIPointer(location, size, type, stride, offset);
+  //   } else {
+  //     // Attaches ARRAY_BUFFER with specified buffer format to location
+  //     this.device.gl.vertexAttribPointer(location, size, type, normalized, stride, offset);
+  //   }
+  //   this.device.gl2.vertexAttribDivisor(location, divisor || 0);
+  // }
+  /** Get an accessor from the  */
+  _getAccessor(location) {
+    const attributeInfo = this.attributeInfos[location];
+    if (!attributeInfo) {
+      throw new Error(`Unknown attribute location ${location}`);
+    }
+    const glType = getGLFromVertexType(attributeInfo.bufferDataType);
+    return {
+      size: attributeInfo.bufferComponents,
+      type: glType,
+      stride: attributeInfo.byteStride,
+      offset: attributeInfo.byteOffset,
+      normalized: attributeInfo.normalized,
+      // it is the shader attribute declaration, not the vertex memory format,
+      // that determines if the data in the buffer will be treated as integers.
+      //
+      // Also note that WebGL supports assigning non-normalized integer data to floating point attributes,
+      // but as far as we can tell, WebGPU does not.
+      integer: attributeInfo.integer,
+      divisor: attributeInfo.stepMode === "instance" ? 1 : 0
+    };
+  }
+  /**
+   * 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 = WEBGLVertexArray.isConstantAttributeZeroSupported(this.device);
+    const canDisableAttribute = canDisableAttributeZero || location !== 0;
+    if (enable2 || canDisableAttribute) {
+      location = Number(location);
+      this.device.gl2.bindVertexArray(this.handle);
+      if (enable2) {
+        this.device.gl.enableVertexAttribArray(location);
+      } else {
+        this.device.gl.disableVertexAttribArray(location);
+      }
+      this.device.gl2.bindVertexArray(null);
+    }
+  }
+  /**
+   * 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_core26.getScratchArray)(value.constructor, length);
+      (0, import_core26.fillArray)({ target: typedArray, source: constantValue, start: 0, count: length });
+      this.buffer.subData(typedArray);
+      this.bufferValue = value;
+    }
+    return this.buffer;
+  }
+};
+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/webgl-device.ts
 var LOG_LEVEL2 = 1;
 var _WebGLDevice = class extends import_core27.Device {
@@ -6032,13 +6020,13 @@ var _WebGLDevice = class extends import_core27.Device {
         message: "Computer entered sleep mode, or too many apps or browser tabs are using the GPU."
       });
     };
-    let gl2 = props.gl || null;
-    gl2 = gl2 || ((0, import_env3.isBrowser)() ? createBrowserContext(this.canvasContext.canvas, __spreadProps(__spreadValues({}, props), { onContextLost })) : null);
-    gl2 = gl2 || (!(0, import_env3.isBrowser)() ? createHeadlessContext(__spreadProps(__spreadValues({}, props), { onContextLost })) : null);
-    if (!gl2) {
+    let gl = props.gl || null;
+    gl = gl || ((0, import_env3.isBrowser)() ? createBrowserContext(this.canvasContext.canvas, __spreadProps(__spreadValues({}, props), { onContextLost })) : null);
+    gl = gl || (!(0, import_env3.isBrowser)() ? createHeadlessContext(__spreadProps(__spreadValues({}, props), { onContextLost })) : null);
+    if (!gl) {
       throw new Error("WebGL context creation failed");
     }
-    this.handle = gl2;
+    this.handle = gl;
     this.gl = this.handle;
     this.gl2 = this.gl;
     this.isWebGL2 = isWebGL22(this.gl);
@@ -6088,17 +6076,17 @@ var _WebGLDevice = class extends import_core27.Device {
    * @param gl
    * @returns
    */
-  static attach(gl2) {
-    if (gl2 instanceof _WebGLDevice) {
-      return gl2;
+  static attach(gl) {
+    if (gl instanceof _WebGLDevice) {
+      return gl;
     }
-    if ((gl2 == null ? void 0 : gl2.device) instanceof import_core27.Device) {
-      return gl2.device;
+    if ((gl == null ? void 0 : gl.device) instanceof import_core27.Device) {
+      return gl.device;
     }
-    if (!isWebGL3(gl2)) {
+    if (!isWebGL3(gl)) {
       throw new Error("Invalid WebGLRenderingContext");
     }
-    return new _WebGLDevice({ gl: gl2 });
+    return new _WebGLDevice({ gl });
   }
   static create() {
     return __async(this, arguments, function* (props = {}) {
@@ -6179,6 +6167,9 @@ var _WebGLDevice = class extends import_core27.Device {
   createRenderPipeline(props) {
     return new WEBGLRenderPipeline(this, props);
   }
+  createVertexArray(props) {
+    return new WEBGLVertexArray(this, props);
+  }
   beginRenderPass(props) {
     return new WEBGLRenderPass(this, props);
   }
@@ -6238,48 +6229,114 @@ var _WebGLDevice = class extends import_core27.Device {
   popState() {
     popContextState(this.gl);
   }
-  /** 
-   * Storing data on a special field on WebGLObjects makes that data visible in SPECTOR chrome debug extension 
+  /**
+   * Storing data on a special field on WebGLObjects makes that data visible in SPECTOR chrome debug extension
    * luma.gl ids and props can be inspected
    */
   setSpectorMetadata(handle, props) {
     handle.__SPECTOR_Metadata = props;
   }
-  /** 
+  /**
    * Returns the GL.<KEY> constant that corresponds to a numeric value of a GL constant
    * Be aware that there are some duplicates especially for constants that are 0,
    * so this isn't guaranteed to return the right key in all cases.
    */
-  getGLKey(value, gl2) {
-    gl2 = gl2 || this.gl2 || this.gl;
+  getGLKey(value, gl) {
+    gl = gl || this.gl2 || this.gl;
     const number = Number(value);
-    for (const key in gl2) {
-      if (gl2[key] === number) {
+    for (const key in gl) {
+      if (gl[key] === number) {
         return `GL.${key}`;
       }
     }
     return String(value);
   }
+  /**
+   * Set a constant value for a location. Disabled attributes at that location will read from this value
+   * @note WebGL constants are stored globally on the WebGL context, not the VertexArray
+   * so they need to be updated before every render
+   * @todo - remember/cache values to avoid setting them unnecessarily?
+   */
+  setConstantAttribute(location, constant) {
+    this._constants = this._constants || new Array(this.limits.maxVertexAttributes).fill(null);
+    const currentConstant = this._constants[location];
+    if (currentConstant && compareConstantArrayValues2(currentConstant, constant)) {
+      import_core27.log.info(1, `setConstantAttribute(${location}) could have been skipped, value unchanged`)();
+    }
+    this._constants[location] = constant;
+    switch (constant.constructor) {
+      case Float32Array:
+        setConstantFloatArray(this, location, constant);
+        break;
+      case Int32Array:
+        setConstantIntArray(this, location, constant);
+        break;
+      case Uint32Array:
+        setConstantUintArray(this, location, constant);
+        break;
+      default:
+        (0, import_core27.assert)(false);
+    }
+  }
 };
 var WebGLDevice = _WebGLDevice;
 //
 // Public `Device` API
 //
 WebGLDevice.type = "webgl";
-function isWebGL3(gl2) {
-  if (typeof WebGLRenderingContext !== "undefined" && gl2 instanceof WebGLRenderingContext) {
+function isWebGL3(gl) {
+  if (typeof WebGLRenderingContext !== "undefined" && gl instanceof WebGLRenderingContext) {
     return true;
   }
-  if (typeof WebGL2RenderingContext !== "undefined" && gl2 instanceof WebGL2RenderingContext) {
+  if (typeof WebGL2RenderingContext !== "undefined" && gl instanceof WebGL2RenderingContext) {
     return true;
   }
-  return Boolean(gl2 && Number.isFinite(gl2._version));
+  return Boolean(gl && Number.isFinite(gl._version));
 }
-function isWebGL22(gl2) {
-  if (typeof WebGL2RenderingContext !== "undefined" && gl2 instanceof WebGL2RenderingContext) {
+function isWebGL22(gl) {
+  if (typeof WebGL2RenderingContext !== "undefined" && gl instanceof WebGL2RenderingContext) {
     return true;
   }
-  return Boolean(gl2 && gl2._version === 2);
+  return Boolean(gl && gl._version === 2);
+}
+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_core27.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 compareConstantArrayValues2(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/classic/clear.ts
@@ -6288,8 +6345,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(gl2, options) {
-  const device = WebGLDevice.attach(gl2);
+function clear(gl, options) {
+  const device = WebGLDevice.attach(gl);
   const { framebuffer = null, color = null, depth = null, stencil = null } = options || {};
   const parameters = {};
   if (framebuffer) {
@@ -6315,7 +6372,7 @@ function clear(gl2, options) {
     }
   }
   (0, import_core28.assert)(clearFlags !== 0, ERR_ARGUMENTS);
-  withParameters(device.gl, parameters, () => {
+  withGLParameters(device.gl, parameters, () => {
     device.gl.clear(clearFlags);
   });
 }
@@ -6365,10 +6422,15 @@ function glTypeToBytes(type) {
 
 // src/classic/copy-and-blit.ts
 function readPixelsToArray(source, options) {
-  const { sourceX = 0, sourceY = 0, sourceFormat = import_constants28.GL.RGBA } = options || {};
-  let {
-    sourceAttachment = import_constants28.GL.COLOR_ATTACHMENT0,
+  var _a;
+  const {
+    sourceX = 0,
+    sourceY = 0,
+    sourceFormat = import_constants28.GL.RGBA,
+    sourceAttachment = import_constants28.GL.COLOR_ATTACHMENT0
     // TODO - support gl.readBuffer
+  } = options || {};
+  let {
     target = null,
     // following parameters are auto deduced if not provided
     sourceWidth,
@@ -6377,19 +6439,16 @@ function readPixelsToArray(source, options) {
   } = options || {};
   const { framebuffer, deleteFramebuffer } = getFramebuffer2(source);
   (0, import_core30.assert)(framebuffer);
-  const { gl: gl2, handle } = framebuffer;
+  const { gl, handle } = framebuffer;
   sourceWidth = sourceWidth || framebuffer.width;
   sourceHeight = sourceHeight || framebuffer.height;
-  if (sourceAttachment === import_constants28.GL.COLOR_ATTACHMENT0 && handle === null) {
-    sourceAttachment = import_constants28.GL.FRONT;
-  }
   const attachment = sourceAttachment - import_constants28.GL.COLOR_ATTACHMENT0;
-  sourceType = sourceType || framebuffer.colorAttachments[attachment].type;
+  sourceType = sourceType || ((_a = framebuffer.colorAttachments[attachment]) == null ? void 0 : _a.type) || import_constants28.GL.UNSIGNED_BYTE;
   target = getPixelArray(target, sourceType, sourceFormat, sourceWidth, sourceHeight);
   sourceType = sourceType || getGLTypeFromTypedArray(target);
-  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);
+  const prevHandle = gl.bindFramebuffer(import_constants28.GL.FRAMEBUFFER, handle);
+  gl.readPixels(sourceX, sourceY, sourceWidth, sourceHeight, sourceFormat, sourceType, target);
+  gl.bindFramebuffer(import_constants28.GL.FRAMEBUFFER, prevHandle || null);
   if (deleteFramebuffer) {
     framebuffer.destroy();
   }
@@ -6412,7 +6471,7 @@ function readPixelsToBuffer(source, options) {
     target = new BufferWithAccessor(gl2, { byteLength, accessor: { type: sourceType, size: components } });
   }
   target.bind({ glTarget: import_constants28.GL.PIXEL_PACK_BUFFER });
-  withParameters(gl2, { framebuffer }, () => {
+  withGLParameters(gl2, { framebuffer }, () => {
     gl2.readPixels(
       sourceX,
       sourceY,
@@ -6454,7 +6513,7 @@ function copyToTexture(source, target, options) {
   targetX = targetX || 0;
   targetY = targetY || 0;
   targetZ = targetZ || 0;
-  const prevHandle2 = device.gl.bindFramebuffer(import_constants28.GL.FRAMEBUFFER, handle);
+  const prevHandle = device.gl.bindFramebuffer(import_constants28.GL.FRAMEBUFFER, handle);
   (0, import_core30.assert)(target);
   let texture = null;
   let textureTarget;
@@ -6515,7 +6574,7 @@ function copyToTexture(source, target, options) {
   if (texture) {
     texture.unbind();
   }
-  gl.bindFramebuffer(import_constants28.GL.FRAMEBUFFER, prevHandle2 || null);
+  device.gl.bindFramebuffer(import_constants28.GL.FRAMEBUFFER, prevHandle || null);
   if (deleteFramebuffer) {
     framebuffer.destroy();
   }
@@ -6529,16 +6588,12 @@ function getFramebuffer2(source) {
 }
 function toFramebuffer(texture, props) {
   const { device, width, height, id } = texture;
-  const framebuffer = device.createFramebuffer(
-    __spreadProps(__spreadValues({}, props), {
-      id: `framebuffer-for-${id}`,
-      width,
-      height,
-      colorAttachments: [
-        texture
-      ]
-    })
-  );
+  const framebuffer = device.createFramebuffer(__spreadProps(__spreadValues({}, props), {
+    id: `framebuffer-for-${id}`,
+    width,
+    height,
+    colorAttachments: [texture]
+  }));
   return framebuffer;
 }
 function getPixelArray(pixelArray, type, format, width, height) {