@luma.gl/webgpu 9.2.6 → 9.3.0-alpha.4

package/dist/index.cjs

@@ -7,8 +7,8 @@ var __esm = (fn, res) => function __init() {
   return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
 };
 var __export = (target, all) => {
-  for (var name2 in all)
-    __defProp(target, name2, { get: all[name2], enumerable: true });
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
 };
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
@@ -30,13 +30,15 @@ var init_webgpu_buffer = __esm({
       device;
       handle;
       byteLength;
+      paddedByteLength;
       constructor(device, props) {
         var _a, _b;
         super(device, props);
         this.device = device;
         this.byteLength = props.byteLength || ((_a = props.data) == null ? void 0 : _a.byteLength) || 0;
+        this.paddedByteLength = Math.ceil(this.byteLength / 4) * 4;
         const mappedAtCreation = Boolean(this.props.onMapped || props.data);
-        const size = Math.ceil(this.byteLength / 4) * 4;
+        const size = this.paddedByteLength;
         this.device.pushErrorScope("out-of-memory");
         this.device.pushErrorScope("validation");
         this.handle = this.props.handle || this.device.handle.createBuffer({
@@ -89,18 +91,21 @@ var init_webgpu_buffer = __esm({
         });
       }
       async mapAndWriteAsync(callback, byteOffset = 0, byteLength = this.byteLength - byteOffset) {
+        const alignedByteLength = Math.ceil(byteLength / 4) * 4;
         const isMappable = (this.usage & import_core.Buffer.MAP_WRITE) !== 0;
-        const mappableBuffer = !isMappable ? this._getMappableBuffer(import_core.Buffer.MAP_WRITE | import_core.Buffer.COPY_SRC, 0, this.byteLength) : null;
+        const mappableBuffer = !isMappable ? this._getMappableBuffer(import_core.Buffer.MAP_WRITE | import_core.Buffer.COPY_SRC, 0, this.paddedByteLength) : null;
         const writeBuffer = mappableBuffer || this;
         this.device.pushErrorScope("validation");
         try {
           await this.device.handle.queue.onSubmittedWorkDone();
-          await writeBuffer.handle.mapAsync(GPUMapMode.WRITE, byteOffset, byteLength);
-          const arrayBuffer = writeBuffer.handle.getMappedRange(byteOffset, byteLength);
+          await writeBuffer.handle.mapAsync(GPUMapMode.WRITE, byteOffset, alignedByteLength);
+          const mappedRange = writeBuffer.handle.getMappedRange(byteOffset, alignedByteLength);
+          const arrayBuffer = mappedRange.slice(0, byteLength);
           await callback(arrayBuffer, "mapped");
+          new Uint8Array(mappedRange).set(new Uint8Array(arrayBuffer), 0);
           writeBuffer.handle.unmap();
           if (mappableBuffer) {
-            this._copyBuffer(mappableBuffer, byteOffset, byteLength);
+            this._copyBuffer(mappableBuffer, byteOffset, alignedByteLength);
           }
         } finally {
           this.device.popErrorScope((error) => {
@@ -114,24 +119,37 @@ var init_webgpu_buffer = __esm({
         return this.mapAndReadAsync((arrayBuffer) => new Uint8Array(arrayBuffer.slice(0)), byteOffset, byteLength);
       }
       async mapAndReadAsync(callback, byteOffset = 0, byteLength = this.byteLength - byteOffset) {
+        const requestedEnd = byteOffset + byteLength;
+        if (requestedEnd > this.byteLength) {
+          throw new Error("Mapping range exceeds buffer size");
+        }
+        let mappedByteOffset = byteOffset;
+        let mappedByteLength = byteLength;
+        let sliceByteOffset = 0;
+        let lifetime = "mapped";
         if (byteOffset % 8 !== 0 || byteLength % 4 !== 0) {
-          throw new Error("byteOffset must be multiple of 8 and byteLength multiple of 4");
+          mappedByteOffset = Math.floor(byteOffset / 8) * 8;
+          const alignedEnd = Math.ceil(requestedEnd / 4) * 4;
+          mappedByteLength = alignedEnd - mappedByteOffset;
+          sliceByteOffset = byteOffset - mappedByteOffset;
+          lifetime = "copied";
         }
-        if (byteOffset + byteLength > this.handle.size) {
+        if (mappedByteOffset + mappedByteLength > this.paddedByteLength) {
           throw new Error("Mapping range exceeds buffer size");
         }
         const isMappable = (this.usage & import_core.Buffer.MAP_READ) !== 0;
-        const mappableBuffer = !isMappable ? this._getMappableBuffer(import_core.Buffer.MAP_READ | import_core.Buffer.COPY_DST, 0, this.byteLength) : null;
+        const mappableBuffer = !isMappable ? this._getMappableBuffer(import_core.Buffer.MAP_READ | import_core.Buffer.COPY_DST, 0, this.paddedByteLength) : null;
         const readBuffer = mappableBuffer || this;
         this.device.pushErrorScope("validation");
         try {
           await this.device.handle.queue.onSubmittedWorkDone();
           if (mappableBuffer) {
-            mappableBuffer._copyBuffer(this);
+            mappableBuffer._copyBuffer(this, mappedByteOffset, mappedByteLength);
           }
-          await readBuffer.handle.mapAsync(GPUMapMode.READ, byteOffset, byteLength);
-          const arrayBuffer = readBuffer.handle.getMappedRange(byteOffset, byteLength);
-          const result = await callback(arrayBuffer, "mapped");
+          await readBuffer.handle.mapAsync(GPUMapMode.READ, mappedByteOffset, mappedByteLength);
+          const arrayBuffer = readBuffer.handle.getMappedRange(mappedByteOffset, mappedByteLength);
+          const mappedRange = lifetime === "mapped" ? arrayBuffer : arrayBuffer.slice(sliceByteOffset, sliceByteOffset + byteLength);
+          const result = await callback(mappedRange, lifetime);
           readBuffer.handle.unmap();
           return result;
         } finally {
@@ -267,11 +285,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 +333,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 +393,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();
+        });
       }
     };
   }
@@ -716,7 +842,7 @@ function getBindGroupEntries(bindings, shaderLayout) {
   for (const [bindingName, value] of Object.entries(bindings)) {
     let bindingLayout = getShaderLayoutBinding(shaderLayout, bindingName);
     if (bindingLayout) {
-      const entry = getBindGroupEntry(value, bindingLayout.location);
+      const entry = getBindGroupEntry(value, bindingLayout.location, void 0, bindingName);
       if (entry) {
         entries.push(entry);
       }
@@ -726,7 +852,7 @@ function getBindGroupEntries(bindings, shaderLayout) {
         ignoreWarnings: true
       });
       if (bindingLayout) {
-        const entry = getBindGroupEntry(value, bindingLayout.location, { sampler: true });
+        const entry = getBindGroupEntry(value, bindingLayout.location, { sampler: true }, bindingName);
         if (entry) {
           entries.push(entry);
         }
@@ -735,7 +861,7 @@ function getBindGroupEntries(bindings, shaderLayout) {
   }
   return entries;
 }
-function getBindGroupEntry(binding, index, options) {
+function getBindGroupEntry(binding, index, options, bindingName = "unknown") {
   if (binding instanceof import_core8.Buffer) {
     return {
       binding: index,
@@ -750,6 +876,12 @@ function getBindGroupEntry(binding, index, options) {
       resource: binding.handle
     };
   }
+  if (binding instanceof import_core8.TextureView) {
+    return {
+      binding: index,
+      resource: binding.handle
+    };
+  }
   if (binding instanceof import_core8.Texture) {
     if (options == null ? void 0 : options.sampler) {
       return {
@@ -762,7 +894,7 @@ function getBindGroupEntry(binding, index, options) {
       resource: binding.view.handle
     };
   }
-  import_core8.log.warn(`invalid binding ${name}`, binding);
+  import_core8.log.warn(`invalid binding ${bindingName}`, binding);
   return null;
 }
 var import_core8;
@@ -844,17 +976,17 @@ function getVertexBufferLayout(shaderLayout, bufferLayout) {
   });
   return vertexBufferLayouts;
 }
-function findAttributeLayout(shaderLayout, name2, attributeNames) {
-  const attribute = shaderLayout.attributes.find((attribute_) => attribute_.name === name2);
+function findAttributeLayout(shaderLayout, name, attributeNames) {
+  const attribute = shaderLayout.attributes.find((attribute_) => attribute_.name === name);
   if (!attribute) {
-    import_core9.log.warn(`Supplied attribute not present in shader layout: ${name2}`)();
+    import_core9.log.warn(`Supplied attribute not present in shader layout: ${name}`)();
     return null;
   }
   if (attributeNames) {
-    if (attributeNames.has(name2)) {
-      throw new Error(`Found multiple entries for attribute: ${name2}`);
+    if (attributeNames.has(name)) {
+      throw new Error(`Found multiple entries for attribute: ${name}`);
     }
-    attributeNames.add(name2);
+    attributeNames.add(name);
   }
   return attribute;
 }
@@ -918,8 +1050,8 @@ var init_webgpu_render_pipeline = __esm({
        * @todo Do we want to expose BindGroups in the API and remove this?
        */
       setBindings(bindings) {
-        for (const [name2, binding] of Object.entries(bindings)) {
-          if (this._bindings[name2] !== binding) {
+        for (const [name, binding] of Object.entries(bindings)) {
+          if (this._bindings[name] !== binding) {
             this._bindGroup = null;
           }
         }
@@ -1164,18 +1296,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 +1338,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`,
@@ -1653,8 +1787,7 @@ var init_webgpu_pipeline_layout = __esm({
       }
       mapShaderLayoutToBindGroupEntries() {
         const bindGroupEntries = [];
-        for (let i = 0; i < this.props.shaderLayout.bindings.length; i++) {
-          const binding = this.props.shaderLayout.bindings[i];
+        for (const binding of this.props.shaderLayout.bindings) {
           const bindingTypeInfo = {};
           switch (binding.type) {
             case "uniform": {
@@ -1725,16 +1858,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 +2019,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 +2064,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 +2080,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 +2125,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 +2190,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 +2208,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 +2226,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 +2257,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 +2306,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