@luma.gl/webgl 9.0.17 → 9.1.0-alpha.10

package/dist/dist.dev.js

@@ -11,7 +11,6 @@ var __exports__ = (() => {
   var __getOwnPropNames = Object.getOwnPropertyNames;
   var __getProtoOf = Object.getPrototypeOf;
   var __hasOwnProp = Object.prototype.hasOwnProperty;
-  var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
   var __commonJS = (cb, mod) => function __require() {
     return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
   };
@@ -37,10 +36,6 @@ var __exports__ = (() => {
     mod
   ));
   var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-  var __publicField = (obj, key, value) => {
-    __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-    return value;
-  };
 
   // external-global-plugin:@luma.gl/core
   var require_core = __commonJS({
@@ -58,7 +53,6 @@ var __exports__ = (() => {
     WEBGLFramebuffer: () => WEBGLFramebuffer,
     WEBGLRenderPass: () => WEBGLRenderPass,
     WEBGLRenderPipeline: () => WEBGLRenderPipeline,
-    WEBGLResource: () => WebGLResource,
     WEBGLSampler: () => WEBGLSampler,
     WEBGLShader: () => WEBGLShader,
     WEBGLTexture: () => WEBGLTexture,
@@ -66,28 +60,24 @@ var __exports__ = (() => {
     WEBGLVertexArray: () => WEBGLVertexArray,
     WebGLCanvasContext: () => WebGLCanvasContext,
     WebGLDevice: () => WebGLDevice,
-    WebGLResource: () => WebGLResource,
+    WebGLStateTracker: () => WebGLStateTracker,
     _TEXTURE_FORMATS: () => TEXTURE_FORMATS,
-    _WEBGLRenderbuffer: () => WEBGLRenderbuffer,
-    convertGLToTextureFormat: () => convertGLToTextureFormat,
     getGLParameters: () => getGLParameters,
     getShaderLayout: () => getShaderLayout,
-    popContextState: () => popContextState,
-    pushContextState: () => pushContextState,
     resetGLParameters: () => resetGLParameters,
     setDeviceParameters: () => setDeviceParameters,
     setGLParameters: () => setGLParameters,
-    trackContextState: () => trackContextState,
+    webgl2Adapter: () => webgl2Adapter,
     withDeviceParameters: () => withDeviceParameters,
     withGLParameters: () => withGLParameters
   });
   __reExport(bundle_exports, __toESM(require_core(), 1));
 
-  // src/adapter/webgl-device.ts
-  var import_core27 = __toESM(require_core(), 1);
+  // src/adapter/webgl-adapter.ts
+  var import_core23 = __toESM(require_core(), 1);
 
-  // src/context/state-tracker/track-context-state.ts
-  var import_core = __toESM(require_core(), 1);
+  // src/adapter/webgl-device.ts
+  var import_core22 = __toESM(require_core(), 1);
 
   // ../constants/src/webgl-constants.ts
   var GLEnum = /* @__PURE__ */ ((GLEnum2) => {
@@ -970,7 +960,7 @@ var __exports__ = (() => {
     lineWidth: (gl, value) => gl.lineWidth(value),
     polygonOffsetFill: (gl, value) => value ? gl.enable(32823 /* POLYGON_OFFSET_FILL */) : gl.disable(32823 /* POLYGON_OFFSET_FILL */),
     polygonOffset: (gl, value) => gl.polygonOffset(...value),
-    sampleCoverage: (gl, value) => gl.sampleCoverage(...value),
+    sampleCoverage: (gl, value) => gl.sampleCoverage(value[0], value[1] || false),
     scissorTest: (gl, value) => value ? gl.enable(3089 /* SCISSOR_TEST */) : gl.disable(3089 /* SCISSOR_TEST */),
     scissor: (gl, value) => gl.scissor(...value),
     stencilTest: (gl, value) => value ? gl.enable(2960 /* STENCIL_TEST */) : gl.disable(2960 /* STENCIL_TEST */),
@@ -1316,24 +1306,22 @@ var __exports__ = (() => {
     return false;
   }
 
-  // src/context/state-tracker/track-context-state.ts
-  var GLState = class {
+  // src/context/state-tracker/webgl-state-tracker.ts
+  var WebGLStateTracker = class {
+    static get(gl) {
+      return gl.state;
+    }
     gl;
     program = null;
     stateStack = [];
     enable = true;
-    cache;
+    cache = null;
     log;
-    constructor(gl, {
-      copyState = false,
-      // Copy cache from params (slow) or initialize from WebGL defaults (fast)
-      log: log9 = () => {
-      }
-      // Logging function, called when gl parameter change calls are actually issued
-    } = {}) {
+    initialized = false;
+    constructor(gl, props) {
       this.gl = gl;
-      this.cache = copyState ? getGLParameters(gl) : Object.assign({}, GL_PARAMETER_DEFAULTS);
-      this.log = log9;
+      this.log = props?.log || (() => {
+      });
       this._updateCache = this._updateCache.bind(this);
       Object.seal(this);
     }
@@ -1341,11 +1329,33 @@ var __exports__ = (() => {
       this.stateStack.push({});
     }
     pop() {
-      (0, import_core.assert)(this.stateStack.length > 0);
       const oldValues = this.stateStack[this.stateStack.length - 1];
       setGLParameters(this.gl, oldValues);
       this.stateStack.pop();
     }
+    /**
+     * Initialize WebGL state caching on a context
+     * can be called multiple times to enable/disable
+     *
+     * @note After calling this function, context state will be cached
+     * .push() and .pop() will be available for saving,
+     * temporarily modifying, and then restoring state.
+     */
+    trackState(gl, options) {
+      this.cache = options.copyState ? getGLParameters(gl) : Object.assign({}, GL_PARAMETER_DEFAULTS);
+      if (this.initialized) {
+        throw new Error("WebGLStateTracker");
+      }
+      this.initialized = true;
+      this.gl.state = this;
+      installProgramSpy(gl);
+      for (const key in GL_HOOKED_SETTERS) {
+        const setter = GL_HOOKED_SETTERS[key];
+        installSetterSpy(gl, key, setter);
+      }
+      installGetterOverride(gl, "getParameter");
+      installGetterOverride(gl, "isEnabled");
+    }
     /**
     // interceptor for context set functions - update our cache and our stack
     // values (Object) - the key values for this setter
@@ -1357,7 +1367,6 @@ var __exports__ = (() => {
       let oldValue;
       const oldValues = this.stateStack.length > 0 ? this.stateStack[this.stateStack.length - 1] : null;
       for (const key in values) {
-        (0, import_core.assert)(key !== void 0);
         const value = values[key];
         const cached = this.cache[key];
         if (!deepArrayEqual(value, cached)) {
@@ -1372,46 +1381,13 @@ var __exports__ = (() => {
       return { valueChanged, oldValue };
     }
   };
-  function getContextState(gl) {
-    return gl.state;
-  }
-  function trackContextState(gl, options) {
-    const { enable: enable2 = true, copyState } = options;
-    (0, import_core.assert)(copyState !== void 0);
-    if (!gl.state) {
-      gl.state = new GLState(gl, { copyState });
-      installProgramSpy(gl);
-      for (const key in GL_HOOKED_SETTERS) {
-        const setter = GL_HOOKED_SETTERS[key];
-        installSetterSpy(gl, key, setter);
-      }
-      installGetterOverride(gl, "getParameter");
-      installGetterOverride(gl, "isEnabled");
-    }
-    const glState = getContextState(gl);
-    glState.enable = enable2;
-    return gl;
-  }
-  function pushContextState(gl) {
-    let glState = getContextState(gl);
-    if (!glState) {
-      trackContextState(gl, { copyState: false });
-      glState = getContextState(gl);
-    }
-    glState.push();
-  }
-  function popContextState(gl) {
-    const glState = getContextState(gl);
-    (0, import_core.assert)(glState);
-    glState.pop();
-  }
   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(gl);
+      const glState = WebGLStateTracker.get(gl);
       if (!(pname in glState.cache)) {
         glState.cache[pname] = originalGetterFunc(pname);
       }
@@ -1434,7 +1410,7 @@ var __exports__ = (() => {
     }
     const originalSetterFunc = gl[functionName].bind(gl);
     gl[functionName] = function set(...params) {
-      const glState = getContextState(gl);
+      const glState = WebGLStateTracker.get(gl);
       const { valueChanged, oldValue } = setter(glState._updateCache, ...params);
       if (valueChanged) {
         originalSetterFunc(...params);
@@ -1449,7 +1425,7 @@ var __exports__ = (() => {
   function installProgramSpy(gl) {
     const originalUseProgram = gl.useProgram.bind(gl);
     gl.useProgram = function useProgramLuma(handle) {
-      const glState = getContextState(gl);
+      const glState = WebGLStateTracker.get(gl);
       if (glState.program !== handle) {
         originalUseProgram(handle);
         glState.program = handle;
@@ -1573,10 +1549,10 @@ var __exports__ = (() => {
   }
 
   // src/adapter/device-helpers/webgl-device-features.ts
-  var import_core3 = __toESM(require_core(), 1);
+  var import_core2 = __toESM(require_core(), 1);
 
   // src/adapter/converters/texture-formats.ts
-  var import_core2 = __toESM(require_core(), 1);
+  var import_core = __toESM(require_core(), 1);
 
   // src/adapter/converters/vertex-formats.ts
   function getGLFromVertexType(dataType) {
@@ -1666,26 +1642,6 @@ var __exports__ = (() => {
     return textureExtensions.every((extension) => getWebGLExtension(gl, extension, extensions));
   }
   var TEXTURE_FORMATS = {
-    // Unsized formats that leave the precision up to the driver. TODO - Fix bpp constants
-    "rgb8unorm-unsized": {
-      gl: 6407 /* RGB */,
-      b: 4,
-      c: 2,
-      bpp: 4,
-      dataFormat: 6407 /* RGB */,
-      types: [5121 /* UNSIGNED_BYTE */, 33635 /* UNSIGNED_SHORT_5_6_5 */]
-    },
-    "rgba8unorm-unsized": {
-      gl: 6408 /* RGBA */,
-      b: 4,
-      c: 2,
-      bpp: 4,
-      dataFormat: 6408 /* RGBA */,
-      types: [5121 /* UNSIGNED_BYTE */, 32819 /* UNSIGNED_SHORT_4_4_4_4 */, 32820 /* UNSIGNED_SHORT_5_5_5_1 */]
-    },
-    // 'r8unorm-unsized': {gl: GL.LUMINANCE, b: 4, c: 2, bpp: 4},
-    // 'rgb8unorm-srgb-unsized': {gl: GL.SRGB_EXT, b: 4, c: 2, bpp: 4, gl1Ext: SRGB},
-    // 'rgba8unorm-srgb-unsized': {gl: GL.SRGB_ALPHA_EXT, b: 4, c: 2, bpp: 4, gl1Ext: SRGB},
     // 8-bit formats
     "r8unorm": { gl: 33321 /* R8 */, b: 1, c: 1, rb: true },
     "r8snorm": { gl: 36756 /* R8_SNORM */, b: 1, c: 1, render: snorm8_renderable },
@@ -1719,7 +1675,6 @@ var __exports__ = (() => {
     "bgra8unorm-srgb": { b: 4, c: 4 },
     "rg16uint": { gl: 33338 /* RG16UI */, b: 4, c: 1, bpp: 4 },
     "rg16sint": { gl: 33337 /* RG16I */, b: 4, c: 2, bpp: 4 },
-    // When using a WebGL 2 context and the EXT_color_buffer_float WebGL2 extension
     "rg16float": { gl: 33327 /* RG16F */, bpp: 4, b: 4, c: 2, render: float16_renderable, filter: float16_filterable, rb: true },
     "rg16unorm-webgl": { gl: 33324 /* RG16_EXT */, b: 2, c: 2, render: norm16_renderable },
     "rg16snorm-webgl": { gl: 36761 /* RG16_SNORM_EXT */, b: 2, c: 2, render: snorm16_renderable },
@@ -1801,17 +1756,6 @@ var __exports__ = (() => {
       dataFormat: 34041 /* DEPTH_STENCIL */,
       types: [34042 /* UNSIGNED_INT_24_8 */]
     },
-    // "depth24unorm-stencil8" feature
-    "depth24unorm-stencil8": {
-      gl: 35056 /* DEPTH24_STENCIL8 */,
-      b: 4,
-      c: 2,
-      p: 1,
-      attachment: 33306 /* DEPTH_STENCIL_ATTACHMENT */,
-      dataFormat: 34041 /* DEPTH_STENCIL */,
-      types: [34042 /* UNSIGNED_INT_24_8 */],
-      rb: true
-    },
     // "depth32float-stencil8" feature - TODO below is render buffer only?
     "depth32float-stencil8": {
       gl: 36013 /* DEPTH32F_STENCIL8 */,
@@ -1926,33 +1870,16 @@ var __exports__ = (() => {
     if (info.gl === void 0) {
       return false;
     }
+    const feature = info.f;
+    if (feature) {
+      return checkTextureFeature(gl, feature, extensions);
+    }
     const extension = info.x || info.gl2ext;
     if (extension) {
       return Boolean(getWebGLExtension(gl, extension, extensions));
     }
     return true;
   }
-  function isRenderbufferFormatSupported(gl, format, extensions) {
-    return isTextureFormatSupported(gl, format, extensions) && TEXTURE_FORMATS[format]?.rb;
-  }
-  function convertGLToTextureFormat(format) {
-    if (typeof format === "string") {
-      return format;
-    }
-    const entry = Object.entries(TEXTURE_FORMATS).find(([, entry2]) => entry2.gl === format);
-    if (!entry) {
-      throw new Error(`Unknown texture format ${format}`);
-    }
-    return entry[0];
-  }
-  function convertTextureFormatToGL(format) {
-    const formatInfo = TEXTURE_FORMATS[format];
-    const webglFormat = formatInfo?.gl;
-    if (webglFormat === void 0) {
-      throw new Error(`Unsupported texture format ${format}`);
-    }
-    return webglFormat;
-  }
   function isTextureFormatFilterable(gl, format, extensions) {
     if (!isTextureFormatSupported(gl, format, extensions)) {
       return false;
@@ -1961,7 +1888,7 @@ var __exports__ = (() => {
       return false;
     }
     try {
-      const decoded = (0, import_core2.decodeTextureFormat)(format);
+      const decoded = (0, import_core.decodeTextureFormat)(format);
       if (decoded.signed) {
         return false;
       }
@@ -1985,17 +1912,16 @@ var __exports__ = (() => {
     }
     return true;
   }
-  function getWebGLTextureParameters(format) {
+  function getTextureFormatWebGL(format) {
     const formatData = TEXTURE_FORMATS[format];
     const webglFormat = convertTextureFormatToGL(format);
-    const decoded = (0, import_core2.decodeTextureFormat)(format);
+    const decoded = (0, import_core.decodeTextureFormat)(format);
     return {
-      format: webglFormat,
-      dataFormat: formatData?.dataFormat || getWebGLPixelDataFormat(decoded.format, decoded.integer, decoded.normalized, webglFormat),
+      internalFormat: webglFormat,
+      format: formatData?.dataFormat || getWebGLPixelDataFormat(decoded.channels, decoded.integer, decoded.normalized, webglFormat),
       // depth formats don't have a type
       type: decoded.dataType ? getGLFromVertexType(decoded.dataType) : formatData?.types?.[0] || 5121 /* UNSIGNED_BYTE */,
-      // @ts-expect-error
-      compressed: decoded.compressed
+      compressed: decoded.compressed || false
     };
   }
   function getDepthStencilAttachmentWebGL(format) {
@@ -2005,17 +1931,11 @@ var __exports__ = (() => {
     }
     return info.attachment;
   }
-  function getTextureFormatBytesPerPixel(format) {
-    const params = getWebGLTextureParameters(format);
-    const channels = DATA_FORMAT_CHANNELS[params.dataFormat] || 4;
-    const channelSize = TYPE_SIZES[params.type] || 1;
-    return channels * channelSize;
-  }
-  function getWebGLPixelDataFormat(dataFormat, integer, normalized, format) {
+  function getWebGLPixelDataFormat(channels, integer, normalized, format) {
     if (format === 6408 /* RGBA */ || format === 6407 /* RGB */) {
       return format;
     }
-    switch (dataFormat) {
+    switch (channels) {
       case "r":
         return integer && !normalized ? 36244 /* RED_INTEGER */ : 6403 /* RED */;
       case "rg":
@@ -2024,10 +1944,20 @@ var __exports__ = (() => {
         return integer && !normalized ? 36248 /* RGB_INTEGER */ : 6407 /* RGB */;
       case "rgba":
         return integer && !normalized ? 36249 /* RGBA_INTEGER */ : 6408 /* RGBA */;
+      case "bgra":
+        throw new Error("bgra pixels not supported by WebGL");
       default:
         return 6408 /* RGBA */;
     }
   }
+  function convertTextureFormatToGL(format) {
+    const formatInfo = TEXTURE_FORMATS[format];
+    const webglFormat = formatInfo?.gl;
+    if (webglFormat === void 0) {
+      throw new Error(`Unsupported texture format ${format}`);
+    }
+    return webglFormat;
+  }
 
   // src/adapter/device-helpers/webgl-device-features.ts
   var WEBGL_FEATURES = {
@@ -2037,7 +1967,6 @@ var __exports__ = (() => {
     // 'timestamp-query' // GPUQueryType "timestamp-query"
     // "indirect-first-instance"
     // Textures are handled by getTextureFeatures()
-    // 'depth24unorm-stencil8' // GPUTextureFormat 'depth24unorm-stencil8'
     // 'depth32float-stencil8' // GPUTextureFormat 'depth32float-stencil8'
     // optional WebGL features
     "timer-query-webgl": "EXT_disjoint_timer_query_webgl2",
@@ -2049,7 +1978,7 @@ var __exports__ = (() => {
     "shader-conservative-depth-webgl": "EXT_conservative_depth"
     // Textures are handled by getTextureFeatures()
   };
-  var WebGLDeviceFeatures = class extends import_core3.DeviceFeatures {
+  var WebGLDeviceFeatures = class extends import_core2.DeviceFeatures {
     gl;
     extensions;
     testedFeatures = /* @__PURE__ */ new Set();
@@ -2069,7 +1998,7 @@ var __exports__ = (() => {
       return [];
     }
     has(feature) {
-      if (this.disabledFeatures[feature]) {
+      if (this.disabledFeatures?.[feature]) {
         return false;
       }
       if (!this.testedFeatures.has(feature)) {
@@ -2103,8 +2032,8 @@ var __exports__ = (() => {
   };
 
   // src/adapter/device-helpers/webgl-device-limits.ts
-  var import_core4 = __toESM(require_core(), 1);
-  var WebGLDeviceLimits = class extends import_core4.DeviceLimits {
+  var import_core3 = __toESM(require_core(), 1);
+  var WebGLDeviceLimits = class extends import_core3.DeviceLimits {
     get maxTextureDimension1D() {
       return 0;
     }
@@ -2208,18 +2137,18 @@ var __exports__ = (() => {
       if (this.limits[parameter] === void 0) {
         this.limits[parameter] = this.gl.getParameter(parameter);
       }
-      return this.limits[parameter];
+      return this.limits[parameter] || 0;
     }
   };
 
   // src/adapter/webgl-canvas-context.ts
-  var import_core11 = __toESM(require_core(), 1);
+  var import_core9 = __toESM(require_core(), 1);
 
   // src/adapter/resources/webgl-framebuffer.ts
-  var import_core10 = __toESM(require_core(), 1);
+  var import_core8 = __toESM(require_core(), 1);
 
   // src/adapter/resources/webgl-texture.ts
-  var import_core9 = __toESM(require_core(), 1);
+  var import_core7 = __toESM(require_core(), 1);
 
   // src/context/state-tracker/with-parameters.ts
   function withGLParameters(gl, parameters, func) {
@@ -2227,17 +2156,18 @@ var __exports__ = (() => {
       return func(gl);
     }
     const { nocatch = true } = parameters;
-    pushContextState(gl);
+    const webglState = WebGLStateTracker.get(gl);
+    webglState.push();
     setGLParameters(gl, parameters);
     let value;
     if (nocatch) {
       value = func(gl);
-      popContextState(gl);
+      webglState.pop();
     } else {
       try {
         value = func(gl);
       } finally {
-        popContextState(gl);
+        webglState.pop();
       }
     }
     return value;
@@ -2250,31 +2180,32 @@ var __exports__ = (() => {
   }
 
   // src/adapter/converters/device-parameters.ts
-  var import_core5 = __toESM(require_core(), 1);
+  var import_core4 = __toESM(require_core(), 1);
   function withDeviceAndGLParameters(device, parameters, glParameters, func) {
-    if ((0, import_core5.isObjectEmpty)(parameters)) {
+    if (isObjectEmpty3(parameters)) {
       return func(device);
     }
     const webglDevice = device;
-    pushContextState(webglDevice.gl);
+    webglDevice.pushState();
     try {
       setDeviceParameters(device, parameters);
       setGLParameters(webglDevice.gl, glParameters);
       return func(device);
     } finally {
-      popContextState(webglDevice.gl);
+      webglDevice.popState();
     }
   }
   function withDeviceParameters(device, parameters, func) {
-    if ((0, import_core5.isObjectEmpty)(parameters)) {
+    if (isObjectEmpty3(parameters)) {
       return func(device);
     }
-    pushContextState(device.gl);
+    const webglDevice = device;
+    webglDevice.pushState();
     try {
       setDeviceParameters(device, parameters);
       return func(device);
     } finally {
-      popContextState(device.gl);
+      webglDevice.popState();
     }
   }
   function setDeviceParameters(device, parameters) {
@@ -2383,7 +2314,7 @@ var __exports__ = (() => {
       gl.stencilMaskSeparate(1029 /* BACK */, mask);
     }
     if (parameters.stencilReadMask) {
-      import_core5.log.warn("stencilReadMask not supported under WebGL");
+      import_core4.log.warn("stencilReadMask not supported under WebGL");
     }
     if (parameters.stencilCompare) {
       const mask = parameters.stencilReadMask || 4294967295;
@@ -2402,8 +2333,16 @@ var __exports__ = (() => {
       gl.stencilOpSeparate(1028 /* FRONT */, sfail, dpfail, dppass);
       gl.stencilOpSeparate(1029 /* BACK */, sfail, dpfail, dppass);
     }
+    switch (parameters.blend) {
+      case true:
+        gl.enable(3042 /* BLEND */);
+        break;
+      case false:
+        gl.disable(3042 /* BLEND */);
+        break;
+      default:
+    }
     if (parameters.blendColorOperation || parameters.blendAlphaOperation) {
-      gl.enable(3042 /* BLEND */);
       const colorEquation = convertBlendOperationToEquation(
         "blendColorOperation",
         parameters.blendColorOperation || "add"
@@ -2496,6 +2435,14 @@ var __exports__ = (() => {
   function mapBoolean(parameter, value) {
     return value;
   }
+  function isObjectEmpty3(obj) {
+    let isEmpty = true;
+    for (const key in obj) {
+      isEmpty = false;
+      break;
+    }
+    return isEmpty;
+  }
 
   // src/adapter/converters/sampler-parameters.ts
   function convertSamplerParametersToWebGL(props) {
@@ -2565,134 +2512,9 @@ var __exports__ = (() => {
     }
   }
 
-  // src/adapter/resources/webgl-buffer.ts
-  var import_core6 = __toESM(require_core(), 1);
-  var WEBGLBuffer = class extends import_core6.Buffer {
-    device;
-    gl;
-    handle;
-    /** Target in OpenGL defines the type of buffer */
-    glTarget;
-    /** Usage is a hint on how frequently the buffer will be updates */
-    glUsage;
-    /** Index type is needed when issuing draw calls, so we pre-compute it */
-    glIndexType = 5123 /* UNSIGNED_SHORT */;
-    /** Number of bytes allocated on the GPU for this buffer */
-    byteLength;
-    /** Number of bytes used */
-    bytesUsed;
-    constructor(device, props = {}) {
-      super(device, props);
-      this.device = device;
-      this.gl = this.device.gl;
-      const handle = typeof props === "object" ? props.handle : void 0;
-      this.handle = handle || this.gl.createBuffer();
-      device.setSpectorMetadata(this.handle, { ...this.props, data: typeof this.props.data });
-      this.glTarget = getWebGLTarget(this.props.usage);
-      this.glUsage = getWebGLUsage(this.props.usage);
-      this.glIndexType = this.props.indexType === "uint32" ? 5125 /* UNSIGNED_INT */ : 5123 /* UNSIGNED_SHORT */;
-      if (props.data) {
-        this._initWithData(props.data, props.byteOffset, props.byteLength);
-      } else {
-        this._initWithByteLength(props.byteLength || 0);
-      }
-    }
-    // PRIVATE METHODS
-    /** Allocate a new buffer and initialize to contents of typed array */
-    _initWithData(data, byteOffset = 0, byteLength = data.byteLength + byteOffset) {
-      const glTarget = this.glTarget;
-      this.gl.bindBuffer(glTarget, this.handle);
-      this.gl.bufferData(glTarget, byteLength, this.glUsage);
-      this.gl.bufferSubData(glTarget, byteOffset, data);
-      this.gl.bindBuffer(glTarget, null);
-      this.bytesUsed = byteLength;
-      this.byteLength = byteLength;
-      this._setDebugData(data, byteOffset, byteLength);
-      this.trackAllocatedMemory(byteLength);
-    }
-    // Allocate a GPU buffer of specified size.
-    _initWithByteLength(byteLength) {
-      (0, import_core6.assert)(byteLength >= 0);
-      let data = byteLength;
-      if (byteLength === 0) {
-        data = new Float32Array(0);
-      }
-      const glTarget = this.glTarget;
-      this.gl.bindBuffer(glTarget, this.handle);
-      this.gl.bufferData(glTarget, data, this.glUsage);
-      this.gl.bindBuffer(glTarget, null);
-      this.bytesUsed = byteLength;
-      this.byteLength = byteLength;
-      this._setDebugData(null, 0, byteLength);
-      this.trackAllocatedMemory(byteLength);
-      return this;
-    }
-    destroy() {
-      if (!this.destroyed && this.handle) {
-        this.removeStats();
-        this.trackDeallocatedMemory();
-        this.gl.deleteBuffer(this.handle);
-        this.destroyed = true;
-        this.handle = null;
-      }
-    }
-    write(data, byteOffset = 0) {
-      const srcOffset = 0;
-      const byteLength = void 0;
-      const glTarget = 36663 /* COPY_WRITE_BUFFER */;
-      this.gl.bindBuffer(glTarget, this.handle);
-      if (srcOffset !== 0 || byteLength !== void 0) {
-        this.gl.bufferSubData(glTarget, byteOffset, data, srcOffset, byteLength);
-      } else {
-        this.gl.bufferSubData(glTarget, byteOffset, data);
-      }
-      this.gl.bindBuffer(glTarget, null);
-      this._setDebugData(data, byteOffset, data.byteLength);
-    }
-    /** Asynchronously read data from the buffer */
-    async readAsync(byteOffset = 0, byteLength) {
-      return this.readSyncWebGL(byteOffset, byteLength);
-    }
-    /** Synchronously read data from the buffer. WebGL only. */
-    readSyncWebGL(byteOffset = 0, byteLength) {
-      byteLength = byteLength ?? this.byteLength - byteOffset;
-      const data = new Uint8Array(byteLength);
-      const dstOffset = 0;
-      this.gl.bindBuffer(36662 /* COPY_READ_BUFFER */, this.handle);
-      this.gl.getBufferSubData(36662 /* COPY_READ_BUFFER */, byteOffset, data, dstOffset, byteLength);
-      this.gl.bindBuffer(36662 /* COPY_READ_BUFFER */, null);
-      this._setDebugData(data, byteOffset, byteLength);
-      return data;
-    }
-  };
-  function getWebGLTarget(usage) {
-    if (usage & import_core6.Buffer.INDEX) {
-      return 34963 /* ELEMENT_ARRAY_BUFFER */;
-    }
-    if (usage & import_core6.Buffer.VERTEX) {
-      return 34962 /* ARRAY_BUFFER */;
-    }
-    if (usage & import_core6.Buffer.UNIFORM) {
-      return 35345 /* UNIFORM_BUFFER */;
-    }
-    return 34962 /* ARRAY_BUFFER */;
-  }
-  function getWebGLUsage(usage) {
-    if (usage & import_core6.Buffer.INDEX) {
-      return 35044 /* STATIC_DRAW */;
-    }
-    if (usage & import_core6.Buffer.VERTEX) {
-      return 35044 /* STATIC_DRAW */;
-    }
-    if (usage & import_core6.Buffer.UNIFORM) {
-      return 35048 /* DYNAMIC_DRAW */;
-    }
-    return 35044 /* STATIC_DRAW */;
-  }
-
   // src/adapter/resources/webgl-sampler.ts
-  var import_core7 = __toESM(require_core(), 1);
-  var WEBGLSampler = class extends import_core7.Sampler {
+  var import_core5 = __toESM(require_core(), 1);
+  var WEBGLSampler = class extends import_core5.Sampler {
     device;
     handle;
     parameters;
@@ -2730,14 +2552,15 @@ var __exports__ = (() => {
   };
 
   // src/adapter/resources/webgl-texture-view.ts
-  var import_core8 = __toESM(require_core(), 1);
-  var WEBGLTextureView = class extends import_core8.TextureView {
+  var import_core6 = __toESM(require_core(), 1);
+  var WEBGLTextureView = class extends import_core6.TextureView {
     device;
     gl;
     handle;
+    // Does not have a WebGL representation
     texture;
     constructor(device, props) {
-      super(device, { ...import_core8.Texture.defaultProps, ...props });
+      super(device, { ...import_core6.Texture.defaultProps, ...props });
       this.device = device;
       this.gl = this.device.gl;
       this.handle = null;
@@ -2745,167 +2568,252 @@ var __exports__ = (() => {
     }
   };
 
-  // src/adapter/resources/webgl-texture.ts
-  var DEFAULT_WEBGL_TEXTURE_PROPS = {
-    // deprecated
-    parameters: {},
-    pixelStore: {},
-    pixels: null,
-    border: 0,
-    dataFormat: void 0,
-    textureUnit: void 0,
-    target: void 0
-  };
-  var _WEBGLTexture = class extends import_core9.Texture {
-    MAX_ATTRIBUTES;
-    device;
-    gl;
-    handle;
-    // (TODO - currently unused in WebGL, but WebGL 2 does support sampler objects) */
-    sampler = void 0;
-    view = void 0;
-    // data;
-    glFormat = void 0;
-    type = void 0;
-    dataFormat = void 0;
-    mipmaps = void 0;
-    /**
-     * @note `target` cannot be modified by bind:
-     * textures are special because when you first bind them to a target,
-     * they get special information. When you first bind a texture as a
-     * GL_TEXTURE_2D, you are saying that this texture is a 2D texture.
-     * And it will always be a 2D texture; this state cannot be changed ever.
-     * A texture that was first bound as a GL_TEXTURE_2D, must always be bound as a GL_TEXTURE_2D;
-     * attempting to bind it as GL_TEXTURE_3D will give rise to a run-time error
-     * */
-    target;
-    textureUnit = void 0;
-    /**
-     * Program.draw() checks the loaded flag of all textures to avoid
-     * Textures that are still loading from promises
-     * Set to true as soon as texture has been initialized with valid data
-     */
-    loaded = false;
-    _video;
-    constructor(device, props) {
-      super(device, { ...DEFAULT_WEBGL_TEXTURE_PROPS, format: "rgba8unorm", ...props });
-      this.device = device;
-      this.gl = this.device.gl;
-      this.handle = this.props.handle || this.gl.createTexture();
-      this.device.setSpectorMetadata(this.handle, { ...this.props, data: typeof this.props.data });
-      this.glFormat = 6408 /* RGBA */;
-      this.target = getWebGLTextureTarget(this.props);
-      this.loaded = false;
-      if (typeof this.props?.data === "string") {
-        Object.assign(this.props, { data: (0, import_core9.loadImage)(this.props.data) });
-      }
-      this.initialize(this.props);
-      Object.seal(this);
-    }
-    destroy() {
-      if (this.handle) {
-        this.gl.deleteTexture(this.handle);
-        this.removeStats();
-        this.trackDeallocatedMemory("Texture");
-        this.destroyed = true;
-      }
-    }
-    toString() {
-      return `Texture(${this.id},${this.width}x${this.height})`;
+  // src/adapter/helpers/webgl-texture-utils.ts
+  function initializeTextureStorage(gl, levels, options) {
+    const { dimension, width, height, depth = 0 } = options;
+    const { glInternalFormat } = options;
+    const glTarget = options.glTarget;
+    switch (dimension) {
+      case "2d-array":
+      case "3d":
+        gl.texStorage3D(glTarget, levels, glInternalFormat, width, height, depth);
+        break;
+      default:
+        gl.texStorage2D(glTarget, levels, glInternalFormat, width, height);
     }
-    createView(props) {
-      return new WEBGLTextureView(this.device, { ...props, texture: this });
+  }
+  function copyCPUImageToMipLevel(gl, image, options) {
+    const { dimension, width, height, depth = 0, level = 0 } = options;
+    const { x = 0, y = 0, z = 0 } = options;
+    const { glFormat, glType } = options;
+    const glTarget = getWebGLCubeFaceTarget(options.glTarget, dimension, depth);
+    switch (dimension) {
+      case "2d-array":
+      case "3d":
+        gl.texSubImage3D(glTarget, level, x, y, z, width, height, depth, glFormat, glType, image);
+        break;
+      case "2d":
+      case "cube":
+        gl.texSubImage2D(glTarget, level, x, y, width, height, glFormat, glType, image);
+        break;
+      default:
+        throw new Error(dimension);
     }
-    // eslint-disable-next-line max-statements
-    initialize(props = {}) {
-      if (this.props.dimension === "cube") {
-        return this.initializeCube(props);
-      }
-      let data = props.data;
-      if (data instanceof Promise) {
-        data.then(
-          (resolvedImageData) => this.initialize(
-            Object.assign({}, props, {
-              pixels: resolvedImageData,
-              data: resolvedImageData
-            })
-          )
-        );
-        return this;
-      }
-      const isVideo = typeof HTMLVideoElement !== "undefined" && data instanceof HTMLVideoElement;
-      if (isVideo && data.readyState < HTMLVideoElement.HAVE_METADATA) {
+  }
+  function copyCPUDataToMipLevel(gl, typedArray, options) {
+    const { dimension, width, height, depth = 0, level = 0, byteOffset = 0 } = options;
+    const { x = 0, y = 0, z = 0 } = options;
+    const { glFormat, glType, compressed } = options;
+    const glTarget = getWebGLCubeFaceTarget(options.glTarget, dimension, depth);
+    switch (dimension) {
+      case "2d-array":
+      case "3d":
+        if (compressed) {
+          gl.compressedTexSubImage3D(glTarget, level, x, y, z, width, height, depth, glFormat, typedArray, byteOffset);
+        } else {
+          gl.texSubImage3D(glTarget, level, x, y, z, width, height, depth, glFormat, glType, typedArray, byteOffset);
+        }
+        break;
+      case "2d":
+      case "cube":
+        if (compressed) {
+          gl.compressedTexSubImage2D(glTarget, level, x, y, width, height, glFormat, typedArray, byteOffset);
+        } else {
+          gl.texSubImage2D(glTarget, level, x, y, width, height, glFormat, glType, typedArray, byteOffset);
+        }
+        break;
+      default:
+        throw new Error(dimension);
+    }
+  }
+  function getWebGLTextureTarget(dimension) {
+    switch (dimension) {
+      case "1d":
+        break;
+      case "2d":
+        return 3553 /* TEXTURE_2D */;
+      case "3d":
+        return 32879 /* TEXTURE_3D */;
+      case "cube":
+        return 34067 /* TEXTURE_CUBE_MAP */;
+      case "2d-array":
+        return 35866 /* TEXTURE_2D_ARRAY */;
+      case "cube-array":
+        break;
+    }
+    throw new Error(dimension);
+  }
+  function getWebGLCubeFaceTarget(glTarget, dimension, level) {
+    return dimension === "cube" ? 34069 /* TEXTURE_CUBE_MAP_POSITIVE_X */ + level : glTarget;
+  }
+
+  // src/adapter/resources/webgl-texture.ts
+  function normalizeTextureData(data, options) {
+    let lodArray;
+    if (ArrayBuffer.isView(data)) {
+      lodArray = [
+        {
+          // ts-expect-error does data really need to be Uint8ClampedArray?
+          data,
+          width: options.width,
+          height: options.height
+          // depth: options.depth
+        }
+      ];
+    } else if (!Array.isArray(data)) {
+      lodArray = [data];
+    } else {
+      lodArray = data;
+    }
+    return lodArray;
+  }
+  var WEBGLTexture = class extends import_core7.Texture {
+    MAX_ATTRIBUTES;
+    device;
+    gl;
+    handle;
+    sampler = void 0;
+    // TODO - currently unused in WebGL. Create dummy sampler?
+    view = void 0;
+    // TODO - currently unused in WebGL. Create dummy view?
+    mipmaps = false;
+    /**
+     * @note `target` cannot be modified by bind:
+     * textures are special because when you first bind them to a target,
+     * When you first bind a texture as a GL_TEXTURE_2D, you are saying that this texture is a 2D texture.
+     * And it will always be a 2D texture; this state cannot be changed ever.
+     * A texture that was first bound as a GL_TEXTURE_2D, must always be bound as a GL_TEXTURE_2D;
+     * attempting to bind it as GL_TEXTURE_3D will give rise to a run-time error
+     */
+    glTarget;
+    // Texture type
+    /** The WebGL format - essentially channel structure */
+    glFormat;
+    /** The WebGL data format - the type of each channel */
+    glType;
+    /** The WebGL constant corresponding to the WebGPU style constant in format */
+    glInternalFormat;
+    /** Whether the internal format is compressed */
+    compressed;
+    // data;
+    // inherited props
+    // dimension: ...
+    // format: GLTextureTarget;
+    // width: number = undefined;
+    // height: number = undefined;
+    // depth: number = undefined;
+    // state
+    /** Texture binding slot */
+    textureUnit = 0;
+    /** For automatically updating video */
+    _video = null;
+    constructor(device, props) {
+      super(device, { ...import_core7.Texture.defaultProps, ...props, data: void 0 });
+      this.device = device;
+      this.gl = this.device.gl;
+      this.glTarget = getWebGLTextureTarget(this.props.dimension);
+      const format = getTextureFormatWebGL(this.props.format);
+      this.glInternalFormat = format.internalFormat;
+      this.glFormat = format.format;
+      this.glType = format.type;
+      this.compressed = format.compressed;
+      if (typeof HTMLVideoElement !== "undefined" && props.data instanceof HTMLVideoElement && // @ts-expect-error
+      props.data.readyState < HTMLVideoElement.HAVE_METADATA) {
+        const video = props.data;
         this._video = null;
-        data.addEventListener("loadeddata", () => this.initialize(props));
-        return this;
+        video.addEventListener("loadeddata", () => this.initialize(props));
       }
-      const { parameters = {} } = props;
-      const { pixels = null, pixelStore = {}, textureUnit = void 0, mipmaps = true } = props;
-      if (!data) {
-        data = pixels;
+      this.initialize({ ...this.props, data: props.data });
+      Object.seal(this);
+    }
+    /**
+     * Initialize texture with supplied props
+     */
+    // eslint-disable-next-line max-statements
+    initialize(props = {}) {
+      this.handle = this.props.handle || this.gl.createTexture();
+      this.device.setSpectorMetadata(this.handle, { ...this.props, data: typeof this.props.data });
+      const data = props.data;
+      let { width, height } = props;
+      if (!width || !height) {
+        const textureSize = import_core7.Texture.getTextureDataSize(data);
+        width = textureSize?.width || 1;
+        height = textureSize?.height || 1;
       }
-      let { width, height, dataFormat, type, compressed = false } = props;
-      const { depth = 0 } = props;
-      const glFormat = convertTextureFormatToGL(props.format);
-      ({ width, height, compressed, dataFormat, type } = this._deduceParameters({
-        format: props.format,
-        type,
-        dataFormat,
-        compressed,
-        data,
-        width,
-        height
-      }));
       this.width = width;
       this.height = height;
-      this.glFormat = glFormat;
-      this.type = type;
-      this.dataFormat = dataFormat;
-      this.textureUnit = textureUnit;
-      if (Number.isFinite(this.textureUnit)) {
-        this.gl.activeTexture(33984 /* TEXTURE0 */ + this.textureUnit);
-        this.gl.bindTexture(this.target, this.handle);
-      }
-      this.mipmaps = mipmaps;
-      this.setImageData({
-        data,
-        width,
-        height,
-        depth,
-        format: glFormat,
-        type,
-        dataFormat,
-        // @ts-expect-error
-        parameters: pixelStore,
-        compressed
-      });
+      this.depth = props.depth;
       this.setSampler(props.sampler);
-      this._setSamplerParameters(parameters);
-      this.view = this.createView({ ...this.props, mipLevelCount: 1, arrayLayerCount: 1 });
-      if (mipmaps && this.device.isTextureFormatFilterable(props.format)) {
+      this.view = new WEBGLTextureView(this.device, { ...this.props, texture: this });
+      this.bind();
+      if (!this.props.data) {
+        initializeTextureStorage(this.gl, this.mipLevels, this);
+      }
+      if (props.data) {
+        switch (props.dimension) {
+          case "1d":
+            this.setTexture1DData(props.data);
+            break;
+          case "2d":
+            this.setTexture2DData(props.data);
+            break;
+          case "3d":
+            this.setTexture3DData(props.data);
+            break;
+          case "cube":
+            this.setTextureCubeData(props.data);
+            break;
+          case "2d-array":
+            this.setTextureArrayData(props.data);
+            break;
+          case "cube-array":
+            this.setTextureCubeArrayData(props.data);
+            break;
+          default:
+            throw new Error(props.dimension);
+        }
+      }
+      this.mipmaps = Boolean(props.mipmaps);
+      if (this.mipmaps) {
         this.generateMipmap();
       }
-      if (isVideo) {
-        this._video = {
-          video: data,
-          parameters,
-          // @ts-expect-error
-          lastTime: data.readyState >= HTMLVideoElement.HAVE_CURRENT_DATA ? data.currentTime : -1
-        };
+    }
+    /*
+      initializeCube(props?: TextureProps): void {
+        const {mipmaps = true} = props; // , parameters = {} as Record<GL, any>} = props;
+    
+        // Store props for accessors
+        // this.props = props;
+    
+        // @ts-expect-error
+        this.setCubeMapData(props).then(() => {
+          // TODO - should genMipmap() be called on the cubemap or on the faces?
+          // TODO - without generateMipmap() cube textures do not work at all!!! Why?
+          if (mipmaps) {
+            this.generateMipmap(props);
+          }
+    
+          this.setSampler(props.sampler);
+    
+          // v8 compatibility?
+          // const {parameters = {} as Record<GL, any>} = props;
+          // this._setSamplerParameters(parameters);
+        });
+      }
+      */
+    destroy() {
+      if (this.handle) {
+        this.gl.deleteTexture(this.handle);
+        this.removeStats();
+        this.trackDeallocatedMemory("Texture");
+        this.destroyed = true;
       }
-      return this;
     }
-    initializeCube(props) {
-      const { mipmaps = true, parameters = {} } = props;
-      this.setCubeMapImageData(props).then(() => {
-        this.loaded = true;
-        if (mipmaps) {
-          this.generateMipmap(props);
-        }
-        this.setSampler(props.sampler);
-        this._setSamplerParameters(parameters);
-      });
-      return this;
+    toString() {
+      return `Texture(${this.id},${this.width}x${this.height})`;
+    }
+    createView(props) {
+      return new WEBGLTextureView(this.device, { ...props, texture: this });
     }
     setSampler(sampler = {}) {
       let samplerProps;
@@ -2918,377 +2826,102 @@ var __exports__ = (() => {
       }
       const parameters = convertSamplerParametersToWebGL(samplerProps);
       this._setSamplerParameters(parameters);
-      return this;
-    }
-    /**
-     * If size has changed, reinitializes with current format
-     * @note note clears image and mipmaps
-     */
-    resize(options) {
-      const { height, width, mipmaps = false } = options;
-      if (width !== this.width || height !== this.height) {
-        return this.initialize({
-          width,
-          height,
-          format: this.format,
-          type: this.type,
-          dataFormat: this.dataFormat,
-          mipmaps
-        });
-      }
-      return this;
     }
-    /** Update external texture (video frame) */
+    /** Update external texture (video frame or canvas) */
     update() {
-      if (this._video) {
-        const { video, parameters, lastTime } = this._video;
-        if (lastTime === video.currentTime || video.readyState < HTMLVideoElement.HAVE_CURRENT_DATA) {
-          return;
-        }
-        this.setSubImageData({
-          data: video,
-          parameters
-        });
-        if (this.mipmaps) {
-          this.generateMipmap();
-        }
-        this._video.lastTime = video.currentTime;
-      }
+      import_core7.log.warn("Texture.update() not implemented");
     }
     // Call to regenerate mipmaps after modifying texture(s)
     generateMipmap(params = {}) {
+      if (!this.props.data) {
+        return;
+      }
       this.mipmaps = true;
-      this.gl.bindTexture(this.target, this.handle);
+      this.gl.bindTexture(this.glTarget, this.handle);
       withGLParameters(this.gl, params, () => {
-        this.gl.generateMipmap(this.target);
+        this.gl.generateMipmap(this.glTarget);
       });
-      this.gl.bindTexture(this.target, null);
-      return this;
+      this.gl.bindTexture(this.glTarget, null);
     }
-    /*
-     * Allocates storage
-     * @param {*} pixels -
-     *  null - create empty texture of specified format
-     *  Typed array - init from image data in typed array
-     *  Buffer|WebGLBuffer - (WEBGL2) init from image data in WebGLBuffer
-     *  HTMLImageElement|Image - Inits with content of image. Auto width/height
-     *  HTMLCanvasElement - Inits with contents of canvas. Auto width/height
-     *  HTMLVideoElement - Creates video texture. Auto width/height
-     *
-     * @param  width -
-     * @param  height -
-     * @param  mipMapLevel -
-     * @param {GLenum} format - format of image data.
-     * @param {GLenum} type
-     *  - format of array (autodetect from type) or
-     *  - (WEBGL2) format of buffer
-     * @param {Number} offset - (WEBGL2) offset from start of buffer
-     * @parameters - temporary settings to be applied, can be used to supply pixel store settings.
-     */
-    // eslint-disable-next-line max-statements, complexity
-    setImageData(options) {
-      if (this.props.dimension === "3d" || this.props.dimension === "2d-array") {
-        return this.setImageData3D(options);
+    // Image Data Setters
+    copyExternalImage(options) {
+      const size = import_core7.Texture.getExternalImageSize(options.image);
+      const opts = { ...import_core7.Texture.defaultCopyExternalImageOptions, ...size, ...options };
+      const { depth, mipLevel: lodLevel, image } = opts;
+      this.bind();
+      this._setMipLevel(depth, lodLevel, image);
+      this.unbind();
+      return { width: opts.width, height: opts.height };
+    }
+    setTexture1DData(data) {
+      throw new Error("setTexture1DData not supported in WebGL.");
+    }
+    /** Set a simple texture */
+    setTexture2DData(lodData, depth = 0) {
+      this.bind();
+      const lodArray = normalizeTextureData(lodData, this);
+      if (lodArray.length > 1 && this.props.mipmaps !== false) {
+        import_core7.log.warn(`Texture ${this.id} mipmap and multiple LODs.`)();
       }
-      this.trackDeallocatedMemory("Texture");
-      const {
-        target = this.target,
-        pixels = null,
-        level = 0,
-        glFormat = this.glFormat,
-        offset = 0,
-        parameters = {}
-      } = options;
-      let {
-        data = null,
-        type = this.type,
-        width = this.width,
-        height = this.height,
-        dataFormat = this.dataFormat,
-        compressed = false
-      } = options;
-      if (!data) {
-        data = pixels;
+      for (let lodLevel = 0; lodLevel < lodArray.length; lodLevel++) {
+        const imageData = lodArray[lodLevel];
+        this._setMipLevel(depth, lodLevel, imageData);
       }
-      ({ type, dataFormat, compressed, width, height } = this._deduceParameters({
-        format: this.props.format,
-        type,
-        dataFormat,
-        compressed,
-        data,
-        width,
-        height
-      }));
-      const { gl } = this;
-      gl.bindTexture(this.target, this.handle);
-      let dataType = null;
-      ({ data, dataType } = this._getDataType({ data, compressed }));
-      withGLParameters(this.gl, parameters, () => {
-        switch (dataType) {
-          case "null":
-            gl.texImage2D(
-              target,
-              level,
-              glFormat,
-              width,
-              height,
-              0,
-              dataFormat,
-              type,
-              data
-            );
-            break;
-          case "typed-array":
-            gl.texImage2D(
-              target,
-              level,
-              glFormat,
-              width,
-              height,
-              0,
-              // border (must be 0)
-              dataFormat,
-              type,
-              data,
-              offset
-            );
-            break;
-          case "buffer":
-            this.device.gl.bindBuffer(35052 /* PIXEL_UNPACK_BUFFER */, data.handle || data);
-            this.device.gl.texImage2D(
-              target,
-              level,
-              glFormat,
-              width,
-              height,
-              0,
-              dataFormat,
-              type,
-              offset
-            );
-            this.device.gl.bindBuffer(35052 /* PIXEL_UNPACK_BUFFER */, null);
-            break;
-          case "browser-object":
-            gl.texImage2D(
-              target,
-              level,
-              glFormat,
-              width,
-              height,
-              0,
-              dataFormat,
-              type,
-              data
-            );
-            break;
-          case "compressed":
-            for (const [levelIndex, levelData] of data.entries()) {
-              gl.compressedTexImage2D(
-                target,
-                levelIndex,
-                levelData.format,
-                levelData.width,
-                levelData.height,
-                0,
-                levelData.data
-              );
-            }
-            break;
-          default:
-            (0, import_core9.assert)(false, "Unknown image data type");
-        }
-      });
-      if (data && data.byteLength) {
-        this.trackAllocatedMemory(data.byteLength, "Texture");
-      } else {
-        const bytesPerPixel = getTextureFormatBytesPerPixel(this.props.format);
-        this.trackAllocatedMemory(this.width * this.height * bytesPerPixel, "Texture");
-      }
-      this.loaded = true;
-      return this;
+      this.unbind();
     }
     /**
-     * Redefines an area of an existing texture
-     * Note: does not allocate storage
-     * Redefines an area of an existing texture
+     * Sets a 3D texture
+     * @param data
      */
-    setSubImageData({
-      target = this.target,
-      pixels = null,
-      data = null,
-      x = 0,
-      y = 0,
-      width = this.width,
-      height = this.height,
-      level = 0,
-      glFormat = this.glFormat,
-      type = this.type,
-      dataFormat = this.dataFormat,
-      compressed = false,
-      offset = 0,
-      parameters = {}
-    }) {
-      ({ type, dataFormat, compressed, width, height } = this._deduceParameters({
-        format: this.props.format,
-        type,
-        dataFormat,
-        compressed,
-        data,
-        width,
-        height
-      }));
-      (0, import_core9.assert)(this.depth === 1, "texSubImage not supported for 3D textures");
-      if (!data) {
-        data = pixels;
-      }
-      if (data && data.data) {
-        const ndarray = data;
-        data = ndarray.data;
-        width = ndarray.shape[0];
-        height = ndarray.shape[1];
+    setTexture3DData(data) {
+      if (this.props.dimension !== "3d") {
+        throw new Error(this.id);
       }
-      if (data instanceof WEBGLBuffer) {
-        data = data.handle;
+      if (ArrayBuffer.isView(data)) {
+        this.bind();
+        copyCPUDataToMipLevel(this.device.gl, data, this);
+        this.unbind();
       }
-      this.gl.bindTexture(this.target, this.handle);
-      withGLParameters(this.gl, parameters, () => {
-        if (compressed) {
-          this.gl.compressedTexSubImage2D(target, level, x, y, width, height, glFormat, data);
-        } else if (data === null) {
-          this.gl.texSubImage2D(target, level, x, y, width, height, dataFormat, type, null);
-        } else if (ArrayBuffer.isView(data)) {
-          this.gl.texSubImage2D(target, level, x, y, width, height, dataFormat, type, data, offset);
-        } else if (typeof WebGLBuffer !== "undefined" && data instanceof WebGLBuffer) {
-          this.device.gl.bindBuffer(35052 /* PIXEL_UNPACK_BUFFER */, data);
-          this.device.gl.texSubImage2D(target, level, x, y, width, height, dataFormat, type, offset);
-          this.device.gl.bindBuffer(35052 /* PIXEL_UNPACK_BUFFER */, null);
-        } else {
-          this.device.gl.texSubImage2D(target, level, x, y, width, height, dataFormat, type, data);
-        }
-      });
-      this.gl.bindTexture(this.target, null);
     }
     /**
-     * Defines a two-dimensional texture image or cube-map texture image with
-     * pixels from the current framebuffer (rather than from client memory).
-     * (gl.copyTexImage2D wrapper)
-     *
-     * Note that binding a texture into a Framebuffer's color buffer and
-     * rendering can be faster.
+     * Set a Texture Cube Data
+     * @todo - could support TextureCubeArray with depth
+     * @param data
+     * @param index
      */
-    copyFramebuffer(opts = {}) {
-      import_core9.log.error(
-        "Texture.copyFramebuffer({...}) is no logner supported, use copyToTexture(source, target, opts})"
-      )();
-      return null;
-    }
-    getActiveUnit() {
-      return this.gl.getParameter(34016 /* ACTIVE_TEXTURE */) - 33984 /* TEXTURE0 */;
-    }
-    bind(textureUnit = this.textureUnit) {
-      const { gl } = this;
-      if (textureUnit !== void 0) {
-        this.textureUnit = textureUnit;
-        gl.activeTexture(gl.TEXTURE0 + textureUnit);
+    setTextureCubeData(data, depth = 0) {
+      if (this.props.dimension !== "cube") {
+        throw new Error(this.id);
       }
-      gl.bindTexture(this.target, this.handle);
-      return textureUnit;
-    }
-    unbind(textureUnit = this.textureUnit) {
-      const { gl } = this;
-      if (textureUnit !== void 0) {
-        this.textureUnit = textureUnit;
-        gl.activeTexture(gl.TEXTURE0 + textureUnit);
+      for (const face of import_core7.Texture.CubeFaces) {
+        this.setTextureCubeFaceData(data[face], face);
       }
-      gl.bindTexture(this.target, null);
-      return textureUnit;
     }
-    // PRIVATE METHODS
-    _getDataType({ data, compressed = false }) {
-      if (compressed) {
-        return { data, dataType: "compressed" };
-      }
-      if (data === null) {
-        return { data, dataType: "null" };
-      }
-      if (ArrayBuffer.isView(data)) {
-        return { data, dataType: "typed-array" };
-      }
-      if (data instanceof WEBGLBuffer) {
-        return { data: data.handle, dataType: "buffer" };
-      }
-      if (typeof WebGLBuffer !== "undefined" && data instanceof WebGLBuffer) {
-        return { data, dataType: "buffer" };
-      }
-      return { data, dataType: "browser-object" };
-    }
-    // HELPER METHODS
-    _deduceParameters(opts) {
-      const { format, data } = opts;
-      let { width, height, dataFormat, type, compressed } = opts;
-      const parameters = getWebGLTextureParameters(format);
-      dataFormat = dataFormat || parameters.dataFormat;
-      type = type || parameters.type;
-      compressed = compressed || parameters.compressed;
-      ({ width, height } = this._deduceImageSize(data, width, height));
-      return { dataFormat, type, compressed, width, height, format, data };
-    }
-    // eslint-disable-next-line complexity
-    _deduceImageSize(data, width, height) {
-      let size;
-      if (typeof ImageData !== "undefined" && data instanceof ImageData) {
-        size = { width: data.width, height: data.height };
-      } else if (typeof HTMLImageElement !== "undefined" && data instanceof HTMLImageElement) {
-        size = { width: data.naturalWidth, height: data.naturalHeight };
-      } else if (typeof HTMLCanvasElement !== "undefined" && data instanceof HTMLCanvasElement) {
-        size = { width: data.width, height: data.height };
-      } else if (typeof ImageBitmap !== "undefined" && data instanceof ImageBitmap) {
-        size = { width: data.width, height: data.height };
-      } else if (typeof HTMLVideoElement !== "undefined" && data instanceof HTMLVideoElement) {
-        size = { width: data.videoWidth, height: data.videoHeight };
-      } else if (!data) {
-        size = { width: width >= 0 ? width : 1, height: height >= 0 ? height : 1 };
-      } else {
-        size = { width, height };
+    /**
+     * Sets an entire texture array
+     * @param data
+     */
+    setTextureArrayData(data) {
+      if (this.props.dimension !== "2d-array") {
+        throw new Error(this.id);
       }
-      (0, import_core9.assert)(size, "Could not deduced texture size");
-      (0, import_core9.assert)(
-        width === void 0 || size.width === width,
-        "Deduced texture width does not match supplied width"
-      );
-      (0, import_core9.assert)(
-        height === void 0 || size.height === height,
-        "Deduced texture height does not match supplied height"
-      );
-      return size;
+      throw new Error("setTextureArrayData not implemented.");
     }
-    // CUBE MAP METHODS
-    /* eslint-disable max-statements, max-len */
-    async setCubeMapImageData(options) {
-      const { gl } = this;
-      const { width, height, pixels, data, format = 6408 /* RGBA */, type = 5121 /* UNSIGNED_BYTE */ } = options;
-      const imageDataMap = pixels || data;
-      const resolvedFaces = await Promise.all(
-        _WEBGLTexture.FACES.map((face) => {
-          const facePixels = imageDataMap[face];
-          return Promise.all(Array.isArray(facePixels) ? facePixels : [facePixels]);
-        })
-      );
-      this.bind();
-      _WEBGLTexture.FACES.forEach((face, index) => {
-        if (resolvedFaces[index].length > 1 && this.props.mipmaps !== false) {
-          import_core9.log.warn(`${this.id} has mipmap and multiple LODs.`)();
-        }
-        resolvedFaces[index].forEach((image, lodLevel) => {
-          if (width && height) {
-            gl.texImage2D(face, lodLevel, format, width, height, 0, format, type, image);
-          } else {
-            gl.texImage2D(face, lodLevel, format, format, type, image);
-          }
-        });
-      });
-      this.unbind();
+    /**
+     * Sets an entire texture cube array
+     * @param data
+     */
+    setTextureCubeArrayData(data) {
+      throw new Error("setTextureCubeArrayData not supported in WebGL2.");
     }
+    setTextureCubeFaceData(lodData, face, depth = 0) {
+      if (Array.isArray(lodData) && lodData.length > 1 && this.props.mipmaps !== false) {
+        import_core7.log.warn(`${this.id} has mipmap and multiple LODs.`)();
+      }
+      const faceDepth = import_core7.Texture.CubeFaces.indexOf(face);
+      this.setTexture2DData(lodData, faceDepth);
+    }
+    // INTERNAL METHODS
     /** @todo update this method to accept LODs */
     setImageDataForFace(options) {
       const {
@@ -3319,132 +2952,158 @@ var __exports__ = (() => {
       } else {
         gl.texImage2D(face, 0, format, format, type, imageData);
       }
-      return this;
     }
-    /** Image 3D copies from Typed Array or WebGLBuffer */
-    setImageData3D(options) {
-      const {
-        level = 0,
-        dataFormat,
-        format,
-        type,
-        // = GL.UNSIGNED_BYTE,
-        width,
-        height,
-        depth = 1,
-        offset = 0,
-        data,
-        parameters = {}
-      } = options;
-      this.trackDeallocatedMemory("Texture");
-      this.gl.bindTexture(this.target, this.handle);
-      const webglTextureFormat = getWebGLTextureParameters(format);
-      withGLParameters(this.gl, parameters, () => {
-        if (ArrayBuffer.isView(data)) {
-          this.gl.texImage3D(
-            this.target,
-            level,
-            webglTextureFormat.format,
-            width,
-            height,
-            depth,
-            0,
-            webglTextureFormat.dataFormat,
-            webglTextureFormat.type,
-            // dataType: getWebGL,
-            data
-          );
+    _getImageDataMap(faceData) {
+      for (let i = 0; i < import_core7.Texture.CubeFaces.length; ++i) {
+        const faceName = import_core7.Texture.CubeFaces[i];
+        if (faceData[faceName]) {
+          faceData[34069 /* TEXTURE_CUBE_MAP_POSITIVE_X */ + i] = faceData[faceName];
+          delete faceData[faceName];
         }
-        if (data instanceof WEBGLBuffer) {
-          this.gl.bindBuffer(35052 /* PIXEL_UNPACK_BUFFER */, data.handle);
-          this.gl.texImage3D(
-            this.target,
-            level,
-            dataFormat,
-            width,
-            height,
-            depth,
-            0,
-            format,
-            type,
-            offset
-          );
-        }
-      });
-      if (data && data.byteLength) {
-        this.trackAllocatedMemory(data.byteLength, "Texture");
-      } else {
-        const bytesPerPixel = getTextureFormatBytesPerPixel(this.props.format);
-        this.trackAllocatedMemory(this.width * this.height * this.depth * bytesPerPixel, "Texture");
       }
-      this.loaded = true;
-      return this;
+      return faceData;
     }
     // RESOURCE METHODS
     /**
      * Sets sampler parameters on texture
      */
     _setSamplerParameters(parameters) {
-      if ((0, import_core9.isObjectEmpty)(parameters)) {
-        return;
-      }
-      logParameters(parameters);
-      this.gl.bindTexture(this.target, this.handle);
+      import_core7.log.log(1, "texture sampler parameters", parameters)();
+      this.gl.bindTexture(this.glTarget, this.handle);
       for (const [pname, pvalue] of Object.entries(parameters)) {
         const param = Number(pname);
         const value = pvalue;
         switch (param) {
           case 33082 /* TEXTURE_MIN_LOD */:
           case 33083 /* TEXTURE_MAX_LOD */:
-            this.gl.texParameterf(this.target, param, value);
+            this.gl.texParameterf(this.glTarget, param, value);
+            break;
+          case 10241 /* TEXTURE_MIN_FILTER */:
+            this.gl.texParameteri(this.glTarget, param, value);
+            break;
+          case 10242 /* TEXTURE_WRAP_S */:
+          case 10243 /* TEXTURE_WRAP_T */:
+            this.gl.texParameteri(this.glTarget, param, value);
+            break;
+          case 34046 /* TEXTURE_MAX_ANISOTROPY_EXT */:
+            if (this.device.features.has("texture-filterable-anisotropic-webgl")) {
+              this.gl.texParameteri(this.glTarget, param, value);
+            }
             break;
           default:
-            this.gl.texParameteri(this.target, param, value);
+            this.gl.texParameteri(this.glTarget, param, value);
             break;
         }
       }
-      this.gl.bindTexture(this.target, null);
-      return;
+      this.gl.bindTexture(this.glTarget, null);
     }
-  };
-  var WEBGLTexture = _WEBGLTexture;
-  // TODO - remove?
-  __publicField(WEBGLTexture, "FACES", [
-    34069 /* TEXTURE_CUBE_MAP_POSITIVE_X */,
-    34070 /* TEXTURE_CUBE_MAP_NEGATIVE_X */,
-    34071 /* TEXTURE_CUBE_MAP_POSITIVE_Y */,
-    34072 /* TEXTURE_CUBE_MAP_NEGATIVE_Y */,
-    34073 /* TEXTURE_CUBE_MAP_POSITIVE_Z */,
-    34074 /* TEXTURE_CUBE_MAP_NEGATIVE_Z */
-  ]);
-  function getWebGLTextureTarget(props) {
-    switch (props.dimension) {
-      case "2d":
-        return 3553 /* TEXTURE_2D */;
-      case "cube":
-        return 34067 /* TEXTURE_CUBE_MAP */;
-      case "2d-array":
-        return 35866 /* TEXTURE_2D_ARRAY */;
-      case "3d":
-        return 32879 /* TEXTURE_3D */;
-      case "1d":
-      case "cube-array":
-      default:
-        throw new Error(props.dimension);
+    // CLASSIC
+    /*
+      setCubeMapData(options: {
+        width: number;
+        height: number;
+        data: Record<GL, Texture2DData> | Record<TextureCubeFace, Texture2DData>;
+        format?: any;
+        type?: any;
+        /** @deprecated Use .data *
+        pixels: any;
+      }): void {
+        const {gl} = this;
+    
+        const {width, height, pixels, data, format = GL.RGBA, type = GL.UNSIGNED_BYTE} = options;
+    
+        // pixel data (imageDataMap) is an Object from Face to Image or Promise.
+        // For example:
+        // {
+        // GL.TEXTURE_CUBE_MAP_POSITIVE_X : Image-or-Promise,
+        // GL.TEXTURE_CUBE_MAP_NEGATIVE_X : Image-or-Promise,
+        // ... }
+        // To provide multiple level-of-details (LODs) this can be Face to Array
+        // of Image or Promise, like this
+        // {
+        // GL.TEXTURE_CUBE_MAP_POSITIVE_X : [Image-or-Promise-LOD-0, Image-or-Promise-LOD-1],
+        // GL.TEXTURE_CUBE_MAP_NEGATIVE_X : [Image-or-Promise-LOD-0, Image-or-Promise-LOD-1],
+        // ... }
+    
+        const imageDataMap = this._getImageDataMap(pixels || data);
+    
+        const resolvedFaces = WEBGLTexture.FACES.map(face => {
+          const facePixels = imageDataMap[face];
+          return Array.isArray(facePixels) ? facePixels : [facePixels];
+        });
+        this.bind();
+    
+        WEBGLTexture.FACES.forEach((face, index) => {
+          if (resolvedFaces[index].length > 1 && this.props.mipmaps !== false) {
+            // If the user provides multiple LODs, then automatic mipmap
+            // generation generateMipmap() should be disabled to avoid overwritting them.
+            log.warn(`${this.id} has mipmap and multiple LODs.`)();
+          }
+          resolvedFaces[index].forEach((image, lodLevel) => {
+            // TODO: adjust width & height for LOD!
+            if (width && height) {
+              gl.texImage2D(face, lodLevel, format, width, height, 0 /* border*, format, type, image);
+            } else {
+              gl.texImage2D(face, lodLevel, format, format, type, image);
+            }
+          });
+        });
+    
+        this.unbind();
+      }
+      */
+    // INTERNAL SETTERS
+    /**
+     * Copy a region of data from a CPU memory buffer into this texture.
+     * @todo -   GLUnpackParameters parameters
+     */
+    _setMipLevel(depth, level, textureData, glTarget = this.glTarget) {
+      if (import_core7.Texture.isExternalImage(textureData)) {
+        copyCPUImageToMipLevel(this.device.gl, textureData, { ...this, depth, level, glTarget });
+        return;
+      }
+      if (import_core7.Texture.isTextureLevelData(textureData)) {
+        copyCPUDataToMipLevel(this.device.gl, textureData.data, {
+          ...this,
+          depth,
+          level,
+          glTarget
+        });
+        return;
+      }
+      throw new Error("Texture: invalid image data");
     }
-  }
-  function logParameters(parameters) {
-    import_core9.log.log(1, "texture sampler parameters", parameters)();
-  }
+    // HELPERS
+    getActiveUnit() {
+      return this.gl.getParameter(34016 /* ACTIVE_TEXTURE */) - 33984 /* TEXTURE0 */;
+    }
+    bind(textureUnit) {
+      const { gl } = this;
+      if (textureUnit !== void 0) {
+        this.textureUnit = textureUnit;
+        gl.activeTexture(gl.TEXTURE0 + textureUnit);
+      }
+      gl.bindTexture(this.glTarget, this.handle);
+      return textureUnit;
+    }
+    unbind(textureUnit) {
+      const { gl } = this;
+      if (textureUnit !== void 0) {
+        this.textureUnit = textureUnit;
+        gl.activeTexture(gl.TEXTURE0 + textureUnit);
+      }
+      gl.bindTexture(this.glTarget, null);
+      return textureUnit;
+    }
+  };
 
   // src/adapter/resources/webgl-framebuffer.ts
-  var WEBGLFramebuffer = class extends import_core10.Framebuffer {
+  var WEBGLFramebuffer = class extends import_core8.Framebuffer {
     device;
     gl;
     handle;
-    get texture() {
-      return this.colorAttachments[0];
-    }
+    colorAttachments = [];
+    depthStencilAttachment = null;
     constructor(device, props) {
       super(device, props);
       const isDefaultFramebuffer = props.handle === null;
@@ -3462,11 +3121,11 @@ var __exports__ = (() => {
           const attachment = this.colorAttachments[i];
           const attachmentPoint = 36064 /* COLOR_ATTACHMENT0 */ + i;
           if (attachment) {
-            this._attachOne(attachmentPoint, attachment);
+            this._attachTexture(attachmentPoint, attachment);
           }
         }
         if (this.depthStencilAttachment) {
-          this._attachOne(
+          this._attachTexture(
             getDepthStencilAttachmentWebGL(this.depthStencilAttachment.props.format),
             this.depthStencilAttachment
           );
@@ -3499,73 +3158,55 @@ var __exports__ = (() => {
       });
     }
     /**
-     * Attachment resize is expected to be a noop if size is same
-     */
-    resizeAttachments(width, height) {
-      if (this.handle === null) {
-        this.width = this.gl.drawingBufferWidth;
-        this.height = this.gl.drawingBufferHeight;
+       * Attachment resize is expected to be a noop if size is same
+       *
+      protected override resizeAttachments(width: number, height: number): this {
+        // for default framebuffer, just update the stored size
+        if (this.handle === null) {
+          // assert(width === undefined && height === undefined);
+          this.width = this.gl.drawingBufferWidth;
+          this.height = this.gl.drawingBufferHeight;
+          return this;
+        }
+    
+        if (width === undefined) {
+          width = this.gl.drawingBufferWidth;
+        }
+        if (height === undefined) {
+          height = this.gl.drawingBufferHeight;
+        }
+    
+        // TODO Not clear that this is better than default destroy/create implementation
+    
+        for (const colorAttachment of this.colorAttachments) {
+          colorAttachment.texture.clone({width, height});
+        }
+        if (this.depthStencilAttachment) {
+          this.depthStencilAttachment.texture.resize({width, height});
+        }
         return this;
       }
-      if (width === void 0) {
-        width = this.gl.drawingBufferWidth;
-      }
-      if (height === void 0) {
-        height = this.gl.drawingBufferHeight;
-      }
-      for (const colorAttachment of this.colorAttachments) {
-        colorAttachment.texture.resize({ width, height });
-      }
-      if (this.depthStencilAttachment) {
-        this.depthStencilAttachment.texture.resize({ width, height });
-      }
-      return this;
-    }
+      */
     /** Attach one attachment */
-    _attachOne(attachmentPoint, attachment) {
-      if (Array.isArray(attachment)) {
-        const [texture, layer = 0, level = 0] = attachment;
-        this._attachTexture(attachmentPoint, texture, layer, level);
-        return texture;
-      }
-      if (attachment instanceof WEBGLTexture) {
-        this._attachTexture(attachmentPoint, attachment, 0, 0);
-        return attachment;
-      }
-      if (attachment instanceof WEBGLTextureView) {
-        const textureView = attachment;
-        this._attachTexture(
-          attachmentPoint,
-          textureView.texture,
-          textureView.props.baseMipLevel,
-          textureView.props.baseArrayLayer
-        );
-        return attachment.texture;
-      }
-      throw new Error("attach");
-    }
-    // TODO - we do not seem to need render buffers in WebGL 2
-    // protected _attachWEBGLRenderbuffer(attachment: GL, renderbuffer: WEBGLRenderbuffer): void {
-    //   this.gl.framebufferRenderbuffer(
-    //     GL.FRAMEBUFFER,
-    //     attachment,
-    //     GL.RENDERBUFFER,
-    //     renderbuffer.handle
-    //   );
-    // }
+    _attachTexture(attachmentPoint, textureView) {
+      this._attachTextureView(attachmentPoint, textureView);
+    }
     /**
      * @param attachment
      * @param texture
      * @param layer = 0 - index into WEBGLTextureArray and Texture3D or face for `TextureCubeMap`
      * @param level = 0 - mipmapLevel
      */
-    _attachTexture(attachment, texture, layer, level) {
+    _attachTextureView(attachment, textureView) {
       const { gl } = this.device;
-      gl.bindTexture(texture.target, texture.handle);
-      switch (texture.target) {
+      const { texture } = textureView;
+      const level = textureView.props.baseMipLevel;
+      const layer = textureView.props.baseArrayLayer;
+      gl.bindTexture(texture.glTarget, texture.handle);
+      switch (texture.glTarget) {
         case 35866 /* TEXTURE_2D_ARRAY */:
         case 32879 /* TEXTURE_3D */:
-          gl.framebufferTextureLayer(36160 /* FRAMEBUFFER */, attachment, texture.target, level, layer);
+          gl.framebufferTextureLayer(36160 /* FRAMEBUFFER */, attachment, texture.handle, level, layer);
           break;
         case 34067 /* TEXTURE_CUBE_MAP */:
           const face = mapIndexToCubeMapFace(layer);
@@ -3575,9 +3216,9 @@ var __exports__ = (() => {
           gl.framebufferTexture2D(36160 /* FRAMEBUFFER */, attachment, 3553 /* TEXTURE_2D */, texture.handle, level);
           break;
         default:
-          (0, import_core10.assert)(false, "Illegal texture type");
+          throw new Error("Illegal texture type");
       }
-      gl.bindTexture(texture.target, null);
+      gl.bindTexture(texture.glTarget, null);
     }
   };
   function mapIndexToCubeMapFace(layer) {
@@ -3603,8 +3244,10 @@ var __exports__ = (() => {
   }
 
   // src/adapter/webgl-canvas-context.ts
-  var WebGLCanvasContext = class extends import_core11.CanvasContext {
+  var WebGLCanvasContext = class extends import_core9.CanvasContext {
     device;
+    format = "rgba8unorm";
+    depthStencilFormat = "depth24plus";
     presentationSize;
     _framebuffer = null;
     constructor(device, props) {
@@ -3654,31 +3297,57 @@ var __exports__ = (() => {
   };
 
   // src/context/debug/spector.ts
-  var import_core12 = __toESM(require_core(), 1);
-  var DEFAULT_SPECTOR_PROPS = {
-    spector: import_core12.log.get("spector") || import_core12.log.get("spectorjs")
-  };
-  var SPECTOR_CDN_URL = "https://cdn.jsdelivr.net/npm/spectorjs@0.9.30/dist/spector.bundle.js";
+  var import_core10 = __toESM(require_core(), 1);
+
+  // src/utils/load-script.ts
+  async function loadScript(scriptUrl, scriptId) {
+    const head = document.getElementsByTagName("head")[0];
+    if (!head) {
+      throw new Error("loadScript");
+    }
+    const script = document.createElement("script");
+    script.setAttribute("type", "text/javascript");
+    script.setAttribute("src", scriptUrl);
+    if (scriptId) {
+      script.id = scriptId;
+    }
+    return new Promise((resolve, reject) => {
+      script.onload = resolve;
+      script.onerror = (error) => reject(new Error(`Unable to load script '${scriptUrl}': ${error}`));
+      head.appendChild(script);
+    });
+  }
+
+  // src/context/debug/spector.ts
   var LOG_LEVEL = 1;
   var spector = null;
   var initialized = false;
+  var DEFAULT_SPECTOR_PROPS = {
+    debugWithSpectorJS: import_core10.log.get("spector") || import_core10.log.get("spectorjs"),
+    // https://github.com/BabylonJS/Spector.js#basic-usage
+    // https://forum.babylonjs.com/t/spectorcdn-is-temporarily-off/48241
+    // spectorUrl: 'https://spectorcdn.babylonjs.com/spector.bundle.js';
+    spectorUrl: "https://cdn.jsdelivr.net/npm/spectorjs@0.9.30/dist/spector.bundle.js",
+    gl: void 0
+  };
   async function loadSpectorJS(props) {
     if (!globalThis.SPECTOR) {
       try {
-        await (0, import_core12.loadScript)(SPECTOR_CDN_URL);
+        await loadScript(props.spectorUrl || DEFAULT_SPECTOR_PROPS.spectorUrl);
       } catch (error) {
-        import_core12.log.warn(String(error));
+        import_core10.log.warn(String(error));
       }
     }
   }
   function initializeSpectorJS(props) {
     props = { ...DEFAULT_SPECTOR_PROPS, ...props };
-    if (!props?.spector) {
+    if (!props.debugWithSpectorJS) {
       return null;
     }
-    if (!spector && globalThis.SPECTOR) {
-      import_core12.log.probe(LOG_LEVEL, "SPECTOR found and initialized")();
-      spector = new globalThis.SPECTOR.Spector();
+    if (!spector && globalThis.SPECTOR && !globalThis.luma?.spector) {
+      import_core10.log.probe(LOG_LEVEL, "SPECTOR found and initialized. Start with `luma.spector.displayUI()`")();
+      const { Spector } = globalThis.SPECTOR;
+      spector = new Spector();
       if (globalThis.luma) {
         globalThis.luma.spector = spector;
       }
@@ -3690,22 +3359,22 @@ var __exports__ = (() => {
       initialized = true;
       spector.spyCanvases();
       spector?.onCaptureStarted.add(
-        (capture) => import_core12.log.info("Spector capture started:", capture)()
+        (capture) => import_core10.log.info("Spector capture started:", capture)()
       );
       spector?.onCapture.add((capture) => {
-        import_core12.log.info("Spector capture complete:", capture)();
+        import_core10.log.info("Spector capture complete:", capture)();
         spector?.getResultUI();
         spector?.resultView.display();
         spector?.resultView.addCapture(capture);
       });
     }
-    if (props?.canvas) {
-      if (typeof props.spector === "string" && props.spector !== props.canvas.id) {
-        return spector;
-      }
-      spector?.startCapture(props?.canvas, 500);
+    if (props.gl) {
+      const gl = props.gl;
+      const device = gl.device;
+      spector?.startCapture(props.gl, 500);
+      gl.device = device;
       new Promise((resolve) => setTimeout(resolve, 2e3)).then((_) => {
-        import_core12.log.info("Spector capture stopped after 2 seconds")();
+        import_core10.log.info("Spector capture stopped after 2 seconds")();
         spector?.stopCapture();
       });
     }
@@ -3713,7 +3382,7 @@ var __exports__ = (() => {
   }
 
   // src/context/debug/webgl-developer-tools.ts
-  var import_core13 = __toESM(require_core(), 1);
+  var import_core11 = __toESM(require_core(), 1);
 
   // ../../node_modules/@probe.gl/env/dist/lib/globals.js
   var document_ = globalThis.document || {};
@@ -3777,13 +3446,10 @@ var __exports__ = (() => {
     if (isBrowser() && !globalThis.WebGLDebugUtils) {
       globalThis.global = globalThis.global || globalThis;
       globalThis.global.module = {};
-      await (0, import_core13.loadScript)(WEBGL_DEBUG_CDN_URL);
+      await loadScript(WEBGL_DEBUG_CDN_URL);
     }
   }
   function makeDebugContext(gl, props = {}) {
-    if (!gl) {
-      return null;
-    }
     return props.debug ? getDebugContext(gl, props) : getRealContext(gl);
   }
   function getRealContext(gl) {
@@ -3792,7 +3458,7 @@ var __exports__ = (() => {
   }
   function getDebugContext(gl, props) {
     if (!globalThis.WebGLDebugUtils) {
-      import_core13.log.warn("webgl-debug not loaded")();
+      import_core11.log.warn("webgl-debug not loaded")();
       return gl;
     }
     const data = getWebGLContextData(gl);
@@ -3831,7 +3497,7 @@ var __exports__ = (() => {
     const errorMessage = globalThis.WebGLDebugUtils.glEnumToString(err);
     const functionArgs = globalThis.WebGLDebugUtils.glFunctionArgsToString(functionName, args);
     const message2 = `${errorMessage} in gl.${functionName}(${functionArgs})`;
-    import_core13.log.error(message2)();
+    import_core11.log.error(message2)();
     debugger;
     if (props.throwOnError) {
       throw new Error(message2);
@@ -3839,9 +3505,9 @@ var __exports__ = (() => {
   }
   function onValidateGLFunc(props, functionName, functionArgs) {
     let functionString = "";
-    if (import_core13.log.level >= 1) {
+    if (import_core11.log.level >= 1) {
       functionString = getFunctionString(functionName, functionArgs);
-      import_core13.log.log(1, functionString)();
+      import_core11.log.log(1, functionString)();
     }
     if (props.break && props.break.length > 0) {
       functionString = functionString || getFunctionString(functionName, functionArgs);
@@ -3858,15 +3524,147 @@ var __exports__ = (() => {
         if (props.throwOnError) {
           throw new Error(`Undefined argument: ${functionString}`);
         } else {
-          import_core13.log.error(`Undefined argument: ${functionString}`)();
+          import_core11.log.error(`Undefined argument: ${functionString}`)();
           debugger;
         }
       }
     }
   }
 
+  // src/utils/uid.ts
+  var uidCounters = {};
+  function uid(id = "id") {
+    uidCounters[id] = uidCounters[id] || 1;
+    const count = uidCounters[id]++;
+    return `${id}-${count}`;
+  }
+
+  // src/adapter/resources/webgl-buffer.ts
+  var import_core12 = __toESM(require_core(), 1);
+  var WEBGLBuffer = class extends import_core12.Buffer {
+    device;
+    gl;
+    handle;
+    /** Target in OpenGL defines the type of buffer */
+    glTarget;
+    /** Usage is a hint on how frequently the buffer will be updates */
+    glUsage;
+    /** Index type is needed when issuing draw calls, so we pre-compute it */
+    glIndexType = 5123 /* UNSIGNED_SHORT */;
+    /** Number of bytes allocated on the GPU for this buffer */
+    byteLength;
+    /** Number of bytes used */
+    bytesUsed;
+    constructor(device, props = {}) {
+      super(device, props);
+      this.device = device;
+      this.gl = this.device.gl;
+      const handle = typeof props === "object" ? props.handle : void 0;
+      this.handle = handle || this.gl.createBuffer();
+      device.setSpectorMetadata(this.handle, { ...this.props, data: typeof this.props.data });
+      this.glTarget = getWebGLTarget(this.props.usage);
+      this.glUsage = getWebGLUsage(this.props.usage);
+      this.glIndexType = this.props.indexType === "uint32" ? 5125 /* UNSIGNED_INT */ : 5123 /* UNSIGNED_SHORT */;
+      if (props.data) {
+        this._initWithData(props.data, props.byteOffset, props.byteLength);
+      } else {
+        this._initWithByteLength(props.byteLength || 0);
+      }
+    }
+    // PRIVATE METHODS
+    /** Allocate a new buffer and initialize to contents of typed array */
+    _initWithData(data, byteOffset = 0, byteLength = data.byteLength + byteOffset) {
+      const glTarget = this.glTarget;
+      this.gl.bindBuffer(glTarget, this.handle);
+      this.gl.bufferData(glTarget, byteLength, this.glUsage);
+      this.gl.bufferSubData(glTarget, byteOffset, data);
+      this.gl.bindBuffer(glTarget, null);
+      this.bytesUsed = byteLength;
+      this.byteLength = byteLength;
+      this._setDebugData(data, byteOffset, byteLength);
+      this.trackAllocatedMemory(byteLength);
+    }
+    // Allocate a GPU buffer of specified size.
+    _initWithByteLength(byteLength) {
+      let data = byteLength;
+      if (byteLength === 0) {
+        data = new Float32Array(0);
+      }
+      const glTarget = this.glTarget;
+      this.gl.bindBuffer(glTarget, this.handle);
+      this.gl.bufferData(glTarget, data, this.glUsage);
+      this.gl.bindBuffer(glTarget, null);
+      this.bytesUsed = byteLength;
+      this.byteLength = byteLength;
+      this._setDebugData(null, 0, byteLength);
+      this.trackAllocatedMemory(byteLength);
+      return this;
+    }
+    destroy() {
+      if (!this.destroyed && this.handle) {
+        this.removeStats();
+        this.trackDeallocatedMemory();
+        this.gl.deleteBuffer(this.handle);
+        this.destroyed = true;
+        this.handle = null;
+      }
+    }
+    write(data, byteOffset = 0) {
+      const srcOffset = 0;
+      const byteLength = void 0;
+      const glTarget = 36663 /* COPY_WRITE_BUFFER */;
+      this.gl.bindBuffer(glTarget, this.handle);
+      if (srcOffset !== 0 || byteLength !== void 0) {
+        this.gl.bufferSubData(glTarget, byteOffset, data, srcOffset, byteLength);
+      } else {
+        this.gl.bufferSubData(glTarget, byteOffset, data);
+      }
+      this.gl.bindBuffer(glTarget, null);
+      this._setDebugData(data, byteOffset, data.byteLength);
+    }
+    /** Asynchronously read data from the buffer */
+    async readAsync(byteOffset = 0, byteLength) {
+      return this.readSyncWebGL(byteOffset, byteLength);
+    }
+    /** Synchronously read data from the buffer. WebGL only. */
+    readSyncWebGL(byteOffset = 0, byteLength) {
+      byteLength = byteLength ?? this.byteLength - byteOffset;
+      const data = new Uint8Array(byteLength);
+      const dstOffset = 0;
+      this.gl.bindBuffer(36662 /* COPY_READ_BUFFER */, this.handle);
+      this.gl.getBufferSubData(36662 /* COPY_READ_BUFFER */, byteOffset, data, dstOffset, byteLength);
+      this.gl.bindBuffer(36662 /* COPY_READ_BUFFER */, null);
+      this._setDebugData(data, byteOffset, byteLength);
+      return data;
+    }
+  };
+  function getWebGLTarget(usage) {
+    if (usage & import_core12.Buffer.INDEX) {
+      return 34963 /* ELEMENT_ARRAY_BUFFER */;
+    }
+    if (usage & import_core12.Buffer.VERTEX) {
+      return 34962 /* ARRAY_BUFFER */;
+    }
+    if (usage & import_core12.Buffer.UNIFORM) {
+      return 35345 /* UNIFORM_BUFFER */;
+    }
+    return 34962 /* ARRAY_BUFFER */;
+  }
+  function getWebGLUsage(usage) {
+    if (usage & import_core12.Buffer.INDEX) {
+      return 35044 /* STATIC_DRAW */;
+    }
+    if (usage & import_core12.Buffer.VERTEX) {
+      return 35044 /* STATIC_DRAW */;
+    }
+    if (usage & import_core12.Buffer.UNIFORM) {
+      return 35048 /* DYNAMIC_DRAW */;
+    }
+    return 35044 /* STATIC_DRAW */;
+  }
+
   // src/adapter/resources/webgl-shader.ts
-  var import_core14 = __toESM(require_core(), 1);
+  var import_core13 = __toESM(require_core(), 1);
 
   // src/adapter/helpers/parse-shader-compiler-log.ts
   function parseShaderCompilerLog(errLog) {
@@ -3913,7 +3711,7 @@ var __exports__ = (() => {
   }
 
   // src/adapter/resources/webgl-shader.ts
-  var WEBGLShader = class extends import_core14.Shader {
+  var WEBGLShader = class extends import_core13.Shader {
     device;
     handle;
     constructor(device, props) {
@@ -3943,24 +3741,24 @@ var __exports__ = (() => {
       return this.getCompilationInfoSync();
     }
     getCompilationInfoSync() {
-      const log9 = this.device.gl.getShaderInfoLog(this.handle);
-      return parseShaderCompilerLog(log9);
+      const log10 = this.device.gl.getShaderInfoLog(this.handle);
+      return log10 ? parseShaderCompilerLog(log10) : [];
     }
     getTranslatedSource() {
       const extensions = this.device.getExtension("WEBGL_debug_shaders");
       const ext = extensions.WEBGL_debug_shaders;
-      return ext?.getTranslatedShaderSource(this.handle);
+      return ext?.getTranslatedShaderSource(this.handle) || null;
     }
     // PRIVATE METHODS
     /** Compile a shader and get compilation status */
     async _compile(source) {
-      const addGLSLVersion = (source2) => source2.startsWith("#version ") ? source2 : `#version 100
+      const addGLSLVersion = (source2) => source2.startsWith("#version ") ? source2 : `#version 300 es
 ${source2}`;
       source = addGLSLVersion(source);
       const { gl } = this.device;
       gl.shaderSource(this.handle, source);
       gl.compileShader(this.handle);
-      if (import_core14.log.level === 0) {
+      if (import_core13.log.level === 0) {
         this.compilationStatus = "pending";
         return;
       }
@@ -3972,9 +3770,9 @@ ${source2}`;
         }
         return;
       }
-      import_core14.log.once(1, "Shader compilation is asynchronous")();
+      import_core13.log.once(1, "Shader compilation is asynchronous")();
       await this._waitForCompilationComplete();
-      import_core14.log.info(2, `Shader ${this.id} - async compilation complete: ${this.compilationStatus}`)();
+      import_core13.log.info(2, `Shader ${this.id} - async compilation complete: ${this.compilationStatus}`)();
       this._getCompilationStatus();
       this.debugShader();
     }
@@ -4006,25 +3804,35 @@ ${source2}`;
   };
 
   // src/adapter/resources/webgl-render-pass.ts
-  var import_core15 = __toESM(require_core(), 1);
+  var import_core14 = __toESM(require_core(), 1);
   var GL_DEPTH_BUFFER_BIT = 256;
   var GL_STENCIL_BUFFER_BIT = 1024;
   var GL_COLOR_BUFFER_BIT = 16384;
   var GL_COLOR = 6144;
   var COLOR_CHANNELS = [1, 2, 4, 8];
-  var WEBGLRenderPass = class extends import_core15.RenderPass {
+  var WEBGLRenderPass = class extends import_core14.RenderPass {
     device;
     /** Parameters that should be applied before each draw call */
     glParameters;
     constructor(device, props) {
       super(device, props);
       this.device = device;
-      pushContextState(this.device.gl);
-      this.setParameters(this.props.parameters);
+      let viewport;
+      if (!props?.parameters?.viewport) {
+        if (props?.framebuffer) {
+          const { width, height } = props.framebuffer;
+          viewport = [0, 0, width, height];
+        } else {
+          const [width, height] = device.getCanvasContext().getDrawingBufferSize();
+          viewport = [0, 0, width, height];
+        }
+      }
+      this.device.pushState();
+      this.setParameters({ viewport, ...this.props.parameters });
       this.clear();
     }
     end() {
-      popContextState(this.device.gl);
+      this.device.popState();
     }
     pushDebugGroup(groupLabel) {
     }
@@ -4040,9 +3848,7 @@ ${source2}`;
      */
     setParameters(parameters = {}) {
       const glParameters = { ...this.glParameters };
-      if (this.props.framebuffer) {
-        glParameters.framebuffer = this.props.framebuffer;
-      }
+      glParameters.framebuffer = this.props.framebuffer || null;
       if (this.props.depthReadOnly) {
         glParameters.depthMask = !this.props.depthReadOnly;
       }
@@ -4148,11 +3954,7 @@ ${source2}`;
   };
 
   // src/adapter/resources/webgl-render-pipeline.ts
-  var import_core17 = __toESM(require_core(), 1);
-  var import_core18 = __toESM(require_core(), 1);
-
-  // src/classic/accessor.ts
-  var import_core16 = __toESM(require_core(), 1);
+  var import_core15 = __toESM(require_core(), 1);
 
   // src/classic/typed-array-utils.ts
   var ERR_TYPE_DEDUCTION = "Failed to deduce GL constant from typed array";
@@ -4214,12 +4016,6 @@ ${source2}`;
     normalized: false,
     integer: false
   };
-  var PROP_CHECKS = {
-    deprecatedProps: {
-      instanced: "divisor",
-      isInstanced: "divisor"
-    }
-  };
   var Accessor = class {
     offset;
     stride;
@@ -4235,7 +4031,6 @@ ${source2}`;
       return ArrayType.BYTES_PER_ELEMENT;
     }
     static getBytesPerVertex(accessor) {
-      (0, import_core16.assert)(accessor.size);
       const ArrayType = getTypedArrayFromGLType(accessor.type || 5126 /* FLOAT */);
       return ArrayType.BYTES_PER_ELEMENT * accessor.size;
     }
@@ -4264,7 +4059,6 @@ ${source2}`;
     // PRIVATE
     // eslint-disable-next-line complexity, max-statements
     _assign(props = {}) {
-      props = (0, import_core16.checkProps)("Accessor", props, PROP_CHECKS);
       if (props.type !== void 0) {
         this.type = props.type;
         if (props.type === 5124 /* INT */ || props.type === 5125 /* UNSIGNED_INT */) {
@@ -4707,6 +4501,34 @@ ${source2}`;
     throw new Error("Illegal uniform");
   }
 
+  // ../../node_modules/@math.gl/types/dist/is-array.js
+  function isTypedArray(value) {
+    return ArrayBuffer.isView(value) && !(value instanceof DataView) ? value : null;
+  }
+  function isNumericArray(value) {
+    if (Array.isArray(value)) {
+      return value.length === 0 || typeof value[0] === "number" ? value : null;
+    }
+    return isTypedArray(value);
+  }
+
+  // src/utils/split-uniforms-and-bindings.ts
+  function isUniformValue(value) {
+    return isNumericArray(value) !== null || typeof value === "number" || typeof value === "boolean";
+  }
+  function splitUniformsAndBindings(uniforms) {
+    const result = { bindings: {}, uniforms: {} };
+    Object.keys(uniforms).forEach((name) => {
+      const uniform = uniforms[name];
+      if (isUniformValue(uniform)) {
+        result.uniforms[name] = uniform;
+      } else {
+        result.bindings[name] = uniform;
+      }
+    });
+    return result;
+  }
+
   // src/adapter/helpers/webgl-topology-utils.ts
   function getGLDrawMode(topology) {
     switch (topology) {
@@ -4716,14 +4538,10 @@ ${source2}`;
         return 1 /* LINES */;
       case "line-strip":
         return 3 /* LINE_STRIP */;
-      case "line-loop-webgl":
-        return 2 /* LINE_LOOP */;
       case "triangle-list":
         return 4 /* TRIANGLES */;
       case "triangle-strip":
         return 5 /* TRIANGLE_STRIP */;
-      case "triangle-fan-webgl":
-        return 6 /* TRIANGLE_FAN */;
       default:
         throw new Error(topology);
     }
@@ -4736,14 +4554,10 @@ ${source2}`;
         return 1 /* LINES */;
       case "line-strip":
         return 1 /* LINES */;
-      case "line-loop-webgl":
-        return 1 /* LINES */;
       case "triangle-list":
         return 4 /* TRIANGLES */;
       case "triangle-strip":
         return 4 /* TRIANGLES */;
-      case "triangle-fan-webgl":
-        return 4 /* TRIANGLES */;
       default:
         throw new Error(topology);
     }
@@ -4751,7 +4565,7 @@ ${source2}`;
 
   // src/adapter/resources/webgl-render-pipeline.ts
   var LOG_PROGRAM_PERF_PRIORITY = 4;
-  var WEBGLRenderPipeline = class extends import_core17.RenderPipeline {
+  var WEBGLRenderPipeline = class extends import_core15.RenderPipeline {
     /** The WebGL device that created this render pipeline */
     device;
     /** Handle to underlying WebGL program */
@@ -4776,27 +4590,18 @@ ${source2}`;
       this.device = device;
       this.handle = this.props.handle || this.device.gl.createProgram();
       this.device.setSpectorMetadata(this.handle, { id: this.props.id });
-      this.vs = (0, import_core17.cast)(props.vs);
-      this.fs = (0, import_core17.cast)(props.fs);
+      this.vs = props.vs;
+      this.fs = props.fs;
       const { varyings, bufferMode = 35981 /* SEPARATE_ATTRIBS */ } = props;
       if (varyings && varyings.length > 0) {
         this.varyings = varyings;
         this.device.gl.transformFeedbackVaryings(this.handle, varyings, bufferMode);
       }
       this._linkShaders();
-      import_core17.log.time(1, `RenderPipeline ${this.id} - shaderLayout introspection`)();
+      import_core15.log.time(1, `RenderPipeline ${this.id} - shaderLayout introspection`)();
       this.introspectedLayout = getShaderLayout(this.device.gl, this.handle);
-      import_core17.log.timeEnd(1, `RenderPipeline ${this.id} - shaderLayout introspection`)();
-      this.shaderLayout = (0, import_core18.mergeShaderLayout)(this.introspectedLayout, props.shaderLayout);
-      switch (this.props.topology) {
-        case "triangle-fan-webgl":
-        case "line-loop-webgl":
-          import_core17.log.warn(
-            `Primitive topology ${this.props.topology} is deprecated and will be removed in v9.1`
-          );
-          break;
-        default:
-      }
+      import_core15.log.timeEnd(1, `RenderPipeline ${this.id} - shaderLayout introspection`)();
+      this.shaderLayout = mergeShaderLayout(this.introspectedLayout, props.shaderLayout);
     }
     destroy() {
       if (this.handle) {
@@ -4814,14 +4619,15 @@ ${source2}`;
         if (!binding) {
           const validBindings = this.shaderLayout.bindings.map((binding2) => `"${binding2.name}"`).join(", ");
           if (!options?.disableWarnings) {
-            import_core17.log.warn(
-              `Unknown binding "${name}" in render pipeline "${this.id}", expected one of ${validBindings}`
+            import_core15.log.warn(
+              `No binding "${name}" in render pipeline "${this.id}", expected one of ${validBindings}`,
+              value
             )();
           }
           continue;
         }
         if (!value) {
-          import_core17.log.warn(`Unsetting binding "${name}" in render pipeline "${this.id}"`)();
+          import_core15.log.warn(`Unsetting binding "${name}" in render pipeline "${this.id}"`)();
         }
         switch (binding.type) {
           case "uniform":
@@ -4835,7 +4641,7 @@ ${source2}`;
             }
             break;
           case "sampler":
-            import_core17.log.warn(`Ignoring sampler ${name}`)();
+            import_core15.log.warn(`Ignoring sampler ${name}`)();
             break;
           default:
             throw new Error(binding.type);
@@ -4867,17 +4673,13 @@ ${source2}`;
       const isIndexed = Boolean(vertexArray.indexBuffer);
       const glIndexType = vertexArray.indexBuffer?.glIndexType;
       if (this.linkStatus !== "success") {
-        import_core17.log.info(2, `RenderPipeline:${this.id}.draw() aborted - waiting for shader linking`)();
+        import_core15.log.info(2, `RenderPipeline:${this.id}.draw() aborted - waiting for shader linking`)();
         return false;
       }
-      if (!this._areTexturesRenderable() || vertexCount === 0) {
-        import_core17.log.info(2, `RenderPipeline:${this.id}.draw() aborted - textures not yet loaded`)();
+      if (!this._areTexturesRenderable()) {
+        import_core15.log.info(2, `RenderPipeline:${this.id}.draw() aborted - textures not yet loaded`)();
         return false;
       }
-      if (vertexCount === 0) {
-        import_core17.log.info(2, `RenderPipeline:${this.id}.draw() aborted - no vertices to draw`)();
-        return true;
-      }
       this.device.gl.useProgram(this.handle);
       vertexArray.bindBeforeRender(renderPass);
       if (transformFeedback) {
@@ -4917,9 +4719,9 @@ ${source2}`;
     }
     // DEPRECATED METHODS
     setUniformsWebGL(uniforms) {
-      const { bindings } = (0, import_core17.splitUniformsAndBindings)(uniforms);
+      const { bindings } = splitUniformsAndBindings(uniforms);
       Object.keys(bindings).forEach((name) => {
-        import_core17.log.warn(
+        import_core15.log.warn(
           `Unsupported value "${JSON.stringify(
             bindings[name]
           )}" used in setUniforms() for key ${name}. Use setBindings() instead?`
@@ -4934,19 +4736,19 @@ ${source2}`;
       const { gl } = this.device;
       gl.attachShader(this.handle, this.vs.handle);
       gl.attachShader(this.handle, this.fs.handle);
-      import_core17.log.time(LOG_PROGRAM_PERF_PRIORITY, `linkProgram for ${this.id}`)();
+      import_core15.log.time(LOG_PROGRAM_PERF_PRIORITY, `linkProgram for ${this.id}`)();
       gl.linkProgram(this.handle);
-      import_core17.log.timeEnd(LOG_PROGRAM_PERF_PRIORITY, `linkProgram for ${this.id}`)();
-      if (import_core17.log.level === 0) {
+      import_core15.log.timeEnd(LOG_PROGRAM_PERF_PRIORITY, `linkProgram for ${this.id}`)();
+      if (import_core15.log.level === 0) {
       }
       if (!this.device.features.has("compilation-status-async-webgl")) {
         const status2 = this._getLinkStatus();
         this._reportLinkStatus(status2);
         return;
       }
-      import_core17.log.once(1, "RenderPipeline linking is asynchronous")();
+      import_core15.log.once(1, "RenderPipeline linking is asynchronous")();
       await this._waitForLinkComplete();
-      import_core17.log.info(2, `RenderPipeline ${this.id} - async linking complete: ${this.linkStatus}`)();
+      import_core15.log.info(2, `RenderPipeline ${this.id} - async linking complete: ${this.linkStatus}`)();
       const status = this._getLinkStatus();
       this._reportLinkStatus(status);
     }
@@ -5012,10 +4814,15 @@ ${source2}`;
      */
     _areTexturesRenderable() {
       let texturesRenderable = true;
+      for (const bindingInfo of this.shaderLayout.bindings) {
+        if (!this.bindings[bindingInfo.name] && !this.bindings[bindingInfo.name.replace(/Uniforms$/, "")]) {
+          import_core15.log.warn(`Binding ${bindingInfo.name} not found in ${this.id}`)();
+          texturesRenderable = false;
+        }
+      }
       for (const [, texture] of Object.entries(this.bindings)) {
         if (texture instanceof WEBGLTexture) {
           texture.update();
-          texturesRenderable = texturesRenderable && texture.loaded;
         }
       }
       return texturesRenderable;
@@ -5068,7 +4875,7 @@ ${source2}`;
             } else if (value instanceof WEBGLTexture) {
               texture = value;
             } else if (value instanceof WEBGLFramebuffer && value.colorAttachments[0] instanceof WEBGLTextureView) {
-              import_core17.log.warn(
+              import_core15.log.warn(
                 "Passing framebuffer in texture binding may be deprecated. Use fbo.colorAttachments[0] instead"
               )();
               texture = value.colorAttachments[0].texture;
@@ -5076,7 +4883,7 @@ ${source2}`;
               throw new Error("No texture");
             }
             gl.activeTexture(33984 /* TEXTURE0 */ + textureUnit);
-            gl.bindTexture(texture.target, texture.handle);
+            gl.bindTexture(texture.glTarget, texture.handle);
             textureUnit += 1;
             break;
           case "sampler":
@@ -5101,16 +4908,29 @@ ${source2}`;
       }
     }
   };
+  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) {
+        import_core15.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;
+  }
 
   // src/adapter/resources/webgl-command-encoder.ts
-  var import_core20 = __toESM(require_core(), 1);
+  var import_core17 = __toESM(require_core(), 1);
 
   // src/adapter/resources/webgl-command-buffer.ts
-  var import_core19 = __toESM(require_core(), 1);
-  function cast2(value) {
-    return value;
-  }
-  var WEBGLCommandBuffer = class extends import_core19.CommandBuffer {
+  var import_core16 = __toESM(require_core(), 1);
+  var WEBGLCommandBuffer = class extends import_core16.CommandBuffer {
     device;
     commands = [];
     constructor(device) {
@@ -5137,8 +4957,8 @@ ${source2}`;
     }
   };
   function _copyBufferToBuffer(device, options) {
-    const source = cast2(options.source);
-    const destination = cast2(options.destination);
+    const source = options.source;
+    const destination = options.destination;
     device.gl.bindBuffer(36662 /* COPY_READ_BUFFER */, source.handle);
     device.gl.bindBuffer(36663 /* COPY_WRITE_BUFFER */, destination.handle);
     device.gl.copyBufferSubData(
@@ -5197,8 +5017,10 @@ ${source2}`;
       const webglBuffer = destination;
       const sourceWidth = width || framebuffer.width;
       const sourceHeight = height || framebuffer.height;
-      const sourceParams = getWebGLTextureParameters(framebuffer.texture.props.format);
-      const sourceFormat = sourceParams.dataFormat;
+      const sourceParams = getTextureFormatWebGL(
+        framebuffer.colorAttachments[0].texture.props.format
+      );
+      const sourceFormat = sourceParams.format;
       const sourceType = sourceParams.type;
       device.gl.bindBuffer(35051 /* PIXEL_PACK_BUFFER */, webglBuffer.handle);
       prevHandle = device.gl.bindFramebuffer(36160 /* FRAMEBUFFER */, framebuffer.handle);
@@ -5261,7 +5083,7 @@ ${source2}`;
       width = Number.isFinite(width) ? width : texture.width;
       height = Number.isFinite(height) ? height : texture.height;
       texture.bind(0);
-      textureTarget = texture.target;
+      textureTarget = texture.glTarget;
     } else {
       throw new Error("invalid destination");
     }
@@ -5304,7 +5126,7 @@ ${source2}`;
     }
   }
   function getFramebuffer(source) {
-    if (source instanceof import_core19.Texture) {
+    if (source instanceof import_core16.Texture) {
       const { width, height, id } = source;
       const framebuffer = source.device.createFramebuffer({
         id: `framebuffer-for-${id}`,
@@ -5318,7 +5140,7 @@ ${source2}`;
   }
 
   // src/adapter/resources/webgl-command-encoder.ts
-  var WEBGLCommandEncoder = class extends import_core20.CommandEncoder {
+  var WEBGLCommandEncoder = class extends import_core17.CommandEncoder {
     device;
     commandBuffer;
     constructor(device, props) {
@@ -5357,8 +5179,31 @@ ${source2}`;
   };
 
   // src/adapter/resources/webgl-vertex-array.ts
-  var import_core21 = __toESM(require_core(), 1);
-  var WEBGLVertexArray = class extends import_core21.VertexArray {
+  var import_core18 = __toESM(require_core(), 1);
+
+  // src/utils/fill-array.ts
+  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/adapter/resources/webgl-vertex-array.ts
+  var WEBGLVertexArray = class extends import_core18.VertexArray {
     get [Symbol.toStringTag]() {
       return "VertexArray";
     }
@@ -5526,8 +5371,8 @@ ${source2}`;
       this.buffer = this.buffer || this.device.createBuffer({ byteLength });
       updateNeeded = updateNeeded || !compareConstantArrayValues(constantValue, this.bufferValue);
       if (updateNeeded) {
-        const typedArray = (0, import_core21.getScratchArray)(value.constructor, length);
-        (0, import_core21.fillArray)({ target: typedArray, source: constantValue, start: 0, count: length });
+        const typedArray = (0, import_core18.getScratchArray)(value.constructor, length);
+        fillArray({ target: typedArray, source: constantValue, start: 0, count: length });
         this.buffer.write(typedArray);
         this.bufferValue = value;
       }
@@ -5553,8 +5398,8 @@ ${source2}`;
   }
 
   // src/adapter/resources/webgl-transform-feedback.ts
-  var import_core22 = __toESM(require_core(), 1);
-  var WEBGLTransformFeedback = class extends import_core22.TransformFeedback {
+  var import_core19 = __toESM(require_core(), 1);
+  var WEBGLTransformFeedback = class extends import_core19.TransformFeedback {
     device;
     gl;
     handle;
@@ -5617,7 +5462,7 @@ ${source2}`;
       const { buffer, byteLength, byteOffset } = this._getBufferRange(bufferOrRange);
       if (location < 0) {
         this.unusedBuffers[locationOrName] = buffer;
-        import_core22.log.warn(`${this.id} unusedBuffers varying buffer ${locationOrName}`)();
+        import_core19.log.warn(`${this.id} unusedBuffers varying buffer ${locationOrName}`)();
         return;
       }
       this.buffers[location] = { buffer, byteLength, byteOffset };
@@ -5704,8 +5549,8 @@ ${source2}`;
   }
 
   // src/adapter/resources/webgl-query-set.ts
-  var import_core23 = __toESM(require_core(), 1);
-  var WEBGLQuerySet = class extends import_core23.QuerySet {
+  var import_core20 = __toESM(require_core(), 1);
+  var WEBGLQuerySet = class extends import_core20.QuerySet {
     device;
     handle;
     target = null;
@@ -5838,10 +5683,9 @@ ${source2}`;
   };
 
   // src/classic/copy-and-blit.ts
-  var import_core25 = __toESM(require_core(), 1);
+  var import_core21 = __toESM(require_core(), 1);
 
   // src/classic/format-utils.ts
-  var import_core24 = __toESM(require_core(), 1);
   function glFormatToComponents(format) {
     switch (format) {
       case 6406 /* ALPHA */:
@@ -5858,7 +5702,6 @@ ${source2}`;
       case 34836 /* RGBA32F */:
         return 4;
       default:
-        (0, import_core24.assert)(false);
         return 0;
     }
   }
@@ -5873,7 +5716,6 @@ ${source2}`;
       case 5126 /* FLOAT */:
         return 4;
       default:
-        (0, import_core24.assert)(false);
         return 0;
     }
   }
@@ -5883,7 +5725,6 @@ ${source2}`;
     const {
       sourceX = 0,
       sourceY = 0,
-      sourceFormat = 6408 /* RGBA */,
       sourceAttachment = 36064 /* COLOR_ATTACHMENT0 */
       // TODO - support gl.readBuffer
     } = options || {};
@@ -5892,16 +5733,19 @@ ${source2}`;
       // following parameters are auto deduced if not provided
       sourceWidth,
       sourceHeight,
+      sourceDepth,
+      sourceFormat,
       sourceType
     } = options || {};
     const { framebuffer, deleteFramebuffer } = getFramebuffer2(source);
-    (0, import_core25.assert)(framebuffer);
     const { gl, handle } = framebuffer;
-    sourceWidth = sourceWidth || framebuffer.width;
-    sourceHeight = sourceHeight || framebuffer.height;
     const attachment = sourceAttachment - 36064 /* COLOR_ATTACHMENT0 */;
-    sourceType = sourceType || framebuffer.colorAttachments[attachment]?.texture?.type || 5121 /* UNSIGNED_BYTE */;
-    target = getPixelArray(target, sourceType, sourceFormat, sourceWidth, sourceHeight);
+    sourceWidth ||= framebuffer.width;
+    sourceHeight ||= framebuffer.height;
+    sourceDepth = framebuffer.colorAttachments[attachment]?.texture?.depth || 1;
+    sourceFormat ||= framebuffer.colorAttachments[attachment]?.texture?.glFormat || 6408 /* RGBA */;
+    sourceType ||= framebuffer.colorAttachments[attachment]?.texture?.glType || 5121 /* UNSIGNED_BYTE */;
+    target = getPixelArray(target, sourceType, sourceFormat, sourceWidth, sourceHeight, sourceDepth);
     sourceType = sourceType || getGLTypeFromTypedArray(target);
     const prevHandle = gl.bindFramebuffer(36160 /* FRAMEBUFFER */, handle);
     gl.readPixels(sourceX, sourceY, sourceWidth, sourceHeight, sourceFormat, sourceType, target);
@@ -5921,7 +5765,6 @@ ${source2}`;
     } = options || {};
     let { sourceWidth, sourceHeight, sourceType } = options || {};
     const { framebuffer, deleteFramebuffer } = getFramebuffer2(source);
-    (0, import_core25.assert)(framebuffer);
     sourceWidth = sourceWidth || framebuffer.width;
     sourceHeight = sourceHeight || framebuffer.height;
     const webglFramebuffer = framebuffer;
@@ -5949,7 +5792,7 @@ ${source2}`;
     return webglBufferTarget;
   }
   function getFramebuffer2(source) {
-    if (!(source instanceof import_core25.Framebuffer)) {
+    if (!(source instanceof import_core21.Framebuffer)) {
       return { framebuffer: toFramebuffer(source), deleteFramebuffer: true };
     }
     return { framebuffer: source, deleteFramebuffer: false };
@@ -5965,7 +5808,7 @@ ${source2}`;
     });
     return framebuffer;
   }
-  function getPixelArray(pixelArray, type, format, width, height) {
+  function getPixelArray(pixelArray, type, format, width, height, depth) {
     if (pixelArray) {
       return pixelArray;
     }
@@ -5976,11 +5819,9 @@ ${source2}`;
   }
 
   // src/classic/clear.ts
-  var import_core26 = __toESM(require_core(), 1);
   var GL_DEPTH_BUFFER_BIT2 = 256;
   var GL_STENCIL_BUFFER_BIT2 = 1024;
   var GL_COLOR_BUFFER_BIT2 = 16384;
-  var ERR_ARGUMENTS = "clear: bad arguments";
   function clear(device, options) {
     const { framebuffer = null, color = null, depth = null, stencil = null } = options || {};
     const parameters = {};
@@ -6006,7 +5847,6 @@ ${source2}`;
         parameters.clearStencil = depth;
       }
     }
-    (0, import_core26.assert)(clearFlags !== 0, ERR_ARGUMENTS);
     const gl = device.gl;
     withGLParameters(gl, parameters, () => {
       gl.clear(clearFlags);
@@ -6014,8 +5854,10 @@ ${source2}`;
   }
 
   // src/adapter/webgl-device.ts
-  var LOG_LEVEL2 = 1;
-  var _WebGLDevice = class extends import_core27.Device {
+  var WebGLDevice = class extends import_core22.Device {
+    //
+    // Public `Device` API
+    //
     /** type of this device */
     type = "webgl";
     /** The underlying WebGL context */
@@ -6026,66 +5868,21 @@ ${source2}`;
     canvasContext;
     lost;
     _resolveContextLost;
-    //
-    // Static methods, expected to be present by `luma.createDevice()`
-    //
-    /** Check if WebGL 2 is available */
-    static isSupported() {
-      return typeof WebGL2RenderingContext !== "undefined";
-    }
-    /**
-     * Get a device instance from a GL context
-     * Creates and instruments the device if not already created
-     * @param gl
-     * @returns
-     */
-    static attach(gl) {
-      if (gl instanceof _WebGLDevice) {
-        return gl;
-      }
-      if (gl?.device instanceof import_core27.Device) {
-        return gl.device;
-      }
-      if (!isWebGL(gl)) {
-        throw new Error("Invalid WebGL2RenderingContext");
-      }
-      return new _WebGLDevice({ gl });
-    }
-    static async create(props = {}) {
-      import_core27.log.groupCollapsed(LOG_LEVEL2, "WebGLDevice created")();
-      const promises = [];
-      if (props.debug) {
-        promises.push(loadWebGLDeveloperTools());
-      }
-      if (props.spector) {
-        promises.push(loadSpectorJS());
-      }
-      if (typeof props.canvas === "string") {
-        promises.push(import_core27.CanvasContext.pageLoaded);
-      }
-      const results = await Promise.allSettled(promises);
-      for (const result of results) {
-        if (result.status === "rejected") {
-          import_core27.log.error(`Failed to initialize debug libraries ${result.reason}`)();
-        }
-      }
-      import_core27.log.probe(LOG_LEVEL2 + 1, "DOM is loaded")();
-      if (props.gl?.device) {
-        import_core27.log.warn("reattaching existing device")();
-        return _WebGLDevice.attach(props.gl);
-      }
-      const device = new _WebGLDevice(props);
-      const message2 = `Created ${device.type}${device.debug ? " debug" : ""} context: ${device.info.vendor}, ${device.info.renderer} for canvas: ${device.canvasContext.id}`;
-      import_core27.log.probe(LOG_LEVEL2, message2)();
-      import_core27.log.table(LOG_LEVEL2, device.info)();
-      import_core27.log.groupEnd(LOG_LEVEL2)();
-      return device;
-    }
+    /** WebGL2 context. */
+    gl;
+    debug = false;
+    /** State used by luma.gl classes: TODO - move to canvasContext*/
+    _canvasSizeInfo = { clientWidth: 0, clientHeight: 0, devicePixelRatio: 1 };
+    /** State used by luma.gl classes - TODO - not used? */
+    _extensions = {};
+    _polyfilled = false;
+    /** Instance of Spector.js (if initialized) */
+    spectorJS;
     //
     // Public API
     //
     constructor(props) {
-      super({ ...props, id: props.id || (0, import_core27.uid)("webgl-device") });
+      super({ ...props, id: props.id || uid("webgl-device") });
       const device = props.gl?.device;
       if (device) {
         throw new Error(`WebGL context already attached to device ${device.id}`);
@@ -6095,24 +5892,20 @@ ${source2}`;
       this.lost = new Promise((resolve) => {
         this._resolveContextLost = resolve;
       });
-      let gl = props.gl || null;
-      gl ||= createBrowserContext(this.canvasContext.canvas, {
+      this.handle = createBrowserContext(this.canvasContext.canvas, {
         ...props,
         onContextLost: (event) => this._resolveContextLost?.({
           reason: "destroyed",
           message: "Entered sleep mode, or too many apps or browser tabs are using the GPU."
         })
       });
-      if (!gl) {
+      this.gl = this.handle;
+      if (!this.handle) {
         throw new Error("WebGL context creation failed");
       }
-      this.handle = gl;
-      this.gl = gl;
+      this.spectorJS = initializeSpectorJS({ ...this.props, gl: this.handle });
       this.gl.device = this;
       this.gl._version = 2;
-      if (props.spector) {
-        this.spectorJS = initializeSpectorJS({ ...this.props, canvas: this.handle.canvas });
-      }
       this.info = getDeviceInfo(this.gl, this._extensions);
       this.limits = new WebGLDeviceLimits(this.gl);
       this.features = new WebGLDeviceFeatures(this.gl, this._extensions, this.props.disabledFeatures);
@@ -6120,17 +5913,15 @@ ${source2}`;
         this.features.initializeFeatures();
       }
       this.canvasContext.resize();
-      const { enable: enable2 = true, copyState = false } = props;
-      trackContextState(this.gl, {
-        enable: enable2,
-        copyState,
-        log: (...args) => import_core27.log.log(1, ...args)()
+      const glState = new WebGLStateTracker(this.gl, {
+        log: (...args) => import_core22.log.log(1, ...args)()
       });
+      glState.trackState(this.gl, { copyState: false });
       if (props.debug) {
         this.gl = makeDebugContext(this.gl, { ...props, throwOnError: true });
         this.debug = true;
-        import_core27.log.level = Math.max(import_core27.log.level, 1);
-        import_core27.log.warn("WebGL debug mode activated. Performance reduced.")();
+        import_core22.log.level = Math.max(import_core22.log.level, 1);
+        import_core22.log.warn("WebGL debug mode activated. Performance reduced.")();
       }
     }
     /**
@@ -6142,9 +5933,6 @@ ${source2}`;
     get isLost() {
       return this.gl.isContextLost();
     }
-    getSize() {
-      return [this.gl.drawingBufferWidth, this.gl.drawingBufferHeight];
-    }
     isTextureFormatSupported(format) {
       return isTextureFormatSupported(this.gl, format, this._extensions);
     }
@@ -6162,6 +5950,7 @@ ${source2}`;
       const newProps = this._getBufferProps(props);
       return new WEBGLBuffer(this, newProps);
     }
+    // _createTexture(props: TextureProps): WEBGLTexture {
     _createTexture(props) {
       return new WEBGLTexture(this, props);
     }
@@ -6199,7 +5988,7 @@ ${source2}`;
       throw new Error("ComputePass not supported in WebGL");
     }
     renderPass = null;
-    createCommandEncoder(props) {
+    createCommandEncoder(props = {}) {
       return new WEBGLCommandEncoder(this, props);
     }
     /**
@@ -6235,22 +6024,12 @@ ${source2}`;
       clear(this, options);
     }
     resetWebGL() {
-      import_core27.log.warn("WebGLDevice.resetWebGL is deprecated, use only for debugging")();
+      import_core22.log.warn("WebGLDevice.resetWebGL is deprecated, use only for debugging")();
       resetGLParameters(this.gl);
     }
     //
     // WebGL-only API (not part of `Device` API)
     //
-    /** WebGL2 context. */
-    gl;
-    debug = false;
-    /** State used by luma.gl classes: TODO - move to canvasContext*/
-    _canvasSizeInfo = { clientWidth: 0, clientHeight: 0, devicePixelRatio: 1 };
-    /** State used by luma.gl classes - TODO - not used? */
-    _extensions = {};
-    _polyfilled = false;
-    /** Instance of Spector.js (if initialized) */
-    spectorJS;
     /**
      * Triggers device (or WebGL context) loss.
      * @note primarily intended for testing how application reacts to device loss
@@ -6271,11 +6050,13 @@ ${source2}`;
     }
     /** Save current WebGL context state onto an internal stack */
     pushState() {
-      pushContextState(this.gl);
+      const webglState = WebGLStateTracker.get(this.gl);
+      webglState.push();
     }
     /** Restores previously saved context state */
     popState() {
-      popContextState(this.gl);
+      const webglState = WebGLStateTracker.get(this.gl);
+      webglState.pop();
     }
     /**
      * Storing data on a special field on WebGLObjects makes that data visible in SPECTOR chrome debug extension
@@ -6312,7 +6093,7 @@ ${source2}`;
       this._constants = this._constants || new Array(maxVertexAttributes).fill(null);
       const currentConstant = this._constants[location];
       if (currentConstant && compareConstantArrayValues2(currentConstant, constant)) {
-        import_core27.log.info(
+        import_core22.log.info(
           1,
           `setConstantAttributeWebGL(${location}) could have been skipped, value unchanged`
         )();
@@ -6329,7 +6110,7 @@ ${source2}`;
           setConstantUintArray(this, location, constant);
           break;
         default:
-          (0, import_core27.assert)(false);
+          throw new Error("constant");
       }
     }
     /** Ensure extensions are only requested once */
@@ -6338,18 +6119,6 @@ ${source2}`;
       return this._extensions;
     }
   };
-  var WebGLDevice = _WebGLDevice;
-  //
-  // Public `Device` API
-  //
-  /** type of this device */
-  __publicField(WebGLDevice, "type", "webgl");
-  function isWebGL(gl) {
-    if (typeof WebGL2RenderingContext !== "undefined" && gl instanceof WebGL2RenderingContext) {
-      return true;
-    }
-    return Boolean(gl && Number.isFinite(gl._version));
-  }
   function setConstantFloatArray(device, location, array) {
     switch (array.length) {
       case 1:
@@ -6365,7 +6134,6 @@ ${source2}`;
         device.gl.vertexAttrib4fv(location, array);
         break;
       default:
-        (0, import_core27.assert)(false);
     }
   }
   function setConstantIntArray(device, location, array) {
@@ -6386,216 +6154,180 @@ ${source2}`;
     return true;
   }
 
-  // src/adapter/objects/webgl-resource.ts
-  var import_core28 = __toESM(require_core(), 1);
-  var ERR_RESOURCE_METHOD_UNDEFINED = "Resource subclass must define virtual methods";
-  var WebGLResource = class extends import_core28.Resource {
-    device;
-    gl;
-    gl2;
-    _handle;
-    _bound = false;
-    // Only meaningful for resources that allocate GPU memory
-    byteLength = 0;
-    constructor(device, props, defaultProps) {
-      super(device, props, defaultProps);
-      this.device = device;
-      const gl = this.device.gl;
-      const { id } = props || {};
-      this.gl = gl;
-      this.gl2 = gl;
-      this.id = id || (0, import_core28.uid)(this.constructor.name);
-      this._handle = props?.handle;
-      if (this._handle === void 0) {
-        this._handle = this._createHandle();
-      }
-      this.byteLength = 0;
+  // src/context/polyfills/polyfill-webgl1-extensions.ts
+  var WEBGL1_STATIC_EXTENSIONS = {
+    WEBGL_depth_texture: {
+      UNSIGNED_INT_24_8_WEBGL: 34042 /* UNSIGNED_INT_24_8 */
+    },
+    OES_element_index_uint: {},
+    OES_texture_float: {},
+    OES_texture_half_float: {
+      // @ts-expect-error different numbers?
+      HALF_FLOAT_OES: 5131 /* HALF_FLOAT */
+    },
+    EXT_color_buffer_float: {},
+    OES_standard_derivatives: {
+      FRAGMENT_SHADER_DERIVATIVE_HINT_OES: 35723 /* FRAGMENT_SHADER_DERIVATIVE_HINT */
+    },
+    EXT_frag_depth: {},
+    EXT_blend_minmax: {
+      MIN_EXT: 32775 /* MIN */,
+      MAX_EXT: 32776 /* MAX */
+    },
+    EXT_shader_texture_lod: {}
+  };
+  var getWEBGL_draw_buffers = (gl) => ({
+    drawBuffersWEBGL(buffers) {
+      return gl.drawBuffers(buffers);
+    },
+    COLOR_ATTACHMENT0_WEBGL: 36064 /* COLOR_ATTACHMENT0 */,
+    COLOR_ATTACHMENT1_WEBGL: 36065 /* COLOR_ATTACHMENT1 */,
+    COLOR_ATTACHMENT2_WEBGL: 36066 /* COLOR_ATTACHMENT2 */,
+    COLOR_ATTACHMENT3_WEBGL: 36067 /* COLOR_ATTACHMENT3 */
+  });
+  var getOES_vertex_array_object = (gl) => ({
+    VERTEX_ARRAY_BINDING_OES: 34229 /* VERTEX_ARRAY_BINDING */,
+    createVertexArrayOES() {
+      return gl.createVertexArray();
+    },
+    deleteVertexArrayOES(vertexArray) {
+      return gl.deleteVertexArray(vertexArray);
+    },
+    isVertexArrayOES(vertexArray) {
+      return gl.isVertexArray(vertexArray);
+    },
+    bindVertexArrayOES(vertexArray) {
+      return gl.bindVertexArray(vertexArray);
     }
-    toString() {
-      return `${this.constructor.name}(${this.id})`;
+  });
+  var getANGLE_instanced_arrays = (gl) => ({
+    VERTEX_ATTRIB_ARRAY_DIVISOR_ANGLE: 35070,
+    drawArraysInstancedANGLE(...args) {
+      return gl.drawArraysInstanced(...args);
+    },
+    drawElementsInstancedANGLE(...args) {
+      return gl.drawElementsInstanced(...args);
+    },
+    vertexAttribDivisorANGLE(...args) {
+      return gl.vertexAttribDivisor(...args);
     }
-    get handle() {
-      return this._handle;
+  });
+  function enforceWebGL2(enforce = true) {
+    const prototype = HTMLCanvasElement.prototype;
+    if (!enforce && prototype.originalGetContext) {
+      prototype.getContext = prototype.originalGetContext;
+      prototype.originalGetContext = void 0;
+      return;
     }
-    delete({ deleteChildren = false } = {}) {
-      const children = this._handle && this._deleteHandle(this._handle);
-      if (this._handle) {
-        this.removeStats();
-      }
-      this._handle = null;
-      if (children && deleteChildren) {
-        children.filter(Boolean).forEach((child) => child.destroy());
+    prototype.originalGetContext = prototype.getContext;
+    prototype.getContext = function(contextId, options) {
+      if (contextId === "webgl" || contextId === "experimental-webgl") {
+        const context = this.originalGetContext("webgl2", options);
+        if (context instanceof HTMLElement) {
+          polyfillWebGL1Extensions(context);
+        }
+        return context;
       }
-      return this;
-    }
-    bind(funcOrHandle = this.handle) {
-      if (typeof funcOrHandle !== "function") {
-        this._bindHandle(funcOrHandle);
-        return this;
+      return this.originalGetContext(contextId, options);
+    };
+  }
+  function polyfillWebGL1Extensions(gl) {
+    gl.getExtension("EXT_color_buffer_float");
+    const boundExtensions = {
+      ...WEBGL1_STATIC_EXTENSIONS,
+      WEBGL_disjoint_timer_query: gl.getExtension("EXT_disjoint_timer_query_webgl2"),
+      WEBGL_draw_buffers: getWEBGL_draw_buffers(gl),
+      OES_vertex_array_object: getOES_vertex_array_object(gl),
+      ANGLE_instanced_arrays: getANGLE_instanced_arrays(gl)
+    };
+    const originalGetExtension = gl.getExtension;
+    gl.getExtension = function(extensionName) {
+      const ext = originalGetExtension.call(gl, extensionName);
+      if (ext) {
+        return ext;
       }
-      let value;
-      if (!this._bound) {
-        this._bindHandle(this.handle);
-        this._bound = true;
-        value = funcOrHandle();
-        this._bound = false;
-        this._bindHandle(null);
-      } else {
-        value = funcOrHandle();
+      if (extensionName in boundExtensions) {
+        return boundExtensions[extensionName];
       }
-      return value;
-    }
-    unbind() {
-      this.bind(null);
-    }
-    // Install stubs for removed methods
-    stubRemovedMethods(className, version, methodNames) {
-      return (0, import_core28.stubRemovedMethods)(this, className, version, methodNames);
-    }
-    // PUBLIC VIRTUAL METHODS
-    initialize(props) {
-    }
-    // PROTECTED METHODS - These must be overridden by subclass
-    _createHandle() {
-      throw new Error(ERR_RESOURCE_METHOD_UNDEFINED);
-    }
-    _deleteHandle() {
-      throw new Error(ERR_RESOURCE_METHOD_UNDEFINED);
-    }
-    _bindHandle(handle) {
-      throw new Error(ERR_RESOURCE_METHOD_UNDEFINED);
-    }
-    _getOptsFromHandle() {
-      throw new Error(ERR_RESOURCE_METHOD_UNDEFINED);
+      return null;
+    };
+    const originalGetSupportedExtensions = gl.getSupportedExtensions;
+    gl.getSupportedExtensions = function() {
+      const extensions = originalGetSupportedExtensions.apply(gl) || [];
+      return extensions?.concat(Object.keys(boundExtensions));
+    };
+  }
+
+  // src/adapter/webgl-adapter.ts
+  var LOG_LEVEL2 = 1;
+  var WebGLAdapter = class extends import_core23.Adapter {
+    /** type of device's created by this adapter */
+    type = "webgl";
+    constructor() {
+      super();
+      import_core23.Device.defaultProps = { ...import_core23.Device.defaultProps, ...DEFAULT_SPECTOR_PROPS };
+      WebGLDevice.adapter = this;
     }
-    _getParameter(pname, props) {
-      throw new Error(ERR_RESOURCE_METHOD_UNDEFINED);
+    /** Check if WebGL 2 is available */
+    isSupported() {
+      return typeof WebGL2RenderingContext !== "undefined";
     }
-    _setParameter(pname, value) {
-      throw new Error(ERR_RESOURCE_METHOD_UNDEFINED);
+    /** Force any created WebGL contexts to be WebGL2 contexts, polyfilled with WebGL1 extensions */
+    enforceWebGL2(enable2) {
+      enforceWebGL2(enable2);
     }
-    // PRIVATE METHODS
-    /*
-      _addStats() {
-        const name = this.constructor.name;
-        const stats = lumaStats.get('Resource Counts');
-    
-        stats.get('Resources Created').incrementCount();
-        stats.get(`${name}s Created`).incrementCount();
-        stats.get(`${name}s Active`).incrementCount();
-      }
-    
-      _removeStats() {
-        const name = this.constructor.name;
-        const stats = lumaStats.get('Resource Counts');
-    
-        stats.get(`${name}s Active`).decrementCount();
+    /**
+     * Get a device instance from a GL context
+     * Creates and instruments the device if not already created
+     * @param gl
+     * @returns
+     */
+    async attach(gl) {
+      if (gl instanceof WebGLDevice) {
+        return gl;
       }
-    
-      trackAllocatedMemory(bytes, name = this.constructor.name) {
-        const stats = lumaStats.get('Memory Usage');
-    
-        stats.get('GPU Memory').addCount(bytes);
-        stats.get(`${name} Memory`).addCount(bytes);
-        this.byteLength = bytes;
+      if (gl?.device instanceof import_core23.Device) {
+        return gl.device;
       }
-    
-      trackDeallocatedMemory(name = this.constructor.name) {
-        const stats = lumaStats.get('Memory Usage');
-    
-        stats.get('GPU Memory').subtractCount(this.byteLength);
-        stats.get(`${name} Memory`).subtractCount(this.byteLength);
-        this.byteLength = 0;
+      if (!isWebGL(gl)) {
+        throw new Error("Invalid WebGL2RenderingContext");
       }
-      */
-  };
-
-  // src/adapter/objects/webgl-renderbuffer.ts
-  var import_core29 = __toESM(require_core(), 1);
-  var _WEBGLRenderbuffer = class extends WebGLResource {
-    get [Symbol.toStringTag]() {
-      return "Renderbuffer";
-    }
-    get width() {
-      return this.props.width;
-    }
-    get height() {
-      return this.props.height;
-    }
-    get format() {
-      return this.props.format;
-    }
-    get samples() {
-      return this.props.samples;
-    }
-    get attachment() {
-      return;
+      return new WebGLDevice({ gl });
     }
-    /** WebGL format constant */
-    glFormat;
-    static isTextureFormatSupported(device, format) {
-      return isRenderbufferFormatSupported(device.gl, format, device._extensions);
-    }
-    constructor(device, props) {
-      if (typeof props.format === "number") {
-        throw new Error("Renderbuffer");
+    async create(props = {}) {
+      import_core23.log.groupCollapsed(LOG_LEVEL2, "WebGLDevice created")();
+      const promises = [];
+      if (props.debug) {
+        promises.push(loadWebGLDeveloperTools());
       }
-      super(device, props, _WEBGLRenderbuffer.defaultProps);
-      this.glFormat = convertTextureFormatToGL(this.props.format);
-      this._initialize(this.props);
-    }
-    resize(size) {
-      if (size.width !== this.width || size.height !== this.height) {
-        Object.assign(this.props, { ...size, format: this.format, samples: this.samples });
-        this._initialize(this.props);
+      if (props.debugWithSpectorJS) {
+        promises.push(loadSpectorJS(props));
       }
-    }
-    // PRIVATE METHODS
-    /** Creates and initializes a renderbuffer object's data store */
-    _initialize(props) {
-      const { format, width, height, samples } = props;
-      (0, import_core29.assert)(format, "Needs format");
-      this.trackDeallocatedMemory();
-      this.gl.bindRenderbuffer(36161 /* RENDERBUFFER */, this.handle);
-      if (samples !== 0) {
-        this.gl.renderbufferStorageMultisample(
-          36161 /* RENDERBUFFER */,
-          samples,
-          this.glFormat,
-          width,
-          height
-        );
-      } else {
-        this.gl.renderbufferStorage(36161 /* RENDERBUFFER */, this.glFormat, width, height);
+      if (typeof props.canvas === "string") {
+        promises.push(import_core23.CanvasContext.pageLoaded);
       }
-      this.gl.bindRenderbuffer(36161 /* RENDERBUFFER */, null);
-      this.trackAllocatedMemory(
-        width * height * (samples || 1) * getTextureFormatBytesPerPixel(this.format)
-      );
-    }
-    // RESOURCE IMPLEMENTATION
-    _createHandle() {
-      return this.gl.createRenderbuffer();
-    }
-    _deleteHandle() {
-      this.gl.deleteRenderbuffer(this.handle);
-      this.trackDeallocatedMemory();
-    }
-    _bindHandle(handle) {
-      this.gl.bindRenderbuffer(36161 /* RENDERBUFFER */, handle);
+      const results = await Promise.allSettled(promises);
+      for (const result of results) {
+        if (result.status === "rejected") {
+          import_core23.log.error(`Failed to initialize debug libraries ${result.reason}`)();
+        }
+      }
+      import_core23.log.probe(LOG_LEVEL2 + 1, "DOM is loaded")();
+      const device = new WebGLDevice(props);
+      const message2 = `Created ${device.type}${device.debug ? " debug" : ""} context: ${device.info.vendor}, ${device.info.renderer} for canvas: ${device.canvasContext.id}`;
+      import_core23.log.probe(LOG_LEVEL2, message2)();
+      import_core23.log.table(LOG_LEVEL2, device.info)();
+      import_core23.log.groupEnd(LOG_LEVEL2)();
+      return device;
     }
   };
-  var WEBGLRenderbuffer = _WEBGLRenderbuffer;
-  __publicField(WEBGLRenderbuffer, "defaultProps", {
-    id: void 0,
-    handle: void 0,
-    userData: void 0,
-    format: void 0,
-    // 'depth16unorm'
-    width: 1,
-    height: 1,
-    samples: 0
-  });
+  function isWebGL(gl) {
+    if (typeof WebGL2RenderingContext !== "undefined" && gl instanceof WebGL2RenderingContext) {
+      return true;
+    }
+    return Boolean(gl && Number.isFinite(gl._version));
+  }
+  var webgl2Adapter = new WebGLAdapter();
   return __toCommonJS(bundle_exports);
 })();
       return __exports__;