@babylonjs/core 7.4.0 → 7.6.0

package/Engines/webgpuEngine.d.ts

@@ -10,7 +10,8 @@ import type { BaseTexture } from "../Materials/Textures/baseTexture";
 import type { IShaderProcessor } from "./Processors/iShaderProcessor";
 import type { ShaderProcessingContext } from "./Processors/shaderProcessingOptions";
 import { WebGPUTextureManager } from "./WebGPU/webgpuTextureManager";
-import { type ISceneLike, AbstractEngine } from "./abstractEngine";
+import { AbstractEngine } from "./abstractEngine";
+import type { ISceneLike, AbstractEngineOptions } from "./abstractEngine";
 import { WebGPUBufferManager } from "./WebGPU/webgpuBufferManager";
 import type { HardwareTextureWrapper } from "../Materials/Textures/hardwareTextureWrapper";
 import { WebGPUHardwareTexture } from "./WebGPU/webgpuHardwareTexture";
@@ -36,7 +37,6 @@ import type { RenderTargetTexture } from "../Materials/Textures/renderTargetText
 import type { RenderTargetWrapper } from "./renderTargetWrapper";
 import { WebGPUPerfCounter } from "./WebGPU/webgpuPerfCounter";
 import type { Scene } from "../scene";
-import type { AbstractEngineOptions } from "./abstractEngine";
 import type { PostProcess } from "../PostProcesses/postProcess";
 import { PerformanceMonitor } from "../Misc/performanceMonitor";
 import "./AbstractEngine/abstractEngine.loadingScreen";
@@ -44,6 +44,8 @@ import "./AbstractEngine/abstractEngine.dom";
 import "./AbstractEngine/abstractEngine.states";
 import "./AbstractEngine/abstractEngine.renderPass";
 import "../Audio/audioEngine";
