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

package/dist/dist.dev.js

@@ -43,7 +43,7 @@ var __exports__ = (() => {
     WEBGLSampler: () => WEBGLSampler,
     WEBGLShader: () => WEBGLShader,
     WEBGLTexture: () => WEBGLTexture,
-    WEBGLVertexArrayObject: () => WEBGLVertexArrayObject,
+    WEBGLVertexArray: () => WEBGLVertexArray,
     WebGLCanvasContext: () => WebGLCanvasContext,
     WebGLDevice: () => WebGLDevice,
     WebGLResource: () => WebGLResource,
@@ -54,7 +54,7 @@ var __exports__ = (() => {
     clear: () => clear,
     convertGLToTextureFormat: () => convertGLToTextureFormat,
     copyToTexture: () => copyToTexture,
-    getParameters: () => getParameters,
+    getGLParameters: () => getGLParameters,
     getShaderLayout: () => getShaderLayout,
     getWebGL2Context: () => getWebGL2Context,
     isWebGL: () => isWebGL,
@@ -65,12 +65,12 @@ var __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
   });
 
   // src/context/context/create-headless-context.ts
@@ -106,11 +106,11 @@ var __exports__ = (() => {
     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;
   }
 
   // ../../node_modules/@probe.gl/env/dist/lib/is-electron.js
@@ -1150,9 +1150,13 @@ var __exports__ = (() => {
   __publicField(Buffer2, "MAP_WRITE", 2);
   __publicField(Buffer2, "COPY_SRC", 4);
   __publicField(Buffer2, "COPY_DST", 8);
+  /** Index buffer */
   __publicField(Buffer2, "INDEX", 16);
+  /** Vertex buffer */
   __publicField(Buffer2, "VERTEX", 32);
+  /** Uniform buffer */
   __publicField(Buffer2, "UNIFORM", 64);
+  /** Storage buffer */
   __publicField(Buffer2, "STORAGE", 128);
   __publicField(Buffer2, "INDIRECT", 256);
   __publicField(Buffer2, "QUERY_RESOLVE", 512);
@@ -1243,6 +1247,7 @@ var __exports__ = (() => {
     createCommandEncoder(props = {}) {
       throw new Error("not implemented");
     }
+    /** Create a vertex array */
     /** Create a RenderPass */
     /** Create a ComputePass */
     /** Get a renderpass that is set up to render to the primary CanvasContext */
@@ -1448,11 +1453,11 @@ var __exports__ = (() => {
     // PRIVATE
     /** @todo Major hack done to port the CSS methods above, base canvas context should not depend on WebGL */
     getDrawingBufferSize() {
-      const gl2 = this.device.gl;
-      if (!gl2) {
+      const gl = this.device.gl;
+      if (!gl) {
         throw new Error("canvas size");
       }
-      return [gl2.drawingBufferWidth, gl2.drawingBufferHeight];
+      return [gl.drawingBufferWidth, gl.drawingBufferHeight];
     }
     /** Perform platform specific updates (WebGPU vs WebGL) */
     /**
@@ -1612,7 +1617,7 @@ var __exports__ = (() => {
     stage: "vertex",
     source: "",
     sourceMap: null,
-    language: "glsl",
+    language: "auto",
     shaderType: 0
   });
 
@@ -1837,12 +1842,13 @@ var __exports__ = (() => {
       return "RenderPipeline";
     }
     hash = "";
+    /** The merged layout */
+    /** Buffer map describing buffer interleaving etc */
     constructor(device, props) {
       super(device, props, _RenderPipeline.defaultProps);
+      this.shaderLayout = this.props.shaderLayout;
+      this.bufferLayout = this.props.bufferLayout || [];
     }
-    /** Set attributes (stored on pipeline and set before each call) */
-    /** Set attributes (stored on pipeline and set before each call) */
-    /** Set constant attributes (WebGL only) */
     /** Set bindings (stored on pipeline and set before each call) */
     /** Uniforms 
      * @deprecated Only supported on WebGL devices.
@@ -1868,8 +1874,6 @@ var __exports__ = (() => {
     parameters: {},
     vertexCount: 0,
     instanceCount: 0,
-    indices: null,
-    attributes: {},
     bindings: {},
     uniforms: {}
   });
@@ -1978,12 +1982,67 @@ var __exports__ = (() => {
     ...Resource.defaultProps
   });
 
-  // ../core/src/lib/utils/assert.ts
-  function assert2(condition, message2) {
-    if (!condition) {
-      throw new Error(message2 || "luma.gl: assertion failed.");
+  // ../core/src/adapter/type-utils/decode-attribute-type.ts
+  function decodeShaderAttributeType(attributeType) {
+    const [dataType, components] = TYPE_INFO[attributeType];
+    const integer = dataType === "i32" || dataType === "u32";
+    const signed = dataType !== "u32";
+    const byteLength = TYPE_SIZES[dataType] * components;
+    const defaultVertexFormat = getCompatibleVertexFormat(dataType, components);
+    return {
+      dataType,
+      components,
+      defaultVertexFormat,
+      byteLength,
+      integer,
+      signed
+    };
+  }
+  function getCompatibleVertexFormat(dataType, components) {
+    let vertexType;
+    switch (dataType) {
+      case "f32":
+        vertexType = "float32";
+        break;
+      case "i32":
+        vertexType = "sint32";
+        break;
+      case "u32":
+        vertexType = "uint32";
+        break;
+      case "f16":
+        return components <= 2 ? "float16x2" : "float16x4";
+    }
+    if (components === 1) {
+      return vertexType;
     }
+    return `${vertexType}x${components}`;
   }
+  var TYPE_INFO = {
+    f32: ["f32", 1],
+    "vec2<f32>": ["f32", 2],
+    "vec3<f32>": ["f32", 3],
+    "vec4<f32>": ["f32", 4],
+    f16: ["f16", 1],
+    "vec2<f16>": ["f16", 2],
+    "vec3<f16>": ["f16", 3],
+    "vec4<f16>": ["f16", 4],
+    i32: ["i32", 1],
+    "vec2<i32>": ["i32", 2],
+    "vec3<i32>": ["i32", 3],
+    "vec4<i32>": ["i32", 4],
+    u32: ["u32", 1],
+    "vec2<u32>": ["u32", 2],
+    "vec3<u32>": ["u32", 3],
+    "vec4<u32>": ["u32", 4]
+  };
+  var TYPE_SIZES = {
+    f32: 4,
+    f16: 2,
+    i32: 4,
+    u32: 4
+    // 'bool-webgl': 4,  
+  };
 
   // ../core/src/adapter/type-utils/decode-data-type.ts
   function decodeVertexType(type) {
@@ -2001,7 +2060,7 @@ var __exports__ = (() => {
     };
   }
   function getDataTypeBytes(type) {
-    const bytes = TYPE_SIZES[type];
+    const bytes = TYPE_SIZES2[type];
     return bytes;
   }
   var TYPE_MAP = {
@@ -2018,7 +2077,7 @@ var __exports__ = (() => {
     uint32: "uint32",
     sint32: "sint32"
   };
-  var TYPE_SIZES = {
+  var TYPE_SIZES2 = {
     uint8: 1,
     sint8: 1,
     uint16: 2,
@@ -2054,6 +2113,203 @@ var __exports__ = (() => {
     return result;
   }
 
+  // ../core/src/adapter/attribute-utils/get-attribute-from-layouts.ts
+  function getAttributeInfosFromLayouts(shaderLayout, bufferLayout) {
+    const attributeInfos = {};
+    for (const attribute of shaderLayout.attributes) {
+      attributeInfos[attribute.name] = getAttributeInfoFromLayouts(shaderLayout, bufferLayout, attribute.name);
+    }
+    return attributeInfos;
+  }
+  function getAttributeInfosByLocation(shaderLayout, bufferLayout, maxVertexAttributes = 16) {
+    const attributeInfos = getAttributeInfosFromLayouts(shaderLayout, bufferLayout);
+    const locationInfos = new Array(maxVertexAttributes).fill(null);
+    for (const attributeInfo of Object.values(attributeInfos)) {
+      locationInfos[attributeInfo.location] = attributeInfo;
+    }
+    return locationInfos;
+  }
+  function getAttributeInfoFromLayouts(shaderLayout, bufferLayout, name2) {
+    const shaderDeclaration = getAttributeFromShaderLayout(shaderLayout, name2);
+    const bufferMapping = getAttributeFromBufferLayout(bufferLayout, name2);
+    if (!shaderDeclaration) {
+      return null;
+    }
+    const attributeTypeInfo = decodeShaderAttributeType(shaderDeclaration.type);
+    const vertexFormat = bufferMapping?.vertexFormat || attributeTypeInfo.defaultVertexFormat;
+    const vertexFormatInfo = decodeVertexFormat(vertexFormat);
+    return {
+      attributeName: bufferMapping?.attributeName || shaderDeclaration.name,
+      bufferName: bufferMapping?.bufferName || shaderDeclaration.name,
+      location: shaderDeclaration.location,
+      shaderType: shaderDeclaration.type,
+      shaderDataType: attributeTypeInfo.dataType,
+      shaderComponents: attributeTypeInfo.components,
+      vertexFormat,
+      bufferDataType: vertexFormatInfo.type,
+      bufferComponents: vertexFormatInfo.components,
+      // normalized is a property of the buffer's vertex format
+      normalized: vertexFormatInfo.normalized,
+      // integer is a property of the shader declaration
+      integer: attributeTypeInfo.integer,
+      stepMode: bufferMapping?.stepMode || shaderDeclaration.stepMode,
+      byteOffset: bufferMapping?.byteOffset || 0,
+      byteStride: bufferMapping?.byteStride || 0
+    };
+  }
+  function getAttributeFromShaderLayout(shaderLayout, name2) {
+    const attribute = shaderLayout.attributes.find((attr) => attr.name === name2);
+    if (!attribute) {
+      log.warn(`shader layout attribute "${name2}" not present in shader`);
+    }
+    return attribute || null;
+  }
+  function getAttributeFromBufferLayout(bufferLayouts, name2) {
+    checkBufferLayouts(bufferLayouts);
+    let bufferLayoutInfo = getAttributeFromShortHand(bufferLayouts, name2);
+    if (bufferLayoutInfo) {
+      return bufferLayoutInfo;
+    }
+    bufferLayoutInfo = getAttributeFromAttributesList(bufferLayouts, name2);
+    if (bufferLayoutInfo) {
+      return bufferLayoutInfo;
+    }
+    log.warn(`layout for attribute "${name2}" not present in buffer layout`);
+    return null;
+  }
+  function checkBufferLayouts(bufferLayouts) {
+    for (const bufferLayout of bufferLayouts) {
+      if (bufferLayout.attributes && bufferLayout.format || !bufferLayout.attributes && !bufferLayout.format) {
+        log.warn(`BufferLayout ${name} must have either 'attributes' or 'format' field`);
+      }
+    }
+  }
+  function getAttributeFromShortHand(bufferLayouts, name2) {
+    for (const bufferLayout of bufferLayouts) {
+      if (bufferLayout.format && bufferLayout.name === name2) {
+        return {
+          attributeName: bufferLayout.name,
+          bufferName: name2,
+          stepMode: bufferLayout.stepMode,
+          vertexFormat: bufferLayout.format,
+          // If offset is needed, use `attributes` field.
+          byteOffset: 0,
+          byteStride: bufferLayout.byteStride || 0
+        };
+      }
+    }
+    return null;
+  }
+  function getAttributeFromAttributesList(bufferLayouts, name2) {
+    for (const bufferLayout of bufferLayouts) {
+      let byteStride = bufferLayout.byteStride;
+      if (typeof bufferLayout.byteStride !== "number") {
+        for (const attributeMapping2 of bufferLayout.attributes || []) {
+          const info = decodeVertexFormat(attributeMapping2.format);
+          byteStride += info.byteLength;
+        }
+      }
+      const attributeMapping = bufferLayout.attributes?.find((mapping) => mapping.attribute === name2);
+      if (attributeMapping) {
+        return {
+          attributeName: attributeMapping.attribute,
+          bufferName: bufferLayout.name,
+          stepMode: bufferLayout.stepMode,
+          vertexFormat: attributeMapping.format,
+          byteOffset: attributeMapping.byteOffset,
+          byteStride
+        };
+      }
+    }
+    return null;
+  }
+  function mergeShaderLayout(baseLayout, overrideLayout) {
+    const mergedLayout = {
+      ...baseLayout,
+      attributes: baseLayout.attributes.map((attribute) => ({
+        ...attribute
+      }))
+    };
+    for (const attribute of overrideLayout?.attributes || []) {
+      const baseAttribute = mergedLayout.attributes.find((attr) => attr.name === attribute.name);
+      if (!baseAttribute) {
+        log.warn(`shader layout attribute ${attribute.name} not present in shader`);
+      } else {
+        baseAttribute.type = attribute.type || baseAttribute.type;
+        baseAttribute.stepMode = attribute.stepMode || baseAttribute.stepMode;
+      }
+    }
+    return mergedLayout;
+  }
+
+  // ../core/src/adapter/resources/vertex-array.ts
+  var _VertexArray = class extends Resource {
+    get [Symbol.toStringTag]() {
+      return "VertexArray";
+    }
+    /** Max number of vertex attributes */
+    /** Attribute infos indexed by location - TODO only needed by webgl module? */
+    indexBuffer = null;
+    constructor(device, props) {
+      super(device, props, _VertexArray.defaultProps);
+      this.maxVertexAttributes = device.limits.maxVertexAttributes;
+      this.attributes = new Array(this.maxVertexAttributes).fill(null);
+      this.attributeInfos = getAttributeInfosByLocation(props.renderPipeline.shaderLayout, props.renderPipeline.bufferLayout, this.maxVertexAttributes);
+    }
+    /** Set attributes (stored on pipeline and set before each call) */
+    /** Set attributes (stored on pipeline and set before each call) */
+    /** Set constant attributes (WebGL only) */
+  };
+  var VertexArray = _VertexArray;
+  __publicField(VertexArray, "defaultProps", {
+    ...Resource.defaultProps,
+    renderPipeline: null
+  });
+
+  // ../core/src/lib/utils/assert.ts
+  function assert2(condition, message2) {
+    if (!condition) {
+      throw new Error(message2 || "luma.gl: assertion failed.");
+    }
+  }
+
+  // ../core/src/lib/utils/array-utils-flat.ts
+  var arrayBuffer;
+  function getScratchArrayBuffer(byteLength) {
+    if (!arrayBuffer || arrayBuffer.byteLength < byteLength) {
+      arrayBuffer = new ArrayBuffer(byteLength);
+    }
+    return arrayBuffer;
+  }
+  function getScratchArray(Type, length) {
+    const scratchArrayBuffer = getScratchArrayBuffer(Type.BYTES_PER_ELEMENT * length);
+    return new Type(scratchArrayBuffer, 0, length);
+  }
+  function fillArray(options) {
+    const {
+      target,
+      source,
+      start = 0,
+      count = 1
+    } = options;
+    const length = source.length;
+    const total = count * length;
+    let copied = 0;
+    for (let i = start; copied < length; copied++) {
+      target[i++] = source[copied];
+    }
+    while (copied < total) {
+      if (copied < total - copied) {
+        target.copyWithin(start + copied, start, start + copied);
+        copied *= 2;
+      } else {
+        target.copyWithin(start + copied, start, start + total - copied);
+        copied = total;
+      }
+    }
+    return options.target;
+  }
+
   // ../core/src/adapter/type-utils/decode-texture-format.ts
   var REGEX = /^(rg?b?a?)([0-9]*)([a-z]*)(-srgb)?(-webgl|-unsized)?$/;
   function decodeTextureFormat(format) {
@@ -2160,68 +2416,6 @@ var __exports__ = (() => {
     };
   }
 
-  // ../core/src/adapter/type-utils/decode-attribute-type.ts
-  function decodeShaderAttributeType(attributeType) {
-    const [dataType, components] = TYPE_INFO[attributeType];
-    const integer = dataType === "i32" || dataType === "u32";
-    const signed = dataType !== "u32";
-    const byteLength = TYPE_SIZES2[dataType] * components;
-    const defaultVertexFormat = getCompatibleVertexFormat(dataType, components);
-    return {
-      dataType,
-      components,
-      defaultVertexFormat,
-      byteLength,
-      integer,
-      signed
-    };
-  }
-  function getCompatibleVertexFormat(dataType, components) {
-    let vertexType;
-    switch (dataType) {
-      case "f32":
-        vertexType = "float32";
-        break;
-      case "i32":
-        vertexType = "sint32";
-        break;
-      case "u32":
-        vertexType = "uint32";
-        break;
-      case "f16":
-        return components <= 2 ? "float16x2" : "float16x4";
-    }
-    if (components === 1) {
-      return vertexType;
-    }
-    return `${vertexType}x${components}`;
-  }
-  var TYPE_INFO = {
-    f32: ["f32", 1],
-    "vec2<f32>": ["f32", 2],
-    "vec3<f32>": ["f32", 3],
-    "vec4<f32>": ["f32", 4],
-    f16: ["f16", 1],
-    "vec2<f16>": ["f16", 2],
-    "vec3<f16>": ["f16", 3],
-    "vec4<f16>": ["f16", 4],
-    i32: ["i32", 1],
-    "vec2<i32>": ["i32", 2],
-    "vec3<i32>": ["i32", 3],
-    "vec4<i32>": ["i32", 4],
-    u32: ["u32", 1],
-    "vec2<u32>": ["u32", 2],
-    "vec3<u32>": ["u32", 3],
-    "vec4<u32>": ["u32", 4]
-  };
-  var TYPE_SIZES2 = {
-    f32: 4,
-    f16: 2,
-    i32: 4,
-    u32: 4
-    // 'bool-webgl': 4,  
-  };
-
   // ../core/src/lib/compiler-log/format-compiler-log.ts
   function formatCompilerLog(shaderLog, source, options) {
     const lines = source.split(/\r?\n/);
@@ -2234,153 +2428,32 @@ var __exports__ = (() => {
   function formatCompilerMessage(message2, lines, lineNum, options) {
     if (options?.showSourceCode) {
       const positionIndicator = message2.linePos > 0 ? `${" ".repeat(message2.linePos + 5)}^^^
-` : "";
-      const numberedLines = getNumberedLines(lines, lineNum);
-      return `${numberedLines}${positionIndicator}${message2.type.toUpperCase()}: ${message2.message}
-
-`;
-    }
-    return `${message2.type.toUpperCase()}: ${message2.message}
-`;
-  }
-  function getNumberedLines(lines, lineNum) {
-    let numberedLines = "";
-    for (let line = lineNum - 2; line <= lineNum; line++) {
-      const sourceLine = lines[line];
-      if (sourceLine !== void 0) {
-        numberedLines += `${padLeft(String(line), 4)}: ${sourceLine}
-`;
-      }
-    }
-    return numberedLines;
-  }
-  function padLeft(string, paddedLength) {
-    let result = "";
-    for (let i = string.length; i < paddedLength; ++i) {
-      result += " ";
-    }
-    return result + string;
-  }
-
-  // ../core/src/adapter/attribute-utils/get-attribute-from-layouts.ts
-  function getAttributeInfosFromLayouts(shaderLayout, bufferLayout) {
-    const attributeInfos = {};
-    for (const attribute of shaderLayout.attributes) {
-      attributeInfos[attribute.name] = getAttributeInfoFromLayouts(shaderLayout, bufferLayout, attribute.name);
-    }
-    return attributeInfos;
-  }
-  function getAttributeInfoFromLayouts(shaderLayout, bufferLayout, name2) {
-    const shaderDeclaration = getAttributeFromShaderLayout(shaderLayout, name2);
-    const bufferMapping = getAttributeFromBufferLayout(bufferLayout, name2);
-    if (!shaderDeclaration) {
-      return null;
-    }
-    const attributeTypeInfo = decodeShaderAttributeType(shaderDeclaration.type);
-    const vertexFormat = bufferMapping?.vertexFormat || attributeTypeInfo.defaultVertexFormat;
-    const vertexFormatInfo = decodeVertexFormat(vertexFormat);
-    return {
-      attributeName: bufferMapping?.attributeName || shaderDeclaration.name,
-      bufferName: bufferMapping?.bufferName || shaderDeclaration.name,
-      location: shaderDeclaration.location,
-      shaderType: shaderDeclaration.type,
-      shaderDataType: attributeTypeInfo.dataType,
-      shaderComponents: attributeTypeInfo.components,
-      vertexFormat,
-      bufferDataType: vertexFormatInfo.type,
-      bufferComponents: vertexFormatInfo.components,
-      // normalized is a property of the buffer's vertex format
-      normalized: vertexFormatInfo.normalized,
-      // integer is a property of the shader declaration
-      integer: attributeTypeInfo.integer,
-      stepMode: bufferMapping?.stepMode || shaderDeclaration.stepMode,
-      byteOffset: bufferMapping?.byteOffset || 0,
-      byteStride: bufferMapping?.byteStride || 0
-    };
-  }
-  function getAttributeFromShaderLayout(shaderLayout, name2) {
-    const attribute = shaderLayout.attributes.find((attr) => attr.name === name2);
-    if (!attribute) {
-      log.warn(`shader layout attribute "${name2}" not present in shader`);
-    }
-    return attribute || null;
-  }
-  function getAttributeFromBufferLayout(bufferLayouts, name2) {
-    checkBufferLayouts(bufferLayouts);
-    let bufferLayoutInfo = getAttributeFromShortHand(bufferLayouts, name2);
-    if (bufferLayoutInfo) {
-      return bufferLayoutInfo;
-    }
-    bufferLayoutInfo = getAttributeFromAttributesList(bufferLayouts, name2);
-    if (bufferLayoutInfo) {
-      return bufferLayoutInfo;
-    }
-    log.warn(`layout for attribute "${name2}" not present in buffer layout`);
-    return null;
-  }
-  function checkBufferLayouts(bufferLayouts) {
-    for (const bufferLayout of bufferLayouts) {
-      if (bufferLayout.attributes && bufferLayout.format || !bufferLayout.attributes && !bufferLayout.format) {
-        log.warn(`BufferLayout ${name} must have either 'attributes' or 'format' field`);
-      }
-    }
-  }
-  function getAttributeFromShortHand(bufferLayouts, name2) {
-    for (const bufferLayout of bufferLayouts) {
-      if (bufferLayout.format && bufferLayout.name === name2) {
-        return {
-          attributeName: bufferLayout.name,
-          bufferName: name2,
-          stepMode: bufferLayout.stepMode,
-          vertexFormat: bufferLayout.format,
-          // If offset is needed, use `attributes` field.
-          byteOffset: 0,
-          byteStride: bufferLayout.byteStride || 0
-        };
-      }
-    }
-    return null;
-  }
-  function getAttributeFromAttributesList(bufferLayouts, name2) {
-    for (const bufferLayout of bufferLayouts) {
-      let byteStride = bufferLayout.byteStride;
-      if (typeof bufferLayout.byteStride !== "number") {
-        for (const attributeMapping2 of bufferLayout.attributes || []) {
-          const info = decodeVertexFormat(attributeMapping2.format);
-          byteStride += info.byteLength;
-        }
-      }
-      const attributeMapping = bufferLayout.attributes?.find((mapping) => mapping.attribute === name2);
-      if (attributeMapping) {
-        return {
-          attributeName: attributeMapping.attribute,
-          bufferName: bufferLayout.name,
-          stepMode: bufferLayout.stepMode,
-          vertexFormat: attributeMapping.format,
-          byteOffset: attributeMapping.byteOffset,
-          byteStride
-        };
-      }
+` : "";
+      const numberedLines = getNumberedLines(lines, lineNum);
+      return `${numberedLines}${positionIndicator}${message2.type.toUpperCase()}: ${message2.message}
+
+`;
     }
-    return null;
+    return `${message2.type.toUpperCase()}: ${message2.message}
+`;
   }
-  function mergeShaderLayout(baseLayout, overrideLayout) {
-    const mergedLayout = {
-      ...baseLayout,
-      attributes: baseLayout.attributes.map((attribute) => ({
-        ...attribute
-      }))
-    };
-    for (const attribute of overrideLayout?.attributes || []) {
-      const baseAttribute = mergedLayout.attributes.find((attr) => attr.name === attribute.name);
-      if (!baseAttribute) {
-        log.warn(`shader layout attribute ${attribute.name} not present in shader`);
-      } else {
-        baseAttribute.type = attribute.type || baseAttribute.type;
-        baseAttribute.stepMode = attribute.stepMode || baseAttribute.stepMode;
+  function getNumberedLines(lines, lineNum) {
+    let numberedLines = "";
+    for (let line = lineNum - 2; line <= lineNum; line++) {
+      const sourceLine = lines[line];
+      if (sourceLine !== void 0) {
+        numberedLines += `${padLeft(String(line), 4)}: ${sourceLine}
+`;
       }
     }
-    return mergedLayout;
+    return numberedLines;
+  }
+  function padLeft(string, paddedLength) {
+    let result = "";
+    for (let i = string.length; i < paddedLength; ++i) {
+      result += " ";
+    }
+    return result + string;
   }
 
   // ../core/src/lib/utils/cast.ts
@@ -2468,43 +2541,6 @@ var __exports__ = (() => {
     });
   }
 
-  // ../core/src/lib/utils/array-utils-flat.ts
-  var arrayBuffer;
-  function getScratchArrayBuffer(byteLength) {
-    if (!arrayBuffer || arrayBuffer.byteLength < byteLength) {
-      arrayBuffer = new ArrayBuffer(byteLength);
-    }
-    return arrayBuffer;
-  }
-  function getScratchArray(Type, length) {
-    const scratchArrayBuffer = getScratchArrayBuffer(Type.BYTES_PER_ELEMENT * length);
-    return new Type(scratchArrayBuffer, 0, length);
-  }
-  function fillArray(options) {
-    const {
-      target,
-      source,
-      start = 0,
-      count = 1
-    } = options;
-    const length = source.length;
-    const total = count * length;
-    let copied = 0;
-    for (let i = start; copied < length; copied++) {
-      target[i++] = source[copied];
-    }
-    while (copied < total) {
-      if (copied < total - copied) {
-        target.copyWithin(start + copied, start, start + copied);
-        copied *= 2;
-      } else {
-        target.copyWithin(start + copied, start, start + total - copied);
-        copied = total;
-      }
-    }
-    return options.target;
-  }
-
   // src/context/polyfill/polyfill-vertex-array-object.ts
   var glErrorShadow = {};
   function error(msg) {
@@ -2523,43 +2559,43 @@ var __exports__ = (() => {
       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;
@@ -2569,19 +2605,19 @@ var __exports__ = (() => {
   WebGLVertexArrayObjectOES.VertexAttrib.prototype.recache = function recache() {
     this.cached = [this.size, this.type, this.normalized, this.stride, this.offset].join(":");
   };
-  var OESVertexArrayObject = function OESVertexArrayObject2(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;
@@ -2590,53 +2626,53 @@ var __exports__ = (() => {
       }
       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];
@@ -2649,11 +2685,11 @@ var __exports__ = (() => {
       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("webglcontextrestored", () => {
+    if (gl.canvas) {
+      gl.canvas.addEventListener("webglcontextrestored", () => {
         log2("OESVertexArrayObject emulation library context restored");
         self.reset_();
       }, true);
@@ -2668,8 +2704,8 @@ var __exports__ = (() => {
         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;
@@ -2697,9 +2733,9 @@ var __exports__ = (() => {
     return false;
   };
   OESVertexArrayObject.prototype.bindVertexArrayOES = function bindVertexArrayOES(arrayObject) {
-    const gl2 = this.gl;
+    const gl = this.gl;
     if (arrayObject && !arrayObject.isAlive) {
-      synthesizeGLError(gl2.INVALID_OPERATION, "bindVertexArrayOES: attempt to bind deleted arrayObject");
+      synthesizeGLError(gl.INVALID_OPERATION, "bindVertexArrayOES: attempt to bind deleted arrayObject");
       return;
     }
     const original = this.original;
@@ -2711,7 +2747,7 @@ var __exports__ = (() => {
       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);
@@ -2720,43 +2756,43 @@ var __exports__ = (() => {
       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, n, attrib.size, attrib.type, attrib.normalized, attrib.stride, attrib.offset);
+          original.vertexAttribPointer.call(gl, n, attrib.size, attrib.type, attrib.normalized, attrib.stride, attrib.offset);
         }
       }
     }
     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 original_getExtension = gl.getExtension;
+    gl.getExtension = function getExtension(name2) {
       const ext = original_getExtension.call(this, name2);
       if (ext) {
         return ext;
@@ -2764,7 +2800,7 @@ var __exports__ = (() => {
       if (name2 !== "OES_vertex_array_object") {
         return null;
       }
-      if (!gl2.__OESVertexArrayObject) {
+      if (!gl.__OESVertexArrayObject) {
         this.__OESVertexArrayObject = new OESVertexArrayObject(this);
       }
       return this.__OESVertexArrayObject;
@@ -3441,31 +3477,31 @@ var __exports__ = (() => {
   // src/context/context/webgl-checks.ts
   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) {
-    assert2(isWebGL(gl2), ERR_CONTEXT);
-    return gl2;
+  function assertWebGLContext(gl) {
+    assert2(isWebGL(gl), ERR_CONTEXT);
+    return gl;
   }
-  function assertWebGL2Context(gl2) {
-    assert2(isWebGL2(gl2), ERR_WEBGL2);
-    return gl2;
+  function assertWebGL2Context(gl) {
+    assert2(isWebGL2(gl), ERR_WEBGL2);
+    return gl;
   }
 
   // src/context/polyfill/get-parameter-polyfill.ts
@@ -3481,39 +3517,39 @@ var __exports__ = (() => {
   var GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT = 34047;
   var GL_UNMASKED_VENDOR_WEBGL = 37445;
   var GL_UNMASKED_RENDERER_WEBGL = 37446;
-  var getWebGL2ValueOrZero = (gl2) => !isWebGL2(gl2) ? 0 : void 0;
+  var getWebGL2ValueOrZero = (gl) => !isWebGL2(gl) ? 0 : void 0;
   var WEBGL_PARAMETERS = {
-    [GL.READ_BUFFER]: (gl2) => !isWebGL2(gl2) ? GL.COLOR_ATTACHMENT0 : void 0,
+    [GL.READ_BUFFER]: (gl) => !isWebGL2(gl) ? 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,
     [GL.RASTERIZER_DISCARD]: getWebGL2ValueOrZero,
     [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 || 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 || GL.RENDERER);
     },
     // Extension LIMITS
-    [GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT]: (gl2, getParameter) => {
-      const ext = gl2.luma?.extensions?.[EXT_texture_filter_anisotropic] || gl2.getExtension("EXT_texture_filter_anisotropic");
+    [GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT]: (gl, getParameter) => {
+      const ext = gl.luma?.extensions?.[EXT_texture_filter_anisotropic] || gl.getExtension("EXT_texture_filter_anisotropic");
       return ext ? getParameter(ext.MAX_TEXTURE_MAX_ANISOTROPY_EXT) : 1;
     },
     // WebGL2 Limits
     [GL.MAX_3D_TEXTURE_SIZE]: getWebGL2ValueOrZero,
     [GL.MAX_ARRAY_TEXTURE_LAYERS]: getWebGL2ValueOrZero,
     [GL.MAX_CLIENT_WAIT_TIMEOUT_WEBGL]: getWebGL2ValueOrZero,
-    [GL.MAX_COLOR_ATTACHMENTS]: (gl2, getParameter) => {
-      if (!isWebGL2(gl2)) {
-        const ext = gl2.getExtension(WEBGL_draw_buffers);
+    [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;
@@ -3521,24 +3557,24 @@ var __exports__ = (() => {
     [GL.MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS]: getWebGL2ValueOrZero,
     [GL.MAX_COMBINED_UNIFORM_BLOCKS]: getWebGL2ValueOrZero,
     [GL.MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS]: getWebGL2ValueOrZero,
-    [GL.MAX_DRAW_BUFFERS]: (gl2) => {
-      if (!isWebGL2(gl2)) {
-        const ext = gl2.getExtension(WEBGL_draw_buffers);
+    [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;
     },
     [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
     ),
     [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
     ),
     [GL.MAX_ELEMENTS_VERTICES]: (
       // Guess: "Reasonably safe" per webglstats.com - could be higher/lower (on some mobile devices)
-      (gl2) => 16777216
+      (gl) => 16777216
     ),
     [GL.MAX_FRAGMENT_INPUT_COMPONENTS]: getWebGL2ValueOrZero,
     [GL.MAX_FRAGMENT_UNIFORM_BLOCKS]: getWebGL2ValueOrZero,
@@ -3559,24 +3595,24 @@ var __exports__ = (() => {
     [GL.MAX_PROGRAM_TEXEL_OFFSET]: getWebGL2ValueOrZero,
     [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
@@ -3586,10 +3622,10 @@ var __exports__ = (() => {
   var EXT_disjoint_timer_query2 = "EXT_disjoint_timer_query";
   var EXT_texture_filter_anisotropic2 = "EXT_texture_filter_anisotropic";
   var ERR_VAO_NOT_SUPPORTED = "VertexArray requires WebGL2 or OES_vertex_array_object extension";
-  function getExtensionData(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 = {
@@ -3660,18 +3696,18 @@ var __exports__ = (() => {
   };
   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) => {
+    getVertexAttrib: (gl, originalFunc, location, pname) => {
       const {
         webgl2,
         ext
-      } = getExtensionData(gl2, ANGLE_instanced_arrays);
+      } = getExtensionData(gl, ANGLE_instanced_arrays);
       let result;
       switch (pname) {
         case GL.VERTEX_ATTRIB_ARRAY_INTEGER:
@@ -3685,8 +3721,8 @@ var __exports__ = (() => {
       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 GL.TRANSFORM_FEEDBACK_BUFFER_MODE:
             return GL.SEPARATE_ATTRIBS;
@@ -3699,21 +3735,21 @@ var __exports__ = (() => {
       }
       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 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 GL.TEXTURE_MAX_ANISOTROPY_EXT:
-          const contextData = getContextData(gl2);
+          const contextData = getContextData(gl);
           const {
             _extensions
           } = contextData;
@@ -3725,47 +3761,47 @@ var __exports__ = (() => {
       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, {
+      polyfillVertexArrayObject(gl);
+      initializeExtensions(gl);
+      installPolyfills(gl, WEBGL2_CONTEXT_POLYFILLS);
+      installOverrides(gl, {
         target: contextState,
-        target2: gl2
+        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, {
+        polyfillExtension(gl, {
           extension,
           target: contextState,
-          target2: gl2
+          target2: gl
         });
       }
     }
   }
-  function polyfillExtension(gl2, {
+  function polyfillExtension(gl, {
     extension,
     target,
     target2
@@ -3778,12 +3814,12 @@ var __exports__ = (() => {
     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") {
@@ -3795,15 +3831,15 @@ var __exports__ = (() => {
       }
     }
   }
-  function installOverrides(gl2, {
+  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;
       }
@@ -3894,19 +3930,19 @@ var __exports__ = (() => {
     [GL.UNPACK_SKIP_ROWS]: 0,
     [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 === GL.FRAMEBUFFER_BINDING) {
-      target = isWebGL2(gl2) ? GL.DRAW_FRAMEBUFFER : GL.FRAMEBUFFER;
+      target = isWebGL2(gl) ? GL.DRAW_FRAMEBUFFER : GL.FRAMEBUFFER;
     } else {
       target = 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 = {
       [GL.ARRAY_BUFFER_BINDING]: GL.ARRAY_BUFFER,
       [GL.COPY_READ_BUFFER_BINDING]: GL.COPY_READ_BUFFER,
@@ -3915,35 +3951,35 @@ var __exports__ = (() => {
       [GL.PIXEL_UNPACK_BUFFER_BINDING]: 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 = {
     [GL.BLEND]: enable,
-    [GL.BLEND_COLOR]: (gl2, value) => gl2.blendColor(...value),
+    [GL.BLEND_COLOR]: (gl, value) => gl.blendColor(...value),
     [GL.BLEND_EQUATION_RGB]: "blendEquation",
     [GL.BLEND_EQUATION_ALPHA]: "blendEquation",
     [GL.BLEND_SRC_RGB]: "blendFunc",
     [GL.BLEND_DST_RGB]: "blendFunc",
     [GL.BLEND_SRC_ALPHA]: "blendFunc",
     [GL.BLEND_DST_ALPHA]: "blendFunc",
-    [GL.COLOR_CLEAR_VALUE]: (gl2, value) => gl2.clearColor(...value),
-    [GL.COLOR_WRITEMASK]: (gl2, value) => gl2.colorMask(...value),
+    [GL.COLOR_CLEAR_VALUE]: (gl, value) => gl.clearColor(...value),
+    [GL.COLOR_WRITEMASK]: (gl, value) => gl.colorMask(...value),
     [GL.CULL_FACE]: enable,
-    [GL.CULL_FACE_MODE]: (gl2, value) => gl2.cullFace(value),
+    [GL.CULL_FACE_MODE]: (gl, value) => gl.cullFace(value),
     [GL.DEPTH_TEST]: enable,
-    [GL.DEPTH_CLEAR_VALUE]: (gl2, value) => gl2.clearDepth(value),
-    [GL.DEPTH_FUNC]: (gl2, value) => gl2.depthFunc(value),
-    [GL.DEPTH_RANGE]: (gl2, value) => gl2.depthRange(...value),
-    [GL.DEPTH_WRITEMASK]: (gl2, value) => gl2.depthMask(value),
+    [GL.DEPTH_CLEAR_VALUE]: (gl, value) => gl.clearDepth(value),
+    [GL.DEPTH_FUNC]: (gl, value) => gl.depthFunc(value),
+    [GL.DEPTH_RANGE]: (gl, value) => gl.depthRange(...value),
+    [GL.DEPTH_WRITEMASK]: (gl, value) => gl.depthMask(value),
     [GL.DITHER]: enable,
     [GL.FRAGMENT_SHADER_DERIVATIVE_HINT]: hint,
-    [GL.CURRENT_PROGRAM]: (gl2, value) => gl2.useProgram(value),
-    [GL.RENDERBUFFER_BINDING]: (gl2, value) => gl2.bindRenderbuffer(GL.RENDERBUFFER, value),
-    [GL.TRANSFORM_FEEDBACK_BINDING]: (gl2, value) => gl2.bindTransformFeedback?.(GL.TRANSFORM_FEEDBACK, value),
-    [GL.VERTEX_ARRAY_BINDING]: (gl2, value) => gl2.bindVertexArray(value),
+    [GL.CURRENT_PROGRAM]: (gl, value) => gl.useProgram(value),
+    [GL.RENDERBUFFER_BINDING]: (gl, value) => gl.bindRenderbuffer(GL.RENDERBUFFER, value),
+    [GL.TRANSFORM_FEEDBACK_BINDING]: (gl, value) => gl.bindTransformFeedback?.(GL.TRANSFORM_FEEDBACK, value),
+    [GL.VERTEX_ARRAY_BINDING]: (gl, value) => gl.bindVertexArray(value),
     // NOTE: FRAMEBUFFER_BINDING and DRAW_FRAMEBUFFER_BINDING(WebGL2) refer same state.
     [GL.FRAMEBUFFER_BINDING]: bindFramebuffer,
     [GL.READ_FRAMEBUFFER_BINDING]: bindFramebuffer,
@@ -3953,9 +3989,9 @@ var __exports__ = (() => {
     [GL.COPY_WRITE_BUFFER_BINDING]: bindBuffer,
     [GL.PIXEL_PACK_BUFFER_BINDING]: bindBuffer,
     [GL.PIXEL_UNPACK_BUFFER_BINDING]: bindBuffer,
-    [GL.FRONT_FACE]: (gl2, value) => gl2.frontFace(value),
+    [GL.FRONT_FACE]: (gl, value) => gl.frontFace(value),
     [GL.GENERATE_MIPMAP_HINT]: hint,
-    [GL.LINE_WIDTH]: (gl2, value) => gl2.lineWidth(value),
+    [GL.LINE_WIDTH]: (gl, value) => gl.lineWidth(value),
     [GL.POLYGON_OFFSET_FILL]: enable,
     [GL.POLYGON_OFFSET_FACTOR]: "polygonOffset",
     [GL.POLYGON_OFFSET_UNITS]: "polygonOffset",
@@ -3965,11 +4001,11 @@ var __exports__ = (() => {
     [GL.SAMPLE_COVERAGE_VALUE]: "sampleCoverage",
     [GL.SAMPLE_COVERAGE_INVERT]: "sampleCoverage",
     [GL.SCISSOR_TEST]: enable,
-    [GL.SCISSOR_BOX]: (gl2, value) => gl2.scissor(...value),
+    [GL.SCISSOR_BOX]: (gl, value) => gl.scissor(...value),
     [GL.STENCIL_TEST]: enable,
-    [GL.STENCIL_CLEAR_VALUE]: (gl2, value) => gl2.clearStencil(value),
-    [GL.STENCIL_WRITEMASK]: (gl2, value) => gl2.stencilMaskSeparate(GL.FRONT, value),
-    [GL.STENCIL_BACK_WRITEMASK]: (gl2, value) => gl2.stencilMaskSeparate(GL.BACK, value),
+    [GL.STENCIL_CLEAR_VALUE]: (gl, value) => gl.clearStencil(value),
+    [GL.STENCIL_WRITEMASK]: (gl, value) => gl.stencilMaskSeparate(GL.FRONT, value),
+    [GL.STENCIL_BACK_WRITEMASK]: (gl, value) => gl.stencilMaskSeparate(GL.BACK, value),
     [GL.STENCIL_FUNC]: "stencilFuncFront",
     [GL.STENCIL_REF]: "stencilFuncFront",
     [GL.STENCIL_VALUE_MASK]: "stencilFuncFront",
@@ -3982,7 +4018,7 @@ var __exports__ = (() => {
     [GL.STENCIL_BACK_FAIL]: "stencilOpBack",
     [GL.STENCIL_BACK_PASS_DEPTH_FAIL]: "stencilOpBack",
     [GL.STENCIL_BACK_PASS_DEPTH_PASS]: "stencilOpBack",
-    [GL.VIEWPORT]: (gl2, value) => gl2.viewport(...value),
+    [GL.VIEWPORT]: (gl, value) => gl.viewport(...value),
     // WEBGL1 PIXEL PACK/UNPACK MODES
     [GL.PACK_ALIGNMENT]: pixelStorei,
     [GL.UNPACK_ALIGNMENT]: pixelStorei,
@@ -4000,75 +4036,75 @@ var __exports__ = (() => {
     [GL.UNPACK_SKIP_ROWS]: pixelStorei,
     [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(GL.FRAMEBUFFER, handle);
+      return gl.bindFramebuffer(GL.FRAMEBUFFER, handle);
     },
-    blend: (gl2, value) => value ? gl2.enable(GL.BLEND) : gl2.disable(GL.BLEND),
-    blendColor: (gl2, value) => gl2.blendColor(...value),
-    blendEquation: (gl2, args) => {
+    blend: (gl, value) => value ? gl.enable(GL.BLEND) : gl.disable(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?.length === 2 ? [...args, ...args] : args;
-      gl2.blendFuncSeparate(...separateFuncs);
-    },
-    clearColor: (gl2, value) => gl2.clearColor(...value),
-    clearDepth: (gl2, value) => gl2.clearDepth(value),
-    clearStencil: (gl2, value) => gl2.clearStencil(value),
-    colorMask: (gl2, value) => gl2.colorMask(...value),
-    cull: (gl2, value) => value ? gl2.enable(GL.CULL_FACE) : gl2.disable(GL.CULL_FACE),
-    cullFace: (gl2, value) => gl2.cullFace(value),
-    depthTest: (gl2, value) => value ? gl2.enable(GL.DEPTH_TEST) : gl2.disable(GL.DEPTH_TEST),
-    depthFunc: (gl2, value) => gl2.depthFunc(value),
-    depthMask: (gl2, value) => gl2.depthMask(value),
-    depthRange: (gl2, value) => gl2.depthRange(...value),
-    dither: (gl2, value) => value ? gl2.enable(GL.DITHER) : gl2.disable(GL.DITHER),
-    derivativeHint: (gl2, value) => {
-      gl2.hint(GL.FRAGMENT_SHADER_DERIVATIVE_HINT, value);
-    },
-    frontFace: (gl2, value) => gl2.frontFace(value),
-    mipmapHint: (gl2, value) => gl2.hint(GL.GENERATE_MIPMAP_HINT, value),
-    lineWidth: (gl2, value) => gl2.lineWidth(value),
-    polygonOffsetFill: (gl2, value) => value ? gl2.enable(GL.POLYGON_OFFSET_FILL) : gl2.disable(GL.POLYGON_OFFSET_FILL),
-    polygonOffset: (gl2, value) => gl2.polygonOffset(...value),
-    sampleCoverage: (gl2, value) => gl2.sampleCoverage(...value),
-    scissorTest: (gl2, value) => value ? gl2.enable(GL.SCISSOR_TEST) : gl2.disable(GL.SCISSOR_TEST),
-    scissor: (gl2, value) => gl2.scissor(...value),
-    stencilTest: (gl2, value) => value ? gl2.enable(GL.STENCIL_TEST) : gl2.disable(GL.STENCIL_TEST),
-    stencilMask: (gl2, value) => {
+      gl.blendFuncSeparate(...separateFuncs);
+    },
+    clearColor: (gl, value) => gl.clearColor(...value),
+    clearDepth: (gl, value) => gl.clearDepth(value),
+    clearStencil: (gl, value) => gl.clearStencil(value),
+    colorMask: (gl, value) => gl.colorMask(...value),
+    cull: (gl, value) => value ? gl.enable(GL.CULL_FACE) : gl.disable(GL.CULL_FACE),
+    cullFace: (gl, value) => gl.cullFace(value),
+    depthTest: (gl, value) => value ? gl.enable(GL.DEPTH_TEST) : gl.disable(GL.DEPTH_TEST),
+    depthFunc: (gl, value) => gl.depthFunc(value),
+    depthMask: (gl, value) => gl.depthMask(value),
+    depthRange: (gl, value) => gl.depthRange(...value),
+    dither: (gl, value) => value ? gl.enable(GL.DITHER) : gl.disable(GL.DITHER),
+    derivativeHint: (gl, value) => {
+      gl.hint(GL.FRAGMENT_SHADER_DERIVATIVE_HINT, value);
+    },
+    frontFace: (gl, value) => gl.frontFace(value),
+    mipmapHint: (gl, value) => gl.hint(GL.GENERATE_MIPMAP_HINT, value),
+    lineWidth: (gl, value) => gl.lineWidth(value),
+    polygonOffsetFill: (gl, value) => value ? gl.enable(GL.POLYGON_OFFSET_FILL) : gl.disable(GL.POLYGON_OFFSET_FILL),
+    polygonOffset: (gl, value) => gl.polygonOffset(...value),
+    sampleCoverage: (gl, value) => gl.sampleCoverage(...value),
+    scissorTest: (gl, value) => value ? gl.enable(GL.SCISSOR_TEST) : gl.disable(GL.SCISSOR_TEST),
+    scissor: (gl, value) => gl.scissor(...value),
+    stencilTest: (gl, value) => value ? gl.enable(GL.STENCIL_TEST) : gl.disable(GL.STENCIL_TEST),
+    stencilMask: (gl, value) => {
       value = isArray(value) ? value : [value, value];
       const [mask, backMask] = value;
-      gl2.stencilMaskSeparate(GL.FRONT, mask);
-      gl2.stencilMaskSeparate(GL.BACK, backMask);
+      gl.stencilMaskSeparate(GL.FRONT, mask);
+      gl.stencilMaskSeparate(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(GL.FRONT, func, ref, mask);
-      gl2.stencilFuncSeparate(GL.BACK, backFunc, backRef, backMask);
+      gl.stencilFuncSeparate(GL.FRONT, func, ref, mask);
+      gl.stencilFuncSeparate(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(GL.FRONT, sfail, dpfail, dppass);
-      gl2.stencilOpSeparate(GL.BACK, backSfail, backDpfail, backDppass);
+      gl.stencilOpSeparate(GL.FRONT, sfail, dpfail, dppass);
+      gl.stencilOpSeparate(GL.BACK, backSfail, backDpfail, backDppass);
     },
-    viewport: (gl2, value) => gl2.viewport(...value)
+    viewport: (gl, value) => gl.viewport(...value)
   };
   function getValue(glEnum, values, cache2) {
     return values[glEnum] !== void 0 ? values[glEnum] : cache2[glEnum];
   }
   var GL_COMPOSITE_PARAMETER_SETTERS = {
-    blendEquation: (gl2, values, cache2) => gl2.blendEquationSeparate(getValue(GL.BLEND_EQUATION_RGB, values, cache2), getValue(GL.BLEND_EQUATION_ALPHA, values, cache2)),
-    blendFunc: (gl2, values, cache2) => gl2.blendFuncSeparate(getValue(GL.BLEND_SRC_RGB, values, cache2), getValue(GL.BLEND_DST_RGB, values, cache2), getValue(GL.BLEND_SRC_ALPHA, values, cache2), getValue(GL.BLEND_DST_ALPHA, values, cache2)),
-    polygonOffset: (gl2, values, cache2) => gl2.polygonOffset(getValue(GL.POLYGON_OFFSET_FACTOR, values, cache2), getValue(GL.POLYGON_OFFSET_UNITS, values, cache2)),
-    sampleCoverage: (gl2, values, cache2) => gl2.sampleCoverage(getValue(GL.SAMPLE_COVERAGE_VALUE, values, cache2), getValue(GL.SAMPLE_COVERAGE_INVERT, values, cache2)),
-    stencilFuncFront: (gl2, values, cache2) => gl2.stencilFuncSeparate(GL.FRONT, getValue(GL.STENCIL_FUNC, values, cache2), getValue(GL.STENCIL_REF, values, cache2), getValue(GL.STENCIL_VALUE_MASK, values, cache2)),
-    stencilFuncBack: (gl2, values, cache2) => gl2.stencilFuncSeparate(GL.BACK, getValue(GL.STENCIL_BACK_FUNC, values, cache2), getValue(GL.STENCIL_BACK_REF, values, cache2), getValue(GL.STENCIL_BACK_VALUE_MASK, values, cache2)),
-    stencilOpFront: (gl2, values, cache2) => gl2.stencilOpSeparate(GL.FRONT, getValue(GL.STENCIL_FAIL, values, cache2), getValue(GL.STENCIL_PASS_DEPTH_FAIL, values, cache2), getValue(GL.STENCIL_PASS_DEPTH_PASS, values, cache2)),
-    stencilOpBack: (gl2, values, cache2) => gl2.stencilOpSeparate(GL.BACK, getValue(GL.STENCIL_BACK_FAIL, values, cache2), getValue(GL.STENCIL_BACK_PASS_DEPTH_FAIL, values, cache2), getValue(GL.STENCIL_BACK_PASS_DEPTH_PASS, values, cache2))
+    blendEquation: (gl, values, cache2) => gl.blendEquationSeparate(getValue(GL.BLEND_EQUATION_RGB, values, cache2), getValue(GL.BLEND_EQUATION_ALPHA, values, cache2)),
+    blendFunc: (gl, values, cache2) => gl.blendFuncSeparate(getValue(GL.BLEND_SRC_RGB, values, cache2), getValue(GL.BLEND_DST_RGB, values, cache2), getValue(GL.BLEND_SRC_ALPHA, values, cache2), getValue(GL.BLEND_DST_ALPHA, values, cache2)),
+    polygonOffset: (gl, values, cache2) => gl.polygonOffset(getValue(GL.POLYGON_OFFSET_FACTOR, values, cache2), getValue(GL.POLYGON_OFFSET_UNITS, values, cache2)),
+    sampleCoverage: (gl, values, cache2) => gl.sampleCoverage(getValue(GL.SAMPLE_COVERAGE_VALUE, values, cache2), getValue(GL.SAMPLE_COVERAGE_INVERT, values, cache2)),
+    stencilFuncFront: (gl, values, cache2) => gl.stencilFuncSeparate(GL.FRONT, getValue(GL.STENCIL_FUNC, values, cache2), getValue(GL.STENCIL_REF, values, cache2), getValue(GL.STENCIL_VALUE_MASK, values, cache2)),
+    stencilFuncBack: (gl, values, cache2) => gl.stencilFuncSeparate(GL.BACK, getValue(GL.STENCIL_BACK_FUNC, values, cache2), getValue(GL.STENCIL_BACK_REF, values, cache2), getValue(GL.STENCIL_BACK_VALUE_MASK, values, cache2)),
+    stencilOpFront: (gl, values, cache2) => gl.stencilOpSeparate(GL.FRONT, getValue(GL.STENCIL_FAIL, values, cache2), getValue(GL.STENCIL_PASS_DEPTH_FAIL, values, cache2), getValue(GL.STENCIL_PASS_DEPTH_PASS, values, cache2)),
+    stencilOpBack: (gl, values, cache2) => gl.stencilOpSeparate(GL.BACK, getValue(GL.STENCIL_BACK_FAIL, values, cache2), getValue(GL.STENCIL_BACK_PASS_DEPTH_FAIL, values, cache2), getValue(GL.STENCIL_BACK_PASS_DEPTH_PASS, values, cache2))
   };
   var GL_HOOKED_SETTERS = {
     // GENERIC SETTERS
@@ -4234,7 +4270,7 @@ var __exports__ = (() => {
       [GL.VIEWPORT]: [x, y, width, height]
     })
   };
-  var isEnabled = (gl2, key) => gl2.isEnabled(key);
+  var isEnabled = (gl, key) => gl.isEnabled(key);
   var GL_PARAMETER_GETTERS = {
     [GL.BLEND]: isEnabled,
     [GL.CULL_FACE]: isEnabled,
@@ -4288,9 +4324,9 @@ var __exports__ = (() => {
   ]);
 
   // 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 (isObjectEmpty2(parameters)) {
       return;
     }
@@ -4302,36 +4338,36 @@ var __exports__ = (() => {
         if (typeof setter === "string") {
           compositeSetters[setter] = true;
         } else {
-          setter(gl2, parameters[key], glConstant);
+          setter(gl, parameters[key], glConstant);
         }
       }
     }
-    const cache2 = gl2.state && gl2.state.cache;
+    const cache2 = gl.state && gl.state.cache;
     if (cache2) {
       for (const key in compositeSetters) {
         const compositeSetter = GL_COMPOSITE_PARAMETER_SETTERS[key];
-        compositeSetter(gl2, parameters, cache2);
+        compositeSetter(gl, parameters, cache2);
       }
     }
   }
-  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 isObjectEmpty2(object) {
     for (const key in object) {
@@ -4363,15 +4399,15 @@ var __exports__ = (() => {
     program = null;
     stateStack = [];
     enable = true;
-    constructor(gl2, {
+    constructor(gl, {
       copyState = false,
       // Copy cache from params (slow) or initialize from WebGL defaults (fast)
       log: log3 = () => {
       }
       // Logging function, called when gl parameter change calls are actually issued
     } = {}) {
-      this.gl = 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 = log3;
       this._updateCache = this._updateCache.bind(this);
       Object.seal(this);
@@ -4382,7 +4418,7 @@ var __exports__ = (() => {
     pop() {
       assert2(this.stateStack.length > 0);
       const oldValues = this.stateStack[this.stateStack.length - 1];
-      setParameters(this.gl, oldValues);
+      setGLParameters(this.gl, oldValues);
       this.stateStack.pop();
     }
     /**
@@ -4414,53 +4450,53 @@ var __exports__ = (() => {
       };
     }
   };
-  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;
     assert2(copyState !== void 0);
-    if (!gl2.state) {
-      gl2.state = new GLState(gl2, {
+    if (!gl.state) {
+      gl.state = new GLState(gl, {
         copyState
       });
-      installProgramSpy(gl2);
+      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, {
+      trackContextState(gl, {
         copyState: false
       });
-      glState = getContextState(gl2);
+      glState = getContextState(gl);
     }
     glState.push();
   }
-  function popContextState(gl2) {
-    const glState = getContextState(gl2);
+  function popContextState(gl) {
+    const glState = getContextState(gl);
     assert2(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);
       }
@@ -4472,18 +4508,18 @@ var __exports__ = (() => {
         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
@@ -4493,15 +4529,15 @@ var __exports__ = (() => {
       }
       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;
@@ -4530,7 +4566,7 @@ var __exports__ = (() => {
     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 = {
         ...props,
@@ -4543,14 +4579,14 @@ var __exports__ = (() => {
         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"}`);
     }
     if (props.onContextLost) {
@@ -4565,28 +4601,28 @@ var __exports__ = (() => {
       } = props;
       canvas.addEventListener("webglcontextrestored", (event) => onContextRestored(event), false);
     }
-    return gl2;
+    return gl;
   }
 
   // src/adapter/device-helpers/get-device-info.ts
-  function getDeviceInfo(gl2) {
-    const vendorMasked = gl2.getParameter(GL.VENDOR);
-    const rendererMasked = gl2.getParameter(GL.RENDERER);
-    const ext = gl2.getExtension("WEBGL_debug_renderer_info");
-    const vendorUnmasked = gl2.getParameter(ext ? ext.UNMASKED_VENDOR_WEBGL : GL.VENDOR);
-    const rendererUnmasked = gl2.getParameter(ext ? ext.UNMASKED_RENDERER_WEBGL : GL.RENDERER);
+  function getDeviceInfo(gl) {
+    const vendorMasked = gl.getParameter(GL.VENDOR);
+    const rendererMasked = gl.getParameter(GL.RENDERER);
+    const ext = gl.getExtension("WEBGL_debug_renderer_info");
+    const vendorUnmasked = gl.getParameter(ext ? ext.UNMASKED_VENDOR_WEBGL : GL.VENDOR);
+    const rendererUnmasked = gl.getParameter(ext ? ext.UNMASKED_RENDERER_WEBGL : GL.RENDERER);
     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(GL.VERSION),
+      version: gl.getParameter(GL.VERSION),
       shadingLanguages: ["glsl"],
       shadingLanguageVersions: {
-        "glsl": gl2.getParameter(GL.SHADING_LANGUAGE_VERSION)
+        "glsl": gl.getParameter(GL.SHADING_LANGUAGE_VERSION)
       }
     };
   }
@@ -4669,38 +4705,38 @@ var __exports__ = (() => {
   var EXT_TEXTURE_NORM16 = "EXT_texture_norm16";
   var EXT_FLOAT_WEBGL1 = "WEBGL_color_buffer_float";
   var EXT_FLOAT_RENDER_WEBGL2 = "EXT_color_buffer_float";
-  var checkExtension = (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) {
-    return TEXTURE_FEATURE_CHECKS[feature]?.(gl2) || false;
+  function checkTextureFeature(gl, feature) {
+    return TEXTURE_FEATURE_CHECKS[feature]?.(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.
@@ -5440,23 +5476,23 @@ var __exports__ = (() => {
     [GL.BYTE]: 1,
     [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) {
-    return isTextureFormatSupported(gl2, format) && TEXTURE_FORMATS[format]?.renderbuffer;
+  function isRenderbufferFormatSupported(gl, format) {
+    return isTextureFormatSupported(gl, format) && TEXTURE_FORMATS[format]?.renderbuffer;
   }
   function convertGLToTextureFormat(format) {
     if (typeof format === "string") {
@@ -5476,9 +5512,9 @@ var __exports__ = (() => {
     }
     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 {
@@ -5490,16 +5526,16 @@ var __exports__ = (() => {
       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") {
@@ -5527,27 +5563,27 @@ var __exports__ = (() => {
     }
     return info.attachment;
   }
-  function _checkFloat32ColorAttachment(gl2, internalFormat = gl2.RGBA, srcFormat = GL.RGBA, srcType = GL.UNSIGNED_BYTE) {
+  function _checkFloat32ColorAttachment(gl, internalFormat = gl.RGBA, srcFormat = GL.RGBA, srcType = GL.UNSIGNED_BYTE) {
     let texture = null;
     let framebuffer = null;
     try {
-      texture = gl2.createTexture();
-      gl2.bindTexture(GL.TEXTURE_2D, texture);
+      texture = gl.createTexture();
+      gl.bindTexture(GL.TEXTURE_2D, texture);
       const level = 0;
       const width = 1;
       const height = 1;
       const border = 0;
       const pixel = new Uint8Array([0, 0, 255, 255]);
-      gl2.texImage2D(gl2.TEXTURE_2D, level, internalFormat, width, height, border, srcFormat, srcType, pixel);
-      framebuffer = gl2.createFramebuffer();
-      gl2.bindFramebuffer(GL.FRAMEBUFFER, framebuffer);
-      gl2.framebufferTexture2D(GL.FRAMEBUFFER, GL.COLOR_ATTACHMENT0, GL.TEXTURE_2D, texture, 0);
-      const status = gl2.checkFramebufferStatus(GL.FRAMEBUFFER) === GL.FRAMEBUFFER_COMPLETE;
-      gl2.bindTexture(GL.TEXTURE_2D, null);
+      gl.texImage2D(gl.TEXTURE_2D, level, internalFormat, width, height, border, srcFormat, srcType, pixel);
+      framebuffer = gl.createFramebuffer();
+      gl.bindFramebuffer(GL.FRAMEBUFFER, framebuffer);
+      gl.framebufferTexture2D(GL.FRAMEBUFFER, GL.COLOR_ATTACHMENT0, GL.TEXTURE_2D, texture, 0);
+      const status = gl.checkFramebufferStatus(GL.FRAMEBUFFER) === GL.FRAMEBUFFER_COMPLETE;
+      gl.bindTexture(GL.TEXTURE_2D, null);
       return status;
     } finally {
-      gl2.deleteTexture(texture);
-      gl2.deleteFramebuffer(framebuffer);
+      gl.deleteTexture(texture);
+      gl.deleteFramebuffer(framebuffer);
     }
   }
   function getTextureFormatBytesPerPixel(formatOrGL, isWebGL23) {
@@ -5576,52 +5612,52 @@ var __exports__ = (() => {
   }
 
   // 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, {
+        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;
     }
@@ -5631,14 +5667,14 @@ var __exports__ = (() => {
     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;
   }
@@ -5675,38 +5711,38 @@ void main(void) {}`;
   };
 
   // src/adapter/device-helpers/device-limits.ts
-  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(GL.MAX_TEXTURE_SIZE),
-      maxTextureDimension3D: gl22 ? gl22.getParameter(GL.MAX_3D_TEXTURE_SIZE) : 0,
-      maxTextureArrayLayers: gl22 ? gl22.getParameter(GL.MAX_ARRAY_TEXTURE_LAYERS) : 0,
+      maxTextureDimension2D: gl.getParameter(GL.MAX_TEXTURE_SIZE),
+      maxTextureDimension3D: gl2 ? gl2.getParameter(GL.MAX_3D_TEXTURE_SIZE) : 0,
+      maxTextureArrayLayers: gl2 ? gl2.getParameter(GL.MAX_ARRAY_TEXTURE_LAYERS) : 0,
       maxBindGroups: 1,
       // TBD
       maxDynamicUniformBuffersPerPipelineLayout: 0,
       // TBD
       maxDynamicStorageBuffersPerPipelineLayout: 0,
       // TBD
-      maxSampledTexturesPerShaderStage: gl2.getParameter(GL.MAX_VERTEX_TEXTURE_IMAGE_UNITS),
+      maxSampledTexturesPerShaderStage: gl.getParameter(GL.MAX_VERTEX_TEXTURE_IMAGE_UNITS),
       // TBD
-      maxSamplersPerShaderStage: gl2.getParameter(GL.MAX_COMBINED_TEXTURE_IMAGE_UNITS),
+      maxSamplersPerShaderStage: gl.getParameter(GL.MAX_COMBINED_TEXTURE_IMAGE_UNITS),
       maxStorageBuffersPerShaderStage: 0,
       // TBD
       maxStorageTexturesPerShaderStage: 0,
       // TBD
-      maxUniformBuffersPerShaderStage: gl22 ? gl22.getParameter(GL.MAX_UNIFORM_BUFFER_BINDINGS) : 0,
-      maxUniformBufferBindingSize: gl22 ? gl22.getParameter(GL.MAX_UNIFORM_BLOCK_SIZE) : 0,
+      maxUniformBuffersPerShaderStage: gl2 ? gl2.getParameter(GL.MAX_UNIFORM_BUFFER_BINDINGS) : 0,
+      maxUniformBufferBindingSize: gl2 ? gl2.getParameter(GL.MAX_UNIFORM_BLOCK_SIZE) : 0,
       maxStorageBufferBindingSize: 0,
-      minUniformBufferOffsetAlignment: gl22 ? gl22.getParameter(GL.UNIFORM_BUFFER_OFFSET_ALIGNMENT) : 0,
+      minUniformBufferOffsetAlignment: gl2 ? gl2.getParameter(GL.UNIFORM_BUFFER_OFFSET_ALIGNMENT) : 0,
       minStorageBufferOffsetAlignment: 0,
       // TBD
       maxVertexBuffers: 0,
-      maxVertexAttributes: gl2.getParameter(GL.MAX_VERTEX_ATTRIBS),
+      maxVertexAttributes: gl.getParameter(GL.MAX_VERTEX_ATTRIBS),
       maxVertexBufferArrayStride: 2048,
       // TBD, this is just the default value from WebGPU
-      maxInterStageShaderComponents: gl22 ? gl22.getParameter(GL.MAX_VARYING_COMPONENTS) : 0,
+      maxInterStageShaderComponents: gl2 ? gl2.getParameter(GL.MAX_VARYING_COMPONENTS) : 0,
       maxComputeWorkgroupStorageSize: 0,
       // WebGL does not support compute shaders
       maxComputeInvocationsPerWorkgroup: 0,
@@ -5721,13 +5757,13 @@ void main(void) {}`;
       // 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 {
       [GL.ALIASED_LINE_WIDTH_RANGE]: get(GL.ALIASED_LINE_WIDTH_RANGE),
@@ -5818,26 +5854,26 @@ void main(void) {}`;
   }
 
   // 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 (isObjectEmpty3(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;
@@ -5850,13 +5886,14 @@ void main(void) {}`;
   }
 
   // src/adapter/converters/device-parameters.ts
-  function withGLParameters(device, parameters, func) {
+  function withDeviceAndGLParameters(device, parameters, glParameters, func) {
     if (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);
@@ -5877,43 +5914,43 @@ void main(void) {}`;
   function setDeviceParameters(device, parameters) {
     const webglDevice = WebGLDevice.attach(device);
     const {
-      gl: gl2
+      gl
     } = webglDevice;
     if (parameters.cullMode) {
       switch (parameters.cullMode) {
         case "none":
-          gl2.disable(GL.CULL_FACE);
+          gl.disable(GL.CULL_FACE);
           break;
         case "front":
-          gl2.enable(GL.CULL_FACE);
-          gl2.cullFace(GL.FRONT);
+          gl.enable(GL.CULL_FACE);
+          gl.cullFace(GL.FRONT);
           break;
         case "back":
-          gl2.enable(GL.CULL_FACE);
-          gl2.cullFace(GL.BACK);
+          gl.enable(GL.CULL_FACE);
+          gl.cullFace(GL.BACK);
           break;
       }
     }
     if (parameters.frontFace) {
-      gl2.frontFace(map("frontFace", parameters.frontFace, {
+      gl.frontFace(map("frontFace", parameters.frontFace, {
         ccw: GL.CCW,
         cw: GL.CW
       }));
     }
     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(GL.DEPTH_TEST) : gl2.disable(GL.DEPTH_TEST);
-      gl2.depthFunc(convertCompareFunction("depthCompare", parameters.depthCompare));
+      parameters.depthCompare !== "always" ? gl.enable(GL.DEPTH_TEST) : gl.disable(GL.DEPTH_TEST);
+      gl.depthFunc(convertCompareFunction("depthCompare", parameters.depthCompare));
     }
     if (parameters.stencilWriteMask) {
       const mask = parameters.stencilWriteMask;
-      gl2.stencilMaskSeparate(GL.FRONT, mask);
-      gl2.stencilMaskSeparate(GL.BACK, mask);
+      gl.stencilMaskSeparate(GL.FRONT, mask);
+      gl.stencilMaskSeparate(GL.BACK, mask);
     }
     if (parameters.stencilReadMask) {
       log.warn("stencilReadMask not supported under WebGL");
@@ -5921,16 +5958,16 @@ void main(void) {}`;
     if (parameters.stencilCompare) {
       const mask = parameters.stencilReadMask || 4294967295;
       const glValue = convertCompareFunction("depthCompare", parameters.stencilCompare);
-      parameters.stencilCompare !== "always" ? gl2.enable(GL.STENCIL_TEST) : gl2.disable(GL.STENCIL_TEST);
-      gl2.stencilFuncSeparate(GL.FRONT, glValue, 0, mask);
-      gl2.stencilFuncSeparate(GL.BACK, glValue, 0, mask);
+      parameters.stencilCompare !== "always" ? gl.enable(GL.STENCIL_TEST) : gl.disable(GL.STENCIL_TEST);
+      gl.stencilFuncSeparate(GL.FRONT, glValue, 0, mask);
+      gl.stencilFuncSeparate(GL.BACK, glValue, 0, mask);
     }
     if (parameters.stencilPassOperation && parameters.stencilFailOperation && parameters.stencilDepthFailOperation) {
       const dppass = convertStencilOperation("stencilPassOperation", parameters.stencilPassOperation);
       const sfail = convertStencilOperation("stencilFailOperation", parameters.stencilFailOperation);
       const dpfail = convertStencilOperation("stencilDepthFailOperation", parameters.stencilDepthFailOperation);
-      gl2.stencilOpSeparate(GL.FRONT, sfail, dpfail, dppass);
-      gl2.stencilOpSeparate(GL.BACK, sfail, dpfail, dppass);
+      gl.stencilOpSeparate(GL.FRONT, sfail, dpfail, dppass);
+      gl.stencilOpSeparate(GL.BACK, sfail, dpfail, dppass);
     }
   }
   function convertCompareFunction(parameter, value) {
@@ -6463,7 +6500,7 @@ void main(void) {}`;
       }
       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);
@@ -6530,9 +6567,9 @@ void main(void) {}`;
         height
       }));
       const {
-        gl: gl2
+        gl
       } = this;
-      gl2.bindTexture(this.target, this.handle);
+      gl.bindTexture(this.target, this.handle);
       let dataType = null;
       ({
         data,
@@ -6541,14 +6578,14 @@ void main(void) {}`;
         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,
@@ -6564,21 +6601,21 @@ void main(void) {}`;
             );
             break;
           case "buffer":
-            gl22 = this.device.assertWebGL2();
-            gl22.bindBuffer(GL.PIXEL_UNPACK_BUFFER, data.handle || data);
-            gl22.texImage2D(target, level, glFormat, width, height, 0, dataFormat, type, offset);
-            gl22.bindBuffer(GL.PIXEL_UNPACK_BUFFER, null);
+            gl2 = this.device.assertWebGL2();
+            gl2.bindBuffer(GL.PIXEL_UNPACK_BUFFER, data.handle || data);
+            gl2.texImage2D(target, level, glFormat, width, height, 0, dataFormat, type, offset);
+            gl2.bindBuffer(GL.PIXEL_UNPACK_BUFFER, null);
             break;
           case "browser-object":
             if (this.device.isWebGL2) {
-              gl2.texImage2D(target, level, glFormat, width, height, 0, dataFormat, type, data);
+              gl.texImage2D(target, level, glFormat, width, height, 0, dataFormat, type, 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(target, levelIndex, levelData.format, levelData.width, levelData.height, 0, levelData.data);
+              gl.compressedTexImage2D(target, levelIndex, levelData.format, levelData.width, levelData.height, 0, levelData.data);
             }
             break;
           default:
@@ -6644,7 +6681,7 @@ void main(void) {}`;
         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) {
@@ -6682,24 +6719,24 @@ void main(void) {}`;
     }
     bind(textureUnit = this.textureUnit) {
       const {
-        gl: gl2
+        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
+        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
@@ -6821,7 +6858,7 @@ void main(void) {}`;
     /* eslint-disable max-statements, max-len */
     async setCubeMapImageData(options) {
       const {
-        gl: gl2
+        gl
       } = this;
       const {
         width,
@@ -6843,9 +6880,9 @@ void main(void) {}`;
         }
         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);
           }
         });
       });
@@ -6864,7 +6901,7 @@ void main(void) {}`;
         // generateMipmap = false // TODO
       } = options;
       const {
-        gl: gl2
+        gl
       } = this;
       const imageData = pixels || data;
       this.bind();
@@ -6875,9 +6912,9 @@ void main(void) {}`;
           pixels: resolvedImageData
         })));
       } 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;
     }
@@ -6899,7 +6936,7 @@ void main(void) {}`;
       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,
@@ -7009,7 +7046,7 @@ void main(void) {}`;
   }
 
   // src/adapter/objects/constants-to-keys.ts
-  function getKeyValue(gl2, name2) {
+  function getKeyValue(gl, name2) {
     if (typeof name2 !== "string") {
       return name2;
     }
@@ -7018,7 +7055,7 @@ void main(void) {}`;
       return number;
     }
     name2 = name2.replace(/^.*\./, "");
-    const value = gl2[name2];
+    const value = gl[name2];
     assert2(value !== void 0, `Accessing undefined constant GL.${name2}`);
     return value;
   }
@@ -7032,13 +7069,13 @@ void main(void) {}`;
     constructor(device, props, defaultProps) {
       super(device, props, defaultProps);
       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 || uid(this.constructor.name);
       this._handle = props?.handle;
       if (this._handle === void 0) {
@@ -7356,12 +7393,12 @@ void main(void) {}`;
     /** Check the status */
     _checkStatus() {
       const {
-        gl: gl2
+        gl
       } = this;
-      const prevHandle2 = gl2.bindFramebuffer(GL.FRAMEBUFFER, this.handle);
-      const status = gl2.checkFramebufferStatus(GL.FRAMEBUFFER);
-      gl2.bindFramebuffer(GL.FRAMEBUFFER, prevHandle2 || null);
-      if (status !== gl2.FRAMEBUFFER_COMPLETE) {
+      const prevHandle = gl.bindFramebuffer(GL.FRAMEBUFFER, this.handle);
+      const status = gl.checkFramebufferStatus(GL.FRAMEBUFFER);
+      gl.bindFramebuffer(GL.FRAMEBUFFER, prevHandle || null);
+      if (status !== gl.FRAMEBUFFER_COMPLETE) {
         throw new Error(`Framebuffer ${_getFrameBufferStatus(status)}`);
       }
     }
@@ -7432,27 +7469,27 @@ void main(void) {}`;
      */
     _attachTexture(attachment, texture, layer, level) {
       const {
-        gl: gl2,
-        gl2: gl22
+        gl,
+        gl2
       } = this.device;
-      gl2.bindTexture(texture.target, texture.handle);
+      gl.bindTexture(texture.target, texture.handle);
       switch (texture.target) {
         case GL.TEXTURE_2D_ARRAY:
         case GL.TEXTURE_3D:
           this.device.assertWebGL2();
-          gl22?.framebufferTextureLayer(GL.FRAMEBUFFER, attachment, texture.target, level, layer);
+          gl2?.framebufferTextureLayer(GL.FRAMEBUFFER, attachment, texture.target, level, layer);
           break;
         case GL.TEXTURE_CUBE_MAP:
           const face = mapIndexToCubeMapFace(layer);
-          gl2.framebufferTexture2D(GL.FRAMEBUFFER, attachment, face, texture.handle, level);
+          gl.framebufferTexture2D(GL.FRAMEBUFFER, attachment, face, texture.handle, level);
           break;
         case GL.TEXTURE_2D:
-          gl2.framebufferTexture2D(GL.FRAMEBUFFER, attachment, GL.TEXTURE_2D, texture.handle, level);
+          gl.framebufferTexture2D(GL.FRAMEBUFFER, attachment, GL.TEXTURE_2D, texture.handle, level);
           break;
         default:
           assert2(false, "Illegal texture type");
       }
-      gl2.bindTexture(texture.target, null);
+      gl.bindTexture(texture.target, null);
     }
   };
   function mapIndexToCubeMapFace(layer) {
@@ -7590,9 +7627,9 @@ void main(void) {}`;
 
   // src/context/debug/webgl-developer-tools.ts
   var WEBGL_DEBUG_CDN_URL = "https://unpkg.com/webgl-debug@2.0.1/index.js";
-  function getContextData2(gl2) {
-    gl2.luma = gl2.luma || {};
-    return gl2.luma;
+  function getContextData2(gl) {
+    gl.luma = gl.luma || {};
+    return gl.luma;
   }
   async function loadWebGLDeveloperTools() {
     if (isBrowser() && !globalThis.WebGLDebugUtils) {
@@ -7601,30 +7638,30 @@ void main(void) {}`;
       await loadScript(WEBGL_DEBUG_CDN_URL);
     }
   }
-  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) {
       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({
       ...GL,
-      ...gl2
+      ...gl
     });
-    const glDebug = globalThis.WebGLDebugUtils.makeDebugContext(gl2, onGLError.bind(null, props), onValidateGLFunc.bind(null, props));
+    const glDebug = globalThis.WebGLDebugUtils.makeDebugContext(gl, onGLError.bind(null, props), onValidateGLFunc.bind(null, props));
     for (const key in GL) {
       if (!(key in glDebug) && typeof GL[key] === "number") {
         glDebug[key] = GL[key];
@@ -7632,10 +7669,10 @@ void main(void) {}`;
     }
     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;
@@ -8019,15 +8056,15 @@ void main(void) {}`;
         size
       } = options;
       const {
-        gl: gl2,
-        gl2: gl22
+        gl,
+        gl2
       } = this;
-      assertWebGL2Context(gl2);
-      gl2.bindBuffer(GL.COPY_READ_BUFFER, sourceBuffer.handle);
-      gl2.bindBuffer(GL.COPY_WRITE_BUFFER, this.handle);
-      gl22?.copyBufferSubData(GL.COPY_READ_BUFFER, GL.COPY_WRITE_BUFFER, readOffset, writeOffset, size);
-      gl2.bindBuffer(GL.COPY_READ_BUFFER, null);
-      gl2.bindBuffer(GL.COPY_WRITE_BUFFER, null);
+      assertWebGL2Context(gl);
+      gl.bindBuffer(GL.COPY_READ_BUFFER, sourceBuffer.handle);
+      gl.bindBuffer(GL.COPY_WRITE_BUFFER, this.handle);
+      gl2?.copyBufferSubData(GL.COPY_READ_BUFFER, GL.COPY_WRITE_BUFFER, readOffset, writeOffset, size);
+      gl.bindBuffer(GL.COPY_READ_BUFFER, null);
+      gl.bindBuffer(GL.COPY_WRITE_BUFFER, null);
       this.debugData = null;
       return this;
     }
@@ -8297,16 +8334,18 @@ void main(void) {}`;
 ${source2}`;
       source = addGLSLVersion(source);
       const {
-        gl: gl2
+        gl
       } = this.device;
-      gl2.shaderSource(this.handle, source);
-      gl2.compileShader(this.handle);
-      const compileStatus = gl2.getShaderParameter(this.handle, GL.COMPILE_STATUS);
+      gl.shaderSource(this.handle, source);
+      gl.compileShader(this.handle);
+      const compileStatus = gl.getShaderParameter(this.handle, 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 = formatCompilerLog(messages, source);
+        const formattedLog = formatCompilerLog(messages, source, {
+          showSourceCode: true
+        });
         const shaderName = getShaderInfo(source).name;
         const shaderDescription = `${this.stage} shader ${shaderName}`;
         log.error(`GLSL compilation errors in ${shaderDescription}
@@ -8377,6 +8416,7 @@ ${formattedLog}`)();
         parameters[GL.STENCIL_REF] = parameters.stencilReference;
       }
       this.glParameters = glParameters;
+      setGLParameters(this.device, glParameters);
     }
     // Internal
     /**
@@ -8400,7 +8440,7 @@ ${formattedLog}`)();
         glParameters.clearStencil = this.props.clearStencil;
       }
       if (clearMask !== 0) {
-        withParameters(this.device, glParameters, () => {
+        withGLParameters(this.device, glParameters, () => {
           this.device.gl.clear(clearMask);
         });
       }
@@ -8409,7 +8449,7 @@ ${formattedLog}`)();
      * WebGL2 - clear a specific color buffer 
      */
     clearColorBuffer(drawBuffer = 0, value = [0, 0, 0, 0]) {
-      withParameters(this.device.gl2, {
+      withGLParameters(this.device.gl2, {
         framebuffer: this.props.framebuffer
       }, () => {
         switch (value.constructor) {
@@ -8515,13 +8555,13 @@ ${formattedLog}`)();
   }
 
   // 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,
@@ -8539,7 +8579,7 @@ ${formattedLog}`)();
         uniforms: uniforms2
       });
     }
-    const uniforms = readUniformBindings(gl2, program);
+    const uniforms = readUniformBindings(gl, program);
     let textureUnit = 0;
     for (const uniform of uniforms) {
       if (isSamplerUniform(uniform.type)) {
@@ -8561,17 +8601,17 @@ ${formattedLog}`)();
     if (uniforms.length) {
       shaderLayout.uniforms = uniforms;
     }
-    const varyings = readVaryings(gl2, program);
+    const varyings = readVaryings(gl, program);
     if (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");
       }
@@ -8580,7 +8620,7 @@ ${formattedLog}`)();
         type: compositeType
         /* , size*/
       } = activeInfo;
-      const location = gl2.getAttribLocation(program, name2);
+      const location = gl.getAttribLocation(program, name2);
       if (location >= 0) {
         const {
           attributeType
@@ -8598,15 +8638,15 @@ ${formattedLog}`)();
     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, GL.TRANSFORM_FEEDBACK_VARYINGS);
+    const count = gl.getProgramParameter(program, 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");
       }
@@ -8633,11 +8673,11 @@ ${formattedLog}`)();
     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, GL.ACTIVE_UNIFORMS);
+    const uniformCount = gl.getProgramParameter(program, 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");
       }
@@ -8650,7 +8690,7 @@ ${formattedLog}`)();
         name: name2,
         isArray: isArray2
       } = parseUniformName(rawName);
-      let webglLocation = gl2.getUniformLocation(program, name2);
+      let webglLocation = gl.getUniformLocation(program, name2);
       const uniformInfo = {
         // WebGL locations are uniquely typed but just numbers
         location: webglLocation,
@@ -8663,7 +8703,7 @@ ${formattedLog}`)();
       if (uniformInfo.size > 1) {
         for (let j = 0; j < uniformInfo.size; j++) {
           const elementName = `${name2}[${j}]`;
-          webglLocation = gl2.getUniformLocation(program, elementName);
+          webglLocation = gl.getUniformLocation(program, elementName);
           const arrayElementUniformInfo = {
             ...uniformInfo,
             name: elementName,
@@ -8675,17 +8715,17 @@ ${formattedLog}`)();
     }
     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, GL.ACTIVE_UNIFORM_BLOCKS);
+    const blockCount = gl2.getProgramParameter(program, 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, GL.UNIFORM_BLOCK_BINDING),
         byteLength: getBlockParameter(blockIndex, GL.UNIFORM_BLOCK_DATA_SIZE),
         vertex: getBlockParameter(blockIndex, GL.UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER),
@@ -8694,12 +8734,12 @@ ${formattedLog}`)();
         uniforms: []
       };
       const uniformIndices = getBlockParameter(blockIndex, GL.UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES) || [];
-      const uniformType = gl22.getActiveUniforms(program, uniformIndices, GL.UNIFORM_TYPE);
-      const uniformArrayLength = gl22.getActiveUniforms(program, uniformIndices, GL.UNIFORM_SIZE);
-      const uniformOffset = gl22.getActiveUniforms(program, uniformIndices, GL.UNIFORM_OFFSET);
-      const uniformStride = gl22.getActiveUniforms(program, uniformIndices, GL.UNIFORM_ARRAY_STRIDE);
+      const uniformType = gl2.getActiveUniforms(program, uniformIndices, GL.UNIFORM_TYPE);
+      const uniformArrayLength = gl2.getActiveUniforms(program, uniformIndices, GL.UNIFORM_SIZE);
+      const uniformOffset = gl2.getActiveUniforms(program, uniformIndices, GL.UNIFORM_OFFSET);
+      const uniformStride = gl2.getActiveUniforms(program, uniformIndices, GL.UNIFORM_ARRAY_STRIDE);
       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");
         }
@@ -8768,8 +8808,8 @@ ${formattedLog}`)();
   }
 
   // src/adapter/helpers/set-uniform.ts
-  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;
@@ -8795,251 +8835,61 @@ ${formattedLog}`)();
       case GL.UNSIGNED_INT_SAMPLER_CUBE:
       case GL.UNSIGNED_INT_SAMPLER_2D_ARRAY:
         if (typeof value !== "number") {
-          throw new Error("samplers must be set to integers");
-        }
-        return gl2.uniform1i(location, value);
-      case GL.FLOAT:
-        return gl2.uniform1fv(location, arrayValue);
-      case GL.FLOAT_VEC2:
-        return gl2.uniform2fv(location, arrayValue);
-      case GL.FLOAT_VEC3:
-        return gl2.uniform3fv(location, arrayValue);
-      case GL.FLOAT_VEC4:
-        return gl2.uniform4fv(location, arrayValue);
-      case GL.INT:
-        return gl2.uniform1iv(location, arrayValue);
-      case GL.INT_VEC2:
-        return gl2.uniform2iv(location, arrayValue);
-      case GL.INT_VEC3:
-        return gl2.uniform3iv(location, arrayValue);
-      case GL.INT_VEC4:
-        return gl2.uniform4iv(location, arrayValue);
-      case GL.BOOL:
-        return gl2.uniform1iv(location, arrayValue);
-      case GL.BOOL_VEC2:
-        return gl2.uniform2iv(location, arrayValue);
-      case GL.BOOL_VEC3:
-        return gl2.uniform3iv(location, arrayValue);
-      case GL.BOOL_VEC4:
-        return gl2.uniform4iv(location, arrayValue);
-      case GL.UNSIGNED_INT:
-        return gl22.uniform1uiv(location, arrayValue, 1);
-      case GL.UNSIGNED_INT_VEC2:
-        return gl22.uniform2uiv(location, arrayValue, 2);
-      case GL.UNSIGNED_INT_VEC3:
-        return gl22.uniform3uiv(location, arrayValue, 3);
-      case GL.UNSIGNED_INT_VEC4:
-        return gl22.uniform4uiv(location, arrayValue, 4);
-      case GL.FLOAT_MAT2:
-        return gl2.uniformMatrix2fv(location, false, arrayValue);
-      case GL.FLOAT_MAT3:
-        return gl2.uniformMatrix3fv(location, false, arrayValue);
-      case GL.FLOAT_MAT4:
-        return gl2.uniformMatrix4fv(location, false, arrayValue);
-      case GL.FLOAT_MAT2x3:
-        return gl22.uniformMatrix2x3fv(location, false, arrayValue);
-      case GL.FLOAT_MAT2x4:
-        return gl22.uniformMatrix2x4fv(location, false, arrayValue);
-      case GL.FLOAT_MAT3x2:
-        return gl22.uniformMatrix3x2fv(location, false, arrayValue);
-      case GL.FLOAT_MAT3x4:
-        return gl22.uniformMatrix3x4fv(location, false, arrayValue);
-      case GL.FLOAT_MAT4x2:
-        return gl22.uniformMatrix4x2fv(location, false, arrayValue);
-      case GL.FLOAT_MAT4x3:
-        return gl22.uniformMatrix4x3fv(location, false, arrayValue);
-    }
-    throw new Error("Illegal uniform");
-  }
-
-  // src/adapter/objects/webgl-vertex-array-object.ts
-  var ERR_ELEMENTS = "elements must be GL.ELEMENT_ARRAY_BUFFER";
-  var WEBGLVertexArrayObject = class extends WebGLResource {
-    get [Symbol.toStringTag]() {
-      return "BaseVertexArrayObject";
-    }
-    /** Buffer constant */
-    buffer = null;
-    bufferValue = null;
-    static isConstantAttributeZeroSupported(device) {
-      return device.info.type === "webgl2" || getBrowser() === "Chrome";
-    }
-    // Create a VertexArray
-    constructor(device, props) {
-      super(device, props, {
-        ...Resource.defaultProps,
-        constantAttributeZero: false
-      });
-      Object.seal(this);
-    }
-    destroy() {
-      super.destroy();
-      if (this.buffer) {
-        this.buffer?.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 || 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 = {}) {
-      assert2(!elementBuffer || elementBuffer.glTarget === GL.ELEMENT_ARRAY_BUFFER, ERR_ELEMENTS);
-      this.bind(() => {
-        this.gl.bindBuffer(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 === 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:
-          assert2(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 = getScratchArray(value.constructor, length);
-        fillArray({
-          target: typedArray,
-          source: constantValue,
-          start: 0,
-          count: length
-        });
-        this.buffer.subData(typedArray);
-        this.bufferValue = value;
-      }
-      return this.buffer;
-    }
-  };
-  function setConstantFloatArray(device, location, array) {
-    switch (array.length) {
-      case 1:
-        device.gl.vertexAttrib1fv(location, array);
-        break;
-      case 2:
-        device.gl.vertexAttrib2fv(location, array);
-        break;
-      case 3:
-        device.gl.vertexAttrib3fv(location, array);
-        break;
-      case 4:
-        device.gl.vertexAttrib4fv(location, array);
-        break;
-      default:
-        assert2(false);
-    }
-  }
-  function setConstantIntArray(device, location, array) {
-    device.assertWebGL2();
-    device.gl2?.vertexAttribI4iv(location, array);
-  }
-  function setConstantUintArray(device, location, array) {
-    device.assertWebGL2();
-    device.gl2?.vertexAttribI4uiv(location, array);
-  }
-  function normalizeConstantArrayValue(arrayValue) {
-    if (Array.isArray(arrayValue)) {
-      return new Float32Array(arrayValue);
-    }
-    return arrayValue;
-  }
-  function compareConstantArrayValues(v1, v2) {
-    if (!v1 || !v2 || v1.length !== v2.length || v1.constructor !== v2.constructor) {
-      return false;
-    }
-    for (let i = 0; i < v1.length; ++i) {
-      if (v1[i] !== v2[i]) {
-        return false;
-      }
+          throw new Error("samplers must be set to integers");
+        }
+        return gl.uniform1i(location, value);
+      case GL.FLOAT:
+        return gl.uniform1fv(location, arrayValue);
+      case GL.FLOAT_VEC2:
+        return gl.uniform2fv(location, arrayValue);
+      case GL.FLOAT_VEC3:
+        return gl.uniform3fv(location, arrayValue);
+      case GL.FLOAT_VEC4:
+        return gl.uniform4fv(location, arrayValue);
+      case GL.INT:
+        return gl.uniform1iv(location, arrayValue);
+      case GL.INT_VEC2:
+        return gl.uniform2iv(location, arrayValue);
+      case GL.INT_VEC3:
+        return gl.uniform3iv(location, arrayValue);
+      case GL.INT_VEC4:
+        return gl.uniform4iv(location, arrayValue);
+      case GL.BOOL:
+        return gl.uniform1iv(location, arrayValue);
+      case GL.BOOL_VEC2:
+        return gl.uniform2iv(location, arrayValue);
+      case GL.BOOL_VEC3:
+        return gl.uniform3iv(location, arrayValue);
+      case GL.BOOL_VEC4:
+        return gl.uniform4iv(location, arrayValue);
+      case GL.UNSIGNED_INT:
+        return gl2.uniform1uiv(location, arrayValue, 1);
+      case GL.UNSIGNED_INT_VEC2:
+        return gl2.uniform2uiv(location, arrayValue, 2);
+      case GL.UNSIGNED_INT_VEC3:
+        return gl2.uniform3uiv(location, arrayValue, 3);
+      case GL.UNSIGNED_INT_VEC4:
+        return gl2.uniform4uiv(location, arrayValue, 4);
+      case GL.FLOAT_MAT2:
+        return gl.uniformMatrix2fv(location, false, arrayValue);
+      case GL.FLOAT_MAT3:
+        return gl.uniformMatrix3fv(location, false, arrayValue);
+      case GL.FLOAT_MAT4:
+        return gl.uniformMatrix4fv(location, false, arrayValue);
+      case GL.FLOAT_MAT2x3:
+        return gl2.uniformMatrix2x3fv(location, false, arrayValue);
+      case GL.FLOAT_MAT2x4:
+        return gl2.uniformMatrix2x4fv(location, false, arrayValue);
+      case GL.FLOAT_MAT3x2:
+        return gl2.uniformMatrix3x2fv(location, false, arrayValue);
+      case GL.FLOAT_MAT3x4:
+        return gl2.uniformMatrix3x4fv(location, false, arrayValue);
+      case GL.FLOAT_MAT4x2:
+        return gl2.uniformMatrix4x2fv(location, false, arrayValue);
+      case GL.FLOAT_MAT4x3:
+        return gl2.uniformMatrix4x3fv(location, false, arrayValue);
     }
-    return true;
+    throw new Error("Illegal uniform");
   }
 
   // src/adapter/resources/webgl-render-pipeline.ts
@@ -9050,18 +8900,12 @@ ${formattedLog}`)();
     /** vertex shader */
     /** fragment shader */
     /** The layout extracted from shader by WebGL introspection APIs */
-    /** The merged layout */
-    /** Buffer map describing buffer interleaving etc */
     /** Uniforms set on this model */
     uniforms = {};
     /** Bindings set on this model */
     bindings = {};
-    /** Any constant attributes */
-    constantAttributes = {};
-    /** Index buffer is stored separately */
     /** WebGL varyings */
     varyings = null;
-    /** Stores attribute bindings */
     _textureUniforms = {};
     _textureIndexCounter = 0;
     _uniformCount = 0;
@@ -9088,8 +8932,6 @@ ${formattedLog}`)();
       this._compileAndLink();
       this.introspectedLayout = getShaderLayout(this.device.gl, this.handle);
       this.shaderLayout = mergeShaderLayout(this.introspectedLayout, props.shaderLayout);
-      this.bufferLayout = props.bufferLayout || [];
-      this.vertexArrayObject = new WEBGLVertexArrayObject(this.device);
     }
     destroy() {
       if (this.handle) {
@@ -9097,68 +8939,37 @@ ${formattedLog}`)();
         this.destroyed = true;
       }
     }
-    setIndexBuffer(indexBuffer) {
-      const webglBuffer = cast(indexBuffer);
-      this.vertexArrayObject.setElementBuffer(webglBuffer);
-      this._indexBuffer = webglBuffer;
-    }
-    /** @todo needed for portable model */
-    setAttributes(buffers) {
-      const attributeInfos = 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 = cast(buffer);
-          const glType = getGLFromVertexType(attributeInfo.bufferDataType);
-          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) {
-          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
@@ -9203,6 +9014,7 @@ ${formattedLog}`)();
     draw(options) {
       const {
         renderPass,
+        vertexArray,
         vertexCount,
         // indexCount,
         instanceCount,
@@ -9211,71 +9023,68 @@ ${formattedLog}`)();
         // firstInstance,
         // baseVertex
       } = options;
-      const drawMode = getGLDrawMode(this.props.topology);
-      const isIndexed = Boolean(this._indexBuffer);
-      const indexType = this._indexBuffer?.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 = vertexArray.indexBuffer?.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, () => {
+        if (isIndexed && isInstanced) {
+          this.device.gl2?.drawElementsInstanced(
+            glDrawMode,
+            vertexCount || 0,
+            // indexCount?
+            glIndexType,
+            firstVertex,
+            instanceCount || 0
+          );
+        } else if (isIndexed) {
+          this.device.gl.drawElements(glDrawMode, vertexCount || 0, glIndexType, firstVertex);
+        } else if (isInstanced) {
+          this.device.gl2?.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, () => {
-            if (isIndexed && isInstanced) {
-              this.device.gl2?.drawElementsInstanced(
-                drawMode,
-                vertexCount || 0,
-                // indexCount?
-                indexType,
-                firstVertex,
-                instanceCount || 0
-              );
-            } else if (isIndexed) {
-              this.device.gl.drawElements(drawMode, vertexCount || 0, indexType, firstVertex);
-            } else if (isInstanced) {
-              this.device.gl2?.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
+        gl
       } = this.device;
-      gl2.attachShader(this.handle, this.vs.handle);
-      gl2.attachShader(this.handle, this.fs.handle);
+      gl.attachShader(this.handle, this.vs.handle);
+      gl.attachShader(this.handle, this.fs.handle);
       log.time(LOG_PROGRAM_PERF_PRIORITY, `linkProgram for ${this.id}`)();
-      gl2.linkProgram(this.handle);
+      gl.linkProgram(this.handle);
       log.timeEnd(LOG_PROGRAM_PERF_PRIORITY, `linkProgram for ${this.id}`)();
-      if (gl2.debug || 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)}`);
-        }
+      if (!gl.debug && 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
@@ -9302,19 +9111,22 @@ ${formattedLog}`)();
      * 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() {
+     *
+    _applyConstantAttributes(vertexArray: WEBGLVertexArray): void {
       const attributeInfos = getAttributeInfosFromLayouts(this.shaderLayout, this.bufferLayout);
-      for (const [name2, value] of Object.entries(this.constantAttributes)) {
-        const attributeInfo = attributeInfos[name2];
+      for (const [name, value] of Object.entries(this.)) {
+        const attributeInfo = attributeInfos[name];
         if (!attributeInfo) {
-          log.warn(`Ignoring constant value supplied for unknown attribute "${name2}" in pipeline "${this.id}"`)();
-          continue;
+          log.warn(
+            `Ignoring constant value supplied for unknown attribute "${name}" in pipeline "${this.id}"`
+          )();
+          continue; // eslint-disable-line no-continue
         }
-        this.vertexArrayObject.setConstant(attributeInfo.location, value);
-        this.vertexArrayObject.enable(attributeInfo.location, false);
+        vertexArray.setConstant(attributeInfo.location, value);
+        vertexArray.enable(attributeInfo.location, false);
       }
     }
+    */
     /** Apply any bindings (before each draw call) */
     _applyBindings() {
       this.device.gl.useProgram(this.handle);
@@ -9344,7 +9156,16 @@ ${formattedLog}`)();
             if (value instanceof WEBGLBuffer) {
               gl2.bindBufferBase(GL.UNIFORM_BUFFER, uniformBufferIndex, value.handle);
             } else {
-              gl2.bindBufferRange(GL.UNIFORM_BUFFER, uniformBufferIndex, value.buffer.handle, value.offset || 0, value.size || value.buffer.byteLength - value.offset);
+              gl2.bindBufferRange(
+                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
+              );
             }
             uniformBufferIndex += 1;
             break;
@@ -9591,7 +9412,6 @@ ${formattedLog}`)();
     if (texture) {
       texture.unbind();
     }
-    device.gl.bindFramebuffer(GL.FRAMEBUFFER, prevHandle || null);
     if (destroyFramebuffer) {
       framebuffer.destroy();
     }
@@ -9676,6 +9496,215 @@ ${formattedLog}`)();
     // }): void;
   };
 
+  // src/adapter/resources/webgl-vertex-array.ts
+  var WEBGLVertexArray = class extends VertexArray {
+    get [Symbol.toStringTag]() {
+      return "VertexArray";
+    }
+    /** Attribute 0 buffer constant */
+    buffer = null;
+    bufferValue = null;
+    /** * Attribute 0 can not be disable on most desktop OpenGL based browsers */
+    static isConstantAttributeZeroSupported(device) {
+      return device.info.type === "webgl2" || getBrowser() === "Chrome";
+    }
+    // Create a VertexArray
+    constructor(device, props) {
+      super(device, props);
+      this.device = device;
+      this.handle = this.device.gl2.createVertexArray();
+    }
+    destroy() {
+      super.destroy();
+      if (this.buffer) {
+        this.buffer?.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 !== GL.ELEMENT_ARRAY_BUFFER) {
+        throw new Error("Use .setBuffer()");
+      }
+      this.device.gl2.bindVertexArray(this.handle);
+      this.device.gl2.bindBuffer(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 === 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(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;
+    }
+    init = false;
+    bindBeforeRender() {
+      this.device.gl2.bindVertexArray(this.handle);
+      if (!this.init) {
+        const webglBuffer = this.indexBuffer;
+        this.device.gl2.bindBuffer(GL.ELEMENT_ARRAY_BUFFER, 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 = getScratchArray(value.constructor, length);
+        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 Device {
@@ -9699,18 +9728,18 @@ ${formattedLog}`)();
      * @param gl
      * @returns
      */
-    static attach(gl2) {
-      if (gl2 instanceof _WebGLDevice) {
-        return gl2;
+    static attach(gl) {
+      if (gl instanceof _WebGLDevice) {
+        return gl;
       }
-      if (gl2?.device instanceof Device) {
-        return gl2.device;
+      if (gl?.device instanceof Device) {
+        return gl.device;
       }
-      if (!isWebGL3(gl2)) {
+      if (!isWebGL3(gl)) {
         throw new Error("Invalid WebGLRenderingContext");
       }
       return new _WebGLDevice({
-        gl: gl2
+        gl
       });
     }
     static async create(props = {}) {
@@ -9753,19 +9782,19 @@ ${formattedLog}`)();
         reason: "destroyed",
         message: "Computer entered sleep mode, or too many apps or browser tabs are using the GPU."
       });
-      let gl2 = props.gl || null;
-      gl2 = gl2 || (isBrowser() ? createBrowserContext(this.canvasContext.canvas, {
+      let gl = props.gl || null;
+      gl = gl || (isBrowser() ? createBrowserContext(this.canvasContext.canvas, {
         ...props,
         onContextLost
       }) : null);
-      gl2 = gl2 || (!isBrowser() ? createHeadlessContext({
+      gl = gl || (!isBrowser() ? createHeadlessContext({
         ...props,
         onContextLost
       }) : null);
-      if (!gl2) {
+      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);
@@ -9864,6 +9893,9 @@ ${formattedLog}`)();
     createRenderPipeline(props) {
       return new WEBGLRenderPipeline(this, props);
     }
+    createVertexArray(props) {
+      return new WEBGLVertexArray(this, props);
+    }
     beginRenderPass(props) {
       return new WEBGLRenderPass(this, props);
     }
@@ -9941,48 +9973,113 @@ ${formattedLog}`)();
     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);
     }
+    /** Store constants */
+    /**
+     * 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)) {
+        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:
+          assert2(false);
+      }
+    }
   };
   var WebGLDevice = _WebGLDevice;
   //
   // Public `Device` API
   //
   __publicField(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:
+        assert2(false);
+    }
+  }
+  function setConstantIntArray(device, location, array) {
+    device.assertWebGL2();
+    device.gl2?.vertexAttribI4iv(location, array);
+  }
+  function setConstantUintArray(device, location, array) {
+    device.assertWebGL2();
+    device.gl2?.vertexAttribI4uiv(location, array);
+  }
+  function 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
@@ -9990,8 +10087,8 @@ ${formattedLog}`)();
   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,
@@ -10022,7 +10119,7 @@ ${formattedLog}`)();
       }
     }
     assert2(clearFlags !== 0, ERR_ARGUMENTS);
-    withParameters(device.gl, parameters, () => {
+    withGLParameters(device.gl, parameters, () => {
       device.gl.clear(clearFlags);
     });
   }
@@ -10069,11 +10166,11 @@ ${formattedLog}`)();
     const {
       sourceX = 0,
       sourceY = 0,
-      sourceFormat = GL.RGBA
+      sourceFormat = GL.RGBA,
+      sourceAttachment = GL.COLOR_ATTACHMENT0
+      // TODO - support gl.readBuffer
     } = options || {};
     let {
-      sourceAttachment = GL.COLOR_ATTACHMENT0,
-      // TODO - support gl.readBuffer
       target = null,
       // following parameters are auto deduced if not provided
       sourceWidth,
@@ -10086,21 +10183,18 @@ ${formattedLog}`)();
     } = getFramebuffer2(source);
     assert2(framebuffer);
     const {
-      gl: gl2,
+      gl,
       handle
     } = framebuffer;
     sourceWidth = sourceWidth || framebuffer.width;
     sourceHeight = sourceHeight || framebuffer.height;
-    if (sourceAttachment === GL.COLOR_ATTACHMENT0 && handle === null) {
-      sourceAttachment = GL.FRONT;
-    }
     const attachment = sourceAttachment - GL.COLOR_ATTACHMENT0;
-    sourceType = sourceType || framebuffer.colorAttachments[attachment].type;
+    sourceType = sourceType || framebuffer.colorAttachments[attachment]?.type || GL.UNSIGNED_BYTE;
     target = getPixelArray(target, sourceType, sourceFormat, sourceWidth, sourceHeight);
     sourceType = sourceType || getGLTypeFromTypedArray(target);
-    const prevHandle2 = gl2.bindFramebuffer(GL.FRAMEBUFFER, handle);
-    gl2.readPixels(sourceX, sourceY, sourceWidth, sourceHeight, sourceFormat, sourceType, target);
-    gl2.bindFramebuffer(GL.FRAMEBUFFER, prevHandle2 || null);
+    const prevHandle = gl.bindFramebuffer(GL.FRAMEBUFFER, handle);
+    gl.readPixels(sourceX, sourceY, sourceWidth, sourceHeight, sourceFormat, sourceType, target);
+    gl.bindFramebuffer(GL.FRAMEBUFFER, prevHandle || null);
     if (deleteFramebuffer) {
       framebuffer.destroy();
     }
@@ -10144,7 +10238,7 @@ ${formattedLog}`)();
     target.bind({
       glTarget: GL.PIXEL_PACK_BUFFER
     });
-    withParameters(gl2, {
+    withGLParameters(gl2, {
       framebuffer
     }, () => {
       gl2.readPixels(sourceX, sourceY, sourceWidth, sourceHeight, sourceFormat, sourceType, targetByteOffset);
@@ -10188,7 +10282,7 @@ ${formattedLog}`)();
     targetX = targetX || 0;
     targetY = targetY || 0;
     targetZ = targetZ || 0;
-    const prevHandle2 = device.gl.bindFramebuffer(GL.FRAMEBUFFER, handle);
+    const prevHandle = device.gl.bindFramebuffer(GL.FRAMEBUFFER, handle);
     assert2(target);
     let texture = null;
     let textureTarget;
@@ -10230,7 +10324,7 @@ ${formattedLog}`)();
     if (texture) {
       texture.unbind();
     }
-    gl.bindFramebuffer(GL.FRAMEBUFFER, prevHandle2 || null);
+    device.gl.bindFramebuffer(GL.FRAMEBUFFER, prevHandle || null);
     if (deleteFramebuffer) {
       framebuffer.destroy();
     }