@babylonjs/core 7.2.2 → 7.2.3

package/Engines/engine.js

@@ -1,18 +1,23 @@
-import { Observable } from "../Misc/observable.js";
 import { InternalTexture, InternalTextureSource } from "../Materials/Textures/internalTexture.js";
-import { IsDocumentAvailable, IsWindowObjectExist } from "../Misc/domManagement.js";
 import { EngineStore } from "./engineStore.js";
-import { _WarnImport } from "../Misc/devTools.js";
 import { ThinEngine } from "./thinEngine.js";
 
 import { PerformanceMonitor } from "../Misc/performanceMonitor.js";
-import { PerfCounter } from "../Misc/perfCounter.js";
 import { WebGLDataBuffer } from "../Meshes/WebGL/webGLDataBuffer.js";
 import { Logger } from "../Misc/logger.js";
 import { WebGLHardwareTexture } from "./WebGL/webGLHardwareTexture.js";
 import "./Extensions/engine.alpha.js";
 import "./Extensions/engine.readTexture.js";
 import "./Extensions/engine.dynamicBuffer.js";
+import "./AbstractEngine/abstractEngine.loadingScreen.js";
+import "./AbstractEngine/abstractEngine.dom.js";
+import "./AbstractEngine/abstractEngine.states.js";
+import "./AbstractEngine/abstractEngine.renderPass.js";
+import "./AbstractEngine/abstractEngine.texture.js";
+import { AbstractEngine } from "./abstractEngine.js";
+import { CreateImageBitmapFromSource, ExitFullscreen, ExitPointerlock, GetFontOffset, RequestFullscreen, RequestPointerlock, ResizeImageBitmap, _CommonDispose, _CommonInit, } from "./engine.common.js";
+import { PerfCounter } from "../Misc/perfCounter.js";
+import "../Audio/audioEngine.js";
 /**
  * The engine class is responsible for interfacing with all lower-level APIs such as WebGL and Audio
  */
