@babylonjs/core 6.36.0 → 6.37.0

package/Engines/webgpuEngine.d.ts

@@ -10,7 +10,7 @@ import type { DataBuffer } from "../Buffers/dataBuffer";
 import type { BaseTexture } from "../Materials/Textures/baseTexture";
 import type { IShaderProcessor } from "./Processors/iShaderProcessor";
 import type { ShaderProcessingContext } from "./Processors/shaderProcessingOptions";
-import { WebGPUTextureHelper } from "./WebGPU/webgpuTextureHelper";
+import { WebGPUTextureManager } from "./WebGPU/webgpuTextureManager";
 import type { ISceneLike, ThinEngineOptions } from "./thinEngine";
 import { WebGPUBufferManager } from "./WebGPU/webgpuBufferManager";
 import type { HardwareTextureWrapper } from "../Materials/Textures/hardwareTextureWrapper";
@@ -112,8 +112,11 @@ export interface WebGPUEngineOptions extends ThinEngineOptions, GPURequestAdapte
  */
 export declare class WebGPUEngine extends Engine {
     private static readonly _GLSLslangDefaultOptions;
+    private static _InstanceId;
     /** true to enable using TintWASM to convert Spir-V to WGSL */
     static UseTWGSL: boolean;
+    /** A unique id to identify this instance */
+    readonly uniqueId = -1;
     private readonly _uploadEncoderDescriptor;
     private readonly _renderEncoderDescriptor;
     /** @internal */
@@ -137,8 +140,10 @@ export declare class WebGPUEngine extends Engine {
     private _deviceLimits;
     private _context;
     private _mainPassSampleCount;
+    private _glslangOptions?;
+    private _twgslOptions?;
     /** @internal */
-    _textureHelper: WebGPUTextureHelper;
+    _textureHelper: WebGPUTextureManager;
     /** @internal */
     _bufferManager: WebGPUBufferManager;
     private _clearQuad;
@@ -349,6 +354,8 @@ export declare class WebGPUEngine extends Engine {
     private _initializeContextAndSwapChain;
     private _initializeMainAttachments;
     private _configureContext;
+    protected _rebuildBuffers(): void;
+    protected _restoreEngineAfterContextLost(initEngine: () => void): void;
     /**
      * Force a specific size of the canvas
      * @param width defines the new canvas' width

package/Engines/webgpuEngine.js

@@ -14,6 +14,7 @@ import { WebGPUShaderProcessorWGSL } from "./WebGPU/webgpuShaderProcessorsWGSL.j
 import { WebGPUShaderProcessingContext } from "./WebGPU/webgpuShaderProcessingContext.js";
 import { Tools } from "../Misc/tools.js";
 import { WebGPUTextureHelper } from "./WebGPU/webgpuTextureHelper.js";
+import { WebGPUTextureManager } from "./WebGPU/webgpuTextureManager.js";
 import { WebGPUBufferManager } from "./WebGPU/webgpuBufferManager.js";
 import { WebGPUHardwareTexture } from "./WebGPU/webgpuHardwareTexture.js";
 import { UniformBuffer } from "../Materials/uniformBuffer.js";
@@ -229,6 +230,8 @@ export class WebGPUEngine extends Engine {
     constructor(canvas, options = {}) {
         var _a, _b;
         super(null, (_a = options.antialias) !== null && _a !== void 0 ? _a : true, options);
+        /** A unique id to identify this instance */
+        this.uniqueId = -1;
         // Page Life cycle and constants
         this._uploadEncoderDescriptor = { label: "upload" };
         this._renderEncoderDescriptor = { label: "render" };
@@ -355,6 +358,9 @@ export class WebGPUEngine extends Engine {
      */
     initAsync(glslangOptions, twgslOptions) {
         var _a;
+        this.uniqueId = WebGPUEngine._InstanceId++;
+        this._glslangOptions = glslangOptions;
+        this._twgslOptions = twgslOptions;
         return this._initGlslang(glslangOptions !== null && glslangOptions !== void 0 ? glslangOptions : (_a = this._options) === null || _a === void 0 ? void 0 : _a.glslangOptions)
             .then((glslang) => {
             var _a;
@@ -405,6 +411,7 @@ export class WebGPUEngine extends Engine {
                         deviceDescriptor.requiredLimits[name] = this._adapterSupportedLimits[name];
                     }
                 }
+                deviceDescriptor.label = `BabylonWebGPUDevice${this.uniqueId}`;
                 return this._adapter.requestDevice(deviceDescriptor);
             }
         })
@@ -431,7 +438,23 @@ export class WebGPUEngine extends Engine {
                     this._contextWasLost = true;
                     Logger.Warn("WebGPU context lost. " + info);
                     this.onContextLostObservable.notifyObservers(this);
-                    this._restoreEngineAfterContextLost(() => this.initAsync());
+                    this._restoreEngineAfterContextLost(async () => {
+                        var _a, _b, _c, _d;
+                        const snapshotRenderingMode = this.snapshotRenderingMode;
+                        const snapshotRendering = this.snapshotRendering;
+                        const disableCacheSamplers = this.disableCacheSamplers;
+                        const disableCacheRenderPipelines = this.disableCacheRenderPipelines;
+                        const disableCacheBindGroups = this.disableCacheBindGroups;
+                        const enableGPUTimingMeasurements = this.enableGPUTimingMeasurements;
+                        await this.initAsync((_a = this._glslangOptions) !== null && _a !== void 0 ? _a : (_b = this._options) === null || _b === void 0 ? void 0 : _b.glslangOptions, (_c = this._twgslOptions) !== null && _c !== void 0 ? _c : (_d = this._options) === null || _d === void 0 ? void 0 : _d.twgslOptions);
+                        this.snapshotRenderingMode = snapshotRenderingMode;
+                        this.snapshotRendering = snapshotRendering;
+                        this.disableCacheSamplers = disableCacheSamplers;
+                        this.disableCacheRenderPipelines = disableCacheRenderPipelines;
+                        this.disableCacheBindGroups = disableCacheBindGroups;
+                        this.enableGPUTimingMeasurements = enableGPUTimingMeasurements;
+                        this._currentRenderPass = null;
+                    });
                 });
             }
         }, (e) => {
@@ -440,7 +463,7 @@ export class WebGPUEngine extends Engine {
         })
             .then(() => {
             this._bufferManager = new WebGPUBufferManager(this, this._device);
-            this._textureHelper = new WebGPUTextureHelper(this._device, this._glslang, this._tintWASM, this._bufferManager, this._deviceEnabledExtensions);
+            this._textureHelper = new WebGPUTextureManager(this, this._device, this._glslang, this._tintWASM, this._bufferManager, this._deviceEnabledExtensions);
             this._cacheSampler = new WebGPUCacheSampler(this._device);
             this._cacheBindGroups = new WebGPUCacheBindGroups(this._device, this._cacheSampler, this);
             this._timestampQuery = new WebGPUTimestampQuery(this, this._device, this._bufferManager);
@@ -458,7 +481,12 @@ export class WebGPUEngine extends Engine {
             this._uploadEncoder = this._device.createCommandEncoder(this._uploadEncoderDescriptor);
             this._renderEncoder = this._device.createCommandEncoder(this._renderEncoderDescriptor);
             this._initializeLimits();
-            this._emptyVertexBuffer = new VertexBuffer(this, [0], "", false, false, 1, false, 0, 1);
+            this._emptyVertexBuffer = new VertexBuffer(this, [0], "", {
+                stride: 1,
+                offset: 0,
+                size: 1,
+                label: "EmptyVertexBuffer",
+            });
             this._cacheRenderPipeline = new WebGPUCacheRenderPipelineTree(this._device, this._emptyVertexBuffer);
             this._depthCullingState = new WebGPUDepthCullingState(this._cacheRenderPipeline);
             this._stencilStateComposer = new WebGPUStencilStateComposer(this._cacheRenderPipeline);
@@ -696,6 +724,48 @@ export class WebGPUEngine extends Engine {
             alphaMode: this.premultipliedAlpha ? WebGPUConstants.CanvasAlphaMode.Premultiplied : WebGPUConstants.CanvasAlphaMode.Opaque,
         });
     }
+    _rebuildBuffers() {
+        super._rebuildBuffers();
+        for (const storageBuffer of this._storageBuffers) {
+            // The buffer can already be rebuilt by the call to _rebuildGeometries(), which recreates the storage buffers for the ComputeShaderParticleSystem
+            if (storageBuffer.getBuffer().engineId !== this.uniqueId) {
+                storageBuffer._rebuild();
+            }
+        }
+    }
+    _restoreEngineAfterContextLost(initEngine) {
+        WebGPUCacheRenderPipelineTree.ResetCache();
+        WebGPUCacheBindGroups.ResetCache();
+        // Clear the draw wrappers and material contexts
+        const cleanScenes = (scenes) => {
+            var _a;
+            for (const scene of scenes) {
+                for (const mesh of scene.meshes) {
+                    const subMeshes = mesh.subMeshes;
+                    if (!subMeshes) {
+                        continue;
+                    }
+                    for (const subMesh of subMeshes) {
+                        subMesh._drawWrappers = [];
+                    }
+                }
+                for (const material of scene.materials) {
+                    (_a = material._materialContext) === null || _a === void 0 ? void 0 : _a.reset();
+                }
+            }
+        };
+        cleanScenes(this.scenes);
+        cleanScenes(this._virtualScenes);
+        // The leftOver uniform buffers are removed from the list because they will be recreated when we rebuild the effects
+        const uboList = [];
+        for (const uniformBuffer of this._uniformBuffers) {
+            if (uniformBuffer.name.indexOf("leftOver") < 0) {
+                uboList.push(uniformBuffer);
+            }
+        }
+        this._uniformBuffers = uboList;
+        super._restoreEngineAfterContextLost(initEngine);
+    }
     /**
      * Force a specific size of the canvas
      * @param width defines the new canvas' width
@@ -1670,6 +1740,7 @@ export class WebGPUEngine extends Engine {
             texture.height = imageBitmap.height;
             texture.format = texture.format !== -1 ? texture.format : format !== null && format !== void 0 ? format : 5;
             texture.type = texture.type !== -1 ? texture.type : 0;
+            texture._creationFlags = creationFlags !== null && creationFlags !== void 0 ? creationFlags : 0;
             processFunction(texture.width, texture.height, imageBitmap, extension, texture, () => { });
             if (!((_a = texture._hardwareTexture) === null || _a === void 0 ? void 0 : _a.underlyingResource)) {
                 // the texture could have been created before reaching this point so don't recreate it if already existing
@@ -2906,6 +2977,7 @@ WebGPUEngine._GLSLslangDefaultOptions = {
     jsPath: `${Tools._DefaultCdnUrl}/glslang/glslang.js`,
     wasmPath: `${Tools._DefaultCdnUrl}/glslang/glslang.wasm`,
 };
+WebGPUEngine._InstanceId = 0;
 /** true to enable using TintWASM to convert Spir-V to WGSL */
 WebGPUEngine.UseTWGSL = true;
 //# sourceMappingURL=webgpuEngine.js.map