@luma.gl/gltf 9.0.0-alpha.47 → 9.0.0-alpha.50

package/dist/dist.dev.js

@@ -822,8 +822,6 @@ var __exports__ = (() => {
         VERSION: VERSION3,
         version: VERSION3,
         log,
-        // A global stats object that various components can add information to
-        // E.g. see webgl/resource.js
         stats: lumaStats
       };
     }
@@ -863,17 +861,10 @@ var __exports__ = (() => {
 
   // ../core/src/adapter/resources/resource.ts
   var Resource = class {
-    /** props.id, for debugging. */
     userData = {};
-    /** Whether this resource has been destroyed */
     destroyed = false;
-    /** For resources that allocate GPU memory */
     allocatedBytes = 0;
-    /** Attached resources will be destroyed when this resource is destroyed. Tracks auto-created "sub" resources. */
     _attachedResources = /* @__PURE__ */ new Set();
-    /**
-     * Create a new Resource. Called from Subclass
-     */
     constructor(device, props, defaultProps) {
       if (!device) {
         throw new Error("no device");
@@ -886,13 +877,9 @@ var __exports__ = (() => {
       this.userData = this.props.userData || {};
       this.addStats();
     }
-    /**
-     * destroy can be called on any resource to release it before it is garbage collected.
-     */
     destroy() {
       this.destroyResource();
     }
-    /** @deprecated Use destroy() */
     delete() {
       this.destroy();
       return this;
@@ -900,70 +887,48 @@ var __exports__ = (() => {
     toString() {
       return `${this[Symbol.toStringTag] || this.constructor.name}(${this.id})`;
     }
-    /**
-     * Combines a map of user props and default props, only including props from defaultProps
-     * @returns returns a map of overridden default props
-     */
     getProps() {
       return this.props;
     }
-    // ATTACHED RESOURCES
-    /** 
-     * Attaches a resource. Attached resources are auto destroyed when this resource is destroyed
-     * Called automatically when sub resources are auto created but can be called by application
-     */
     attachResource(resource) {
       this._attachedResources.add(resource);
     }
-    /** 
-     * Detach an attached resource. The resource will no longer be auto-destroyed when this resource is destroyed.
-     */
     detachResource(resource) {
       this._attachedResources.delete(resource);
     }
-    /** 
-     * Destroys a resource (only if owned), and removes from the owned (auto-destroy) list for this resource.
-     */
     destroyAttachedResource(resource) {
       if (this._attachedResources.delete(resource)) {
         resource.destroy();
       }
     }
-    /** Destroy all owned resources. Make sure the resources are no longer needed before calling. */
     destroyAttachedResources() {
       for (const resource of Object.values(this._attachedResources)) {
         resource.destroy();
       }
       this._attachedResources = /* @__PURE__ */ new Set();
     }
-    // PROTECTED METHODS
-    /** Perform all destroy steps. Can be called by derived resources when overriding destroy() */
     destroyResource() {
       this.destroyAttachedResources();
       this.removeStats();
       this.destroyed = true;
     }
-    /** Called by .destroy() to track object destruction. Subclass must call if overriding destroy() */
     removeStats() {
       const stats = this._device.statsManager.getStats("Resource Counts");
       const name2 = this[Symbol.toStringTag];
       stats.get(`${name2}s Active`).decrementCount();
     }
-    /** Called by subclass to track memory allocations */
     trackAllocatedMemory(bytes, name2 = this[Symbol.toStringTag]) {
       const stats = this._device.statsManager.getStats("Resource Counts");
       stats.get("GPU Memory").addCount(bytes);
       stats.get(`${name2} Memory`).addCount(bytes);
       this.allocatedBytes = bytes;
     }
-    /** Called by subclass to track memory deallocations */
     trackDeallocatedMemory(name2 = this[Symbol.toStringTag]) {
       const stats = this._device.statsManager.getStats("Resource Counts");
       stats.get("GPU Memory").subtractCount(this.allocatedBytes);
       stats.get(`${name2} Memory`).subtractCount(this.allocatedBytes);
       this.allocatedBytes = 0;
     }
-    /** Called by resource constructor to track object creation */
     addStats() {
       const stats = this._device.statsManager.getStats("Resource Counts");
       const name2 = this[Symbol.toStringTag];
@@ -972,7 +937,6 @@ var __exports__ = (() => {
       stats.get(`${name2}s Active`).incrementCount();
     }
   };
-  /** Default properties for resource */
   __publicField(Resource, "defaultProps", {
     id: "undefined",
     handle: void 0,
@@ -995,9 +959,6 @@ var __exports__ = (() => {
     get [Symbol.toStringTag]() {
       return "Buffer";
     }
-    /** The usage with which this buffer was created */
-    /** For index buffers, whether indices are 16 or 32 bit */
-    /** Length of buffer in bytes */
     constructor(device, props) {
       const deducedProps = {
         ...props
@@ -1019,159 +980,55 @@ var __exports__ = (() => {
     readAsync(byteOffset, byteLength) {
       throw new Error("not implemented");
     }
-    // TODO - can sync read be supported in WebGPU?
     getData() {
       throw new Error("not implemented");
     }
-    // Convenience API
-    /** Read data from the buffer *
-    async readAsync(options: {
-      byteOffset?: number,
-      byteLength?: number,
-      map?: boolean,
-      unmap?: boolean
-    }): Promise<ArrayBuffer> {
-      if (options.map ?? true) {
-        await this.mapAsync(Buffer.MAP_READ, options.byteOffset, options.byteLength);
-      }
-      const arrayBuffer = this.getMappedRange(options.byteOffset, options.byteLength);
-      if (options.unmap ?? true) {
-        this.unmap();
-      }
-      return arrayBuffer;
-    }
-     /** Write data to the buffer *
-    async writeAsync(options: {
-      data: ArrayBuffer,
-      byteOffset?: number,
-      byteLength?: number,
-      map?: boolean,
-      unmap?: boolean
-    }): Promise<void> {
-      if (options.map ?? true) {
-        await this.mapAsync(Buffer.MAP_WRITE, options.byteOffset, options.byteLength);
-      }
-      const arrayBuffer = this.getMappedRange(options.byteOffset, options.byteLength);
-      const destArray = new Uint8Array(arrayBuffer);
-      const srcArray = new Uint8Array(options.data);
-      destArray.set(srcArray);
-      if (options.unmap ?? true) {
-        this.unmap();
-      }
-    }
-    */
-    // Mapped API (WebGPU)
-    /** Maps the memory so that it can be read */
-    // abstract mapAsync(mode, byteOffset, byteLength): Promise<void>
-    /** Get the mapped range of data for reading or writing */
-    // abstract getMappedRange(byteOffset, byteLength): ArrayBuffer;
-    /** unmap makes the contents of the buffer available to the GPU again */
-    // abstract unmap(): void;
   };
   var Buffer2 = _Buffer;
   __publicField(Buffer2, "defaultProps", {
     ...Resource.defaultProps,
     usage: 0,
-    // Buffer.COPY_DST | Buffer.COPY_SRC
     byteLength: 0,
     byteOffset: 0,
     data: null,
     indexType: "uint16",
     mappedAtCreation: false
   });
-  // Usage Flags
   __publicField(Buffer2, "MAP_READ", 1);
   __publicField(Buffer2, "MAP_WRITE", 2);
   __publicField(Buffer2, "COPY_SRC", 4);
   __publicField(Buffer2, "COPY_DST", 8);
-  /** Index buffer */
   __publicField(Buffer2, "INDEX", 16);
-  /** Vertex buffer */
   __publicField(Buffer2, "VERTEX", 32);
-  /** Uniform buffer */
   __publicField(Buffer2, "UNIFORM", 64);
-  /** Storage buffer */
   __publicField(Buffer2, "STORAGE", 128);
   __publicField(Buffer2, "INDIRECT", 256);
   __publicField(Buffer2, "QUERY_RESOLVE", 512);
 
   // ../core/src/adapter/device.ts
-  var DEFAULT_DEVICE_PROPS = {
-    id: null,
-    type: "best-available",
-    canvas: null,
-    container: null,
-    webgl2: true,
-    // Attempt to create a WebGL2 context
-    webgl1: true,
-    // Attempt to create a WebGL1 context (false to fail if webgl2 not available)
-    manageState: true,
-    width: 800,
-    // width are height are only used by headless gl
-    height: 600,
-    debug: Boolean(log.get("debug")),
-    // Instrument context (at the expense of performance)
-    break: [],
-    // alpha: undefined,
-    // depth: undefined,
-    // stencil: undefined,
-    // antialias: undefined,
-    // premultipliedAlpha: undefined,
-    // preserveDrawingBuffer: undefined,
-    // failIfMajorPerformanceCaveat: undefined
-    gl: null
-  };
-  var Device = class {
+  var _Device = class {
     get [Symbol.toStringTag]() {
       return "Device";
     }
     constructor(props) {
       this.props = {
-        ...DEFAULT_DEVICE_PROPS,
+        ..._Device.defaultProps,
         ...props
       };
       this.id = this.props.id || uid(this[Symbol.toStringTag].toLowerCase());
     }
-    /** id of this device, primarily for debugging */
-    /** stats */
     statsManager = lumaStats;
-    /** A copy of the device props  */
-    /** Available for the application to store data on the device */
     userData = {};
-    /** Used by other luma.gl modules to store data on the device */
     _lumaData = {};
-    // Capabilities
-    /** Information about the device (vendor, versions etc) */
-    /** Optional capability discovery */
-    /** WebGPU style device limits */
-    /** Check if device supports a specific texture format (creation and `nearest` sampling) */
-    /** Check if linear filtering (sampler interpolation) is supported for a specific texture format */
-    /** Check if device supports rendering to a specific texture format */
-    // Device loss
-    /** `true` if device is already lost */
-    /** Promise that resolves when device is lost */
-    /**
-     * Trigger device loss.
-     * @returns `true` if context loss could actually be triggered.
-     * @note primarily intended for testing how application reacts to device loss
-     */
     loseDevice() {
       return false;
     }
-    // Canvas context
-    /** Default / primary canvas context. Can be null as WebGPU devices can be created without a CanvasContext */
-    /** Returns the default / primary canvas context. Throws an error if no canvas context is available (a WebGPU compute device) */
     getCanvasContext() {
       if (!this.canvasContext) {
         throw new Error("Device has no CanvasContext");
       }
       return this.canvasContext;
     }
-    /** Creates a new CanvasContext (WebGPU only) */
-    /** Call after rendering a frame (necessary e.g. on WebGL OffscreenCanvas) */
-    // Resource creation
-    /** Create a buffer */
-    /** Create a texture */
     createTexture(props) {
       if (props instanceof Promise || typeof props === "string") {
         props = {
@@ -1180,21 +1037,9 @@ var __exports__ = (() => {
       }
       return this._createTexture(props);
     }
-    /** Create a temporary texture view of a video source */
-    /** Create a sampler */
-    /** Create a Framebuffer. Must have at least one attachment. */
-    /** Create a shader */
-    /** Create a render pipeline (aka program) */
-    /** Create a compute pipeline (aka program). WebGPU only. */
     createCommandEncoder(props = {}) {
       throw new Error("not implemented");
     }
-    /** Create a vertex array */
-    /** Create a RenderPass */
-    /** Create a ComputePass */
-    /** Get a renderpass that is set up to render to the primary CanvasContext */
-    /** Create a transform feedback (immutable set of output buffer bindings). WebGL 2 only. */
-    // Implementation
     _getBufferProps(props) {
       if (props instanceof ArrayBuffer || ArrayBuffer.isView(props)) {
         props = {
@@ -1216,6 +1061,21 @@ var __exports__ = (() => {
       return newProps;
     }
   };
+  var Device = _Device;
+  __publicField(Device, "defaultProps", {
+    id: null,
+    type: "best-available",
+    canvas: null,
+    container: null,
+    webgl2: true,
+    webgl1: true,
+    manageState: true,
+    width: 800,
+    height: 600,
+    debug: Boolean(log.get("debug")),
+    break: [],
+    gl: null
+  });
   __publicField(Device, "VERSION", VERSION2);
 
   // ../core/src/adapter/canvas-context.ts
@@ -1224,7 +1084,6 @@ var __exports__ = (() => {
   var DEFAULT_CANVAS_CONTEXT_PROPS = {
     canvas: null,
     width: 800,
-    // width are height are only used by headless gl
     height: 600,
     useDevicePixels: true,
     autoResize: true,
@@ -1236,13 +1095,11 @@ var __exports__ = (() => {
   var CanvasContext = class {
     width = 1;
     height = 1;
-    /** State used by luma.gl classes: TODO - move to canvasContext*/
     _canvasSizeInfo = {
       clientWidth: 0,
       clientHeight: 0,
       devicePixelRatio: 1
     };
-    /** Check if the DOM is loaded */
     static get isPageLoaded() {
       return isPageLoaded();
     }
@@ -1293,11 +1150,6 @@ var __exports__ = (() => {
         this.resizeObserver.observe(this.canvas);
       }
     }
-    /** Returns a framebuffer with properly resized current 'swap chain' textures */
-    /**
-     * Returns the current DPR, if props.useDevicePixels is true
-     * Device refers to physical
-     */
     getDevicePixelRatio(useDevicePixels) {
       if (typeof OffscreenCanvas !== "undefined" && this.canvas instanceof OffscreenCanvas) {
         return 1;
@@ -1312,12 +1164,6 @@ var __exports__ = (() => {
       }
       return useDevicePixels;
     }
-    /**
-     * Returns the size of drawing buffer in device pixels.
-     * @note This can be different from the 'CSS' size of a canvas, and also from the
-     * canvas' internal drawing buffer size (.width, .height).
-     * This is the size required to cover the canvas, adjusted for DPR
-     */
     getPixelSize() {
       switch (this.type) {
         case "node":
@@ -1336,9 +1182,6 @@ var __exports__ = (() => {
       const [width, height] = this.getPixelSize();
       return width / height;
     }
-    /**
-     * Returns multiplier need to convert CSS size to Device size
-     */
     cssToDeviceRatio() {
       try {
         const [drawingBufferWidth] = this.getDrawingBufferSize();
@@ -1350,18 +1193,11 @@ var __exports__ = (() => {
         return 1;
       }
     }
-    /**
-     * Maps CSS pixel position to device pixel position
-     */
     cssToDevicePixels(cssPixel, yInvert = true) {
       const ratio = this.cssToDeviceRatio();
       const [width, height] = this.getDrawingBufferSize();
       return scalePixels(cssPixel, ratio, width, height, yInvert);
     }
-    /**
-     * Use devicePixelRatio to set canvas width and height
-     * @note this is a raw port of luma.gl v8 code. Might be worth a review
-     */
     setDevicePixelRatio(devicePixelRatio, options = {}) {
       if (!this.htmlCanvas) {
         return;
@@ -1393,8 +1229,6 @@ var __exports__ = (() => {
         this._canvasSizeInfo.devicePixelRatio = devicePixelRatio;
       }
     }
-    // PRIVATE
-    /** @todo Major hack done to port the CSS methods above, base canvas context should not depend on WebGL */
     getDrawingBufferSize() {
       const gl = this.device.gl;
       if (!gl) {
@@ -1402,23 +1236,12 @@ var __exports__ = (() => {
       }
       return [gl.drawingBufferWidth, gl.drawingBufferHeight];
     }
-    /** Perform platform specific updates (WebGPU vs WebGL) */
-    /**
-     * Allows subclass constructor to override the canvas id for auto created canvases.
-     * This can really help when debugging DOM in apps that create multiple devices
-     */
     _setAutoCreatedCanvasId(id) {
       if (this.htmlCanvas?.id === "lumagl-auto-created-canvas") {
         this.htmlCanvas.id = id;
       }
     }
   };
-  /**
-   * Get a 'lazy' promise that resolves when the DOM is loaded.
-   * @note Since there may be limitations on number of `load` event listeners,
-   * it is recommended avoid calling this function until actually needed.
-   * I.e. don't call it until you know that you will be looking up a string in the DOM.
-   */
   __publicField(CanvasContext, "pageLoaded", getPageLoadPromise());
   function getPageLoadPromise() {
     if (isPageLoaded() || typeof window === "undefined") {
@@ -1449,7 +1272,7 @@ var __exports__ = (() => {
       throw new Error(`Accessing '${canvasId}' before page was loaded`);
     }
     if (!(canvas instanceof HTMLCanvasElement)) {
-      throw new Error(`'${canvas}' is not a canvas element`);
+      throw new Error("Object is not a canvas element");
     }
     return canvas;
   }
@@ -1484,7 +1307,6 @@ var __exports__ = (() => {
     return {
       x,
       y,
-      // when ratio < 1, current css pixel and next css pixel may point to same device pixel, set width/height to 1 in those cases.
       width: Math.max(xHigh - x + 1, 1),
       height: Math.max(yHigh - y + 1, 1)
     };
@@ -1502,12 +1324,6 @@ var __exports__ = (() => {
     get [Symbol.toStringTag]() {
       return "Texture";
     }
-    /** dimension of this texture */
-    /** format of this texture */
-    /** width in pixels of this texture */
-    /** height in pixels of this texture */
-    /** depth of this texture */
-    /** Default sampler for this texture */
     constructor(device, props, defaultProps = _Texture.defaultProps) {
       super(device, props, defaultProps);
       this.dimension = this.props.dimension;
@@ -1528,11 +1344,8 @@ var __exports__ = (() => {
     depth: 1,
     mipmaps: true,
     sampler: {},
-    // type: undefined,
     compressed: false,
-    // mipLevels: 1,
     usage: 0,
-    // usage: GPUTextureUsage.COPY_DST
     mipLevels: void 0,
     samples: void 0,
     type: void 0
@@ -1585,7 +1398,6 @@ var __exports__ = (() => {
     mipmapFilter: "nearest",
     lodMinClamp: 0,
     lodMaxClamp: 32,
-    // Per WebGPU spec
     compare: "less-equal",
     maxAnisotropy: 1
   });
@@ -1595,21 +1407,13 @@ var __exports__ = (() => {
     get [Symbol.toStringTag]() {
       return "Framebuffer";
     }
-    /** Width of all attachments in this framebuffer */
-    /** Height of all attachments in this framebuffer */
-    /** Color attachments */
     colorAttachments = [];
-    /** Depth-stencil attachment, if provided */
     depthStencilAttachment = null;
     constructor(device, props = {}) {
       super(device, props, _Framebuffer.defaultProps);
       this.width = this.props.width;
       this.height = this.props.height;
     }
-    /**
-     * Resizes all attachments
-     * @note resize() destroys existing textures (if size has changed).
-     */
     resize(size) {
       let updateSize = !size;
       if (size) {
@@ -1623,51 +1427,6 @@ var __exports__ = (() => {
         this.resizeAttachments(this.width, this.height);
       }
     }
-    // /** Returns fully populated attachment object. */
-    // protected normalizeColorAttachment(
-    //   attachment: Texture | ColorTextureFormat
-    // ): Required<ColorAttachment> {
-    //   const COLOR_ATTACHMENT_DEFAULTS: Required<ColorAttachment> = {
-    //     texture: undefined!,
-    //     format: undefined!,
-    //     clearValue: [0.0, 0.0, 0.0, 0.0],
-    //     loadOp: 'clear',
-    //     storeOp: 'store'
-    //   };
-    //   if (attachment instanceof Texture) {
-    //     return {...COLOR_ATTACHMENT_DEFAULTS, texture: attachment};
-    //   }
-    //   if (typeof attachment === 'string') {
-    //     return {...COLOR_ATTACHMENT_DEFAULTS, format: attachment};
-    //   }
-    //   return {...COLOR_ATTACHMENT_DEFAULTS, ...attachment};
-    // }
-    // /** Wraps texture inside fully populated attachment object. */
-    // protected normalizeDepthStencilAttachment(
-    //   attachment: DepthStencilAttachment | Texture | DepthStencilTextureFormat
-    // ): Required<DepthStencilAttachment> {
-    //   const DEPTH_STENCIL_ATTACHMENT_DEFAULTS: Required<DepthStencilAttachment> = {
-    //     texture: undefined!,
-    //     format: undefined!,
-    //     depthClearValue: 1.0,
-    //     depthLoadOp: 'clear',
-    //     depthStoreOp: 'store',
-    //     depthReadOnly: false,
-    //     stencilClearValue: 0,
-    //     stencilLoadOp: 'clear',
-    //     stencilStoreOp: 'store',
-    //     stencilReadOnly: false
-    //   };
-    //   if (typeof attachment === 'string') {
-    //     return {...DEPTH_STENCIL_ATTACHMENT_DEFAULTS, format: attachment};
-    //   }
-    //   // @ts-expect-error attachment instanceof Texture doesn't cover Renderbuffer
-    //   if (attachment.handle || attachment instanceof Texture) {
-    //     return {...DEPTH_STENCIL_ATTACHMENT_DEFAULTS, texture: attachment as Texture};
-    //   }
-    //   return {...DEPTH_STENCIL_ATTACHMENT_DEFAULTS, ...attachment};
-    // }
-    /** Auto creates any textures */
     autoCreateAttachmentTextures() {
       this.colorAttachments = this.props.colorAttachments.map((attachment) => {
         if (typeof attachment === "string") {
@@ -1687,7 +1446,6 @@ var __exports__ = (() => {
         }
       }
     }
-    /** Create a color texture */
     createColorTexture(format) {
       return this.device.createTexture({
         id: "color-attachment",
@@ -1697,7 +1455,6 @@ var __exports__ = (() => {
         height: this.height
       });
     }
-    /** Create depth stencil texture */
     createDepthStencilTexture(format) {
       return this.device.createTexture({
         id: "depth-stencil-attachment",
@@ -1707,11 +1464,6 @@ var __exports__ = (() => {
         height: this.height
       });
     }
-    /**
-     * Default implementation of resize
-     * Creates new textures with correct size for all attachments.
-     * and destroys existing textures if owned
-     */
     resizeAttachments(width, height) {
       for (let i = 0; i < this.colorAttachments.length; ++i) {
         if (this.colorAttachments[i]) {
@@ -1736,37 +1488,6 @@ var __exports__ = (() => {
         this.attachResource(resizedTexture);
       }
     }
-    /** Create a color attachment for WebGL *
-    protected override createColorTexture(colorAttachment: Required<ColorAttachment>): Required<ColorAttachment> {
-      return this.device._createTexture({
-        id: `${this.id}-color`,
-        data: null, // reserves texture memory, but texels are undefined
-        format,
-        // type: GL.UNSIGNED_BYTE,
-        width: this.width,
-        height: this.height,
-        // Note: Mipmapping can be disabled by texture resource when we resize the texture
-        // to a non-power-of-two dimenstion (NPOT texture) under WebGL1. To have consistant
-        // behavior we always disable mipmaps.
-        mipmaps: false,
-        // Set MIN and MAG filtering parameters so mipmaps are not used in sampling.
-        // Use LINEAR so subpixel algos like fxaa work.
-        // Set WRAP modes that support NPOT textures too.
-        sampler: {
-          minFilter: 'linear',
-          magFilter: 'linear',
-          addressModeU: 'clamp-to-edge',
-          addressModeV: 'clamp-to-edge'
-        }
-        // parameters: {
-        //   [GL.TEXTURE_MIN_FILTER]: GL.LINEAR,
-        //   [GL.TEXTURE_MAG_FILTER]: GL.LINEAR,
-        //   [GL.TEXTURE_WRAP_S]: GL.CLAMP_TO_EDGE,
-        //   [GL.TEXTURE_WRAP_T]: GL.CLAMP_TO_EDGE
-        // }
-      });
-    }
-    */
   };
   var Framebuffer = _Framebuffer;
   __publicField(Framebuffer, "defaultProps", {
@@ -1774,9 +1495,7 @@ var __exports__ = (() => {
     width: 1,
     height: 1,
     colorAttachments: [],
-    // ['rgba8unorm-unsized'],
     depthStencilAttachment: null
-    // 'depth24plus-stencil8'
   });
 
   // ../core/src/adapter/resources/render-pipeline.ts
@@ -1785,31 +1504,20 @@ var __exports__ = (() => {
       return "RenderPipeline";
     }
     hash = "";
-    /** The merged layout */
-    /** Buffer map describing buffer interleaving etc */
     constructor(device, props) {
       super(device, props, _RenderPipeline.defaultProps);
       this.shaderLayout = this.props.shaderLayout;
       this.bufferLayout = this.props.bufferLayout || [];
     }
-    /** Set bindings (stored on pipeline and set before each call) */
-    /** Uniforms
-     * @deprecated Only supported on WebGL devices.
-     * @note textures, samplers and uniform buffers should be set via `setBindings()`, these are not considered uniforms.
-     * @note In WebGL uniforms have a performance penalty, they are reset before each call to enable pipeline sharing.
-     */
-    /** Draw call */
   };
   var RenderPipeline = _RenderPipeline;
   __publicField(RenderPipeline, "defaultProps", {
     ...Resource.defaultProps,
     vs: null,
     vsEntryPoint: "",
-    // main
     vsConstants: {},
     fs: null,
     fsEntryPoint: "",
-    // main
     fsConstants: {},
     shaderLayout: null,
     bufferLayout: [],
@@ -1829,43 +1537,8 @@ var __exports__ = (() => {
     constructor(device, props) {
       super(device, props, _RenderPass.defaultProps);
     }
-    /** Call when rendering is done in this pass. */
-    /** 
-     * A small set of parameters can be changed between every draw call 
-     * (viewport, scissorRect, blendColor, stencilReference) 
-     */
-    // writeTimestamp(querySet: GPUQuerySet, queryIndex: number): void;
-    // beginOcclusionQuery(queryIndex: number): void;
-    // endOcclusionQuery(): void;
-    // executeBundles(bundles: Iterable<GPURenderBundle>): void;
-    // In WebGPU the following methods are on the renderpass.
-    // luma.gl keeps them on the pipeline for now
-    /*
-    setPipeline(pipeline: RenderPipeline): void {}
-     setIndexBuffer(
-      buffer: Buffer,
-      indexFormat: 'uint16' | 'uint32',
-      offset?: number,
-      size?: number
-    ): void {}
-     abstract setVertexBuffer(slot: number, buffer: Buffer, offset: number): void;
-     abstract setBindings(bindings: Record<string, Binding>): void;
-     abstract setParameters(parameters: RenderPassParameters);
-     draw(options: {
-      vertexCount?: number; // Either vertexCount or indexCount must be provided
-      indexCount?: number;  // Activates indexed drawing (call setIndexBuffer())
-      instanceCount?: number; //
-      firstVertex?: number;
-      firstIndex?: number; // requires device.features.has('indirect-first-instance')?
-      firstInstance?: number;
-      baseVertex?: number;
-    }): void {}
-     drawIndirect(indirectBuffer: GPUBuffer, indirectOffset: number): void;
-    drawIndexedIndirect(indirectBuffer: GPUBuffer, indirectOffset: number): void;
-    */
   };
   var RenderPass = _RenderPass;
-  /** Default properties for RenderPass */
   __publicField(RenderPass, "defaultProps", {
     ...Resource.defaultProps,
     framebuffer: null,
@@ -1886,24 +1559,12 @@ var __exports__ = (() => {
     constructor(device, props) {
       super(device, props, _CommandEncoder.defaultProps);
     }
-    // TODO - return the CommandBuffer?
-    // beginRenderPass(GPURenderPassDescriptor descriptor): GPURenderPassEncoder;
-    // beginComputePass(optional GPUComputePassDescriptor descriptor = {}): GPUComputePassEncoder;
-    // finish(options?: {id?: string}): GPUCommandBuffer;
     pushDebugGroup(groupLabel) {
     }
     popDebugGroup() {
     }
     insertDebugMarker(markerLabel) {
     }
-    // writeTimestamp(querySet: Query, queryIndex: number): void;
-    // resolveQuerySet(options: {
-    //   querySet: GPUQuerySet,
-    //   firstQuery: number,
-    //   queryCount: number,
-    //   destination: Buffer,
-    //   destinationOffset?: number;
-    // }): void;
   };
   var CommandEncoder = _CommandEncoder;
   __publicField(CommandEncoder, "defaultProps", {
@@ -1984,7 +1645,6 @@ var __exports__ = (() => {
     f16: 2,
     i32: 4,
     u32: 4
-    // 'bool-webgl': 4,  
   };
 
   // ../core/src/adapter/type-utils/decode-data-type.ts
@@ -2091,9 +1751,7 @@ var __exports__ = (() => {
       vertexFormat,
       bufferDataType: vertexFormatInfo.type,
       bufferComponents: vertexFormatInfo.components,
-      // normalized is a property of the buffer's vertex format
       normalized: vertexFormatInfo.normalized,
-      // integer is a property of the shader declaration
       integer: attributeTypeInfo.integer,
       stepMode: bufferMapping?.stepMode || shaderDeclaration.stepMode,
       byteOffset: bufferMapping?.byteOffset || 0,
@@ -2135,7 +1793,6 @@ var __exports__ = (() => {
           bufferName: name2,
           stepMode: bufferLayout.stepMode,
           vertexFormat: bufferLayout.format,
-          // If offset is needed, use `attributes` field.
           byteOffset: 0,
           byteStride: bufferLayout.byteStride || 0
         };
@@ -2190,8 +1847,6 @@ var __exports__ = (() => {
     get [Symbol.toStringTag]() {
       return "VertexArray";
     }
-    /** Max number of vertex attributes */
-    /** Attribute infos indexed by location - TODO only needed by webgl module? */
     indexBuffer = null;
     constructor(device, props) {
       super(device, props, _VertexArray.defaultProps);
@@ -2199,9 +1854,6 @@ var __exports__ = (() => {
       this.attributes = new Array(this.maxVertexAttributes).fill(null);
       this.attributeInfos = getAttributeInfosByLocation(props.renderPipeline.shaderLayout, props.renderPipeline.bufferLayout, this.maxVertexAttributes);
     }
-    /** Set attributes (stored on pipeline and set before each call) */
-    /** Set attributes (stored on pipeline and set before each call) */
-    /** Set constant attributes (WebGL only) */
   };
   var VertexArray = _VertexArray;
   __publicField(VertexArray, "defaultProps", {
@@ -2232,6 +1884,109 @@ var __exports__ = (() => {
     }
   }
 
+  // ../core/src/adapter/type-utils/decode-shader-types.ts
+  var UNIFORM_FORMATS = {
+    "f32": {
+      type: "f32",
+      components: 1
+    },
+    "i32": {
+      type: "i32",
+      components: 1
+    },
+    "u32": {
+      type: "u32",
+      components: 1
+    },
+    "vec2<f32>": {
+      type: "f32",
+      components: 2
+    },
+    "vec3<f32>": {
+      type: "f32",
+      components: 3
+    },
+    "vec4<f32>": {
+      type: "f32",
+      components: 4
+    },
+    "vec2<i32>": {
+      type: "i32",
+      components: 2
+    },
+    "vec3<i32>": {
+      type: "i32",
+      components: 3
+    },
+    "vec4<i32>": {
+      type: "i32",
+      components: 4
+    },
+    "vec2<u32>": {
+      type: "u32",
+      components: 2
+    },
+    "vec3<u32>": {
+      type: "u32",
+      components: 3
+    },
+    "vec4<u32>": {
+      type: "u32",
+      components: 4
+    },
+    "mat2x2<f32>": {
+      type: "f32",
+      components: 4
+    },
+    "mat2x3<f32>": {
+      type: "f32",
+      components: 6
+    },
+    "mat2x4<f32>": {
+      type: "f32",
+      components: 8
+    },
+    "mat3x2<f32>": {
+      type: "f32",
+      components: 6
+    },
+    "mat3x3<f32>": {
+      type: "f32",
+      components: 9
+    },
+    "mat3x4<f32>": {
+      type: "f32",
+      components: 12
+    },
+    "mat4x2<f32>": {
+      type: "f32",
+      components: 8
+    },
+    "mat4x3<f32>": {
+      type: "f32",
+      components: 12
+    },
+    "mat4x4<f32>": {
+      type: "f32",
+      components: 16
+    }
+  };
+  function decodeShaderUniformType(format) {
+    const decoded = UNIFORM_FORMATS[format];
+    assert2(format);
+    return decoded;
+  }
+  function alignTo(size, count) {
+    switch (count) {
+      case 1:
+        return size;
+      case 2:
+        return size + size % 2;
+      default:
+        return size + (4 - size % 4) % 4;
+    }
+  }
+
   // ../core/src/lib/utils/array-utils-flat.ts
   var arrayBuffer;
   function getScratchArrayBuffer(byteLength) {
@@ -2269,6 +2024,237 @@ var __exports__ = (() => {
     return options.target;
   }
 
+  // ../core/src/lib/uniforms/uniform-buffer-layout.ts
+  var minBufferSize = 1024;
+  var UniformBufferLayout = class {
+    layout = {};
+    constructor(uniformTypes) {
+      let size = 0;
+      for (const [key, uniformType] of Object.entries(uniformTypes)) {
+        const typeAndComponents = decodeShaderUniformType(uniformType);
+        const {
+          type,
+          components: count
+        } = typeAndComponents;
+        size = alignTo(size, count);
+        const offset = size;
+        size += count;
+        this.layout[key] = {
+          type,
+          size: count,
+          offset
+        };
+      }
+      size += (4 - size % 4) % 4;
+      const actualByteLength = size * 4;
+      this.byteLength = Math.max(actualByteLength, minBufferSize);
+    }
+    getData(uniformValues) {
+      const bufferSize = Math.max(this.byteLength, minBufferSize);
+      const arrayBuffer2 = getScratchArrayBuffer(bufferSize);
+      const typedArrays = {
+        i32: new Int32Array(arrayBuffer2),
+        u32: new Uint32Array(arrayBuffer2),
+        f32: new Float32Array(arrayBuffer2),
+        f16: new Uint16Array(arrayBuffer2)
+      };
+      for (const [name2, value] of Object.entries(uniformValues)) {
+        const uniformLayout = this.layout[name2];
+        if (!uniformLayout) {
+          log.warn(`Supplied uniform value ${name2} not present in uniform block layout`)();
+          continue;
+        }
+        const {
+          type,
+          size,
+          offset
+        } = uniformLayout;
+        const typedArray = typedArrays[type];
+        if (size === 1) {
+          if (typeof value !== "number" && typeof value !== "boolean") {
+            log.warn(`Supplied value for single component uniform ${name2} is not a number: ${value}`)();
+            continue;
+          }
+          typedArray[offset] = Number(value);
+        } else {
+          const numericArray = isNumberArray(value);
+          if (!numericArray) {
+            log.warn(`Supplied value for multi component / array uniform ${name2} is not a numeric array: ${value}`)();
+            continue;
+          }
+          typedArray.set(numericArray, offset);
+        }
+      }
+      return new Uint8Array(arrayBuffer2);
+    }
+    has(name2) {
+      return Boolean(this.layout[name2]);
+    }
+    get(name2) {
+      const layout = this.layout[name2];
+      return layout;
+    }
+  };
+
+  // ../core/src/lib/utils/array-equal.ts
+  function arrayEqual(a, b, limit = 16) {
+    if (a !== b) {
+      return false;
+    }
+    const arrayA = isNumberArray(a);
+    if (!arrayA) {
+      return false;
+    }
+    const arrayB = isNumberArray(b);
+    if (arrayB && arrayA.length === arrayB.length) {
+      for (let i = 0; i < arrayA.length; ++i) {
+        if (arrayB[i] !== arrayA[i]) {
+          return false;
+        }
+      }
+    }
+    return true;
+  }
+  function arrayCopy(a) {
+    const numberArray = isNumberArray(a);
+    if (numberArray) {
+      return numberArray.slice();
+    }
+    return a;
+  }
+
+  // ../core/src/lib/uniforms/uniform-block.ts
+  var UniformBlock = class {
+    uniforms = {};
+    modifiedUniforms = {};
+    modified = true;
+    bindingLayout = {};
+    needsRedraw = "initialized";
+    constructor(props) {
+      this.name = props?.name;
+      if (props?.name && props?.shaderLayout) {
+        const binding = props?.shaderLayout.bindings?.find((binding2) => binding2.type === "uniform" && binding2.name === props?.name);
+        if (!binding) {
+          throw new Error(props?.name);
+        }
+        const uniformBlock = binding;
+        for (const uniform of uniformBlock.uniforms || []) {
+          this.bindingLayout[uniform.name] = uniform;
+        }
+      }
+    }
+    setUniforms(uniforms) {
+      for (const [key, value] of Object.entries(uniforms)) {
+        this._setUniform(key, value);
+        if (!this.needsRedraw) {
+          this.setNeedsRedraw(`${this.name}.${key}=${value}`);
+        }
+      }
+    }
+    setNeedsRedraw(reason) {
+      this.needsRedraw = this.needsRedraw || reason;
+    }
+    getAllUniforms() {
+      this.modifiedUniforms = {};
+      this.needsRedraw = false;
+      return this.uniforms || {};
+    }
+    _setUniform(key, value) {
+      if (arrayEqual(this.uniforms[key], value)) {
+        return;
+      }
+      this.uniforms[key] = arrayCopy(value);
+      this.modifiedUniforms[key] = true;
+      this.modified = true;
+    }
+  };
+
+  // ../core/src/lib/uniforms/uniform-store.ts
+  var UniformStore = class {
+    uniformBlocks = /* @__PURE__ */ new Map();
+    uniformBufferLayouts = /* @__PURE__ */ new Map();
+    uniformBuffers = /* @__PURE__ */ new Map();
+    constructor(blocks) {
+      for (const [bufferName, block] of Object.entries(blocks)) {
+        const uniformBufferName = bufferName;
+        const uniformBufferLayout = new UniformBufferLayout(block.uniformTypes || {});
+        this.uniformBufferLayouts.set(uniformBufferName, uniformBufferLayout);
+        const uniformBlock = new UniformBlock({
+          name: bufferName
+        });
+        uniformBlock.setUniforms(block.defaultUniforms || {});
+        this.uniformBlocks.set(uniformBufferName, uniformBlock);
+      }
+    }
+    destroy() {
+      for (const uniformBuffer of Object.values(this.uniformBuffers)) {
+        uniformBuffer.destroy();
+      }
+    }
+    setUniforms(uniforms) {
+      for (const [blockName, uniformValues] of Object.entries(uniforms)) {
+        this.uniformBlocks.get(blockName).setUniforms(uniformValues);
+      }
+      this.updateUniformBuffers();
+    }
+    getUniformBufferByteLength(uniformBufferName) {
+      return this.uniformBufferLayouts.get(uniformBufferName).byteLength;
+    }
+    getUniformBufferData(uniformBufferName) {
+      const uniformValues = this.uniformBlocks.get(uniformBufferName).getAllUniforms();
+      return this.uniformBufferLayouts.get(uniformBufferName).getData(uniformValues);
+    }
+    createUniformBuffer(device, uniformBufferName, uniforms) {
+      if (uniforms) {
+        this.setUniforms(uniforms);
+      }
+      const byteLength = this.getUniformBufferByteLength(uniformBufferName);
+      const uniformBuffer = device.createBuffer({
+        usage: Buffer2.UNIFORM,
+        byteLength
+      });
+      const uniformBufferData = this.getUniformBufferData(uniformBufferName);
+      uniformBuffer.write(uniformBufferData);
+      return uniformBuffer;
+    }
+    getManagedUniformBuffer(device, uniformBufferName) {
+      if (!this.uniformBuffers.get(uniformBufferName)) {
+        const byteLength = this.getUniformBufferByteLength(uniformBufferName);
+        const uniformBuffer = device.createBuffer({
+          usage: Buffer2.UNIFORM,
+          byteLength
+        });
+        this.uniformBuffers.set(uniformBufferName, uniformBuffer);
+      }
+      return this.uniformBuffers.get(uniformBufferName);
+    }
+    updateUniformBuffers() {
+      let reason = false;
+      for (const uniformBufferName of this.uniformBlocks.keys()) {
+        const bufferReason = this.updateUniformBuffer(uniformBufferName);
+        reason ||= bufferReason;
+      }
+      if (reason) {
+        log.log(3, `UniformStore.updateUniformBuffers(): ${reason}`)();
+      }
+      return reason;
+    }
+    updateUniformBuffer(uniformBufferName) {
+      const uniformBlock = this.uniformBlocks.get(uniformBufferName);
+      const uniformBuffer = this.uniformBuffers.get(uniformBufferName);
+      let reason = false;
+      if (uniformBuffer && uniformBlock.needsRedraw) {
+        reason ||= uniformBlock.needsRedraw;
+        const uniformBufferData = this.getUniformBufferData(uniformBufferName);
+        const uniformBuffer2 = this.uniformBuffers.get(uniformBufferName);
+        uniformBuffer2.write(uniformBufferData);
+        const uniformValues = this.uniformBlocks.get(uniformBufferName).getAllUniforms();
+        log.log(4, `Writing to uniform buffer ${String(uniformBufferName)}`, uniformBufferData, uniformValues)();
+      }
+      return reason;
+    }
+  };
+
   // ../core/src/adapter/type-utils/decode-texture-format.ts
   var REGEX = /^(rg?b?a?)([0-9]*)([a-z]*)(-srgb)?(-webgl|-unsized)?$/;
   function decodeTextureFormat(format) {
@@ -2280,8 +2266,7 @@ var __exports__ = (() => {
         const decodedType = decodeVertexType(dataType);
         return {
           format: format2,
-          components: 0,
-          // dataType - overwritten by decodedType
+          components: format2.length,
           srgb: srgb === "-srgb",
           unsized: suffix === "-unsized",
           webgl: suffix === "-webgl",
@@ -2292,7 +2277,6 @@ var __exports__ = (() => {
     return decodeNonStandardFormat(format);
   }
   var EXCEPTIONS = {
-    // Packed 16 bit formats
     "rgba4unorm-webgl": {
       format: "rgba",
       bpp: 2
@@ -2305,7 +2289,6 @@ var __exports__ = (() => {
       format: "rgba",
       bbp: 2
     },
-    // Packed 32 bit formats
     "rgb9e5ufloat": {
       format: "rgb",
       bbp: 4
@@ -2322,7 +2305,6 @@ var __exports__ = (() => {
       format: "rgba",
       bbp: 4
     },
-    // Depth/stencil
     "stencil8": {
       components: 1,
       bpp: 1,
@@ -2348,13 +2330,11 @@ var __exports__ = (() => {
       bpp: 4,
       a: "depth-stencil"
     },
-    // "depth24unorm-stencil8" feature
     "depth24unorm-stencil8": {
       components: 2,
       bpp: 4,
       a: "depth-stencil"
     },
-    // "depth32float-stencil8" feature
     "depth32float-stencil8": {
       components: 2,
       bpp: 4,
@@ -2368,7 +2348,7 @@ var __exports__ = (() => {
     }
     return {
       format: data.format || "",
-      components: data.components || 1,
+      components: data.components || data.format?.length || 1,
       byteLength: data.bpp || 1,
       srgb: false,
       unsized: false
@@ -2398,22 +2378,28 @@ var __exports__ = (() => {
         throw new Error(type.constructor.name);
     }
   }
-  function getVertexFormatFromAttribute(typedArray, size) {
+  function getVertexFormatFromAttribute(typedArray, size, normalized) {
     if (!size || size > 4) {
       throw new Error(`size ${size}`);
     }
     const components = size;
-    const dataType = getDataTypeFromTypedArray(typedArray);
+    let dataType = getDataTypeFromTypedArray(typedArray);
     if (dataType === "uint8" || dataType === "sint8") {
       if (components === 1 || components === 3) {
         throw new Error(`size: ${size}`);
       }
+      if (normalized) {
+        dataType = dataType.replace("int", "norm");
+      }
       return `${dataType}x${components}`;
     }
     if (dataType === "uint16" || dataType === "sint16") {
       if (components === 1 || components === 3) {
         throw new Error(`size: ${size}`);
       }
+      if (normalized) {
+        dataType = dataType.replace("int", "norm");
+      }
       return `${dataType}x${components}`;
     }
     if (components === 1) {
@@ -2609,7 +2595,7 @@ var __exports__ = (() => {
   }
 
   // src/pbr/parse-pbr-material.ts
-  var GLEnum = /* @__PURE__ */ function(GLEnum4) {
+  var GLEnum = function(GLEnum4) {
     GLEnum4[GLEnum4["FUNC_ADD"] = 32774] = "FUNC_ADD";
     GLEnum4[GLEnum4["ONE"] = 1] = "ONE";
     GLEnum4[GLEnum4["SRC_ALPHA"] = 770] = "SRC_ALPHA";
@@ -2623,17 +2609,13 @@ var __exports__ = (() => {
   function parsePBRMaterial(device, material, attributes, options) {
     const parsedMaterial = {
       defines: {
-        // TODO: Use EXT_sRGB if available (Standard in WebGL 2.0)
         MANUAL_SRGB: 1,
         SRGB_FAST_APPROXIMATION: 1
       },
       bindings: {},
       uniforms: {
-        // TODO: find better values?
         u_Camera: [0, 0, 0],
-        // Model should override
         u_MetallicRoughnessValues: [1, 1]
-        // Default is 1 and 1
       },
       parameters: {},
       glParameters: {},
@@ -2974,6 +2956,7 @@ var __exports__ = (() => {
   }
 
   // ../shadertools/src/lib/shader-module/shader-module-instance.ts
+  var index = 1;
   var ShaderModuleInstance = class {
     uniforms = {};
     uniformTypes = {};
@@ -2982,8 +2965,11 @@ var __exports__ = (() => {
         if (module instanceof ShaderModuleInstance) {
           return module;
         }
-        assert3(typeof module !== "string", `Shader module use by name is deprecated. Import shader module '${module}' and use it directly.`);
-        assert3(module.name, "shader module has no name");
+        assert3(typeof module !== "string", `Shader module use by name is deprecated. Import shader module '${JSON.stringify(module)}' and use it directly.`);
+        if (!module.name) {
+          console.warn("shader module has no name");
+          module.name = `shader-module-${index++}`;
+        }
         const moduleObject = new ShaderModuleInstance(module);
         moduleObject.dependencies = ShaderModuleInstance.instantiateModules(module.dependencies || []);
         return moduleObject;
@@ -3014,7 +3000,6 @@ var __exports__ = (() => {
         this.uniforms = makePropValidators(uniformPropTypes);
       }
     }
-    // Extracts the source code chunk for the specified shader type from the named shader module
     getModuleSource(stage) {
       let moduleSource;
       switch (stage) {
@@ -3027,8 +3012,11 @@ var __exports__ = (() => {
         default:
           assert3(false);
       }
-      return `#define MODULE_${this.name.toUpperCase().replace(/[^0-9a-z]/gi, "_")}
-${moduleSource}// END MODULE_${this.name}
+      const moduleName = this.name.toUpperCase().replace(/[^0-9a-z]/gi, "_");
+      return `// ----- MODULE ${this.name} ---------------
+
+#define MODULE_${moduleName}
+${moduleSource}
 
 `;
     }
@@ -3041,7 +3029,6 @@ ${moduleSource}// END MODULE_${this.name}
     getDefines() {
       return this.defines;
     }
-    // Warn about deprecated uniforms or functions
     checkDeprecations(shaderSource, log3) {
       this.deprecations.forEach((def) => {
         if (def.regex?.test(shaderSource)) {
@@ -3172,18 +3159,20 @@ ${moduleSource}// END MODULE_${this.name}
     }
   }
   function getVersionDefines(platformInfo) {
-    let versionDefines = glsl`\
-#if (__VERSION__ > 120)
+    let versionDefines = "";
+    if (platformInfo.features.has("webgl2")) {
+      versionDefines += glsl`\
 # define FEATURE_GLSL_DERIVATIVES
 # define FEATURE_GLSL_DRAW_BUFFERS
 # define FEATURE_GLSL_FRAG_DEPTH
 # define FEATURE_GLSL_TEXTURE_LOD
-#endif // __VERSION
 `;
-    if (!platformInfo.features.has("webgl2") && platformInfo.features.has("glsl-frag-depth")) {
-      versionDefines += glsl`\
+    }
+    if (!platformInfo.features.has("webgl2")) {
+      if (platformInfo.features.has("glsl-frag-depth")) {
+        versionDefines += glsl`\
 
-// FRAG_DEPTH => gl_FragDepth is available
+// FEATURE_GLSL_FRAG_DEPTH => gl_FragDepth is available
 #ifdef GL_EXT_frag_depth
 # extension GL_EXT_frag_depth : enable
 # define FEATURE_GLSL_FRAG_DEPTH
@@ -3191,31 +3180,29 @@ ${moduleSource}// END MODULE_${this.name}
 # define gl_FragDepth gl_FragDepthEXT
 #endif
 `;
-    }
-    if (!platformInfo.features.has("webgl2") && platformInfo?.features.has("glsl-derivatives")) {
-      versionDefines += glsl`\
+      }
+      if (platformInfo?.features.has("glsl-derivatives")) {
+        versionDefines += glsl`\
 
-// DERIVATIVES => dxdF, dxdY and fwidth are available
+// FEATURE_GLSL_DERIVATIVES => dxdF, dxdY and fwidth are available
 #if defined(GL_OES_standard_derivatives) || defined(FEATURE_GLSL_DERIVATIVES)
 # extension GL_OES_standard_derivatives : enable
 # define FEATURE_GLSL_DERIVATIVES
-# define DERIVATIVES
 #endif
 `;
-    }
-    if (!platformInfo.features.has("webgl2") && platformInfo?.features.has("glsl-frag-data")) {
-      versionDefines += glsl`\
+      }
+      if (platformInfo?.features.has("glsl-frag-data")) {
+        versionDefines += glsl`\
 
-// DRAW_BUFFERS => gl_FragData[] is available
+// FEATURE_GLSL_DRAW_BUFFERS => gl_FragData[] is available
 #ifdef GL_EXT_draw_buffers
 # extension GL_EXT_draw_buffers : require
 # define FEATURE_GLSL_DRAW_BUFFERS
-# define DRAW_BUFFERS
 #endif
 `;
-    }
-    if (!platformInfo.features.has("webgl2") && platformInfo?.features.has("glsl-texture-lod")) {
-      versionDefines += glsl`\
+      }
+      if (platformInfo?.features.has("glsl-texture-lod")) {
+        versionDefines += glsl`\
 // TEXTURE_LOD => texture2DLod etc are available
 #ifdef GL_EXT_shader_texture_lod
 # extension GL_EXT_shader_texture_lod : enable
@@ -3223,91 +3210,59 @@ ${moduleSource}// END MODULE_${this.name}
 # define TEXTURE_LOD
 #endif
 `;
+      }
     }
     return versionDefines;
   }
 
   // ../shadertools/src/lib/shader-transpiler/transpile-glsl-shader.ts
   function transpileGLSLShader(source, targetGLSLVersion, stage) {
+    const sourceGLSLVersion = Number(source.match(/^#version[ \t]+(\d+)/m)?.[1] || 100);
+    if (sourceGLSLVersion !== 300) {
+      throw new Error("luma.gl v9 only supports GLSL 3.00 shader sources");
+    }
     switch (targetGLSLVersion) {
       case 300:
         switch (stage) {
           case "vertex":
-            return convertShader(source, ES300_VERTEX_REPLACEMENTS);
+            source = convertShader(source, ES300_VERTEX_REPLACEMENTS);
+            return source;
           case "fragment":
-            return convertFragmentShaderTo300(source);
+            source = convertShader(source, ES300_FRAGMENT_REPLACEMENTS);
+            return source;
           default:
-            throw new Error(`unknown shader stage ${stage}`);
+            throw new Error(stage);
         }
       case 100:
         switch (stage) {
           case "vertex":
-            return convertShader(source, ES100_VERTEX_REPLACEMENTS);
+            source = convertShader(source, ES100_VERTEX_REPLACEMENTS);
+            return source;
           case "fragment":
-            return convertFragmentShaderTo100(source);
+            source = convertShader(source, ES100_FRAGMENT_REPLACEMENTS);
+            source = convertFragmentShaderTo100(source);
+            return source;
           default:
-            throw new Error(`unknown shader stage ${stage}`);
+            throw new Error(stage);
         }
       default:
-        throw new Error(`unknown GLSL version ${targetGLSLVersion}`);
-    }
-  }
-  var ES300_REPLACEMENTS = [
-    // Fix poorly formatted version directive
-    [/^(#version[ \t]+(100|300[ \t]+es))?[ \t]*\n/, "#version 300 es\n"],
-    // The individual `texture...()` functions were replaced with `texture()` overloads
-    [/\btexture(2D|2DProj|Cube)Lod(EXT)?\(/g, "textureLod("],
-    [/\btexture(2D|2DProj|Cube)(EXT)?\(/g, "texture("]
-  ];
-  var ES300_VERTEX_REPLACEMENTS = [
-    ...ES300_REPLACEMENTS,
-    // `attribute` keyword replaced with `in`
-    [makeVariableTextRegExp("attribute"), "in $1"],
-    // `varying` keyword replaced with `out`
-    [makeVariableTextRegExp("varying"), "out $1"]
-  ];
-  var ES300_FRAGMENT_REPLACEMENTS = [
-    ...ES300_REPLACEMENTS,
-    // `varying` keyword replaced with `in`
-    [makeVariableTextRegExp("varying"), "in $1"]
-  ];
-  var ES100_REPLACEMENTS = [
-    [/^#version[ \t]+300[ \t]+es/, "#version 100"],
-    // In GLSL 1.00 ES these functions are provided by an extension
-    [/\btexture(2D|2DProj|Cube)Lod\(/g, "texture$1LodEXT("],
-    // Overloads in GLSL 3.00 map to individual functions. Note that we cannot
-    // differentiate 2D,2DProj,Cube without type analysis so we choose the most common variant.
-    [/\btexture\(/g, "texture2D("],
-    [/\btextureLod\(/g, "texture2DLodEXT("]
-  ];
+        throw new Error(String(targetGLSLVersion));
+    }
+  }
+  var ES300_REPLACEMENTS = [[/^(#version[ \t]+(100|300[ \t]+es))?[ \t]*\n/, "#version 300 es\n"], [/\btexture(2D|2DProj|Cube)Lod(EXT)?\(/g, "textureLod("], [/\btexture(2D|2DProj|Cube)(EXT)?\(/g, "texture("]];
+  var ES300_VERTEX_REPLACEMENTS = [...ES300_REPLACEMENTS, [makeVariableTextRegExp("attribute"), "in $1"], [makeVariableTextRegExp("varying"), "out $1"]];
+  var ES300_FRAGMENT_REPLACEMENTS = [...ES300_REPLACEMENTS, [makeVariableTextRegExp("varying"), "in $1"]];
+  var ES100_REPLACEMENTS = [[/^#version[ \t]+300[ \t]+es/, "#version 100"], [/\btexture(2D|2DProj|Cube)Lod\(/g, "texture$1LodEXT("], [/\btexture\(/g, "texture2D("], [/\btextureLod\(/g, "texture2DLodEXT("]];
   var ES100_VERTEX_REPLACEMENTS = [...ES100_REPLACEMENTS, [makeVariableTextRegExp("in"), "attribute $1"], [makeVariableTextRegExp("out"), "varying $1"]];
-  var ES100_FRAGMENT_REPLACEMENTS = [
-    ...ES100_REPLACEMENTS,
-    // Replace `in` with `varying`
-    [makeVariableTextRegExp("in"), "varying $1"]
-  ];
+  var ES100_FRAGMENT_REPLACEMENTS = [...ES100_REPLACEMENTS, [makeVariableTextRegExp("in"), "varying $1"]];
   var ES100_FRAGMENT_OUTPUT_NAME = "gl_FragColor";
   var ES300_FRAGMENT_OUTPUT_REGEX = /\bout[ \t]+vec4[ \t]+(\w+)[ \t]*;\n?/;
-  var REGEX_START_OF_MAIN2 = /void\s+main\s*\([^)]*\)\s*\{\n?/;
   function convertShader(source, replacements) {
     for (const [pattern, replacement] of replacements) {
       source = source.replace(pattern, replacement);
     }
     return source;
   }
-  function convertFragmentShaderTo300(source) {
-    source = convertShader(source, ES300_FRAGMENT_REPLACEMENTS);
-    const outputMatch = ES300_FRAGMENT_OUTPUT_REGEX.exec(source);
-    if (outputMatch) {
-      const outputName = outputMatch[1];
-      source = source.replace(new RegExp(`\\b${ES100_FRAGMENT_OUTPUT_NAME}\\b`, "g"), outputName);
-    } else {
-      const outputName = "fragmentColor";
-      source = source.replace(REGEX_START_OF_MAIN2, (match) => `out vec4 ${outputName};
-${match}`).replace(new RegExp(`\\b${ES100_FRAGMENT_OUTPUT_NAME}\\b`, "g"), outputName);
-    }
-    return source;
-  }
   function convertFragmentShaderTo100(source) {
     source = convertShader(source, ES100_FRAGMENT_REPLACEMENTS);
     const outputMatch = ES300_FRAGMENT_OUTPUT_REGEX.exec(source);
@@ -3381,32 +3336,58 @@ ${match}`).replace(new RegExp(`\\b${ES100_FRAGMENT_OUTPUT_NAME}\\b`, "g"), outpu
     return result;
   }
 
+  // ../shadertools/src/lib/glsl-utils/get-shader-info.ts
+  function getShaderInfo(source, defaultName) {
+    return {
+      name: getShaderName(source, defaultName),
+      language: "glsl",
+      version: getShaderVersion(source)
+    };
+  }
+  function getShaderName(shader, defaultName = "unnamed") {
+    const SHADER_NAME_REGEXP = /#define[\s*]SHADER_NAME[\s*]([A-Za-z0-9_-]+)[\s*]/;
+    const match = SHADER_NAME_REGEXP.exec(shader);
+    return match ? match[1] : defaultName;
+  }
+  function getShaderVersion(source) {
+    let version = 100;
+    const words = source.match(/[^\s]+/g);
+    if (words && words.length >= 2 && words[0] === "#version") {
+      const parsedVersion = parseInt(words[1], 10);
+      if (Number.isFinite(parsedVersion)) {
+        version = parsedVersion;
+      }
+    }
+    if (version !== 100 && version !== 300) {
+      throw new Error(`Invalid GLSL version ${version}`);
+    }
+    return version;
+  }
+
   // ../shadertools/src/lib/shader-assembly/assemble-shaders.ts
   var INJECT_SHADER_DECLARATIONS = `
 
 ${DECLARATION_INJECT_MARKER}
-
 `;
   var FRAGMENT_SHADER_PROLOGUE = glsl`\
 precision highp float;
-
 `;
-  function assembleShaders(platformInfo, options) {
+  function assembleShaders(options) {
     const {
       vs: vs3,
       fs: fs3
     } = options;
     const modules = resolveModules(options.modules || []);
-    switch (platformInfo.shaderLanguage) {
+    switch (options.platformInfo.shaderLanguage) {
       case "glsl":
         return {
-          vs: assembleGLSLShader(platformInfo, {
+          vs: assembleGLSLShader(options.platformInfo, {
             ...options,
             source: vs3,
             stage: "vertex",
             modules
           }),
-          fs: assembleGLSLShader(platformInfo, {
+          fs: assembleGLSLShader(options.platformInfo, {
             ...options,
             source: fs3,
             stage: "fragment",
@@ -3416,13 +3397,13 @@ precision highp float;
         };
       case "wgsl":
         return {
-          vs: assembleWGSLShader(platformInfo, {
+          vs: assembleWGSLShader(options.platformInfo, {
             ...options,
             source: vs3,
             stage: "vertex",
             modules
           }),
-          fs: assembleWGSLShader(platformInfo, {
+          fs: assembleWGSLShader(options.platformInfo, {
             ...options,
             source: fs3,
             stage: "fragment",
@@ -3434,7 +3415,6 @@ precision highp float;
   }
   function assembleWGSLShader(platformInfo, options) {
     const {
-      // id,
       source,
       stage,
       modules,
@@ -3505,33 +3485,24 @@ precision highp float;
     return assembledSource;
   }
   function assembleGLSLShader(platformInfo, options) {
-    const isWGSL = options.source.includes("->");
     const {
       id,
       source,
       stage,
-      language = isWGSL ? "wgsl" : "glsl",
+      language = "glsl",
       modules,
       defines = {},
       hookFunctions = [],
       inject = {},
-      transpileToGLSL100 = false,
-      prologue = !isWGSL,
+      prologue = true,
       log: log3
     } = options;
     assert3(typeof source === "string", "shader source must be a string");
+    const sourceVersion = language === "glsl" ? getShaderInfo(source).version : -1;
+    const targetVersion = platformInfo.shaderLanguageVersion;
+    const sourceVersionDirective = sourceVersion === 100 ? "#version 100" : "#version 300 es";
     const sourceLines = source.split("\n");
-    let glslVersion = 100;
-    let versionLine = "";
-    let coreSource = source;
-    if (sourceLines[0].indexOf("#version ") === 0) {
-      glslVersion = 300;
-      versionLine = sourceLines[0];
-      coreSource = sourceLines.slice(1).join("\n");
-    } else {
-      versionLine = `#version ${glslVersion}`;
-    }
-    const targetVersion = transpileToGLSL100 ? 100 : glslVersion;
+    const coreSource = sourceLines.slice(1).join("\n");
     const allDefines = {};
     modules.forEach((module) => {
       Object.assign(allDefines, module.getDefines());
@@ -3542,7 +3513,9 @@ precision highp float;
       case "wgsl":
         break;
       case "glsl":
-        assembledSource = prologue ? `${versionLine}
+        assembledSource = prologue ? `${sourceVersionDirective}
+
+// ----- PROLOGUE -------------------------
 ${getShaderNameDefine({
           id,
           source,
@@ -3551,9 +3524,13 @@ ${getShaderNameDefine({
 ${`#define SHADER_TYPE_${stage.toUpperCase()}`}
 ${getPlatformShaderDefines(platformInfo)}
 ${getVersionDefines(platformInfo)}
-${getApplicationDefines(allDefines)}
 ${stage === "fragment" ? FRAGMENT_SHADER_PROLOGUE : ""}
-` : `${versionLine}
+
+// ----- APPLICATION DEFINES -------------------------
+
+${getApplicationDefines(allDefines)}
+
+` : `${sourceVersionDirective}
 `;
         break;
     }
@@ -3603,12 +3580,15 @@ ${stage === "fragment" ? FRAGMENT_SHADER_PROLOGUE : ""}
         }
       }
     }
+    assembledSource += "// ----- MAIN SHADER SOURCE -------------------------";
     assembledSource += INJECT_SHADER_DECLARATIONS;
     assembledSource = injectShader(assembledSource, stage, declInjections);
     assembledSource += getShaderHooks(hookFunctionMap[stage], hookInjections);
     assembledSource += coreSource;
     assembledSource = injectShader(assembledSource, stage, mainInjections);
-    assembledSource = transpileGLSLShader(assembledSource, targetVersion, stage);
+    if (language === "glsl" && sourceVersion !== targetVersion) {
+      assembledSource = transpileGLSLShader(assembledSource, targetVersion, stage);
+    }
     return assembledSource.trim();
   }
   function assembleGetUniforms(modules) {
@@ -3634,34 +3614,26 @@ ${stage === "fragment" ? FRAGMENT_SHADER_PROLOGUE : ""}
 ` : "";
   }
   function getApplicationDefines(defines = {}) {
-    let count = 0;
     let sourceText = "";
     for (const define in defines) {
-      if (count === 0) {
-        sourceText += "\n// APPLICATION DEFINES\n";
-      }
-      count++;
       const value = defines[define];
       if (value || Number.isFinite(value)) {
         sourceText += `#define ${define.toUpperCase()} ${defines[define]}
 `;
       }
     }
-    if (count === 0) {
-      sourceText += "\n";
-    }
     return sourceText;
   }
 
   // ../shadertools/src/lib/shader-assembly/select-shaders.ts
-  function selectShaders(platformInfo, props) {
+  function selectShaders(props) {
     if (!props.vs) {
       throw new Error("no vertex shader");
     }
-    const vs3 = getShaderSource(platformInfo, props.vs);
+    const vs3 = getShaderSource(props.platformInfo, props.vs);
     let fs3;
     if (props.fs) {
-      fs3 = getShaderSource(platformInfo, props.fs);
+      fs3 = getShaderSource(props.platformInfo, props.fs);
     }
     return {
       ...props,
@@ -3689,39 +3661,21 @@ ${stage === "fragment" ? FRAGMENT_SHADER_PROLOGUE : ""}
 
   // ../shadertools/src/lib/shader-assembler.ts
   var ShaderAssembler = class {
-    /** Default ShaderAssembler instance */
-    /** Hook functions */
     _hookFunctions = [];
-    /** Shader modules */
     _defaultModules = [];
-    /**
-     * A default shader assembler instance - the natural place to register default modules and hooks
-     * @returns 
-     */
     static getDefaultShaderAssembler() {
       ShaderAssembler.defaultShaderAssembler = ShaderAssembler.defaultShaderAssembler || new ShaderAssembler();
       return ShaderAssembler.defaultShaderAssembler;
     }
-    /** 
-     * Add a default module that does not have to be provided with every call to assembleShaders() 
-     */
     addDefaultModule(module) {
       if (!this._defaultModules.find((m) => m.name === (typeof module === "string" ? module : module.name))) {
         this._defaultModules.push(module);
       }
     }
-    /** 
-     * Remove a default module
-     */
     removeDefaultModule(module) {
       const moduleName = typeof module === "string" ? module : module.name;
       this._defaultModules = this._defaultModules.filter((m) => m.name !== moduleName);
     }
-    /**
-     * Register a shader hook
-     * @param hook 
-     * @param opts 
-     */
     addShaderHook(hook, opts) {
       if (opts) {
         hook = Object.assign(opts, {
@@ -3730,26 +3684,21 @@ ${stage === "fragment" ? FRAGMENT_SHADER_PROLOGUE : ""}
       }
       this._hookFunctions.push(hook);
     }
-    /**
-     * Assemble a pair of shaders into a single shader program
-     * @param platformInfo 
-     * @param props 
-     * @returns 
-     */
-    assembleShaders(platformInfo, props) {
+    assembleShaders(props) {
       const modules = this._getModuleList(props.modules);
       const hookFunctions = this._hookFunctions;
-      const options = selectShaders(platformInfo, props);
-      const assembled = assembleShaders(platformInfo, {
+      const options = selectShaders(props);
+      const assembled = assembleShaders({
+        platformInfo: props.platformInfo,
         ...options,
         modules,
         hookFunctions
       });
-      return assembled;
+      return {
+        ...assembled,
+        modules
+      };
     }
-    /** 
-     * Dedupe and combine with default modules 
-     */
     _getModuleList(appModules = []) {
       const modules = new Array(this._defaultModules.length + appModules.length);
       const seen = {};
@@ -3769,7 +3718,7 @@ ${stage === "fragment" ? FRAGMENT_SHADER_PROLOGUE : ""}
         }
       }
       modules.length = count;
-      return modules;
+      return ShaderModuleInstance.instantiateModules(modules);
     }
   };
 
@@ -6386,15 +6335,15 @@ float getPointLightAttenuation(PointLight pointLight, float distance) {
     } else {
       lightSourceUniforms["lighting_uAmbientLight.color"] = [0, 0, 0];
     }
-    pointLights.forEach((pointLight, index) => {
-      lightSourceUniforms[`lighting_uPointLight[${index}].color`] = convertColor(pointLight);
-      lightSourceUniforms[`lighting_uPointLight[${index}].position`] = pointLight.position;
-      lightSourceUniforms[`lighting_uPointLight[${index}].attenuation`] = pointLight.attenuation || [1, 0, 0];
+    pointLights.forEach((pointLight, index2) => {
+      lightSourceUniforms[`lighting_uPointLight[${index2}].color`] = convertColor(pointLight);
+      lightSourceUniforms[`lighting_uPointLight[${index2}].position`] = pointLight.position;
+      lightSourceUniforms[`lighting_uPointLight[${index2}].attenuation`] = pointLight.attenuation || [1, 0, 0];
     });
     lightSourceUniforms.lighting_uPointLightCount = pointLights.length;
-    directionalLights.forEach((directionalLight, index) => {
-      lightSourceUniforms[`lighting_uDirectionalLight[${index}].color`] = convertColor(directionalLight);
-      lightSourceUniforms[`lighting_uDirectionalLight[${index}].direction`] = directionalLight.direction;
+    directionalLights.forEach((directionalLight, index2) => {
+      lightSourceUniforms[`lighting_uDirectionalLight[${index2}].color`] = convertColor(directionalLight);
+      lightSourceUniforms[`lighting_uDirectionalLight[${index2}].direction`] = directionalLight.direction;
     });
     lightSourceUniforms.lighting_uDirectionalLightCount = directionalLights.length;
     return lightSourceUniforms;
@@ -6909,10 +6858,53 @@ vec4 pbr_filterColor(vec4 colorUnused)
     dependencies: [lights]
   };
 
+  // ../engine/src/shader-inputs.ts
+  var ShaderInputs = class {
+    constructor(modules) {
+      const allModules = resolveModules(Object.values(modules));
+      log.log(1, "Creating ShaderInputs with modules", allModules.map((m) => m.name))();
+      this.modules = modules;
+      this.moduleUniforms = {};
+      this.moduleBindings = {};
+      for (const [name2, module] of Object.entries(modules)) {
+        const moduleName = name2;
+        this.moduleUniforms[moduleName] = module.defaultUniforms || {};
+        this.moduleBindings[moduleName] = {};
+      }
+    }
+    destroy() {
+    }
+    setProps(props) {
+      for (const name2 of Object.keys(props)) {
+        const moduleName = name2;
+        const moduleProps = props[moduleName];
+        const module = this.modules[moduleName];
+        const oldUniforms = this.moduleUniforms[moduleName];
+        const uniforms = module.getUniforms?.(moduleProps, this.moduleUniforms[moduleName]) || moduleProps;
+        this.moduleUniforms[moduleName] = {
+          ...oldUniforms,
+          ...uniforms
+        };
+      }
+    }
+    getModules() {
+      return Object.values(this.modules);
+    }
+    getUniformValues() {
+      return this.moduleUniforms;
+    }
+    getBindings() {
+      const bindings = {};
+      for (const moduleBindings of Object.values(this.moduleBindings)) {
+        Object.assign(bindings, moduleBindings);
+      }
+      return bindings;
+    }
+  };
+
   // ../engine/src/geometry/gpu-geometry.ts
   var GPUGeometry = class {
     userData = {};
-    /** Determines how vertices are read from the 'vertex' attributes */
     bufferLayout = [];
     constructor(props) {
       this.id = props.id || uid("geometry");
@@ -6995,11 +6987,12 @@ vec4 pbr_filterColor(vec4 colorUnused)
       });
       const {
         value,
-        size
+        size,
+        normalized
       } = attribute;
       bufferLayout.push({
         name: name2,
-        format: getVertexFormatFromAttribute(value, size)
+        format: getVertexFormatFromAttribute(value, size, normalized)
       });
     }
     const vertexCount = geometry._calculateVertexCount(geometry.attributes, geometry.indices);
@@ -7059,7 +7052,6 @@ vec4 pbr_filterColor(vec4 colorUnused)
         delete this._useCounts[hash];
       }
     }
-    // PRIVATE
     _createRenderPipeline(props) {
       if (!props.fs) {
         throw new Error("fs");
@@ -7077,7 +7069,6 @@ vec4 pbr_filterColor(vec4 colorUnused)
       });
       return pipeline;
     }
-    /** Calculate a hash based on all the inputs for a render pipeline */
     _hashRenderPipeline(props) {
       const vsHash = this._getHash(props.vs);
       const fsHash = props.fs ? this._getHash(props.fs) : 0;
@@ -7108,31 +7099,12 @@ vec4 pbr_filterColor(vec4 colorUnused)
   // ../engine/src/model/model.ts
   var _Model = class {
     userData = {};
-    // Fixed properties (change can trigger pipeline rebuild)
-    /** The render pipeline GPU parameters, depth testing etc */
-    /** The primitive topology */
-    /** Buffer layout */
-    // Dynamic properties
-    /** Vertex count */
-    /** instance count */
     instanceCount = 0;
-    /** Index buffer */
     indexBuffer = null;
-    /** Buffer-valued attributes */
     bufferAttributes = {};
-    /** Constant-valued attributes */
     constantAttributes = {};
-    /** Bindings (textures, samplers, uniform buffers) */
     bindings = {};
-    /** Sets uniforms @deprecated Use uniform buffers and setBindings() for portability*/
     uniforms = {};
-    /** The underlying GPU "program". @note May be recreated if parameters change */
-    /**
-     * VertexArray
-     * @note not implemented: if bufferLayout is updated, vertex array has to be rebuilt!
-     * @todo - allow application to define multiple vertex arrays?
-     * */
-    /** TransformFeedback, WebGL 2 only. */
     transformFeedback = null;
     _pipelineNeedsUpdate = "newly created";
     _attributeInfos = {};
@@ -7146,17 +7118,19 @@ vec4 pbr_filterColor(vec4 colorUnused)
       this.id = props.id || uid("model");
       this.device = device;
       Object.assign(this.userData, props.userData);
-      const platformInfo = {
-        type: device.info.type,
-        shaderLanguage: device.info.shadingLanguages[0],
-        gpu: device.info.gpu,
-        features: device.features
-      };
+      const moduleMap = Object.fromEntries(this.props.modules?.map((module) => [module.name, module]) || []);
+      this.setShaderInputs(props.shaderInputs || new ShaderInputs(moduleMap));
+      const platformInfo = getPlatformInfo(device);
+      const modules = (this.props.modules?.length > 0 ? this.props.modules : this.shaderInputs?.getModules()) || [];
       const {
         vs: vs3,
         fs: fs3,
         getUniforms: getUniforms2
-      } = this.props.shaderAssembler.assembleShaders(platformInfo, this.props);
+      } = this.props.shaderAssembler.assembleShaders({
+        platformInfo,
+        ...this.props,
+        modules
+      });
       this.vs = vs3;
       this.fs = fs3;
       this._getModuleUniforms = getUniforms2;
@@ -7201,19 +7175,23 @@ vec4 pbr_filterColor(vec4 colorUnused)
         this.setUniforms(props.uniforms);
       }
       if (props.moduleSettings) {
+        console.warn("Model.props.moduleSettings is deprecated. Use Model.shaderInputs.setProps()");
         this.updateModuleSettings(props.moduleSettings);
       }
       if (props.transformFeedback) {
         this.transformFeedback = props.transformFeedback;
       }
-      this.setUniforms(this._getModuleUniforms());
       Object.seal(this);
     }
     destroy() {
       this.pipelineFactory.release(this.pipeline);
+      this._uniformStore.destroy();
+    }
+    predraw() {
+      this.updateShaderInputs();
     }
-    // Draw call
     draw(renderPass) {
+      this.predraw();
       this.pipeline = this._updatePipeline();
       this.pipeline.setBindings(this.bindings);
       this.pipeline.setUniforms(this.uniforms);
@@ -7225,12 +7203,6 @@ vec4 pbr_filterColor(vec4 colorUnused)
         transformFeedback: this.transformFeedback
       });
     }
-    // Update fixed fields (can trigger pipeline rebuild)
-    /**
-     * Updates the optional geometry
-     * Geometry, set topology and bufferLayout
-     * @note Can trigger a pipeline rebuild / pipeline cache fetch on WebGPU
-     */
     setGeometry(geometry) {
       const gpuGeometry = geometry && makeGPUGeometry(this.device, geometry);
       this.setTopology(gpuGeometry.topology || "triangle-list");
@@ -7240,30 +7212,17 @@ vec4 pbr_filterColor(vec4 colorUnused)
       }
       return gpuGeometry;
     }
-    /**
-     * Updates the optional geometry attributes
-     * Geometry, sets several attributes, indexBuffer, and also vertex count
-     * @note Can trigger a pipeline rebuild / pipeline cache fetch on WebGPU
-     */
     _setGeometryAttributes(gpuGeometry) {
       this.vertexCount = gpuGeometry.vertexCount;
       this.setAttributes(gpuGeometry.attributes);
       this.setIndexBuffer(gpuGeometry.indices);
     }
-    /**
-     * Updates the primitive topology ('triangle-list', 'triangle-strip' etc).
-     * @note Triggers a pipeline rebuild / pipeline cache fetch on WebGPU
-     */
     setTopology(topology) {
       if (topology !== this.topology) {
         this.topology = topology;
         this._setPipelineNeedsUpdate("topology");
       }
     }
-    /**
-     * Updates the buffer layout.
-     * @note Triggers a pipeline rebuild / pipeline cache fetch on WebGPU
-     */
     setBufferLayout(bufferLayout) {
       this.bufferLayout = this._gpuGeometry ? mergeBufferLayouts(bufferLayout, this._gpuGeometry.bufferLayout) : bufferLayout;
       this._setPipelineNeedsUpdate("bufferLayout");
@@ -7275,36 +7234,31 @@ vec4 pbr_filterColor(vec4 colorUnused)
         this._setGeometryAttributes(this._gpuGeometry);
       }
     }
-    /**
-     * Set GPU parameters.
-     * @note Can trigger a pipeline rebuild / pipeline cache fetch.
-     * @param parameters
-     */
     setParameters(parameters) {
       if (!deepEqual(parameters, this.parameters, 2)) {
         this.parameters = parameters;
         this._setPipelineNeedsUpdate("parameters");
       }
     }
-    // Update dynamic fields
-    /**
-     * Updates the vertex count (used in draw calls)
-     * @note Any attributes with stepMode=vertex need to be at least this big
-     */
     setVertexCount(vertexCount) {
       this.vertexCount = vertexCount;
     }
-    /**
-     * Updates the instance count (used in draw calls)
-     * @note Any attributes with stepMode=instance need to be at least this big
-     */
     setInstanceCount(instanceCount) {
       this.instanceCount = instanceCount;
     }
-    /**
-     * Updates shader module settings (which results in bindings & uniforms being set)
-     */
-    setShaderModuleProps(props) {
+    setShaderInputs(shaderInputs) {
+      this.shaderInputs = shaderInputs;
+      this._uniformStore = new UniformStore(this.shaderInputs.modules);
+      for (const moduleName of Object.keys(this.shaderInputs.modules)) {
+        const uniformBuffer = this._uniformStore.getManagedUniformBuffer(this.device, moduleName);
+        this.bindings[`${moduleName}Uniforms`] = uniformBuffer;
+      }
+    }
+    updateShaderInputs() {
+      this._uniformStore.setUniforms(this.shaderInputs.getUniformValues());
+    }
+    updateModuleSettings(props) {
+      console.warn("Model.updateModuleSettings is deprecated. Use Model.shaderInputs.setProps()");
       const {
         bindings,
         uniforms
@@ -7312,45 +7266,19 @@ vec4 pbr_filterColor(vec4 colorUnused)
       Object.assign(this.bindings, bindings);
       Object.assign(this.uniforms, uniforms);
     }
-    /**
-     * Updates optional transform feedback. WebGL 2 only.
-     */
-    setTransformFeedback(transformFeedback) {
-      this.transformFeedback = transformFeedback;
-    }
-    /**
-     * @deprecated Updates shader module settings (which results in uniforms being set)
-     */
-    updateModuleSettings(props) {
-      this.setShaderModuleProps(props);
-    }
-    /**
-     * Sets bindings (textures, samplers, uniform buffers)
-     */
     setBindings(bindings) {
       Object.assign(this.bindings, bindings);
     }
-    /**
-     * Sets individual uniforms
-     * @deprecated WebGL only, use uniform buffers for portability
-     * @param uniforms
-     * @returns self for chaining
-     */
     setUniforms(uniforms) {
       this.pipeline.setUniforms(uniforms);
       Object.assign(this.uniforms, uniforms);
     }
-    /**
-     * Sets the index buffer
-     * @todo - how to unset it if we change geometry?
-     */
     setIndexBuffer(indexBuffer) {
       this.vertexArray.setIndexBuffer(indexBuffer);
     }
-    /**
-     * Sets attributes (buffers)
-     * @note Overrides any attributes previously set with the same name
-     */
+    setTransformFeedback(transformFeedback) {
+      this.transformFeedback = transformFeedback;
+    }
     setAttributes(buffers) {
       if (buffers.indices) {
         log.warn(`Model:${this.id} setAttributes() - indexBuffer should be set using setIndexBuffer()`);
@@ -7375,14 +7303,6 @@ vec4 pbr_filterColor(vec4 colorUnused)
         }
       }
     }
-    /**
-     * Sets constant attributes
-     * @note Overrides any attributes previously set with the same name
-     * Constant attributes are only supported in WebGL, not in WebGPU
-     * Any attribute that is disabled in the current vertex array object
-     * is read from the context's global constant value for that attribute location.
-     * @param constantAttributes
-     */
     setConstantAttributes(attributes) {
       for (const [attributeName, value] of Object.entries(attributes)) {
         const attributeInfo = this._attributeInfos[attributeName];
@@ -7433,12 +7353,13 @@ vec4 pbr_filterColor(vec4 colorUnused)
     userData: {},
     defines: {},
     modules: [],
-    moduleSettings: {},
+    moduleSettings: void 0,
     geometry: null,
     indexBuffer: null,
     attributes: {},
     constantAttributes: {},
     varyings: [],
+    shaderInputs: void 0,
     pipelineFactory: void 0,
     transformFeedback: void 0,
     shaderAssembler: ShaderAssembler.getDefaultShaderAssembler()
@@ -7446,19 +7367,27 @@ vec4 pbr_filterColor(vec4 colorUnused)
   function mergeBufferLayouts(layouts1, layouts2) {
     const layouts = [...layouts1];
     for (const attribute of layouts2) {
-      const index = layouts.findIndex((attribute2) => attribute2.name === attribute.name);
-      if (index < 0) {
+      const index2 = layouts.findIndex((attribute2) => attribute2.name === attribute.name);
+      if (index2 < 0) {
         layouts.push(attribute);
       } else {
-        layouts[index] = attribute;
+        layouts[index2] = attribute;
       }
     }
     return layouts;
   }
+  function getPlatformInfo(device) {
+    return {
+      type: device.info.type,
+      shaderLanguage: device.info.shadingLanguage,
+      shaderLanguageVersion: device.info.shadingLanguageVersion,
+      gpu: device.info.gpu,
+      features: device.features
+    };
+  }
 
   // ../engine/src/geometry/geometry.ts
   var Geometry = class {
-    /** Determines how vertices are read from the 'vertex' attributes */
     userData = {};
     constructor(props) {
       const {
@@ -7499,31 +7428,15 @@ vec4 pbr_filterColor(vec4 colorUnused)
     getVertexCount() {
       return this.vertexCount;
     }
-    /** 
-     * Return an object with all attributes plus indices added as a field.
-     * TODO Geometry types are a mess
-     */
     getAttributes() {
       return this.indices ? {
         indices: this.indices,
         ...this.attributes
       } : this.attributes;
     }
-    // PRIVATE
     _print(attributeName) {
       return `Geometry ${this.id} attribute ${attributeName}`;
     }
-    /**
-     * GeometryAttribute
-     * value: typed array
-     * type: indices, vertices, uvs
-     * size: elements per vertex
-     * target: WebGL buffer type (string or constant)
-     * 
-     * @param attributes 
-     * @param indices 
-     * @returns 
-     */
     _setAttributes(attributes, indices) {
       return this;
     }
@@ -7568,7 +7481,6 @@ vec4 pbr_filterColor(vec4 colorUnused)
     }
     destroy() {
     }
-    /** @deprecated use .destroy() */
     delete() {
       this.destroy();
     }
@@ -7665,26 +7577,6 @@ vec4 pbr_filterColor(vec4 colorUnused)
         worldInverseTransposeMatrix: worldInverseTranspose
       };
     }
-    // TODO - copied code, not yet vetted
-    /*
-    transform() {
-      if (!this.parent) {
-        this.endPosition.set(this.position);
-        this.endRotation.set(this.rotation);
-        this.endScale.set(this.scale);
-      } else {
-        const parent = this.parent;
-        this.endPosition.set(this.position.add(parent.endPosition));
-        this.endRotation.set(this.rotation.add(parent.endRotation));
-        this.endScale.set(this.scale.add(parent.endScale));
-      }
-       const ch = this.children;
-      for (let i = 0; i < ch.length; ++i) {
-        ch[i].transform();
-      }
-       return this;
-    }
-    */
     _setScenegraphNodeProps(props) {
       if ("display" in props) {
         this.display = props.display;
@@ -7750,7 +7642,6 @@ vec4 pbr_filterColor(vec4 colorUnused)
       this.removeAll();
       super.destroy();
     }
-    // Unpacks arrays and nested arrays of children
     add(...children) {
       for (const child of children) {
         if (Array.isArray(child)) {
@@ -7794,10 +7685,6 @@ vec4 pbr_filterColor(vec4 colorUnused)
   // ../engine/src/scenegraph/model-node.ts
   var ModelNode = class extends ScenegraphNode {
     bounds = null;
-    // TODO - is this used? override callbacks to make sure we call them with this
-    // onBeforeRender = null;
-    // onAfterRender = null;
-    // AfterRender = null;
     constructor(props) {
       super(props);
       this.model = props.model;
@@ -7816,7 +7703,6 @@ vec4 pbr_filterColor(vec4 colorUnused)
       this.managedResources.forEach((resource) => resource.destroy());
       this.managedResources = [];
     }
-    // Expose model methods
     draw(renderPass) {
       return this.model.draw(renderPass);
     }
@@ -7944,17 +7830,17 @@ vec4 pbr_filterColor(vec4 colorUnused)
       }
       return original.getParameter.apply(this, arguments);
     };
-    gl.enableVertexAttribArray = function enableVertexAttribArray(index) {
+    gl.enableVertexAttribArray = function enableVertexAttribArray(index2) {
       const vao = self.currentVertexArrayObject;
-      vao.maxAttrib = Math.max(vao.maxAttrib, index);
-      const attrib = vao.attribs[index];
+      vao.maxAttrib = Math.max(vao.maxAttrib, index2);
+      const attrib = vao.attribs[index2];
       attrib.enabled = true;
       return original.enableVertexAttribArray.apply(this, arguments);
     };
-    gl.disableVertexAttribArray = function disableVertexAttribArray(index) {
+    gl.disableVertexAttribArray = function disableVertexAttribArray(index2) {
       const vao = self.currentVertexArrayObject;
-      vao.maxAttrib = Math.max(vao.maxAttrib, index);
-      const attrib = vao.attribs[index];
+      vao.maxAttrib = Math.max(vao.maxAttrib, index2);
+      const attrib = vao.attribs[index2];
       attrib.enabled = false;
       return original.disableVertexAttribArray.apply(this, arguments);
     };
@@ -7970,9 +7856,9 @@ vec4 pbr_filterColor(vec4 colorUnused)
       }
       return original.bindBuffer.apply(this, arguments);
     };
-    gl.getVertexAttrib = function getVertexAttrib(index, pname) {
+    gl.getVertexAttrib = function getVertexAttrib(index2, pname) {
       const vao = self.currentVertexArrayObject;
-      const attrib = vao.attribs[index];
+      const attrib = vao.attribs[index2];
       switch (pname) {
         case gl.VERTEX_ATTRIB_ARRAY_BUFFER_BINDING:
           return attrib.buffer;
@@ -8126,7 +8012,7 @@ vec4 pbr_filterColor(vec4 colorUnused)
   }
 
   // ../constants/src/constants-enum.ts
-  var GLEnum2 = /* @__PURE__ */ function(GLEnum4) {
+  var GLEnum2 = function(GLEnum4) {
     GLEnum4[GLEnum4["DEPTH_BUFFER_BIT"] = 256] = "DEPTH_BUFFER_BIT";
     GLEnum4[GLEnum4["STENCIL_BUFFER_BIT"] = 1024] = "STENCIL_BUFFER_BIT";
     GLEnum4[GLEnum4["COLOR_BUFFER_BIT"] = 16384] = "COLOR_BUFFER_BIT";
@@ -8833,16 +8719,13 @@ vec4 pbr_filterColor(vec4 colorUnused)
   var getWebGL2ValueOrZero = (gl) => !isWebGL2(gl) ? 0 : void 0;
   var WEBGL_PARAMETERS = {
     [GLEnum2.READ_BUFFER]: (gl) => !isWebGL2(gl) ? GLEnum2.COLOR_ATTACHMENT0 : void 0,
-    // WebGL2 context parameters
     [GL_FRAGMENT_SHADER_DERIVATIVE_HINT]: (gl) => !isWebGL2(gl) ? GL_DONT_CARE : void 0,
     [GLEnum2.RASTERIZER_DISCARD]: getWebGL2ValueOrZero,
     [GLEnum2.SAMPLES]: getWebGL2ValueOrZero,
-    // WebGL2 extension context parameters
     [GL_GPU_DISJOINT_EXT]: (gl, getParameter) => {
       const ext = isWebGL2(gl) ? gl.getExtension(EXT_disjoint_timer_query_webgl2) : gl.getExtension(EXT_disjoint_timer_query);
       return ext && ext.GPU_DISJOINT_EXT ? getParameter(ext.GPU_DISJOINT_EXT) : 0;
     },
-    // Extension fixed values
     [GL_UNMASKED_VENDOR_WEBGL]: (gl, getParameter) => {
       const ext = gl.getExtension(WEBGL_debug_renderer_info);
       return getParameter(ext && ext.UNMASKED_VENDOR_WEBGL || GLEnum2.VENDOR);
@@ -8851,12 +8734,10 @@ vec4 pbr_filterColor(vec4 colorUnused)
       const ext = gl.getExtension(WEBGL_debug_renderer_info);
       return getParameter(ext && ext.UNMASKED_RENDERER_WEBGL || GLEnum2.RENDERER);
     },
-    // Extension LIMITS
     [GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT]: (gl, getParameter) => {
       const ext = gl.luma?.extensions?.[EXT_texture_filter_anisotropic] || gl.getExtension("EXT_texture_filter_anisotropic");
       return ext ? getParameter(ext.MAX_TEXTURE_MAX_ANISOTROPY_EXT) : 1;
     },
-    // WebGL2 Limits
     [GLEnum2.MAX_3D_TEXTURE_SIZE]: getWebGL2ValueOrZero,
     [GLEnum2.MAX_ARRAY_TEXTURE_LAYERS]: getWebGL2ValueOrZero,
     [GLEnum2.MAX_CLIENT_WAIT_TIMEOUT_WEBGL]: getWebGL2ValueOrZero,
@@ -8877,18 +8758,9 @@ vec4 pbr_filterColor(vec4 colorUnused)
       }
       return void 0;
     },
-    [GLEnum2.MAX_ELEMENT_INDEX]: (
-      // Guess: per webglstats.com 99.6% of webgl2 supports 2147483647
-      (gl) => gl.getExtension(OES_element_index) ? 2147483647 : 65535
-    ),
-    [GLEnum2.MAX_ELEMENTS_INDICES]: (
-      // Guess: "Reasonably safe" per webglstats.com - could be higher/lower (on some mobile devices)
-      (gl) => gl.getExtension(OES_element_index) ? 16777216 : 65535
-    ),
-    [GLEnum2.MAX_ELEMENTS_VERTICES]: (
-      // Guess: "Reasonably safe" per webglstats.com - could be higher/lower (on some mobile devices)
-      (gl) => 16777216
-    ),
+    [GLEnum2.MAX_ELEMENT_INDEX]: (gl) => gl.getExtension(OES_element_index) ? 2147483647 : 65535,
+    [GLEnum2.MAX_ELEMENTS_INDICES]: (gl) => gl.getExtension(OES_element_index) ? 16777216 : 65535,
+    [GLEnum2.MAX_ELEMENTS_VERTICES]: (gl) => 16777216,
     [GLEnum2.MAX_FRAGMENT_INPUT_COMPONENTS]: getWebGL2ValueOrZero,
     [GLEnum2.MAX_FRAGMENT_UNIFORM_BLOCKS]: getWebGL2ValueOrZero,
     [GLEnum2.MAX_FRAGMENT_UNIFORM_COMPONENTS]: getWebGL2ValueOrZero,
@@ -8942,12 +8814,10 @@ vec4 pbr_filterColor(vec4 colorUnused)
     };
   }
   var WEBGL2_CONTEXT_POLYFILLS = {
-    // POLYFILL TABLE
     [OES_vertex_array_object]: {
       meta: {
         suffix: "OES"
       },
-      // NEW METHODS
       createVertexArray: () => {
         assert2(false, ERR_VAO_NOT_SUPPORTED);
       },
@@ -8960,9 +8830,6 @@ vec4 pbr_filterColor(vec4 colorUnused)
     [ANGLE_instanced_arrays]: {
       meta: {
         suffix: "ANGLE"
-        // constants: {
-        //   VERTEX_ATTRIB_ARRAY_DIVISOR: 'VERTEX_ATTRIB_ARRAY_DIVISOR_ANGLE'
-        // }
       },
       vertexAttribDivisor(location, divisor) {
         assert2(divisor === 0, "WebGL instanced rendering not supported");
@@ -8984,7 +8851,6 @@ vec4 pbr_filterColor(vec4 colorUnused)
       meta: {
         suffix: "EXT"
       },
-      // WebGL1: Polyfills the WebGL2 Query API
       createQuery: () => {
         assert2(false);
       },
@@ -8999,7 +8865,6 @@ vec4 pbr_filterColor(vec4 colorUnused)
       getQuery(handle, pname) {
         return this.getQueryObject(handle, pname);
       },
-      // The WebGL1 extension uses getQueryObject rather then getQueryParameter
       getQueryParameter(handle, pname) {
         return this.getQueryObject(handle, pname);
       },
@@ -9008,14 +8873,12 @@ vec4 pbr_filterColor(vec4 colorUnused)
     }
   };
   var WEBGL2_CONTEXT_OVERRIDES = {
-    // Ensure readBuffer is a no-op
     readBuffer: (gl, originalFunc, attachment) => {
       if (isWebGL2(gl)) {
         originalFunc(attachment);
       } else {
       }
     },
-    // Override for getVertexAttrib that returns sane values for non-WebGL1 constants
     getVertexAttrib: (gl, originalFunc, location, pname) => {
       const {
         webgl2,
@@ -9033,7 +8896,6 @@ vec4 pbr_filterColor(vec4 colorUnused)
       }
       return result !== void 0 ? result : originalFunc(location, pname);
     },
-    // Handle transform feedback and uniform block queries in WebGL1
     getProgramParameter: (gl, originalFunc, program, pname) => {
       if (!isWebGL2(gl)) {
         switch (pname) {
@@ -9170,7 +9032,6 @@ vec4 pbr_filterColor(vec4 colorUnused)
     [GLEnum2.BLEND_SRC_ALPHA]: GLEnum2.ONE,
     [GLEnum2.BLEND_DST_ALPHA]: GLEnum2.ZERO,
     [GLEnum2.COLOR_CLEAR_VALUE]: new Float32Array([0, 0, 0, 0]),
-    // TBD
     [GLEnum2.COLOR_WRITEMASK]: [true, true, true, true],
     [GLEnum2.CULL_FACE]: false,
     [GLEnum2.CULL_FACE_MODE]: GLEnum2.BACK,
@@ -9178,11 +9039,9 @@ vec4 pbr_filterColor(vec4 colorUnused)
     [GLEnum2.DEPTH_CLEAR_VALUE]: 1,
     [GLEnum2.DEPTH_FUNC]: GLEnum2.LESS,
     [GLEnum2.DEPTH_RANGE]: new Float32Array([0, 1]),
-    // TBD
     [GLEnum2.DEPTH_WRITEMASK]: true,
     [GLEnum2.DITHER]: true,
     [GLEnum2.CURRENT_PROGRAM]: null,
-    // FRAMEBUFFER_BINDING and DRAW_FRAMEBUFFER_BINDING(WebGL2) refer same state.
     [GLEnum2.FRAMEBUFFER_BINDING]: null,
     [GLEnum2.RENDERBUFFER_BINDING]: null,
     [GLEnum2.VERTEX_ARRAY_BINDING]: null,
@@ -9198,7 +9057,6 @@ vec4 pbr_filterColor(vec4 colorUnused)
     [GLEnum2.SAMPLE_COVERAGE_VALUE]: 1,
     [GLEnum2.SAMPLE_COVERAGE_INVERT]: false,
     [GLEnum2.SCISSOR_TEST]: false,
-    // Note: Dynamic value. If scissor test enabled we expect users to set correct scissor box
     [GLEnum2.SCISSOR_BOX]: new Int32Array([0, 0, 1024, 1024]),
     [GLEnum2.STENCIL_TEST]: false,
     [GLEnum2.STENCIL_CLEAR_VALUE]: 0,
@@ -9216,16 +9074,12 @@ vec4 pbr_filterColor(vec4 colorUnused)
     [GLEnum2.STENCIL_BACK_FAIL]: GLEnum2.KEEP,
     [GLEnum2.STENCIL_BACK_PASS_DEPTH_FAIL]: GLEnum2.KEEP,
     [GLEnum2.STENCIL_BACK_PASS_DEPTH_PASS]: GLEnum2.KEEP,
-    // Dynamic value: We use [0, 0, 1024, 1024] as default, but usually this is updated in each frame.
     [GLEnum2.VIEWPORT]: [0, 0, 1024, 1024],
-    // WEBGL1 PIXEL PACK/UNPACK MODES
     [GLEnum2.PACK_ALIGNMENT]: 4,
     [GLEnum2.UNPACK_ALIGNMENT]: 4,
     [GLEnum2.UNPACK_FLIP_Y_WEBGL]: false,
     [GLEnum2.UNPACK_PREMULTIPLY_ALPHA_WEBGL]: false,
     [GLEnum2.UNPACK_COLORSPACE_CONVERSION_WEBGL]: GLEnum2.BROWSER_DEFAULT_WEBGL,
-    // WEBGL2 / EXTENSIONS
-    // gl1: 'OES_standard_derivatives'
     [GLEnum2.TRANSFORM_FEEDBACK_BINDING]: null,
     [GLEnum2.COPY_READ_BUFFER_BINDING]: null,
     [GLEnum2.COPY_WRITE_BUFFER_BINDING]: null,
@@ -9293,10 +9147,8 @@ vec4 pbr_filterColor(vec4 colorUnused)
     [GLEnum2.RENDERBUFFER_BINDING]: (gl, value) => gl.bindRenderbuffer(GLEnum2.RENDERBUFFER, value),
     [GLEnum2.TRANSFORM_FEEDBACK_BINDING]: (gl, value) => gl.bindTransformFeedback?.(GLEnum2.TRANSFORM_FEEDBACK, value),
     [GLEnum2.VERTEX_ARRAY_BINDING]: (gl, value) => gl.bindVertexArray(value),
-    // NOTE: FRAMEBUFFER_BINDING and DRAW_FRAMEBUFFER_BINDING(WebGL2) refer same state.
     [GLEnum2.FRAMEBUFFER_BINDING]: bindFramebuffer,
     [GLEnum2.READ_FRAMEBUFFER_BINDING]: bindFramebuffer,
-    // Buffers
     [GLEnum2.ARRAY_BUFFER_BINDING]: bindBuffer,
     [GLEnum2.COPY_READ_BUFFER_BINDING]: bindBuffer,
     [GLEnum2.COPY_WRITE_BUFFER_BINDING]: bindBuffer,
@@ -9332,14 +9184,11 @@ vec4 pbr_filterColor(vec4 colorUnused)
     [GLEnum2.STENCIL_BACK_PASS_DEPTH_FAIL]: "stencilOpBack",
     [GLEnum2.STENCIL_BACK_PASS_DEPTH_PASS]: "stencilOpBack",
     [GLEnum2.VIEWPORT]: (gl, value) => gl.viewport(...value),
-    // WEBGL1 PIXEL PACK/UNPACK MODES
     [GLEnum2.PACK_ALIGNMENT]: pixelStorei,
     [GLEnum2.UNPACK_ALIGNMENT]: pixelStorei,
     [GLEnum2.UNPACK_FLIP_Y_WEBGL]: pixelStorei,
     [GLEnum2.UNPACK_PREMULTIPLY_ALPHA_WEBGL]: pixelStorei,
     [GLEnum2.UNPACK_COLORSPACE_CONVERSION_WEBGL]: pixelStorei,
-    // WEBGL2 PIXEL PACK/UNPACK MODES
-    // RASTERIZER_DISCARD ...
     [GLEnum2.PACK_ROW_LENGTH]: pixelStorei,
     [GLEnum2.PACK_SKIP_PIXELS]: pixelStorei,
     [GLEnum2.PACK_SKIP_ROWS]: pixelStorei,
@@ -9348,7 +9197,6 @@ vec4 pbr_filterColor(vec4 colorUnused)
     [GLEnum2.UNPACK_SKIP_PIXELS]: pixelStorei,
     [GLEnum2.UNPACK_SKIP_ROWS]: pixelStorei,
     [GLEnum2.UNPACK_SKIP_IMAGES]: pixelStorei,
-    // Function-style setters
     framebuffer: (gl, framebuffer) => {
       const handle = framebuffer && "handle" in framebuffer ? framebuffer.handle : framebuffer;
       return gl.bindFramebuffer(GLEnum2.FRAMEBUFFER, handle);
@@ -9420,7 +9268,6 @@ vec4 pbr_filterColor(vec4 colorUnused)
     stencilOpBack: (gl, values, cache2) => gl.stencilOpSeparate(GLEnum2.BACK, getValue(GLEnum2.STENCIL_BACK_FAIL, values, cache2), getValue(GLEnum2.STENCIL_BACK_PASS_DEPTH_FAIL, values, cache2), getValue(GLEnum2.STENCIL_BACK_PASS_DEPTH_PASS, values, cache2))
   };
   var GL_HOOKED_SETTERS = {
-    // GENERIC SETTERS
     enable: (update, capability) => update({
       [capability]: true
     }),
@@ -9433,7 +9280,6 @@ vec4 pbr_filterColor(vec4 colorUnused)
     hint: (update, pname, hint2) => update({
       [pname]: hint2
     }),
-    // SPECIFIC SETTERS
     useProgram: (update, value) => update({
       [GLEnum2.CURRENT_PROGRAM]: value
     }),
@@ -9594,47 +9440,9 @@ vec4 pbr_filterColor(vec4 colorUnused)
     [GLEnum2.SAMPLE_COVERAGE]: isEnabled,
     [GLEnum2.SCISSOR_TEST]: isEnabled,
     [GLEnum2.STENCIL_TEST]: isEnabled,
-    // WebGL 2
     [GLEnum2.RASTERIZER_DISCARD]: isEnabled
   };
-  var NON_CACHE_PARAMETERS = /* @__PURE__ */ new Set([
-    // setter not intercepted
-    GLEnum2.ACTIVE_TEXTURE,
-    GLEnum2.TRANSFORM_FEEDBACK_ACTIVE,
-    GLEnum2.TRANSFORM_FEEDBACK_PAUSED,
-    // setters bindBufferRange/bindBufferBase cannot be pruned based on cache
-    GLEnum2.TRANSFORM_FEEDBACK_BUFFER_BINDING,
-    GLEnum2.UNIFORM_BUFFER_BINDING,
-    // states depending on VERTEX_ARRAY_BINDING
-    GLEnum2.ELEMENT_ARRAY_BUFFER_BINDING,
-    // states depending on READ_FRAMEBUFFER_BINDING
-    GLEnum2.IMPLEMENTATION_COLOR_READ_FORMAT,
-    GLEnum2.IMPLEMENTATION_COLOR_READ_TYPE,
-    // states depending on FRAMEBUFFER_BINDING
-    GLEnum2.READ_BUFFER,
-    GLEnum2.DRAW_BUFFER0,
-    GLEnum2.DRAW_BUFFER1,
-    GLEnum2.DRAW_BUFFER2,
-    GLEnum2.DRAW_BUFFER3,
-    GLEnum2.DRAW_BUFFER4,
-    GLEnum2.DRAW_BUFFER5,
-    GLEnum2.DRAW_BUFFER6,
-    GLEnum2.DRAW_BUFFER7,
-    GLEnum2.DRAW_BUFFER8,
-    GLEnum2.DRAW_BUFFER9,
-    GLEnum2.DRAW_BUFFER10,
-    GLEnum2.DRAW_BUFFER11,
-    GLEnum2.DRAW_BUFFER12,
-    GLEnum2.DRAW_BUFFER13,
-    GLEnum2.DRAW_BUFFER14,
-    GLEnum2.DRAW_BUFFER15,
-    // states depending on ACTIVE_TEXTURE
-    GLEnum2.SAMPLER_BINDING,
-    GLEnum2.TEXTURE_BINDING_2D,
-    GLEnum2.TEXTURE_BINDING_2D_ARRAY,
-    GLEnum2.TEXTURE_BINDING_3D,
-    GLEnum2.TEXTURE_BINDING_CUBE_MAP
-  ]);
+  var NON_CACHE_PARAMETERS = /* @__PURE__ */ new Set([GLEnum2.ACTIVE_TEXTURE, GLEnum2.TRANSFORM_FEEDBACK_ACTIVE, GLEnum2.TRANSFORM_FEEDBACK_PAUSED, GLEnum2.TRANSFORM_FEEDBACK_BUFFER_BINDING, GLEnum2.UNIFORM_BUFFER_BINDING, GLEnum2.ELEMENT_ARRAY_BUFFER_BINDING, GLEnum2.IMPLEMENTATION_COLOR_READ_FORMAT, GLEnum2.IMPLEMENTATION_COLOR_READ_TYPE, GLEnum2.READ_BUFFER, GLEnum2.DRAW_BUFFER0, GLEnum2.DRAW_BUFFER1, GLEnum2.DRAW_BUFFER2, GLEnum2.DRAW_BUFFER3, GLEnum2.DRAW_BUFFER4, GLEnum2.DRAW_BUFFER5, GLEnum2.DRAW_BUFFER6, GLEnum2.DRAW_BUFFER7, GLEnum2.DRAW_BUFFER8, GLEnum2.DRAW_BUFFER9, GLEnum2.DRAW_BUFFER10, GLEnum2.DRAW_BUFFER11, GLEnum2.DRAW_BUFFER12, GLEnum2.DRAW_BUFFER13, GLEnum2.DRAW_BUFFER14, GLEnum2.DRAW_BUFFER15, GLEnum2.SAMPLER_BINDING, GLEnum2.TEXTURE_BINDING_2D, GLEnum2.TEXTURE_BINDING_2D_ARRAY, GLEnum2.TEXTURE_BINDING_3D, GLEnum2.TEXTURE_BINDING_CUBE_MAP]);
 
   // ../webgl/src/context/parameters/unified-parameter-api.ts
   function setGLParameters(device, parameters) {
@@ -9711,10 +9519,8 @@ vec4 pbr_filterColor(vec4 colorUnused)
     enable = true;
     constructor(gl, {
       copyState = false,
-      // Copy cache from params (slow) or initialize from WebGL defaults (fast)
       log: log3 = () => {
       }
-      // Logging function, called when gl parameter change calls are actually issued
     } = {}) {
       this.gl = gl;
       this.cache = copyState ? getGLParameters(gl) : Object.assign({}, GL_PARAMETER_DEFAULTS);
@@ -9731,12 +9537,6 @@ vec4 pbr_filterColor(vec4 colorUnused)
       setGLParameters(this.gl, oldValues);
       this.stateStack.pop();
     }
-    /**
-    // interceptor for context set functions - update our cache and our stack
-    // values (Object) - the key values for this setter
-     * @param values
-     * @returns
-     */
     _updateCache(values) {
       let valueChanged = false;
       let oldValue;
@@ -9810,13 +9610,7 @@ vec4 pbr_filterColor(vec4 colorUnused)
       if (!(pname in glState.cache)) {
         glState.cache[pname] = originalGetterFunc(pname);
       }
-      return glState.enable ? (
-        // Call the getter the params so that it can e.g. serve from a cache
-        glState.cache[pname]
-      ) : (
-        // Optionally call the original function to do a "hard" query from the WebGLRenderingContext
-        originalGetterFunc(pname)
-      );
+      return glState.enable ? glState.cache[pname] : originalGetterFunc(pname);
     };
     Object.defineProperty(gl[functionName], "name", {
       value: `${functionName}-from-cache`,
@@ -9858,14 +9652,9 @@ vec4 pbr_filterColor(vec4 colorUnused)
   // ../webgl/src/context/context/create-browser-context.ts
   var DEFAULT_CONTEXT_PROPS = {
     webgl2: true,
-    // Attempt to create a WebGL2 context
     webgl1: true,
-    // Attempt to create a WebGL1 context (false to fail if webgl2 not available)
     powerPreference: "high-performance",
-    // After all, most apps are using WebGL for performance reasons
-    // eslint-disable-next-line no-console
     onContextLost: () => console.error("WebGL context lost"),
-    // eslint-disable-next-line no-console
     onContextRestored: () => console.info("WebGL context restored")
   };
   function createBrowserContext(canvas, props) {
@@ -9923,17 +9712,20 @@ vec4 pbr_filterColor(vec4 colorUnused)
     const rendererUnmasked = gl.getParameter(ext ? ext.UNMASKED_RENDERER_WEBGL : GLEnum2.RENDERER);
     const vendor = vendorUnmasked || vendorMasked;
     const renderer = rendererUnmasked || rendererMasked;
+    const version = gl.getParameter(GLEnum2.VERSION);
     const gpu = identifyGPUVendor(vendor, renderer);
+    const gpuBackend = identifyGPUBackend(vendor, renderer);
+    const shadingLanguage = "glsl";
+    const shadingLanguageVersion = isWebGL2(gl) ? 300 : 100;
     return {
       type: isWebGL2(gl) ? "webgl2" : "webgl",
       gpu,
-      vendor: vendorUnmasked || vendorMasked,
-      renderer: rendererUnmasked || rendererMasked,
-      version: gl.getParameter(GLEnum2.VERSION),
-      shadingLanguages: ["glsl"],
-      shadingLanguageVersions: {
-        "glsl": gl.getParameter(GLEnum2.SHADING_LANGUAGE_VERSION)
-      }
+      gpuBackend,
+      vendor,
+      renderer,
+      version,
+      shadingLanguage,
+      shadingLanguageVersion
     };
   }
   function identifyGPUVendor(vendor, renderer) {
@@ -9954,6 +9746,15 @@ vec4 pbr_filterColor(vec4 colorUnused)
     }
     return "unknown";
   }
+  function identifyGPUBackend(vendor, renderer) {
+    if (/ANGLE/i.exec(vendor) || /ANGLE/i.exec(renderer)) {
+      return "angle";
+    }
+    if (/Metal/i.exec(vendor) || /Metal/i.exec(renderer)) {
+      return "metal";
+    }
+    return "unknown";
+  }
 
   // ../webgl/src/adapter/device-helpers/is-old-ie.ts
   function isOldIE(opts = {}) {
@@ -10028,13 +9829,9 @@ vec4 pbr_filterColor(vec4 colorUnused)
     "texture-filter-linear-float16-webgl": (gl) => checkExtension(gl, "OES_texture_half_float_linear"),
     "texture-filter-anisotropic-webgl": (gl) => checkExtension(gl, "EXT_texture_filter_anisotropic"),
     "texture-renderable-float32-webgl": (gl) => checkExtension(gl, "EXT_color_buffer_float"),
-    // [false, 'EXT_color_buffer_float'],
     "texture-renderable-float16-webgl": (gl) => checkExtension(gl, "EXT_color_buffer_half_float"),
     "texture-compression-bc": (gl) => checkExtensions(gl, [X_S3TC, X_S3TC_SRGB, X_RGTC, X_BPTC]),
     "texture-compression-bc5-webgl": (gl) => checkExtensions(gl, [X_RGTC]),
-    // 'texture-compression-bc7-webgl': gl => checkExtensions(gl, [X_BPTC]),
-    // 'texture-compression-bc3-srgb-webgl': gl => checkExtensions(gl, [X_S3TC_SRGB]),
-    // 'texture-compression-bc3-webgl': gl => checkExtensions(gl, [X_S3TC]),
     "texture-compression-etc2": (gl) => checkExtensions(gl, [X_ETC2]),
     "texture-compression-astc": (gl) => checkExtensions(gl, [X_ASTC]),
     "texture-compression-etc1-webgl": (gl) => checkExtensions(gl, [X_ETC1]),
@@ -10049,9 +9846,6 @@ vec4 pbr_filterColor(vec4 colorUnused)
     return textureFeatures.filter((feature) => checkTextureFeature(gl, feature));
   }
   var TEXTURE_FORMATS = {
-    // Unsized formats that leave the precision up to the driver.
-    // TODO - Fix bpp constants
-    // 'r8unorm-unsized': {gl: GL.LUMINANCE, b: 4, c: 2, bpp: 4},
     "rgb8unorm-unsized": {
       gl: GLEnum2.RGB,
       gl1: GLEnum2.RGB,
@@ -10070,9 +9864,6 @@ vec4 pbr_filterColor(vec4 colorUnused)
       dataFormat: GLEnum2.RGBA,
       types: [GLEnum2.UNSIGNED_BYTE, GLEnum2.UNSIGNED_SHORT_4_4_4_4, GLEnum2.UNSIGNED_SHORT_5_5_5_1]
     },
-    // 'rgb8unorm-srgb-unsized': {gl: GL.SRGB_EXT, b: 4, c: 2, bpp: 4, gl1Ext: SRGB},
-    // 'rgba8unorm-srgb-unsized': {gl: GL.SRGB_ALPHA_EXT, b: 4, c: 2, bpp: 4, gl1Ext: SRGB},
-    // 8-bit formats
     "r8unorm": {
       gl: GLEnum2.R8,
       b: 1,
@@ -10096,7 +9887,6 @@ vec4 pbr_filterColor(vec4 colorUnused)
       c: 1,
       renderbuffer: true
     },
-    // 16-bit formats
     "rg8unorm": {
       gl: GLEnum2.RG8,
       b: 2,
@@ -10155,7 +9945,6 @@ vec4 pbr_filterColor(vec4 colorUnused)
       f: "texture-formats-norm16-webgl",
       x: EXT_TEXTURE_NORM16
     },
-    // Packed 16-bit formats
     "rgba4unorm-webgl": {
       gl: GLEnum2.RGBA4,
       b: 2,
@@ -10177,7 +9966,6 @@ vec4 pbr_filterColor(vec4 colorUnused)
       wgpu: false,
       renderbuffer: true
     },
-    // 24-bit formats
     "rgb8unorm-webgl": {
       gl: GLEnum2.RGB8,
       b: 3,
@@ -10190,7 +9978,6 @@ vec4 pbr_filterColor(vec4 colorUnused)
       c: 3,
       wgpu: false
     },
-    // 32-bit formats  
     "rgba8unorm": {
       gl: GLEnum2.RGBA8,
       gl1: GLEnum2.RGBA,
@@ -10223,7 +10010,6 @@ vec4 pbr_filterColor(vec4 colorUnused)
       c: 4,
       bpp: 4
     },
-    // reverse colors, webgpu only
     "bgra8unorm": {
       b: 4,
       c: 4
@@ -10244,7 +10030,6 @@ vec4 pbr_filterColor(vec4 colorUnused)
       c: 2,
       bpp: 4
     },
-    // When using a WebGL 2 context and the EXT_color_buffer_float WebGL2 extension
     "rg16float": {
       gl: GLEnum2.RG16F,
       bpp: 4,
@@ -10290,7 +10075,6 @@ vec4 pbr_filterColor(vec4 colorUnused)
       render: "texture-renderable-float32-webgl",
       filter: "texture-filter-linear-float32-webgl"
     },
-    // Packed 32-bit formats
     "rgb9e5ufloat": {
       gl: GLEnum2.RGB9_E5,
       b: 4,
@@ -10314,7 +10098,6 @@ vec4 pbr_filterColor(vec4 colorUnused)
       p: 1,
       renderbuffer: true
     },
-    // webgl2 only
     "rgb10a2unorm-webgl": {
       b: 4,
       c: 4,
@@ -10324,7 +10107,6 @@ vec4 pbr_filterColor(vec4 colorUnused)
       bpp: 4,
       renderbuffer: true
     },
-    // 48-bit formats
     "rgb16unorm-webgl": {
       gl: GLEnum2.RGB16_EXT,
       b: 2,
@@ -10339,7 +10121,6 @@ vec4 pbr_filterColor(vec4 colorUnused)
       f: "texture-formats-norm16-webgl",
       x: EXT_TEXTURE_NORM16
     },
-    // 64-bit formats
     "rg32uint": {
       gl: GLEnum2.RG32UI,
       b: 8,
@@ -10395,7 +10176,6 @@ vec4 pbr_filterColor(vec4 colorUnused)
       f: "texture-formats-norm16-webgl",
       x: EXT_TEXTURE_NORM16
     },
-    // 96-bit formats (deprecated!)
     "rgb32float-webgl": {
       gl: GLEnum2.RGB32F,
       gl1: GLEnum2.RGB,
@@ -10403,11 +10183,9 @@ vec4 pbr_filterColor(vec4 colorUnused)
       filter: "texture-filter-linear-float32-webgl",
       gl2ext: EXT_FLOAT_RENDER_WEBGL2,
       gl1ext: EXT_FLOAT_WEBGL1,
-      // WebGL1 render buffers are supported with GL.RGB32F
       dataFormat: GLEnum2.RGB,
       types: [GLEnum2.FLOAT]
     },
-    // 128-bit formats
     "rgba32uint": {
       gl: GLEnum2.RGBA32UI,
       b: 16,
@@ -10428,7 +10206,6 @@ vec4 pbr_filterColor(vec4 colorUnused)
       filter: "texture-filter-linear-float32-webgl",
       renderbuffer: true
     },
-    // Depth and stencil formats
     "stencil8": {
       gl: GLEnum2.STENCIL_INDEX8,
       gl1: GLEnum2.STENCIL_INDEX8,
@@ -10437,7 +10214,6 @@ vec4 pbr_filterColor(vec4 colorUnused)
       attachment: GLEnum2.STENCIL_ATTACHMENT,
       renderbuffer: true
     },
-    // 8 stencil bits
     "depth16unorm": {
       gl: GLEnum2.DEPTH_COMPONENT16,
       gl1: GLEnum2.DEPTH_COMPONENT16,
@@ -10446,7 +10222,6 @@ vec4 pbr_filterColor(vec4 colorUnused)
       attachment: GLEnum2.DEPTH_ATTACHMENT,
       renderbuffer: true
     },
-    // 16 depth bits
     "depth24plus": {
       gl: GLEnum2.DEPTH_COMPONENT24,
       b: 3,
@@ -10460,7 +10235,6 @@ vec4 pbr_filterColor(vec4 colorUnused)
       attachment: GLEnum2.DEPTH_ATTACHMENT,
       renderbuffer: true
     },
-    // The depth component of the "depth24plus" and "depth24plus-stencil8" formats may be implemented as either a 24-bit depth value or a "depth32float" value.
     "depth24plus-stencil8": {
       gl: GLEnum2.DEPTH_STENCIL,
       gl1: GLEnum2.DEPTH_STENCIL,
@@ -10471,7 +10245,6 @@ vec4 pbr_filterColor(vec4 colorUnused)
       renderbuffer: true,
       depthTexture: true
     },
-    // "depth24unorm-stencil8" feature
     "depth24unorm-stencil8": {
       gl: GLEnum2.DEPTH24_STENCIL8,
       b: 4,
@@ -10480,7 +10253,6 @@ vec4 pbr_filterColor(vec4 colorUnused)
       attachment: GLEnum2.DEPTH_STENCIL_ATTACHMENT,
       renderbuffer: true
     },
-    // "depth32float-stencil8" feature
     "depth32float-stencil8": {
       gl: GLEnum2.DEPTH32F_STENCIL8,
       b: 5,
@@ -10489,7 +10261,6 @@ vec4 pbr_filterColor(vec4 colorUnused)
       attachment: GLEnum2.DEPTH_STENCIL_ATTACHMENT,
       renderbuffer: true
     },
-    // BC compressed formats: check device.features.has("texture-compression-bc");
     "bc1-rgb-unorm-webgl": {
       gl: GLEnum2.COMPRESSED_RGB_S3TC_DXT1_EXT,
       x: X_S3TC,
@@ -10570,8 +10341,6 @@ vec4 pbr_filterColor(vec4 colorUnused)
       x: X_BPTC,
       f: texture_compression_bc
     },
-    // WEBGL_compressed_texture_etc: device.features.has("texture-compression-etc2")
-    // Note: Supposedly guaranteed availability compressed formats in WebGL2, but through CPU decompression
     "etc2-rgb8unorm": {
       gl: GLEnum2.COMPRESSED_RGB8_ETC2,
       f: texture_compression_etc2
@@ -10612,7 +10381,6 @@ vec4 pbr_filterColor(vec4 colorUnused)
       gl: GLEnum2.COMPRESSED_SIGNED_RG11_EAC,
       f: texture_compression_etc2
     },
-    // X_ASTC compressed formats: device.features.has("texture-compression-astc")
     "astc-4x4-unorm": {
       gl: GLEnum2.COMPRESSED_RGBA_ASTC_4x4_KHR,
       f: texture_compression_astc
@@ -10725,7 +10493,6 @@ vec4 pbr_filterColor(vec4 colorUnused)
       gl: GLEnum2.COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR,
       f: texture_compression_astc
     },
-    // WEBGL_compressed_texture_pvrtc
     "pvrtc-rgb4unorm-webgl": {
       gl: GLEnum2.COMPRESSED_RGB_PVRTC_4BPPV1_IMG,
       f: texture_compression_pvrtc_webgl
@@ -10742,12 +10509,10 @@ vec4 pbr_filterColor(vec4 colorUnused)
       gl: GLEnum2.COMPRESSED_RGBA_PVRTC_2BPPV1_IMG,
       f: texture_compression_pvrtc_webgl
     },
-    // WEBGL_compressed_texture_etc1
     "etc1-rbg-unorm-webgl": {
       gl: GLEnum2.COMPRESSED_RGB_ETC1_WEBGL,
       f: texture_compression_etc1_webgl
     },
-    // WEBGL_compressed_texture_atc
     "atc-rgb-unorm-webgl": {
       gl: GLEnum2.COMPRESSED_RGB_ATC_WEBGL,
       f: texture_compression_atc_webgl
@@ -10860,9 +10625,7 @@ vec4 pbr_filterColor(vec4 colorUnused)
     return {
       format: webglFormat,
       dataFormat: getWebGLPixelDataFormat(decoded.format, decoded.integer, decoded.normalized, webglFormat),
-      // depth formats don't have a type
       type: decoded.dataType ? getGLFromVertexType(decoded.dataType) : GLEnum2.UNSIGNED_BYTE,
-      // @ts-expect-error
       compressed: decoded.compressed
     };
   }
@@ -10993,28 +10756,22 @@ void main(void) {}`;
     "webgl2": [false, true],
     "timer-query-webgl": ["EXT_disjoint_timer_query", "EXT_disjoint_timer_query_webgl2"],
     "transform-feedback-webgl2": [false, true],
-    // WEBGL1 SUPPORT
     "vertex-array-object-webgl1": ["OES_vertex_array_object", true],
     "instanced-rendering-webgl1": ["ANGLE_instanced_arrays", true],
     "multiple-render-targets-webgl1": ["WEBGL_draw_buffers", true],
     "index-uint32-webgl1": ["OES_element_index_uint", true],
     "blend-minmax-webgl1": ["EXT_blend_minmax", true],
     "texture-blend-float-webgl1": ["EXT_float_blend", "EXT_float_blend"],
-    // TEXTURES, RENDERBUFFERS
     "texture-formats-srgb-webgl1": ["EXT_sRGB", true],
-    // TEXTURES
     "texture-formats-depth-webgl1": ["WEBGL_depth_texture", true],
     "texture-formats-float32-webgl1": ["OES_texture_float", true],
     "texture-formats-float16-webgl1": ["OES_texture_half_float", true],
     "texture-filter-linear-float32-webgl": ["OES_texture_float_linear", "OES_texture_float_linear"],
     "texture-filter-linear-float16-webgl": ["OES_texture_half_float_linear", "OES_texture_half_float_linear"],
     "texture-filter-anisotropic-webgl": ["EXT_texture_filter_anisotropic", "EXT_texture_filter_anisotropic"],
-    // FRAMEBUFFERS, TEXTURES AND RENDERBUFFERS
     "texture-renderable-rgba32float-webgl": ["WEBGL_color_buffer_float", "EXT_color_buffer_float"],
-    // Note override check
     "texture-renderable-float32-webgl": [false, "EXT_color_buffer_float"],
     "texture-renderable-float16-webgl": ["EXT_color_buffer_half_float", "EXT_color_buffer_half_float"],
-    // GLSL extensions
     "glsl-frag-data": ["WEBGL_draw_buffers", true],
     "glsl-frag-depth": ["EXT_frag_depth", true],
     "glsl-derivatives": ["OES_standard_derivatives", true],
@@ -11026,46 +10783,31 @@ void main(void) {}`;
     const gl2 = getWebGL2Context(gl);
     return {
       maxTextureDimension1D: 0,
-      // WebGL does not support 1D textures
       maxTextureDimension2D: gl.getParameter(GLEnum2.MAX_TEXTURE_SIZE),
       maxTextureDimension3D: gl2 ? gl2.getParameter(GLEnum2.MAX_3D_TEXTURE_SIZE) : 0,
       maxTextureArrayLayers: gl2 ? gl2.getParameter(GLEnum2.MAX_ARRAY_TEXTURE_LAYERS) : 0,
       maxBindGroups: 1,
-      // TBD
       maxDynamicUniformBuffersPerPipelineLayout: 0,
-      // TBD
       maxDynamicStorageBuffersPerPipelineLayout: 0,
-      // TBD
       maxSampledTexturesPerShaderStage: gl.getParameter(GLEnum2.MAX_VERTEX_TEXTURE_IMAGE_UNITS),
-      // TBD
       maxSamplersPerShaderStage: gl.getParameter(GLEnum2.MAX_COMBINED_TEXTURE_IMAGE_UNITS),
       maxStorageBuffersPerShaderStage: 0,
-      // TBD
       maxStorageTexturesPerShaderStage: 0,
-      // TBD
       maxUniformBuffersPerShaderStage: gl2 ? gl2.getParameter(GLEnum2.MAX_UNIFORM_BUFFER_BINDINGS) : 0,
       maxUniformBufferBindingSize: gl2 ? gl2.getParameter(GLEnum2.MAX_UNIFORM_BLOCK_SIZE) : 0,
       maxStorageBufferBindingSize: 0,
       minUniformBufferOffsetAlignment: gl2 ? gl2.getParameter(GLEnum2.UNIFORM_BUFFER_OFFSET_ALIGNMENT) : 0,
       minStorageBufferOffsetAlignment: 0,
-      // TBD
       maxVertexBuffers: 0,
       maxVertexAttributes: gl.getParameter(GLEnum2.MAX_VERTEX_ATTRIBS),
       maxVertexBufferArrayStride: 2048,
-      // TBD, this is just the default value from WebGPU
       maxInterStageShaderComponents: gl2 ? gl2.getParameter(GLEnum2.MAX_VARYING_COMPONENTS) : 0,
       maxComputeWorkgroupStorageSize: 0,
-      // WebGL does not support compute shaders
       maxComputeInvocationsPerWorkgroup: 0,
-      // WebGL does not support compute shaders
       maxComputeWorkgroupSizeX: 0,
-      // WebGL does not support compute shaders
       maxComputeWorkgroupSizeY: 0,
-      // WebGL does not support compute shaders
       maxComputeWorkgroupSizeZ: 0,
-      // WebGL does not support compute shaders
       maxComputeWorkgroupsPerDimension: 0
-      // WebGL does not support compute shaders
     };
   }
   function getWebGLLimits(gl) {
@@ -11081,86 +10823,45 @@ void main(void) {}`;
       [GLEnum2.ALIASED_POINT_SIZE_RANGE]: get(GLEnum2.ALIASED_POINT_SIZE_RANGE),
       [GLEnum2.MAX_TEXTURE_SIZE]: get(GLEnum2.MAX_TEXTURE_SIZE),
       [GLEnum2.MAX_CUBE_MAP_TEXTURE_SIZE]: get(GLEnum2.MAX_CUBE_MAP_TEXTURE_SIZE),
-      // GLint
       [GLEnum2.MAX_TEXTURE_IMAGE_UNITS]: get(GLEnum2.MAX_TEXTURE_IMAGE_UNITS),
-      // GLint
       [GLEnum2.MAX_COMBINED_TEXTURE_IMAGE_UNITS]: get(GLEnum2.MAX_COMBINED_TEXTURE_IMAGE_UNITS),
-      // GLint
       [GLEnum2.MAX_VERTEX_TEXTURE_IMAGE_UNITS]: get(GLEnum2.MAX_VERTEX_TEXTURE_IMAGE_UNITS),
-      // GLint
       [GLEnum2.MAX_RENDERBUFFER_SIZE]: get(GLEnum2.MAX_RENDERBUFFER_SIZE),
-      // GLint
       [GLEnum2.MAX_VARYING_VECTORS]: get(GLEnum2.MAX_VARYING_VECTORS),
-      // GLint
       [GLEnum2.MAX_VERTEX_ATTRIBS]: get(GLEnum2.MAX_VERTEX_ATTRIBS),
-      // GLint
       [GLEnum2.MAX_VERTEX_UNIFORM_VECTORS]: get(GLEnum2.MAX_VERTEX_UNIFORM_VECTORS),
-      // GLint
       [GLEnum2.MAX_FRAGMENT_UNIFORM_VECTORS]: get(GLEnum2.MAX_FRAGMENT_UNIFORM_VECTORS),
-      // GLint
       [GLEnum2.MAX_VIEWPORT_DIMS]: get(GLEnum2.MAX_VIEWPORT_DIMS),
-      // Extensions
       [GLEnum2.MAX_TEXTURE_MAX_ANISOTROPY_EXT]: get(GLEnum2.MAX_TEXTURE_MAX_ANISOTROPY_EXT),
-      // getMaxAnistropy(),
-      // WebGL2 Limits
       [GLEnum2.MAX_3D_TEXTURE_SIZE]: get2(GLEnum2.MAX_3D_TEXTURE_SIZE),
-      //  GLint
       [GLEnum2.MAX_ARRAY_TEXTURE_LAYERS]: get2(GLEnum2.MAX_ARRAY_TEXTURE_LAYERS),
-      // GLint
       [GLEnum2.MAX_CLIENT_WAIT_TIMEOUT_WEBGL]: get2(GLEnum2.MAX_CLIENT_WAIT_TIMEOUT_WEBGL),
-      //  GLint64
       [GLEnum2.MAX_COLOR_ATTACHMENTS]: get2(GLEnum2.MAX_COLOR_ATTACHMENTS),
-      //  GLint
       [GLEnum2.MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS]: get2(GLEnum2.MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS),
-      // GLint64
       [GLEnum2.MAX_COMBINED_UNIFORM_BLOCKS]: get2(GLEnum2.MAX_COMBINED_UNIFORM_BLOCKS),
-      //  GLint
       [GLEnum2.MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS]: get2(GLEnum2.MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS),
-      // GLint64
       [GLEnum2.MAX_DRAW_BUFFERS]: get2(GLEnum2.MAX_DRAW_BUFFERS),
-      // GLint
       [GLEnum2.MAX_ELEMENT_INDEX]: get2(GLEnum2.MAX_ELEMENT_INDEX),
-      //  GLint64
       [GLEnum2.MAX_ELEMENTS_INDICES]: get2(GLEnum2.MAX_ELEMENTS_INDICES),
-      // GLint
       [GLEnum2.MAX_ELEMENTS_VERTICES]: get2(GLEnum2.MAX_ELEMENTS_VERTICES),
-      //  GLint
       [GLEnum2.MAX_FRAGMENT_INPUT_COMPONENTS]: get2(GLEnum2.MAX_FRAGMENT_INPUT_COMPONENTS),
-      //  GLint
       [GLEnum2.MAX_FRAGMENT_UNIFORM_BLOCKS]: get2(GLEnum2.MAX_FRAGMENT_UNIFORM_BLOCKS),
-      //  GLint
       [GLEnum2.MAX_FRAGMENT_UNIFORM_COMPONENTS]: get2(GLEnum2.MAX_FRAGMENT_UNIFORM_COMPONENTS),
-      //  GLint
       [GLEnum2.MAX_SAMPLES]: get2(GLEnum2.MAX_SAMPLES),
-      //  GLint
       [GLEnum2.MAX_SERVER_WAIT_TIMEOUT]: get2(GLEnum2.MAX_SERVER_WAIT_TIMEOUT),
-      //  GLint64
       [GLEnum2.MAX_TEXTURE_LOD_BIAS]: get2(GLEnum2.MAX_TEXTURE_LOD_BIAS),
-      // GLfloat
       [GLEnum2.MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS]: get2(GLEnum2.MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS),
-      //  GLint
       [GLEnum2.MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS]: get2(GLEnum2.MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS),
-      //  GLint
       [GLEnum2.MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS]: get2(GLEnum2.MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS),
-      // GLint
       [GLEnum2.MAX_UNIFORM_BLOCK_SIZE]: get2(GLEnum2.MAX_UNIFORM_BLOCK_SIZE),
-      // GLint64
       [GLEnum2.MAX_UNIFORM_BUFFER_BINDINGS]: get2(GLEnum2.MAX_UNIFORM_BUFFER_BINDINGS),
-      //  GLint
       [GLEnum2.MAX_VARYING_COMPONENTS]: get2(GLEnum2.MAX_VARYING_COMPONENTS),
-      // GLint
       [GLEnum2.MAX_VERTEX_OUTPUT_COMPONENTS]: get2(GLEnum2.MAX_VERTEX_OUTPUT_COMPONENTS),
-      // GLint
       [GLEnum2.MAX_VERTEX_UNIFORM_BLOCKS]: get2(GLEnum2.MAX_VERTEX_UNIFORM_BLOCKS),
-      //  GLint
       [GLEnum2.MAX_VERTEX_UNIFORM_COMPONENTS]: get2(GLEnum2.MAX_VERTEX_UNIFORM_COMPONENTS),
-      //  GLint
       [GLEnum2.MIN_PROGRAM_TEXEL_OFFSET]: get2(GLEnum2.MIN_PROGRAM_TEXEL_OFFSET),
-      // GLint
       [GLEnum2.MAX_PROGRAM_TEXEL_OFFSET]: get2(GLEnum2.MAX_PROGRAM_TEXEL_OFFSET),
-      // GLint
       [GLEnum2.UNIFORM_BUFFER_OFFSET_ALIGNMENT]: get2(GLEnum2.UNIFORM_BUFFER_OFFSET_ALIGNMENT)
-      // GLint
     };
   }
 
@@ -11268,6 +10969,17 @@ void main(void) {}`;
       gl.stencilOpSeparate(GLEnum2.FRONT, sfail, dpfail, dppass);
       gl.stencilOpSeparate(GLEnum2.BACK, sfail, dpfail, dppass);
     }
+    if (parameters.blendColorOperation || parameters.blendAlphaOperation) {
+      gl.enable(GLEnum2.BLEND);
+      const colorEquation = convertBlendOperationToEquation("blendColorOperation", parameters.blendColorOperation || "add");
+      const alphaEquation = convertBlendOperationToEquation("blendAlphaOperation", parameters.blendAlphaOperation || "add");
+      gl.blendEquationSeparate(colorEquation, alphaEquation);
+      const colorSrcFactor = convertBlendFactorToFunction("blendColorSrcFactor", parameters.blendColorSrcFactor || "one");
+      const colorDstFactor = convertBlendFactorToFunction("blendColorDstFactor", parameters.blendColorDstFactor || "zero");
+      const alphaSrcFactor = convertBlendFactorToFunction("blendAlphaSrcFactor", parameters.blendAlphaSrcFactor || "one");
+      const alphaDstFactor = convertBlendFactorToFunction("blendAlphaDstFactor", parameters.blendAlphaDstFactor || "zero");
+      gl.blendFuncSeparate(colorSrcFactor, colorDstFactor, alphaSrcFactor, alphaDstFactor);
+    }
   }
   function convertCompareFunction(parameter, value) {
     return map(parameter, value, {
@@ -11293,6 +11005,29 @@ void main(void) {}`;
       "decrement-wrap": GLEnum2.DECR_WRAP
     });
   }
+  function convertBlendOperationToEquation(parameter, value) {
+    return map(parameter, value, {
+      "add": GLEnum2.FUNC_ADD,
+      "subtract": GLEnum2.FUNC_SUBTRACT,
+      "reverse-subtract": GLEnum2.FUNC_REVERSE_SUBTRACT,
+      "min": GLEnum2.MIN,
+      "max": GLEnum2.MAX
+    });
+  }
+  function convertBlendFactorToFunction(parameter, value) {
+    return map(parameter, value, {
+      "one": GLEnum2.ONE,
+      "zero": GLEnum2.ZERO,
+      "src-color": GLEnum2.SRC_COLOR,
+      "one-minus-src-color": GLEnum2.ONE_MINUS_SRC_COLOR,
+      "dst-color": GLEnum2.DST_COLOR,
+      "one-minus-dst-color": GLEnum2.ONE_MINUS_DST_COLOR,
+      "src-alpha": GLEnum2.SRC_ALPHA,
+      "one-minus-src-alpha": GLEnum2.ONE_MINUS_SRC_ALPHA,
+      "dst-alpha": GLEnum2.DST_ALPHA,
+      "one-minus-dst-alpha": GLEnum2.ONE_MINUS_DST_ALPHA
+    });
+  }
   function message(parameter, value) {
     return `Illegal parameter ${value} for ${parameter}`;
   }
@@ -11385,13 +11120,7 @@ void main(void) {}`;
   // ../webgl/src/adapter/resources/webgl-buffer.ts
   var DEBUG_DATA_LENGTH = 10;
   var WEBGLBuffer = class extends Buffer2 {
-    /** Target in OpenGL defines the type of buffer */
-    /** Usage is a hint on how frequently the buffer will be updates */
-    /** Index type is needed when issuing draw calls, so we pre-compute it */
     glIndexType = GLEnum2.UNSIGNED_SHORT;
-    /** Number of bytes allocated on the GPU for this buffer */
-    /** Number of bytes used */
-    /** A partial CPU-side copy of the data in this buffer, for debugging purposes */
     debugData = null;
     constructor(device, props = {}) {
       super(device, props);
@@ -11414,8 +11143,6 @@ void main(void) {}`;
         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) {
       assert2(ArrayBuffer.isView(data));
       const glTarget = this._getWriteTarget();
@@ -11429,7 +11156,6 @@ void main(void) {}`;
       this.trackAllocatedMemory(byteLength);
       return this;
     }
-    // Allocate a GPU buffer of specified size.
     _initWithByteLength(byteLength) {
       assert2(byteLength >= 0);
       let data = byteLength;
@@ -11467,7 +11193,6 @@ void main(void) {}`;
       }
       this.gl.bindBuffer(glTarget, null);
     }
-    /** Read data from the buffer */
     async readAsync(byteOffset = 0, byteLength) {
       this.device.assertWebGL2();
       byteLength = byteLength ?? this.byteLength;
@@ -11478,7 +11203,6 @@ void main(void) {}`;
       this.gl.bindBuffer(GLEnum2.COPY_READ_BUFFER, null);
       return data;
     }
-    // PROTECTED METHODS (INTENDED FOR USE BY OTHER FRAMEWORK CODE ONLY)
     _invalidateDebugData() {
       this.debugData = null;
     }
@@ -11534,7 +11258,6 @@ void main(void) {}`;
     toString() {
       return `Sampler(${this.id},${JSON.stringify(this.props)})`;
     }
-    /** Set sampler parameters on the sampler */
     _setSamplerParameters(parameters) {
       for (const [pname, value] of Object.entries(parameters)) {
         const param = Number(pname);
@@ -11553,7 +11276,6 @@ void main(void) {}`;
 
   // ../webgl/src/adapter/resources/webgl-texture.ts
   var DEFAULT_WEBGL_TEXTURE_PROPS = {
-    // deprecated
     parameters: {},
     pixelStore: {},
     pixels: null,
@@ -11563,28 +11285,12 @@ void main(void) {}`;
     target: void 0
   };
   var _WEBGLTexture = class extends Texture {
-    /** Sampler object (currently unused) */
     sampler = void 0;
-    // data;
     glFormat = void 0;
     type = void 0;
     dataFormat = void 0;
     mipmaps = void 0;
-    /**
-     * @note `target` cannot be modified by bind:
-     * textures are special because when you first bind them to a target,
-     * they get special information. When you first bind a texture as a
-     * GL_TEXTURE_2D, you are saying that this texture is a 2D texture.
-     * And it will always be a 2D texture; this state cannot be changed ever.
-     * A texture that was first bound as a GL_TEXTURE_2D, must always be bound as a GL_TEXTURE_2D;
-     * attempting to bind it as GL_TEXTURE_3D will give rise to a run-time error
-     * */
     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;
     constructor(device, props) {
       super(device, {
@@ -11622,7 +11328,6 @@ void main(void) {}`;
     toString() {
       return `Texture(${this.id},${this.width}x${this.height})`;
     }
-    // eslint-disable-next-line max-statements
     initialize(props = {}) {
       if (this.props.dimension === "cube") {
         return this.initializeCube(props);
@@ -11702,7 +11407,6 @@ void main(void) {}`;
         format: glFormat,
         type,
         dataFormat,
-        // @ts-expect-error 
         parameters: pixelStore,
         compressed
       });
@@ -11715,7 +11419,6 @@ void main(void) {}`;
         this._video = {
           video: data,
           parameters,
-          // @ts-expect-error
           lastTime: data.readyState >= HTMLVideoElement.HAVE_CURRENT_DATA ? data.currentTime : -1
         };
       }
@@ -11749,10 +11452,6 @@ void main(void) {}`;
       this._setSamplerParameters(parameters);
       return this;
     }
-    /**
-     * If size has changed, reinitializes with current format
-     * @note note clears image and mipmaps
-     */
     resize(options) {
       const {
         height,
@@ -11771,7 +11470,6 @@ void main(void) {}`;
       }
       return this;
     }
-    /** Update external texture (video frame) */
     update() {
       if (this._video) {
         const {
@@ -11792,7 +11490,6 @@ void main(void) {}`;
         this._video.lastTime = video.currentTime;
       }
     }
-    // Call to regenerate mipmaps after modifying texture(s)
     generateMipmap(params = {}) {
       if (this.device.isWebGL1 && isNPOT(this.width, this.height)) {
         log.warn(`texture: ${this} is Non-Power-Of-Two, disabling mipmaping`)();
@@ -11806,27 +11503,6 @@ void main(void) {}`;
       this.gl.bindTexture(this.target, null);
       return this;
     }
-    /*
-     * 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);
@@ -11885,20 +11561,7 @@ void main(void) {}`;
             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,
-              // @ts-expect-error
-              offset
-            );
+            gl.texImage2D(target, level, glFormat, width, height, 0, dataFormat, type, data, offset);
             break;
           case "buffer":
             gl2 = this.device.assertWebGL2();
@@ -11931,11 +11594,6 @@ void main(void) {}`;
       this.loaded = true;
       return this;
     }
-    /**
-     * Redefines an area of an existing texture
-     * Note: does not allocate storage
-     * Redefines an area of an existing texture
-     */
     setSubImageData({
       target = this.target,
       pixels = null,
@@ -12002,14 +11660,6 @@ void main(void) {}`;
       });
       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.
-     */
     copyFramebuffer(opts = {}) {
       log.error("Texture.copyFramebuffer({...}) is no logner supported, use copyToTexture(source, target, opts})")();
       return null;
@@ -12039,7 +11689,6 @@ void main(void) {}`;
       gl.bindTexture(this.target, null);
       return textureUnit;
     }
-    // PRIVATE METHODS
     _getDataType({
       data,
       compressed = false
@@ -12079,7 +11728,6 @@ void main(void) {}`;
         dataType: "browser-object"
       };
     }
-    // HELPER METHODS
     _deduceParameters(opts) {
       const {
         format,
@@ -12110,7 +11758,6 @@ void main(void) {}`;
         data
       };
     }
-    // eslint-disable-next-line complexity
     _deduceImageSize(data, width, height) {
       let size;
       if (typeof ImageData !== "undefined" && data instanceof ImageData) {
@@ -12154,8 +11801,6 @@ void main(void) {}`;
       assert2(height === void 0 || size.height === height, "Deduced texture height does not match supplied height");
       return size;
     }
-    // CUBE MAP METHODS
-    /* eslint-disable max-statements, max-len */
     async setCubeMapImageData(options) {
       const {
         gl
@@ -12174,11 +11819,11 @@ void main(void) {}`;
         return Promise.all(Array.isArray(facePixels) ? facePixels : [facePixels]);
       }));
       this.bind();
-      _WEBGLTexture.FACES.forEach((face, index) => {
-        if (resolvedFaces[index].length > 1 && this.props.mipmaps !== false) {
+      _WEBGLTexture.FACES.forEach((face, index2) => {
+        if (resolvedFaces[index2].length > 1 && this.props.mipmaps !== false) {
           log.warn(`${this.id} has mipmap and multiple LODs.`)();
         }
-        resolvedFaces[index].forEach((image, lodLevel) => {
+        resolvedFaces[index2].forEach((image, lodLevel) => {
           if (width && height) {
             gl.texImage2D(face, lodLevel, format, width, height, 0, format, type, image);
           } else {
@@ -12188,7 +11833,6 @@ void main(void) {}`;
       });
       this.unbind();
     }
-    /** @todo update this method to accept LODs */
     setImageDataForFace(options) {
       const {
         face,
@@ -12198,7 +11842,6 @@ void main(void) {}`;
         data,
         format = GLEnum2.RGBA,
         type = GLEnum2.UNSIGNED_BYTE
-        // generateMipmap = false // TODO
       } = options;
       const {
         gl
@@ -12218,14 +11861,12 @@ void main(void) {}`;
       }
       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,
@@ -12238,19 +11879,7 @@ void main(void) {}`;
       const webglTextureFormat = getWebGLTextureParameters(format, this.device.isWebGL2);
       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
-          );
+          this.gl.texImage3D(this.target, level, webglTextureFormat.format, width, height, depth, 0, webglTextureFormat.dataFormat, webglTextureFormat.type, data);
         }
         if (data instanceof WEBGLBuffer) {
           this.gl.bindBuffer(GLEnum2.PIXEL_UNPACK_BUFFER, data.handle);
@@ -12266,11 +11895,6 @@ void main(void) {}`;
       this.loaded = true;
       return this;
     }
-    // RESOURCE METHODS
-    /**
-     * Sets sampler parameters on texture
-     * @note: Applies NPOT workaround if appropriate
-     */
     _setSamplerParameters(parameters) {
       if (this.device.isWebGL1 && isNPOT(this.width, this.height)) {
         parameters = updateSamplerParametersForNPOT(parameters);
@@ -12296,7 +11920,6 @@ void main(void) {}`;
       this.gl.bindTexture(this.target, null);
       return;
     }
-    /** @deprecated For LegacyTexture subclass */
     _getWebGL1NPOTParameterOverride(pname, value) {
       const npot = this.device.isWebGL1 && isNPOT(this.width, this.height);
       if (npot) {
@@ -12317,7 +11940,6 @@ void main(void) {}`;
     }
   };
   var WEBGLTexture = _WEBGLTexture;
-  // TODO - remove?
   __publicField(WEBGLTexture, "FACES", [GLEnum2.TEXTURE_CUBE_MAP_POSITIVE_X, GLEnum2.TEXTURE_CUBE_MAP_NEGATIVE_X, GLEnum2.TEXTURE_CUBE_MAP_POSITIVE_Y, GLEnum2.TEXTURE_CUBE_MAP_NEGATIVE_Y, GLEnum2.TEXTURE_CUBE_MAP_POSITIVE_Z, GLEnum2.TEXTURE_CUBE_MAP_NEGATIVE_Z]);
   function getWebGLTextureTarget(props) {
     switch (props.dimension) {
@@ -12364,7 +11986,6 @@ void main(void) {}`;
   var ERR_RESOURCE_METHOD_UNDEFINED = "Resource subclass must define virtual methods";
   var WebGLResource = class extends Resource {
     _bound = false;
-    // Only meaningful for resources that allocate GPU memory
     byteLength = 0;
     constructor(device, props, defaultProps) {
       super(device, props, defaultProps);
@@ -12422,12 +12043,6 @@ void main(void) {}`;
     unbind() {
       this.bind(null);
     }
-    /**
-     * Query a Resource parameter
-     *
-     * @param name
-     * @return param
-     */
     getParameter(pname, props = {}) {
       pname = getKeyValue(this.gl, pname);
       assert2(pname);
@@ -12445,9 +12060,6 @@ void main(void) {}`;
       }
       return this._getParameter(pname, props);
     }
-    // Many resources support a getParameter call -
-    // getParameters will get all parameters - slow but useful for debugging
-    // eslint-disable-next-line complexity
     getParameters(options = {}) {
       const {
         parameters,
@@ -12470,15 +12082,6 @@ void main(void) {}`;
       }
       return values;
     }
-    /**
-     * Update a Resource setting
-     *
-     * @todo - cache parameter to avoid issuing WebGL calls?
-     *
-     * @param pname - parameter (GL constant, value or key)
-     * @param value {GLint|GLfloat|GLenum} 
-     * @return returns self to enable chaining
-     */
     setParameter(pname, value) {
       pname = getKeyValue(this.gl, pname);
       assert2(pname);
@@ -12497,24 +12100,17 @@ void main(void) {}`;
       this._setParameter(pname, value);
       return this;
     }
-    /*
-     * Batch update resource parameters
-     * Assumes the subclass supports a setParameter call
-     */
     setParameters(parameters) {
       for (const pname in parameters) {
         this.setParameter(pname, parameters[pname]);
       }
       return this;
     }
-    // Install stubs for removed methods
     stubRemovedMethods(className, version, methodNames) {
       return 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);
     }
@@ -12533,33 +12129,6 @@ void main(void) {}`;
     _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;
-    }
-    */
   };
 
   // ../webgl/src/adapter/objects/webgl-renderbuffer.ts
@@ -12582,7 +12151,6 @@ void main(void) {}`;
     get attachment() {
       return;
     }
-    /** WebGL format constant */
     static isTextureFormatSupported(device, format) {
       return isRenderbufferFormatSupported(device.gl, format);
     }
@@ -12604,8 +12172,6 @@ void main(void) {}`;
         this._initialize(this.props);
       }
     }
-    // PRIVATE METHODS
-    /** Creates and initializes a renderbuffer object's data store */
     _initialize(props) {
       const {
         format,
@@ -12624,7 +12190,6 @@ void main(void) {}`;
       this.gl.bindRenderbuffer(GLEnum2.RENDERBUFFER, null);
       this.trackAllocatedMemory(width * height * (samples || 1) * getTextureFormatBytesPerPixel(this.glFormat, this.device.isWebGL2));
     }
-    // RESOURCE IMPLEMENTATION
     _createHandle() {
       return this.gl.createRenderbuffer();
     }
@@ -12642,7 +12207,6 @@ void main(void) {}`;
     handle: void 0,
     userData: void 0,
     format: void 0,
-    // 'depth16unorm'
     width: 1,
     height: 1,
     samples: 0
@@ -12682,15 +12246,12 @@ void main(void) {}`;
         this._checkStatus();
       }
     }
-    /** destroys any auto created resources etc. */
     destroy() {
       super.destroy();
       if (!this.destroyed && this.handle !== null) {
         this.gl.deleteFramebuffer(this.handle);
       }
     }
-    // PRIVATE
-    /** Check the status */
     _checkStatus() {
       const {
         gl
@@ -12702,21 +12263,14 @@ void main(void) {}`;
         throw new Error(`Framebuffer ${_getFrameBufferStatus(status)}`);
       }
     }
-    /** In WebGL we must use renderbuffers for depth/stencil attachments (unless we have extensions) */
     createDepthStencilTexture(format) {
       return new WEBGLRenderbuffer(this.device, {
         id: `${this.id}-depth-stencil`,
-        // TODO misleading if not depth and stencil?
         format,
-        // dataFormat: GL.DEPTH_STENCIL,
-        // type: GL.UNSIGNED_INT_24_8,
         width: this.width,
         height: this.height
       });
     }
-    /** 
-     * Attachment resize is expected to be a noop if size is same 
-     */
     resizeAttachments(width, height) {
       if (this.handle === null) {
         this.width = this.gl.drawingBufferWidth;
@@ -12743,7 +12297,6 @@ void main(void) {}`;
       }
       return this;
     }
-    /** Attach one attachment */
     _attachOne(attachmentPoint, attachment) {
       if (attachment instanceof WEBGLRenderbuffer) {
         this._attachWEBGLRenderbuffer(attachmentPoint, attachment);
@@ -12761,12 +12314,6 @@ void main(void) {}`;
     _attachWEBGLRenderbuffer(attachment, renderbuffer) {
       this.gl.framebufferRenderbuffer(GLEnum2.FRAMEBUFFER, attachment, GLEnum2.RENDERBUFFER, renderbuffer.handle);
     }
-    /**
-     * @param attachment
-     * @param texture
-     * @param layer = 0 - index into WEBGLTextureArray and Texture3D or face for `TextureCubeMap`
-     * @param level  = 0 - mipmapLevel (must be 0 in WebGL1)
-     */
     _attachTexture(attachment, texture, layer, level) {
       const {
         gl,
@@ -12831,7 +12378,6 @@ void main(void) {}`;
       });
       return this._framebuffer;
     }
-    /** Resizes and updates render targets if necessary */
     update() {
       const size = this.getPixelSize();
       const sizeChanged = size[0] !== this.presentationSize[0] || size[1] !== this.presentationSize[1];
@@ -12839,18 +12385,6 @@ void main(void) {}`;
         this.presentationSize = size;
       }
     }
-    /**
-     * Resize the canvas' drawing buffer.
-     *
-     * Can match the canvas CSS size, and optionally also consider devicePixelRatio
-     * Can be called every frame
-     *
-     * Regardless of size, the drawing buffer will always be scaled to the viewport, but
-     * for best visual results, usually set to either:
-     *  canvas CSS width x canvas CSS height
-     *  canvas CSS width * devicePixelRatio x canvas CSS height * devicePixelRatio
-     * See http://webgl2fundamentals.org/webgl/lessons/webgl-resizing-the-canvas.html
-     */
     resize(options) {
       if (this.canvas) {
         const devicePixelRatio = this.getDevicePixelRatio(options?.useDevicePixels);
@@ -13022,19 +12556,19 @@ void main(void) {}`;
   }
 
   // ../webgl/src/adapter/helpers/get-shader-info.ts
-  function getShaderInfo(source, defaultName) {
+  function getShaderInfo2(source, defaultName) {
     return {
-      name: getShaderName(source, defaultName),
+      name: getShaderName2(source, defaultName),
       language: "glsl",
-      version: getShaderVersion(source)
+      version: getShaderVersion2(source)
     };
   }
-  function getShaderName(shader, defaultName = "unnamed") {
+  function getShaderName2(shader, defaultName = "unnamed") {
     const SHADER_NAME_REGEXP = /#define[\s*]SHADER_NAME[\s*]([A-Za-z0-9_-]+)[\s*]/;
     const match = SHADER_NAME_REGEXP.exec(shader);
     return match ? match[1] : defaultName;
   }
-  function getShaderVersion(source) {
+  function getShaderVersion2(source) {
     let version = 100;
     const words = source.match(/[^\s]+/g);
     if (words && words.length >= 2 && words[0] === "#version") {
@@ -13047,7 +12581,6 @@ void main(void) {}`;
   }
 
   // ../webgl/src/adapter/helpers/parse-shader-compiler-log.ts
-  var MESSAGE_TYPES = ["warning", "error", "info"];
   function parseShaderCompilerLog(errLog) {
     const lines = errLog.split(/\r?\n/);
     const messages = [];
@@ -13056,6 +12589,16 @@ void main(void) {}`;
         continue;
       }
       const segments = line.split(":");
+      if (segments.length === 2) {
+        const [messageType2, message2] = segments;
+        messages.push({
+          message: message2.trim(),
+          type: getMessageType(messageType2),
+          lineNum: 0,
+          linePos: 0
+        });
+        continue;
+      }
       const [messageType, linePosition, lineNumber, ...rest] = segments;
       let lineNum = parseInt(lineNumber, 10);
       if (isNaN(lineNum)) {
@@ -13065,18 +12608,20 @@ void main(void) {}`;
       if (isNaN(linePos)) {
         linePos = 0;
       }
-      const lowerCaseType = messageType.toLowerCase();
-      const type = MESSAGE_TYPES.includes(lowerCaseType) ? lowerCaseType : "info";
       messages.push({
         message: rest.join(":").trim(),
-        type,
+        type: getMessageType(messageType),
         lineNum,
         linePos
-        // TODO
       });
     }
     return messages;
   }
+  function getMessageType(messageType) {
+    const MESSAGE_TYPES = ["warning", "error", "info"];
+    const lowerCaseType = messageType.toLowerCase();
+    return MESSAGE_TYPES.includes(lowerCaseType) ? lowerCaseType : "info";
+  }
 
   // ../webgl/src/adapter/resources/webgl-shader.ts
   var WEBGLShader = class extends Shader {
@@ -13109,7 +12654,6 @@ void main(void) {}`;
       const log3 = this.device.gl.getShaderInfoLog(this.handle);
       return log3 ? parseShaderCompilerLog(log3) : [];
     }
-    // PRIVATE METHODS
     _compile(source) {
       const addGLSLVersion = (source2) => source2.startsWith("#version ") ? source2 : `#version 100
 ${source2}`;
@@ -13127,7 +12671,7 @@ ${source2}`;
         const formattedLog = formatCompilerLog(messages, source, {
           showSourceCode: true
         });
-        const shaderName = getShaderInfo(source).name;
+        const shaderName = getShaderInfo2(source).name;
         const shaderDescription = `${this.stage} shader ${shaderName}`;
         log.error(`GLSL compilation errors in ${shaderDescription}
 ${formattedLog}`)();
@@ -13136,7 +12680,7 @@ ${formattedLog}`)();
     }
   };
   function getShaderIdFromProps(props) {
-    return getShaderInfo(props.source).name || props.id || uid(`unnamed ${props.stage}-shader`);
+    return getShaderInfo2(props.source).name || props.id || uid(`unnamed ${props.stage}-shader`);
   }
 
   // ../webgl/src/adapter/resources/webgl-render-pass.ts
@@ -13145,7 +12689,6 @@ ${formattedLog}`)();
   var GL_COLOR_BUFFER_BIT = 16384;
   var GL_COLOR = 6144;
   var WEBGLRenderPass = class extends RenderPass {
-    /** Parameters that should be applied before each draw call */
     constructor(device, props) {
       super(device, props);
       this.device = device;
@@ -13167,13 +12710,6 @@ ${formattedLog}`)();
     }
     insertDebugMarker(markerLabel) {
     }
-    // writeTimestamp(querySet: GPUQuerySet, queryIndex: number): void;
-    // beginOcclusionQuery(queryIndex: number): void;
-    // endOcclusionQuery(): void;
-    // executeBundles(bundles: Iterable<GPURenderBundle>): void;
-    /**
-     * Maps RenderPass parameters to GL parameters
-     */
     setParameters(parameters = {}) {
       const glParameters = {};
       if (this.props.framebuffer) {
@@ -13206,10 +12742,6 @@ ${formattedLog}`)();
       this.glParameters = glParameters;
       setGLParameters(this.device, glParameters);
     }
-    // Internal
-    /**
-     * Optionally clears depth, color and stencil buffers based on parameters
-     */
     clear() {
       const glParameters = {
         ...this.glParameters
@@ -13233,9 +12765,6 @@ ${formattedLog}`)();
         });
       }
     }
-    /** 
-     * WebGL2 - clear a specific color buffer 
-     */
     clearColorBuffer(drawBuffer = 0, value = [0, 0, 0, 0]) {
       withGLParameters(this.device.gl2, {
         framebuffer: this.props.framebuffer
@@ -13254,24 +12783,6 @@ ${formattedLog}`)();
         }
       });
     }
-    // clearDepthStencil() {
-    // const GL_DEPTH = 0x1801;
-    // const GL_STENCIL = 0x1802;
-    // const GL_DEPTH_STENCIL = 0x84f9;
-    //     case GL_DEPTH:
-    //       this.device.gl2.clearBufferfv(GL_DEPTH, 0, [value]);
-    //       break;
-    //     case GL_STENCIL:
-    //       this.device.gl2.clearBufferiv(GL_STENCIL, 0, [value]);
-    //       break;
-    //     case GL_DEPTH_STENCIL:
-    //       const [depth, stencil] = value;
-    //       this.device.gl2.clearBufferfi(GL_DEPTH_STENCIL, 0, depth, stencil);
-    //       break;
-    //     default:
-    //       assert(false, ERR_ARGUMENTS);
-    //   }
-    // });
   };
 
   // ../webgl/src/classic/typed-array-utils.ts
@@ -13328,10 +12839,6 @@ ${formattedLog}`)();
       const ArrayType = getTypedArrayFromGLType(accessor.type || GLEnum2.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]);
     }
@@ -13342,16 +12849,12 @@ ${formattedLog}`)();
     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 = {}) {
       props = checkProps("Accessor", props, PROP_CHECKS);
       if (props.type !== void 0) {
@@ -13441,25 +12944,15 @@ ${formattedLog}`)();
     [GLEnum2.BOOL_VEC2]: [GLEnum2.FLOAT, 2, "bvec2", "vec2<f32>", "float32x2"],
     [GLEnum2.BOOL_VEC3]: [GLEnum2.FLOAT, 3, "bvec3", "vec3<f32>", "float32x3"],
     [GLEnum2.BOOL_VEC4]: [GLEnum2.FLOAT, 4, "bvec4", "vec4<f32>", "float32x4"],
-    // TODO - are sizes/components below correct?
     [GLEnum2.FLOAT_MAT2]: [GLEnum2.FLOAT, 8, "mat2", "mat2x2<f32>"],
-    // 4
     [GLEnum2.FLOAT_MAT2x3]: [GLEnum2.FLOAT, 8, "mat2x3", "mat2x3<f32>"],
-    // 6
     [GLEnum2.FLOAT_MAT2x4]: [GLEnum2.FLOAT, 8, "mat2x4", "mat2x4<f32>"],
-    // 8
     [GLEnum2.FLOAT_MAT3x2]: [GLEnum2.FLOAT, 12, "mat3x2", "mat3x2<f32>"],
-    // 6
     [GLEnum2.FLOAT_MAT3]: [GLEnum2.FLOAT, 12, "mat3", "mat3x3<f32>"],
-    // 9
     [GLEnum2.FLOAT_MAT3x4]: [GLEnum2.FLOAT, 12, "mat3x4", "mat3x4<f32>"],
-    // 12
     [GLEnum2.FLOAT_MAT4x2]: [GLEnum2.FLOAT, 16, "mat4x2", "mat4x2<f32>"],
-    // 8
     [GLEnum2.FLOAT_MAT4x3]: [GLEnum2.FLOAT, 16, "mat4x3", "mat4x3<f32>"],
-    // 12
     [GLEnum2.FLOAT_MAT4]: [GLEnum2.FLOAT, 16, "mat4", "mat4x4<f32>"]
-    // 16
   };
   function decodeGLUniformType(glUniformType) {
     const typeAndSize = COMPOSITE_GL_TYPES[glUniformType];
@@ -13543,15 +13036,14 @@ ${formattedLog}`)();
   function readAttributeDeclarations(gl, program) {
     const attributes = [];
     const count = gl.getProgramParameter(program, gl.ACTIVE_ATTRIBUTES);
-    for (let index = 0; index < count; index++) {
-      const activeInfo = gl.getActiveAttrib(program, index);
+    for (let index2 = 0; index2 < count; index2++) {
+      const activeInfo = gl.getActiveAttrib(program, index2);
       if (!activeInfo) {
         throw new Error("activeInfo");
       }
       const {
         name: name2,
         type: compositeType
-        /* , size*/
       } = activeInfo;
       const location = gl.getAttribLocation(program, name2);
       if (location >= 0) {
@@ -13564,7 +13056,6 @@ ${formattedLog}`)();
           location,
           stepMode,
           type: attributeType
-          // size - for arrays, size is the number of elements in the array
         });
       }
     }
@@ -13625,7 +13116,6 @@ ${formattedLog}`)();
       } = parseUniformName(rawName);
       let webglLocation = gl.getUniformLocation(program, name2);
       const uniformInfo = {
-        // WebGL locations are uniquely typed but just numbers
         location: webglLocation,
         name: name2,
         size,
@@ -13683,8 +13173,6 @@ ${formattedLog}`)();
           arrayLength: uniformArrayLength[i],
           byteOffset: uniformOffset[i],
           byteStride: uniformStride[i]
-          // matrixStride: uniformStride[i],
-          // rowMajor: uniformRowMajor[i]
         });
       }
       uniformBlocks.push(blockInfo);
@@ -13870,20 +13358,11 @@ ${formattedLog}`)();
   // ../webgl/src/adapter/resources/webgl-render-pipeline.ts
   var LOG_PROGRAM_PERF_PRIORITY = 4;
   var WEBGLRenderPipeline = class extends RenderPipeline {
-    /** The WebGL device that created this render pipeline */
-    /** Handle to underlying WebGL program */
-    /** vertex shader */
-    /** fragment shader */
-    /** The layout extracted from shader by WebGL introspection APIs */
-    /** Uniforms set on this model */
     uniforms = {};
-    /** Bindings set on this model */
     bindings = {};
-    /** WebGL varyings */
     varyings = null;
     _uniformCount = 0;
     _uniformSetters = {};
-    // TODO are these used?
     constructor(device, props) {
       super(device, props);
       this.device = device;
@@ -13912,41 +13391,6 @@ ${formattedLog}`)();
         this.destroyed = true;
       }
     }
-    // setIndexBuffer(indexBuffer: Buffer): void {
-    //   const webglBuffer = cast<WEBGLBuffer>(indexBuffer);
-    //   this.vertexArrayObject.setElementBuffer(webglBuffer);
-    //   this._indexBuffer = indexBuffer;
-    // }
-    // /** @todo needed for portable model */
-    // setAttributes(attributes: Record<string, Buffer>): void {
-    //   for (const [name, buffer] of Object.entries(attributes)) {
-    //     const webglBuffer = cast<WEBGLBuffer>(buffer);
-    //     const attribute = getAttributeLayout(this.layout, name);
-    //     if (!attribute) {
-    //       log.warn(
-    //         `Ignoring buffer supplied for unknown attribute "${name}" in pipeline "${this.id}" (buffer "${buffer.id}")`
-    //       )();
-    //       continue;
-    //     }
-    //     const decoded = decodeVertexFormat(attribute.format);
-    //     const {type: typeString, components: size, byteLength: stride, normalized, integer} = decoded;
-    //     const divisor = attribute.stepMode === 'instance' ? 1 : 0;
-    //     const type = getWebGLDataType(typeString);
-    //     this.vertexArrayObject.setBuffer(attribute.location, webglBuffer, {
-    //       size,
-    //       type,
-    //       stride,
-    //       offset: 0,
-    //       normalized,
-    //       integer,
-    //       divisor
-    //     });
-    //   }
-    // }
-    /**
-     * Bindings include: textures, samplers and uniform buffers
-     * @todo needed for portable model
-     */
     setBindings(bindings) {
       for (const [name2, value] of Object.entries(bindings)) {
         const binding = this.shaderLayout.bindings.find((binding2) => binding2.name === name2) || this.shaderLayout.bindings.find((binding2) => binding2.name === `${name2}Uniforms`);
@@ -13983,25 +13427,17 @@ ${formattedLog}`)();
         bindings
       } = splitUniformsAndBindings(uniforms);
       Object.keys(bindings).forEach((name2) => {
-        log.warn(`Unsupported value "${bindings[name2]}" used in setUniforms() for key ${name2}. Use setBindings() instead?`)();
+        log.warn(`Unsupported value "${JSON.stringify(bindings[name2])}" used in setUniforms() for key ${name2}. Use setBindings() instead?`)();
       });
       Object.assign(this.uniforms, uniforms);
     }
-    /** @todo needed for portable model
-     * @note The WebGL API is offers many ways to draw things
-     * This function unifies those ways into a single call using common parameters with sane defaults
-     */
     draw(options) {
       const {
         renderPass,
         vertexArray,
         vertexCount,
-        // indexCount,
         instanceCount,
         firstVertex = 0,
-        // firstIndex,
-        // firstInstance,
-        // baseVertex,
         transformFeedback
       } = options;
       const glDrawMode = getGLDrawMode(this.props.topology);
@@ -14021,14 +13457,7 @@ ${formattedLog}`)();
       const webglRenderPass = renderPass;
       withDeviceAndGLParameters(this.device, this.props.parameters, webglRenderPass.glParameters, () => {
         if (isIndexed && isInstanced) {
-          this.device.gl2?.drawElementsInstanced(
-            glDrawMode,
-            vertexCount || 0,
-            // indexCount?
-            glIndexType,
-            firstVertex,
-            instanceCount || 0
-          );
+          this.device.gl2?.drawElementsInstanced(glDrawMode, vertexCount || 0, glIndexType, firstVertex, instanceCount || 0);
         } else if (isIndexed) {
           this.device.gl.drawElements(glDrawMode, vertexCount || 0, glIndexType, firstVertex);
         } else if (isInstanced) {
@@ -14043,8 +13472,6 @@ ${formattedLog}`)();
       vertexArray.unbindAfterRender(renderPass);
       return true;
     }
-    // setAttributes(attributes: Record<string, Buffer>): void {}
-    // setBindings(bindings: Record<string, Binding>): void {}
     _compileAndLink() {
       const {
         gl
@@ -14066,12 +13493,6 @@ ${formattedLog}`)();
         throw new Error(`Error validating: ${gl.getProgramInfoLog(this.handle)}`);
       }
     }
-    // PRIVATE METHODS
-    /**
-     * Checks if all texture-values uniforms are renderable (i.e. loaded)
-     * Update a texture if needed (e.g. from video)
-     * Note: This is currently done before every draw call
-     */
     _areTexturesRenderable() {
       let texturesRenderable = true;
       for (const [, texture] of Object.entries(this.bindings)) {
@@ -14082,28 +13503,6 @@ ${formattedLog}`)();
       }
       return texturesRenderable;
     }
-    /**
-     * Constant attributes need to be reset before every draw call
-     * Any attribute that is disabled in the current vertex array object
-     * is read from the context's global constant value for that attribute location.
-     * @note Constant attributes are only supported in WebGL, not in WebGPU
-     *
-    _applyConstantAttributes(vertexArray: WEBGLVertexArray): void {
-      const attributeInfos = getAttributeInfosFromLayouts(this.shaderLayout, this.bufferLayout);
-      for (const [name, value] of Object.entries(this.)) {
-        const attributeInfo = attributeInfos[name];
-        if (!attributeInfo) {
-          log.warn(
-            `Ignoring constant value supplied for unknown attribute "${name}" in pipeline "${this.id}"`
-          )();
-          continue; // eslint-disable-line no-continue
-        }
-        vertexArray.setConstant(attributeInfo.location, value);
-        vertexArray.enable(attributeInfo.location, false);
-      }
-    }
-    */
-    /** Apply any bindings (before each draw call) */
     _applyBindings() {
       this.device.gl.useProgram(this.handle);
       const {
@@ -14132,16 +13531,7 @@ ${formattedLog}`)();
             if (value instanceof WEBGLBuffer) {
               gl2.bindBufferBase(GLEnum2.UNIFORM_BUFFER, uniformBufferIndex, value.handle);
             } else {
-              gl2.bindBufferRange(
-                GLEnum2.UNIFORM_BUFFER,
-                uniformBufferIndex,
-                // @ts-expect-error
-                value.buffer.handle,
-                // @ts-expect-error
-                value.offset || 0,
-                // @ts-expect-error
-                value.size || value.buffer.byteLength - value.offset
-              );
+              gl2.bindBufferRange(GLEnum2.UNIFORM_BUFFER, uniformBufferIndex, value.buffer.handle, value.offset || 0, value.size || value.buffer.byteLength - value.offset);
             }
             uniformBufferIndex += 1;
             break;
@@ -14170,10 +13560,6 @@ ${formattedLog}`)();
         }
       }
     }
-    /**
-     * Due to program sharing, uniforms need to be reset before every draw call
-     * (though caching will avoid redundant WebGL calls)
-     */
     _applyUniforms() {
       for (const uniformLayout of this.shaderLayout.uniforms || []) {
         const {
@@ -14238,33 +13624,16 @@ ${formattedLog}`)();
   }
   function _copyTextureToBuffer(device, options) {
     const {
-      /** Texture to copy to/from. */
       source,
-      /**  Mip-map level of the texture to copy to/from. (Default 0) */
       mipLevel = 0,
-      /** Defines which aspects of the texture to copy to/from. */
       aspect = "all",
-      /** Width to copy */
       width = options.source.width,
-      /** Height to copy */
       height = options.source.height,
       depthOrArrayLayers = 0,
-      /** Defines the origin of the copy - the minimum corner of the texture sub-region to copy to/from. */
       origin = [0, 0],
-      /** Destination buffer */
       destination,
-      /** Offset, in bytes, from the beginning of the buffer to the start of the image data (default 0) */
       byteOffset = 0,
-      /**
-       * The stride, in bytes, between the beginning of each block row and the subsequent block row.
-       * Required if there are multiple block rows (i.e. the copy height or depth is more than one block).
-       */
       bytesPerRow,
-      /**
-       * Number of block rows per single image of the texture.
-       * rowsPerImage &times; bytesPerRow is the stride, in bytes, between the beginning of each image of data and the subsequent image.
-       * Required if there are multiple images (i.e. the copy depth is more than one).
-       */
       rowsPerImage
     } = options;
     if (aspect !== "all") {
@@ -14298,27 +13667,13 @@ ${formattedLog}`)();
   }
   function _copyTextureToTexture(device, options) {
     const {
-      /** Texture to copy to/from. */
       source,
-      /**  Mip-map level of the texture to copy to/from. (Default 0) */
-      // mipLevel = 0,
-      /** Defines which aspects of the texture to copy to/from. */
-      // aspect = 'all',
-      /** Defines the origin of the copy - the minimum corner of the texture sub-region to copy to/from. */
       origin = [0, 0],
-      /** Texture to copy to/from. */
       destination
-      /**  Mip-map level of the texture to copy to/from. (Default 0) */
-      // destinationMipLevel = options.mipLevel,
-      /** Defines the origin of the copy - the minimum corner of the texture sub-region to copy to/from. */
-      // destinationOrigin = [0, 0],
-      /** Defines which aspects of the texture to copy to/from. */
-      // destinationAspect = options.aspect,
     } = options;
     let {
       width = options.destination.width,
       height = options.destination.width
-      // depthOrArrayLayers = 0
     } = options;
     const destinationMipmaplevel = 0;
     const destinationInternalFormat = GLEnum2.RGBA;
@@ -14341,17 +13696,7 @@ ${formattedLog}`)();
       throw new Error("whoops");
     }
     if (!isSubCopy) {
-      device.gl.copyTexImage2D(
-        textureTarget,
-        destinationMipmaplevel,
-        destinationInternalFormat,
-        sourceX,
-        sourceY,
-        width,
-        height,
-        0
-        /* border must be 0 */
-      );
+      device.gl.copyTexImage2D(textureTarget, destinationMipmaplevel, destinationInternalFormat, sourceX, sourceY, width, height, 0);
     } else {
     }
     if (texture) {
@@ -14398,9 +13743,6 @@ ${formattedLog}`)();
     finish() {
       this.commandBuffer.submitCommands();
     }
-    // beginRenderPass(GPURenderPassDescriptor descriptor): GPURenderPassEncoder;
-    // beginComputePass(optional GPUComputePassDescriptor descriptor = {}): GPUComputePassEncoder;
-    // finish(options?: {id?: string}): GPUCommandBuffer;
     copyBufferToBuffer(options) {
       this.commandBuffer.commands.push({
         name: "copy-buffer-to-buffer",
@@ -14431,14 +13773,6 @@ ${formattedLog}`)();
     }
     insertDebugMarker(markerLabel) {
     }
-    // writeTimestamp(querySet: Query, queryIndex: number): void {}
-    // resolveQuerySet(options: {
-    //   querySet: GPUQuerySet,
-    //   firstQuery: number,
-    //   queryCount: number,
-    //   destination: Buffer,
-    //   destinationOffset?: number;
-    // }): void;
   };
 
   // ../webgl/src/adapter/resources/webgl-vertex-array.ts
@@ -14446,14 +13780,11 @@ ${formattedLog}`)();
     get [Symbol.toStringTag]() {
       return "VertexArray";
     }
-    /** Attribute 0 buffer constant */
     buffer = null;
     bufferValue = null;
-    /** * Attribute 0 can not be disable on most desktop OpenGL based browsers */
     static isConstantAttributeZeroSupported(device) {
       return device.info.type === "webgl2" || getBrowser() === "Chrome";
     }
-    // Create a VertexArray
     constructor(device, props) {
       super(device, props);
       this.device = device;
@@ -14469,22 +13800,15 @@ ${formattedLog}`)();
         this.handle = void 0;
       }
     }
-    /**
-    // Set (bind) an elements buffer, for indexed rendering.
-    // Must be a Buffer bound to GL.ELEMENT_ARRAY_BUFFER. Constants not supported
-     * 
-     * @param elementBuffer 
-     */
     setIndexBuffer(indexBuffer) {
       const buffer = indexBuffer;
-      if (buffer?.glTarget !== GLEnum2.ELEMENT_ARRAY_BUFFER) {
+      if (buffer && buffer.glTarget !== GLEnum2.ELEMENT_ARRAY_BUFFER) {
         throw new Error("Use .setBuffer()");
       }
       this.device.gl2.bindVertexArray(this.handle);
       this.device.gl2.bindBuffer(GLEnum2.ELEMENT_ARRAY_BUFFER, buffer ? buffer.handle : null);
       this.indexBuffer = buffer;
     }
-    /** Set a location in vertex attributes array to a buffer, enables the location, sets divisor */
     setBuffer(location, attributeBuffer) {
       const buffer = attributeBuffer;
       if (buffer.glTarget === GLEnum2.ELEMENT_ARRAY_BUFFER) {
@@ -14511,7 +13835,6 @@ ${formattedLog}`)();
       this.device.gl2.vertexAttribDivisor(location, divisor || 0);
       this.attributes[location] = buffer;
     }
-    /** Set a location in vertex attributes array to a constant value, disables the location */
     setConstant(location, value) {
       this._enable(location, false);
       this.attributes[location] = value;
@@ -14529,13 +13852,6 @@ ${formattedLog}`)();
     unbindAfterRender() {
       this.device.gl2.bindVertexArray(null);
     }
-    // Internal methods
-    /**
-     * Constant attributes need to be reset before every draw call
-     * Any attribute that is disabled in the current vertex array object
-     * is read from the context's global constant value for that attribute location.
-     * @note Constant attributes are only supported in WebGL, not in WebGPU
-     */
     _applyConstantAttributes() {
       for (let location = 0; location < this.maxVertexAttributes; ++location) {
         const constant = this.attributes[location];
@@ -14544,23 +13860,6 @@ ${formattedLog}`)();
         }
       }
     }
-    /**
-     * Set a location in vertex attributes array to a buffer, enables the location, sets divisor
-     * @note requires vertex array to be bound
-     */
-    // protected _setAttributeLayout(location: number): void {
-    //   const {size, type, stride, offset, normalized, integer, divisor} = this._getAccessor(location);
-    //   // WebGL2 supports *integer* data formats, i.e. GPU will see integer values
-    //   if (integer) {
-    //     this.device.assertWebGL2();
-    //     this.device.gl2.vertexAttribIPointer(location, size, type, stride, offset);
-    //   } else {
-    //     // Attaches ARRAY_BUFFER with specified buffer format to location
-    //     this.device.gl.vertexAttribPointer(location, size, type, normalized, stride, offset);
-    //   }
-    //   this.device.gl2.vertexAttribDivisor(location, divisor || 0);
-    // }
-    /** Get an accessor from the  */
     _getAccessor(location) {
       const attributeInfo = this.attributeInfos[location];
       if (!attributeInfo) {
@@ -14573,21 +13872,10 @@ ${formattedLog}`)();
         stride: attributeInfo.byteStride,
         offset: attributeInfo.byteOffset,
         normalized: attributeInfo.normalized,
-        // it is the shader attribute declaration, not the vertex memory format,
-        // that determines if the data in the buffer will be treated as integers.
-        //
-        // Also note that WebGL supports assigning non-normalized integer data to floating point attributes,
-        // but as far as we can tell, WebGPU does not.
         integer: attributeInfo.integer,
         divisor: attributeInfo.stepMode === "instance" ? 1 : 0
       };
     }
-    /**
-     * Enabling an attribute location makes it reference the currently bound buffer
-     * Disabling an attribute location makes it reference the global constant value
-     * TODO - handle single values for size 1 attributes?
-     * TODO - convert classic arrays based on known type?
-     */
     _enable(location, enable2 = true) {
       const canDisableAttributeZero = WEBGLVertexArray.isConstantAttributeZeroSupported(this.device);
       const canDisableAttribute = canDisableAttributeZero || location !== 0;
@@ -14602,12 +13890,6 @@ ${formattedLog}`)();
         this.device.gl2.bindVertexArray(null);
       }
     }
-    /**
-     * Provide a means to create a buffer that is equivalent to a constant.
-     * NOTE: Desktop OpenGL cannot disable attribute 0.
-     * https://stackoverflow.com/questions/20305231/webgl-warning-attribute-0-is-disabled-
-     * this-has-significant-performance-penalty
-     */
     getConstantBuffer(elementCount, value) {
       const constantValue = normalizeConstantArrayValue(value);
       const byteLength = constantValue.byteLength * elementCount;
@@ -14654,18 +13936,8 @@ ${formattedLog}`)();
 
   // ../webgl/src/adapter/resources/webgl-transform-feedback.ts
   var WEBGLTransformFeedback = class extends TransformFeedback {
-    /**
-     * NOTE: The Model already has this information while drawing, but
-     * TransformFeedback currently needs it internally, to look up
-     * varying information outside of a draw() call.
-     */
     buffers = {};
     unusedBuffers = {};
-    /**
-     * Allows us to avoid a Chrome bug where a buffer that is already bound to a
-     * different target cannot be bound to 'TRANSFORM_FEEDBACK_BUFFER' target.
-     * This a major workaround, see: https://github.com/KhronosGroup/WebGL/issues/2346
-     */
     bindOnUse = true;
     _bound = false;
     constructor(device, props) {
@@ -14698,7 +13970,6 @@ ${formattedLog}`)();
       }
       this.gl2.bindTransformFeedback(GLEnum2.TRANSFORM_FEEDBACK, null);
     }
-    // SUBCLASS
     setBuffers(buffers) {
       this.buffers = {};
       this.unusedBuffers = {};
@@ -14756,8 +14027,6 @@ ${formattedLog}`)();
     unbind() {
       this.bind(null);
     }
-    // PRIVATE METHODS
-    /** Extract offsets for bindBufferRange */
     _getBufferRange(bufferOrRange) {
       if (bufferOrRange instanceof WEBGLBuffer) {
         return {
@@ -14788,10 +14057,6 @@ ${formattedLog}`)();
       }
       return -1;
     }
-    /**
-     * Need to avoid chrome bug where buffer that is already bound to a different target
-     * cannot be bound to 'TRANSFORM_FEEDBACK_BUFFER' target.
-     */
     _bindBuffers() {
       for (const bufferIndex in this.buffers) {
         const {
@@ -14807,12 +14072,12 @@ ${formattedLog}`)();
         this.gl2.bindBufferBase(GLEnum2.TRANSFORM_FEEDBACK_BUFFER, Number(bufferIndex), null);
       }
     }
-    _bindBuffer(index, buffer, byteOffset = 0, byteLength) {
+    _bindBuffer(index2, buffer, byteOffset = 0, byteLength) {
       const handle = buffer && buffer.handle;
       if (!handle || byteLength === void 0) {
-        this.gl2.bindBufferBase(GLEnum2.TRANSFORM_FEEDBACK_BUFFER, index, handle);
+        this.gl2.bindBufferBase(GLEnum2.TRANSFORM_FEEDBACK_BUFFER, index2, handle);
       } else {
-        this.gl2.bindBufferRange(GLEnum2.TRANSFORM_FEEDBACK_BUFFER, index, handle, byteOffset, byteLength);
+        this.gl2.bindBufferRange(GLEnum2.TRANSFORM_FEEDBACK_BUFFER, index2, handle, byteOffset, byteLength);
       }
     }
   };
@@ -14837,15 +14102,6 @@ ${formattedLog}`)();
       this._limits = this._limits || getDeviceLimits(this.gl);
       return this._limits;
     }
-    //
-    // Static methods, expected to be present by `luma.createDevice()`
-    //
-    /**
-     * Get a device instance from a GL context
-     * Creates and instruments the device if not already created
-     * @param gl
-     * @returns
-     */
     static attach(gl) {
       if (gl instanceof _WebGLDevice) {
         return gl;
@@ -14880,9 +14136,6 @@ ${formattedLog}`)();
       }
       return new _WebGLDevice(props);
     }
-    //
-    // Public API
-    //
     constructor(props) {
       super({
         ...props,
@@ -14952,10 +14205,6 @@ ${formattedLog}`)();
       log.probe(LOG_LEVEL2, message2)();
       log.groupEnd(LOG_LEVEL2)();
     }
-    /**
-     * Destroys the context
-     * @note Has no effect for browser contexts, there is no browser API for destroying contexts
-     */
     destroy() {
       const ext = this.gl.getExtension("STACKGL_destroy_context");
       if (ext) {
@@ -14977,15 +14226,12 @@ ${formattedLog}`)();
     isTextureFormatRenderable(format) {
       return isTextureFormatRenderable(this.gl, format);
     }
-    // WEBGL SPECIFIC METHODS
-    /** Returns a WebGL2RenderingContext or throws an error */
     assertWebGL2() {
       if (!this.gl2) {
         throw new Error("Requires WebGL2");
       }
       return this.gl2;
     }
-    // IMPLEMENTATION OF ABSTRACT DEVICE
     createCanvasContext(props) {
       throw new Error("WebGL only supports a single canvas");
     }
@@ -15036,43 +14282,23 @@ ${formattedLog}`)();
     createCommandEncoder(props) {
       return new WEBGLCommandEncoder(this, props);
     }
-    /**
-     * Offscreen Canvas Support: Commit the frame
-     * https://developer.mozilla.org/en-US/docs/Web/API/WebGLRenderingContext/commit
-     * Chrome's offscreen canvas does not require gl.commit
-     */
     submit() {
       this.renderPass?.end();
       this.renderPass = null;
     }
-    //
-    // WebGL-only API (not part of `Device` API)
-    //
-    /** WebGL1 typed context. Can always be used. */
-    /** WebGL2 typed context. Need to check isWebGL2 or isWebGL1 before using. */
     gl2 = null;
     debug = false;
-    /** `true` if this is a WebGL1 context. @note `false` if WebGL2 */
-    /** `true` if this is a WebGL2 context. @note `false` if WebGL1 */
-    /** State used by luma.gl classes: TODO - move to canvasContext*/
     _canvasSizeInfo = {
       clientWidth: 0,
       clientHeight: 0,
       devicePixelRatio: 1
     };
-    /** State used by luma.gl classes - TODO - not used? */
     _extensions = {};
     _polyfilled = false;
-    /** Instance of Spector.js (if initialized) */
-    /** Return WebGL specific limits */
     get webglLimits() {
       this._webglLimits = this._webglLimits || getWebGLLimits(this.gl);
       return this._webglLimits;
     }
-    /**
-     * Triggers device (or WebGL context) loss.
-     * @note primarily intended for testing how application reacts to device loss
-     */
     loseDevice() {
       let deviceLossTriggered = false;
       const ext = this.gl.getExtension("WEBGL_lose_context");
@@ -15086,26 +14312,15 @@ ${formattedLog}`)();
       });
       return deviceLossTriggered;
     }
-    /** Save current WebGL context state onto an internal stack */
     pushState() {
       pushContextState(this.gl);
     }
-    /** Restores previously saved context state */
     popState() {
       popContextState(this.gl);
     }
-    /**
-     * Storing data on a special field on WebGLObjects makes that data visible in SPECTOR chrome debug extension
-     * luma.gl ids and props can be inspected
-     */
     setSpectorMetadata(handle, props) {
       handle.__SPECTOR_Metadata = props;
     }
-    /**
-     * Returns the GL.<KEY> constant that corresponds to a numeric value of a GL constant
-     * Be aware that there are some duplicates especially for constants that are 0,
-     * so this isn't guaranteed to return the right key in all cases.
-     */
     getGLKey(value, gl) {
       gl = gl || this.gl2 || this.gl;
       const number = Number(value);
@@ -15116,13 +14331,6 @@ ${formattedLog}`)();
       }
       return String(value);
     }
-    /** Store constants */
-    /**
-     * Set a constant value for a location. Disabled attributes at that location will read from this value
-     * @note WebGL constants are stored globally on the WebGL context, not the VertexArray
-     * so they need to be updated before every render
-     * @todo - remember/cache values to avoid setting them unnecessarily?
-     */
     setConstantAttribute(location, constant) {
       this._constants = this._constants || new Array(this.limits.maxVertexAttributes).fill(null);
       const currentConstant = this._constants[location];
@@ -15146,9 +14354,6 @@ ${formattedLog}`)();
     }
   };
   var WebGLDevice = _WebGLDevice;
-  //
-  // Public `Device` API
-  //
   __publicField(WebGLDevice, "type", "webgl");
   function isWebGL3(gl) {
     if (typeof WebGLRenderingContext !== "undefined" && gl instanceof WebGLRenderingContext) {
@@ -15247,8 +14452,8 @@ ${formattedLog}`)();
   };
   var GLTFAnimator = class {
     constructor(gltf) {
-      this.animations = gltf.animations.map((animation, index) => {
-        const name2 = animation.name || `Animation-${index}`;
+      this.animations = gltf.animations.map((animation, index2) => {
+        const name2 = animation.name || `Animation-${index2}`;
         const samplers = animation.samplers.map(({
           input,
           interpolation = "LINEAR",
@@ -15272,7 +14477,6 @@ ${formattedLog}`)();
         });
       });
     }
-    /** @deprecated Use .setTime(). Will be removed (deck.gl is using this) */
     animate(time) {
       this.setTime(time);
     }
@@ -15541,7 +14745,6 @@ ${source}` : source;
     useTangents: false
   };
   var GLTFInstantiator = class {
-    // TODO - replace with Device
     constructor(device, options = {}) {
       this.device = WebGLDevice.attach(device);
       this.options = {
@@ -15663,22 +14866,19 @@ ${source}` : source;
       if (!bufferView.lumaBuffers[usage]) {
         bufferView.lumaBuffers[usage] = this.device.createBuffer({
           id: `from-${bufferView.id}`,
-          // Draco decoded files have attribute.value
           data: bufferView.data || attribute.value
         });
       }
       return bufferView.lumaBuffers[usage];
     }
-    // TODO - create sampler in WebGL2
     createSampler(gltfSampler) {
       return gltfSampler;
     }
-    // Helper methods (move to GLTFLoader.resolve...?)
     needsPOT() {
       return false;
     }
   };
-  var GLEnum3 = /* @__PURE__ */ function(GLEnum4) {
+  var GLEnum3 = function(GLEnum4) {
     GLEnum4[GLEnum4["POINTS"] = 0] = "POINTS";
     GLEnum4[GLEnum4["LINES"] = 1] = "LINES";
     GLEnum4[GLEnum4["LINE_LOOP"] = 2] = "LINE_LOOP";