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

package/dist/dist.dev.js

@@ -91,7 +91,8 @@ var __exports__ = (() => {
       }
     }
     destroy() {
-      this.handle.destroy();
+      this.handle?.destroy();
+      this.handle = null;
     }
     // WebGPU provides multiple ways to write a buffer...
     write(data, byteOffset = 0) {
@@ -160,6 +161,7 @@ var __exports__ = (() => {
       this.handle.label = this.props.id;
     }
     destroy() {
+      this.handle = null;
     }
   };
 
@@ -188,6 +190,7 @@ var __exports__ = (() => {
       this.handle.label = this.props.id;
     }
     destroy() {
+      this.handle = null;
     }
   };
 
@@ -225,6 +228,13 @@ var __exports__ = (() => {
       }
       this.initialize(props);
     }
+    destroy() {
+      this.handle?.destroy();
+      this.handle = null;
+    }
+    createView(props) {
+      return new WebGPUTextureView(this.device, { ...props, texture: this });
+    }
     initialize(props) {
       this.handle = this.props.handle || this.createHandle();
       this.handle.label ||= this.id;
@@ -253,9 +263,6 @@ var __exports__ = (() => {
         sampleCount: this.props.samples
       });
     }
-    destroy() {
-      this.handle.destroy();
-    }
     /**
      * Set default sampler
      * Accept a sampler instance or set of props;
@@ -305,10 +312,6 @@ var __exports__ = (() => {
       return { width, height };
     }
     // 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({
@@ -408,6 +411,7 @@ var __exports__ = (() => {
       this.sampler = null;
     }
     destroy() {
+      this.handle = null;
     }
     /** Set default sampler */
     setSampler(sampler) {
@@ -439,6 +443,7 @@ var __exports__ = (() => {
       }
     }
     destroy() {
+      this.handle = null;
     }
     /** Returns compilation info for this shader */
     async getCompilationInfo() {
@@ -447,23 +452,12 @@ var __exports__ = (() => {
     }
     // PRIVATE METHODS
     createHandle() {
-      const { source, stage } = this.props;
-      let language = this.props.language;
-      if (language === "auto") {
-        language = source.includes("->") ? "wgsl" : "glsl";
-      }
-      switch (language) {
-        case "wgsl":
-          return this.device.handle.createShaderModule({ code: source });
-        case "glsl":
-          return this.device.handle.createShaderModule({
-            code: source,
-            // @ts-expect-error
-            transform: (glsl) => this.device.glslang.compileGLSL(glsl, stage)
-          });
-        default:
-          throw new Error(language);
+      const { source } = this.props;
+      const isGLSL = source.includes("#version");
+      if (this.props.language === "glsl" || isGLSL) {
+        throw new Error("GLSL shaders are not supported in WebGPU");
       }
+      return this.device.handle.createShaderModule({ code: source });
     }
   };
 
@@ -788,11 +782,8 @@ var __exports__ = (() => {
     handle;
     vs;
     fs = null;
-    // private _bufferSlots: Record<string, number>;
-    // private _buffers: Buffer[];
-    // private _firstIndex: number;
-    // private _lastIndex: number;
     /** For internal use to create BindGroups */
+    _bindings;
     _bindGroupLayout = null;
     _bindGroup = null;
     constructor(device, props) {
@@ -809,35 +800,21 @@ var __exports__ = (() => {
       this.handle.label = this.props.id;
       this.vs = (0, import_core9.cast)(props.vs);
       this.fs = (0, import_core9.cast)(props.fs);
+      this._bindings = { ...this.props.bindings };
     }
     destroy() {
+      this.handle = null;
     }
-    // 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
-    //   //   }
-    //   // }
-    // }
+    /**
+     * @todo Use renderpass.setBindings() ?
+     * @todo Do we want to expose BindGroups in the API and remove this?
+     */
     setBindings(bindings) {
-      Object.assign(this.props.bindings, bindings);
+      Object.assign(this._bindings, bindings);
     }
+    /** @todo - should this be moved to renderpass? */
     draw(options) {
-      const webgpuRenderPass = (0, import_core9.cast)(options.renderPass) || this.device.getDefaultRenderPass();
+      const webgpuRenderPass = options.renderPass;
       webgpuRenderPass.handle.setPipeline(this.handle);
       const bindGroup = this._getBindGroup();
       if (bindGroup) {
@@ -861,18 +838,19 @@ var __exports__ = (() => {
         );
       }
       options.vertexArray.unbindAfterRender(options.renderPass);
+      return true;
     }
-    // _getBuffers() {
-    //   return this._buffers;
-    // }
     /** Return a bind group created by setBindings */
     _getBindGroup() {
+      if (this.props.shaderLayout.bindings.length === 0) {
+        return null;
+      }
       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._bindings
       );
       return this._bindGroup;
     }
@@ -882,22 +860,19 @@ var __exports__ = (() => {
     _getRenderPipelineDescriptor() {
       const vertex = {
         module: (0, import_core9.cast)(this.props.vs).handle,
-        entryPoint: this.props.vsEntryPoint || "main",
+        entryPoint: this.props.vertexEntryPoint || "main",
         buffers: getVertexBufferLayout(this.props.shaderLayout, this.props.bufferLayout)
       };
-      let fragment;
-      if (this.props.fs) {
-        fragment = {
-          module: (0, import_core9.cast)(this.props.fs).handle,
-          entryPoint: this.props.fsEntryPoint || "main",
-          targets: [
-            {
-              // TODO exclamation mark hack!
-              format: getWebGPUTextureFormat(this.device?.canvasContext?.format)
-            }
-          ]
-        };
-      }
+      const fragment = {
+        module: (0, import_core9.cast)(this.props.fs).handle,
+        entryPoint: this.props.fragmentEntryPoint || "main",
+        targets: [
+          {
+            // TODO exclamation mark hack!
+            format: getWebGPUTextureFormat(this.device?.canvasContext?.format)
+          }
+        ]
+      };
       switch (this.props.topology) {
         case "triangle-fan-webgl":
         case "line-loop-webgl":
@@ -915,78 +890,66 @@ var __exports__ = (() => {
       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
+  // src/adapter/resources/webgpu-framebuffer.ts
   var import_core10 = __toESM(require_core(), 1);
-  var WebGPUComputePipeline = class extends import_core10.ComputePipeline {
+  var WebGPUFramebuffer = class extends import_core10.Framebuffer {
+    device;
+    constructor(device, props) {
+      super(device, props);
+      this.device = device;
+      this.autoCreateAttachmentTextures();
+    }
+  };
+
+  // src/adapter/resources/webgpu-compute-pipeline.ts
+  var import_core11 = __toESM(require_core(), 1);
+  var WebGPUComputePipeline = class extends import_core11.ComputePipeline {
     device;
     handle;
+    /** For internal use to create BindGroups */
+    _bindGroupLayout = null;
+    _bindGroup = null;
+    /** For internal use to create BindGroups */
+    _bindings = {};
     constructor(device, props) {
       super(device, props);
       this.device = device;
-      const webgpuShader = this.props.cs;
+      const webgpuShader = this.props.shader;
       this.handle = this.props.handle || this.device.handle.createComputePipeline({
         label: this.props.id,
         compute: {
           module: webgpuShader.handle,
-          entryPoint: this.props.csEntryPoint
-          // constants: this.props.csConstants
+          entryPoint: this.props.entryPoint,
+          constants: this.props.constants
         },
         layout: "auto"
       });
     }
-    /** For internal use in render passes */
-    _getBindGroupLayout() {
-      return this.handle.getBindGroupLayout(0);
+    /**
+     * @todo Use renderpass.setBindings() ?
+     * @todo Do we want to expose BindGroups in the API and remove this?
+     */
+    setBindings(bindings) {
+      Object.assign(this._bindings, bindings);
+    }
+    /** 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._bindings
+      );
+      return this._bindGroup;
     }
   };
 
   // src/adapter/resources/webgpu-render-pass.ts
-  var import_core11 = __toESM(require_core(), 1);
-  var WebGPURenderPass = class extends import_core11.RenderPass {
+  var import_core12 = __toESM(require_core(), 1);
+  var WebGPURenderPass = class extends import_core12.RenderPass {
     device;
     handle;
     /** Active pipeline */
@@ -1010,9 +973,9 @@ var __exports__ = (() => {
       }
       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)();
+      import_core12.log.groupCollapsed(3, `new WebGPURenderPass(${this.id})`)();
+      import_core12.log.probe(3, JSON.stringify(renderPassDescriptor, null, 2))();
+      import_core12.log.groupEnd(3)();
     }
     destroy() {
     }
@@ -1020,7 +983,7 @@ var __exports__ = (() => {
       this.handle.end();
     }
     setPipeline(pipeline) {
-      this.pipeline = (0, import_core11.cast)(pipeline);
+      this.pipeline = (0, import_core12.cast)(pipeline);
       this.handle.setPipeline(this.pipeline.handle);
     }
     /** Sets an array of bindings (uniform buffers, samplers, textures, ...) */
@@ -1032,10 +995,10 @@ var __exports__ = (() => {
       }
     }
     setIndexBuffer(buffer, indexFormat, offset = 0, size) {
-      this.handle.setIndexBuffer((0, import_core11.cast)(buffer).handle, indexFormat, offset, size);
+      this.handle.setIndexBuffer((0, import_core12.cast)(buffer).handle, indexFormat, offset, size);
     }
     setVertexBuffer(slot, buffer, offset = 0) {
-      this.handle.setVertexBuffer(slot, (0, import_core11.cast)(buffer).handle, offset);
+      this.handle.setVertexBuffer(slot, (0, import_core12.cast)(buffer).handle, offset);
     }
     draw(options) {
       if (options.indexCount) {
@@ -1137,11 +1100,11 @@ var __exports__ = (() => {
   };
 
   // src/adapter/resources/webgpu-compute-pass.ts
-  var import_core12 = __toESM(require_core(), 1);
-  var WebGPUComputePass = class extends import_core12.ComputePass {
+  var import_core13 = __toESM(require_core(), 1);
+  var WebGPUComputePass = class extends import_core13.ComputePass {
     device;
     handle;
-    _bindGroupLayout = null;
+    _webgpuPipeline = null;
     constructor(device, props) {
       super(device, props);
       this.device = device;
@@ -1170,29 +1133,36 @@ var __exports__ = (() => {
     setPipeline(pipeline) {
       const wgpuPipeline = pipeline;
       this.handle.setPipeline(wgpuPipeline.handle);
-      this._bindGroupLayout = wgpuPipeline._getBindGroupLayout();
+      this._webgpuPipeline = wgpuPipeline;
+      this.setBindings([]);
     }
-    /** Sets an array of bindings (uniform buffers, samplers, textures, ...) */
+    /**
+     * Sets an array of bindings (uniform buffers, samplers, textures, ...)
+     * TODO - still some API confusion - does this method go here or on the pipeline?
+     */
     setBindings(bindings) {
-      throw new Error("fix me");
+      const bindGroup = this._webgpuPipeline._getBindGroup();
+      this.handle.setBindGroup(0, bindGroup);
     }
     /**
      * Dispatch work to be performed with the current ComputePipeline.
-     * @param x X dimension of the grid of workgroups to dispatch.
-     * @param y Y dimension of the grid of workgroups to dispatch.
-     * @param z Z dimension of the grid of workgroups to dispatch.
+     * @param x X dimension of the grid of work groups to dispatch.
+     * @param y Y dimension of the grid of work groups to dispatch.
+     * @param z Z dimension of the grid of work groups to dispatch.
      */
     dispatch(x, y, z) {
       this.handle.dispatchWorkgroups(x, y, z);
     }
     /**
      * Dispatch work to be performed with the current ComputePipeline.
-     * @param indirectBuffer buffer must be a tightly packed block of three 32-bit unsigned integer values (12 bytes total), given in the same order as the arguments for dispatch()
-     * @param indirectOffset
+     *
+     * Buffer must be a tightly packed block of three 32-bit unsigned integer values (12 bytes total), given in the same order as the arguments for dispatch()
+     * @param indirectBuffer
+     * @param indirectOffset offset in buffer to the beginning of the dispatch data.
      */
-    dispatchIndirect(indirectBuffer, indirectOffset = 0) {
+    dispatchIndirect(indirectBuffer, indirectByteOffset = 0) {
       const webgpuBuffer = indirectBuffer;
-      this.handle.dispatchWorkgroupsIndirect(webgpuBuffer.handle, indirectOffset);
+      this.handle.dispatchWorkgroupsIndirect(webgpuBuffer.handle, indirectByteOffset);
     }
     pushDebugGroup(groupLabel) {
       this.handle.pushDebugGroup(groupLabel);
@@ -1206,14 +1176,16 @@ var __exports__ = (() => {
   };
 
   // src/adapter/resources/webgpu-vertex-array.ts
-  var import_core13 = __toESM(require_core(), 1);
+  var import_core14 = __toESM(require_core(), 1);
 
   // ../../node_modules/@probe.gl/env/dist/lib/is-electron.js
   function isElectron(mockUserAgent) {
-    if (typeof window !== "undefined" && typeof window.process === "object" && window.process.type === "renderer") {
+    if (typeof window !== "undefined" && typeof window.process === "object" && // @ts-expect-error
+    window.process.type === "renderer") {
       return true;
     }
-    if (typeof process !== "undefined" && typeof process.versions === "object" && Boolean(process.versions["electron"])) {
+    if (typeof process !== "undefined" && typeof process.versions === "object" && // eslint-disable-next-line
+    Boolean(process.versions["electron"])) {
       return true;
     }
     const realUserAgent = typeof navigator === "object" && typeof navigator.userAgent === "string" && navigator.userAgent;
@@ -1226,7 +1198,10 @@ var __exports__ = (() => {
 
   // ../../node_modules/@probe.gl/env/dist/lib/is-browser.js
   function isBrowser() {
-    const isNode = typeof process === "object" && String(process) === "[object process]" && !process.browser;
+    const isNode = (
+      // @ts-expect-error
+      typeof process === "object" && String(process) === "[object process]" && !process.browser
+    );
     return !isNode || isElectron();
   }
 
@@ -1269,7 +1244,7 @@ var __exports__ = (() => {
   }
 
   // src/adapter/resources/webgpu-vertex-array.ts
-  var WebGPUVertexArray = class extends import_core13.VertexArray {
+  var WebGPUVertexArray = class extends import_core14.VertexArray {
     get [Symbol.toStringTag]() {
       return "WebGPUVertexArray";
     }
@@ -1298,7 +1273,7 @@ var __exports__ = (() => {
       const webgpuRenderPass = renderPass;
       const webgpuIndexBuffer = this.indexBuffer;
       if (webgpuIndexBuffer?.handle) {
-        import_core13.log.warn("setting index buffer", webgpuIndexBuffer?.handle, webgpuIndexBuffer?.indexType)();
+        import_core14.log.warn("setting index buffer", webgpuIndexBuffer?.handle, webgpuIndexBuffer?.indexType)();
         webgpuRenderPass.handle.setIndexBuffer(
           webgpuIndexBuffer?.handle,
           webgpuIndexBuffer?.indexType
@@ -1307,7 +1282,7 @@ var __exports__ = (() => {
       for (let location = 0; location < this.maxVertexAttributes; location++) {
         const webgpuBuffer = this.attributes[location];
         if (webgpuBuffer?.handle) {
-          import_core13.log.warn(`setting vertex buffer ${location}`, webgpuBuffer?.handle)();
+          import_core14.log.warn(`setting vertex buffer ${location}`, webgpuBuffer?.handle)();
           webgpuRenderPass.handle.setVertexBuffer(location, webgpuBuffer?.handle);
         }
       }
@@ -1326,19 +1301,6 @@ var __exports__ = (() => {
 
   // src/adapter/webgpu-canvas-context.ts
   var import_core15 = __toESM(require_core(), 1);
-
-  // src/adapter/resources/webgpu-framebuffer.ts
-  var import_core14 = __toESM(require_core(), 1);
-  var WebGPUFramebuffer = class extends import_core14.Framebuffer {
-    device;
-    constructor(device, props) {
-      super(device, props);
-      this.device = device;
-      this.autoCreateAttachmentTextures();
-    }
-  };
-
-  // src/adapter/webgpu-canvas-context.ts
   var WebGPUCanvasContext = class extends import_core15.CanvasContext {
     device;
     gpuCanvasContext;
@@ -1401,7 +1363,8 @@ var __exports__ = (() => {
     getCurrentTexture() {
       return this.device._createTexture({
         id: `${this.id}#color-texture`,
-        handle: this.gpuCanvasContext.getCurrentTexture()
+        handle: this.gpuCanvasContext.getCurrentTexture(),
+        format: this.format
       });
     }
     /** We build render targets on demand (i.e. not when size changes but when about to render) */
@@ -1434,12 +1397,15 @@ var __exports__ = (() => {
       this.handle.label = this.props.id;
     }
     destroy() {
-      this.handle.destroy();
+      this.handle?.destroy();
+      this.handle = null;
     }
   };
 
   // src/adapter/webgpu-device.ts
   var _WebGPUDevice = class extends import_core17.Device {
+    /** type of this device */
+    type = "webgpu";
     /** The underlying WebGPU device */
     handle;
     /* The underlying WebGPU adapter */
@@ -1476,7 +1442,7 @@ var __exports__ = (() => {
       import_core17.log.probe(2, "Adapter available", adapterInfo)();
       const requiredFeatures = [];
       const requiredLimits = {};
-      if (props.requestMaximalLimits) {
+      if (props.requestMaxLimits) {
         requiredFeatures.push(...Array.from(adapter.features));
         for (const key in adapter.limits) {
           requiredLimits[key] = adapter.limits[key];
@@ -1534,7 +1500,7 @@ var __exports__ = (() => {
     }
     /** @todo implement proper check? */
     isTextureFormatFilterable(format) {
-      return this.isTextureFormatSupported(format);
+      return this.isTextureFormatSupported(format) && !format.startsWith("depth") && !format.startsWith("stencil");
     }
     /** @todo implement proper check? */
     isTextureFormatRenderable(format) {
@@ -1563,7 +1529,7 @@ var __exports__ = (() => {
       return new WebGPURenderPipeline(this, props);
     }
     createFramebuffer(props) {
-      throw new Error("Not implemented");
+      return new WebGPUFramebuffer(this, props);
     }
     createComputePipeline(props) {
       return new WebGPUComputePipeline(this, props);
@@ -1596,15 +1562,6 @@ var __exports__ = (() => {
     createCanvasContext(props) {
       return new WebGPUCanvasContext(this, this.adapter, props);
     }
-    /**
-     * Gets default renderpass encoder.
-     * Creates a new encoder against default canvasContext if not already created
-     * @note Called internally by Model.
-     * @deprecated Create explicit pass with device.beginRenderPass
-     */
-    getDefaultRenderPass() {
-      throw new Error("a");
-    }
     submit() {
       const commandBuffer = this.commandEncoder?.finish();
       if (commandBuffer) {
@@ -1656,7 +1613,7 @@ var __exports__ = (() => {
       for (const feature of WEBGPU_ALWAYS_FEATURES) {
         features.add(feature);
       }
-      return new import_core17.DeviceFeatures(Array.from(features));
+      return new import_core17.DeviceFeatures(Array.from(features), this.props.disabledFeatures);
     }
     copyExternalImageToTexture(options) {
       const {