@luma.gl/webgpu 9.0.0-alpha.2

package/dist/adapter/resources/webgpu-texture.js

@@ -0,0 +1,111 @@
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import { Texture } from '@luma.gl/api';
+import { getWebGPUTextureFormat } from '../helpers/convert-texture-format';
+import WebGPUSampler from './webgpu-sampler';
+const BASE_DIMENSIONS = {
+  '1d': '1d',
+  '2d': '2d',
+  '2d-array': '2d',
+  'cube': '2d',
+  'cube-array': '2d',
+  '3d': '3d'
+};
+export default class WebGPUTexture extends Texture {
+  constructor(device, props) {
+    super(device, props);
+
+    _defineProperty(this, "device", void 0);
+
+    _defineProperty(this, "handle", void 0);
+
+    _defineProperty(this, "view", void 0);
+
+    _defineProperty(this, "sampler", void 0);
+
+    if (typeof this.props.format === 'number') {
+      throw new Error('number format');
+    }
+
+    this.device = device;
+    this.handle = this.props.handle || this.createHandle();
+
+    if (this.props.data) {
+      this.setData({
+        data: this.props.data
+      });
+    }
+
+    this.setSampler(props.sampler);
+    this.view = this.handle.createView({});
+  }
+
+  createHandle() {
+    var _this$props$data, _this$props$data2;
+
+    if (typeof this.props.format === 'number') {
+      throw new Error('number format');
+    }
+
+    const width = this.props.width || ((_this$props$data = this.props.data) === null || _this$props$data === void 0 ? void 0 : _this$props$data.width) || 1;
+    const height = this.props.height || ((_this$props$data2 = this.props.data) === null || _this$props$data2 === void 0 ? void 0 : _this$props$data2.height) || 1;
+    return this.device.handle.createTexture({
+      size: {
+        width,
+        height,
+        depthOrArrayLayers: this.props.depth
+      },
+      dimension: BASE_DIMENSIONS[this.props.dimension],
+      format: getWebGPUTextureFormat(this.props.format),
+      usage: this.props.usage,
+      mipLevelCount: this.props.mipLevels,
+      sampleCount: this.props.samples
+    });
+  }
+
+  destroy() {
+    this.handle.destroy();
+  }
+
+  setSampler(sampler) {
+    this.sampler = sampler instanceof WebGPUSampler ? sampler : new WebGPUSampler(this.device, sampler);
+    return this;
+  }
+
+  setData(options) {
+    return this.setImage({
+      source: options.data
+    });
+  }
+
+  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;
+    this.device.handle.queue.copyExternalImageToTexture({
+      source,
+      origin: [sourceX, sourceY]
+    }, {
+      texture: this.handle,
+      origin: [x, y, z],
+      mipLevel,
+      aspect,
+      colorSpace,
+      premultipliedAlpha
+    }, [width, height, depth]);
+    return this;
+  }
+
+}
+//# sourceMappingURL=webgpu-texture.js.map

