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

package/dist/dist.dev.js

@@ -74,10 +74,10 @@ var __exports__ = (() => {
   __reExport(bundle_exports, __toESM(require_core(), 1));
 
   // src/adapter/webgl-adapter.ts
-  var import_core23 = __toESM(require_core(), 1);
+  var import_core24 = __toESM(require_core(), 1);
 
   // src/adapter/webgl-device.ts
-  var import_core22 = __toESM(require_core(), 1);
+  var import_core23 = __toESM(require_core(), 1);
 
   // ../constants/src/webgl-constants.ts
   var GLEnum = /* @__PURE__ */ ((GLEnum2) => {
@@ -2142,13 +2142,13 @@ var __exports__ = (() => {
   };
 
   // src/adapter/webgl-canvas-context.ts
-  var import_core9 = __toESM(require_core(), 1);
+  var import_core10 = __toESM(require_core(), 1);
 
   // src/adapter/resources/webgl-framebuffer.ts
-  var import_core8 = __toESM(require_core(), 1);
+  var import_core9 = __toESM(require_core(), 1);
 
   // src/adapter/resources/webgl-texture.ts
-  var import_core7 = __toESM(require_core(), 1);
+  var import_core8 = __toESM(require_core(), 1);
 
   // src/context/state-tracker/with-parameters.ts
   function withGLParameters(gl, parameters, func) {
@@ -2568,6 +2568,94 @@ var __exports__ = (() => {
     }
   };
 
+  // src/adapter/helpers/webgl-texture-utils.ts
+  var import_core7 = __toESM(require_core(), 1);
+
+  // src/adapter/helpers/typed-array-utils.ts
+  var ERR_TYPE_DEDUCTION = "Failed to deduce GL constant from typed array";
+  function getGLTypeFromTypedArray(arrayOrType) {
+    const type = ArrayBuffer.isView(arrayOrType) ? arrayOrType.constructor : arrayOrType;
+    switch (type) {
+      case Float32Array:
+        return 5126 /* FLOAT */;
+      case Uint16Array:
+        return 5123 /* UNSIGNED_SHORT */;
+      case Uint32Array:
+        return 5125 /* UNSIGNED_INT */;
+      case Uint8Array:
+        return 5121 /* UNSIGNED_BYTE */;
+      case Uint8ClampedArray:
+        return 5121 /* UNSIGNED_BYTE */;
+      case Int8Array:
+        return 5120 /* BYTE */;
+      case Int16Array:
+        return 5122 /* SHORT */;
+      case Int32Array:
+        return 5124 /* INT */;
+      default:
+        throw new Error(ERR_TYPE_DEDUCTION);
+    }
+  }
+  function getTypedArrayFromGLType(glType, options) {
+    const { clamped = true } = options || {};
+    switch (glType) {
+      case 5126 /* FLOAT */:
+        return Float32Array;
+      case 5123 /* UNSIGNED_SHORT */:
+      case 33635 /* UNSIGNED_SHORT_5_6_5 */:
+      case 32819 /* UNSIGNED_SHORT_4_4_4_4 */:
+      case 32820 /* UNSIGNED_SHORT_5_5_5_1 */:
+        return Uint16Array;
+      case 5125 /* UNSIGNED_INT */:
+        return Uint32Array;
+      case 5121 /* UNSIGNED_BYTE */:
+        return clamped ? Uint8ClampedArray : Uint8Array;
+      case 5120 /* BYTE */:
+        return Int8Array;
+      case 5122 /* SHORT */:
+        return Int16Array;
+      case 5124 /* INT */:
+        return Int32Array;
+      default:
+        throw new Error("Failed to deduce typed array type from GL constant");
+    }
+  }
+
+  // src/adapter/helpers/format-utils.ts
+  function glFormatToComponents(format) {
+    switch (format) {
+      case 6406 /* ALPHA */:
+      case 33326 /* R32F */:
+      case 6403 /* RED */:
+        return 1;
+      case 33328 /* RG32F */:
+      case 33319 /* RG */:
+        return 2;
+      case 6407 /* RGB */:
+      case 34837 /* RGB32F */:
+        return 3;
+      case 6408 /* RGBA */:
+      case 34836 /* RGBA32F */:
+        return 4;
+      default:
+        return 0;
+    }
+  }
+  function glTypeToBytes(type) {
+    switch (type) {
+      case 5121 /* UNSIGNED_BYTE */:
+        return 1;
+      case 33635 /* UNSIGNED_SHORT_5_6_5 */:
+      case 32819 /* UNSIGNED_SHORT_4_4_4_4 */:
+      case 32820 /* UNSIGNED_SHORT_5_5_5_1 */:
+        return 2;
+      case 5126 /* FLOAT */:
+        return 4;
+      default:
+        return 0;
+    }
+  }
+
   // src/adapter/helpers/webgl-texture-utils.ts
   function initializeTextureStorage(gl, levels, options) {
     const { dimension, width, height, depth = 0 } = options;
@@ -2582,26 +2670,31 @@ var __exports__ = (() => {
         gl.texStorage2D(glTarget, levels, glInternalFormat, width, height);
     }
   }
-  function copyCPUImageToMipLevel(gl, image, options) {
-    const { dimension, width, height, depth = 0, level = 0 } = options;
+  function copyExternalImageToMipLevel(gl, handle, image, options) {
+    const { width, height } = options;
+    const { dimension, depth = 0, mipLevel = 0 } = options;
     const { x = 0, y = 0, z = 0 } = options;
     const { glFormat, glType } = options;
     const glTarget = getWebGLCubeFaceTarget(options.glTarget, dimension, depth);
     switch (dimension) {
       case "2d-array":
       case "3d":
-        gl.texSubImage3D(glTarget, level, x, y, z, width, height, depth, glFormat, glType, image);
+        gl.bindTexture(glTarget, handle);
+        gl.texSubImage3D(glTarget, mipLevel, x, y, z, width, height, depth, glFormat, glType, image);
+        gl.bindTexture(glTarget, null);
         break;
       case "2d":
       case "cube":
-        gl.texSubImage2D(glTarget, level, x, y, width, height, glFormat, glType, image);
+        gl.bindTexture(glTarget, handle);
+        gl.texSubImage2D(glTarget, mipLevel, x, y, width, height, glFormat, glType, image);
+        gl.bindTexture(glTarget, null);
         break;
       default:
         throw new Error(dimension);
     }
   }
   function copyCPUDataToMipLevel(gl, typedArray, options) {
-    const { dimension, width, height, depth = 0, level = 0, byteOffset = 0 } = options;
+    const { dimension, width, height, depth = 0, mipLevel = 0, byteOffset = 0 } = options;
     const { x = 0, y = 0, z = 0 } = options;
     const { glFormat, glType, compressed } = options;
     const glTarget = getWebGLCubeFaceTarget(options.glTarget, dimension, depth);
@@ -2609,17 +2702,17 @@ var __exports__ = (() => {
       case "2d-array":
       case "3d":
         if (compressed) {
-          gl.compressedTexSubImage3D(glTarget, level, x, y, z, width, height, depth, glFormat, typedArray, byteOffset);
+          gl.compressedTexSubImage3D(glTarget, mipLevel, x, y, z, width, height, depth, glFormat, typedArray, byteOffset);
         } else {
-          gl.texSubImage3D(glTarget, level, x, y, z, width, height, depth, glFormat, glType, typedArray, byteOffset);
+          gl.texSubImage3D(glTarget, mipLevel, 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);
+          gl.compressedTexSubImage2D(glTarget, mipLevel, x, y, width, height, glFormat, typedArray, byteOffset);
         } else {
-          gl.texSubImage2D(glTarget, level, x, y, width, height, glFormat, glType, typedArray, byteOffset);
+          gl.texSubImage2D(glTarget, mipLevel, x, y, width, height, glFormat, glType, typedArray, byteOffset);
         }
         break;
       default:
@@ -2646,6 +2739,102 @@ var __exports__ = (() => {
   function getWebGLCubeFaceTarget(glTarget, dimension, level) {
     return dimension === "cube" ? 34069 /* TEXTURE_CUBE_MAP_POSITIVE_X */ + level : glTarget;
   }
+  function readPixelsToArray(source, options) {
+    const {
+      sourceX = 0,
+      sourceY = 0,
+      sourceAttachment = 36064 /* COLOR_ATTACHMENT0 */
+      // TODO - support gl.readBuffer
+    } = options || {};
+    let {
+      target = null,
+      // following parameters are auto deduced if not provided
+      sourceWidth,
+      sourceHeight,
+      sourceDepth,
+      sourceFormat,
+      sourceType
+    } = options || {};
+    const { framebuffer, deleteFramebuffer } = getFramebuffer(source);
+    const { gl, handle } = framebuffer;
+    const attachment = sourceAttachment - 36064 /* COLOR_ATTACHMENT0 */;
+    sourceWidth ||= framebuffer.width;
+    sourceHeight ||= framebuffer.height;
+    sourceDepth = framebuffer.colorAttachments[attachment]?.texture?.depth || 1;
+    sourceFormat ||= framebuffer.colorAttachments[attachment]?.texture?.glFormat || 6408 /* RGBA */;
+    sourceType ||= framebuffer.colorAttachments[attachment]?.texture?.glType || 5121 /* UNSIGNED_BYTE */;
+    target = getPixelArray(target, sourceType, sourceFormat, sourceWidth, sourceHeight, sourceDepth);
+    sourceType = sourceType || getGLTypeFromTypedArray(target);
+    const prevHandle = gl.bindFramebuffer(36160 /* FRAMEBUFFER */, handle);
+    gl.readPixels(sourceX, sourceY, sourceWidth, sourceHeight, sourceFormat, sourceType, target);
+    gl.bindFramebuffer(36160 /* FRAMEBUFFER */, prevHandle || null);
+    if (deleteFramebuffer) {
+      framebuffer.destroy();
+    }
+    return target;
+  }
+  function readPixelsToBuffer(source, options) {
+    const {
+      target,
+      sourceX = 0,
+      sourceY = 0,
+      sourceFormat = 6408 /* RGBA */,
+      targetByteOffset = 0
+    } = options || {};
+    let { sourceWidth, sourceHeight, sourceType } = options || {};
+    const { framebuffer, deleteFramebuffer } = getFramebuffer(source);
+    sourceWidth = sourceWidth || framebuffer.width;
+    sourceHeight = sourceHeight || framebuffer.height;
+    const webglFramebuffer = framebuffer;
+    sourceType = sourceType || 5121 /* UNSIGNED_BYTE */;
+    let webglBufferTarget = target;
+    if (!webglBufferTarget) {
+      const components = glFormatToComponents(sourceFormat);
+      const byteCount = glTypeToBytes(sourceType);
+      const byteLength = targetByteOffset + sourceWidth * sourceHeight * components * byteCount;
+      webglBufferTarget = webglFramebuffer.device.createBuffer({ byteLength });
+    }
+    const commandEncoder = source.device.createCommandEncoder();
+    commandEncoder.copyTextureToBuffer({
+      source,
+      width: sourceWidth,
+      height: sourceHeight,
+      origin: [sourceX, sourceY],
+      destination: webglBufferTarget,
+      byteOffset: targetByteOffset
+    });
+    commandEncoder.destroy();
+    if (deleteFramebuffer) {
+      framebuffer.destroy();
+    }
+    return webglBufferTarget;
+  }
+  function getFramebuffer(source) {
+    if (!(source instanceof import_core7.Framebuffer)) {
+      return { framebuffer: toFramebuffer(source), deleteFramebuffer: true };
+    }
+    return { framebuffer: source, deleteFramebuffer: false };
+  }
+  function toFramebuffer(texture, props) {
+    const { device, width, height, id } = texture;
+    const framebuffer = device.createFramebuffer({
+      ...props,
+      id: `framebuffer-for-${id}`,
+      width,
+      height,
+      colorAttachments: [texture]
+    });
+    return framebuffer;
+  }
+  function getPixelArray(pixelArray, type, format, width, height, depth) {
+    if (pixelArray) {
+      return pixelArray;
+    }
+    type = type || 5121 /* UNSIGNED_BYTE */;
+    const ArrayType = getTypedArrayFromGLType(type, { clamped: false });
+    const components = glFormatToComponents(format);
+    return new ArrayType(width * height * components);
+  }
 
   // src/adapter/resources/webgl-texture.ts
   function normalizeTextureData(data, options) {
@@ -2667,7 +2856,7 @@ var __exports__ = (() => {
     }
     return lodArray;
   }
-  var WEBGLTexture = class extends import_core7.Texture {
+  var WEBGLTexture = class extends import_core8.Texture {
     MAX_ATTRIBUTES;
     device;
     gl;
@@ -2708,7 +2897,7 @@ var __exports__ = (() => {
     /** For automatically updating video */
     _video = null;
     constructor(device, props) {
-      super(device, { ...import_core7.Texture.defaultProps, ...props, data: void 0 });
+      super(device, { ...import_core8.Texture.defaultProps, ...props, data: void 0 });
       this.device = device;
       this.gl = this.device.gl;
       this.glTarget = getWebGLTextureTarget(this.props.dimension);
@@ -2736,7 +2925,7 @@ var __exports__ = (() => {
       const data = props.data;
       let { width, height } = props;
       if (!width || !height) {
-        const textureSize = import_core7.Texture.getTextureDataSize(data);
+        const textureSize = import_core8.Texture.getTextureDataSize(data);
         width = textureSize?.width || 1;
         height = textureSize?.height || 1;
       }
@@ -2829,7 +3018,7 @@ var __exports__ = (() => {
     }
     /** Update external texture (video frame or canvas) */
     update() {
-      import_core7.log.warn("Texture.update() not implemented");
+      import_core8.log.warn("Texture.update() not implemented");
     }
     // Call to regenerate mipmaps after modifying texture(s)
     generateMipmap(params = {}) {
@@ -2845,12 +3034,32 @@ var __exports__ = (() => {
     }
     // Image Data Setters
     copyExternalImage(options) {
-      const size = import_core7.Texture.getExternalImageSize(options.image);
-      const opts = { ...import_core7.Texture.defaultCopyExternalImageOptions, ...size, ...options };
-      const { depth, mipLevel: lodLevel, image } = opts;
-      this.bind();
-      this._setMipLevel(depth, lodLevel, image);
-      this.unbind();
+      const size = import_core8.Texture.getExternalImageSize(options.image);
+      const opts = { ...import_core8.Texture.defaultCopyExternalImageOptions, ...size, ...options };
+      const { image, depth, mipLevel, x, y, z } = opts;
+      let { width, height } = opts;
+      const { dimension, glTarget, glFormat, glInternalFormat, glType } = this;
+      width = Math.min(width, size.width - x);
+      height = Math.min(height, size.height - y);
+      if (options.sourceX || options.sourceY) {
+        throw new Error(
+          "WebGL does not yet support sourceX/sourceY in copyExternalImage; requires copyTexSubImage2D from a framebuffer"
+        );
+      }
+      copyExternalImageToMipLevel(this.device.gl, this.handle, image, {
+        dimension,
+        mipLevel,
+        x,
+        y,
+        z,
+        width,
+        height,
+        depth,
+        glFormat,
+        glInternalFormat,
+        glType,
+        glTarget
+      });
       return { width: opts.width, height: opts.height };
     }
     setTexture1DData(data) {
@@ -2861,7 +3070,7 @@ var __exports__ = (() => {
       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.`)();
+        import_core8.log.warn(`Texture ${this.id} mipmap and multiple LODs.`)();
       }
       for (let lodLevel = 0; lodLevel < lodArray.length; lodLevel++) {
         const imageData = lodArray[lodLevel];
@@ -2893,7 +3102,7 @@ var __exports__ = (() => {
       if (this.props.dimension !== "cube") {
         throw new Error(this.id);
       }
-      for (const face of import_core7.Texture.CubeFaces) {
+      for (const face of import_core8.Texture.CubeFaces) {
         this.setTextureCubeFaceData(data[face], face);
       }
     }
@@ -2916,9 +3125,9 @@ var __exports__ = (() => {
     }
     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.`)();
+        import_core8.log.warn(`${this.id} has mipmap and multiple LODs.`)();
       }
-      const faceDepth = import_core7.Texture.CubeFaces.indexOf(face);
+      const faceDepth = import_core8.Texture.CubeFaces.indexOf(face);
       this.setTexture2DData(lodData, faceDepth);
     }
     // INTERNAL METHODS
@@ -2954,8 +3163,8 @@ var __exports__ = (() => {
       }
     }
     _getImageDataMap(faceData) {
-      for (let i = 0; i < import_core7.Texture.CubeFaces.length; ++i) {
-        const faceName = import_core7.Texture.CubeFaces[i];
+      for (let i = 0; i < import_core8.Texture.CubeFaces.length; ++i) {
+        const faceName = import_core8.Texture.CubeFaces[i];
         if (faceData[faceName]) {
           faceData[34069 /* TEXTURE_CUBE_MAP_POSITIVE_X */ + i] = faceData[faceName];
           delete faceData[faceName];
@@ -2968,7 +3177,7 @@ var __exports__ = (() => {
      * Sets sampler parameters on texture
      */
     _setSamplerParameters(parameters) {
-      import_core7.log.log(1, "texture sampler parameters", parameters)();
+      import_core8.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);
@@ -3057,16 +3266,21 @@ var __exports__ = (() => {
      * Copy a region of data from a CPU memory buffer into this texture.
      * @todo -   GLUnpackParameters parameters
      */
-    _setMipLevel(depth, level, textureData, glTarget = this.glTarget) {
-      if (import_core7.Texture.isExternalImage(textureData)) {
-        copyCPUImageToMipLevel(this.device.gl, textureData, { ...this, depth, level, glTarget });
+    _setMipLevel(depth, mipLevel, textureData, glTarget = this.glTarget) {
+      if (import_core8.Texture.isExternalImage(textureData)) {
+        copyExternalImageToMipLevel(this.device.gl, this.handle, textureData, {
+          ...this,
+          depth,
+          mipLevel,
+          glTarget
+        });
         return;
       }
-      if (import_core7.Texture.isTextureLevelData(textureData)) {
+      if (import_core8.Texture.isTextureLevelData(textureData)) {
         copyCPUDataToMipLevel(this.device.gl, textureData.data, {
           ...this,
           depth,
-          level,
+          mipLevel,
           glTarget
         });
         return;
@@ -3098,7 +3312,7 @@ var __exports__ = (() => {
   };
 
   // src/adapter/resources/webgl-framebuffer.ts
-  var WEBGLFramebuffer = class extends import_core8.Framebuffer {
+  var WEBGLFramebuffer = class extends import_core9.Framebuffer {
     device;
     gl;
     handle;
@@ -3113,30 +3327,7 @@ var __exports__ = (() => {
       if (!isDefaultFramebuffer) {
         device.setSpectorMetadata(this.handle, { id: this.props.id, props: this.props });
         this.autoCreateAttachmentTextures();
-        const prevHandle = this.gl.bindFramebuffer(
-          36160 /* FRAMEBUFFER */,
-          this.handle
-        );
-        for (let i = 0; i < this.colorAttachments.length; ++i) {
-          const attachment = this.colorAttachments[i];
-          const attachmentPoint = 36064 /* COLOR_ATTACHMENT0 */ + i;
-          if (attachment) {
-            this._attachTexture(attachmentPoint, attachment);
-          }
-        }
-        if (this.depthStencilAttachment) {
-          this._attachTexture(
-            getDepthStencilAttachmentWebGL(this.depthStencilAttachment.props.format),
-            this.depthStencilAttachment
-          );
-        }
-        if (props.check !== false) {
-          const status = this.gl.checkFramebufferStatus(36160 /* FRAMEBUFFER */);
-          if (status !== 36053 /* FRAMEBUFFER_COMPLETE */) {
-            throw new Error(`Framebuffer ${_getFrameBufferStatus(status)}`);
-          }
-        }
-        this.gl.bindFramebuffer(36160 /* FRAMEBUFFER */, prevHandle);
+        this.updateAttachments();
       }
     }
     /** destroys any auto created resources etc. */
@@ -3146,6 +3337,32 @@ var __exports__ = (() => {
         this.gl.deleteFramebuffer(this.handle);
       }
     }
+    updateAttachments() {
+      const prevHandle = this.gl.bindFramebuffer(
+        36160 /* FRAMEBUFFER */,
+        this.handle
+      );
+      for (let i = 0; i < this.colorAttachments.length; ++i) {
+        const attachment = this.colorAttachments[i];
+        if (attachment) {
+          const attachmentPoint = 36064 /* COLOR_ATTACHMENT0 */ + i;
+          this._attachTextureView(attachmentPoint, attachment);
+        }
+      }
+      if (this.depthStencilAttachment) {
+        const attachmentPoint = getDepthStencilAttachmentWebGL(
+          this.depthStencilAttachment.props.format
+        );
+        this._attachTextureView(attachmentPoint, this.depthStencilAttachment);
+      }
+      if (this.props.check !== false) {
+        const status = this.gl.checkFramebufferStatus(36160 /* FRAMEBUFFER */);
+        if (status !== 36053 /* FRAMEBUFFER_COMPLETE */) {
+          throw new Error(`Framebuffer ${_getFrameBufferStatus(status)}`);
+        }
+      }
+      this.gl.bindFramebuffer(36160 /* FRAMEBUFFER */, prevHandle);
+    }
     // PRIVATE
     /** In WebGL we must use renderbuffers for depth/stencil attachments (unless we have extensions) */
     createDepthStencilTexture(format) {
@@ -3187,10 +3404,6 @@ var __exports__ = (() => {
         return this;
       }
       */
-    /** Attach one attachment */
-    _attachTexture(attachmentPoint, textureView) {
-      this._attachTextureView(attachmentPoint, textureView);
-    }
     /**
      * @param attachment
      * @param texture
@@ -3244,7 +3457,7 @@ var __exports__ = (() => {
   }
 
   // src/adapter/webgl-canvas-context.ts
-  var WebGLCanvasContext = class extends import_core9.CanvasContext {
+  var WebGLCanvasContext = class extends import_core10.CanvasContext {
     device;
     format = "rgba8unorm";
     depthStencilFormat = "depth24plus";
@@ -3297,7 +3510,7 @@ var __exports__ = (() => {
   };
 
   // src/context/debug/spector.ts
-  var import_core10 = __toESM(require_core(), 1);
+  var import_core11 = __toESM(require_core(), 1);
 
   // src/utils/load-script.ts
   async function loadScript(scriptUrl, scriptId) {
@@ -3323,7 +3536,7 @@ var __exports__ = (() => {
   var spector = null;
   var initialized = false;
   var DEFAULT_SPECTOR_PROPS = {
-    debugWithSpectorJS: import_core10.log.get("spector") || import_core10.log.get("spectorjs"),
+    debugWithSpectorJS: import_core11.log.get("spector") || import_core11.log.get("spectorjs"),
     // https://github.com/BabylonJS/Spector.js#basic-usage
     // https://forum.babylonjs.com/t/spectorcdn-is-temporarily-off/48241
     // spectorUrl: 'https://spectorcdn.babylonjs.com/spector.bundle.js';
@@ -3335,7 +3548,7 @@ var __exports__ = (() => {
       try {
         await loadScript(props.spectorUrl || DEFAULT_SPECTOR_PROPS.spectorUrl);
       } catch (error) {
-        import_core10.log.warn(String(error));
+        import_core11.log.warn(String(error));
       }
     }
   }
@@ -3345,7 +3558,7 @@ var __exports__ = (() => {
       return null;
     }
     if (!spector && globalThis.SPECTOR && !globalThis.luma?.spector) {
-      import_core10.log.probe(LOG_LEVEL, "SPECTOR found and initialized. Start with `luma.spector.displayUI()`")();
+      import_core11.log.probe(LOG_LEVEL, "SPECTOR found and initialized. Start with `luma.spector.displayUI()`")();
       const { Spector } = globalThis.SPECTOR;
       spector = new Spector();
       if (globalThis.luma) {
@@ -3359,10 +3572,10 @@ var __exports__ = (() => {
       initialized = true;
       spector.spyCanvases();
       spector?.onCaptureStarted.add(
-        (capture) => import_core10.log.info("Spector capture started:", capture)()
+        (capture) => import_core11.log.info("Spector capture started:", capture)()
       );
       spector?.onCapture.add((capture) => {
-        import_core10.log.info("Spector capture complete:", capture)();
+        import_core11.log.info("Spector capture complete:", capture)();
         spector?.getResultUI();
         spector?.resultView.display();
         spector?.resultView.addCapture(capture);
@@ -3374,7 +3587,7 @@ var __exports__ = (() => {
       spector?.startCapture(props.gl, 500);
       gl.device = device;
       new Promise((resolve) => setTimeout(resolve, 2e3)).then((_) => {
-        import_core10.log.info("Spector capture stopped after 2 seconds")();
+        import_core11.log.info("Spector capture stopped after 2 seconds")();
         spector?.stopCapture();
       });
     }
@@ -3382,7 +3595,7 @@ var __exports__ = (() => {
   }
 
   // src/context/debug/webgl-developer-tools.ts
-  var import_core11 = __toESM(require_core(), 1);
+  var import_core12 = __toESM(require_core(), 1);
 
   // ../../node_modules/@probe.gl/env/dist/lib/globals.js
   var document_ = globalThis.document || {};
@@ -3458,7 +3671,7 @@ var __exports__ = (() => {
   }
   function getDebugContext(gl, props) {
     if (!globalThis.WebGLDebugUtils) {
-      import_core11.log.warn("webgl-debug not loaded")();
+      import_core12.log.warn("webgl-debug not loaded")();
       return gl;
     }
     const data = getWebGLContextData(gl);
@@ -3497,7 +3710,7 @@ var __exports__ = (() => {
     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)();
+    import_core12.log.error(message2)();
     debugger;
     if (props.throwOnError) {
       throw new Error(message2);
@@ -3505,9 +3718,9 @@ var __exports__ = (() => {
   }
   function onValidateGLFunc(props, functionName, functionArgs) {
     let functionString = "";
-    if (import_core11.log.level >= 1) {
+    if (import_core12.log.level >= 1) {
       functionString = getFunctionString(functionName, functionArgs);
-      import_core11.log.log(1, functionString)();
+      import_core12.log.log(1, functionString)();
     }
     if (props.break && props.break.length > 0) {
       functionString = functionString || getFunctionString(functionName, functionArgs);
@@ -3524,7 +3737,7 @@ var __exports__ = (() => {
         if (props.throwOnError) {
           throw new Error(`Undefined argument: ${functionString}`);
         } else {
-          import_core11.log.error(`Undefined argument: ${functionString}`)();
+          import_core12.log.error(`Undefined argument: ${functionString}`)();
           debugger;
         }
       }
@@ -3540,8 +3753,8 @@ var __exports__ = (() => {
   }
 
   // src/adapter/resources/webgl-buffer.ts
-  var import_core12 = __toESM(require_core(), 1);
-  var WEBGLBuffer = class extends import_core12.Buffer {
+  var import_core13 = __toESM(require_core(), 1);
+  var WEBGLBuffer = class extends import_core13.Buffer {
     device;
     gl;
     handle;
@@ -3639,32 +3852,32 @@ var __exports__ = (() => {
     }
   };
   function getWebGLTarget(usage) {
-    if (usage & import_core12.Buffer.INDEX) {
+    if (usage & import_core13.Buffer.INDEX) {
       return 34963 /* ELEMENT_ARRAY_BUFFER */;
     }
-    if (usage & import_core12.Buffer.VERTEX) {
+    if (usage & import_core13.Buffer.VERTEX) {
       return 34962 /* ARRAY_BUFFER */;
     }
-    if (usage & import_core12.Buffer.UNIFORM) {
+    if (usage & import_core13.Buffer.UNIFORM) {
       return 35345 /* UNIFORM_BUFFER */;
     }
     return 34962 /* ARRAY_BUFFER */;
   }
   function getWebGLUsage(usage) {
-    if (usage & import_core12.Buffer.INDEX) {
+    if (usage & import_core13.Buffer.INDEX) {
       return 35044 /* STATIC_DRAW */;
     }
-    if (usage & import_core12.Buffer.VERTEX) {
+    if (usage & import_core13.Buffer.VERTEX) {
       return 35044 /* STATIC_DRAW */;
     }
-    if (usage & import_core12.Buffer.UNIFORM) {
+    if (usage & import_core13.Buffer.UNIFORM) {
       return 35048 /* DYNAMIC_DRAW */;
     }
     return 35044 /* STATIC_DRAW */;
   }
 
   // src/adapter/resources/webgl-shader.ts
-  var import_core13 = __toESM(require_core(), 1);
+  var import_core14 = __toESM(require_core(), 1);
 
   // src/adapter/helpers/parse-shader-compiler-log.ts
   function parseShaderCompilerLog(errLog) {
@@ -3711,7 +3924,7 @@ var __exports__ = (() => {
   }
 
   // src/adapter/resources/webgl-shader.ts
-  var WEBGLShader = class extends import_core13.Shader {
+  var WEBGLShader = class extends import_core14.Shader {
     device;
     handle;
     constructor(device, props) {
@@ -3741,8 +3954,8 @@ var __exports__ = (() => {
       return this.getCompilationInfoSync();
     }
     getCompilationInfoSync() {
-      const log10 = this.device.gl.getShaderInfoLog(this.handle);
-      return log10 ? parseShaderCompilerLog(log10) : [];
+      const log12 = this.device.gl.getShaderInfoLog(this.handle);
+      return log12 ? parseShaderCompilerLog(log12) : [];
     }
     getTranslatedSource() {
       const extensions = this.device.getExtension("WEBGL_debug_shaders");
@@ -3758,7 +3971,7 @@ ${source2}`;
       const { gl } = this.device;
       gl.shaderSource(this.handle, source);
       gl.compileShader(this.handle);
-      if (import_core13.log.level === 0) {
+      if (import_core14.log.level === 0) {
         this.compilationStatus = "pending";
         return;
       }
@@ -3770,9 +3983,9 @@ ${source2}`;
         }
         return;
       }
-      import_core13.log.once(1, "Shader compilation is asynchronous")();
+      import_core14.log.once(1, "Shader compilation is asynchronous")();
       await this._waitForCompilationComplete();
-      import_core13.log.info(2, `Shader ${this.id} - async compilation complete: ${this.compilationStatus}`)();
+      import_core14.log.info(2, `Shader ${this.id} - async compilation complete: ${this.compilationStatus}`)();
       this._getCompilationStatus();
       this.debugShader();
     }
@@ -3804,13 +4017,13 @@ ${source2}`;
   };
 
   // src/adapter/resources/webgl-render-pass.ts
-  var import_core14 = __toESM(require_core(), 1);
+  var import_core15 = __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_core14.RenderPass {
+  var WEBGLRenderPass = class extends import_core15.RenderPass {
     device;
     /** Parameters that should be applied before each draw call */
     glParameters;
@@ -3954,175 +4167,7 @@ ${source2}`;
   };
 
   // src/adapter/resources/webgl-render-pipeline.ts
-  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";
-  function getGLTypeFromTypedArray(arrayOrType) {
-    const type = ArrayBuffer.isView(arrayOrType) ? arrayOrType.constructor : arrayOrType;
-    switch (type) {
-      case Float32Array:
-        return 5126 /* FLOAT */;
-      case Uint16Array:
-        return 5123 /* UNSIGNED_SHORT */;
-      case Uint32Array:
-        return 5125 /* UNSIGNED_INT */;
-      case Uint8Array:
-        return 5121 /* UNSIGNED_BYTE */;
-      case Uint8ClampedArray:
-        return 5121 /* UNSIGNED_BYTE */;
-      case Int8Array:
-        return 5120 /* BYTE */;
-      case Int16Array:
-        return 5122 /* SHORT */;
-      case Int32Array:
-        return 5124 /* INT */;
-      default:
-        throw new Error(ERR_TYPE_DEDUCTION);
-    }
-  }
-  function getTypedArrayFromGLType(glType, options) {
-    const { clamped = true } = options || {};
-    switch (glType) {
-      case 5126 /* FLOAT */:
-        return Float32Array;
-      case 5123 /* UNSIGNED_SHORT */:
-      case 33635 /* UNSIGNED_SHORT_5_6_5 */:
-      case 32819 /* UNSIGNED_SHORT_4_4_4_4 */:
-      case 32820 /* UNSIGNED_SHORT_5_5_5_1 */:
-        return Uint16Array;
-      case 5125 /* UNSIGNED_INT */:
-        return Uint32Array;
-      case 5121 /* UNSIGNED_BYTE */:
-        return clamped ? Uint8ClampedArray : Uint8Array;
-      case 5120 /* BYTE */:
-        return Int8Array;
-      case 5122 /* SHORT */:
-        return Int16Array;
-      case 5124 /* INT */:
-        return Int32Array;
-      default:
-        throw new Error("Failed to deduce typed array type from GL constant");
-    }
-  }
-
-  // src/classic/accessor.ts
-  var DEFAULT_ACCESSOR_VALUES = {
-    offset: 0,
-    stride: 0,
-    type: 5126 /* FLOAT */,
-    size: 1,
-    divisor: 0,
-    normalized: false,
-    integer: false
-  };
-  var Accessor = class {
-    offset;
-    stride;
-    type;
-    size;
-    divisor;
-    normalized;
-    integer;
-    buffer;
-    index;
-    static getBytesPerElement(accessor) {
-      const ArrayType = getTypedArrayFromGLType(accessor.type || 5126 /* FLOAT */);
-      return ArrayType.BYTES_PER_ELEMENT;
-    }
-    static getBytesPerVertex(accessor) {
-      const ArrayType = getTypedArrayFromGLType(accessor.type || 5126 /* FLOAT */);
-      return ArrayType.BYTES_PER_ELEMENT * accessor.size;
-    }
-    // Combines (merges) a list of accessors. On top of default values
-    // Usually [programAccessor, bufferAccessor, appAccessor]
-    // All props will be set in the returned object.
-    // TODO check for conflicts between values in the supplied accessors
-    static resolve(...accessors) {
-      return new Accessor(...[DEFAULT_ACCESSOR_VALUES, ...accessors]);
-    }
-    constructor(...accessors) {
-      accessors.forEach((accessor) => this._assign(accessor));
-      Object.freeze(this);
-    }
-    toString() {
-      return JSON.stringify(this);
-    }
-    // ACCESSORS
-    // TODO - remove>
-    get BYTES_PER_ELEMENT() {
-      return Accessor.getBytesPerElement(this);
-    }
-    get BYTES_PER_VERTEX() {
-      return Accessor.getBytesPerVertex(this);
-    }
-    // PRIVATE
-    // eslint-disable-next-line complexity, max-statements
-    _assign(props = {}) {
-      if (props.type !== void 0) {
-        this.type = props.type;
-        if (props.type === 5124 /* INT */ || props.type === 5125 /* UNSIGNED_INT */) {
-          this.integer = true;
-        }
-      }
-      if (props.size !== void 0) {
-        this.size = props.size;
-      }
-      if (props.offset !== void 0) {
-        this.offset = props.offset;
-      }
-      if (props.stride !== void 0) {
-        this.stride = props.stride;
-      }
-      if (props.normalize !== void 0) {
-        this.normalized = props.normalize;
-      }
-      if (props.normalized !== void 0) {
-        this.normalized = props.normalized;
-      }
-      if (props.integer !== void 0) {
-        this.integer = props.integer;
-      }
-      if (props.divisor !== void 0) {
-        this.divisor = props.divisor;
-      }
-      if (props.buffer !== void 0) {
-        this.buffer = props.buffer;
-      }
-      if (props.index !== void 0) {
-        if (typeof props.index === "boolean") {
-          this.index = props.index ? 1 : 0;
-        } else {
-          this.index = props.index;
-        }
-      }
-      if (props.instanced !== void 0) {
-        this.divisor = props.instanced ? 1 : 0;
-      }
-      if (props.isInstanced !== void 0) {
-        this.divisor = props.isInstanced ? 1 : 0;
-      }
-      if (this.offset === void 0)
-        delete this.offset;
-      if (this.stride === void 0)
-        delete this.stride;
-      if (this.type === void 0)
-        delete this.type;
-      if (this.size === void 0)
-        delete this.size;
-      if (this.divisor === void 0)
-        delete this.divisor;
-      if (this.normalized === void 0)
-        delete this.normalized;
-      if (this.integer === void 0)
-        delete this.integer;
-      if (this.buffer === void 0)
-        delete this.buffer;
-      if (this.index === void 0)
-        delete this.index;
-      return this;
-    }
-  };
+  var import_core16 = __toESM(require_core(), 1);
 
   // src/adapter/helpers/decode-webgl-types.ts
   function isSamplerUniform(type) {
@@ -4289,8 +4334,7 @@ ${source2}`;
       }
       const { name, type: compositeType, size } = activeInfo;
       const { glType, components } = decodeGLUniformType(compositeType);
-      const accessor = new Accessor({ type: glType, size: size * components });
-      const varying = { location, name, accessor };
+      const varying = { location, name, type: glType, size: size * components };
       varyings.push(varying);
     }
     varyings.sort((a, b) => a.location - b.location);
@@ -4503,13 +4547,16 @@ ${source2}`;
 
   // ../../node_modules/@math.gl/types/dist/is-array.js
   function isTypedArray(value) {
-    return ArrayBuffer.isView(value) && !(value instanceof DataView) ? value : null;
+    return ArrayBuffer.isView(value) && !(value instanceof DataView);
   }
-  function isNumericArray(value) {
+  function isNumberArray(value) {
     if (Array.isArray(value)) {
-      return value.length === 0 || typeof value[0] === "number" ? value : null;
+      return value.length === 0 || typeof value[0] === "number";
     }
-    return isTypedArray(value);
+    return false;
+  }
+  function isNumericArray(value) {
+    return isTypedArray(value) || isNumberArray(value);
   }
 
   // src/utils/split-uniforms-and-bindings.ts
@@ -4565,7 +4612,7 @@ ${source2}`;
 
   // src/adapter/resources/webgl-render-pipeline.ts
   var LOG_PROGRAM_PERF_PRIORITY = 4;
-  var WEBGLRenderPipeline = class extends import_core15.RenderPipeline {
+  var WEBGLRenderPipeline = class extends import_core16.RenderPipeline {
     /** The WebGL device that created this render pipeline */
     device;
     /** Handle to underlying WebGL program */
@@ -4598,9 +4645,9 @@ ${source2}`;
         this.device.gl.transformFeedbackVaryings(this.handle, varyings, bufferMode);
       }
       this._linkShaders();
-      import_core15.log.time(1, `RenderPipeline ${this.id} - shaderLayout introspection`)();
+      import_core16.log.time(1, `RenderPipeline ${this.id} - shaderLayout introspection`)();
       this.introspectedLayout = getShaderLayout(this.device.gl, this.handle);
-      import_core15.log.timeEnd(1, `RenderPipeline ${this.id} - shaderLayout introspection`)();
+      import_core16.log.timeEnd(1, `RenderPipeline ${this.id} - shaderLayout introspection`)();
       this.shaderLayout = mergeShaderLayout(this.introspectedLayout, props.shaderLayout);
     }
     destroy() {
@@ -4619,7 +4666,7 @@ ${source2}`;
         if (!binding) {
           const validBindings = this.shaderLayout.bindings.map((binding2) => `"${binding2.name}"`).join(", ");
           if (!options?.disableWarnings) {
-            import_core15.log.warn(
+            import_core16.log.warn(
               `No binding "${name}" in render pipeline "${this.id}", expected one of ${validBindings}`,
               value
             )();
@@ -4627,7 +4674,7 @@ ${source2}`;
           continue;
         }
         if (!value) {
-          import_core15.log.warn(`Unsetting binding "${name}" in render pipeline "${this.id}"`)();
+          import_core16.log.warn(`Unsetting binding "${name}" in render pipeline "${this.id}"`)();
         }
         switch (binding.type) {
           case "uniform":
@@ -4641,7 +4688,7 @@ ${source2}`;
             }
             break;
           case "sampler":
-            import_core15.log.warn(`Ignoring sampler ${name}`)();
+            import_core16.log.warn(`Ignoring sampler ${name}`)();
             break;
           default:
             throw new Error(binding.type);
@@ -4673,11 +4720,11 @@ ${source2}`;
       const isIndexed = Boolean(vertexArray.indexBuffer);
       const glIndexType = vertexArray.indexBuffer?.glIndexType;
       if (this.linkStatus !== "success") {
-        import_core15.log.info(2, `RenderPipeline:${this.id}.draw() aborted - waiting for shader linking`)();
+        import_core16.log.info(2, `RenderPipeline:${this.id}.draw() aborted - waiting for shader linking`)();
         return false;
       }
       if (!this._areTexturesRenderable()) {
-        import_core15.log.info(2, `RenderPipeline:${this.id}.draw() aborted - textures not yet loaded`)();
+        import_core16.log.info(2, `RenderPipeline:${this.id}.draw() aborted - textures not yet loaded`)();
         return false;
       }
       this.device.gl.useProgram(this.handle);
@@ -4721,7 +4768,7 @@ ${source2}`;
     setUniformsWebGL(uniforms) {
       const { bindings } = splitUniformsAndBindings(uniforms);
       Object.keys(bindings).forEach((name) => {
-        import_core15.log.warn(
+        import_core16.log.warn(
           `Unsupported value "${JSON.stringify(
             bindings[name]
           )}" used in setUniforms() for key ${name}. Use setBindings() instead?`
@@ -4736,19 +4783,19 @@ ${source2}`;
       const { gl } = this.device;
       gl.attachShader(this.handle, this.vs.handle);
       gl.attachShader(this.handle, this.fs.handle);
-      import_core15.log.time(LOG_PROGRAM_PERF_PRIORITY, `linkProgram for ${this.id}`)();
+      import_core16.log.time(LOG_PROGRAM_PERF_PRIORITY, `linkProgram for ${this.id}`)();
       gl.linkProgram(this.handle);
-      import_core15.log.timeEnd(LOG_PROGRAM_PERF_PRIORITY, `linkProgram for ${this.id}`)();
-      if (import_core15.log.level === 0) {
+      import_core16.log.timeEnd(LOG_PROGRAM_PERF_PRIORITY, `linkProgram for ${this.id}`)();
+      if (import_core16.log.level === 0) {
       }
       if (!this.device.features.has("compilation-status-async-webgl")) {
         const status2 = this._getLinkStatus();
         this._reportLinkStatus(status2);
         return;
       }
-      import_core15.log.once(1, "RenderPipeline linking is asynchronous")();
+      import_core16.log.once(1, "RenderPipeline linking is asynchronous")();
       await this._waitForLinkComplete();
-      import_core15.log.info(2, `RenderPipeline ${this.id} - async linking complete: ${this.linkStatus}`)();
+      import_core16.log.info(2, `RenderPipeline ${this.id} - async linking complete: ${this.linkStatus}`)();
       const status = this._getLinkStatus();
       this._reportLinkStatus(status);
     }
@@ -4816,7 +4863,7 @@ ${source2}`;
       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}`)();
+          import_core16.log.warn(`Binding ${bindingInfo.name} not found in ${this.id}`)();
           texturesRenderable = false;
         }
       }
@@ -4875,7 +4922,7 @@ ${source2}`;
             } else if (value instanceof WEBGLTexture) {
               texture = value;
             } else if (value instanceof WEBGLFramebuffer && value.colorAttachments[0] instanceof WEBGLTextureView) {
-              import_core15.log.warn(
+              import_core16.log.warn(
                 "Passing framebuffer in texture binding may be deprecated. Use fbo.colorAttachments[0] instead"
               )();
               texture = value.colorAttachments[0].texture;
@@ -4916,7 +4963,7 @@ ${source2}`;
     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`);
+        import_core16.log.warn(`shader layout attribute ${attribute.name} not present in shader`);
       } else {
         baseAttribute.type = attribute.type || baseAttribute.type;
         baseAttribute.stepMode = attribute.stepMode || baseAttribute.stepMode;
@@ -4926,11 +4973,11 @@ ${source2}`;
   }
 
   // src/adapter/resources/webgl-command-encoder.ts
-  var import_core17 = __toESM(require_core(), 1);
+  var import_core18 = __toESM(require_core(), 1);
 
   // src/adapter/resources/webgl-command-buffer.ts
-  var import_core16 = __toESM(require_core(), 1);
-  var WEBGLCommandBuffer = class extends import_core16.CommandBuffer {
+  var import_core17 = __toESM(require_core(), 1);
+  var WEBGLCommandBuffer = class extends import_core17.CommandBuffer {
     device;
     commands = [];
     constructor(device) {
@@ -5011,7 +5058,7 @@ ${source2}`;
     if (mipLevel !== 0 || depthOrArrayLayers !== 0 || bytesPerRow || rowsPerImage) {
       throw new Error("not implemented");
     }
-    const { framebuffer, destroyFramebuffer } = getFramebuffer(source);
+    const { framebuffer, destroyFramebuffer } = getFramebuffer2(source);
     let prevHandle;
     try {
       const webglBuffer = destination;
@@ -5069,7 +5116,7 @@ ${source2}`;
       height = options.destination.height
       // depthOrArrayLayers = 0
     } = options;
-    const { framebuffer, destroyFramebuffer } = getFramebuffer(source);
+    const { framebuffer, destroyFramebuffer } = getFramebuffer2(source);
     const [sourceX, sourceY] = origin;
     const [destinationX, destinationY, destinationZ] = destinationOrigin;
     const prevHandle = device.gl.bindFramebuffer(
@@ -5125,8 +5172,8 @@ ${source2}`;
       framebuffer.destroy();
     }
   }
-  function getFramebuffer(source) {
-    if (source instanceof import_core16.Texture) {
+  function getFramebuffer2(source) {
+    if (source instanceof import_core17.Texture) {
       const { width, height, id } = source;
       const framebuffer = source.device.createFramebuffer({
         id: `framebuffer-for-${id}`,
@@ -5140,7 +5187,7 @@ ${source2}`;
   }
 
   // src/adapter/resources/webgl-command-encoder.ts
-  var WEBGLCommandEncoder = class extends import_core17.CommandEncoder {
+  var WEBGLCommandEncoder = class extends import_core18.CommandEncoder {
     device;
     commandBuffer;
     constructor(device, props) {
@@ -5179,7 +5226,7 @@ ${source2}`;
   };
 
   // src/adapter/resources/webgl-vertex-array.ts
-  var import_core18 = __toESM(require_core(), 1);
+  var import_core19 = __toESM(require_core(), 1);
 
   // src/utils/fill-array.ts
   function fillArray(options) {
@@ -5203,7 +5250,7 @@ ${source2}`;
   }
 
   // src/adapter/resources/webgl-vertex-array.ts
-  var WEBGLVertexArray = class extends import_core18.VertexArray {
+  var WEBGLVertexArray = class extends import_core19.VertexArray {
     get [Symbol.toStringTag]() {
       return "VertexArray";
     }
@@ -5371,7 +5418,7 @@ ${source2}`;
       this.buffer = this.buffer || this.device.createBuffer({ byteLength });
       updateNeeded = updateNeeded || !compareConstantArrayValues(constantValue, this.bufferValue);
       if (updateNeeded) {
-        const typedArray = (0, import_core18.getScratchArray)(value.constructor, length);
+        const typedArray = (0, import_core19.getScratchArray)(value.constructor, length);
         fillArray({ target: typedArray, source: constantValue, start: 0, count: length });
         this.buffer.write(typedArray);
         this.bufferValue = value;
@@ -5398,8 +5445,8 @@ ${source2}`;
   }
 
   // src/adapter/resources/webgl-transform-feedback.ts
-  var import_core19 = __toESM(require_core(), 1);
-  var WEBGLTransformFeedback = class extends import_core19.TransformFeedback {
+  var import_core20 = __toESM(require_core(), 1);
+  var WEBGLTransformFeedback = class extends import_core20.TransformFeedback {
     device;
     gl;
     handle;
@@ -5462,7 +5509,7 @@ ${source2}`;
       const { buffer, byteLength, byteOffset } = this._getBufferRange(bufferOrRange);
       if (location < 0) {
         this.unusedBuffers[locationOrName] = buffer;
-        import_core19.log.warn(`${this.id} unusedBuffers varying buffer ${locationOrName}`)();
+        import_core20.log.warn(`${this.id} unusedBuffers varying buffer ${locationOrName}`)();
         return;
       }
       this.buffers[location] = { buffer, byteLength, byteOffset };
@@ -5549,8 +5596,8 @@ ${source2}`;
   }
 
   // src/adapter/resources/webgl-query-set.ts
-  var import_core20 = __toESM(require_core(), 1);
-  var WEBGLQuerySet = class extends import_core20.QuerySet {
+  var import_core21 = __toESM(require_core(), 1);
+  var WEBGLQuerySet = class extends import_core21.QuerySet {
     device;
     handle;
     target = null;
@@ -5682,147 +5729,13 @@ ${source2}`;
     }
   };
 
-  // src/classic/copy-and-blit.ts
-  var import_core21 = __toESM(require_core(), 1);
-
-  // src/classic/format-utils.ts
-  function glFormatToComponents(format) {
-    switch (format) {
-      case 6406 /* ALPHA */:
-      case 33326 /* R32F */:
-      case 6403 /* RED */:
-        return 1;
-      case 33328 /* RG32F */:
-      case 33319 /* RG */:
-        return 2;
-      case 6407 /* RGB */:
-      case 34837 /* RGB32F */:
-        return 3;
-      case 6408 /* RGBA */:
-      case 34836 /* RGBA32F */:
-        return 4;
-      default:
-        return 0;
-    }
-  }
-  function glTypeToBytes(type) {
-    switch (type) {
-      case 5121 /* UNSIGNED_BYTE */:
-        return 1;
-      case 33635 /* UNSIGNED_SHORT_5_6_5 */:
-      case 32819 /* UNSIGNED_SHORT_4_4_4_4 */:
-      case 32820 /* UNSIGNED_SHORT_5_5_5_1 */:
-        return 2;
-      case 5126 /* FLOAT */:
-        return 4;
-      default:
-        return 0;
-    }
-  }
-
-  // src/classic/copy-and-blit.ts
-  function readPixelsToArray(source, options) {
-    const {
-      sourceX = 0,
-      sourceY = 0,
-      sourceAttachment = 36064 /* COLOR_ATTACHMENT0 */
-      // TODO - support gl.readBuffer
-    } = options || {};
-    let {
-      target = null,
-      // following parameters are auto deduced if not provided
-      sourceWidth,
-      sourceHeight,
-      sourceDepth,
-      sourceFormat,
-      sourceType
-    } = options || {};
-    const { framebuffer, deleteFramebuffer } = getFramebuffer2(source);
-    const { gl, handle } = framebuffer;
-    const attachment = sourceAttachment - 36064 /* COLOR_ATTACHMENT0 */;
-    sourceWidth ||= framebuffer.width;
-    sourceHeight ||= framebuffer.height;
-    sourceDepth = framebuffer.colorAttachments[attachment]?.texture?.depth || 1;
-    sourceFormat ||= framebuffer.colorAttachments[attachment]?.texture?.glFormat || 6408 /* RGBA */;
-    sourceType ||= framebuffer.colorAttachments[attachment]?.texture?.glType || 5121 /* UNSIGNED_BYTE */;
-    target = getPixelArray(target, sourceType, sourceFormat, sourceWidth, sourceHeight, sourceDepth);
-    sourceType = sourceType || getGLTypeFromTypedArray(target);
-    const prevHandle = gl.bindFramebuffer(36160 /* FRAMEBUFFER */, handle);
-    gl.readPixels(sourceX, sourceY, sourceWidth, sourceHeight, sourceFormat, sourceType, target);
-    gl.bindFramebuffer(36160 /* FRAMEBUFFER */, prevHandle || null);
-    if (deleteFramebuffer) {
-      framebuffer.destroy();
-    }
-    return target;
-  }
-  function readPixelsToBuffer(source, options) {
-    const {
-      target,
-      sourceX = 0,
-      sourceY = 0,
-      sourceFormat = 6408 /* RGBA */,
-      targetByteOffset = 0
-    } = options || {};
-    let { sourceWidth, sourceHeight, sourceType } = options || {};
-    const { framebuffer, deleteFramebuffer } = getFramebuffer2(source);
-    sourceWidth = sourceWidth || framebuffer.width;
-    sourceHeight = sourceHeight || framebuffer.height;
-    const webglFramebuffer = framebuffer;
-    sourceType = sourceType || 5121 /* UNSIGNED_BYTE */;
-    let webglBufferTarget = target;
-    if (!webglBufferTarget) {
-      const components = glFormatToComponents(sourceFormat);
-      const byteCount = glTypeToBytes(sourceType);
-      const byteLength = targetByteOffset + sourceWidth * sourceHeight * components * byteCount;
-      webglBufferTarget = webglFramebuffer.device.createBuffer({ byteLength });
-    }
-    const commandEncoder = source.device.createCommandEncoder();
-    commandEncoder.copyTextureToBuffer({
-      source,
-      width: sourceWidth,
-      height: sourceHeight,
-      origin: [sourceX, sourceY],
-      destination: webglBufferTarget,
-      byteOffset: targetByteOffset
-    });
-    commandEncoder.destroy();
-    if (deleteFramebuffer) {
-      framebuffer.destroy();
-    }
-    return webglBufferTarget;
-  }
-  function getFramebuffer2(source) {
-    if (!(source instanceof import_core21.Framebuffer)) {
-      return { framebuffer: toFramebuffer(source), deleteFramebuffer: true };
-    }
-    return { framebuffer: source, deleteFramebuffer: false };
-  }
-  function toFramebuffer(texture, props) {
-    const { device, width, height, id } = texture;
-    const framebuffer = device.createFramebuffer({
-      ...props,
-      id: `framebuffer-for-${id}`,
-      width,
-      height,
-      colorAttachments: [texture]
-    });
-    return framebuffer;
-  }
-  function getPixelArray(pixelArray, type, format, width, height, depth) {
-    if (pixelArray) {
-      return pixelArray;
-    }
-    type = type || 5121 /* UNSIGNED_BYTE */;
-    const ArrayType = getTypedArrayFromGLType(type, { clamped: false });
-    const components = glFormatToComponents(format);
-    return new ArrayType(width * height * components);
-  }
-
-  // src/classic/clear.ts
+  // src/deprecated/clear.ts
+  var import_core22 = __toESM(require_core(), 1);
   var GL_DEPTH_BUFFER_BIT2 = 256;
   var GL_STENCIL_BUFFER_BIT2 = 1024;
   var GL_COLOR_BUFFER_BIT2 = 16384;
   function clear(device, options) {
+    import_core22.log.warn("clear will be removed in next minor release");
     const { framebuffer = null, color = null, depth = null, stencil = null } = options || {};
     const parameters = {};
     if (framebuffer) {
@@ -5854,7 +5767,7 @@ ${source2}`;
   }
 
   // src/adapter/webgl-device.ts
-  var WebGLDevice = class extends import_core22.Device {
+  var WebGLDevice = class extends import_core23.Device {
     //
     // Public `Device` API
     //
@@ -5914,14 +5827,14 @@ ${source2}`;
       }
       this.canvasContext.resize();
       const glState = new WebGLStateTracker(this.gl, {
-        log: (...args) => import_core22.log.log(1, ...args)()
+        log: (...args) => import_core23.log.log(1, ...args)()
       });
       glState.trackState(this.gl, { copyState: false });
       if (props.debug) {
         this.gl = makeDebugContext(this.gl, { ...props, throwOnError: true });
         this.debug = true;
-        import_core22.log.level = Math.max(import_core22.log.level, 1);
-        import_core22.log.warn("WebGL debug mode activated. Performance reduced.")();
+        import_core23.log.level = Math.max(import_core23.log.level, 1);
+        import_core23.log.warn("WebGL debug mode activated. Performance reduced.")();
       }
     }
     /**
@@ -6024,7 +5937,7 @@ ${source2}`;
       clear(this, options);
     }
     resetWebGL() {
-      import_core22.log.warn("WebGLDevice.resetWebGL is deprecated, use only for debugging")();
+      import_core23.log.warn("WebGLDevice.resetWebGL is deprecated, use only for debugging")();
       resetGLParameters(this.gl);
     }
     //
@@ -6093,7 +6006,7 @@ ${source2}`;
       this._constants = this._constants || new Array(maxVertexAttributes).fill(null);
       const currentConstant = this._constants[location];
       if (currentConstant && compareConstantArrayValues2(currentConstant, constant)) {
-        import_core22.log.info(
+        import_core23.log.info(
           1,
           `setConstantAttributeWebGL(${location}) could have been skipped, value unchanged`
         )();
@@ -6260,12 +6173,12 @@ ${source2}`;
 
   // src/adapter/webgl-adapter.ts
   var LOG_LEVEL2 = 1;
-  var WebGLAdapter = class extends import_core23.Adapter {
+  var WebGLAdapter = class extends import_core24.Adapter {
     /** type of device's created by this adapter */
     type = "webgl";
     constructor() {
       super();
-      import_core23.Device.defaultProps = { ...import_core23.Device.defaultProps, ...DEFAULT_SPECTOR_PROPS };
+      import_core24.Device.defaultProps = { ...import_core24.Device.defaultProps, ...DEFAULT_SPECTOR_PROPS };
       WebGLDevice.adapter = this;
     }
     /** Check if WebGL 2 is available */
@@ -6286,7 +6199,7 @@ ${source2}`;
       if (gl instanceof WebGLDevice) {
         return gl;
       }
-      if (gl?.device instanceof import_core23.Device) {
+      if (gl?.device instanceof import_core24.Device) {
         return gl.device;
       }
       if (!isWebGL(gl)) {
@@ -6295,7 +6208,7 @@ ${source2}`;
       return new WebGLDevice({ gl });
     }
     async create(props = {}) {
-      import_core23.log.groupCollapsed(LOG_LEVEL2, "WebGLDevice created")();
+      import_core24.log.groupCollapsed(LOG_LEVEL2, "WebGLDevice created")();
       const promises = [];
       if (props.debug) {
         promises.push(loadWebGLDeveloperTools());
@@ -6304,20 +6217,20 @@ ${source2}`;
         promises.push(loadSpectorJS(props));
       }
       if (typeof props.canvas === "string") {
-        promises.push(import_core23.CanvasContext.pageLoaded);
+        promises.push(import_core24.CanvasContext.pageLoaded);
       }
       const results = await Promise.allSettled(promises);
       for (const result of results) {
         if (result.status === "rejected") {
-          import_core23.log.error(`Failed to initialize debug libraries ${result.reason}`)();
+          import_core24.log.error(`Failed to initialize debug libraries ${result.reason}`)();
         }
       }
-      import_core23.log.probe(LOG_LEVEL2 + 1, "DOM is loaded")();
+      import_core24.log.probe(LOG_LEVEL2 + 1, "DOM is loaded")();
       const device = new WebGLDevice(props);
       const message2 = `Created ${device.type}${device.debug ? " debug" : ""} context: ${device.info.vendor}, ${device.info.renderer} for canvas: ${device.canvasContext.id}`;
-      import_core23.log.probe(LOG_LEVEL2, message2)();
-      import_core23.log.table(LOG_LEVEL2, device.info)();
-      import_core23.log.groupEnd(LOG_LEVEL2)();
+      import_core24.log.probe(LOG_LEVEL2, message2)();
+      import_core24.log.table(LOG_LEVEL2, device.info)();
+      import_core24.log.groupEnd(LOG_LEVEL2)();
       return device;
     }
   };
@@ -6328,6 +6241,150 @@ ${source2}`;
     return Boolean(gl && Number.isFinite(gl._version));
   }
   var webgl2Adapter = new WebGLAdapter();
+
+  // src/deprecated/accessor.ts
+  var import_core25 = __toESM(require_core(), 1);
+  var DEFAULT_ACCESSOR_VALUES = {
+    offset: 0,
+    stride: 0,
+    type: 5126 /* FLOAT */,
+    size: 1,
+    divisor: 0,
+    normalized: false,
+    integer: false
+  };
+  var Accessor = class {
+    offset;
+    stride;
+    type;
+    size;
+    divisor;
+    normalized;
+    integer;
+    buffer;
+    index;
+    static getBytesPerElement(accessor) {
+      const ArrayType = getTypedArrayFromGLType2(accessor.type || 5126 /* FLOAT */);
+      return ArrayType.BYTES_PER_ELEMENT;
+    }
+    static getBytesPerVertex(accessor) {
+      const ArrayType = getTypedArrayFromGLType2(accessor.type || 5126 /* FLOAT */);
+      return ArrayType.BYTES_PER_ELEMENT * accessor.size;
+    }
+    // Combines (merges) a list of accessors. On top of default values
+    // Usually [programAccessor, bufferAccessor, appAccessor]
+    // All props will be set in the returned object.
+    // TODO check for conflicts between values in the supplied accessors
+    static resolve(...accessors) {
+      return new Accessor(...[DEFAULT_ACCESSOR_VALUES, ...accessors]);
+    }
+    constructor(...accessors) {
+      import_core25.log.warn("Accessor will be removed in next minor release");
+      accessors.forEach((accessor) => this._assign(accessor));
+      Object.freeze(this);
+    }
+    toString() {
+      return JSON.stringify(this);
+    }
+    // ACCESSORS
+    // TODO - remove>
+    get BYTES_PER_ELEMENT() {
+      return Accessor.getBytesPerElement(this);
+    }
+    get BYTES_PER_VERTEX() {
+      return Accessor.getBytesPerVertex(this);
+    }
+    // PRIVATE
+    // eslint-disable-next-line complexity, max-statements
+    _assign(props = {}) {
+      if (props.type !== void 0) {
+        this.type = props.type;
+        if (props.type === 5124 /* INT */ || props.type === 5125 /* UNSIGNED_INT */) {
+          this.integer = true;
+        }
+      }
+      if (props.size !== void 0) {
+        this.size = props.size;
+      }
+      if (props.offset !== void 0) {
+        this.offset = props.offset;
+      }
+      if (props.stride !== void 0) {
+        this.stride = props.stride;
+      }
+      if (props.normalize !== void 0) {
+        this.normalized = props.normalize;
+      }
+      if (props.normalized !== void 0) {
+        this.normalized = props.normalized;
+      }
+      if (props.integer !== void 0) {
+        this.integer = props.integer;
+      }
+      if (props.divisor !== void 0) {
+        this.divisor = props.divisor;
+      }
+      if (props.buffer !== void 0) {
+        this.buffer = props.buffer;
+      }
+      if (props.index !== void 0) {
+        if (typeof props.index === "boolean") {
+          this.index = props.index ? 1 : 0;
+        } else {
+          this.index = props.index;
+        }
+      }
+      if (props.instanced !== void 0) {
+        this.divisor = props.instanced ? 1 : 0;
+      }
+      if (props.isInstanced !== void 0) {
+        this.divisor = props.isInstanced ? 1 : 0;
+      }
+      if (this.offset === void 0)
+        delete this.offset;
+      if (this.stride === void 0)
+        delete this.stride;
+      if (this.type === void 0)
+        delete this.type;
+      if (this.size === void 0)
+        delete this.size;
+      if (this.divisor === void 0)
+        delete this.divisor;
+      if (this.normalized === void 0)
+        delete this.normalized;
+      if (this.integer === void 0)
+        delete this.integer;
+      if (this.buffer === void 0)
+        delete this.buffer;
+      if (this.index === void 0)
+        delete this.index;
+      return this;
+    }
+  };
+  function getTypedArrayFromGLType2(glType, options) {
+    const { clamped = true } = options || {};
+    switch (glType) {
+      case 5126 /* FLOAT */:
+        return Float32Array;
+      case 5123 /* UNSIGNED_SHORT */:
+      case 33635 /* UNSIGNED_SHORT_5_6_5 */:
+      case 32819 /* UNSIGNED_SHORT_4_4_4_4 */:
+      case 32820 /* UNSIGNED_SHORT_5_5_5_1 */:
+        return Uint16Array;
+      case 5125 /* UNSIGNED_INT */:
+        return Uint32Array;
+      case 5121 /* UNSIGNED_BYTE */:
+        return clamped ? Uint8ClampedArray : Uint8Array;
+      case 5120 /* BYTE */:
+        return Int8Array;
+      case 5122 /* SHORT */:
+        return Int16Array;
+      case 5124 /* INT */:
+        return Int32Array;
+      default:
+        throw new Error("Failed to deduce typed array type from GL constant");
+    }
+  }
   return __toCommonJS(bundle_exports);
 })();
       return __exports__;