@luma.gl/webgl 9.0.11 → 9.1.0-alpha.1

package/dist/dist.dev.js

@@ -58,7 +58,6 @@ var __exports__ = (() => {
     WEBGLFramebuffer: () => WEBGLFramebuffer,
     WEBGLRenderPass: () => WEBGLRenderPass,
     WEBGLRenderPipeline: () => WEBGLRenderPipeline,
-    WEBGLResource: () => WebGLResource,
     WEBGLSampler: () => WEBGLSampler,
     WEBGLShader: () => WEBGLShader,
     WEBGLTexture: () => WEBGLTexture,
@@ -66,10 +65,7 @@ var __exports__ = (() => {
     WEBGLVertexArray: () => WEBGLVertexArray,
     WebGLCanvasContext: () => WebGLCanvasContext,
     WebGLDevice: () => WebGLDevice,
-    WebGLResource: () => WebGLResource,
     _TEXTURE_FORMATS: () => TEXTURE_FORMATS,
-    _WEBGLRenderbuffer: () => WEBGLRenderbuffer,
-    convertGLToTextureFormat: () => convertGLToTextureFormat,
     getGLParameters: () => getGLParameters,
     getShaderLayout: () => getShaderLayout,
     popContextState: () => popContextState,
@@ -84,10 +80,7 @@ var __exports__ = (() => {
   __reExport(bundle_exports, __toESM(require_core(), 1));
 
   // src/adapter/webgl-device.ts
-  var import_core27 = __toESM(require_core(), 1);
-
-  // src/context/state-tracker/track-context-state.ts
-  var import_core = __toESM(require_core(), 1);
+  var import_core22 = __toESM(require_core(), 1);
 
   // ../constants/src/webgl-constants.ts
   var GLEnum = /* @__PURE__ */ ((GLEnum2) => {
@@ -970,7 +963,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 */),
@@ -1341,7 +1334,6 @@ 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();
@@ -1357,7 +1349,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)) {
@@ -1376,8 +1367,7 @@ var __exports__ = (() => {
     return gl.state;
   }
   function trackContextState(gl, options) {
-    const { enable: enable2 = true, copyState } = options;
-    (0, import_core.assert)(copyState !== void 0);
+    const { enable: enable2 = true, copyState } = options || {};
     if (!gl.state) {
       gl.state = new GLState(gl, { copyState });
       installProgramSpy(gl);
@@ -1402,7 +1392,6 @@ var __exports__ = (() => {
   }
   function popContextState(gl) {
     const glState = getContextState(gl);
-    (0, import_core.assert)(glState);
     glState.pop();
   }
   function installGetterOverride(gl, functionName) {
@@ -1573,10 +1562,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) {
@@ -1719,7 +1708,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 },
@@ -1932,27 +1920,6 @@ var __exports__ = (() => {
     }
     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 +1928,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,13 +1952,13 @@ 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.format, 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
@@ -2005,12 +1972,6 @@ 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) {
     if (format === 6408 /* RGBA */ || format === 6407 /* RGB */) {
       return format;
@@ -2028,6 +1989,14 @@ var __exports__ = (() => {
         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 = {
@@ -2049,7 +2018,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 +2038,7 @@ var __exports__ = (() => {
       return [];
     }
     has(feature) {
-      if (this.disabledFeatures[feature]) {
+      if (this.disabledFeatures?.[feature]) {
         return false;
       }
       if (!this.testedFeatures.has(feature)) {
@@ -2103,8 +2072,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 +2177,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) {
@@ -2250,9 +2219,9 @@ 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;
@@ -2266,7 +2235,7 @@ var __exports__ = (() => {
     }
   }
   function withDeviceParameters(device, parameters, func) {
-    if ((0, import_core5.isObjectEmpty)(parameters)) {
+    if (isObjectEmpty3(parameters)) {
       return func(device);
     }
     pushContextState(device.gl);
@@ -2383,7 +2352,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;
@@ -2496,6 +2465,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 +2542,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 +2582,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,63 +2598,239 @@ var __exports__ = (() => {
     }
   };
 
+  // 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);
+    }
+  }
+  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 = getCubeTargetWebGL(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);
+    }
+  }
+  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 = getCubeTargetWebGL(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 getCubeTargetWebGL(glTarget, dimension, level) {
+    return dimension === "cube" ? 34069 /* TEXTURE_CUBE_MAP_POSITIVE_X */ + level : glTarget;
+  }
+
   // 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 {
+  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;
-    // (TODO - currently unused in WebGL, but WebGL 2 does support sampler objects) */
     sampler = void 0;
+    // TODO - currently unused in WebGL. Create dummy sampler?
     view = void 0;
-    // data;
-    glFormat = void 0;
-    type = void 0;
-    dataFormat = void 0;
-    mipmaps = 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,
-     * 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.
+     * 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;
+    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, { ...DEFAULT_WEBGL_TEXTURE_PROPS, format: "rgba8unorm", ...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;
+        video.addEventListener("loadeddata", () => this.initialize(props));
+      }
+      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 });
-      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) });
+      const data = props.data;
+      let { width, height } = props;
+      if (!width || !height) {
+        const textureSize = this.getTextureDataSize(data);
+        width = textureSize?.width || 1;
+        height = textureSize?.height || 1;
+      }
+      this.width = width;
+      this.height = height;
+      this.depth = props.depth;
+      this.setSampler(props.sampler);
+      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();
       }
-      this.initialize(this.props);
-      Object.seal(this);
     }
+    /*
+      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);
@@ -2816,97 +2845,6 @@ var __exports__ = (() => {
     createView(props) {
       return new WEBGLTextureView(this.device, { ...props, texture: this });
     }
-    // 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) {
-        this._video = null;
-        data.addEventListener("loadeddata", () => this.initialize(props));
-        return this;
-      }
-      const { parameters = {} } = props;
-      const { pixels = null, pixelStore = {}, textureUnit = void 0, mipmaps = true } = props;
-      if (!data) {
-        data = pixels;
-      }
-      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.setSampler(props.sampler);
-      this._setSamplerParameters(parameters);
-      this.view = this.createView({ ...this.props, mipLevelCount: 1, arrayLayerCount: 1 });
-      if (mipmaps && this.device.isTextureFormatFilterable(props.format)) {
-        this.generateMipmap();
-      }
-      if (isVideo) {
-        this._video = {
-          video: data,
-          parameters,
-          // @ts-expect-error
-          lastTime: data.readyState >= HTMLVideoElement.HAVE_CURRENT_DATA ? data.currentTime : -1
-        };
-      }
-      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;
-    }
     setSampler(sampler = {}) {
       let samplerProps;
       if (sampler instanceof WEBGLSampler) {
@@ -2918,377 +2856,88 @@ 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
+    setTexture1DData(data) {
+      throw new Error("setTexture1DData not supported in WebGL.");
+    }
+    /** Set a simple texture */
+    setTexture2DData(lodData, depth = 0, glTarget = this.glTarget) {
+      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)) {
+        copyCPUDataToMipLevel(this.device.gl, data, this);
       }
-      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);
+    /**
+     * Sets an entire texture array
+     * @param data
+     */
+    setTextureArrayData(data) {
+      if (this.props.dimension !== "2d-array") {
+        throw new Error(this.id);
       }
-      gl.bindTexture(this.target, null);
-      return textureUnit;
+      throw new Error("setTextureArrayData not implemented.");
     }
-    // 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 };
-      }
-      (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;
+    /**
+     * Sets an entire texture cube array
+     * @param data
+     */
+    setTextureCubeArrayData(data) {
+      throw new Error("setTextureCubeArrayData not supported in WebGL2.");
     }
-    // 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]);
-        })
-      );
+    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.`)();
+      }
       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();
     }
+    // INTERNAL METHODS
     /** @todo update this method to accept LODs */
     setImageDataForFace(options) {
       const {
@@ -3319,132 +2968,157 @@ 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, offset = 0) {
+      if (import_core7.Texture.isExternalImage(textureData)) {
+        copyCPUImageToMipLevel(this.device.gl, textureData, { ...this, depth, level });
+        return;
+      }
+      if (this.isTextureLevelData(textureData)) {
+        copyCPUDataToMipLevel(this.device.gl, textureData.data, {
+          ...this,
+          depth,
+          level
+        });
+        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 +3136,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 +3173,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.glTarget, level, layer);
           break;
         case 34067 /* TEXTURE_CUBE_MAP */:
           const face = mapIndexToCubeMapFace(layer);
@@ -3575,9 +3231,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 +3259,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,9 +3312,30 @@ var __exports__ = (() => {
   };
 
   // src/context/debug/spector.ts
-  var import_core12 = __toESM(require_core(), 1);
+  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 DEFAULT_SPECTOR_PROPS = {
-    spector: import_core12.log.get("spector") || import_core12.log.get("inspect")
+    spector: import_core10.log.get("spector") || import_core10.log.get("inspect")
   };
   var SPECTOR_CDN_URL = "https://spectorcdn.babylonjs.com/spector.bundle.js";
   var LOG_LEVEL = 1;
@@ -3665,9 +3344,9 @@ var __exports__ = (() => {
   async function loadSpectorJS(props) {
     if (!globalThis.SPECTOR) {
       try {
-        await (0, import_core12.loadScript)(SPECTOR_CDN_URL);
+        await loadScript(SPECTOR_CDN_URL);
       } catch (error) {
-        import_core12.log.warn(String(error));
+        import_core10.log.warn(String(error));
       }
     }
   }
@@ -3677,7 +3356,7 @@ var __exports__ = (() => {
       return null;
     }
     if (!spector && globalThis.SPECTOR) {
-      import_core12.log.probe(LOG_LEVEL, "SPECTOR found and initialized")();
+      import_core10.log.probe(LOG_LEVEL, "SPECTOR found and initialized")();
       spector = new globalThis.SPECTOR.Spector();
       if (globalThis.luma) {
         globalThis.luma.spector = spector;
@@ -3690,10 +3369,10 @@ 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);
@@ -3705,7 +3384,7 @@ var __exports__ = (() => {
       }
       spector?.startCapture(props?.canvas, 500);
       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,40 +3392,37 @@ 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 || {};
+  var process_ = globalThis.process || {};
+  var console_ = globalThis.console;
+  var navigator_ = globalThis.navigator || {};
 
   // ../../node_modules/@probe.gl/env/dist/lib/is-electron.js
   function isElectron(mockUserAgent) {
-    if (typeof window !== "undefined" && typeof window.process === "object" && window.process.type === "renderer") {
+    if (typeof window !== "undefined" && window.process?.type === "renderer") {
       return true;
     }
-    if (typeof process !== "undefined" && typeof process.versions === "object" && Boolean(process.versions["electron"])) {
+    if (typeof process !== "undefined" && Boolean(process.versions?.["electron"])) {
       return true;
     }
-    const realUserAgent = typeof navigator === "object" && typeof navigator.userAgent === "string" && navigator.userAgent;
+    const realUserAgent = typeof navigator !== "undefined" && navigator.userAgent;
     const userAgent = mockUserAgent || realUserAgent;
-    if (userAgent && userAgent.indexOf("Electron") >= 0) {
-      return true;
-    }
-    return false;
+    return Boolean(userAgent && userAgent.indexOf("Electron") >= 0);
   }
 
   // ../../node_modules/@probe.gl/env/dist/lib/is-browser.js
   function isBrowser() {
-    const isNode = typeof process === "object" && String(process) === "[object process]" && !process.browser;
+    const isNode = (
+      // @ts-expect-error
+      typeof process === "object" && String(process) === "[object process]" && !process?.browser
+    );
     return !isNode || isElectron();
   }
 
-  // ../../node_modules/@probe.gl/env/dist/lib/globals.js
-  var self_ = globalThis.self || globalThis.window || globalThis.global;
-  var window_ = globalThis.window || globalThis.self || globalThis.global;
-  var document_ = globalThis.document || {};
-  var process_ = globalThis.process || {};
-  var console_ = globalThis.console;
-  var navigator_ = globalThis.navigator || {};
-
   // ../../node_modules/@probe.gl/env/dist/lib/get-browser.js
-  var window2 = globalThis;
   function getBrowser(mockUserAgent) {
     if (!mockUserAgent && !isBrowser()) {
       return "Node";
@@ -3758,18 +3434,13 @@ var __exports__ = (() => {
     if (userAgent.indexOf("Edge") > -1) {
       return "Edge";
     }
-    const isMSIE = userAgent.indexOf("MSIE ") !== -1;
-    const isTrident = userAgent.indexOf("Trident/") !== -1;
-    if (isMSIE || isTrident) {
-      return "IE";
-    }
-    if (window2.chrome) {
+    if (globalThis.chrome) {
       return "Chrome";
     }
-    if (window2.safari) {
+    if (globalThis.safari) {
       return "Safari";
     }
-    if (window2.mozInnerScreenX) {
+    if (globalThis.mozInnerScreenX) {
       return "Firefox";
     }
     return "Unknown";
@@ -3785,96 +3456,217 @@ 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 = {}) {
+    return props.debug ? getDebugContext(gl, props) : getRealContext(gl);
+  }
+  function getRealContext(gl) {
+    const data = getWebGLContextData(gl);
+    return data.realContext ? data.realContext : gl;
+  }
+  function getDebugContext(gl, props) {
+    if (!globalThis.WebGLDebugUtils) {
+      import_core11.log.warn("webgl-debug not loaded")();
+      return gl;
+    }
+    const data = getWebGLContextData(gl);
+    if (data.debugContext) {
+      return data.debugContext;
+    }
+    globalThis.WebGLDebugUtils.init({ ...GLEnum, ...gl });
+    const glDebug = globalThis.WebGLDebugUtils.makeDebugContext(
+      gl,
+      onGLError.bind(null, props),
+      onValidateGLFunc.bind(null, props)
+    );
+    for (const key in GLEnum) {
+      if (!(key in glDebug) && typeof GLEnum[key] === "number") {
+        glDebug[key] = GLEnum[key];
+      }
+    }
+    class WebGLDebugContext {
+    }
+    Object.setPrototypeOf(glDebug, Object.getPrototypeOf(gl));
+    Object.setPrototypeOf(WebGLDebugContext, glDebug);
+    const debugContext = Object.create(WebGLDebugContext);
+    data.realContext = gl;
+    data.debugContext = debugContext;
+    debugContext.debug = true;
+    return debugContext;
+  }
+  function getFunctionString(functionName, functionArgs) {
+    functionArgs = Array.from(functionArgs).map((arg) => arg === void 0 ? "undefined" : arg);
+    let args = globalThis.WebGLDebugUtils.glFunctionArgsToString(functionName, functionArgs);
+    args = `${args.slice(0, 100)}${args.length > 100 ? "..." : ""}`;
+    return `gl.${functionName}(${args})`;
+  }
+  function onGLError(props, err, functionName, args) {
+    args = Array.from(args).map((arg) => arg === void 0 ? "undefined" : arg);
+    const errorMessage = globalThis.WebGLDebugUtils.glEnumToString(err);
+    const functionArgs = globalThis.WebGLDebugUtils.glFunctionArgsToString(functionName, args);
+    const message2 = `${errorMessage} in gl.${functionName}(${functionArgs})`;
+    import_core11.log.error(message2)();
+    debugger;
+    if (props.throwOnError) {
+      throw new Error(message2);
+    }
+  }
+  function onValidateGLFunc(props, functionName, functionArgs) {
+    let functionString = "";
+    if (import_core11.log.level >= 1) {
+      functionString = getFunctionString(functionName, functionArgs);
+      import_core11.log.log(1, functionString)();
+    }
+    if (props.break && props.break.length > 0) {
+      functionString = functionString || getFunctionString(functionName, functionArgs);
+      const isBreakpoint = props.break.every(
+        (breakOn) => functionString.indexOf(breakOn) !== -1
+      );
+      if (isBreakpoint) {
+        debugger;
+      }
+    }
+    for (const arg of functionArgs) {
+      if (arg === void 0) {
+        functionString = functionString || getFunctionString(functionName, functionArgs);
+        if (props.throwOnError) {
+          throw new Error(`Undefined argument: ${functionString}`);
+        } else {
+          import_core11.log.error(`Undefined argument: ${functionString}`)();
+          debugger;
+        }
+      }
+    }
+  }
+
+  // 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;
     }
-  }
-  function makeDebugContext(gl, props = {}) {
-    if (!gl) {
-      return null;
+    destroy() {
+      if (!this.destroyed && this.handle) {
+        this.removeStats();
+        this.trackDeallocatedMemory();
+        this.gl.deleteBuffer(this.handle);
+        this.destroyed = true;
+        this.handle = null;
+      }
     }
-    return props.debug ? getDebugContext(gl, props) : getRealContext(gl);
-  }
-  function getRealContext(gl) {
-    const data = getWebGLContextData(gl);
-    return data.realContext ? data.realContext : gl;
-  }
-  function getDebugContext(gl, props) {
-    if (!globalThis.WebGLDebugUtils) {
-      import_core13.log.warn("webgl-debug not loaded")();
-      return gl;
+    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);
     }
-    const data = getWebGLContextData(gl);
-    if (data.debugContext) {
-      return data.debugContext;
+    /** Asynchronously read data from the buffer */
+    async readAsync(byteOffset = 0, byteLength) {
+      return this.readSyncWebGL(byteOffset, byteLength);
     }
-    globalThis.WebGLDebugUtils.init({ ...GLEnum, ...gl });
-    const glDebug = globalThis.WebGLDebugUtils.makeDebugContext(
-      gl,
-      onGLError.bind(null, props),
-      onValidateGLFunc.bind(null, props)
-    );
-    for (const key in GLEnum) {
-      if (!(key in glDebug) && typeof GLEnum[key] === "number") {
-        glDebug[key] = GLEnum[key];
-      }
+    /** 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;
     }
-    class WebGLDebugContext {
+  };
+  function getWebGLTarget(usage) {
+    if (usage & import_core12.Buffer.INDEX) {
+      return 34963 /* ELEMENT_ARRAY_BUFFER */;
     }
-    Object.setPrototypeOf(glDebug, Object.getPrototypeOf(gl));
-    Object.setPrototypeOf(WebGLDebugContext, glDebug);
-    const debugContext = Object.create(WebGLDebugContext);
-    data.realContext = gl;
-    data.debugContext = debugContext;
-    debugContext.debug = true;
-    return debugContext;
-  }
-  function getFunctionString(functionName, functionArgs) {
-    functionArgs = Array.from(functionArgs).map((arg) => arg === void 0 ? "undefined" : arg);
-    let args = globalThis.WebGLDebugUtils.glFunctionArgsToString(functionName, functionArgs);
-    args = `${args.slice(0, 100)}${args.length > 100 ? "..." : ""}`;
-    return `gl.${functionName}(${args})`;
-  }
-  function onGLError(props, err, functionName, args) {
-    args = Array.from(args).map((arg) => arg === void 0 ? "undefined" : arg);
-    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)();
-    debugger;
-    if (props.throwOnError) {
-      throw new Error(message2);
+    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 onValidateGLFunc(props, functionName, functionArgs) {
-    let functionString = "";
-    if (import_core13.log.level >= 1) {
-      functionString = getFunctionString(functionName, functionArgs);
-      import_core13.log.log(1, functionString)();
+  function getWebGLUsage(usage) {
+    if (usage & import_core12.Buffer.INDEX) {
+      return 35044 /* STATIC_DRAW */;
     }
-    if (props.break && props.break.length > 0) {
-      functionString = functionString || getFunctionString(functionName, functionArgs);
-      const isBreakpoint = props.break.every(
-        (breakOn) => functionString.indexOf(breakOn) !== -1
-      );
-      if (isBreakpoint) {
-        debugger;
-      }
+    if (usage & import_core12.Buffer.VERTEX) {
+      return 35044 /* STATIC_DRAW */;
     }
-    for (const arg of functionArgs) {
-      if (arg === void 0) {
-        functionString = functionString || getFunctionString(functionName, functionArgs);
-        if (props.throwOnError) {
-          throw new Error(`Undefined argument: ${functionString}`);
-        } else {
-          import_core13.log.error(`Undefined argument: ${functionString}`)();
-          debugger;
-        }
-      }
+    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) {
@@ -3921,7 +3713,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) {
@@ -3952,12 +3744,12 @@ var __exports__ = (() => {
     }
     getCompilationInfoSync() {
       const log9 = this.device.gl.getShaderInfoLog(this.handle);
-      return parseShaderCompilerLog(log9);
+      return log9 ? parseShaderCompilerLog(log9) : [];
     }
     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 */
@@ -3968,7 +3760,7 @@ ${source2}`;
       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;
       }
@@ -3980,9 +3772,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();
     }
@@ -4014,13 +3806,13 @@ ${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;
@@ -4048,9 +3840,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;
       }
@@ -4156,11 +3946,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";
@@ -4222,12 +4008,6 @@ ${source2}`;
     normalized: false,
     integer: false
   };
-  var PROP_CHECKS = {
-    deprecatedProps: {
-      instanced: "divisor",
-      isInstanced: "divisor"
-    }
-  };
   var Accessor = class {
     offset;
     stride;
@@ -4243,7 +4023,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;
     }
@@ -4272,7 +4051,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 */) {
@@ -4715,6 +4493,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) {
@@ -4724,14 +4530,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);
     }
@@ -4744,14 +4546,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);
     }
@@ -4759,7 +4557,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 */
@@ -4784,27 +4582,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) {
@@ -4822,14 +4611,14 @@ ${source2}`;
         if (!binding) {
           const validBindings = this.shaderLayout.bindings.map((binding2) => `"${binding2.name}"`).join(", ");
           if (!options?.disableWarnings) {
-            import_core17.log.warn(
+            import_core15.log.warn(
               `Unknown binding "${name}" in render pipeline "${this.id}", expected one of ${validBindings}`
             )();
           }
           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":
@@ -4843,7 +4632,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);
@@ -4875,17 +4664,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) {
@@ -4925,9 +4710,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?`
@@ -4942,19 +4727,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);
     }
@@ -5020,10 +4805,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;
@@ -5076,7 +4866,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;
@@ -5084,7 +4874,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":
@@ -5109,16 +4899,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) {
@@ -5145,8 +4948,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(
@@ -5205,8 +5008,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);
@@ -5269,7 +5074,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");
     }
@@ -5312,7 +5117,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}`,
@@ -5326,7 +5131,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) {
@@ -5365,8 +5170,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";
     }
@@ -5533,8 +5361,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;
       }
@@ -5560,8 +5388,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;
@@ -5624,7 +5452,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 };
@@ -5711,8 +5539,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;
@@ -5845,10 +5673,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 */:
@@ -5865,7 +5692,6 @@ ${source2}`;
       case 34836 /* RGBA32F */:
         return 4;
       default:
-        (0, import_core24.assert)(false);
         return 0;
     }
   }
@@ -5880,7 +5706,6 @@ ${source2}`;
       case 5126 /* FLOAT */:
         return 4;
       default:
-        (0, import_core24.assert)(false);
         return 0;
     }
   }