package/dist/adapter/resources/webgpu-texture.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/adapter/resources/webgpu-texture.ts"],"names":["Texture","getWebGPUTextureFormat","WebGPUSampler","BASE_DIMENSIONS","WebGPUTexture","constructor","device","props","format","Error","handle","createHandle","data","setData","setSampler","sampler","view","createView","width","height","createTexture","size","depthOrArrayLayers","depth","dimension","usage","mipLevelCount","mipLevels","sampleCount","samples","destroy","options","setImage","source","sourceX","sourceY","mipLevel","x","y","z","aspect","colorSpace","premultipliedAlpha","queue","copyExternalImageToTexture","origin","texture"],"mappings":"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","sourcesContent":["// luma.gl, MIT license\nimport {Texture, TextureProps, Sampler, SamplerProps, assert} from '@luma.gl/api';\nimport {getWebGPUTextureFormat} from '../helpers/convert-texture-format';\nimport type WebGPUDevice from '../webgpu-device';\nimport WebGPUSampler from './webgpu-sampler';\n\nconst BASE_DIMENSIONS: Record<string, '1d' | '2d' | '3d'> = {\n  '1d': '1d',\n  '2d': '2d',\n  '2d-array': '2d',\n  'cube': '2d',\n  'cube-array': '2d',\n  '3d': '3d'\n};\n\nexport default class WebGPUTexture extends Texture {\n  readonly device: WebGPUDevice;\n  readonly handle: GPUTexture;\n  readonly view: GPUTextureView;\n  sampler: WebGPUSampler;\n\n  // static async createFromImageURL(src, usage = 0) {\n  //   const img = document.createElement('img');\n  //   img.src = src;\n  //   await img.decode();\n  //   return WebGPUTexture(img, usage);\n  // }\n\n  constructor(device: WebGPUDevice, props: TextureProps) {\n    super(device, props);\n\n    if (typeof this.props.format === 'number') {\n      throw new Error('number format');\n    }\n\n    this.device = device;\n    this.handle = this.props.handle || this.createHandle();\n\n    if (this.props.data) {\n      this.setData({data: this.props.data}  );\n    }\n\n    // Create a default sampler. This mimics the WebGL1 API where sampler props are stored on the texture\n    this.setSampler(props.sampler);\n\n    // TODO - To support texture arrays we need to create custom views...\n    // But we are not ready to expose TextureViews to the public API.\n    this.view = this.handle.createView({\n      // format: this.props.format,\n      // dimension: this.props.dimension,\n      // aspect = \"all\";\n      // baseMipLevel: 0;\n      // mipLevelCount;\n      // baseArrayLayer = 0;\n      // arrayLayerCount;\n    });\n  }\n\n  protected createHandle(): GPUTexture {\n    if (typeof this.props.format === 'number') {\n      throw new Error('number format');\n    }\n\n    // Deduce size from data - TODO this is a hack\n    // @ts-expect-error\n    const width = this.props.width || this.props.data?.width || 1;\n    // @ts-expect-error\n    const height = this.props.height || this.props.data?.height || 1;\n\n    return this.device.handle.createTexture({\n      size: {\n        width,\n        height,\n        depthOrArrayLayers: this.props.depth\n      },\n      dimension: BASE_DIMENSIONS[this.props.dimension],\n      format: getWebGPUTextureFormat(this.props.format),\n      usage: this.props.usage,\n      mipLevelCount: this.props.mipLevels,\n      sampleCount: this.props.samples\n    });\n  }\n\n  destroy(): void {\n    this.handle.destroy();\n  }\n\n  /**\n   * Set default sampler\n   * Accept a sampler instance or set of props;\n   */\n  setSampler(sampler: Sampler | SamplerProps): this {\n    this.sampler = sampler instanceof WebGPUSampler ? sampler : new WebGPUSampler(this.device, sampler);\n    return this;\n  }\n\n  setData(options: {\n    data: any;\n  }) {\n    return this.setImage({source: options.data});\n  }\n\n  /** Set image */\n  setImage(options: {\n    source: ImageBitmap | HTMLCanvasElement | OffscreenCanvas;\n    width?: number;\n    height?: number;\n    depth?: number;\n    sourceX?: number;\n    sourceY?: number;\n    mipLevel?: number;\n    x?: number;\n    y?: number;\n    z?: number;\n    aspect?: 'all' | 'stencil-only' | 'depth-only';\n    colorSpace?: 'srgb';\n    premultipliedAlpha?: boolean;\n  }): this {\n    const {\n      source,\n      width = options.source.width,\n      height = options.source.height,\n      depth = 1,\n      sourceX = 0,\n      sourceY = 0,\n      mipLevel = 0,\n      x = 0,\n      y = 0,\n      z = 0,\n      aspect = 'all',\n      colorSpace = 'srgb',\n      premultipliedAlpha = false\n    } = options;\n\n    // TODO - max out width\n\n    this.device.handle.queue.copyExternalImageToTexture(\n      // source: GPUImageCopyExternalImage\n      {\n        source,\n        origin: [sourceX, sourceY]\n      },\n      // destination: GPUImageCopyTextureTagged\n      {\n        texture: this.handle,\n        origin: [x, y, z],\n        mipLevel,\n        aspect,\n        colorSpace,\n        premultipliedAlpha\n      },\n      // copySize: GPUExtent3D\n      [\n        width,\n        height,\n        depth\n      ]\n    );\n    return this;\n  }\n\n  /*\n  async readPixels() {\n    const readbackBuffer = device.createBuffer({\n        usage: Buffer.COPY_DST | Buffer.MAP_READ,\n        size: 4 * textureWidth * textureHeight,\n    });\n\n    // Copy data from the texture to the buffer.\n    const encoder = device.createCommandEncoder();\n    encoder.copyTextureToBuffer(\n        { texture },\n        { buffer, rowPitch: textureWidth * 4 },\n        [textureWidth, textureHeight],\n    );\n    device.submit([encoder.finish()]);\n\n    // Get the data on the CPU.\n    await buffer.mapAsync(GPUMapMode.READ);\n    saveScreenshot(buffer.getMappedRange());\n    buffer.unmap();\n  }\n\n  setImageData(imageData, usage): this {\n    let data = null;\n\n    const bytesPerRow = Math.ceil((img.width * 4) / 256) * 256;\n    if (bytesPerRow == img.width * 4) {\n      data = imageData.data;\n    } else {\n      data = new Uint8Array(bytesPerRow * img.height);\n      let imagePixelIndex = 0;\n      for (let y = 0; y < img.height; ++y) {\n        for (let x = 0; x < img.width; ++x) {\n          const i = x * 4 + y * bytesPerRow;\n          data[i] = imageData.data[imagePixelIndex];\n          data[i + 1] = imageData.data[imagePixelIndex + 1];\n          data[i + 2] = imageData.data[imagePixelIndex + 2];\n          data[i + 3] = imageData.data[imagePixelIndex + 3];\n          imagePixelIndex += 4;\n        }\n      }\n    }\n    return this;\n  }\n\n  setData(data): this {\n    const textureDataBuffer = this.device.handle.createBuffer({\n      size: data.byteLength,\n      usage: Buffer.COPY_DST | Buffer.COPY_SRC,\n      mappedAtCreation: true\n    });\n    new Uint8Array(textureDataBuffer.getMappedRange()).set(data);\n    textureDataBuffer.unmap();\n\n    this.setBuffer(textureDataBuffer);\n\n    textureDataBuffer.destroy();\n    return this;\n  }\n\n  setBuffer(textureDataBuffer, {bytesPerRow}): this {\n    const commandEncoder = this.device.handle.createCommandEncoder();\n    commandEncoder.copyBufferToTexture(\n      {\n        buffer: textureDataBuffer,\n        bytesPerRow\n      },\n      {\n        texture: this.handle\n      },\n      {\n        width,\n        height,\n        depth\n      }\n    );\n\n    this.device.handle.defaultQueue.submit([commandEncoder.finish()]);\n    return this;\n  }\n  */\n}\n"],"file":"webgpu-texture.js"}

package/dist/adapter/webgpu-canvas-context.d.ts

@@ -0,0 +1,32 @@
+/// <reference types="@webgpu/types" />
+import type { Texture, TextureFormat, CanvasContextProps } from '@luma.gl/api';
+import { CanvasContext } from '@luma.gl/api';
+import WebGPUDevice from './webgpu-device';
+import WEBGPUFramebuffer from './resources/webgpu-framebuffer';
+/**
+ * Holds a WebGPU Canvas Context which handles resizing etc
+ */
+export default class WebGPUCanvasContext extends CanvasContext {
+    readonly device: WebGPUDevice;
+    readonly gpuCanvasContext: GPUCanvasContext;
+    readonly format: TextureFormat;
+    width: number;
+    height: number;
+    depthStencilFormat: TextureFormat;
+    sampleCount: number;
+    private depthStencilAttachment;
+    constructor(device: WebGPUDevice, adapter: GPUAdapter, props: CanvasContextProps);
+    destroy(): void;
+    /** Update framebuffer with properly resized "swap chain" texture views */
+    getCurrentFramebuffer(): WEBGPUFramebuffer;
+    /** Resizes and updates render targets if necessary */
+    update(): void;
+    resize(options?: {
+        width?: number;
+        height?: number;
+        useDevicePixels?: boolean | number;
+    }): void;
+    /** We build render targets on demand (i.e. not when size changes but when about to render) */
+    _createDepthStencilAttachment(): Texture;
+}
+//# sourceMappingURL=webgpu-canvas-context.d.ts.map

