@luma.gl/webgpu 9.0.0-beta.4 → 9.0.0-beta.6

package/dist/adapter/webgpu-device.js

@@ -1,4 +1,7 @@
-import { Device, CanvasContext, log, uid } from '@luma.gl/core';
+// luma.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+import { Device, DeviceFeatures, CanvasContext, log, uid } from '@luma.gl/core';
 import { WebGPUBuffer } from "./resources/webgpu-buffer.js";
 import { WebGPUTexture } from "./resources/webgpu-texture.js";
 import { WebGPUExternalTexture } from "./resources/webgpu-external-texture.js";
@@ -8,226 +11,267 @@ 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 {WebGPUCommandEncoder} from './resources/webgpu-command-encoder';
 import { WebGPUVertexArray } from "./resources/webgpu-vertex-array.js";
 import { WebGPUCanvasContext } from "./webgpu-canvas-context.js";
+import { WebGPUQuerySet } from "./resources/webgpu-query-set.js";
+/** WebGPU Device implementation */
 export 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');
-    }
-    const adapterInfo = await adapter.requestAdapterInfo();
-    log.probe(2, 'Adapter available', adapterInfo)();
-    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, adapterInfo, props);
-    log.probe(1, 'Device created. For more info, set chrome://flags/#enable-webgpu-developer-features')();
-    log.table(1, device.info)();
-    log.groupEnd(1)();
-    return device;
-  }
-  constructor(device, adapter, adapterInfo, props) {
-    super({
-      ...props,
-      id: props.id || uid('webgpu-device')
-    });
-    this.handle = void 0;
-    this.adapter = void 0;
-    this.lost = void 0;
-    this.canvasContext = null;
-    this.commandEncoder = null;
-    this.renderPass = null;
-    this._info = void 0;
-    this._isLost = false;
-    this.features = void 0;
-    this.handle = device;
-    this.adapter = adapter;
-    const [driver, driverVersion] = (adapterInfo.driver || '').split(' Version ');
-    const vendor = adapterInfo.vendor || this.adapter.__brand || 'unknown';
-    const renderer = driver || '';
-    const version = driverVersion || '';
-    const gpu = vendor === 'apple' ? 'apple' : 'unknown';
-    const gpuArchitecture = adapterInfo.architecture || 'unknown';
-    const gpuBackend = adapterInfo.backend || 'unknown';
-    const gpuType = (adapterInfo.type || '').split(' ')[0].toLowerCase() || 'unknown';
-    this._info = {
-      type: 'webgpu',
-      vendor,
-      renderer,
-      version,
-      gpu,
-      gpuType,
-      gpuBackend,
-      gpuArchitecture,
-      shadingLanguage: 'wgsl',
-      shadingLanguageVersion: 100
-    };
-    this.lost = new Promise(async resolve => {
-      const lostInfo = await this.handle.lost;
-      this._isLost = true;
-      resolve({
-        reason: 'destroyed',
-        message: lostInfo.message
-      });
-    });
-    this.canvasContext = new WebGPUCanvasContext(this, this.adapter, {
-      canvas: props.canvas,
-      height: props.height,
-      width: props.width,
-      container: props.container
-    });
-    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) {
-    const newProps = this._getBufferProps(props);
-    return new WebGPUBuffer(this, newProps);
-  }
-  _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);
-  }
-  createVertexArray(props) {
-    return new WebGPUVertexArray(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);
-  }
-  createTransformFeedback(props) {
-    throw new Error('Transform feedback not supported in WebGPU');
-  }
-  createCanvasContext(props) {
-    return new WebGPUCanvasContext(this, this.adapter, props);
-  }
-  getDefaultRenderPass() {
-    throw new Error('a');
-  }
-  submit() {
-    var _this$commandEncoder;
-    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;
-  }
-  _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;
-  }
-  copyExternalImageToTexture(options) {
-    var _this$handle;
-    const {
-      source,
-      sourceX = 0,
-      sourceY = 0,
-      texture,
-      mipLevel = 0,
-      aspect = 'all',
-      colorSpace = 'display-p3',
-      premultipliedAlpha = false,
-      width = texture.width,
-      height = texture.height,
-      depth = 1
-    } = options;
-    const webGpuTexture = texture;
-    (_this$handle = this.handle) === null || _this$handle === void 0 ? void 0 : _this$handle.queue.copyExternalImageToTexture({
-      source,
-      origin: [sourceX, sourceY]
-    }, {
-      texture: webGpuTexture.handle,
-      origin: [0, 0, 0],
-      mipLevel,
-      aspect,
-      colorSpace,
-      premultipliedAlpha
-    }, [width, height, depth]);
-  }
+    static type = 'webgpu';
+    /** The underlying WebGPU device */
+    handle;
+    /* The underlying WebGPU adapter */
+    adapter;
+    /* The underlying WebGPU adapter's info */
+    adapterInfo;
+    features;
+    info;
+    limits;
+    lost;
+    canvasContext = null;
+    _isLost = false;
+    commandEncoder = null;
+    renderPass = null;
+    /** 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');
+        }
+        const adapterInfo = await adapter.requestAdapterInfo();
+        log.probe(2, 'Adapter available', adapterInfo)();
+        const requiredFeatures = [];
+        const requiredLimits = {};
+        if (props.requestMaximalLimits) {
+            requiredFeatures.push(...Array.from(adapter.features));
+            for (const key in adapter.limits) {
+                requiredLimits[key] = adapter.limits[key];
+            }
+            delete requiredLimits.minSubgroupSize;
+            delete requiredLimits.maxSubgroupSize;
+        }
+        const gpuDevice = await adapter.requestDevice({
+            requiredFeatures,
+            requiredLimits
+        });
+        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, adapterInfo, props);
+        log.probe(1, 'Device created. For more info, set chrome://flags/#enable-webgpu-developer-features')();
+        log.table(1, device.info)();
+        log.groupEnd(1)();
+        return device;
+    }
+    constructor(device, adapter, adapterInfo, props) {
+        super({ ...props, id: props.id || uid('webgpu-device') });
+        this.handle = device;
+        this.adapter = adapter;
+        this.adapterInfo = adapterInfo;
+        this.info = this._getInfo();
+        this.features = this._getFeatures();
+        this.limits = this.handle.limits;
+        // "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,
+            height: props.height,
+            width: props.width,
+            container: props.container
+        });
+        // }
+    }
+    // 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();
+    }
+    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) {
+        const newProps = this._getBufferProps(props);
+        return new WebGPUBuffer(this, newProps);
+    }
+    _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);
+    }
+    createVertexArray(props) {
+        return new WebGPUVertexArray(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);
+    }
+    // createCommandEncoder(props: CommandEncoderProps): WebGPUCommandEncoder {
+    //   return new WebGPUCommandEncoder(this, props);
+    // }
+    createTransformFeedback(props) {
+        throw new Error('Transform feedback not supported in WebGPU');
+    }
+    createQuerySet(props) {
+        return new WebGPUQuerySet(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.
+     * @deprecated Create explicit pass with device.beginRenderPass
+     */
+    getDefaultRenderPass() {
+        // this.renderPass =
+        //   this.renderPass ||
+        //   this.beginRenderPass({
+        //     framebuffer: this.canvasContext?.getCurrentFramebuffer()
+        //   });
+        // return this.renderPass;
+        throw new Error('a');
+    }
+    submit() {
+        // this.renderPass?.end();
+        const commandBuffer = this.commandEncoder?.finish();
+        if (commandBuffer) {
+            this.handle.queue.submit([commandBuffer]);
+        }
+        this.commandEncoder = null;
+        // this.renderPass = null;
+    }
+    // PRIVATE METHODS
+    _getInfo() {
+        const [driver, driverVersion] = (this.adapterInfo.driver || '').split(' Version ');
+        // See https://developer.chrome.com/blog/new-in-webgpu-120#adapter_information_updates
+        const vendor = this.adapterInfo.vendor || this.adapter.__brand || 'unknown';
+        const renderer = driver || '';
+        const version = driverVersion || '';
+        const gpu = vendor === 'apple' ? 'apple' : 'unknown'; // 'nvidia' | 'amd' | 'intel' | 'apple' | 'unknown',
+        const gpuArchitecture = this.adapterInfo.architecture || 'unknown';
+        const gpuBackend = this.adapterInfo.backend || 'unknown';
+        const gpuType = (this.adapterInfo.type || '').split(' ')[0].toLowerCase() || 'unknown';
+        return {
+            type: 'webgpu',
+            vendor,
+            renderer,
+            version,
+            gpu,
+            gpuType,
+            gpuBackend,
+            gpuArchitecture,
+            shadingLanguage: 'wgsl',
+            shadingLanguageVersion: 100
+        };
+    }
+    _getFeatures() {
+        // Initialize with actual WebGPU Features (note that unknown features may not be in DeviceFeature type)
+        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');
+        }
+        // Some subsets of WebGPU extensions correspond to WebGL extensions
+        if (features.has('texture-compression-bc')) {
+            features.add('texture-compression-bc5-webgl');
+        }
+        const WEBGPU_ALWAYS_FEATURES = [
+            'timer-query-webgl',
+            'compilation-status-async-webgl',
+            'float32-renderable-webgl',
+            'float16-renderable-webgl',
+            'norm16-renderable-webgl',
+            'texture-filterable-anisotropic-webgl',
+            'shader-noperspective-interpolation-webgl'
+        ];
+        for (const feature of WEBGPU_ALWAYS_FEATURES) {
+            features.add(feature);
+        }
+        return new DeviceFeatures(Array.from(features));
+    }
+    copyExternalImageToTexture(options) {
+        const { source, sourceX = 0, sourceY = 0, texture, mipLevel = 0, aspect = 'all', colorSpace = 'display-p3', premultipliedAlpha = false, 
+        // destinationX,
+        // destinationY,
+        // desitnationZ,
+        width = texture.width, height = texture.height, depth = 1 } = options;
+        const webGpuTexture = texture;
+        this.handle?.queue.copyExternalImageToTexture(
+        // source: GPUImageCopyExternalImage
+        {
+            source,
+            origin: [sourceX, sourceY]
+        }, 
+        // destination: GPUImageCopyTextureTagged
+        {
+            texture: webGpuTexture.handle,
+            origin: [0, 0, 0], // [x, y, z],
+            mipLevel,
+            aspect,
+            colorSpace,
+            premultipliedAlpha
+        }, 
+        // copySize: GPUExtent3D
+        [width, height, depth]);
+    }
 }
-WebGPUDevice.type = 'webgpu';
-//# sourceMappingURL=webgpu-device.js.map

package/dist/adapter/webgpu-types.js

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