@babylonjs/core 7.2.2 → 7.3.0

package/Engines/webgpuEngine.js

@@ -15,6 +15,7 @@ import { WebGPUShaderProcessingContext } from "./WebGPU/webgpuShaderProcessingCo
 import { Tools } from "../Misc/tools.js";
 import { WebGPUTextureHelper } from "./WebGPU/webgpuTextureHelper.js";
 import { WebGPUTextureManager } from "./WebGPU/webgpuTextureManager.js";
+import { AbstractEngine } from "./abstractEngine.js";
 import { WebGPUBufferManager } from "./WebGPU/webgpuBufferManager.js";
 import { WebGPUHardwareTexture } from "./WebGPU/webgpuHardwareTexture.js";
 import { UniformBuffer } from "../Materials/uniformBuffer.js";
@@ -22,7 +23,6 @@ import { WebGPUCacheSampler } from "./WebGPU/webgpuCacheSampler.js";
 import { WebGPUCacheRenderPipelineTree } from "./WebGPU/webgpuCacheRenderPipelineTree.js";
 import { WebGPUStencilStateComposer } from "./WebGPU/webgpuStencilStateComposer.js";
 import { WebGPUDepthCullingState } from "./WebGPU/webgpuDepthCullingState.js";
-import { DrawWrapper } from "../Materials/drawWrapper.js";
 import { WebGPUMaterialContext } from "./WebGPU/webgpuMaterialContext.js";
 import { WebGPUDrawContext } from "./WebGPU/webgpuDrawContext.js";
 import { WebGPUCacheBindGroups } from "./WebGPU/webgpuCacheBindGroups.js";
@@ -38,6 +38,16 @@ import { WebGPUSnapshotRendering } from "./WebGPU/webgpuSnapshotRendering.js";
 import "../Buffers/buffer.align.js";
 import "../ShadersWGSL/postprocess.vertex.js";
 import { WebGPUPerfCounter } from "./WebGPU/webgpuPerfCounter.js";