+import type { TextureSampler } from "../Materials/Textures/textureSampler";
+import type { StorageBuffer } from "../Buffers/storageBuffer";
 /** @internal */
 interface IWebGPURenderPassWrapper {
     renderPassDescriptor: Nullable<GPURenderPassDescriptor>;
@@ -1018,5 +1020,55 @@ export declare class WebGPUEngine extends AbstractEngine {
      * @returns the error code
      */
     getError(): number;
+    /**
+     * Creates an external texture
+     * @param video video element
+     * @returns the external texture, or null if external textures are not supported by the engine
+     */
+    createExternalTexture(video: HTMLVideoElement): Nullable<ExternalTexture>;
+    /**
+     * Sets an internal texture to the according uniform.
+     * @param name The name of the uniform in the effect
+     * @param texture The texture to apply
+     */
+    setExternalTexture(name: string, texture: Nullable<ExternalTexture>): void;
+    /**
+     * Sets a texture sampler to the according uniform.
+     * @param name The name of the uniform in the effect
+     * @param sampler The sampler to apply
+     */
+    setTextureSampler(name: string, sampler: Nullable<TextureSampler>): void;
+    /**
+     * Creates a storage buffer
+     * @param data the data for the storage buffer or the size of the buffer
+     * @param creationFlags flags to use when creating the buffer (see Constants.BUFFER_CREATIONFLAG_XXX). The BUFFER_CREATIONFLAG_STORAGE flag will be automatically added
+     * @param label defines the label of the buffer (for debug purpose)
+     * @returns the new buffer
+     */
+    createStorageBuffer(data: DataArray | number, creationFlags: number, label?: string): DataBuffer;
+    /**
+     * Updates a storage buffer
+     * @param buffer the storage buffer to update
+     * @param data the data used to update the storage buffer
+     * @param byteOffset the byte offset of the data
+     * @param byteLength the byte length of the data
+     */
+    updateStorageBuffer(buffer: DataBuffer, data: DataArray, byteOffset?: number, byteLength?: number): void;
+    /**
+     * Read data from a storage buffer
+     * @param storageBuffer The storage buffer to read from
+     * @param offset The offset in the storage buffer to start reading from (default: 0)
+     * @param size  The number of bytes to read from the storage buffer (default: capacity of the buffer)
+     * @param buffer The buffer to write the data we have read from the storage buffer to (optional)
+     * @param noDelay If true, a call to flushFramebuffer will be issued so that the data can be read back immediately and not in engine.onEndFrameObservable. This can speed up data retrieval, at the cost of a small perf penalty (default: false).
+     * @returns If not undefined, returns the (promise) buffer (as provided by the 4th parameter) filled with the data, else it returns a (promise) Uint8Array with the data read from the storage buffer
+     */
+    readFromStorageBuffer(storageBuffer: DataBuffer, offset?: number, size?: number, buffer?: ArrayBufferView, noDelay?: boolean): Promise<ArrayBufferView>;
+    /**
+     * Sets a storage buffer in the shader
+     * @param name Defines the name of the storage buffer as defined in the shader
+     * @param buffer Defines the value to give to the uniform
+     */
+    setStorageBuffer(name: string, buffer: Nullable<StorageBuffer>): void;
 }
 export {};

package/Engines/webgpuEngine.js

@@ -49,6 +49,7 @@ import "./AbstractEngine/abstractEngine.states.js";
 import "./AbstractEngine/abstractEngine.renderPass.js";
 import "../Audio/audioEngine.js";
 import { resetCachedPipeline } from "../Materials/effect.functions.js";
+import { WebGPUExternalTexture } from "./WebGPU/webgpuExternalTexture.js";
 const viewDescriptorSwapChainAntialiasing = {
     label: `TextureView_SwapChain_ResolveTarget`,
     dimension: WebGPUConstants.TextureDimension.E2d,
@@ -3055,6 +3056,152 @@ export class WebGPUEngine extends AbstractEngine {
         // TODO WEBGPU. from the webgpu errors.
         return 0;
     }
+    //------------------------------------------------------------------------------
+    //                              External Textures
+    //------------------------------------------------------------------------------
+    /**
+     * Creates an external texture
+     * @param video video element
+     * @returns the external texture, or null if external textures are not supported by the engine
+     */
+    createExternalTexture(video) {
+        const texture = new WebGPUExternalTexture(video);
+        return texture;
+    }
+    /**
+     * Sets an internal texture to the according uniform.
+     * @param name The name of the uniform in the effect
+     * @param texture The texture to apply
+     */
+    setExternalTexture(name, texture) {
+        if (!texture) {
+            this._currentMaterialContext.setTexture(name, null);
+            return;
+        }
+        this._setInternalTexture(name, texture);
+    }
+    //------------------------------------------------------------------------------
+    //                              Samplers
+    //------------------------------------------------------------------------------
+    /**
+     * Sets a texture sampler to the according uniform.
+     * @param name The name of the uniform in the effect
+     * @param sampler The sampler to apply
+     */
+    setTextureSampler(name, sampler) {
+        this._currentMaterialContext?.setSampler(name, sampler);
+    }
+    //------------------------------------------------------------------------------
+    //                              Storage Buffers
+    //------------------------------------------------------------------------------
+    /**
+     * Creates a storage buffer
+     * @param data the data for the storage buffer or the size of the buffer
+     * @param creationFlags flags to use when creating the buffer (see undefined). The BUFFER_CREATIONFLAG_STORAGE flag will be automatically added
+     * @param label defines the label of the buffer (for debug purpose)
+     * @returns the new buffer
+     */
+    createStorageBuffer(data, creationFlags, label) {
+        return this._createBuffer(data, creationFlags | 32, label);
+    }
+    /**
+     * Updates a storage buffer
+     * @param buffer the storage buffer to update
+     * @param data the data used to update the storage buffer
+     * @param byteOffset the byte offset of the data
+     * @param byteLength the byte length of the data
+     */
+    updateStorageBuffer(buffer, data, byteOffset, byteLength) {
+        const dataBuffer = buffer;
+        if (byteOffset === undefined) {
+            byteOffset = 0;
+        }
+        let view;
+        if (byteLength === undefined) {
+            if (data instanceof Array) {
+                view = new Float32Array(data);
+            }
+            else if (data instanceof ArrayBuffer) {
+                view = new Uint8Array(data);
+            }
+            else {
+                view = data;
+            }
+            byteLength = view.byteLength;
+        }
+        else {
+            if (data instanceof Array) {
+                view = new Float32Array(data);
+            }
+            else if (data instanceof ArrayBuffer) {
+                view = new Uint8Array(data);
+            }
+            else {
+                view = data;
+            }
+        }
+        this._bufferManager.setSubData(dataBuffer, byteOffset, view, 0, byteLength);
+    }
+    /**
+     * Read data from a storage buffer
+     * @param storageBuffer The storage buffer to read from
+     * @param offset The offset in the storage buffer to start reading from (default: 0)
+     * @param size  The number of bytes to read from the storage buffer (default: capacity of the buffer)
+     * @param buffer The buffer to write the data we have read from the storage buffer to (optional)
+     * @param noDelay If true, a call to flushFramebuffer will be issued so that the data can be read back immediately and not in engine.onEndFrameObservable. This can speed up data retrieval, at the cost of a small perf penalty (default: false).
+     * @returns If not undefined, returns the (promise) buffer (as provided by the 4th parameter) filled with the data, else it returns a (promise) Uint8Array with the data read from the storage buffer
+     */
+    readFromStorageBuffer(storageBuffer, offset, size, buffer, noDelay) {
+        size = size || storageBuffer.capacity;
+        const gpuBuffer = this._bufferManager.createRawBuffer(size, WebGPUConstants.BufferUsage.MapRead | WebGPUConstants.BufferUsage.CopyDst, undefined, "TempReadFromStorageBuffer");
+        this._renderEncoder.copyBufferToBuffer(storageBuffer.underlyingResource, offset ?? 0, gpuBuffer, 0, size);
+        return new Promise((resolve, reject) => {
+            const readFromBuffer = () => {
+                gpuBuffer.mapAsync(WebGPUConstants.MapMode.Read, 0, size).then(() => {
+                    const copyArrayBuffer = gpuBuffer.getMappedRange(0, size);
+                    let data = buffer;
+                    if (data === undefined) {
+                        data = new Uint8Array(size);
+                        data.set(new Uint8Array(copyArrayBuffer));
+                    }
+                    else {
+                        const ctor = data.constructor; // we want to create result data with the same type as buffer (Uint8Array, Float32Array, ...)
+                        data = new ctor(data.buffer);
+                        data.set(new ctor(copyArrayBuffer));
+                    }
+                    gpuBuffer.unmap();
+                    this._bufferManager.releaseBuffer(gpuBuffer);
+                    resolve(data);
+                }, (reason) => {
+                    if (this.isDisposed) {
+                        resolve(new Uint8Array());
+                    }
+                    else {
+                        reject(reason);
+                    }
+                });
+            };
+            if (noDelay) {
+                this.flushFramebuffer();
+                readFromBuffer();
+            }
+            else {
+                // we are using onEndFrameObservable because we need to map the gpuBuffer AFTER the command buffers
+                // have been submitted, else we get the error: "Buffer used in a submit while mapped"
+                this.onEndFrameObservable.addOnce(() => {
+                    readFromBuffer();
+                });
+            }
+        });
+    }
+    /**
+     * Sets a storage buffer in the shader
+     * @param name Defines the name of the storage buffer as defined in the shader
+     * @param buffer Defines the value to give to the uniform
+     */
+    setStorageBuffer(name, buffer) {
+        this._currentDrawContext?.setBuffer(name, buffer?.getBuffer() ?? null);
+    }
 }
 // Default glslang options.
 WebGPUEngine._GLSLslangDefaultOptions = {