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

package/dist/index.cjs

@@ -21,21 +21,21 @@ var __publicField = (obj, key, value) => {
   return value;
 };
 
-// src/index.ts
-var src_exports = {};
-__export(src_exports, {
+// dist/index.js
+var dist_exports = {};
+__export(dist_exports, {
   WebGPUBuffer: () => WebGPUBuffer,
   WebGPUDevice: () => WebGPUDevice,
   WebGPUSampler: () => WebGPUSampler,
   WebGPUShader: () => WebGPUShader,
   WebGPUTexture: () => WebGPUTexture
 });
-module.exports = __toCommonJS(src_exports);
+module.exports = __toCommonJS(dist_exports);
 
-// src/adapter/webgpu-device.ts
-var import_core15 = require("@luma.gl/core");
+// dist/adapter/webgpu-device.js
+var import_core17 = require("@luma.gl/core");
 
-// src/adapter/resources/webgpu-buffer.ts
+// dist/adapter/resources/webgpu-buffer.js
 var import_core = require("@luma.gl/core");
 function getByteLength(props) {
   var _a;
@@ -70,16 +70,13 @@ var WebGPUBuffer = class extends import_core.Buffer {
   }
   // WebGPU provides multiple ways to write a buffer...
   write(data, byteOffset = 0) {
-    this.device.handle.queue.writeBuffer(
-      this.handle,
-      byteOffset,
-      data.buffer,
-      data.byteOffset,
-      data.byteLength
-    );
+    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()]);
@@ -105,10 +102,10 @@ var WebGPUBuffer = class extends import_core.Buffer {
   }
 };
 
-// src/adapter/resources/webgpu-texture.ts
-var import_core3 = require("@luma.gl/core");
+// dist/adapter/resources/webgpu-texture.js
+var import_core4 = require("@luma.gl/core");
 
-// src/adapter/helpers/convert-texture-format.ts
+// dist/adapter/helpers/convert-texture-format.js
 function getWebGPUTextureFormat(format) {
   if (format.includes("webgl")) {
     throw new Error("webgl-only format");
@@ -116,7 +113,7 @@ function getWebGPUTextureFormat(format) {
   return format;
 }
 
-// src/adapter/resources/webgpu-sampler.ts
+// dist/adapter/resources/webgpu-sampler.js
 var import_core2 = require("@luma.gl/core");
 var WebGPUSampler = class extends import_core2.Sampler {
   device;
@@ -135,22 +132,50 @@ var WebGPUSampler = class extends import_core2.Sampler {
   }
 };
 
-// src/adapter/resources/webgpu-texture.ts
+// 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;
@@ -178,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;
@@ -214,21 +239,7 @@ var WebGPUTexture = class extends import_core3.Texture {
   }
   /** Set image */
   setImage(options) {
-    const {
-      source,
-      width = options.source.width,
-      height = options.source.height,
-      depth = 1,
-      sourceX = 0,
-      sourceY = 0,
-      mipLevel = 0,
-      x = 0,
-      y = 0,
-      z = 0,
-      aspect = "all",
-      colorSpace = "srgb",
-      premultipliedAlpha = false
-    } = options;
+    const { source, width = options.source.width, height = options.source.height, depth = 1, sourceX = 0, sourceY = 0, mipLevel = 0, x = 0, y = 0, z = 0, aspect = "all", colorSpace = "srgb", premultipliedAlpha = false } = options;
     this.device.handle.queue.copyExternalImageToTexture(
       // source: GPUImageCopyExternalImage
       {
@@ -245,105 +256,20 @@ 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 });
   }
-  /*
-    async readPixels() {
-      const readbackBuffer = device.createBuffer({
-          usage: Buffer.COPY_DST | Buffer.MAP_READ,
-          size: 4 * textureWidth * textureHeight,
-      });
-  
-      // Copy data from the texture to the buffer.
-      const encoder = device.createCommandEncoder();
-      encoder.copyTextureToBuffer(
-          { texture },
-          { buffer, rowPitch: textureWidth * 4 },
-          [textureWidth, textureHeight],
-      );
-      device.submit([encoder.finish()]);
-  
-      // Get the data on the CPU.
-      await buffer.mapAsync(GPUMapMode.READ);
-      saveScreenshot(buffer.getMappedRange());
-      buffer.unmap();
-    }
-  
-    setImageData(imageData, usage): this {
-      let data = null;
-  
-      const bytesPerRow = Math.ceil((img.width * 4) / 256) * 256;
-      if (bytesPerRow == img.width * 4) {
-        data = imageData.data;
-      } else {
-        data = new Uint8Array(bytesPerRow * img.height);
-        let imagePixelIndex = 0;
-        for (let y = 0; y < img.height; ++y) {
-          for (let x = 0; x < img.width; ++x) {
-            const i = x * 4 + y * bytesPerRow;
-            data[i] = imageData.data[imagePixelIndex];
-            data[i + 1] = imageData.data[imagePixelIndex + 1];
-            data[i + 2] = imageData.data[imagePixelIndex + 2];
-            data[i + 3] = imageData.data[imagePixelIndex + 3];
-            imagePixelIndex += 4;
-          }
-        }
-      }
-      return this;
-    }
-  
-    setData(data): this {
-      const textureDataBuffer = this.device.handle.createBuffer({
-        size: data.byteLength,
-        usage: Buffer.COPY_DST | Buffer.COPY_SRC,
-        mappedAtCreation: true
-      });
-      new Uint8Array(textureDataBuffer.getMappedRange()).set(data);
-      textureDataBuffer.unmap();
-  
-      this.setBuffer(textureDataBuffer);
-  
-      textureDataBuffer.destroy();
-      return this;
-    }
-  
-    setBuffer(textureDataBuffer, {bytesPerRow}): this {
-      const commandEncoder = this.device.handle.createCommandEncoder();
-      commandEncoder.copyBufferToTexture(
-        {
-          buffer: textureDataBuffer,
-          bytesPerRow
-        },
-        {
-          texture: this.handle
-        },
-        {
-          width,
-          height,
-          depth
-        }
-      );
-  
-      this.device.handle.defaultQueue.submit([commandEncoder.finish()]);
-      return this;
-    }
-    */
 };
 
-// src/adapter/resources/webgpu-external-texture.ts
-var import_core4 = require("@luma.gl/core");
-var WebGPUExternalTexture = class extends import_core4.ExternalTexture {
+// dist/adapter/resources/webgpu-external-texture.js
+var import_core5 = require("@luma.gl/core");
+var WebGPUExternalTexture = class extends import_core5.ExternalTexture {
   device;
   handle;
   sampler;
@@ -365,9 +291,9 @@ var WebGPUExternalTexture = class extends import_core4.ExternalTexture {
   }
 };
 
-// src/adapter/resources/webgpu-shader.ts
-var import_core5 = require("@luma.gl/core");
-var WebGPUShader = class extends import_core5.Shader {
+// dist/adapter/resources/webgpu-shader.js
+var import_core6 = require("@luma.gl/core");
+var WebGPUShader = class extends import_core6.Shader {
   device;
   handle;
   constructor(device, props) {
@@ -383,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}`);
     }
   }
@@ -416,10 +342,10 @@ var WebGPUShader = class extends import_core5.Shader {
   }
 };
 
-// src/adapter/resources/webgpu-render-pipeline.ts
-var import_core8 = require("@luma.gl/core");
+// dist/adapter/resources/webgpu-render-pipeline.js
+var import_core9 = require("@luma.gl/core");
 
-// src/adapter/helpers/webgpu-parameters.ts
+// dist/adapter/helpers/webgpu-parameters.js
 function addDepthStencil(descriptor) {
   descriptor.depthStencil = descriptor.depthStencil || {
     // required, set something
@@ -604,8 +530,8 @@ function addColorState(descriptor) {
   return (_f = descriptor.fragment) == null ? void 0 : _f.targets;
 }
 
-// src/adapter/helpers/get-bind-group.ts
-var import_core6 = require("@luma.gl/core");
+// dist/adapter/helpers/get-bind-group.js
+var import_core7 = require("@luma.gl/core");
 function getBindGroup(device, bindGroupLayout, shaderLayout, bindings) {
   const entries = getBindGroupEntries(bindings, shaderLayout);
   return device.createBindGroup({
@@ -616,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;
 }
@@ -631,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");
 }
 
-// src/adapter/helpers/get-vertex-buffer-layout.ts
-var import_core7 = require("@luma.gl/core");
+// dist/adapter/helpers/get-vertex-buffer-layout.js
+var import_core8 = require("@luma.gl/core");
 function getWebGPUVertexFormat(format) {
   if (format.endsWith("-webgl")) {
     throw new Error(`WebGPU does not support vertex format ${format}`);
@@ -678,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),
@@ -703,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: [
           {
@@ -720,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)) {
@@ -730,8 +656,8 @@ function findAttributeLayout(shaderLayout, name, attributeNames) {
   return attribute;
 }
 
-// src/adapter/resources/webgpu-render-pipeline.ts
-var WebGPURenderPipeline = class extends import_core8.RenderPipeline {
+// dist/adapter/resources/webgpu-render-pipeline.js
+var WebGPURenderPipeline = class extends import_core9.RenderPipeline {
   device;
   handle;
   vs;
@@ -749,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) {
@@ -803,13 +719,7 @@ var WebGPURenderPipeline = class extends import_core8.RenderPipeline {
     }
     options.vertexArray.bindBeforeRender(options.renderPass);
     if (options.indexCount) {
-      webgpuRenderPass.handle.drawIndexed(
-        options.indexCount,
-        options.instanceCount,
-        options.firstIndex,
-        options.baseVertex,
-        options.firstInstance
-      );
+      webgpuRenderPass.handle.drawIndexed(options.indexCount, options.instanceCount, options.firstIndex, options.baseVertex, options.firstInstance);
     } else {
       webgpuRenderPass.handle.draw(
         options.vertexCount || 0,
@@ -826,28 +736,23 @@ var WebGPURenderPipeline = class extends import_core8.RenderPipeline {
   /** Return a bind group created by setBindings */
   _getBindGroup() {
     this._bindGroupLayout = this._bindGroupLayout || this.handle.getBindGroupLayout(0);
-    this._bindGroup = this._bindGroup || getBindGroup(
-      this.device.handle,
-      this._bindGroupLayout,
-      this.props.shaderLayout,
-      this.props.bindings
-    );
+    this._bindGroup = this._bindGroup || getBindGroup(this.device.handle, this._bindGroupLayout, this.props.shaderLayout, this.props.bindings);
     return this._bindGroup;
   }
-  /** 
-   * Populate the complex WebGPU GPURenderPipelineDescriptor 
+  /**
+   * Populate the complex WebGPU GPURenderPipelineDescriptor
    */
   _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: [
           {
@@ -874,53 +779,11 @@ var WebGPURenderPipeline = class extends import_core8.RenderPipeline {
     applyParametersToRenderPipelineDescriptor(descriptor, this.props.parameters);
     return descriptor;
   }
-  /**
-    _setAttributeBuffers(webgpuRenderPass: WebGPURenderPass) {
-      if (this._indexBuffer) {
-        webgpuRenderPass.handle.setIndexBuffer(this._indexBuffer.handle, this._indexBuffer.props.indexType);
-      }
-  
-      const buffers = this._getBuffers();
-      for (let i = 0; i < buffers.length; ++i) {
-        const buffer = cast<WebGPUBuffer>(buffers[i]);
-        if (!buffer) {
-          const attribute = this.props.shaderLayout.attributes.find(
-            (attribute) => attribute.location === i
-          );
-          throw new Error(
-            `No buffer provided for attribute '${attribute?.name || ''}' in Model '${this.props.id}'`
-          );
-        }
-        webgpuRenderPass.handle.setVertexBuffer(i, buffer.handle);
-      }
-  
-      // TODO - HANDLE buffer maps
-      /*
-      for (const [bufferName, attributeMapping] of Object.entries(this.props.bufferLayout)) {
-        const buffer = cast<WebGPUBuffer>(this.props.attributes[bufferName]);
-        if (!buffer) {
-          log.warn(`Missing buffer for buffer map ${bufferName}`)();
-          continue;
-        }
-  
-        if ('location' in attributeMapping) {
-          // @ts-expect-error TODO model must not depend on webgpu
-          renderPass.handle.setVertexBuffer(layout.location, buffer.handle);
-        } else {
-          for (const [bufferName, mapping] of Object.entries(attributeMapping)) {
-            // @ts-expect-error TODO model must not depend on webgpu
-            renderPass.handle.setVertexBuffer(field.location, buffer.handle);
-          }
-        }
-      }
-      *
-    }
-    */
 };
 
-// src/adapter/resources/webgpu-compute-pipeline.ts
-var import_core9 = require("@luma.gl/core");
-var WebGPUComputePipeline = class extends import_core9.ComputePipeline {
+// dist/adapter/resources/webgpu-compute-pipeline.js
+var import_core10 = require("@luma.gl/core");
+var WebGPUComputePipeline = class extends import_core10.ComputePipeline {
   device;
   handle;
   constructor(device, props) {
@@ -943,9 +806,9 @@ var WebGPUComputePipeline = class extends import_core9.ComputePipeline {
   }
 };
 
-// src/adapter/resources/webgpu-render-pass.ts
-var import_core10 = require("@luma.gl/core");
-var WebGPURenderPass = class extends import_core10.RenderPass {
+// dist/adapter/resources/webgpu-render-pass.js
+var import_core11 = require("@luma.gl/core");
+var WebGPURenderPass = class extends import_core11.RenderPass {
   device;
   handle;
   /** Active pipeline */
@@ -955,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() {
   }
@@ -967,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, ...) */
@@ -980,27 +855,16 @@ 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) {
-      this.handle.drawIndexed(
-        options.indexCount,
-        options.instanceCount,
-        options.firstIndex,
-        options.baseVertex,
-        options.firstInstance
-      );
+      this.handle.drawIndexed(options.indexCount, options.instanceCount, options.firstIndex, options.baseVertex, options.firstInstance);
     } else {
-      this.handle.draw(
-        options.vertexCount || 0,
-        options.instanceCount || 1,
-        options.firstIndex,
-        options.firstInstance
-      );
+      this.handle.draw(options.vertexCount || 0, options.instanceCount || 1, options.firstIndex, options.firstInstance);
     }
   }
   drawIndirect() {
@@ -1017,14 +881,7 @@ var WebGPURenderPass = class extends import_core10.RenderPass {
       this.handle.setScissorRect(scissorRect[0], scissorRect[1], scissorRect[2], scissorRect[3]);
     }
     if (viewport) {
-      this.handle.setViewport(
-        viewport[0],
-        viewport[1],
-        viewport[2],
-        viewport[3],
-        viewport[4],
-        viewport[5]
-      );
+      this.handle.setViewport(viewport[0], viewport[1], viewport[2], viewport[3], viewport[4], viewport[5]);
     }
   }
   pushDebugGroup(groupLabel) {
@@ -1036,16 +893,17 @@ 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
-  /** 
+  /**
    * Partial render pass descriptor. Used by WebGPURenderPass.
-   * @returns attachments fields of a renderpass descriptor. 
+   * @returns attachments fields of a renderpass descriptor.
    */
   getRenderPassDescriptor(framebuffer) {
     const renderPassDescriptor = {
@@ -1057,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) {
@@ -1083,9 +941,9 @@ var WebGPURenderPass = class extends import_core10.RenderPass {
   }
 };
 
-// src/adapter/resources/webgpu-compute-pass.ts
-var import_core11 = require("@luma.gl/core");
-var WebGPUComputePass = class extends import_core11.ComputePass {
+// dist/adapter/resources/webgpu-compute-pass.js
+var import_core12 = require("@luma.gl/core");
+var WebGPUComputePass = class extends import_core12.ComputePass {
   device;
   handle;
   _bindGroupLayout = null;
@@ -1093,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 */
@@ -1140,25 +1009,18 @@ var WebGPUComputePass = class extends import_core11.ComputePass {
   insertDebugMarker(markerLabel) {
     this.handle.insertDebugMarker(markerLabel);
   }
-  // writeTimestamp(querySet: GPUQuerySet, queryIndex: number): void;
-  // beginPipelineStatisticsQuery(querySet: GPUQuerySet, queryIndex: number): void;
-  // endPipelineStatisticsQuery(querySet: GPUQuerySet, queryIndex: number): void;
 };
 
-// src/adapter/resources/webgpu-vertex-array.ts
-var import_core12 = require("@luma.gl/core");
+// dist/adapter/resources/webgpu-vertex-array.js
+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 */
-  static isConstantAttributeZeroSupported(device) {
-    return device.info.type === "webgl2" || (0, import_env.getBrowser)() === "Chrome";
-  }
   // Create a VertexArray
   constructor(device, props) {
     super(device, props);
@@ -1168,7 +1030,7 @@ var WebGPUVertexArray = class extends import_core12.VertexArray {
   }
   /**
    * Set an elements buffer, for indexed rendering.
-   * Must be a Buffer bound to buffer with usage bit Buffer.INDEX set. 
+   * Must be a Buffer bound to buffer with usage bit Buffer.INDEX set.
    */
   setIndexBuffer(buffer) {
     this.indexBuffer = buffer;
@@ -1177,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";
+  }
 };
 
-// src/adapter/webgpu-canvas-context.ts
-var import_core14 = require("@luma.gl/core");
+// dist/adapter/webgpu-canvas-context.js
+var import_core15 = require("@luma.gl/core");
 
-// src/adapter/resources/webgpu-framebuffer.ts
-var import_core13 = require("@luma.gl/core");
-var WebGPUFramebuffer = class extends import_core13.Framebuffer {
+// dist/adapter/resources/webgpu-framebuffer.js
+var import_core14 = require("@luma.gl/core");
+var WebGPUFramebuffer = class extends import_core14.Framebuffer {
   device;
   constructor(device, props) {
     super(device, props);
@@ -1214,8 +1080,8 @@ var WebGPUFramebuffer = class extends import_core13.Framebuffer {
   }
 };
 
-// src/adapter/webgpu-canvas-context.ts
-var WebGPUCanvasContext = class extends import_core14.CanvasContext {
+// dist/adapter/webgpu-canvas-context.js
+var WebGPUCanvasContext = class extends import_core15.CanvasContext {
   device;
   gpuCanvasContext;
   /** Format of returned textures: "bgra8unorm", "rgba8unorm", "rgba16float". */
@@ -1267,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) {
@@ -1295,27 +1161,50 @@ var WebGPUCanvasContext = class extends import_core14.CanvasContext {
   }
 };
 
-// src/adapter/webgpu-device.ts
-var _WebGPUDevice = class extends import_core15.Device {
+// 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_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);
   }
   static async create(props) {
     if (!navigator.gpu) {
-      throw new Error(
-        "WebGPU not available. Open in Chrome Canary and turn on chrome://flags/#enable-unsafe-webgpu"
-      );
+      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
@@ -1324,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;
@@ -1376,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
@@ -1385,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");
   }
@@ -1453,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);
   }
@@ -1473,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")) {
@@ -1482,29 +1382,19 @@ var _WebGPUDevice = class extends import_core15.Device {
     if (features.has("texture-compression-bc")) {
       features.add("texture-compression-bc5-webgl");
     }
-    features.add("webgpu");
-    features.add("timer-query-webgl");
-    features.add("vertex-array-object-webgl1");
-    features.add("instanced-rendering-webgl1");
-    features.add("multiple-render-targets-webgl1");
-    features.add("index-uint32-webgl1");
-    features.add("blend-minmax-webgl1");
-    features.add("texture-blend-float-webgl1");
-    features.add("texture-formats-srgb-webgl1");
-    features.add("texture-formats-depth-webgl1");
-    features.add("texture-formats-float32-webgl1");
-    features.add("texture-formats-float16-webgl1");
-    features.add("texture-filter-linear-float32-webgl");
-    features.add("texture-filter-linear-float16-webgl");
-    features.add("texture-filter-anisotropic-webgl");
-    features.add("texture-renderable-rgba32float-webgl");
-    features.add("texture-renderable-float32-webgl");
-    features.add("texture-renderable-float16-webgl");
-    features.add("glsl-frag-data");
-    features.add("glsl-frag-depth");
-    features.add("glsl-derivatives");
-    features.add("glsl-texture-lod");
-    return features;
+    const WEBGPU_ALWAYS_FEATURES = [
+      "timer-query-webgl",
+      "compilation-status-async-webgl",
+      "float32-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 new import_core17.DeviceFeatures(Array.from(features));
   }
   copyExternalImageToTexture(options) {
     var _a;
@@ -1548,3 +1438,4 @@ var _WebGPUDevice = class extends import_core15.Device {
 };
 var WebGPUDevice = _WebGPUDevice;
 __publicField(WebGPUDevice, "type", "webgpu");
+//# sourceMappingURL=index.cjs.map