package/dist/adapter/webgpu-canvas-context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"webgpu-canvas-context.d.ts","sourceRoot":"","sources":["../../src/adapter/webgpu-canvas-context.ts"],"names":[],"mappings":";AAAA,OAAO,KAAK,EAAC,OAAO,EAAE,aAAa,EAAE,kBAAkB,EAAC,MAAM,cAAc,CAAC;AAC7E,OAAO,EAAC,aAAa,EAAM,MAAM,cAAc,CAAC;AAEhD,OAAO,YAAY,MAAM,iBAAiB,CAAC;AAC3C,OAAO,iBAAiB,MAAM,gCAAgC,CAAC;AAE/D;;GAEG;AACH,MAAM,CAAC,OAAO,OAAO,mBAAoB,SAAQ,aAAa;IAC5D,QAAQ,CAAC,MAAM,EAAE,YAAY,CAAC;IAC9B,QAAQ,CAAC,gBAAgB,EAAE,gBAAgB,CAAC;IAC5C,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAC;IAC/B,KAAK,EAAE,MAAM,CAAM;IACnB,MAAM,EAAE,MAAM,CAAM;IACpB,kBAAkB,EAAE,aAAa,CAAiB;IAClD,WAAW,EAAE,MAAM,CAAK;IAExB,OAAO,CAAC,sBAAsB,CAAU;gBAE5B,MAAM,EAAE,YAAY,EAAE,OAAO,EAAE,UAAU,EAAE,KAAK,EAAE,kBAAkB;IAOhF,OAAO;IAIP,0EAA0E;IAC1E,qBAAqB,IAAI,iBAAiB;IAsB1C,sDAAsD;IACtD,MAAM;IA6BN,MAAM,CAAC,OAAO,CAAC,EAAE;QAAC,KAAK,CAAC,EAAE,MAAM,CAAC;QAAC,MAAM,CAAC,EAAE,MAAM,CAAC;QAAC,eAAe,CAAC,EAAE,OAAO,GAAG,MAAM,CAAA;KAAC,GAAG,IAAI;IAI7F,8FAA8F;IAC9F,6BAA6B;CAY9B"}

package/dist/adapter/webgpu-canvas-context.js

@@ -0,0 +1,95 @@
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import { CanvasContext, log } from '@luma.gl/api';
+import { getWebGPUTextureFormat } from './helpers/convert-texture-format';
+import WEBGPUFramebuffer from './resources/webgpu-framebuffer';
+export default class WebGPUCanvasContext extends CanvasContext {
+  constructor(device, adapter, props) {
+    super(props);
+
+    _defineProperty(this, "device", void 0);
+
+    _defineProperty(this, "gpuCanvasContext", void 0);
+
+    _defineProperty(this, "format", void 0);
+
+    _defineProperty(this, "width", -1);
+
+    _defineProperty(this, "height", -1);
+
+    _defineProperty(this, "depthStencilFormat", 'depth24plus');
+
+    _defineProperty(this, "sampleCount", 1);
+
+    _defineProperty(this, "depthStencilAttachment", void 0);
+
+    this.device = device;
+    this.gpuCanvasContext = this.canvas.getContext('webgpu');
+    this.format = this.gpuCanvasContext.getPreferredFormat(adapter);
+  }
+
+  destroy() {
+    this.gpuCanvasContext.unconfigure();
+  }
+
+  getCurrentFramebuffer() {
+    this.update();
+    const currentColorAttachment = this.device.createTexture({
+      id: 'default-render-target',
+      handle: this.gpuCanvasContext.getCurrentTexture(),
+      format: this.format,
+      width: this.width,
+      height: this.height
+    });
+
+    this._createDepthStencilAttachment();
+
+    return new WEBGPUFramebuffer(this.device, {
+      colorAttachments: [currentColorAttachment],
+      depthStencilAttachment: this.depthStencilAttachment
+    });
+  }
+
+  update() {
+    const [width, height] = this.getPixelSize();
+    const sizeChanged = width !== this.width || height !== this.height;
+
+    if (sizeChanged) {
+      this.width = width;
+      this.height = height;
+
+      if (this.depthStencilAttachment) {
+        this.depthStencilAttachment.destroy();
+        this.depthStencilAttachment = undefined;
+      }
+
+      this.gpuCanvasContext.configure({
+        device: this.device.handle,
+        format: getWebGPUTextureFormat(this.format),
+        size: [this.width, this.height],
+        colorSpace: this.props.colorSpace,
+        compositingAlphaMode: this.props.compositingAlphaMode
+      });
+      log.log(1, "Resized to ".concat(this.width, "x").concat(this.height, "px"))();
+    }
+  }
+
+  resize(options) {
+    this.update();
+  }
+
+  _createDepthStencilAttachment() {
+    if (!this.depthStencilAttachment) {
+      this.depthStencilAttachment = this.device.createTexture({
+        id: 'depth-stencil-target',
+        format: this.depthStencilFormat,
+        width: this.width,
+        height: this.height,
+        usage: GPUTextureUsage.RENDER_ATTACHMENT
+      });
+    }
+
+    return this.depthStencilAttachment;
+  }
+
+}
+//# sourceMappingURL=webgpu-canvas-context.js.map