@@ -22,13 +27,13 @@ export class Engine extends ThinEngine {
      */
     // Not mixed with Version for tooling purpose.
     static get NpmPackage() {
-        return ThinEngine.NpmPackage;
+        return AbstractEngine.NpmPackage;
     }
     /**
      * Returns the current version of the framework
      */
     static get Version() {
-        return ThinEngine.Version;
+        return AbstractEngine.Version;
     }
     /** Gets the list of created engines */
     static get Instances() {
@@ -47,57 +52,6 @@ export class Engine extends ThinEngine {
         return EngineStore.LastCreatedScene;
     }
     /** @internal */
-    /**
-     * 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) {
-        const promise = new Promise((resolve, reject) => {
-            const image = new Image();
-            image.onload = () => {
-                image.decode().then(() => {
-                    this.createImageBitmap(image, options).then((imageBitmap) => {
-                        resolve(imageBitmap);
-                    });
-                });
-            };
-            image.onerror = () => {
-                reject(`Error loading image ${image.src}`);
-            };
-            image.src = imageSource;
-        });
-        return promise;
-    }
-    /**
-     * Engine abstraction for createImageBitmap
-     * @param image source for image
-     * @param options An object that sets options for the image's extraction.
-     * @returns ImageBitmap
-     */
-    createImageBitmap(image, options) {
-        return createImageBitmap(image, options);
-    }
-    /**
-     * 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) {
-        const canvas = this.createCanvas(bufferWidth, bufferHeight);
-        const context = canvas.getContext("2d");
-        if (!context) {
-            throw new Error("Unable to get 2d context for resizeImageBitmap");
-        }
-        context.drawImage(image, 0, 0);
-        // Create VertexData from map data
-        // Cast is due to wrong definition in lib.d.ts from ts 1.3 - https://github.com/Microsoft/TypeScript/issues/949
-        const buffer = context.getImageData(0, 0, bufferWidth, bufferHeight).data;
-        return buffer;
-    }
     /**
      * Will flag all materials in all scenes in all engines as dirty to trigger new shader compilation
      * @param flag defines which part of the materials must be marked as dirty
@@ -120,11 +74,16 @@ export class Engine extends ThinEngine {
      */
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
     static DefaultLoadingScreenFactory(canvas) {
-        throw _WarnImport("LoadingScreen");
+        return AbstractEngine.DefaultLoadingScreenFactory(canvas);
     }
     get _supportsHardwareTextureRescaling() {
         return !!Engine._RescalePostProcessFactory;
     }
+    _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
@@ -132,26 +91,7 @@ export class Engine extends ThinEngine {
     get performanceMonitor() {
         return this._performanceMonitor;
     }
-    /**
-     * (WebGPU only) True (default) to be in compatibility mode, meaning rendering all existing scenes without artifacts (same rendering than WebGL).
-     * Setting the property to false will improve performances but may not work in some scenes if some precautions are not taken.
-     * See https://doc.babylonjs.com/setup/support/webGPU/webGPUOptimization/webGPUNonCompatibilityMode for more details
-     */
-    get compatibilityMode() {
-        return this._compatibilityMode;
-    }
-    set compatibilityMode(mode) {
-        // not supported in WebGL
-        this._compatibilityMode = true;
-    }
     // Events
-    /**
-     * Gets the HTML element used to attach event listeners
-     * @returns a HTML element
-     */
-    getInputElement() {
-        return this._renderingCanvas;
-    }
     /**
      * Creates a new engine
      * @param canvasOrContext defines the canvas or WebGL context to use for rendering. If you provide a WebGL context, Babylon.js will not hook events on the canvas (like pointers, keyboards, etc...) so no event observables will be available. This is mostly used when Babylon.js is used as a plugin on a system which already used the WebGL context
@@ -162,96 +102,12 @@ export class Engine extends ThinEngine {
     constructor(canvasOrContext, antialias, options, adaptToDeviceRatio = false) {
         super(canvasOrContext, antialias, options, adaptToDeviceRatio);
         // Members
-        /**
-         * Gets or sets a boolean to enable/disable IndexedDB support and avoid XHR on .manifest
-         **/
-        this.enableOfflineSupport = false;
-        /**
-         * Gets or sets a boolean to enable/disable checking manifest if IndexedDB support is enabled (js will always consider the database is up to date)
-         **/
-        this.disableManifestCheck = false;
-        /**
-         * Gets or sets a boolean to enable/disable the context menu (right-click) from appearing on the main canvas
-         */
-        this.disableContextMenu = true;
-        /**
-         * Gets the list of created scenes
-         */
-        this.scenes = [];
-        /** @internal */
-        this._virtualScenes = new Array();
-        /**
-         * Event raised when a new scene is created
-         */
-        this.onNewSceneAddedObservable = new Observable();
-        /**
-         * Gets the list of created postprocesses
-         */
-        this.postProcesses = [];
-        /**
-         * Gets a boolean indicating if the pointer is currently locked
-         */
-        this.isPointerLock = false;
-        // Observables
-        /**
-         * Observable event triggered each time the rendering canvas is resized
-         */
-        this.onResizeObservable = new Observable();
-        /**
-         * Observable event triggered each time the canvas loses focus
-         */
-        this.onCanvasBlurObservable = new Observable();
-        /**
-         * Observable event triggered each time the canvas gains focus
-         */
-        this.onCanvasFocusObservable = new Observable();
-        /**
-         * Observable event triggered each time the canvas receives pointerout event
-         */
-        this.onCanvasPointerOutObservable = new Observable();
-        /**
-         * Observable raised when the engine begins a new frame
-         */
-        this.onBeginFrameObservable = new Observable();
         /**
          * If set, will be used to request the next animation frame for the render loop
          */
         this.customAnimationFrameRequester = null;
-        /**
-         * Observable raised when the engine ends the current frame
-         */
-        this.onEndFrameObservable = new Observable();
-        /**
-         * Observable raised when the engine is about to compile a shader
-         */
-        this.onBeforeShaderCompilationObservable = new Observable();
-        /**
-         * Observable raised when the engine has just compiled a shader
-         */
-        this.onAfterShaderCompilationObservable = new Observable();
-        // Deterministic lockstepMaxSteps
-        this._deterministicLockstep = false;
-        this._lockstepMaxSteps = 4;
-        this._timeStep = 1 / 60;
-        // FPS
-        this._fps = 60;
-        this._deltaTime = 0;
-        /** @internal */
-        this._drawCalls = new PerfCounter();
-        /** Gets or sets the tab index to set to the rendering canvas. 1 is the minimum value to set to be able to capture keyboard events */
-        this.canvasTabIndex = 1;
-        /**
-         * Turn this value on if you want to pause FPS computation when in background
-         */
-        this.disablePerformanceMonitorInBackground = false;
         this._performanceMonitor = new PerformanceMonitor();
-        this._compatibilityMode = true;
-        /**
-         * Gets or sets the current render pass id
-         */
-        this.currentRenderPassId = 0;
-        this._renderPassNames = ["main"];
-        Engine.Instances.push(this);
+        this._drawCalls = new PerfCounter();
         if (!canvasOrContext) {
             return;
         }
@@ -272,144 +128,59 @@ export class Engine extends ThinEngine {
      */
     _sharedInit(canvas) {
         super._sharedInit(canvas);
-        this._onCanvasFocus = () => {
-            this.onCanvasFocusObservable.notifyObservers(this);
-        };
-        this._onCanvasBlur = () => {
-            this.onCanvasBlurObservable.notifyObservers(this);
-        };
-        this._onCanvasContextMenu = (evt) => {
-            if (this.disableContextMenu) {
-                evt.preventDefault();
-            }
-        };
-        canvas.addEventListener("focus", this._onCanvasFocus);
-        canvas.addEventListener("blur", this._onCanvasBlur);
-        canvas.addEventListener("contextmenu", this._onCanvasContextMenu);
-        this._onBlur = () => {
-            if (this.disablePerformanceMonitorInBackground) {
-                this._performanceMonitor.disable();
-            }
-            this._windowIsBackground = true;
-        };
-        this._onFocus = () => {
-            if (this.disablePerformanceMonitorInBackground) {
-                this._performanceMonitor.enable();
-            }
-            this._windowIsBackground = false;
-        };
-        this._onCanvasPointerOut = (ev) => {
-            // Check that the element at the point of the pointer out isn't the canvas and if it isn't, notify observers
-            // Note: This is a workaround for a bug with Safari
-            if (document.elementFromPoint(ev.clientX, ev.clientY) !== canvas) {
-                this.onCanvasPointerOutObservable.notifyObservers(ev);
-            }
-        };
-        const hostWindow = this.getHostWindow(); // it calls IsWindowObjectExist()
-        if (hostWindow && typeof hostWindow.addEventListener === "function") {
-            hostWindow.addEventListener("blur", this._onBlur);
-            hostWindow.addEventListener("focus", this._onFocus);
-        }
-        canvas.addEventListener("pointerout", this._onCanvasPointerOut);
-        if (!this._creationOptions.doNotHandleTouchAction) {
-            this._disableTouchAction();
-        }
-        // Create Audio Engine if needed.
-        if (!Engine.audioEngine && this._creationOptions.audioEngine && Engine.AudioEngineFactory) {
-            Engine.audioEngine = Engine.AudioEngineFactory(this.getRenderingCanvas(), this.getAudioContext(), this.getAudioDestination());
-        }
-        if (IsDocumentAvailable()) {
-            // Fullscreen
-            this._onFullscreenChange = () => {
-                this.isFullscreen = !!document.fullscreenElement;
-                // Pointer lock
-                if (this.isFullscreen && this._pointerLockRequested && canvas) {
-                    Engine._RequestPointerlock(canvas);
-                }
-            };
-            document.addEventListener("fullscreenchange", this._onFullscreenChange, false);
-            document.addEventListener("webkitfullscreenchange", this._onFullscreenChange, false);
-            // Pointer lock
-            this._onPointerLockChange = () => {
-                this.isPointerLock = document.pointerLockElement === canvas;
-            };
-            document.addEventListener("pointerlockchange", this._onPointerLockChange, false);
-            document.addEventListener("webkitpointerlockchange", this._onPointerLockChange, false);
-        }
-        this.enableOfflineSupport = Engine.OfflineProviderFactory !== undefined;
-        this._deterministicLockstep = !!this._creationOptions.deterministicLockstep;
-        this._lockstepMaxSteps = this._creationOptions.lockstepMaxSteps || 0;
-        this._timeStep = this._creationOptions.timeStep || 1 / 60;
-    }
-    /** @internal */
-    _verifyPointerLock() {
-        this._onPointerLockChange?.();
+        _CommonInit(this, canvas, this._creationOptions);
     }
     /**
-     * Gets current aspect ratio
-     * @param viewportOwner defines the camera to use to get the aspect ratio
-     * @param useScreen defines if screen size must be used (or the current render target if any)
-     * @returns a number defining the aspect ratio
+     * 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
      */
-    getAspectRatio(viewportOwner, useScreen = false) {
-        const viewport = viewportOwner.viewport;
-        return (this.getRenderWidth(useScreen) * viewport.width) / (this.getRenderHeight(useScreen) * viewport.height);
+    resizeImageBitmap(image, bufferWidth, bufferHeight) {
+        return ResizeImageBitmap(this, image, bufferWidth, bufferHeight);
     }
     /**
-     * Gets current screen aspect ratio
-     * @returns a number defining the aspect ratio
+     * 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
      */
-    getScreenAspectRatio() {
-        return this.getRenderWidth(true) / this.getRenderHeight(true);
+    _createImageBitmapFromSource(imageSource, options) {
+        return CreateImageBitmapFromSource(this, imageSource, options);
     }
     /**
-     * Gets the client rect of the HTML canvas attached with the current webGL context
-     * @returns a client rectangle
+     * Toggle full screen mode
+     * @param requestPointerLock defines if a pointer lock should be requested from the user
      */
-    getRenderingCanvasClientRect() {
-        if (!this._renderingCanvas) {
-            return null;
+    switchFullscreen(requestPointerLock) {
+        if (this.isFullscreen) {
+            this.exitFullscreen();
         }
-        return this._renderingCanvas.getBoundingClientRect();
-    }
-    /**
-     * Gets the client rect of the HTML element used for events
-     * @returns a client rectangle
-     */
-    getInputElementClientRect() {
-        if (!this._renderingCanvas) {
-            return null;
+        else {
+            this.enterFullscreen(requestPointerLock);
         }
-        return this.getInputElement().getBoundingClientRect();
-    }
-    /**
-     * Gets a boolean indicating that the engine is running in deterministic lock step mode
-     * @see https://doc.babylonjs.com/features/featuresDeepDive/animation/advanced_animations#deterministic-lockstep
-     * @returns true if engine is in deterministic lock step mode
-     */
-    isDeterministicLockStep() {
-        return this._deterministicLockstep;
     }
     /**
-     * Gets the max steps when engine is running in deterministic lock step
-     * @see https://doc.babylonjs.com/features/featuresDeepDive/animation/advanced_animations#deterministic-lockstep
-     * @returns the max steps
+     * Enters full screen mode
+     * @param requestPointerLock defines if a pointer lock should be requested from the user
      */
-    getLockstepMaxSteps() {
-        return this._lockstepMaxSteps;
+    enterFullscreen(requestPointerLock) {
+        if (!this.isFullscreen) {
+            this._pointerLockRequested = requestPointerLock;
+            if (this._renderingCanvas) {
+                RequestFullscreen(this._renderingCanvas);
+            }
+        }
     }
     /**
-     * Returns the time in ms between steps when using deterministic lock step.
-     * @returns time step in (ms)
+     * Exits full screen mode
      */
-    getTimeStep() {
-        return this._timeStep * 1000;
+    exitFullscreen() {
+        if (this.isFullscreen) {
+            ExitFullscreen();
+        }
     }
-    /**
-     * Force the mipmap generation for the given render target texture
-     * @param texture defines the render target texture to use
-     * @param unbind defines whether or not to unbind the texture after generation. Defaults to true.
-     */
     generateMipMapsForCubemap(texture, unbind = true) {
         if (texture.generateMipMaps) {
             const gl = this._gl;
@@ -421,132 +192,6 @@ export class Engine extends ThinEngine {
         }
     }
     /** States */
-    /**
-     * Gets a boolean indicating if depth writing is enabled
-     * @returns the current depth writing state
-     */
-    getDepthWrite() {
-        return this._depthCullingState.depthMask;
-    }
-    /**
-     * Enable or disable depth writing
-     * @param enable defines the state to set
-     */
-    setDepthWrite(enable) {
-        this._depthCullingState.depthMask = enable;
-    }
-    /**
-     * Gets a boolean indicating if stencil buffer is enabled
-     * @returns the current stencil buffer state
-     */
-    getStencilBuffer() {
-        return this._stencilState.stencilTest;
-    }
-    /**
-     * Enable or disable the stencil buffer
-     * @param enable defines if the stencil buffer must be enabled or disabled
-     */
-    setStencilBuffer(enable) {
-        this._stencilState.stencilTest = enable;
-    }
-    /**
-     * Gets the current stencil mask
-     * @returns a number defining the new stencil mask to use
-     */
-    getStencilMask() {
-        return this._stencilState.stencilMask;
-    }
-    /**
-     * Sets the current stencil mask
-     * @param mask defines the new stencil mask to use
-     */
-    setStencilMask(mask) {
-        this._stencilState.stencilMask = mask;
-    }
-    /**
-     * Gets the current stencil function
-     * @returns a number defining the stencil function to use
-     */
-    getStencilFunction() {
-        return this._stencilState.stencilFunc;
-    }
-    /**
-     * Gets the current stencil reference value
-     * @returns a number defining the stencil reference value to use
-     */
-    getStencilFunctionReference() {
-        return this._stencilState.stencilFuncRef;
-    }
-    /**
-     * Gets the current stencil mask
-     * @returns a number defining the stencil mask to use
-     */
-    getStencilFunctionMask() {
-        return this._stencilState.stencilFuncMask;
-    }
-    /**
-     * Sets the current stencil function
-     * @param stencilFunc defines the new stencil function to use
-     */
-    setStencilFunction(stencilFunc) {
-        this._stencilState.stencilFunc = stencilFunc;
-    }
-    /**
-     * Sets the current stencil reference
-     * @param reference defines the new stencil reference to use
-     */
-    setStencilFunctionReference(reference) {
-        this._stencilState.stencilFuncRef = reference;
-    }
-    /**
-     * Sets the current stencil mask
-     * @param mask defines the new stencil mask to use
-     */
-    setStencilFunctionMask(mask) {
-        this._stencilState.stencilFuncMask = mask;
-    }
-    /**
-     * Gets the current stencil operation when stencil fails
-     * @returns a number defining stencil operation to use when stencil fails
-     */
-    getStencilOperationFail() {
-        return this._stencilState.stencilOpStencilFail;
-    }
-    /**
-     * Gets the current stencil operation when depth fails
-     * @returns a number defining stencil operation to use when depth fails
-     */
-    getStencilOperationDepthFail() {
-        return this._stencilState.stencilOpDepthFail;
-    }
-    /**
-     * Gets the current stencil operation when stencil passes
-     * @returns a number defining stencil operation to use when stencil passes
-     */
-    getStencilOperationPass() {
-        return this._stencilState.stencilOpStencilDepthPass;
-    }
-    /**
-     * Sets the stencil operation to use when stencil fails
-     * @param operation defines the stencil operation to use when stencil fails
-     */
-    setStencilOperationFail(operation) {
-        this._stencilState.stencilOpStencilFail = operation;
-    }
-    /**
-     * Sets the stencil operation to use when depth fails
-     * @param operation defines the stencil operation to use when depth fails
-     */
-    setStencilOperationDepthFail(operation) {
-        this._stencilState.stencilOpDepthFail = operation;
-    }
-    /**
-     * Sets the stencil operation to use when stencil passes
-     * @param operation defines the stencil operation to use when stencil passes
-     */
-    setStencilOperationPass(operation) {
-        this._stencilState.stencilOpStencilDepthPass = operation;
-    }
     /**
      * Sets a boolean indicating if the dithering state is enabled or disabled
      * @param value defines the dithering state
@@ -571,68 +216,6 @@ export class Engine extends ThinEngine {
             this._gl.enable(this._gl.RASTERIZER_DISCARD);
         }
     }
-    /**
-     * Gets the current depth function
-     * @returns a number defining the depth function
-     */
-    getDepthFunction() {
-        return this._depthCullingState.depthFunc;
-    }
-    /**
-     * Sets the current depth function
-     * @param depthFunc defines the function to use
-     */
-    setDepthFunction(depthFunc) {
-        this._depthCullingState.depthFunc = depthFunc;
-    }
-    /**
-     * Sets the current depth function to GREATER
-     */
-    setDepthFunctionToGreater() {
-        this.setDepthFunction(516);
-    }
-    /**
-     * Sets the current depth function to GEQUAL
-     */
-    setDepthFunctionToGreaterOrEqual() {
-        this.setDepthFunction(518);
-    }
-    /**
-     * Sets the current depth function to LESS
-     */
-    setDepthFunctionToLess() {
-        this.setDepthFunction(513);
-    }
-    /**
-     * Sets the current depth function to LEQUAL
-     */
-    setDepthFunctionToLessOrEqual() {
-        this.setDepthFunction(515);
-    }
-    /**
-     * Caches the state of the stencil buffer
-     */
-    cacheStencilState() {
-        this._cachedStencilBuffer = this.getStencilBuffer();
-        this._cachedStencilFunction = this.getStencilFunction();
-        this._cachedStencilMask = this.getStencilMask();
-        this._cachedStencilOperationPass = this.getStencilOperationPass();
-        this._cachedStencilOperationFail = this.getStencilOperationFail();
-        this._cachedStencilOperationDepthFail = this.getStencilOperationDepthFail();
-        this._cachedStencilReference = this.getStencilFunctionReference();
-    }
-    /**
-     * Restores the state of the stencil buffer
-     */
-    restoreStencilState() {
-        this.setStencilFunction(this._cachedStencilFunction);
-        this.setStencilMask(this._cachedStencilMask);
-        this.setStencilBuffer(this._cachedStencilBuffer);
-        this.setStencilOperationPass(this._cachedStencilOperationPass);
-        this.setStencilOperationFail(this._cachedStencilOperationFail);
-        this.setStencilOperationDepthFail(this._cachedStencilOperationDepthFail);
-        this.setStencilFunctionReference(this._cachedStencilReference);
-    }
     /**
      * Directly set the WebGL Viewport
      * @param x defines the x coordinate of the viewport (in screen space)
@@ -680,12 +263,6 @@ export class Engine extends ThinEngine {
         const gl = this._gl;
         gl.disable(gl.SCISSOR_TEST);
     }
-    /**
-     * @internal
-     */
-    _reportDrawCall(numDrawCalls = 1) {
-        this._drawCalls.addCount(numDrawCalls, false);
-    }
     /**
      * @internal
      */
@@ -744,7 +321,7 @@ export class Engine extends ThinEngine {
         }
     }
     /**
-     * Sets a texture to the webGL context from a postprocess
+     * 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
@@ -793,14 +370,13 @@ export class Engine extends ThinEngine {
         }
         super._rebuildBuffers();
     }
-    _rebuildTextures() {
-        for (const scene of this.scenes) {
-            scene._rebuildTextures();
-        }
-        for (const scene of this._virtualScenes) {
-            scene._rebuildTextures();
-        }
-        super._rebuildTextures();
+    /**
+     * Get Font size information
+     * @param font font name
+     * @returns an object containing ascent, height and descent
+     */
+    getFontOffset(font) {
+        return GetFontOffset(font);
     }
     /** @internal */
     _renderFrame() {
@@ -857,67 +433,27 @@ export class Engine extends ThinEngine {
     _renderViews() {
         return false;
     }
-    /**
-     * 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) {
-                Engine._RequestFullscreen(this._renderingCanvas);
-            }
-        }
-    }
-    /**
-     * Exits full screen mode
-     */
-    exitFullscreen() {
-        if (this.isFullscreen) {
-            Engine._ExitFullscreen();
-        }
-    }
     /**
      * Enters Pointerlock mode
      */
     enterPointerlock() {
         if (this._renderingCanvas) {
-            Engine._RequestPointerlock(this._renderingCanvas);
+            RequestPointerlock(this._renderingCanvas);
         }
     }
     /**
      * Exits Pointerlock mode
      */
     exitPointerlock() {
-        Engine._ExitPointerlock();
+        ExitPointerlock();
     }
     /**
      * Begin a new frame
      */
     beginFrame() {
         this._measureFps();
-        this.onBeginFrameObservable.notifyObservers(this);
         super.beginFrame();
     }
-    /**
-     * End the current frame
-     */
-    endFrame() {
-        super.endFrame();
-        this.onEndFrameObservable.notifyObservers(this);
-    }
     /**
      * Force a specific size of the canvas
      * @param width defines the new canvas' width
@@ -1018,50 +554,6 @@ export class Engine extends ThinEngine {
             });
         });
     }
-    /**
-     * Gets the names of the render passes that are currently created
-     * @returns list of the render pass names
-     */
-    getRenderPassNames() {
-        return this._renderPassNames;
-    }
-    /**
-     * Gets the name of the current render pass
-     * @returns name of the current render pass
-     */
-    getCurrentRenderPassName() {
-        return this._renderPassNames[this.currentRenderPassId];
-    }
-    /**
-     * Creates a render pass id
-     * @param name Name of the render pass (for debug purpose only)
-     * @returns the id of the new render pass
-     */
-    createRenderPassId(name) {
-        // Note: render pass id == 0 is always for the main render pass
-        const id = ++Engine._RenderPassIdCounter;
-        this._renderPassNames[id] = name ?? "NONAME";
-        return id;
-    }
-    /**
-     * Releases a render pass id
-     * @param id id of the render pass to release
-     */
-    releaseRenderPassId(id) {
-        this._renderPassNames[id] = undefined;
-        for (let s = 0; s < this.scenes.length; ++s) {
-            const scene = this.scenes[s];
-            for (let m = 0; m < scene.meshes.length; ++m) {
-                const mesh = scene.meshes[m];
-                if (mesh.subMeshes) {
-                    for (let b = 0; b < mesh.subMeshes.length; ++b) {
-                        const subMesh = mesh.subMeshes[b];
-                        subMesh._removeDrawWrapper(id);
-                    }
-                }
-            }
-        }
-    }
     /**
      * @internal
      * Rescales a texture
@@ -1110,26 +602,6 @@ export class Engine extends ThinEngine {
             });
         }
     }
-    // FPS
-    /**
-     * Gets the current framerate
-     * @returns a number representing the framerate
-     */
-    getFps() {
-        return this._fps;
-    }
-    /**
-     * Gets the time spent between current and previous frame
-     * @returns a number representing the delta time in ms
-     */
-    getDeltaTime() {
-        return this._deltaTime;
-    }
-    _measureFps() {
-        this._performanceMonitor.sampleFrame();
-        this._fps = this._performanceMonitor.averageFPS;
-        this._deltaTime = this._performanceMonitor.instantaneousFrameTime || 0;
-    }
     /**
      * Wraps an external web gl texture in a Babylon texture.
      * @param texture defines the external texture
@@ -1279,224 +751,12 @@ export class Engine extends ThinEngine {
         });
     }
     dispose() {
-        this.hideLoadingUI();
-        this.onNewSceneAddedObservable.clear();
-        // Release postProcesses
-        while (this.postProcesses.length) {
-            this.postProcesses[0].dispose();
-        }
         // Rescale PP
         if (this._rescalePostProcess) {
             this._rescalePostProcess.dispose();
         }
-        // Release scenes
-        while (this.scenes.length) {
-            this.scenes[0].dispose();
-        }
-        while (this._virtualScenes.length) {
-            this._virtualScenes[0].dispose();
-        }
-        // Release audio engine
-        if (EngineStore.Instances.length === 1 && Engine.audioEngine) {
-            Engine.audioEngine.dispose();
-            Engine.audioEngine = null;
-        }
-        // Events
-        const hostWindow = this.getHostWindow(); // it calls IsWindowObjectExist()
-        if (hostWindow && typeof hostWindow.removeEventListener === "function") {
-            hostWindow.removeEventListener("blur", this._onBlur);
-            hostWindow.removeEventListener("focus", this._onFocus);
-        }
-        if (this._renderingCanvas) {
-            this._renderingCanvas.removeEventListener("focus", this._onCanvasFocus);
-            this._renderingCanvas.removeEventListener("blur", this._onCanvasBlur);
-            this._renderingCanvas.removeEventListener("pointerout", this._onCanvasPointerOut);
-            this._renderingCanvas.removeEventListener("contextmenu", this._onCanvasContextMenu);
-        }
-        if (IsDocumentAvailable()) {
-            document.removeEventListener("fullscreenchange", this._onFullscreenChange);
-            document.removeEventListener("mozfullscreenchange", this._onFullscreenChange);
-            document.removeEventListener("webkitfullscreenchange", this._onFullscreenChange);
-            document.removeEventListener("msfullscreenchange", this._onFullscreenChange);
-            document.removeEventListener("pointerlockchange", this._onPointerLockChange);
-            document.removeEventListener("mspointerlockchange", this._onPointerLockChange);
-            document.removeEventListener("mozpointerlockchange", this._onPointerLockChange);
-            document.removeEventListener("webkitpointerlockchange", this._onPointerLockChange);
-        }
+        _CommonDispose(this, this._renderingCanvas);
         super.dispose();
-        // Remove from Instances
-        const index = EngineStore.Instances.indexOf(this);
-        if (index >= 0) {
-            EngineStore.Instances.splice(index, 1);
-        }
-        // no more engines left in the engine store? Notify!
-        if (!Engine.Instances.length) {
-            EngineStore.OnEnginesDisposedObservable.notifyObservers(this);
-        }
-        // Observables
-        this.onResizeObservable.clear();
-        this.onCanvasBlurObservable.clear();
-        this.onCanvasFocusObservable.clear();
-        this.onCanvasPointerOutObservable.clear();
-        this.onBeginFrameObservable.clear();
-        this.onEndFrameObservable.clear();
-    }
-    _disableTouchAction() {
-        if (!this._renderingCanvas || !this._renderingCanvas.setAttribute) {
-            return;
-        }
-        this._renderingCanvas.setAttribute("touch-action", "none");
-        this._renderingCanvas.style.touchAction = "none";
-        this._renderingCanvas.style.webkitTapHighlightColor = "transparent";
-    }
-    // Loading screen
-    /**
-     * Display the loading screen
-     * @see https://doc.babylonjs.com/features/featuresDeepDive/scene/customLoadingScreen
-     */
-    displayLoadingUI() {
-        if (!IsWindowObjectExist()) {
-            return;
-        }
-        const loadingScreen = this.loadingScreen;
-        if (loadingScreen) {
-            loadingScreen.displayLoadingUI();
-        }
-    }
-    /**
-     * Hide the loading screen
-     * @see https://doc.babylonjs.com/features/featuresDeepDive/scene/customLoadingScreen
-     */
-    hideLoadingUI() {
-        if (!IsWindowObjectExist()) {
-            return;
-        }
-        const loadingScreen = this._loadingScreen;
-        if (loadingScreen) {
-            loadingScreen.hideLoadingUI();
-        }
-    }
-    /**
-     * Gets the current loading screen object
-     * @see https://doc.babylonjs.com/features/featuresDeepDive/scene/customLoadingScreen
-     */
-    get loadingScreen() {
-        if (!this._loadingScreen && this._renderingCanvas) {
-            this._loadingScreen = Engine.DefaultLoadingScreenFactory(this._renderingCanvas);
-        }
-        return this._loadingScreen;
-    }
-    /**
-     * Sets the current loading screen object
-     * @see https://doc.babylonjs.com/features/featuresDeepDive/scene/customLoadingScreen
-     */
-    set loadingScreen(loadingScreen) {
-        this._loadingScreen = loadingScreen;
-    }
-    /**
-     * Sets the current loading screen text
-     * @see https://doc.babylonjs.com/features/featuresDeepDive/scene/customLoadingScreen
-     */
-    set loadingUIText(text) {
-        this.loadingScreen.loadingUIText = text;
-    }
-    /**
-     * Sets the current loading screen background color
-     * @see https://doc.babylonjs.com/features/featuresDeepDive/scene/customLoadingScreen
-     */
-    set loadingUIBackgroundColor(color) {
-        this.loadingScreen.loadingUIBackgroundColor = color;
-    }
-    /**
-     * creates and returns a new video element
-     * @param constraints video constraints
-     * @returns video element
-     */
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    createVideoElement(constraints) {
-        return document.createElement("video");
-    }
-    /** Pointerlock and fullscreen */
-    /**
-     * Ask the browser to promote the current element to pointerlock mode
-     * @param element defines the DOM element to promote
-     */
-    static _RequestPointerlock(element) {
-        if (element.requestPointerLock) {
-            // In some browsers, requestPointerLock returns a promise.
-            // Handle possible rejections to avoid an unhandled top-level exception.
-            const promise = element.requestPointerLock();
-            if (promise instanceof Promise)
-                promise
-                    .then(() => {
-                    element.focus();
-                })
-                    .catch(() => { });
-            else
-                element.focus();
-        }
-    }
-    /**
-     * Asks the browser to exit pointerlock mode
-     */
-    static _ExitPointerlock() {
-        if (document.exitPointerLock) {
-            document.exitPointerLock();
-        }
-    }
-    /**
-     * Ask the browser to promote the current element to fullscreen rendering mode
-     * @param element defines the DOM element to promote
-     */
-    static _RequestFullscreen(element) {
-        const requestFunction = element.requestFullscreen || element.webkitRequestFullscreen;
-        if (!requestFunction) {
-            return;
-        }
-        requestFunction.call(element);
-    }
-    /**
-     * Asks the browser to exit fullscreen mode
-     */
-    static _ExitFullscreen() {
-        const anyDoc = document;
-        if (document.exitFullscreen) {
-            document.exitFullscreen();
-        }
-        else if (anyDoc.webkitCancelFullScreen) {
-            anyDoc.webkitCancelFullScreen();
-        }
-    }
-    /**
-     * Get Font size information
-     * @param font font name
-     * @returns an object containing ascent, height and descent
-     */
-    getFontOffset(font) {
-        const text = document.createElement("span");
-        text.innerHTML = "Hg";
-        text.setAttribute("style", `font: ${font} !important`);
-        const block = document.createElement("div");
-        block.style.display = "inline-block";
-        block.style.width = "1px";
-        block.style.height = "0px";
-        block.style.verticalAlign = "bottom";
-        const div = document.createElement("div");
-        div.style.whiteSpace = "nowrap";
-        div.appendChild(text);
-        div.appendChild(block);
-        document.body.appendChild(div);
-        let fontAscent = 0;
-        let fontHeight = 0;
-        try {
-            fontHeight = block.getBoundingClientRect().top - text.getBoundingClientRect().top;
-            block.style.verticalAlign = "baseline";
-            fontAscent = block.getBoundingClientRect().top - text.getBoundingClientRect().top;
-        }
-        finally {
-            document.body.removeChild(div);
-        }
-        return { ascent: fontAscent, height: fontHeight, descent: fontHeight - fontAscent };
     }
 }
 // Const statics
@@ -1691,10 +951,4 @@ Engine.SCALEMODE_FLOOR = 1;
 Engine.SCALEMODE_NEAREST = 2;
 /** Defines that texture rescaling will use a ceil to find the closer power of 2 size */
 Engine.SCALEMODE_CEILING = 3;
-/**
- * Method called to create the default rescale post process on each engine.
- */
-Engine._RescalePostProcessFactory = null;
-// eslint-disable-next-line @typescript-eslint/naming-convention
-Engine._RenderPassIdCounter = 0;
 //# sourceMappingURL=engine.js.map