@luma.gl/webgpu 9.2.5 → 9.3.0-alpha.2

package/dist/index.cjs

@@ -267,11 +267,8 @@ var init_webgpu_texture = __esm({
       sampler;
       view;
       constructor(device, props) {
-        super(device, props);
+        super(device, props, { byteAlignment: 256 });
         this.device = device;
-        if (this.dimension === "cube") {
-          this.depth = 6;
-        }
         this.device.pushErrorScope("out-of-memory");
         this.device.pushErrorScope("validation");
         this.handle = this.props.handle || this.device.handle.createTexture({
@@ -318,6 +315,36 @@ var init_webgpu_texture = __esm({
       createView(props) {
         return new WebGPUTextureView(this.device, { ...props, texture: this });
       }
+      copyExternalImage(options_) {
+        const options = this._normalizeCopyExternalImageOptions(options_);
+        this.device.pushErrorScope("validation");
+        this.device.handle.queue.copyExternalImageToTexture(
+          // source: GPUImageCopyExternalImage
+          {
+            source: options.image,
+            origin: [options.sourceX, options.sourceY],
+            flipY: false
+            // options.flipY
+          },
+          // destination: GPUImageCopyTextureTagged
+          {
+            texture: this.handle,
+            origin: [options.x, options.y, options.z],
+            mipLevel: options.mipLevel,
+            aspect: options.aspect,
+            colorSpace: options.colorSpace,
+            premultipliedAlpha: options.premultipliedAlpha
+          },
+          // copySize: GPUExtent3D
+          [options.width, options.height, options.depth]
+          // depth is always 1 for 2D textures
+        );
+        this.device.popErrorScope((error) => {
+          this.device.reportError(new Error(`copyExternalImage: ${error.message}`), this)();
+          this.device.debug();
+        });
+        return { width: options.width, height: options.height };
+      }
       copyImageData(options_) {
         const { width, height, depth } = this;
         const options = this._normalizeCopyImageDataOptions(options_);
@@ -348,37 +375,118 @@ var init_webgpu_texture = __esm({
           this.device.debug();
         });
       }
-      copyExternalImage(options_) {
-        const options = this._normalizeCopyExternalImageOptions(options_);
+      generateMipmapsWebGL() {
+        import_core4.log.warn(`${this}: generateMipmaps not supported in WebGPU`)();
+      }
+      getImageDataLayout(options) {
+        return {
+          byteLength: 0,
+          bytesPerRow: 0,
+          rowsPerImage: 0
+        };
+      }
+      readBuffer(options = {}, buffer) {
+        const { x = 0, y = 0, z = 0, width = this.width, height = this.height, depthOrArrayLayers = this.depth, mipLevel = 0, aspect = "all" } = options;
+        const layout = this.computeMemoryLayout(options);
+        const { bytesPerRow, rowsPerImage, byteLength } = layout;
+        const readBuffer = buffer || this.device.createBuffer({
+          byteLength,
+          usage: import_core4.Buffer.COPY_DST | import_core4.Buffer.MAP_READ
+        });
+        const gpuReadBuffer = readBuffer.handle;
+        const gpuDevice = this.device.handle;
         this.device.pushErrorScope("validation");
-        this.device.handle.queue.copyExternalImageToTexture(
-          // source: GPUImageCopyExternalImage
+        const commandEncoder = gpuDevice.createCommandEncoder();
+        commandEncoder.copyTextureToBuffer(
+          // source
           {
-            source: options.image,
-            origin: [options.sourceX, options.sourceY],
-            flipY: options.flipY
+            texture: this.handle,
+            origin: { x, y, z },
+            // origin: [options.x, options.y, 0], // options.depth],
+            mipLevel,
+            aspect
+            // colorSpace: options.colorSpace,
+            // premultipliedAlpha: options.premultipliedAlpha
           },
-          // destination: GPUImageCopyTextureTagged
+          // destination
           {
-            texture: this.handle,
-            origin: [options.x, options.y, 0],
-            // options.depth],
-            mipLevel: options.mipLevel,
-            aspect: options.aspect,
-            colorSpace: options.colorSpace,
-            premultipliedAlpha: options.premultipliedAlpha
+            buffer: gpuReadBuffer,
+            offset: 0,
+            bytesPerRow,
+            rowsPerImage
           },
-          // copySize: GPUExtent3D
-          [options.width, options.height, 1]
+          // copy size
+          {
+            width,
+            height,
+            depthOrArrayLayers
+          }
         );
+        const commandBuffer = commandEncoder.finish();
+        this.device.handle.queue.submit([commandBuffer]);
         this.device.popErrorScope((error) => {
-          this.device.reportError(new Error(`copyExternalImage: ${error.message}`), this)();
+          this.device.reportError(new Error(`${this} readBuffer: ${error.message}`), this)();
+          this.device.debug();
+        });
+        return readBuffer;
+      }
+      async readDataAsync(options = {}) {
+        const buffer = this.readBuffer(options);
+        const data = await buffer.readAsync();
+        buffer.destroy();
+        return data.buffer;
+      }
+      writeBuffer(buffer, options = {}) {
+        const { x = 0, y = 0, z = 0, width = this.width, height = this.height, depthOrArrayLayers = this.depth, mipLevel = 0, aspect = "all" } = options;
+        const layout = this.computeMemoryLayout(options);
+        const { bytesPerRow, rowsPerImage } = layout;
+        const gpuDevice = this.device.handle;
+        this.device.pushErrorScope("validation");
+        const commandEncoder = gpuDevice.createCommandEncoder();
+        commandEncoder.copyBufferToTexture({
+          buffer: buffer.handle,
+          offset: 0,
+          bytesPerRow,
+          rowsPerImage
+        }, {
+          texture: this.handle,
+          origin: { x, y, z },
+          mipLevel,
+          aspect
+        }, { width, height, depthOrArrayLayers });
+        const commandBuffer = commandEncoder.finish();
+        this.device.handle.queue.submit([commandBuffer]);
+        this.device.popErrorScope((error) => {
+          this.device.reportError(new Error(`${this} writeBuffer: ${error.message}`), this)();
           this.device.debug();
         });
-        return { width: options.width, height: options.height };
       }
-      generateMipmapsWebGL() {
-        import_core4.log.warn(`${this}: generateMipmaps not supported in WebGPU`)();
+      writeData(data, options = {}) {
+        const device = this.device;
+        const { x = 0, y = 0, z = 0, width = this.width, height = this.height, depthOrArrayLayers = this.depth, mipLevel = 0, aspect = "all" } = options;
+        const layout = import_core4.textureFormatDecoder.computeMemoryLayout({
+          format: this.format,
+          width: this.width,
+          height: this.height,
+          depth: this.depth,
+          byteAlignment: this.byteAlignment
+        });
+        const { bytesPerRow, rowsPerImage } = layout;
+        this.device.pushErrorScope("validation");
+        device.handle.queue.writeTexture({
+          texture: this.handle,
+          mipLevel,
+          aspect,
+          origin: { x, y, z }
+        }, data, {
+          offset: 0,
+          bytesPerRow,
+          rowsPerImage
+        }, { width, height, depthOrArrayLayers });
+        this.device.popErrorScope((error) => {
+          this.device.reportError(new Error(`${this} writeData: ${error.message}`), this)();
+          this.device.debug();
+        });
       }
     };
   }
@@ -1164,18 +1272,34 @@ var init_webgpu_canvas_context = __esm({
         this.device = device;
         this.handle = context;
         this._setAutoCreatedCanvasId(`${this.device.id}-canvas`);
-        this._updateDevice();
+        this._configureDevice();
       }
       /** Destroy any textures produced while configured and remove the context configuration. */
       destroy() {
         this.handle.unconfigure();
         super.destroy();
       }
+      // IMPLEMENTATION OF ABSTRACT METHODS
+      /** @see https://www.w3.org/TR/webgpu/#canvas-configuration */
+      _configureDevice() {
+        if (this.depthStencilAttachment) {
+          this.depthStencilAttachment.destroy();
+          this.depthStencilAttachment = null;
+        }
+        this.handle.configure({
+          device: this.device.handle,
+          format: this.device.preferredColorFormat,
+          // Can be used to define e.g. -srgb views
+          // viewFormats: [...]
+          colorSpace: this.props.colorSpace,
+          alphaMode: this.props.alphaMode
+        });
+      }
       /** Update framebuffer with properly resized "swap chain" texture views */
-      getCurrentFramebuffer(options = {
+      _getCurrentFramebuffer(options = {
         depthStencilFormat: "depth24plus"
       }) {
-        const currentColorAttachment = this.getCurrentTexture();
+        const currentColorAttachment = this._getCurrentTexture();
         if (currentColorAttachment.width !== this.drawingBufferWidth || currentColorAttachment.height !== this.drawingBufferHeight) {
           const [oldWidth, oldHeight] = this.getDrawingBufferSize();
           this.drawingBufferWidth = currentColorAttachment.width;
@@ -1190,23 +1314,9 @@ var init_webgpu_canvas_context = __esm({
           depthStencilAttachment: this.depthStencilAttachment
         });
       }
-      // IMPLEMENTATION OF ABSTRACT METHODS
-      _updateDevice() {
-        if (this.depthStencilAttachment) {
-          this.depthStencilAttachment.destroy();
-          this.depthStencilAttachment = null;
-        }
-        this.handle.configure({
-          device: this.device.handle,
-          format: this.device.preferredColorFormat,
-          // Can be used to define e.g. -srgb views
-          // viewFormats: [...]
-          colorSpace: this.props.colorSpace,
-          alphaMode: this.props.alphaMode
-        });
-      }
+      // PRIMARY METHODS
       /** Wrap the current canvas context texture in a luma.gl texture */
-      getCurrentTexture() {
+      _getCurrentTexture() {
         const handle = this.handle.getCurrentTexture();
         return this.device.createTexture({
           id: `${this.id}#color-texture`,
@@ -1725,16 +1835,154 @@ var init_webgpu_pipeline_layout = __esm({
   }
 });
 
+// dist/adapter/resources/webgpu-fence.js
+var import_core21, WebGPUFence;
+var init_webgpu_fence = __esm({
+  "dist/adapter/resources/webgpu-fence.js"() {
+    "use strict";
+    import_core21 = require("@luma.gl/core");
+    WebGPUFence = class extends import_core21.Fence {
+      device;
+      handle = null;
+      signaled;
+      _signaled = false;
+      constructor(device, props = {}) {
+        super(device, {});
+        this.device = device;
+        this.signaled = device.handle.queue.onSubmittedWorkDone().then(() => {
+          this._signaled = true;
+        });
+      }
+      isSignaled() {
+        return this._signaled;
+      }
+      destroy() {
+      }
+    };
+  }
+});
+
+// dist/wgsl/get-shader-layout-wgsl.js
+function getShaderLayoutFromWGSL(source) {
+  var _a;
+  const shaderLayout = { attributes: [], bindings: [] };
+  let parsedWGSL;
+  try {
+    parsedWGSL = parseWGSL(source);
+  } catch (error) {
+    import_core22.log.error(error.message)();
+    return shaderLayout;
+  }
+  for (const uniform of parsedWGSL.uniforms) {
+    const members = [];
+    for (const attribute of ((_a = uniform.type) == null ? void 0 : _a.members) || []) {
+      members.push({
+        name: attribute.name,
+        type: getType(attribute.type)
+      });
+    }
+    shaderLayout.bindings.push({
+      type: "uniform",
+      name: uniform.name,
+      group: uniform.group,
+      location: uniform.binding,
+      // @ts-expect-error TODO - unused for now but needs fixing
+      members
+    });
+  }
+  for (const texture of parsedWGSL.textures) {
+    const bindingDeclaration = {
+      type: "texture",
+      name: texture.name,
+      group: texture.group,
+      location: texture.binding,
+      ...getTextureBindingFromReflect(texture)
+    };
+    shaderLayout.bindings.push(bindingDeclaration);
+  }
+  for (const sampler of parsedWGSL.samplers) {
+    shaderLayout.bindings.push({
+      type: "sampler",
+      name: sampler.name,
+      group: sampler.group,
+      location: sampler.binding
+    });
+  }
+  const vertex = parsedWGSL.entry.vertex[0];
+  const attributeCount = (vertex == null ? void 0 : vertex.inputs.length) || 0;
+  for (let i = 0; i < attributeCount; i++) {
+    const wgslAttribute = vertex.inputs[i];
+    if (wgslAttribute.locationType === "location") {
+      const type = getType(wgslAttribute.type);
+      shaderLayout.attributes.push({
+        name: wgslAttribute.name,
+        location: Number(wgslAttribute.location),
+        type
+      });
+    }
+  }
+  return shaderLayout;
+}
+function getType(type) {
+  return (type == null ? void 0 : type.format) ? `${type.name}<${type.format.name}>` : type.name;
+}
+function parseWGSL(source) {
+  try {
+    return new import_wgsl_reflect.WgslReflect(source);
+  } catch (error) {
+    if (error instanceof Error) {
+      throw error;
+    }
+    let message = "WGSL parse error";
+    if (typeof error === "object" && (error == null ? void 0 : error.message)) {
+      message += `: ${error.message} `;
+    }
+    if (typeof error === "object" && (error == null ? void 0 : error.token)) {
+      message += error.token.line || "";
+    }
+    throw new Error(message, { cause: error });
+  }
+}
+function getTextureBindingFromReflect(v, opts) {
+  var _a;
+  if (v.resourceType !== import_wgsl_reflect.ResourceType.Texture) {
+    throw new Error("Not a texture binding");
+  }
+  const typeName = v.type.name;
+  const component = (_a = v.type.format) == null ? void 0 : _a.name;
+  const viewDimension = typeName.includes("cube_array") ? "cube-array" : typeName.includes("cube") ? "cube" : typeName.includes("2d_array") ? "2d-array" : typeName.includes("3d") ? "3d" : typeName.includes("1d") ? "1d" : "2d";
+  const multisampled = typeName === "texture_multisampled_2d";
+  let sampleType;
+  if (typeName.startsWith("texture_depth")) {
+    sampleType = "depth";
+  } else if (component === "i32") {
+    sampleType = "sint";
+  } else if (component === "u32") {
+    sampleType = "uint";
+  } else {
+    sampleType = "float";
+  }
+  return { viewDimension, sampleType, multisampled };
+}
+var import_core22, import_wgsl_reflect;
+var init_get_shader_layout_wgsl = __esm({
+  "dist/wgsl/get-shader-layout-wgsl.js"() {
+    "use strict";
+    import_core22 = require("@luma.gl/core");
+    import_wgsl_reflect = require("wgsl_reflect");
+  }
+});
+
 // dist/adapter/webgpu-device.js
 var webgpu_device_exports = {};
 __export(webgpu_device_exports, {
   WebGPUDevice: () => WebGPUDevice
 });
-var import_core21, WebGPUDevice;
+var import_core23, WebGPUDevice;
 var init_webgpu_device = __esm({
   "dist/adapter/webgpu-device.js"() {
     "use strict";
-    import_core21 = require("@luma.gl/core");
+    import_core23 = require("@luma.gl/core");
     init_webgpu_buffer();
     init_webgpu_texture();
     init_webgpu_external_texture();
@@ -1748,7 +1996,9 @@ var init_webgpu_device = __esm({
     init_webgpu_command_encoder();
     init_webgpu_query_set();
     init_webgpu_pipeline_layout();
-    WebGPUDevice = class extends import_core21.Device {
+    init_webgpu_fence();
+    init_get_shader_layout_wgsl();
+    WebGPUDevice = class extends import_core23.Device {
       /** The underlying WebGPU device */
       handle;
       /* The underlying WebGPU adapter */
@@ -1791,7 +2041,7 @@ var init_webgpu_device = __esm({
           this._isLost = true;
           resolve({ reason: "destroyed", message: lostInfo.message });
         });
-        const canvasContextProps = import_core21.Device._getCanvasContextProps(props);
+        const canvasContextProps = import_core23.Device._getCanvasContextProps(props);
         if (canvasContextProps) {
           this.canvasContext = new WebGPUCanvasContext(this, this.adapter, canvasContextProps);
         }
@@ -1807,13 +2057,13 @@ var init_webgpu_device = __esm({
       get isLost() {
         return this._isLost;
       }
+      getShaderLayout(source) {
+        return getShaderLayoutFromWGSL(source);
+      }
       isVertexFormatSupported(format) {
         const info = this.getVertexFormatInfo(format);
         return !info.webglOnly;
       }
-      getTextureByteAlignment() {
-        return 1;
-      }
       createBuffer(props) {
         const newProps = this._normalizeBufferProps(props);
         return new WebGPUBuffer(this, newProps);
@@ -1852,6 +2102,9 @@ var init_webgpu_device = __esm({
       createQuerySet(props) {
         return new WebGPUQuerySet(this, props);
       }
+      createFence() {
+        return new WebGPUFence(this);
+      }
       createCanvasContext(props) {
         return new WebGPUCanvasContext(this, this.adapter, props);
       }
@@ -1914,6 +2167,12 @@ var init_webgpu_device = __esm({
         if (features.has("texture-compression-bc")) {
           features.add("texture-compression-bc5-webgl");
         }
+        if (this.handle.features.has("chromium-experimental-norm16-texture-formats")) {
+          features.add("norm16-renderable-webgl");
+        }
+        if (this.handle.features.has("chromium-experimental-snorm16-texture-formats")) {
+          features.add("snorm16-renderable-webgl");
+        }
         const WEBGPU_ALWAYS_FEATURES = [
           "timer-query-webgl",
           "compilation-status-async-webgl",
@@ -1926,7 +2185,7 @@ var init_webgpu_device = __esm({
         for (const feature of WEBGPU_ALWAYS_FEATURES) {
           features.add(feature);
         }
-        return new import_core21.DeviceFeatures(Array.from(features), this.props._disabledFeatures);
+        return new import_core23.DeviceFeatures(Array.from(features), this.props._disabledFeatures);
       }
       _getDeviceSpecificTextureFormatCapabilities(capabilities) {
         const { format } = capabilities;
@@ -1944,16 +2203,18 @@ var dist_exports = {};
 __export(dist_exports, {
   WebGPUBuffer: () => WebGPUBuffer,
   WebGPUDevice: () => WebGPUDevice,
+  WebGPUFence: () => WebGPUFence,
   WebGPUSampler: () => WebGPUSampler,
   WebGPUShader: () => WebGPUShader,
   WebGPUTexture: () => WebGPUTexture,
+  getShaderLayoutFromWGSL: () => getShaderLayoutFromWGSL,
   webgpuAdapter: () => webgpuAdapter
 });
 module.exports = __toCommonJS(dist_exports);
 
 // dist/adapter/webgpu-adapter.js
-var import_core22 = require("@luma.gl/core");
-var WebGPUAdapter = class extends import_core22.Adapter {
+var import_core24 = require("@luma.gl/core");
+var WebGPUAdapter = class extends import_core24.Adapter {
   /** type of device's created by this adapter */
   type = "webgpu";
   isSupported() {
@@ -1973,43 +2234,41 @@ var WebGPUAdapter = class extends import_core22.Adapter {
     if (!navigator.gpu) {
       throw new Error("WebGPU not available. Recent Chrome browsers should work.");
     }
-    import_core22.log.groupCollapsed(1, "WebGPUDevice created")();
-    try {
-      const adapter = await navigator.gpu.requestAdapter({
-        powerPreference: "high-performance"
-        // forceSoftware: false
-      });
-      if (!adapter) {
-        throw new Error("Failed to request WebGPU adapter");
-      }
-      const adapterInfo = adapter.info || // @ts-ignore
-      await ((_a = adapter.requestAdapterInfo) == null ? void 0 : _a.call(adapter));
-      import_core22.log.probe(2, "Adapter available", adapterInfo)();
-      const requiredFeatures = [];
-      const requiredLimits = {};
-      if (props._requestMaxLimits) {
-        requiredFeatures.push(...Array.from(adapter.features));
-        const limits = Object.keys(adapter.limits).filter((key) => !["minSubgroupSize", "maxSubgroupSize"].includes(key));
-        for (const key of limits) {
-          const limit = key;
-          const value = adapter.limits[limit];
-          if (typeof value === "number") {
-            requiredLimits[limit] = value;
-          }
+    const adapter = await navigator.gpu.requestAdapter({
+      powerPreference: "high-performance"
+      // forceSoftware: false
+    });
+    if (!adapter) {
+      throw new Error("Failed to request WebGPU adapter");
+    }
+    const adapterInfo = adapter.info || // @ts-ignore
+    await ((_a = adapter.requestAdapterInfo) == null ? void 0 : _a.call(adapter));
+    const requiredFeatures = [];
+    const requiredLimits = {};
+    if (props._requestMaxLimits) {
+      requiredFeatures.push(...Array.from(adapter.features));
+      const limits = Object.keys(adapter.limits).filter((key) => !["minSubgroupSize", "maxSubgroupSize"].includes(key));
+      for (const key of limits) {
+        const limit = key;
+        const value = adapter.limits[limit];
+        if (typeof value === "number") {
+          requiredLimits[limit] = value;
         }
       }
-      const gpuDevice = await adapter.requestDevice({
-        requiredFeatures,
-        requiredLimits
-      });
-      import_core22.log.probe(1, "GPUDevice available")();
-      const { WebGPUDevice: WebGPUDevice2 } = await Promise.resolve().then(() => (init_webgpu_device(), webgpu_device_exports));
+    }
+    const gpuDevice = await adapter.requestDevice({
+      requiredFeatures,
+      requiredLimits
+    });
+    const { WebGPUDevice: WebGPUDevice2 } = await Promise.resolve().then(() => (init_webgpu_device(), webgpu_device_exports));
+    import_core24.log.groupCollapsed(1, "WebGPUDevice created")();
+    try {
       const device = new WebGPUDevice2(props, gpuDevice, adapter, adapterInfo);
-      import_core22.log.probe(1, "Device created. For more info, set chrome://flags/#enable-webgpu-developer-features")();
-      import_core22.log.table(1, device.info)();
+      import_core24.log.probe(1, "Device created. For more info, set chrome://flags/#enable-webgpu-developer-features")();
+      import_core24.log.table(1, device.info)();
       return device;
     } finally {
-      import_core22.log.groupEnd(1)();
+      import_core24.log.groupEnd(1)();
     }
   }
   async attach(handle) {
@@ -2024,4 +2283,6 @@ init_webgpu_buffer();
 init_webgpu_texture();
 init_webgpu_sampler();
 init_webgpu_shader();
+init_webgpu_fence();
+init_get_shader_layout_wgsl();
 //# sourceMappingURL=index.cjs.map