package/dist/adapter/webgpu-canvas-context.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/adapter/webgpu-canvas-context.ts"],"names":["CanvasContext","log","getWebGPUTextureFormat","WEBGPUFramebuffer","WebGPUCanvasContext","constructor","device","adapter","props","gpuCanvasContext","canvas","getContext","format","getPreferredFormat","destroy","unconfigure","getCurrentFramebuffer","update","currentColorAttachment","createTexture","id","handle","getCurrentTexture","width","height","_createDepthStencilAttachment","colorAttachments","depthStencilAttachment","getPixelSize","sizeChanged","undefined","configure","size","colorSpace","compositingAlphaMode","resize","options","depthStencilFormat","usage","GPUTextureUsage","RENDER_ATTACHMENT"],"mappings":"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","sourcesContent":["import type {Texture, TextureFormat, CanvasContextProps} from '@luma.gl/api';\nimport {CanvasContext, log} from '@luma.gl/api';\nimport {getWebGPUTextureFormat} from './helpers/convert-texture-format';\nimport WebGPUDevice from './webgpu-device';\nimport WEBGPUFramebuffer from './resources/webgpu-framebuffer';\n\n/** \n * Holds a WebGPU Canvas Context which handles resizing etc \n */\nexport default class WebGPUCanvasContext extends CanvasContext {\n  readonly device: WebGPUDevice;\n  readonly gpuCanvasContext: GPUCanvasContext;\n  readonly format: TextureFormat;\n  width: number = -1;\n  height: number = -1;\n  depthStencilFormat: TextureFormat = 'depth24plus';\n  sampleCount: number = 1;\n\n  private depthStencilAttachment: Texture;\n\n  constructor(device: WebGPUDevice, adapter: GPUAdapter, props: CanvasContextProps) {\n    super(props);\n    this.device = device;\n    this.gpuCanvasContext = this.canvas.getContext('webgpu') as GPUCanvasContext;\n    this.format = this.gpuCanvasContext.getPreferredFormat(adapter);\n  }\n\n  destroy() {\n    this.gpuCanvasContext.unconfigure();\n  }\n\n  /** Update framebuffer with properly resized \"swap chain\" texture views */\n  getCurrentFramebuffer(): WEBGPUFramebuffer {\n    // Ensure the canvas context size is updated\n    this.update();\n\n    // Wrap the current canvas context texture in a luma.gl texture \n    const currentColorAttachment = this.device.createTexture({\n      id: 'default-render-target',\n      handle: this.gpuCanvasContext.getCurrentTexture(),\n      format: this.format,\n      width: this.width,\n      height: this.height\n    });\n\n    // Resize the depth stencil attachment\n    this._createDepthStencilAttachment();\n\n    return new WEBGPUFramebuffer(this.device, {\n      colorAttachments: [currentColorAttachment],\n      depthStencilAttachment: this.depthStencilAttachment\n    });\n  }\n\n  /** Resizes and updates render targets if necessary */\n  update() {\n    const [width, height] = this.getPixelSize();\n\n    const sizeChanged = width !== this.width || height !== this.height;\n\n    if (sizeChanged) {\n      this.width = width;\n      this.height = height;\n\n      if (this.depthStencilAttachment) {\n        this.depthStencilAttachment.destroy();\n        this.depthStencilAttachment = undefined;\n      }\n\n      // Reconfigure the canvas size.\n      // https://www.w3.org/TR/webgpu/#canvas-configuration\n      this.gpuCanvasContext.configure({\n        device: this.device.handle,\n        format: getWebGPUTextureFormat(this.format),\n        size: [this.width, this.height],\n        colorSpace: this.props.colorSpace,\n        compositingAlphaMode: this.props.compositingAlphaMode\n      });\n\n      log.log(1, `Resized to ${this.width}x${this.height}px`)();\n    }\n\n  }\n\n  resize(options?: {width?: number; height?: number; useDevicePixels?: boolean | number}): void {\n    this.update();\n  }\n\n  /** We build render targets on demand (i.e. not when size changes but when about to render) */\n  _createDepthStencilAttachment() {\n    if (!this.depthStencilAttachment) {\n      this.depthStencilAttachment = this.device.createTexture({\n        id: 'depth-stencil-target',\n        format: this.depthStencilFormat,\n        width: this.width,\n        height: this.height,\n        usage: GPUTextureUsage.RENDER_ATTACHMENT\n      });\n    }\n    return this.depthStencilAttachment;\n  }\n}\n"],"file":"webgpu-canvas-context.js"}

package/dist/adapter/webgpu-device.d.ts

@@ -0,0 +1,67 @@
+/// <reference types="@webgpu/types" />
+import type { DeviceProps, DeviceInfo, DeviceLimits, DeviceFeature, CanvasContextProps, BufferProps, SamplerProps, ShaderProps, TextureProps, TextureFormat, ExternalTextureProps, FramebufferProps, RenderPipelineProps, ComputePipelineProps, RenderPassProps, ComputePassProps } from '@luma.gl/api';
+import { Device } from '@luma.gl/api';
+import WebGPUBuffer from './resources/webgpu-buffer';
+import WebGPUTexture from './resources/webgpu-texture';
+import WebGPUExternalTexture from './resources/webgpu-external-texture';
+import WebGPUSampler from './resources/webgpu-sampler';
+import WebGPUShader from './resources/webgpu-shader';
+import WebGPURenderPipeline from './resources/webgpu-render-pipeline';
+import WebGPUFramebuffer from './resources/webgpu-framebuffer';
+import WebGPUComputePipeline from './resources/webgpu-compute-pipeline';
+import WebGPURenderPass from './resources/webgpu-render-pass';
+import WebGPUComputePass from './resources/webgpu-compute-pass';
+import WebGPUCanvasContext from './webgpu-canvas-context';
+/** WebGPU Device implementation */
+export default class WebGPUDevice extends Device {
+    readonly handle: GPUDevice;
+    readonly adapter: GPUAdapter;
+    readonly lost: Promise<{
+        reason: 'destroyed';
+        message: string;
+    }>;
+    canvasContext: WebGPUCanvasContext | undefined;
+    commandEncoder: GPUCommandEncoder;
+    renderPass: WebGPURenderPass;
+    private _info;
+    private _isLost;
+    static type: string;
+    /** Check if WebGPU is available */
+    static isSupported(): boolean;
+    static create(props: DeviceProps): Promise<WebGPUDevice>;
+    constructor(device: GPUDevice, adapter: GPUAdapter, props: DeviceProps);
+    destroy(): void;
+    get info(): DeviceInfo;
+    features: Set<DeviceFeature>;
+    get limits(): DeviceLimits;
+    isTextureFormatSupported(format: TextureFormat): boolean;
+    /** @todo implement proper check? */
+    isTextureFormatFilterable(format: TextureFormat): boolean;
+    /** @todo implement proper check? */
+    isTextureFormatRenderable(format: TextureFormat): boolean;
+    get isLost(): boolean;
+    _createBuffer(props: BufferProps): WebGPUBuffer;
+    _createTexture(props: TextureProps): WebGPUTexture;
+    createExternalTexture(props: ExternalTextureProps): WebGPUExternalTexture;
+    createShader(props: ShaderProps): WebGPUShader;
+    createSampler(props: SamplerProps): WebGPUSampler;
+    createRenderPipeline(props: RenderPipelineProps): WebGPURenderPipeline;
+    createFramebuffer(props: FramebufferProps): WebGPUFramebuffer;
+    createComputePipeline(props: ComputePipelineProps): WebGPUComputePipeline;
+    /**
+     * Allows a render pass to begin against a canvas context
+     * @todo need to support a "Framebuffer" equivalent (aka preconfigured RenderPassDescriptors?).
+     */
+    beginRenderPass(props?: RenderPassProps): WebGPURenderPass;
+    beginComputePass(props?: ComputePassProps): WebGPUComputePass;
+    createCanvasContext(props?: CanvasContextProps): WebGPUCanvasContext;
+    /**
+     * Gets default renderpass encoder.
+     * Creates a new encoder against default canvasContext if not already created
+     * @note Called internally by Model.
+     */
+    getDefaultRenderPass(): WebGPURenderPass;
+    submit(): void;
+    _getFeatures(): Set<DeviceFeature>;
+}
+//# sourceMappingURL=webgpu-device.d.ts.map

package/dist/adapter/webgpu-device.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"webgpu-device.d.ts","sourceRoot":"","sources":["../../src/adapter/webgpu-device.ts"],"names":[],"mappings":";AAEA,OAAO,KAAK,EACV,WAAW,EACX,UAAU,EACV,YAAY,EACZ,aAAa,EACb,kBAAkB,EAClB,WAAW,EACX,YAAY,EACZ,WAAW,EACX,YAAY,EACZ,aAAa,EACb,oBAAoB,EACpB,gBAAgB,EAChB,mBAAmB,EACnB,oBAAoB,EACpB,eAAe,EACf,gBAAgB,EACjB,MAAM,cAAc,CAAC;AACtB,OAAO,EAAC,MAAM,EAA2B,MAAM,cAAc,CAAC;AAC9D,OAAO,YAAY,MAAM,2BAA2B,CAAC;AACrD,OAAO,aAAa,MAAM,4BAA4B,CAAC;AACvD,OAAO,qBAAqB,MAAM,qCAAqC,CAAC;AACxE,OAAO,aAAa,MAAM,4BAA4B,CAAC;AACvD,OAAO,YAAY,MAAM,2BAA2B,CAAC;AACrD,OAAO,oBAAoB,MAAM,oCAAoC,CAAC;AACtE,OAAO,iBAAiB,MAAM,gCAAgC,CAAC;AAC/D,OAAO,qBAAqB,MAAM,qCAAqC,CAAC;AACxE,OAAO,gBAAgB,MAAM,gCAAgC,CAAC;AAC9D,OAAO,iBAAiB,MAAM,iCAAiC,CAAC;AAEhE,OAAO,mBAAmB,MAAM,yBAAyB,CAAC;AAG1D,mCAAmC;AACnC,MAAM,CAAC,OAAO,OAAO,YAAa,SAAQ,MAAM;IAC9C,QAAQ,CAAC,MAAM,EAAE,SAAS,CAAC;IAC3B,QAAQ,CAAC,OAAO,EAAE,UAAU,CAAC;IAC7B,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;QAAC,MAAM,EAAE,WAAW,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAC,CAAC,CAAC;IAC/D,aAAa,EAAE,mBAAmB,GAAG,SAAS,CAAC;IAE/C,cAAc,EAAE,iBAAiB,CAAC;IAClC,UAAU,EAAE,gBAAgB,CAAC;IAE7B,OAAO,CAAC,KAAK,CAAa;IAC1B,OAAO,CAAC,OAAO,CAAkB;IAEjC,MAAM,CAAC,IAAI,EAAE,MAAM,CAAY;IAE/B,mCAAmC;IACnC,MAAM,CAAC,WAAW,IAAI,OAAO;WAIhB,MAAM,CAAC,KAAK,EAAE,WAAW,GAAG,OAAO,CAAC,YAAY,CAAC;gBA8BlD,MAAM,EAAE,SAAS,EAAE,OAAO,EAAE,UAAU,EAAE,KAAK,EAAE,WAAW;IAsCtE,OAAO;IAIP,IAAI,IAAI,IAAI,UAAU,CAErB;IAED,QAAQ,EAAE,GAAG,CAAC,aAAa,CAAC,CAAC;IAE7B,IAAI,MAAM,IAAI,YAAY,CAEzB;IAED,wBAAwB,CAAC,MAAM,EAAE,aAAa,GAAG,OAAO;IAIxD,oCAAoC;IACpC,yBAAyB,CAAC,MAAM,EAAE,aAAa,GAAG,OAAO;IAIzD,oCAAoC;IACpC,yBAAyB,CAAC,MAAM,EAAE,aAAa,GAAG,OAAO;IAIzD,IAAI,MAAM,IAAI,OAAO,CAEpB;IAED,aAAa,CAAC,KAAK,EAAE,WAAW,GAAG,YAAY;IAI/C,cAAc,CAAC,KAAK,EAAE,YAAY,GAAG,aAAa;IAIlD,qBAAqB,CAAC,KAAK,EAAE,oBAAoB,GAAG,qBAAqB;IAIzE,YAAY,CAAC,KAAK,EAAE,WAAW,GAAG,YAAY;IAI9C,aAAa,CAAC,KAAK,EAAE,YAAY,GAAG,aAAa;IAIjD,oBAAoB,CAAC,KAAK,EAAE,mBAAmB,GAAG,oBAAoB;IAItE,iBAAiB,CAAC,KAAK,EAAE,gBAAgB,GAAG,iBAAiB;IAI7D,qBAAqB,CAAC,KAAK,EAAE,oBAAoB,GAAG,qBAAqB;IAMzE;;;OAGG;IACH,eAAe,CAAC,KAAK,CAAC,EAAE,eAAe,GAAG,gBAAgB;IAK1D,gBAAgB,CAAC,KAAK,CAAC,EAAE,gBAAgB,GAAG,iBAAiB;IAK7D,mBAAmB,CAAC,KAAK,CAAC,EAAE,kBAAkB,GAAG,mBAAmB;IAIpE;;;;OAIG;IACH,oBAAoB,IAAI,gBAAgB;IAOxC,MAAM,IAAI,IAAI;IAQd,YAAY;CAsDb"}

package/dist/adapter/webgpu-device.js

@@ -0,0 +1,225 @@
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import { Device, CanvasContext, log } from '@luma.gl/api';
+import WebGPUBuffer from './resources/webgpu-buffer';
+import WebGPUTexture from './resources/webgpu-texture';
+import WebGPUExternalTexture from './resources/webgpu-external-texture';
+import WebGPUSampler from './resources/webgpu-sampler';
+import WebGPUShader from './resources/webgpu-shader';
+import WebGPURenderPipeline from './resources/webgpu-render-pipeline';
+import WebGPUComputePipeline from './resources/webgpu-compute-pipeline';
+import WebGPURenderPass from './resources/webgpu-render-pass';
+import WebGPUComputePass from './resources/webgpu-compute-pass';
+import WebGPUCanvasContext from './webgpu-canvas-context';
+export default class WebGPUDevice extends Device {
+  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');
+    }
+
+    log.groupCollapsed(1, 'WebGPUDevice created')();
+    const adapter = await navigator.gpu.requestAdapter({
+      powerPreference: "high-performance"
+    });
+    log.probe(1, "Adapter available")();
+    const gpuDevice = await adapter.requestDevice({
+      requiredFeatures: adapter.features
+    });
+    log.probe(1, "GPUDevice available")();
+
+    if (typeof props.canvas === 'string') {
+      await CanvasContext.pageLoaded;
+      log.probe(1, "DOM is loaded")();
+    }
+
+    const device = new WebGPUDevice(gpuDevice, adapter, props);
+    log.probe(1, "Device created", device.info)();
+    log.table(1, device.info)();
+    log.groupEnd(1)();
+    return device;
+  }
+
+  constructor(device, adapter, props) {
+    super(props);
+
+    _defineProperty(this, "handle", void 0);
+
+    _defineProperty(this, "adapter", void 0);
+
+    _defineProperty(this, "lost", void 0);
+
+    _defineProperty(this, "canvasContext", void 0);
+
+    _defineProperty(this, "commandEncoder", void 0);
+
+    _defineProperty(this, "renderPass", void 0);
+
+    _defineProperty(this, "_info", void 0);
+
+    _defineProperty(this, "_isLost", false);
+
+    _defineProperty(this, "features", void 0);
+
+    this.handle = device;
+    this.adapter = adapter;
+    this._info = {
+      type: 'webgpu',
+      vendor: this.adapter.name,
+      renderer: '',
+      version: '',
+      gpu: 'unknown',
+      shadingLanguages: ['glsl', 'wgsl'],
+      shadingLanguageVersions: {
+        glsl: '450',
+        wgsl: '100'
+      },
+      vendorMasked: '',
+      rendererMasked: ''
+    };
+    this.lost = this.handle.lost;
+    this.lost.then(_ => {
+      this._isLost = true;
+    });
+
+    if (props.canvas) {
+      this.canvasContext = new WebGPUCanvasContext(this, this.adapter, {
+        canvas: props.canvas
+      });
+    }
+
+    this.features = this._getFeatures();
+  }
+
+  destroy() {
+    this.handle.destroy();
+  }
+
+  get info() {
+    return this._info;
+  }
+
+  get limits() {
+    return this.handle.limits;
+  }
+
+  isTextureFormatSupported(format) {
+    return !format.includes('webgl');
+  }
+
+  isTextureFormatFilterable(format) {
+    return this.isTextureFormatSupported(format);
+  }
+
+  isTextureFormatRenderable(format) {
+    return this.isTextureFormatSupported(format);
+  }
+
+  get isLost() {
+    return this._isLost;
+  }
+
+  _createBuffer(props) {
+    return new WebGPUBuffer(this, props);
+  }
+
+  _createTexture(props) {
+    return new WebGPUTexture(this, props);
+  }
+
+  createExternalTexture(props) {
+    return new WebGPUExternalTexture(this, props);
+  }
+
+  createShader(props) {
+    return new WebGPUShader(this, props);
+  }
+
+  createSampler(props) {
+    return new WebGPUSampler(this, props);
+  }
+
+  createRenderPipeline(props) {
+    return new WebGPURenderPipeline(this, props);
+  }
+
+  createFramebuffer(props) {
+    throw new Error('Not implemented');
+  }
+
+  createComputePipeline(props) {
+    return new WebGPUComputePipeline(this, props);
+  }
+
+  beginRenderPass(props) {
+    this.commandEncoder = this.commandEncoder || this.handle.createCommandEncoder();
+    return new WebGPURenderPass(this, props);
+  }
+
+  beginComputePass(props) {
+    this.commandEncoder = this.commandEncoder || this.handle.createCommandEncoder();
+    return new WebGPUComputePass(this, props);
+  }
+
+  createCanvasContext(props) {
+    return new WebGPUCanvasContext(this, this.adapter, props);
+  }
+
+  getDefaultRenderPass() {
+    this.renderPass = this.renderPass || this.beginRenderPass({
+      framebuffer: this.canvasContext.getCurrentFramebuffer()
+    });
+    return this.renderPass;
+  }
+
+  submit() {
+    this.renderPass.endPass();
+    const commandBuffer = this.commandEncoder.finish();
+    this.handle.queue.submit([commandBuffer]);
+    this.commandEncoder = null;
+    this.renderPass = null;
+  }
+
+  _getFeatures() {
+    const features = new Set(this.handle.features);
+
+    if (features.has('depth-clamping')) {
+      features.delete('depth-clamping');
+      features.add('depth-clip-control');
+    }
+
+    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;
+  }
+
+}
+
+_defineProperty(WebGPUDevice, "type", 'webgpu');
+//# sourceMappingURL=webgpu-device.js.map

