@luma.gl/webgpu 9.0.0-beta.5 → 9.0.0-beta.6

package/dist/index.cjs

@@ -33,7 +33,7 @@ __export(dist_exports, {
 module.exports = __toCommonJS(dist_exports);
 
 // dist/adapter/webgpu-device.js
-var import_core15 = require("@luma.gl/core");
+var import_core17 = require("@luma.gl/core");
 
 // dist/adapter/resources/webgpu-buffer.js
 var import_core = require("@luma.gl/core");
@@ -73,7 +73,10 @@ var WebGPUBuffer = class extends import_core.Buffer {
     this.device.handle.queue.writeBuffer(this.handle, byteOffset, data.buffer, data.byteOffset, data.byteLength);
   }
   async readAsync(byteOffset = 0, byteLength = this.byteLength) {
-    const tempBuffer = new WebGPUBuffer(this.device, { usage: import_core.Buffer.MAP_READ | import_core.Buffer.COPY_DST, byteLength });
+    const tempBuffer = new WebGPUBuffer(this.device, {
+      usage: import_core.Buffer.MAP_READ | import_core.Buffer.COPY_DST,
+      byteLength
+    });
     const commandEncoder = this.device.handle.createCommandEncoder();
     commandEncoder.copyBufferToBuffer(this.handle, byteOffset, tempBuffer.handle, 0, byteLength);
     this.device.handle.queue.submit([commandEncoder.finish()]);
@@ -100,7 +103,7 @@ var WebGPUBuffer = class extends import_core.Buffer {
 };
 
 // dist/adapter/resources/webgpu-texture.js
-var import_core3 = require("@luma.gl/core");
+var import_core4 = require("@luma.gl/core");
 
 // dist/adapter/helpers/convert-texture-format.js
 function getWebGPUTextureFormat(format) {
@@ -129,22 +132,50 @@ var WebGPUSampler = class extends import_core2.Sampler {
   }
 };
 
+// dist/adapter/resources/webgpu-texture-view.js
+var import_core3 = require("@luma.gl/core");
+var WebGPUTextureView = class extends import_core3.TextureView {
+  device;
+  handle;
+  texture;
+  constructor(device, props) {
+    super(device, props);
+    this.device = device;
+    this.texture = props.texture;
+    this.handle = this.handle || this.texture.handle.createView({
+      format: props.format || this.texture.format,
+      dimension: props.dimension || this.texture.dimension,
+      aspect: props.aspect,
+      baseMipLevel: props.baseMipLevel,
+      mipLevelCount: props.mipLevelCount,
+      // GPUIntegerCoordinate;
+      baseArrayLayer: props.baseArrayLayer,
+      // GPUIntegerCoordinate;
+      arrayLayerCount: props.arrayLayerCount
+      // GPUIntegerCoordinate;
+    });
+    this.handle.label = this.props.id;
+  }
+  destroy() {
+  }
+};
+
 // dist/adapter/resources/webgpu-texture.js
 var BASE_DIMENSIONS = {
   "1d": "1d",
   "2d": "2d",
   "2d-array": "2d",
-  "cube": "2d",
+  cube: "2d",
   "cube-array": "2d",
   "3d": "3d"
 };
-var WebGPUTexture = class extends import_core3.Texture {
+var WebGPUTexture = class extends import_core4.Texture {
   device;
   handle;
-  view;
-  sampler;
   height = 1;
   width = 1;
+  sampler;
+  view;
   // static async createFromImageURL(src, usage = 0) {
   //   const img = document.createElement('img');
   //   img.src = src;
@@ -172,7 +203,7 @@ var WebGPUTexture = class extends import_core3.Texture {
     this.width = this.handle.width;
     this.height = this.handle.height;
     this.sampler = props.sampler instanceof WebGPUSampler ? props.sampler : new WebGPUSampler(this.device, props.sampler);
-    this.view = this.createView();
+    this.view = new WebGPUTextureView(this.device, { ...this.props, texture: this });
   }
   createHandle() {
     var _a, _b;
@@ -225,15 +256,11 @@ var WebGPUTexture = class extends import_core3.Texture {
         premultipliedAlpha
       },
       // copySize: GPUExtent3D
-      [
-        width,
-        height,
-        depth
-      ]
+      [width, height, depth]
     );
     return { width, height };
   }
-  // WebGPU specific 
+  // WebGPU specific
   /** TODO - intention is to expose TextureViews in the public API */
   createView() {
     return this.handle.createView({ label: this.id });
@@ -241,8 +268,8 @@ var WebGPUTexture = class extends import_core3.Texture {
 };
 
 // dist/adapter/resources/webgpu-external-texture.js
-var import_core4 = require("@luma.gl/core");
-var WebGPUExternalTexture = class extends import_core4.ExternalTexture {
+var import_core5 = require("@luma.gl/core");
+var WebGPUExternalTexture = class extends import_core5.ExternalTexture {
   device;
   handle;
   sampler;
@@ -265,8 +292,8 @@ var WebGPUExternalTexture = class extends import_core4.ExternalTexture {
 };
 
 // dist/adapter/resources/webgpu-shader.js
-var import_core5 = require("@luma.gl/core");
-var WebGPUShader = class extends import_core5.Shader {
+var import_core6 = require("@luma.gl/core");
+var WebGPUShader = class extends import_core6.Shader {
   device;
   handle;
   constructor(device, props) {
@@ -282,7 +309,7 @@ var WebGPUShader = class extends import_core5.Shader {
     if (error) {
       this.debugShader();
       const shaderLog = await this.getCompilationInfo();
-      import_core5.log.error(`Shader compilation error: ${error.message}`, shaderLog)();
+      import_core6.log.error(`Shader compilation error: ${error.message}`, shaderLog)();
       throw new Error(`Shader compilation error: ${error.message}`);
     }
   }
@@ -316,7 +343,7 @@ var WebGPUShader = class extends import_core5.Shader {
 };
 
 // dist/adapter/resources/webgpu-render-pipeline.js
-var import_core8 = require("@luma.gl/core");
+var import_core9 = require("@luma.gl/core");
 
 // dist/adapter/helpers/webgpu-parameters.js
 function addDepthStencil(descriptor) {
@@ -504,7 +531,7 @@ function addColorState(descriptor) {
 }
 
 // dist/adapter/helpers/get-bind-group.js
-var import_core6 = require("@luma.gl/core");
+var import_core7 = require("@luma.gl/core");
 function getBindGroup(device, bindGroupLayout, shaderLayout, bindings) {
   const entries = getBindGroupEntries(bindings, shaderLayout);
   return device.createBindGroup({
@@ -515,7 +542,7 @@ function getBindGroup(device, bindGroupLayout, shaderLayout, bindings) {
 function getShaderLayoutBinding(shaderLayout, bindingName) {
   const bindingLayout = shaderLayout.bindings.find((binding) => binding.name === bindingName || `${binding.name}uniforms` === bindingName.toLocaleLowerCase());
   if (!bindingLayout) {
-    import_core6.log.warn(`Binding ${bindingName} not set: Not found in shader layout.`)();
+    import_core7.log.warn(`Binding ${bindingName} not set: Not found in shader layout.`)();
   }
   return bindingLayout;
 }
@@ -530,30 +557,30 @@ function getBindGroupEntries(bindings, shaderLayout) {
   return entries;
 }
 function getBindGroupEntry(binding, index) {
-  if (binding instanceof import_core6.Buffer) {
+  if (binding instanceof import_core7.Buffer) {
     return {
       binding: index,
       resource: {
-        buffer: (0, import_core6.cast)(binding).handle
+        buffer: (0, import_core7.cast)(binding).handle
       }
     };
   }
-  if (binding instanceof import_core6.Sampler) {
+  if (binding instanceof import_core7.Sampler) {
     return {
       binding: index,
-      resource: (0, import_core6.cast)(binding).handle
+      resource: (0, import_core7.cast)(binding).handle
     };
-  } else if (binding instanceof import_core6.Texture) {
+  } else if (binding instanceof import_core7.Texture) {
     return {
       binding: index,
-      resource: (0, import_core6.cast)(binding).handle.createView({ label: "bind-group-auto-created" })
+      resource: (0, import_core7.cast)(binding).handle.createView({ label: "bind-group-auto-created" })
     };
   }
   throw new Error("invalid binding");
 }
 
 // dist/adapter/helpers/get-vertex-buffer-layout.js
-var import_core7 = require("@luma.gl/core");
+var import_core8 = require("@luma.gl/core");
 function getWebGPUVertexFormat(format) {
   if (format.endsWith("-webgl")) {
     throw new Error(`WebGPU does not support vertex format ${format}`);
@@ -577,14 +604,14 @@ function getVertexBufferLayout(shaderLayout, bufferLayout) {
           offset: attributeMapping.byteOffset,
           shaderLocation: attributeLayout.location
         });
-        byteStride += (0, import_core7.decodeVertexFormat)(mapping.format).byteLength;
+        byteStride += (0, import_core8.decodeVertexFormat)(mapping.format).byteLength;
       }
     } else {
       const attributeLayout = findAttributeLayout(shaderLayout, mapping.name, usedAttributes);
       if (!attributeLayout) {
         continue;
       }
-      byteStride = (0, import_core7.decodeVertexFormat)(mapping.format).byteLength;
+      byteStride = (0, import_core8.decodeVertexFormat)(mapping.format).byteLength;
       stepMode = attributeLayout.stepMode || (attributeLayout.name.startsWith("instance") ? "instance" : "vertex");
       vertexAttributes.push({
         format: getWebGPUVertexFormat(mapping.format),
@@ -602,7 +629,7 @@ function getVertexBufferLayout(shaderLayout, bufferLayout) {
   for (const attribute of shaderLayout.attributes) {
     if (!usedAttributes.has(attribute.name)) {
       vertexBufferLayouts.push({
-        arrayStride: (0, import_core7.decodeVertexFormat)("float32x3").byteLength,
+        arrayStride: (0, import_core8.decodeVertexFormat)("float32x3").byteLength,
         stepMode: attribute.stepMode || (attribute.name.startsWith("instance") ? "instance" : "vertex"),
         attributes: [
           {
@@ -619,7 +646,7 @@ function getVertexBufferLayout(shaderLayout, bufferLayout) {
 function findAttributeLayout(shaderLayout, name, attributeNames) {
   const attribute = shaderLayout.attributes.find((attribute2) => attribute2.name === name);
   if (!attribute) {
-    import_core7.log.warn(`Unknown attribute ${name}`)();
+    import_core8.log.warn(`Unknown attribute ${name}`)();
     return null;
   }
   if (attributeNames.has(name)) {
@@ -630,7 +657,7 @@ function findAttributeLayout(shaderLayout, name, attributeNames) {
 }
 
 // dist/adapter/resources/webgpu-render-pipeline.js
-var WebGPURenderPipeline = class extends import_core8.RenderPipeline {
+var WebGPURenderPipeline = class extends import_core9.RenderPipeline {
   device;
   handle;
   vs;
@@ -648,53 +675,43 @@ var WebGPURenderPipeline = class extends import_core8.RenderPipeline {
     this.handle = this.props.handle;
     if (!this.handle) {
       const descriptor = this._getRenderPipelineDescriptor();
-      import_core8.log.groupCollapsed(1, `new WebGPURenderPipeline(${this.id})`)();
-      import_core8.log.probe(1, JSON.stringify(descriptor, null, 2))();
-      import_core8.log.groupEnd(1)();
+      import_core9.log.groupCollapsed(1, `new WebGPURenderPipeline(${this.id})`)();
+      import_core9.log.probe(1, JSON.stringify(descriptor, null, 2))();
+      import_core9.log.groupEnd(1)();
       this.handle = this.device.handle.createRenderPipeline(descriptor);
     }
     this.handle.label = this.props.id;
-    this.vs = (0, import_core8.cast)(props.vs);
-    this.fs = (0, import_core8.cast)(props.fs);
+    this.vs = (0, import_core9.cast)(props.vs);
+    this.fs = (0, import_core9.cast)(props.fs);
   }
   destroy() {
   }
   // setIndexBuffer(indexBuffer: Buffer): void {
   //   this._indexBuffer = cast<WebGPUBuffer>(indexBuffer);
   // }
-  /*
-  setAttributes(attributes: Record<string, Buffer>): void {
-    for (const [name, buffer] of Object.entries(attributes)) {
-      const bufferIndex = this._bufferSlots[name];
-      if (bufferIndex >= 0) {
-        this._buffers[bufferIndex] = buffer;
-      } else {
-        throw new Error(
-          `Setting attribute '${name}' not listed in shader layout for program ${this.id}`
-        );
-      }
-    }
-    // for (let i = 0; i < this._bufferSlots.length; ++i) {
-    //   const bufferName = this._bufferSlots[i];
-    //   if (attributes[bufferName]) {
-    //     this.handle
-    //   }
-    // }
-  }
-  */
-  // setConstantAttributes(attributes: Record<string, TypedArray>): void {
-  //   throw new Error('not implemented');
+  // setAttributes(attributes: Record<string, Buffer>): void {
+  //   for (const [name, buffer] of Object.entries(attributes)) {
+  //     const bufferIndex = this._bufferSlots[name];
+  //     if (bufferIndex >= 0) {
+  //       this._buffers[bufferIndex] = buffer;
+  //     } else {
+  //       throw new Error(
+  //         `Setting attribute '${name}' not listed in shader layout for program ${this.id}`
+  //       );
+  //     }
+  //   }
+  //   // for (let i = 0; i < this._bufferSlots.length; ++i) {
+  //   //   const bufferName = this._bufferSlots[i];
+  //   //   if (attributes[bufferName]) {
+  //   //     this.handle
+  //   //   }
+  //   // }
   // }
   setBindings(bindings) {
     Object.assign(this.props.bindings, bindings);
   }
-  setUniforms(uniforms) {
-    if (!(0, import_core8.isObjectEmpty)(uniforms)) {
-      throw new Error("WebGPU does not support uniforms");
-    }
-  }
   draw(options) {
-    const webgpuRenderPass = (0, import_core8.cast)(options.renderPass) || this.device.getDefaultRenderPass();
+    const webgpuRenderPass = (0, import_core9.cast)(options.renderPass) || this.device.getDefaultRenderPass();
     webgpuRenderPass.handle.setPipeline(this.handle);
     const bindGroup = this._getBindGroup();
     if (bindGroup) {
@@ -728,14 +745,14 @@ var WebGPURenderPipeline = class extends import_core8.RenderPipeline {
   _getRenderPipelineDescriptor() {
     var _a, _b;
     const vertex = {
-      module: (0, import_core8.cast)(this.props.vs).handle,
+      module: (0, import_core9.cast)(this.props.vs).handle,
       entryPoint: this.props.vsEntryPoint || "main",
       buffers: getVertexBufferLayout(this.props.shaderLayout, this.props.bufferLayout)
     };
     let fragment;
     if (this.props.fs) {
       fragment = {
-        module: (0, import_core8.cast)(this.props.fs).handle,
+        module: (0, import_core9.cast)(this.props.fs).handle,
         entryPoint: this.props.fsEntryPoint || "main",
         targets: [
           {
@@ -765,8 +782,8 @@ var WebGPURenderPipeline = class extends import_core8.RenderPipeline {
 };
 
 // dist/adapter/resources/webgpu-compute-pipeline.js
-var import_core9 = require("@luma.gl/core");
-var WebGPUComputePipeline = class extends import_core9.ComputePipeline {
+var import_core10 = require("@luma.gl/core");
+var WebGPUComputePipeline = class extends import_core10.ComputePipeline {
   device;
   handle;
   constructor(device, props) {
@@ -790,8 +807,8 @@ var WebGPUComputePipeline = class extends import_core9.ComputePipeline {
 };
 
 // dist/adapter/resources/webgpu-render-pass.js
-var import_core10 = require("@luma.gl/core");
-var WebGPURenderPass = class extends import_core10.RenderPass {
+var import_core11 = require("@luma.gl/core");
+var WebGPURenderPass = class extends import_core11.RenderPass {
   device;
   handle;
   /** Active pipeline */
@@ -801,11 +818,23 @@ var WebGPURenderPass = class extends import_core10.RenderPass {
     this.device = device;
     const framebuffer = props.framebuffer || device.canvasContext.getCurrentFramebuffer();
     const renderPassDescriptor = this.getRenderPassDescriptor(framebuffer);
-    import_core10.log.groupCollapsed(3, `new WebGPURenderPass(${this.id})`)();
-    import_core10.log.probe(3, JSON.stringify(renderPassDescriptor, null, 2))();
-    import_core10.log.groupEnd(3)();
+    const webgpuQuerySet = props.timestampQuerySet;
+    if (webgpuQuerySet) {
+      renderPassDescriptor.occlusionQuerySet = webgpuQuerySet.handle;
+    }
+    if (device.features.has("timestamp-query")) {
+      const webgpuQuerySet2 = props.timestampQuerySet;
+      renderPassDescriptor.timestampWrites = webgpuQuerySet2 ? {
+        querySet: webgpuQuerySet2.handle,
+        beginningOfPassWriteIndex: props.beginTimestampIndex,
+        endOfPassWriteIndex: props.endTimestampIndex
+      } : void 0;
+    }
     this.handle = this.props.handle || device.commandEncoder.beginRenderPass(renderPassDescriptor);
     this.handle.label = this.props.id;
+    import_core11.log.groupCollapsed(3, `new WebGPURenderPass(${this.id})`)();
+    import_core11.log.probe(3, JSON.stringify(renderPassDescriptor, null, 2))();
+    import_core11.log.groupEnd(3)();
   }
   destroy() {
   }
@@ -813,7 +842,7 @@ var WebGPURenderPass = class extends import_core10.RenderPass {
     this.handle.end();
   }
   setPipeline(pipeline) {
-    this.pipeline = (0, import_core10.cast)(pipeline);
+    this.pipeline = (0, import_core11.cast)(pipeline);
     this.handle.setPipeline(this.pipeline.handle);
   }
   /** Sets an array of bindings (uniform buffers, samplers, textures, ...) */
@@ -826,10 +855,10 @@ var WebGPURenderPass = class extends import_core10.RenderPass {
     }
   }
   setIndexBuffer(buffer, indexFormat, offset = 0, size) {
-    this.handle.setIndexBuffer((0, import_core10.cast)(buffer).handle, indexFormat, offset, size);
+    this.handle.setIndexBuffer((0, import_core11.cast)(buffer).handle, indexFormat, offset, size);
   }
   setVertexBuffer(slot, buffer, offset = 0) {
-    this.handle.setVertexBuffer(slot, (0, import_core10.cast)(buffer).handle, offset);
+    this.handle.setVertexBuffer(slot, (0, import_core11.cast)(buffer).handle, offset);
   }
   draw(options) {
     if (options.indexCount) {
@@ -864,11 +893,12 @@ var WebGPURenderPass = class extends import_core10.RenderPass {
   insertDebugMarker(markerLabel) {
     this.handle.insertDebugMarker(markerLabel);
   }
-  // writeTimestamp(querySet: GPUQuerySet, queryIndex: number): void;
-  // beginOcclusionQuery(queryIndex: number): void;
-  // endOcclusionQuery(): void;
-  // beginPipelineStatisticsQuery(querySet: GPUQuerySet, queryIndex: number): void;
-  // endPipelineStatisticsQuery(querySet: GPUQuerySet, queryIndex: number): void;
+  beginOcclusionQuery(queryIndex) {
+    this.handle.beginOcclusionQuery(queryIndex);
+  }
+  endOcclusionQuery() {
+    this.handle.endOcclusionQuery();
+  }
   // executeBundles(bundles: Iterable<GPURenderBundle>): void;
   // INTERNAL
   /**
@@ -885,11 +915,11 @@ var WebGPURenderPass = class extends import_core10.RenderPass {
       colorClearValue: this.props.clearColor || [0, 0, 0, 0],
       storeOp: this.props.discard ? "discard" : "store",
       // ...colorAttachment,
-      view: colorAttachment.createView()
+      view: colorAttachment.handle
     }));
     if (framebuffer.depthStencilAttachment) {
       renderPassDescriptor.depthStencilAttachment = {
-        view: framebuffer.depthStencilAttachment.createView()
+        view: framebuffer.depthStencilAttachment.handle
       };
       const { depthStencilAttachment } = renderPassDescriptor;
       if (this.props.depthReadOnly) {
@@ -912,8 +942,8 @@ var WebGPURenderPass = class extends import_core10.RenderPass {
 };
 
 // dist/adapter/resources/webgpu-compute-pass.js
-var import_core11 = require("@luma.gl/core");
-var WebGPUComputePass = class extends import_core11.ComputePass {
+var import_core12 = require("@luma.gl/core");
+var WebGPUComputePass = class extends import_core12.ComputePass {
   device;
   handle;
   _bindGroupLayout = null;
@@ -921,9 +951,20 @@ var WebGPUComputePass = class extends import_core11.ComputePass {
     var _a;
     super(device, props);
     this.device = device;
+    let timestampWrites;
+    if (device.features.has("timestamp-query")) {
+      const webgpuQuerySet = props.timestampQuerySet;
+      if (webgpuQuerySet) {
+        timestampWrites = {
+          querySet: webgpuQuerySet.handle,
+          beginningOfPassWriteIndex: props.beginTimestampIndex,
+          endOfPassWriteIndex: props.endTimestampIndex
+        };
+      }
+    }
     this.handle = this.props.handle || ((_a = device.commandEncoder) == null ? void 0 : _a.beginComputePass({
-      label: this.props.id
-      // timestampWrites?: GPUComputePassTimestampWrites;
+      label: this.props.id,
+      timestampWrites
     }));
   }
   /** @note no WebGPU destroy method, just gc */
@@ -971,22 +1012,15 @@ var WebGPUComputePass = class extends import_core11.ComputePass {
 };
 
 // dist/adapter/resources/webgpu-vertex-array.js
-var import_core12 = require("@luma.gl/core");
+var import_core13 = require("@luma.gl/core");
 var import_env = require("@probe.gl/env");
-var WebGPUVertexArray = class extends import_core12.VertexArray {
+var WebGPUVertexArray = class extends import_core13.VertexArray {
   get [Symbol.toStringTag]() {
     return "WebGPUVertexArray";
   }
   device;
   /** Vertex Array is a helper class under WebGPU */
   handle;
-  /**
-   * Attribute 0 can not be disable on most desktop OpenGL based browsers
-   * TODO is this even an issue for WebGPU?
-   */
-  static isConstantAttributeZeroSupported(device) {
-    return (0, import_env.getBrowser)() === "Chrome";
-  }
   // Create a VertexArray
   constructor(device, props) {
     super(device, props);
@@ -1005,35 +1039,39 @@ var WebGPUVertexArray = class extends import_core12.VertexArray {
   setBuffer(bufferSlot, buffer) {
     this.attributes[bufferSlot] = buffer;
   }
-  /** Set a location in vertex attributes array to a constant value, disables the location */
-  setConstant(location, value) {
-    import_core12.log.warn(`${this.id} constant attributes not supported on WebGPU`);
-  }
   bindBeforeRender(renderPass, firstIndex, indexCount) {
     const webgpuRenderPass = renderPass;
     const webgpuIndexBuffer = this.indexBuffer;
     if (webgpuIndexBuffer == null ? void 0 : webgpuIndexBuffer.handle) {
-      import_core12.log.warn("setting index buffer", webgpuIndexBuffer == null ? void 0 : webgpuIndexBuffer.handle, webgpuIndexBuffer == null ? void 0 : webgpuIndexBuffer.indexType)();
+      import_core13.log.warn("setting index buffer", webgpuIndexBuffer == null ? void 0 : webgpuIndexBuffer.handle, webgpuIndexBuffer == null ? void 0 : webgpuIndexBuffer.indexType)();
       webgpuRenderPass.handle.setIndexBuffer(webgpuIndexBuffer == null ? void 0 : webgpuIndexBuffer.handle, webgpuIndexBuffer == null ? void 0 : webgpuIndexBuffer.indexType);
     }
     for (let location = 0; location < this.maxVertexAttributes; location++) {
       const webgpuBuffer = this.attributes[location];
       if (webgpuBuffer == null ? void 0 : webgpuBuffer.handle) {
-        import_core12.log.warn(`setting vertex buffer ${location}`, webgpuBuffer == null ? void 0 : webgpuBuffer.handle)();
+        import_core13.log.warn(`setting vertex buffer ${location}`, webgpuBuffer == null ? void 0 : webgpuBuffer.handle)();
         webgpuRenderPass.handle.setVertexBuffer(location, webgpuBuffer == null ? void 0 : webgpuBuffer.handle);
       }
     }
   }
   unbindAfterRender(renderPass) {
   }
+  // DEPRECATED METHODS
+  /**
+   * @deprecated is this even an issue for WebGPU?
+   * Attribute 0 can not be disable on most desktop OpenGL based browsers
+   */
+  static isConstantAttributeZeroSupported(device) {
+    return (0, import_env.getBrowser)() === "Chrome";
+  }
 };
 
 // dist/adapter/webgpu-canvas-context.js
-var import_core14 = require("@luma.gl/core");
+var import_core15 = require("@luma.gl/core");
 
 // dist/adapter/resources/webgpu-framebuffer.js
-var import_core13 = require("@luma.gl/core");
-var WebGPUFramebuffer = class extends import_core13.Framebuffer {
+var import_core14 = require("@luma.gl/core");
+var WebGPUFramebuffer = class extends import_core14.Framebuffer {
   device;
   constructor(device, props) {
     super(device, props);
@@ -1043,11 +1081,10 @@ var WebGPUFramebuffer = class extends import_core13.Framebuffer {
 };
 
 // dist/adapter/webgpu-canvas-context.js
-var WebGPUCanvasContext = class extends import_core14.CanvasContext {
+var WebGPUCanvasContext = class extends import_core15.CanvasContext {
   device;
   gpuCanvasContext;
   /** Format of returned textures: "bgra8unorm", "rgba8unorm", "rgba16float". */
-  // @ts-ignore - TODO - fix this
   format = navigator.gpu.getPreferredCanvasFormat();
   /** Default stencil format for depth textures */
   depthStencilFormat = "depth24plus";
@@ -1096,7 +1133,7 @@ var WebGPUCanvasContext = class extends import_core14.CanvasContext {
         colorSpace: this.props.colorSpace,
         alphaMode: this.props.alphaMode
       });
-      import_core14.log.log(1, `Resized to ${this.width}x${this.height}px`)();
+      import_core15.log.log(1, `Resized to ${this.width}x${this.height}px`)();
     }
   }
   resize(options) {
@@ -1124,16 +1161,41 @@ var WebGPUCanvasContext = class extends import_core14.CanvasContext {
   }
 };
 
+// dist/adapter/resources/webgpu-query-set.js
+var import_core16 = require("@luma.gl/core");
+var WebGPUQuerySet = class extends import_core16.QuerySet {
+  device;
+  handle;
+  constructor(device, props) {
+    super(device, props);
+    this.device = device;
+    this.handle = this.props.handle || this.device.handle.createQuerySet({
+      type: this.props.type,
+      count: this.props.count
+    });
+    this.handle.label = this.props.id;
+  }
+  destroy() {
+    this.handle.destroy();
+  }
+};
+
 // dist/adapter/webgpu-device.js
-var _WebGPUDevice = class extends import_core15.Device {
+var _WebGPUDevice = class extends import_core17.Device {
+  /** The underlying WebGPU device */
   handle;
+  /* The underlying WebGPU adapter */
   adapter;
+  /* The underlying WebGPU adapter's info */
+  adapterInfo;
+  features;
+  info;
+  limits;
   lost;
   canvasContext = null;
+  _isLost = false;
   commandEncoder = null;
   renderPass = null;
-  _info;
-  _isLost = false;
   /** Check if WebGPU is available */
   static isSupported() {
     return Boolean(typeof navigator !== "undefined" && navigator.gpu);
@@ -1142,7 +1204,7 @@ var _WebGPUDevice = class extends import_core15.Device {
     if (!navigator.gpu) {
       throw new Error("WebGPU not available. Open in Chrome Canary and turn on chrome://flags/#enable-unsafe-webgpu");
     }
-    import_core15.log.groupCollapsed(1, "WebGPUDevice created")();
+    import_core17.log.groupCollapsed(1, "WebGPUDevice created")();
     const adapter = await navigator.gpu.requestAdapter({
       powerPreference: "high-performance"
       // forceSoftware: false
@@ -1151,47 +1213,40 @@ var _WebGPUDevice = class extends import_core15.Device {
       throw new Error("Failed to request WebGPU adapter");
     }
     const adapterInfo = await adapter.requestAdapterInfo();
-    import_core15.log.probe(2, "Adapter available", adapterInfo)();
+    import_core17.log.probe(2, "Adapter available", adapterInfo)();
+    const requiredFeatures = [];
+    const requiredLimits = {};
+    if (props.requestMaximalLimits) {
+      requiredFeatures.push(...Array.from(adapter.features));
+      for (const key in adapter.limits) {
+        requiredLimits[key] = adapter.limits[key];
+      }
+      delete requiredLimits.minSubgroupSize;
+      delete requiredLimits.maxSubgroupSize;
+    }
     const gpuDevice = await adapter.requestDevice({
-      requiredFeatures: adapter.features
-      // TODO ensure we obtain best limits
-      // requiredLimits: adapter.limits
+      requiredFeatures,
+      requiredLimits
     });
-    import_core15.log.probe(1, "GPUDevice available")();
+    import_core17.log.probe(1, "GPUDevice available")();
     if (typeof props.canvas === "string") {
-      await import_core15.CanvasContext.pageLoaded;
-      import_core15.log.probe(1, "DOM is loaded")();
+      await import_core17.CanvasContext.pageLoaded;
+      import_core17.log.probe(1, "DOM is loaded")();
     }
     const device = new _WebGPUDevice(gpuDevice, adapter, adapterInfo, props);
-    import_core15.log.probe(1, "Device created. For more info, set chrome://flags/#enable-webgpu-developer-features")();
-    import_core15.log.table(1, device.info)();
-    import_core15.log.groupEnd(1)();
+    import_core17.log.probe(1, "Device created. For more info, set chrome://flags/#enable-webgpu-developer-features")();
+    import_core17.log.table(1, device.info)();
+    import_core17.log.groupEnd(1)();
     return device;
   }
   constructor(device, adapter, adapterInfo, props) {
-    super({ ...props, id: props.id || (0, import_core15.uid)("webgpu-device") });
+    super({ ...props, id: props.id || (0, import_core17.uid)("webgpu-device") });
     this.handle = device;
     this.adapter = adapter;
-    const [driver, driverVersion] = (adapterInfo.driver || "").split(" Version ");
-    const vendor = adapterInfo.vendor || this.adapter.__brand || "unknown";
-    const renderer = driver || "";
-    const version = driverVersion || "";
-    const gpu = vendor === "apple" ? "apple" : "unknown";
-    const gpuArchitecture = adapterInfo.architecture || "unknown";
-    const gpuBackend = adapterInfo.backend || "unknown";
-    const gpuType = (adapterInfo.type || "").split(" ")[0].toLowerCase() || "unknown";
-    this._info = {
-      type: "webgpu",
-      vendor,
-      renderer,
-      version,
-      gpu,
-      gpuType,
-      gpuBackend,
-      gpuArchitecture,
-      shadingLanguage: "wgsl",
-      shadingLanguageVersion: 100
-    };
+    this.adapterInfo = adapterInfo;
+    this.info = this._getInfo();
+    this.features = this._getFeatures();
+    this.limits = this.handle.limits;
     this.lost = new Promise(async (resolve) => {
       const lostInfo = await this.handle.lost;
       this._isLost = true;
@@ -1203,7 +1258,6 @@ var _WebGPUDevice = class extends import_core15.Device {
       width: props.width,
       container: props.container
     });
-    this.features = this._getFeatures();
   }
   // TODO
   // Load the glslang module now so that it is available synchronously when compiling shaders
@@ -1212,13 +1266,6 @@ var _WebGPUDevice = class extends import_core15.Device {
   destroy() {
     this.handle.destroy();
   }
-  get info() {
-    return this._info;
-  }
-  features;
-  get limits() {
-    return this.handle.limits;
-  }
   isTextureFormatSupported(format) {
     return !format.includes("webgl");
   }
@@ -1280,6 +1327,9 @@ var _WebGPUDevice = class extends import_core15.Device {
   createTransformFeedback(props) {
     throw new Error("Transform feedback not supported in WebGPU");
   }
+  createQuerySet(props) {
+    return new WebGPUQuerySet(this, props);
+  }
   createCanvasContext(props) {
     return new WebGPUCanvasContext(this, this.adapter, props);
   }
@@ -1300,6 +1350,29 @@ var _WebGPUDevice = class extends import_core15.Device {
     }
     this.commandEncoder = null;
   }
+  // PRIVATE METHODS
+  _getInfo() {
+    const [driver, driverVersion] = (this.adapterInfo.driver || "").split(" Version ");
+    const vendor = this.adapterInfo.vendor || this.adapter.__brand || "unknown";
+    const renderer = driver || "";
+    const version = driverVersion || "";
+    const gpu = vendor === "apple" ? "apple" : "unknown";
+    const gpuArchitecture = this.adapterInfo.architecture || "unknown";
+    const gpuBackend = this.adapterInfo.backend || "unknown";
+    const gpuType = (this.adapterInfo.type || "").split(" ")[0].toLowerCase() || "unknown";
+    return {
+      type: "webgpu",
+      vendor,
+      renderer,
+      version,
+      gpu,
+      gpuType,
+      gpuBackend,
+      gpuArchitecture,
+      shadingLanguage: "wgsl",
+      shadingLanguageVersion: 100
+    };
+  }
   _getFeatures() {
     const features = new Set(this.handle.features);
     if (features.has("depth-clamping")) {
@@ -1310,19 +1383,18 @@ var _WebGPUDevice = class extends import_core15.Device {
       features.add("texture-compression-bc5-webgl");
     }
     const WEBGPU_ALWAYS_FEATURES = [
-      "webgpu",
-      "wgsl",
       "timer-query-webgl",
-      "float32-filterable-linear-webgl",
-      "float16-filterable-linear-webgl",
-      "texture-filterable-anisotropic-webgl",
+      "compilation-status-async-webgl",
       "float32-renderable-webgl",
-      "float16-renderable-webgl"
+      "float16-renderable-webgl",
+      "norm16-renderable-webgl",
+      "texture-filterable-anisotropic-webgl",
+      "shader-noperspective-interpolation-webgl"
     ];
     for (const feature of WEBGPU_ALWAYS_FEATURES) {
       features.add(feature);
     }
-    return features;
+    return new import_core17.DeviceFeatures(Array.from(features));
   }
   copyExternalImageToTexture(options) {
     var _a;