@luma.gl/webgpu 9.0.0-alpha.14 → 9.0.0-alpha.16

package/dist/adapter/webgpu-device.js

@@ -1,244 +1,217 @@
-import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+/// <reference types="@webgpu/types" />
 import { Device, CanvasContext, log, uid } 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'
-    });
-
-    if (!adapter) {
-      throw new Error('Failed to request WebGPU adapter');
-    }
-
-    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,
-      id: props.id || uid('webgpu-device')
-    });
-
-    _defineProperty(this, "handle", void 0);
-
-    _defineProperty(this, "adapter", void 0);
-
-    _defineProperty(this, "lost", void 0);
-
-    _defineProperty(this, "canvasContext", null);
-
-    _defineProperty(this, "commandEncoder", null);
-
-    _defineProperty(this, "renderPass", null);
-
-    _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 = new Promise(async resolve => {
-      const lostInfo = await this.handle.lost;
-      this._isLost = true;
-      resolve({
-        reason: 'destroyed',
-        message: lostInfo.message
-      });
-    });
-
-    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() {
-    var _this$canvasContext;
-
-    this.renderPass = this.renderPass || this.beginRenderPass({
-      framebuffer: (_this$canvasContext = this.canvasContext) === null || _this$canvasContext === void 0 ? void 0 : _this$canvasContext.getCurrentFramebuffer()
-    });
-    return this.renderPass;
-  }
-
-  submit() {
-    var _this$renderPass, _this$commandEncoder;
-
-    (_this$renderPass = this.renderPass) === null || _this$renderPass === void 0 ? void 0 : _this$renderPass.endPass();
-    const commandBuffer = (_this$commandEncoder = this.commandEncoder) === null || _this$commandEncoder === void 0 ? void 0 : _this$commandEncoder.finish();
-
-    if (commandBuffer) {
-      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;
-  }
-
+import WebGPUBuffer from './resources/webgpu-buffer.js';
+import WebGPUTexture from './resources/webgpu-texture.js';
+import WebGPUExternalTexture from './resources/webgpu-external-texture.js';
+import WebGPUSampler from './resources/webgpu-sampler.js';
+import WebGPUShader from './resources/webgpu-shader.js';
+import WebGPURenderPipeline from './resources/webgpu-render-pipeline.js';
+import WebGPUComputePipeline from './resources/webgpu-compute-pipeline.js';
+import WebGPURenderPass from './resources/webgpu-render-pass.js';
+import WebGPUComputePass from './resources/webgpu-compute-pass.js';
+import WebGPUCanvasContext from './webgpu-canvas-context.js';
+// import {loadGlslangModule} from '../glsl/glslang.js';
+/** WebGPU Device implementation */
+class WebGPUDevice extends Device {
+    /** Check if WebGPU is available */
+    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'
+            // forceSoftware: false
+        });
+        if (!adapter) {
+            throw new Error('Failed to request WebGPU adapter');
+        }
+        log.probe(1, 'Adapter available')();
+        const gpuDevice = await adapter.requestDevice({
+            requiredFeatures: adapter.features
+            // TODO ensure we obtain best limits
+            // requiredLimits: adapter.limits
+        });
+        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, id: props.id || uid('webgpu-device') });
+        this.canvasContext = null;
+        this.commandEncoder = null;
+        this.renderPass = null;
+        this._isLost = false;
+        this.handle = device;
+        this.adapter = adapter;
+        this._info = {
+            type: 'webgpu',
+            vendor: this.adapter.__brand,
+            renderer: '',
+            version: '',
+            gpu: 'unknown',
+            shadingLanguages: ['glsl', 'wgsl'],
+            shadingLanguageVersions: {
+                glsl: '450',
+                wgsl: '100'
+            },
+            vendorMasked: '',
+            rendererMasked: ''
+        };
+        // "Context" loss handling
+        this.lost = new Promise(async (resolve) => {
+            const lostInfo = await this.handle.lost;
+            this._isLost = true;
+            resolve({ reason: 'destroyed', message: lostInfo.message });
+        });
+        // Note: WebGPU devices can be created without a canvas, for compute shader purposes
+        if (props.canvas) {
+            this.canvasContext = new WebGPUCanvasContext(this, this.adapter, { canvas: props.canvas });
+        }
+        this.features = this._getFeatures();
+    }
+    // TODO
+    // Load the glslang module now so that it is available synchronously when compiling shaders
+    // const {glsl = true} = props;
+    // this.glslang = glsl && await loadGlslangModule();
+    destroy() {
+        this.handle.destroy();
+    }
+    get info() {
+        return this._info;
+    }
+    get limits() {
+        return this.handle.limits;
+    }
+    isTextureFormatSupported(format) {
+        return !format.includes('webgl');
+    }
+    /** @todo implement proper check? */
+    isTextureFormatFilterable(format) {
+        return this.isTextureFormatSupported(format);
+    }
+    /** @todo implement proper check? */
+    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);
+    }
+    // WebGPU specifics
+    /**
+     * Allows a render pass to begin against a canvas context
+     * @todo need to support a "Framebuffer" equivalent (aka preconfigured RenderPassDescriptors?).
+     */
+    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);
+    }
+    /**
+     * Gets default renderpass encoder.
+     * Creates a new encoder against default canvasContext if not already created
+     * @note Called internally by Model.
+     */
+    getDefaultRenderPass() {
+        this.renderPass =
+            this.renderPass ||
+                this.beginRenderPass({
+                    framebuffer: this.canvasContext?.getCurrentFramebuffer()
+                });
+        return this.renderPass;
+    }
+    submit() {
+        this.renderPass?.end();
+        const commandBuffer = this.commandEncoder?.finish();
+        if (commandBuffer) {
+            this.handle.queue.submit([commandBuffer]);
+        }
+        this.commandEncoder = null;
+        this.renderPass = null;
+    }
+    _getFeatures() {
+        // WebGPU Features
+        const features = new Set(this.handle.features);
+        // Fixups for pre-standard names: https://github.com/webgpu-native/webgpu-headers/issues/133
+        // @ts-expect-error Chrome Canary v99
+        if (features.has('depth-clamping')) {
+            // @ts-expect-error Chrome Canary v99
+            features.delete('depth-clamping');
+            features.add('depth-clip-control');
+        }
+        // Add subsets
+        if (features.has('texture-compression-bc')) {
+            features.add('texture-compression-bc5-webgl');
+        }
+        features.add('webgpu');
+        features.add('timer-query-webgl');
+        // WEBGL1 SUPPORT
+        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');
+        // TEXTURES, RENDERBUFFERS
+        features.add('texture-formats-srgb-webgl1');
+        // TEXTURES
+        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');
+        // FRAMEBUFFERS, TEXTURES AND RENDERBUFFERS
+        features.add('texture-renderable-rgba32float-webgl');
+        features.add('texture-renderable-float32-webgl');
+        features.add('texture-renderable-float16-webgl');
+        // GLSL extensions
+        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
+WebGPUDevice.type = 'webgpu';
+export default WebGPUDevice;

package/dist/adapter/webgpu-types.js

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

package/dist/bundle.js

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