@@ -5902,12 +5727,11 @@ ${source2}`;
       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 */;
+    sourceType = sourceType || framebuffer.colorAttachments[attachment]?.texture?.glType || 5121 /* UNSIGNED_BYTE */;
     target = getPixelArray(target, sourceType, sourceFormat, sourceWidth, sourceHeight);
     sourceType = sourceType || getGLTypeFromTypedArray(target);
     const prevHandle = gl.bindFramebuffer(36160 /* FRAMEBUFFER */, handle);
@@ -5928,7 +5752,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;
@@ -5956,7 +5779,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 };
@@ -5983,11 +5806,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 = {};
@@ -6013,7 +5834,6 @@ ${source2}`;
         parameters.clearStencil = depth;
       }
     }
-    (0, import_core26.assert)(clearFlags !== 0, ERR_ARGUMENTS);
     const gl = device.gl;
     withGLParameters(gl, parameters, () => {
       gl.clear(clearFlags);
@@ -6022,7 +5842,7 @@ ${source2}`;
 
   // src/adapter/webgl-device.ts
   var LOG_LEVEL2 = 1;
-  var _WebGLDevice = class extends import_core27.Device {
+  var _WebGLDevice = class extends import_core22.Device {
     /** type of this device */
     type = "webgl";
     /** The underlying WebGL context */
@@ -6050,7 +5870,7 @@ ${source2}`;
       if (gl instanceof _WebGLDevice) {
         return gl;
       }
-      if (gl?.device instanceof import_core27.Device) {
+      if (gl?.device instanceof import_core22.Device) {
         return gl.device;
       }
       if (!isWebGL(gl)) {
@@ -6059,7 +5879,7 @@ ${source2}`;
       return new _WebGLDevice({ gl });
     }
     static async create(props = {}) {
-      import_core27.log.groupCollapsed(LOG_LEVEL2, "WebGLDevice created")();
+      import_core22.log.groupCollapsed(LOG_LEVEL2, "WebGLDevice created")();
       const promises = [];
       if (props.debug) {
         promises.push(loadWebGLDeveloperTools());
@@ -6068,31 +5888,31 @@ ${source2}`;
         promises.push(loadSpectorJS());
       }
       if (typeof props.canvas === "string") {
-        promises.push(import_core27.CanvasContext.pageLoaded);
+        promises.push(import_core22.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_core22.log.error(`Failed to initialize debug libraries ${result.reason}`)();
         }
       }
-      import_core27.log.probe(LOG_LEVEL2 + 1, "DOM is loaded")();
+      import_core22.log.probe(LOG_LEVEL2 + 1, "DOM is loaded")();
       if (props.gl?.device) {
-        import_core27.log.warn("reattaching existing device")();
+        import_core22.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)();
+      import_core22.log.probe(LOG_LEVEL2, message2)();
+      import_core22.log.table(LOG_LEVEL2, device.info)();
+      import_core22.log.groupEnd(LOG_LEVEL2)();
       return device;
     }
     //
     // Public API
     //
     constructor(props) {
-      super({ ...props, id: props.id || (0, import_core27.uid)("webgl-device") });
+      super({ ...props, id: props.id || "webgl-device" });
       const device = props.gl?.device;
       if (device) {
         throw new Error(`WebGL context already attached to device ${device.id}`);
@@ -6128,13 +5948,13 @@ ${source2}`;
       trackContextState(this.gl, {
         enable: enable2,
         copyState,
-        log: (...args) => import_core27.log.log(1, ...args)()
+        log: (...args) => import_core22.log.log(1, ...args)()
       });
       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.")();
       }
       if (props.spector) {
         this.spectorJS = initializeSpectorJS({ ...this.props, canvas: this.handle.canvas });
@@ -6169,6 +5989,7 @@ ${source2}`;
       const newProps = this._getBufferProps(props);
       return new WEBGLBuffer(this, newProps);
     }
+    // _createTexture(props: TextureProps): WEBGLTexture {
     _createTexture(props) {
       return new WEBGLTexture(this, props);
     }
@@ -6206,7 +6027,7 @@ ${source2}`;
       throw new Error("ComputePass not supported in WebGL");
     }
     renderPass = null;
-    createCommandEncoder(props) {
+    createCommandEncoder(props = {}) {
       return new WEBGLCommandEncoder(this, props);
     }
     /**
@@ -6242,7 +6063,7 @@ ${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);
     }
     //
@@ -6319,7 +6140,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`
         )();
@@ -6336,7 +6157,7 @@ ${source2}`;
           setConstantUintArray(this, location, constant);
           break;
         default:
-          (0, import_core27.assert)(false);
+          throw new Error("constant");
       }
     }
     /** Ensure extensions are only requested once */
@@ -6372,7 +6193,6 @@ ${source2}`;
         device.gl.vertexAttrib4fv(location, array);
         break;
       default:
-        (0, import_core27.assert)(false);
     }
   }
   function setConstantIntArray(device, location, array) {
@@ -6392,217 +6212,6 @@ ${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;
-    }
-    toString() {
-      return `${this.constructor.name}(${this.id})`;
-    }
-    get handle() {
-      return this._handle;
-    }
-    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());
-      }
-      return this;
-    }
-    bind(funcOrHandle = this.handle) {
-      if (typeof funcOrHandle !== "function") {
-        this._bindHandle(funcOrHandle);
-        return this;
-      }
-      let value;
-      if (!this._bound) {
-        this._bindHandle(this.handle);
-        this._bound = true;
-        value = funcOrHandle();
-        this._bound = false;
-        this._bindHandle(null);
-      } else {
-        value = funcOrHandle();
-      }
-      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);
-    }
-    _getParameter(pname, props) {
-      throw new Error(ERR_RESOURCE_METHOD_UNDEFINED);
-    }
-    _setParameter(pname, value) {
-      throw new Error(ERR_RESOURCE_METHOD_UNDEFINED);
-    }
-    // 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();
-      }
-    
-      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;
-      }
-    
-      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;
-      }
-      */
-  };
-
-  // 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;
-    }
-    /** 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");
-      }
-      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);
-      }
-    }
-    // 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);
-      }
-      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);
-    }
-  };
-  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
-  });
   return __toCommonJS(bundle_exports);
 })();
       return __exports__;