@luma.gl/webgpu 9.0.0-alpha.9 → 9.0.0-beta.10

package/dist/adapter/resources/webgpu-render-pipeline.js

@@ -1,164 +1,167 @@
-import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
-import { RenderPipeline, cast, log, isObjectEmpty } from '@luma.gl/api';
-import { applyParametersToRenderPipelineDescriptor } from '../helpers/webgpu-parameters';
-import { getWebGPUTextureFormat } from '../helpers/convert-texture-format';
-import { getBindGroup } from '../helpers/get-bind-group';
-import { getVertexBufferLayout, getBufferSlots } from '../helpers/get-vertex-buffer-layout';
-export default class WebGPURenderPipeline extends RenderPipeline {
-  constructor(device, props) {
-    super(device, props);
-
-    _defineProperty(this, "device", void 0);
-
-    _defineProperty(this, "handle", void 0);
-
-    _defineProperty(this, "vs", void 0);
-
-    _defineProperty(this, "fs", null);
-
-    _defineProperty(this, "_bufferSlots", void 0);
-
-    _defineProperty(this, "_buffers", void 0);
-
-    _defineProperty(this, "_indexBuffer", null);
-
-    _defineProperty(this, "_bindGroupLayout", void 0);
-
-    _defineProperty(this, "_bindGroup", null);
-
-    this.device = device;
-    this.handle = this.props.handle || this.createHandle();
-    this.handle.label = this.props.id;
-    this.vs = cast(props.vs);
-    this.fs = cast(props.fs);
-    this._bufferSlots = getBufferSlots(this.props.layout, this.props.bufferMap);
-    this._buffers = new Array(Object.keys(this._bufferSlots).length).fill(null);
-    this._bindGroupLayout = this.handle.getBindGroupLayout(0);
-  }
-
-  createHandle() {
-    const descriptor = this._getRenderPipelineDescriptor();
-
-    const renderPipeline = this.device.handle.createRenderPipeline(descriptor);
-    log.groupCollapsed(1, "new WebGPRenderPipeline(".concat(this.id, ")"))();
-    log.log(1, JSON.stringify(descriptor, null, 2))();
-    log.groupEnd(1)();
-    return renderPipeline;
-  }
-
-  destroy() {}
-
-  setIndexBuffer(indexBuffer) {
-    this._indexBuffer = cast(indexBuffer);
-  }
-
-  setAttributes(attributes) {
-    for (const [name, buffer] of Object.entries(attributes)) {
-      const bufferIndex = this._bufferSlots[name];
-
-      if (bufferIndex >= 0) {
-        this._buffers[bufferIndex] = buffer;
-      } else {
-        throw new Error("Setting attribute '".concat(name, "' not listed in shader layout for program ").concat(this.id));
-      }
+// luma.gl MIT license
+import { RenderPipeline, cast, log } from '@luma.gl/core';
+import { applyParametersToRenderPipelineDescriptor } from "../helpers/webgpu-parameters.js";
+import { getWebGPUTextureFormat } from "../helpers/convert-texture-format.js";
+import { getBindGroup } from "../helpers/get-bind-group.js";
+import { getVertexBufferLayout } from "../helpers/get-vertex-buffer-layout.js";
+// RENDER PIPELINE
+/** Creates a new render pipeline when parameters change */
+export class WebGPURenderPipeline extends RenderPipeline {
+    device;
+    handle;
+    vs;
+    fs = null;
+    /** For internal use to create BindGroups */
+    _bindings;
+    _bindGroupLayout = null;
+    _bindGroup = null;
+    constructor(device, props) {
+        super(device, props);
+        this.device = device;
+        this.handle = this.props.handle;
+        if (!this.handle) {
+            const descriptor = this._getRenderPipelineDescriptor();
+            log.groupCollapsed(1, `new WebGPURenderPipeline(${this.id})`)();
+            log.probe(1, JSON.stringify(descriptor, null, 2))();
+            log.groupEnd(1)();
+            this.handle = this.device.handle.createRenderPipeline(descriptor);
+        }
+        this.handle.label = this.props.id;
+        this.vs = cast(props.vs);
+        this.fs = cast(props.fs);
+        this._bindings = { ...this.props.bindings };
     }
-  }
-
-  setBindings(bindings) {
-    if (!isObjectEmpty(this.props.bindings)) {
-      Object.assign(this.props.bindings, bindings);
-      this._bindGroup = getBindGroup(this.device.handle, this._bindGroupLayout, this.props.layout, this.props.bindings);
+    destroy() {
+        // WebGPURenderPipeline has no destroy method.
+        this.handle = null;
     }
-  }
-
-  setUniforms(uniforms) {
-    if (!isObjectEmpty(uniforms)) {
-      throw new Error('WebGPU does not support uniforms');
+    /**
+     * @todo Use renderpass.setBindings() ?
+     * @todo Do we want to expose BindGroups in the API and remove this?
+     */
+    setBindings(bindings) {
+        Object.assign(this._bindings, bindings);
     }
-  }
-
-  _getBuffers() {
-    return this._buffers;
-  }
-
-  _getBindGroup() {
-    return this._bindGroup;
-  }
-
-  _getRenderPipelineDescriptor() {
-    const vertex = {
-      module: cast(this.props.vs).handle,
-      entryPoint: this.props.vsEntryPoint || 'main',
-      buffers: getVertexBufferLayout(this.props.layout, this.props.bufferMap)
-    };
-    let fragment;
-
-    if (this.props.fs) {
-      var _this$device, _this$device$canvasCo;
-
-      fragment = {
-        module: cast(this.props.fs).handle,
-        entryPoint: this.props.fsEntryPoint || 'main',
-        targets: [{
-          format: getWebGPUTextureFormat((_this$device = this.device) === null || _this$device === void 0 ? void 0 : (_this$device$canvasCo = _this$device.canvasContext) === null || _this$device$canvasCo === void 0 ? void 0 : _this$device$canvasCo.format)
-        }]
-      };
+    /** @todo - should this be moved to renderpass? */
+    draw(options) {
+        const webgpuRenderPass = options.renderPass;
+        // Set pipeline
+        webgpuRenderPass.handle.setPipeline(this.handle);
+        // Set bindings (uniform buffers, textures etc)
+        const bindGroup = this._getBindGroup();
+        if (bindGroup) {
+            webgpuRenderPass.handle.setBindGroup(0, bindGroup);
+        }
+        // Set attributes
+        // Note: Rebinds constant attributes before each draw call
+        options.vertexArray.bindBeforeRender(options.renderPass);
+        // Draw
+        if (options.indexCount) {
+            webgpuRenderPass.handle.drawIndexed(options.indexCount, options.instanceCount, options.firstIndex, options.baseVertex, options.firstInstance);
+        }
+        else {
+            webgpuRenderPass.handle.draw(options.vertexCount || 0, options.instanceCount || 1, // If 0, nothing will be drawn
+            options.firstInstance);
+        }
+        // Note: Rebinds constant attributes before each draw call
+        options.vertexArray.unbindAfterRender(options.renderPass);
+        return true;
     }
-
-    switch (this.props.topology) {
-      case 'triangle-fan':
-      case 'line-loop':
-        throw new Error("WebGPU does not support primitive topology ".concat(this.props.topology));
-
-      default:
+    /** Return a bind group created by setBindings */
+    _getBindGroup() {
+        if (this.props.shaderLayout.bindings.length === 0) {
+            return null;
+        }
+        // Get hold of the bind group layout. We don't want to do this unless we know there is at least one bind group
+        this._bindGroupLayout = this._bindGroupLayout || this.handle.getBindGroupLayout(0);
+        // Set up the bindings
+        // TODO what if bindings change? We need to rebuild the bind group!
+        this._bindGroup =
+            this._bindGroup ||
+                getBindGroup(this.device.handle, this._bindGroupLayout, this.props.shaderLayout, this._bindings);
+        return this._bindGroup;
     }
-
-    let descriptor = {
-      vertex,
-      fragment,
-      primitive: {
-        topology: this.props.topology
-      }
-    };
-    applyParametersToRenderPipelineDescriptor(descriptor, this.props.parameters);
-    return descriptor;
-  }
-
-  draw(options) {
-    const webgpuRenderPass = cast(options.renderPass) || this.device.getDefaultRenderPass();
-    webgpuRenderPass.handle.setPipeline(this.handle);
-
-    if (this._getBindGroup()) {
-      webgpuRenderPass.handle.setBindGroup(0, this._getBindGroup());
+    /**
+     * Populate the complex WebGPU GPURenderPipelineDescriptor
+     */
+    _getRenderPipelineDescriptor() {
+        // Set up the vertex stage
+        const vertex = {
+            module: cast(this.props.vs).handle,
+            entryPoint: this.props.vertexEntryPoint || 'main',
+            buffers: getVertexBufferLayout(this.props.shaderLayout, this.props.bufferLayout)
+        };
+        // Set up the fragment stage
+        const fragment = {
+            module: cast(this.props.fs).handle,
+            entryPoint: this.props.fragmentEntryPoint || 'main',
+            targets: [
+                {
+                    // TODO exclamation mark hack!
+                    format: getWebGPUTextureFormat(this.device?.canvasContext?.format)
+                }
+            ]
+        };
+        // WebGPU has more restrictive topology support than WebGL
+        switch (this.props.topology) {
+            case 'triangle-fan-webgl':
+            case 'line-loop-webgl':
+                throw new Error(`WebGPU does not support primitive topology ${this.props.topology}`);
+            default:
+        }
+        // Create a partially populated descriptor
+        const descriptor = {
+            vertex,
+            fragment,
+            primitive: {
+                topology: this.props.topology
+            },
+            layout: 'auto'
+        };
+        // Set parameters on the descriptor
+        applyParametersToRenderPipelineDescriptor(descriptor, this.props.parameters);
+        return descriptor;
     }
+}
+/**
+_setAttributeBuffers(webgpuRenderPass: WebGPURenderPass) {
+  if (this._indexBuffer) {
+    webgpuRenderPass.handle.setIndexBuffer(this._indexBuffer.handle, this._indexBuffer.props.indexType);
+  }
 
-    this._setAttributeBuffers(webgpuRenderPass);
-
-    if (options.indexCount) {
-      webgpuRenderPass.handle.drawIndexed(options.indexCount, options.instanceCount, options.firstIndex, options.baseVertex, options.firstInstance);
-    } else {
-      webgpuRenderPass.handle.draw(options.vertexCount || 0, options.instanceCount, options.firstIndex, options.firstInstance);
+  const buffers = this._getBuffers();
+  for (let i = 0; i < buffers.length; ++i) {
+    const buffer = cast<WebGPUBuffer>(buffers[i]);
+    if (!buffer) {
+      const attribute = this.props.shaderLayout.attributes.find(
+        (attribute) => attribute.location === i
+      );
+      throw new Error(
+        `No buffer provided for attribute '${attribute?.name || ''}' in Model '${this.props.id}'`
+      );
     }
+    webgpuRenderPass.handle.setVertexBuffer(i, buffer.handle);
   }
 
-  _setAttributeBuffers(webgpuRenderPass) {
-    if (this._indexBuffer) {
-      webgpuRenderPass.handle.setIndexBuffer(this._indexBuffer.handle, this._indexBuffer.props.indexType);
+  // TODO - HANDLE buffer maps
+  /*
+  for (const [bufferName, attributeMapping] of Object.entries(this.props.bufferLayout)) {
+    const buffer = cast<WebGPUBuffer>(this.props.attributes[bufferName]);
+    if (!buffer) {
+      log.warn(`Missing buffer for buffer map ${bufferName}`)();
+      continue;
     }
 
-    const buffers = this._getBuffers();
-
-    for (let i = 0; i < buffers.length; ++i) {
-      const buffer = cast(buffers[i]);
-
-      if (!buffer) {
-        const attribute = this.props.layout.attributes.find(attribute => attribute.location === i);
-        throw new Error("No buffer provided for attribute '".concat((attribute === null || attribute === void 0 ? void 0 : attribute.name) || '', "' in Model '").concat(this.props.id, "'"));
+    if ('location' in attributeMapping) {
+      // @ts-expect-error TODO model must not depend on webgpu
+      renderPass.handle.setVertexBuffer(layout.location, buffer.handle);
+    } else {
+      for (const [bufferName, mapping] of Object.entries(attributeMapping)) {
+        // @ts-expect-error TODO model must not depend on webgpu
+        renderPass.handle.setVertexBuffer(field.location, buffer.handle);
       }
-
-      webgpuRenderPass.handle.setVertexBuffer(i, buffer.handle);
     }
   }
-
+  *
 }
-//# sourceMappingURL=webgpu-render-pipeline.js.map
+*/

package/dist/adapter/resources/webgpu-sampler.d.ts

@@ -1,13 +1,13 @@
-/// <reference types="@webgpu/types" />
-import { Sampler, SamplerProps } from '@luma.gl/api';
-import type WebGPUDevice from '../webgpu-device';
-export declare type WebGPUSamplerProps = SamplerProps & {
+/// <reference types="dist" />
+import { Sampler, SamplerProps } from '@luma.gl/core';
+import type { WebGPUDevice } from "../webgpu-device.js";
+export type WebGPUSamplerProps = SamplerProps & {
     handle?: GPUSampler;
 };
 /**
  *
  */
-export default class WebGPUSampler extends Sampler {
+export declare class WebGPUSampler extends Sampler {
     readonly device: WebGPUDevice;
     readonly handle: GPUSampler;
     constructor(device: WebGPUDevice, props: WebGPUSamplerProps);

package/dist/adapter/resources/webgpu-sampler.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"webgpu-sampler.d.ts","sourceRoot":"","sources":["../../../src/adapter/resources/webgpu-sampler.ts"],"names":[],"mappings":";AAAA,OAAO,EAAC,OAAO,EAAE,YAAY,EAAC,MAAM,cAAc,CAAC;AACnD,OAAO,KAAK,YAAY,MAAM,kBAAkB,CAAC;AAEjD,oBAAY,kBAAkB,GAAG,YAAY,GAAG;IAC9C,MAAM,CAAC,EAAE,UAAU,CAAC;CACrB,CAAA;AAED;;GAEG;AACH,MAAM,CAAC,OAAO,OAAO,aAAc,SAAQ,OAAO;IAChD,QAAQ,CAAC,MAAM,EAAE,YAAY,CAAC;IAC9B,QAAQ,CAAC,MAAM,EAAE,UAAU,CAAC;gBAEhB,MAAM,EAAE,YAAY,EAAE,KAAK,EAAE,kBAAkB;IAc3D,OAAO,IAAI,IAAI;CAGhB"}
+{"version":3,"file":"webgpu-sampler.d.ts","sourceRoot":"","sources":["../../../src/adapter/resources/webgpu-sampler.ts"],"names":[],"mappings":";AAAA,OAAO,EAAC,OAAO,EAAE,YAAY,EAAC,MAAM,eAAe,CAAC;AACpD,OAAO,KAAK,EAAC,YAAY,EAAC,4BAAyB;AAEnD,MAAM,MAAM,kBAAkB,GAAG,YAAY,GAAG;IAC9C,MAAM,CAAC,EAAE,UAAU,CAAC;CACrB,CAAC;AAEF;;GAEG;AACH,qBAAa,aAAc,SAAQ,OAAO;IACxC,QAAQ,CAAC,MAAM,EAAE,YAAY,CAAC;IAC9B,QAAQ,CAAC,MAAM,EAAE,UAAU,CAAC;gBAEhB,MAAM,EAAE,YAAY,EAAE,KAAK,EAAE,kBAAkB;IAclD,OAAO,IAAI,IAAI;CAMzB"}

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

@@ -1,25 +1,25 @@
-import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
-import { Sampler } from '@luma.gl/api';
-export default class WebGPUSampler extends Sampler {
-  constructor(device, props) {
-    super(device, props);
-
-    _defineProperty(this, "device", void 0);
-
-    _defineProperty(this, "handle", void 0);
-
-    this.device = device;
-    const samplerProps = this.props;
-
-    if (samplerProps.type !== 'comparison-sampler') {
-      delete samplerProps.compare;
+import { Sampler } from '@luma.gl/core';
+/**
+ *
+ */
+export class WebGPUSampler extends Sampler {
+    device;
+    handle;
+    constructor(device, props) {
+        super(device, props);
+        this.device = device;
+        // Prepare sampler props
+        const samplerProps = { ...this.props };
+        if (samplerProps.type !== 'comparison-sampler') {
+            delete samplerProps.compare;
+        }
+        this.handle = this.handle || this.device.handle.createSampler(samplerProps);
+        this.handle.label = this.props.id;
+    }
+    destroy() {
+        // GPUSampler does not have a destroy method
+        // this.handle.destroy();
+        // @ts-expect-error readonly
+        this.handle = null;
     }
-
-    this.handle = this.handle || this.device.handle.createSampler(this.props);
-    this.handle.label = this.props.id;
-  }
-
-  destroy() {}
-
 }
-//# sourceMappingURL=webgpu-sampler.js.map

package/dist/adapter/resources/webgpu-shader.d.ts

@@ -1,21 +1,18 @@
-/// <reference types="@webgpu/types" />
-import type { ShaderProps, CompilerMessage } from '@luma.gl/api';
-import { Shader } from '@luma.gl/api';
-import type WebGPUDevice from '../webgpu-device';
-export declare type WebGPUShaderProps = ShaderProps & {
-    handle?: GPUShaderModule;
-};
+/// <reference types="dist" />
+import type { ShaderProps, CompilerMessage } from '@luma.gl/core';
+import { Shader } from '@luma.gl/core';
+import type { WebGPUDevice } from "../webgpu-device.js";
 /**
  * Immutable shader
  */
-export default class WebGPUShader extends Shader {
+export declare class WebGPUShader extends Shader {
     readonly device: WebGPUDevice;
     readonly handle: GPUShaderModule;
-    constructor(device: WebGPUDevice, props: WebGPUShaderProps);
-    _checkCompilationError(errorScope: Promise<GPUError>): Promise<void>;
+    constructor(device: WebGPUDevice, props: ShaderProps);
+    _checkCompilationError(errorScope: Promise<GPUError | null>): Promise<void>;
     destroy(): void;
-    protected createHandle(): GPUShaderModule;
     /** Returns compilation info for this shader */
-    compilationInfo(): Promise<readonly CompilerMessage[]>;
+    getCompilationInfo(): Promise<readonly CompilerMessage[]>;
+    protected createHandle(): GPUShaderModule;
 }
 //# sourceMappingURL=webgpu-shader.d.ts.map

package/dist/adapter/resources/webgpu-shader.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"webgpu-shader.d.ts","sourceRoot":"","sources":["../../../src/adapter/resources/webgpu-shader.ts"],"names":[],"mappings":";AAAA,OAAO,KAAK,EAAC,WAAW,EAAE,eAAe,EAAC,MAAM,cAAc,CAAC;AAC/D,OAAO,EAAC,MAAM,EAAM,MAAM,cAAc,CAAC;AACzC,OAAO,KAAK,YAAY,MAAM,kBAAkB,CAAC;AAEjD,oBAAY,iBAAiB,GAAG,WAAW,GAAG;IAC5C,MAAM,CAAC,EAAE,eAAe,CAAC;CAC1B,CAAC;AAEF;;GAEG;AACH,MAAM,CAAC,OAAO,OAAO,YAAa,SAAQ,MAAM;IAC9C,QAAQ,CAAC,MAAM,EAAE,YAAY,CAAC;IAC9B,QAAQ,CAAC,MAAM,EAAE,eAAe,CAAC;gBAErB,MAAM,EAAE,YAAY,EAAE,KAAK,EAAE,iBAAiB;IAYpD,sBAAsB,CAAC,UAAU,EAAE,OAAO,CAAC,QAAQ,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;IAW1E,OAAO;IAIP,SAAS,CAAC,YAAY,IAAI,eAAe;IAwBzC,+CAA+C;IACzC,eAAe,IAAI,OAAO,CAAC,SAAS,eAAe,EAAE,CAAC;CAI7D"}
+{"version":3,"file":"webgpu-shader.d.ts","sourceRoot":"","sources":["../../../src/adapter/resources/webgpu-shader.ts"],"names":[],"mappings":";AAIA,OAAO,KAAK,EAAC,WAAW,EAAE,eAAe,EAAC,MAAM,eAAe,CAAC;AAChE,OAAO,EAAC,MAAM,EAAM,MAAM,eAAe,CAAC;AAC1C,OAAO,KAAK,EAAC,YAAY,EAAC,4BAAyB;AAEnD;;GAEG;AACH,qBAAa,YAAa,SAAQ,MAAM;IACtC,QAAQ,CAAC,MAAM,EAAE,YAAY,CAAC;IAC9B,QAAQ,CAAC,MAAM,EAAE,eAAe,CAAC;gBAErB,MAAM,EAAE,YAAY,EAAE,KAAK,EAAE,WAAW;IAY9C,sBAAsB,CAAC,UAAU,EAAE,OAAO,CAAC,QAAQ,GAAG,IAAI,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;IAcxE,OAAO,IAAI,IAAI;IAOxB,+CAA+C;IACzC,kBAAkB,IAAI,OAAO,CAAC,SAAS,eAAe,EAAE,CAAC;IAO/D,SAAS,CAAC,YAAY,IAAI,eAAe;CAU1C"}

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

@@ -1,64 +1,51 @@
-import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
-import { Shader, log } from '@luma.gl/api';
-export default class WebGPUShader extends Shader {
-  constructor(device, props) {
-    super(device, props);
-
-    _defineProperty(this, "device", void 0);
-
-    _defineProperty(this, "handle", void 0);
-
-    this.device = device;
-    this.device.handle.pushErrorScope('validation');
-    this.handle = this.props.handle || this.createHandle();
-    this.handle.label = this.props.id;
-
-    this._checkCompilationError(this.device.handle.popErrorScope());
-  }
-
-  async _checkCompilationError(errorScope) {
-    const error = await errorScope;
-
-    if (error) {
-      const shaderLog = await this.compilationInfo();
-      log.error("Shader compilation error: ".concat(error.message), shaderLog)();
-      throw new Error("Shader compilation error: ".concat(error.message));
+// luma.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+import { Shader, log } from '@luma.gl/core';
+/**
+ * Immutable shader
+ */
+export class WebGPUShader extends Shader {
+    device;
+    handle;
+    constructor(device, props) {
+        super(device, props);
+        this.device = device;
+        this.device.handle.pushErrorScope('validation');
+        this.handle = this.props.handle || this.createHandle();
+        this.handle.label = this.props.id;
+        this._checkCompilationError(this.device.handle.popErrorScope());
     }
-  }
-
-  destroy() {}
-
-  createHandle() {
-    const {
-      source
-    } = this.props;
-    let language = this.props.language;
-
-    if (!language) {
-      language = source.includes('->') ? 'wgsl' : 'glsl';
+    async _checkCompilationError(errorScope) {
+        const error = (await errorScope);
+        if (error) {
+            // The `Shader` base class will determine if debug window should be opened based on props
+            this.debugShader();
+            const shaderLog = await this.getCompilationInfo();
+            log.error(`Shader compilation error: ${error.message}`, shaderLog)();
+            // Note: Even though this error is asynchronous and thrown after the constructor completes,
+            // it will result in a useful stack trace leading back to the constructor
+            throw new Error(`Shader compilation error: ${error.message}`);
+        }
     }
-
-    switch (language) {
-      case 'wgsl':
-        return this.device.handle.createShaderModule({
-          code: source
-        });
-
-      case 'glsl':
-        return this.device.handle.createShaderModule({
-          code: source,
-          transform: glsl => this.device.glslang.compileGLSL(glsl, type)
-        });
-
-      default:
-        throw new Error(language);
+    destroy() {
+        // Note: WebGPU does not offer a method to destroy shaders
+        // this.handle.destroy();
+        // @ts-expect-error readonly
+        this.handle = null;
+    }
+    /** Returns compilation info for this shader */
+    async getCompilationInfo() {
+        const compilationInfo = await this.handle.getCompilationInfo();
+        return compilationInfo.messages;
+    }
+    // PRIVATE METHODS
+    createHandle() {
+        const { source } = this.props;
+        const isGLSL = source.includes('#version');
+        if (this.props.language === 'glsl' || isGLSL) {
+            throw new Error('GLSL shaders are not supported in WebGPU');
+        }
+        return this.device.handle.createShaderModule({ code: source });
     }
-  }
-
-  async compilationInfo() {
-    const compilationInfo = await this.handle.compilationInfo();
-    return compilationInfo.messages;
-  }
-
 }
-//# sourceMappingURL=webgpu-shader.js.map

package/dist/adapter/resources/webgpu-texture-view.d.ts

@@ -0,0 +1,20 @@
+/// <reference types="dist" />
+import { TextureView, TextureViewProps } from '@luma.gl/core';
+import type { WebGPUDevice } from "../webgpu-device.js";
+import type { WebGPUTexture } from "./webgpu-texture.js";
+export type WebGPUTextureViewProps = TextureViewProps & {
+    handle?: GPUTextureView;
+};
+/**
+ *
+ */
+export declare class WebGPUTextureView extends TextureView {
+    readonly device: WebGPUDevice;
+    readonly handle: GPUTextureView;
+    readonly texture: WebGPUTexture;
+    constructor(device: WebGPUDevice, props: WebGPUTextureViewProps & {
+        texture: WebGPUTexture;
+    });
+    destroy(): void;
+}
+//# sourceMappingURL=webgpu-texture-view.d.ts.map

package/dist/adapter/resources/webgpu-texture-view.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"webgpu-texture-view.d.ts","sourceRoot":"","sources":["../../../src/adapter/resources/webgpu-texture-view.ts"],"names":[],"mappings":";AAIA,OAAO,EAAC,WAAW,EAAE,gBAAgB,EAAC,MAAM,eAAe,CAAC;AAC5D,OAAO,KAAK,EAAC,YAAY,EAAC,4BAAyB;AACnD,OAAO,KAAK,EAAC,aAAa,EAAC,4BAAyB;AAEpD,MAAM,MAAM,sBAAsB,GAAG,gBAAgB,GAAG;IACtD,MAAM,CAAC,EAAE,cAAc,CAAC;CACzB,CAAC;AAEF;;GAEG;AACH,qBAAa,iBAAkB,SAAQ,WAAW;IAChD,QAAQ,CAAC,MAAM,EAAE,YAAY,CAAC;IAC9B,QAAQ,CAAC,MAAM,EAAE,cAAc,CAAC;IAChC,QAAQ,CAAC,OAAO,EAAE,aAAa,CAAC;gBAEpB,MAAM,EAAE,YAAY,EAAE,KAAK,EAAE,sBAAsB,GAAG;QAAC,OAAO,EAAE,aAAa,CAAA;KAAC;IAmBjF,OAAO,IAAI,IAAI;CAMzB"}

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

@@ -0,0 +1,35 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+import { TextureView } from '@luma.gl/core';
+/**
+ *
+ */
+export class WebGPUTextureView extends TextureView {
+    device;
+    handle;
+    texture;
+    constructor(device, props) {
+        super(device, props);
+        this.device = device;
+        this.texture = props.texture;
+        this.handle =
+            this.handle ||
+                this.texture.handle.createView({
+                    format: (props.format || this.texture.format),
+                    dimension: props.dimension || this.texture.dimension,
+                    aspect: props.aspect,
+                    baseMipLevel: props.baseMipLevel,
+                    mipLevelCount: props.mipLevelCount, // GPUIntegerCoordinate;
+                    baseArrayLayer: props.baseArrayLayer, // GPUIntegerCoordinate;
+                    arrayLayerCount: props.arrayLayerCount // GPUIntegerCoordinate;
+                });
+        this.handle.label = this.props.id;
+    }
+    destroy() {
+        // GPUTextureView does not have a destroy method
+        // this.handle.destroy();
+        // @ts-expect-error readonly
+        this.handle = null;
+    }
+}