+import { SphericalPolynomial } from "../Maths/sphericalPolynomial.js";
+import { PerformanceMonitor } from "../Misc/performanceMonitor.js";
+import { CreateImageBitmapFromSource, ExitFullscreen, ExitPointerlock, GetFontOffset, RequestFullscreen, RequestPointerlock, ResizeImageBitmap, _CommonDispose, _CommonInit, } from "./engine.common.js";
+import { IsWrapper } from "../Materials/drawWrapper.functions.js";
+import { PerfCounter } from "../Misc/perfCounter.js";
+import "./AbstractEngine/abstractEngine.loadingScreen.js";
+import "./AbstractEngine/abstractEngine.dom.js";
+import "./AbstractEngine/abstractEngine.states.js";
+import "./AbstractEngine/abstractEngine.renderPass.js";
+import "../Audio/audioEngine.js";
 const viewDescriptorSwapChainAntialiasing = {
     label: `TextureView_SwapChain_ResolveTarget`,
     dimension: WebGPUConstants.TextureDimension.E2d,
@@ -58,7 +68,7 @@ const tempColor4 = new Color4();
  * The web GPU engine class provides support for WebGPU version of babylon.js.
  * @since 5.0.0
  */
-export class WebGPUEngine extends Engine {
+export class WebGPUEngine extends AbstractEngine {
     /**
      * Gets or sets the snapshot rendering mode
      */
@@ -117,6 +127,21 @@ export class WebGPUEngine extends Engine {
             this._cacheBindGroups.disabled = disable;
         }
     }
+    /**
+     * Gets a boolean indicating if all created effects are ready
+     * @returns true if all effects are ready
+     */
+    areAllEffectsReady() {
+        return true;
+    }
+    /**
+     * Get Font size information
+     * @param font font name
+     * @returns an object containing ascent, height and descent
+     */
+    getFontOffset(font) {
+        return GetFontOffset(font);
+    }
     /**
      * Gets a Promise<boolean> indicating if the engine can be instantiated (ie. if a WebGPU context can be found)
      */
@@ -228,7 +253,7 @@ export class WebGPUEngine extends Engine {
      * @param options Defines the options passed to the engine to create the GPU context dependencies
      */
     constructor(canvas, options = {}) {
-        super(null, options.antialias ?? true, options);
+        super(options.antialias ?? true, options);
         /** A unique id to identify this instance */
         this.uniqueId = -1;
         // Page Life cycle and constants
@@ -273,6 +298,12 @@ export class WebGPUEngine extends Engine {
          * Max number of uncaptured error messages to log
          */
         this.numMaxUncapturedErrors = 20;
+        /**
+         * Gets the list of created scenes
+         */
+        this.scenes = [];
+        /** @internal */
+        this._virtualScenes = new Array();
         this._commandBuffers = [null, null];
         // Frame Buffer Life Cycle (recreated for each render target pass)
         /** @internal */
@@ -310,6 +341,7 @@ export class WebGPUEngine extends Engine {
         this.dbgLogIfNotDrawWrapper = true;
         /** @internal */
         this.dbgShowEmptyEnableEffectCalls = true;
+        this._snapshotRenderingMode = 0;
         /**
          * Indicates if the z range in NDC space is 0..1 (value: true) or -1..1 (value: false)
          */
@@ -327,7 +359,9 @@ export class WebGPUEngine extends Engine {
         this._scissorCached = { x: 0, y: 0, z: 0, w: 0 };
         this._stencilRefsCurrent = -1;
         this._blendColorsCurrent = [null, null, null, null];
+        this._performanceMonitor = new PerformanceMonitor();
         this._name = "WebGPU";
+        this._drawCalls = new PerfCounter();
         options.deviceDescriptor = options.deviceDescriptor || {};
         options.enableGPUDebugMarkers = options.enableGPUDebugMarkers ?? false;
         Logger.Log(`Babylon.js v${Engine.Version} - ${this.description} engine`);
@@ -341,7 +375,9 @@ export class WebGPUEngine extends Engine {
         this._renderingCanvas = canvas;
         this._options = options;
         this._mainPassSampleCount = options.antialias ? this._defaultSampleCount : 1;
-        this._setupMobileChecks();
+        if (navigator && navigator.userAgent) {
+            this._setupMobileChecks();
+        }
         this._sharedInit(this._renderingCanvas);
         this._shaderProcessor = new WebGPUShaderProcessorGLSL();
         this._shaderProcessorWGSL = new WebGPUShaderProcessorWGSL();
@@ -704,6 +740,14 @@ export class WebGPUEngine extends Engine {
             depthStencilAttachment: mainDepthAttachment,
         };
     }
+    /**
+     * Shared initialization across engines types.
+     * @param canvas The canvas associated with this instance of the engine.
+     */
+    _sharedInit(canvas) {
+        super._sharedInit(canvas);
+        _CommonInit(this, canvas, this._creationOptions);
+    }
     _configureContext() {
         this._context.configure({
             device: this._device,
@@ -712,6 +756,71 @@ export class WebGPUEngine extends Engine {
             alphaMode: this.premultipliedAlpha ? WebGPUConstants.CanvasAlphaMode.Premultiplied : WebGPUConstants.CanvasAlphaMode.Opaque,
         });
     }
+    /**
+     * Resize an image and returns the image data as an uint8array
+     * @param image image to resize
+     * @param bufferWidth destination buffer width
+     * @param bufferHeight destination buffer height
+     * @returns an uint8array containing RGBA values of bufferWidth * bufferHeight size
+     */
+    resizeImageBitmap(image, bufferWidth, bufferHeight) {
+        return ResizeImageBitmap(this, image, bufferWidth, bufferHeight);
+    }
+    /**
+     * Engine abstraction for loading and creating an image bitmap from a given source string.
+     * @param imageSource source to load the image from.
+     * @param options An object that sets options for the image's extraction.
+     * @returns ImageBitmap
+     */
+    _createImageBitmapFromSource(imageSource, options) {
+        return CreateImageBitmapFromSource(this, imageSource, options);
+    }
+    /**
+     * Toggle full screen mode
+     * @param requestPointerLock defines if a pointer lock should be requested from the user
+     */
+    switchFullscreen(requestPointerLock) {
+        if (this.isFullscreen) {
+            this.exitFullscreen();
+        }
+        else {
+            this.enterFullscreen(requestPointerLock);
+        }
+    }
+    /**
+     * Enters full screen mode
+     * @param requestPointerLock defines if a pointer lock should be requested from the user
+     */
+    enterFullscreen(requestPointerLock) {
+        if (!this.isFullscreen) {
+            this._pointerLockRequested = requestPointerLock;
+            if (this._renderingCanvas) {
+                RequestFullscreen(this._renderingCanvas);
+            }
+        }
+    }
+    /**
+     * Exits full screen mode
+     */
+    exitFullscreen() {
+        if (this.isFullscreen) {
+            ExitFullscreen();
+        }
+    }
+    /**
+     * Enters Pointerlock mode
+     */
+    enterPointerlock() {
+        if (this._renderingCanvas) {
+            RequestPointerlock(this._renderingCanvas);
+        }
+    }
+    /**
+     * Exits Pointerlock mode
+     */
+    exitPointerlock() {
+        ExitPointerlock();
+    }
     _rebuildBuffers() {
         super._rebuildBuffers();
         for (const storageBuffer of this._storageBuffers) {
@@ -753,6 +862,51 @@ export class WebGPUEngine extends Engine {
         this._uniformBuffers = uboList;
         super._restoreEngineAfterContextLost(initEngine);
     }
+    /**
+     * Sets a depth stencil texture from a render target to the according uniform.
+     * @param channel The texture channel
+     * @param uniform The uniform to set
+     * @param texture The render target texture containing the depth stencil texture to apply
+     * @param name The texture name
+     */
+    setDepthStencilTexture(channel, uniform, texture, name) {
+        if (channel === undefined) {
+            return;
+        }
+        if (!texture || !texture.depthStencilTexture) {
+            this._setTexture(channel, null, undefined, undefined, name);
+        }
+        else {
+            this._setTexture(channel, texture, false, true, name);
+        }
+    }
+    /**
+     * Sets a texture to the context from a postprocess
+     * @param channel defines the channel to use
+     * @param postProcess defines the source postprocess
+     * @param name name of the channel
+     */
+    setTextureFromPostProcess(channel, postProcess, name) {
+        let postProcessInput = null;
+        if (postProcess) {
+            if (postProcess._forcedOutputTexture) {
+                postProcessInput = postProcess._forcedOutputTexture;
+            }
+            else if (postProcess._textures.data[postProcess._currentRenderTextureInd]) {
+                postProcessInput = postProcess._textures.data[postProcess._currentRenderTextureInd];
+            }
+        }
+        this._bindTexture(channel, postProcessInput?.texture ?? null, name);
+    }
+    /**
+     * Binds the output of the passed in post process to the texture channel specified
+     * @param channel The channel the texture should be bound to
+     * @param postProcess The post process which's output should be bound
+     * @param name name of the channel
+     */
+    setTextureFromPostProcessOutput(channel, postProcess, name) {
+        this._bindTexture(channel, postProcess?._outputTexture?.texture ?? null, name);
+    }
     /**
      * Force a specific size of the canvas
      * @param width defines the new canvas' width
@@ -1240,6 +1394,12 @@ export class WebGPUEngine extends Engine {
         // eslint-disable-next-line no-throw-literal
         throw "Not implemented on WebGPU";
     }
+    /**
+     * Unbind all instance attributes
+     */
+    unbindInstanceAttributes() {
+        // Does nothing
+    }
     /**
      * Bind a list of vertex buffers with the engine
      * @param vertexBuffers defines the list of vertex buffers to bind
@@ -1368,7 +1528,7 @@ export class WebGPUEngine extends Engine {
             }
             return compiledEffect;
         }
-        const effect = new Effect(baseName, attributesNamesOrOptions, uniformsNamesOrEngine, samplers, this, defines, fallbacks, onCompiled, onError, indexParameters, name, shaderLanguage);
+        const effect = new Effect(baseName, attributesNamesOrOptions, uniformsNamesOrEngine, samplers, this, defines, fallbacks, onCompiled, onError, indexParameters, name, attributesNamesOrOptions.shaderLanguage ?? shaderLanguage);
         this._compiledEffects[name] = effect;
         return effect;
     }
@@ -1526,7 +1686,7 @@ export class WebGPUEngine extends Engine {
         if (!effect) {
             return;
         }
-        if (!DrawWrapper.IsWrapper(effect)) {
+        if (!IsWrapper(effect)) {
             this._currentEffect = effect;
             this._currentMaterialContext = this._defaultMaterialContext;
             this._currentDrawContext = this._defaultDrawContext;
@@ -1777,6 +1937,12 @@ export class WebGPUEngine extends Engine {
             this._generateMipmaps(texture);
         }
     }
+    /**
+     * @internal
+     */
+    _getUseSRGBBuffer(useSRGBBuffer, noMipmap) {
+        return useSRGBBuffer && this._caps.supportSRGBBuffers;
+    }
     /**
      * Update the sampling mode of a given texture
      * @param samplingMode defines the required sampling mode
@@ -1842,6 +2008,41 @@ export class WebGPUEngine extends Engine {
             }
         }
     }
+    /**
+     * Create a cube texture from prefiltered data (ie. the mipmaps contain ready to use data for PBR reflection)
+     * @param rootUrl defines the url where the file to load is located
+     * @param scene defines the current scene
+     * @param lodScale defines scale to apply to the mip map selection
+     * @param lodOffset defines offset to apply to the mip map selection
+     * @param onLoad defines an optional callback raised when the texture is loaded
+     * @param onError defines an optional callback raised if there is an issue to load the texture
+     * @param format defines the format of the data
+     * @param forcedExtension defines the extension to use to pick the right loader
+     * @param createPolynomials defines wheter or not to create polynomails harmonics for the texture
+     * @returns the cube texture as an InternalTexture
+     */
+    createPrefilteredCubeTexture(rootUrl, scene, lodScale, lodOffset, onLoad = null, onError = null, format, forcedExtension = null, createPolynomials = true) {
+        const callback = (loadData) => {
+            if (!loadData) {
+                if (onLoad) {
+                    onLoad(null);
+                }
+                return;
+            }
+            const texture = loadData.texture;
+            if (!createPolynomials) {
+                texture._sphericalPolynomial = new SphericalPolynomial();
+            }
+            else if (loadData.info.sphericalPolynomial) {
+                texture._sphericalPolynomial = loadData.info.sphericalPolynomial;
+            }
+            texture._source = InternalTextureSource.CubePrefiltered;
+            if (onLoad) {
+                onLoad(texture);
+            }
+        };
+        return this.createCubeTexture(rootUrl, scene, null, false, callback, onError, format, forcedExtension, createPolynomials, lodScale, lodOffset);
+    }
     /**
      * Sets a texture to the according uniform.
      * @param channel The texture channel
@@ -2104,10 +2305,23 @@ export class WebGPUEngine extends Engine {
     //------------------------------------------------------------------------------
     //                              Frame management
     //------------------------------------------------------------------------------
+    _measureFps() {
+        this._performanceMonitor.sampleFrame();
+        this._fps = this._performanceMonitor.averageFPS;
+        this._deltaTime = this._performanceMonitor.instantaneousFrameTime || 0;
+    }
+    /**
+     * Gets the performance monitor attached to this engine
+     * @see https://doc.babylonjs.com/features/featuresDeepDive/scene/optimize_your_scene#engineinstrumentation
+     */
+    get performanceMonitor() {
+        return this._performanceMonitor;
+    }
     /**
      * Begin a new frame
      */
     beginFrame() {
+        this._measureFps();
         super.beginFrame();
     }
     /**
@@ -2147,7 +2361,6 @@ export class WebGPUEngine extends Engine {
         this._cacheRenderPipeline.endFrame();
         this._cacheBindGroups.endFrame();
         this._pendingDebugCommands.length = 0;
-        super.endFrame();
         if (this.dbgVerboseLogsForFirstFrames) {
             if (this._count === undefined) {
                 this._count = 0;
@@ -2162,6 +2375,11 @@ export class WebGPUEngine extends Engine {
                 }
             }
         }
+        super.endFrame();
+    }
+    /**Gets driver info if available */
+    extractDriverInfo() {
+        return "";
     }
     /**
      * Force a WebGPU flush (ie. a flush of all waiting commands)
@@ -2518,7 +2736,7 @@ export class WebGPUEngine extends Engine {
      */
     unBindFramebuffer(texture, disableGenerateMipMaps = false, onBeforeUnbind) {
         const saveCRT = this._currentRenderTarget;
-        this._currentRenderTarget = null; // to be iso with thinEngine, this._currentRenderTarget must be null when onBeforeUnbind is called
+        this._currentRenderTarget = null; // to be iso with abstractEngine, this._currentRenderTarget must be null when onBeforeUnbind is called
         if (onBeforeUnbind) {
             onBeforeUnbind();
         }
@@ -2585,6 +2803,28 @@ export class WebGPUEngine extends Engine {
     setRasterizerState() {
         // Does not exist in WebGPU
     }
+    /**
+     * @internal
+     */
+    _executeWhenRenderingStateIsCompiled(pipelineContext, action) {
+        // No parallel shader compilation.
+        // No Async, so direct launch
+        action();
+    }
+    /**
+     * @internal
+     */
+    bindSamplers() { }
+    /** @internal */
+    _getUnpackAlignement() {
+        return 1;
+    }
+    /**
+     * @internal
+     */
+    _bindTextureDirectly() {
+        return false;
+    }
     /**
      * Set various states to the webGL context
      * @param culling defines culling state: true to enable culling, false to disable it
@@ -2768,6 +3008,7 @@ export class WebGPUEngine extends Engine {
         this._textureHelper.destroyDeferredTextures();
         this._bufferManager.destroyDeferredBuffers();
         this._device.destroy();
+        _CommonDispose(this, this._renderingCanvas);
         super.dispose();
     }
     //------------------------------------------------------------------------------
@@ -2806,160 +3047,6 @@ export class WebGPUEngine extends Engine {
         // TODO WEBGPU. from the webgpu errors.
         return 0;
     }
-    //------------------------------------------------------------------------------
-    //                              Unused WebGPU
-    //------------------------------------------------------------------------------
-    /**
-     * @internal
-     */
-    bindSamplers() { }
-    /**
-     * @internal
-     */
-    _bindTextureDirectly() {
-        return false;
-    }
-    /**
-     * Gets a boolean indicating if all created effects are ready
-     * @returns always true - No parallel shader compilation
-     */
-    areAllEffectsReady() {
-        return true;
-    }
-    /**
-     * @internal
-     */
-    _executeWhenRenderingStateIsCompiled(pipelineContext, action) {
-        // No parallel shader compilation.
-        // No Async, so direct launch
-        action();
-    }
-    /**
-     * @internal
-     */
-    _isRenderingStateCompiled() {
-        // No parallel shader compilation.
-        return true;
-    }
-    /** @internal */
-    _getUnpackAlignement() {
-        return 1;
-    }
-    /**
-     * @internal
-     */
-    _unpackFlipY() { }
-    /**
-     * @internal
-     */
-    _bindUnboundFramebuffer() {
-        // eslint-disable-next-line no-throw-literal
-        throw "_bindUnboundFramebuffer is not implementedin WebGPU! You probably want to use restoreDefaultFramebuffer or unBindFramebuffer instead";
-    }
-    // TODO WEBGPU. All of the below should go once engine split with baseEngine.
-    /**
-     * @internal
-     */
-    _getSamplingParameters() {
-        // eslint-disable-next-line no-throw-literal
-        throw "_getSamplingParameters is not available in WebGPU";
-    }
-    /**
-     * @internal
-     */
-    getUniforms() {
-        return [];
-    }
-    /**
-     * @internal
-     */
-    setIntArray() {
-        return false;
-    }
-    /**
-     * @internal
-     */
-    setIntArray2() {
-        return false;
-    }
-    /**
-     * @internal
-     */
-    setIntArray3() {
-        return false;
-    }
-    /**
-     * @internal
-     */
-    setIntArray4() {
-        return false;
-    }
-    /**
-     * @internal
-     */
-    setArray() {
-        return false;
-    }
-    /**
-     * @internal
-     */
-    setArray2() {
-        return false;
-    }
-    /**
-     * @internal
-     */
-    setArray3() {
-        return false;
-    }
-    /**
-     * @internal
-     */
-    setArray4() {
-        return false;
-    }
-    /**
-     * @internal
-     */
-    setMatrices() {
-        return false;
-    }
-    /**
-     * @internal
-     */
-    setMatrix3x3() {
-        return false;
-    }
-    /**
-     * @internal
-     */
-    setMatrix2x2() {
-        return false;
-    }
-    /**
-     * @internal
-     */
-    setFloat() {
-        return false;
-    }
-    /**
-     * @internal
-     */
-    setFloat2() {
-        return false;
-    }
-    /**
-     * @internal
-     */
-    setFloat3() {
-        return false;
-    }
-    /**
-     * @internal
-     */
-    setFloat4() {
-        return false;
-    }
 }
 // Default glslang options.
 WebGPUEngine._GLSLslangDefaultOptions = {