package/dist/adapter/webgpu-device.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/adapter/webgpu-device.ts"],"names":["Device","CanvasContext","log","WebGPUBuffer","WebGPUTexture","WebGPUExternalTexture","WebGPUSampler","WebGPUShader","WebGPURenderPipeline","WebGPUComputePipeline","WebGPURenderPass","WebGPUComputePass","WebGPUCanvasContext","WebGPUDevice","isSupported","Boolean","navigator","gpu","create","props","Error","groupCollapsed","adapter","requestAdapter","powerPreference","probe","gpuDevice","requestDevice","requiredFeatures","features","canvas","pageLoaded","device","info","table","groupEnd","constructor","handle","_info","type","vendor","name","renderer","version","shadingLanguages","shadingLanguageVersions","glsl","wgsl","vendorMasked","rendererMasked","lost","then","_","_isLost","canvasContext","_getFeatures","destroy","limits","isTextureFormatSupported","format","includes","isTextureFormatFilterable","isTextureFormatRenderable","isLost","_createBuffer","_createTexture","createExternalTexture","createShader","createSampler","createRenderPipeline","createFramebuffer","createComputePipeline","beginRenderPass","commandEncoder","createCommandEncoder","beginComputePass","createCanvasContext","getDefaultRenderPass","renderPass","framebuffer","getCurrentFramebuffer","submit","endPass","commandBuffer","finish","queue","Set","has","delete","add"],"mappings":"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","sourcesContent":["/// <reference types=\"@webgpu/types\" />\n\nimport type {\n  DeviceProps,\n  DeviceInfo,\n  DeviceLimits,\n  DeviceFeature,\n  CanvasContextProps,\n  BufferProps,\n  SamplerProps,\n  ShaderProps,\n  TextureProps,\n  TextureFormat,\n  ExternalTextureProps,\n  FramebufferProps,\n  RenderPipelineProps,\n  ComputePipelineProps,\n  RenderPassProps,\n  ComputePassProps\n} from '@luma.gl/api';\nimport {Device, CanvasContext, log, cast} from '@luma.gl/api';\nimport WebGPUBuffer from './resources/webgpu-buffer';\nimport WebGPUTexture from './resources/webgpu-texture';\nimport WebGPUExternalTexture from './resources/webgpu-external-texture';\nimport WebGPUSampler from './resources/webgpu-sampler';\nimport WebGPUShader from './resources/webgpu-shader';\nimport WebGPURenderPipeline from './resources/webgpu-render-pipeline';\nimport WebGPUFramebuffer from './resources/webgpu-framebuffer';\nimport WebGPUComputePipeline from './resources/webgpu-compute-pipeline';\nimport WebGPURenderPass from './resources/webgpu-render-pass';\nimport WebGPUComputePass from './resources/webgpu-compute-pass';\n\nimport WebGPUCanvasContext from './webgpu-canvas-context';\n// import {loadGlslangModule} from '../glsl/glslang';\n\n/** WebGPU Device implementation */\nexport default class WebGPUDevice extends Device {\n  readonly handle: GPUDevice;\n  readonly adapter: GPUAdapter;\n  readonly lost: Promise<{reason: 'destroyed', message: string}>;\n  canvasContext: WebGPUCanvasContext | undefined;\n\n  commandEncoder: GPUCommandEncoder;\n  renderPass: WebGPURenderPass;\n\n  private _info: DeviceInfo;\n  private _isLost: boolean = false;\n\n  static type: string = 'webgpu';\n\n  /** Check if WebGPU is available */\n  static isSupported(): boolean {\n    return Boolean(typeof navigator !== 'undefined' && navigator.gpu);\n  }\n\n  static async create(props: DeviceProps): Promise<WebGPUDevice> {\n    if (!navigator.gpu) {\n      throw new Error('WebGPU not available. Open in Chrome Canary and turn on chrome://flags/#enable-unsafe-webgpu');\n    }\n    log.groupCollapsed(1, 'WebGPUDevice created')();\n    const adapter = await navigator.gpu.requestAdapter({\n      powerPreference: \"high-performance\"\n      // forceSoftware: false\n    });\n    log.probe(1, \"Adapter available\")();\n\n    const gpuDevice = await adapter.requestDevice({\n      requiredFeatures: adapter.features as ReadonlySet<GPUFeatureName>,\n      // TODO ensure we obtain best limits\n      // requiredLimits: adapter.limits\n    });\n    log.probe(1, \"GPUDevice available\")();\n\n    if (typeof props.canvas === 'string') {\n      await CanvasContext.pageLoaded;\n      log.probe(1, \"DOM is loaded\")();\n    }\n\n    const device = new WebGPUDevice(gpuDevice, adapter, props);\n    log.probe(1, \"Device created\", device.info)();\n    log.table(1, device.info)();\n    log.groupEnd(1)();\n    return device;\n  }\n\n  constructor(device: GPUDevice, adapter: GPUAdapter, props: DeviceProps) {\n    super(props);\n    this.handle = device;\n    this.adapter = adapter;\n\n    this._info = {\n      type: 'webgpu',\n      vendor: this.adapter.name,\n      renderer: '',\n      version: '',\n      gpu: 'unknown', // 'nvidia' | 'amd' | 'intel' | 'apple' | 'unknown',\n      shadingLanguages: ['glsl', 'wgsl'],\n      shadingLanguageVersions: {\n        glsl: '450',\n        wgsl: '100'\n      },\n      vendorMasked: '',\n      rendererMasked: ''\n    };\n\n    this.lost = this.handle.lost;\n    this.lost.then(_ => {\n      this._isLost = true;\n    });\n\n    // Note: WebGPU devices can be created without a canvas, for compute shader purposes\n    if (props.canvas) {\n      this.canvasContext = new WebGPUCanvasContext(this, this.adapter, {canvas: props.canvas});\n    }\n\n    this.features = this._getFeatures();\n  }\n\n  // TODO\n  // Load the glslang module now so that it is available synchronously when compiling shaders\n  // const {glsl = true} = props;\n  // this.glslang = glsl && await loadGlslangModule();\n\n  destroy() {\n    this.handle.destroy();\n  }\n\n  get info(): DeviceInfo {\n    return this._info;\n  }\n\n  features: Set<DeviceFeature>;\n\n  get limits(): DeviceLimits {\n    return this.handle.limits;\n  }\n\n  isTextureFormatSupported(format: TextureFormat): boolean {\n    return !format.includes('webgl');\n  }\n\n  /** @todo implement proper check? */\n  isTextureFormatFilterable(format: TextureFormat): boolean {\n    return this.isTextureFormatSupported(format); \n  }\n\n  /** @todo implement proper check? */\n  isTextureFormatRenderable(format: TextureFormat): boolean {\n    return this.isTextureFormatSupported(format); \n  }\n\n  get isLost(): boolean {\n    return this._isLost;\n  }\n\n  _createBuffer(props: BufferProps): WebGPUBuffer {\n    return new WebGPUBuffer(this, props);\n  }\n\n  _createTexture(props: TextureProps): WebGPUTexture {\n    return new WebGPUTexture(this, props);\n  }\n\n  createExternalTexture(props: ExternalTextureProps): WebGPUExternalTexture {\n    return new WebGPUExternalTexture(this, props);\n  }\n\n  createShader(props: ShaderProps): WebGPUShader {\n    return new WebGPUShader(this, props);\n  }\n\n  createSampler(props: SamplerProps): WebGPUSampler {\n    return new WebGPUSampler(this, props);\n  }\n\n  createRenderPipeline(props: RenderPipelineProps): WebGPURenderPipeline {\n    return new WebGPURenderPipeline(this, props);\n  }\n\n  createFramebuffer(props: FramebufferProps): WebGPUFramebuffer {\n    throw new Error('Not implemented');\n  }\n\n  createComputePipeline(props: ComputePipelineProps): WebGPUComputePipeline {\n    return new WebGPUComputePipeline(this, props);\n  }\n\n  // WebGPU specifics\n\n  /** \n   * Allows a render pass to begin against a canvas context\n   * @todo need to support a \"Framebuffer\" equivalent (aka preconfigured RenderPassDescriptors?).\n   */\n  beginRenderPass(props?: RenderPassProps): WebGPURenderPass {\n    this.commandEncoder = this.commandEncoder || this.handle.createCommandEncoder();\n    return new WebGPURenderPass(this, props);\n  }\n\n  beginComputePass(props?: ComputePassProps): WebGPUComputePass {\n    this.commandEncoder = this.commandEncoder || this.handle.createCommandEncoder();\n    return new WebGPUComputePass(this, props);\n  }\n\n  createCanvasContext(props?: CanvasContextProps): WebGPUCanvasContext {\n    return new WebGPUCanvasContext(this, this.adapter, props);\n  }\n\n  /** \n   * Gets default renderpass encoder.\n   * Creates a new encoder against default canvasContext if not already created \n   * @note Called internally by Model.\n   */\n  getDefaultRenderPass(): WebGPURenderPass {\n    this.renderPass = this.renderPass || this.beginRenderPass({\n      framebuffer: this.canvasContext.getCurrentFramebuffer()\n    });\n    return this.renderPass;\n  }\n\n  submit(): void {\n    this.renderPass.endPass();\n    const commandBuffer = this.commandEncoder.finish();\n    this.handle.queue.submit([commandBuffer]);\n    this.commandEncoder = null;\n    this.renderPass = null;\n  }\n\n  _getFeatures() {\n    // WebGPU Features\n    const features = new Set<DeviceFeature>(this.handle.features as Set<DeviceFeature>);\n\n    // Fixups for pre-standard names: https://github.com/webgpu-native/webgpu-headers/issues/133\n    // @ts-expect-error Chrome Canary v99\n    if (features.has('depth-clamping')) {\n      // @ts-expect-error Chrome Canary v99\n      features.delete('depth-clamping');\n      features.add('depth-clip-control');\n    }\n\n    // Add subsets\n    if (features.has('texture-compression-bc')) {\n      features.add('texture-compression-bc5-webgl');\n    }\n\n    features.add('webgpu');\n\n    features.add('timer-query-webgl');\n\n    // WEBGL1 SUPPORT\n    features.add('vertex-array-object-webgl1');\n    features.add('instanced-rendering-webgl1');\n    features.add('multiple-render-targets-webgl1');\n    features.add('index-uint32-webgl1');\n    features.add('blend-minmax-webgl1');\n    features.add('texture-blend-float-webgl1');\n  \n    // TEXTURES, RENDERBUFFERS\n    features.add('texture-formats-srgb-webgl1');\n  \n    // TEXTURES\n    features.add('texture-formats-depth-webgl1');\n    features.add('texture-formats-float32-webgl1');\n    features.add('texture-formats-float16-webgl1');\n  \n    features.add('texture-filter-linear-float32-webgl');\n    features.add('texture-filter-linear-float16-webgl');\n    features.add('texture-filter-anisotropic-webgl');\n  \n    // FRAMEBUFFERS, TEXTURES AND RENDERBUFFERS\n    features.add('texture-renderable-rgba32float-webgl');\n    features.add('texture-renderable-float32-webgl');\n    features.add('texture-renderable-float16-webgl');\n  \n    // GLSL extensions\n    features.add('glsl-frag-data');\n    features.add('glsl-frag-depth');\n    features.add('glsl-derivatives');\n    features.add('glsl-texture-lod');\n\n    return features;\n  }\n}\n"],"file":"webgpu-device.js"}

package/dist/adapter/webgpu-types.d.ts

@@ -0,0 +1 @@
+//# sourceMappingURL=webgpu-types.d.ts.map

package/dist/adapter/webgpu-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"webgpu-types.d.ts","sourceRoot":"","sources":["../../src/adapter/webgpu-types.ts"],"names":[],"mappings":""}

package/dist/adapter/webgpu-types.js

@@ -0,0 +1,2 @@
+
+//# sourceMappingURL=webgpu-types.js.map

package/dist/adapter/webgpu-types.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","sourcesContent":[],"file":"webgpu-types.js"}

package/dist/bundle.d.ts

@@ -0,0 +1,2 @@
+declare const moduleExports: any;
+//# sourceMappingURL=bundle.d.ts.map

package/dist/bundle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bundle.d.ts","sourceRoot":"","sources":["../src/bundle.ts"],"names":[],"mappings":"AACA,QAAA,MAAM,aAAa,KAAqB,CAAC"}

package/dist/bundle.js

@@ -0,0 +1,5 @@
+const moduleExports = require('./index');
+
+globalThis.luma = globalThis.luma || {};
+module.exports = Object.assign(globalThis.luma, moduleExports);
+//# sourceMappingURL=bundle.js.map

package/dist/bundle.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/bundle.ts"],"names":["moduleExports","require","globalThis","luma","module","exports","Object","assign"],"mappings":"AACA,MAAMA,aAAa,GAAGC,OAAO,CAAC,SAAD,CAA7B;;AACAC,UAAU,CAACC,IAAX,GAAkBD,UAAU,CAACC,IAAX,IAAmB,EAArC;AACAC,MAAM,CAACC,OAAP,GAAiBC,MAAM,CAACC,MAAP,CAAcL,UAAU,CAACC,IAAzB,EAA+BH,aAA/B,CAAjB","sourcesContent":["// @ts-nocheck\nconst moduleExports = require('./index');\nglobalThis.luma = globalThis.luma || {};\nmodule.exports = Object.assign(globalThis.luma, moduleExports);\n"],"file":"bundle.js"}