@babylonjs/core 6.33.1 → 6.34.0-alpha.0

package/esm/Engines/engine.base.js

@@ -0,0 +1,1235 @@
+/**
+ * Base engine functionality to be used in all other different engines
+ */
+/* eslint-disable jsdoc/require-jsdoc */
+import { Effect } from "../../Materials/effect.js";
+import { Observable } from "../../Misc/observable.js";
+import { PrecisionDate } from "../../Misc/precisionDate.js";
+import { AlphaState } from "../../States/alphaCullingState.js";
+import { EngineType } from "./engine.interfaces.js";
+import { IsDocumentAvailable, IsWindowObjectExist, hostInformation } from "./runtimeEnvironment.js";
+import { PerformanceConfigurator } from "../../Engines/performanceConfigurator.js";
+import { EngineStore, _CreateCanvas, _ExitFullscreen, _ExitPointerlock, _RequestFullscreen, _RequestPointerlock } from "./engine.static.js";
+import { PerformanceMonitor } from "../../Misc/performanceMonitor.js";
+import { StencilState } from "../../States/stencilState.js";
+import { augmentEngineStateWithExtensions } from "./Extensions/engine.extensions.js";
+let engineCounter = 0;
+/**
+ * @internal
+ */
+export function initBaseEngineState(overrides = {}, options = {}) {
+    var _a, _b, _c, _d, _e;
+    const devicePixelRatio = IsWindowObjectExist() ? window.devicePixelRatio || 1.0 : 1.0;
+    const limitDeviceRatio = options.limitDeviceRatio || devicePixelRatio;
+    options.deterministicLockstep = (_a = options.deterministicLockstep) !== null && _a !== void 0 ? _a : false;
+    options.lockstepMaxSteps = (_b = options.lockstepMaxSteps) !== null && _b !== void 0 ? _b : 4;
+    options.timeStep = (_c = options.timeStep) !== null && _c !== void 0 ? _c : 1 / 60;
+    options.stencil = (_d = options.stencil) !== null && _d !== void 0 ? _d : true;
+    // TODO - this needs to be a module as well
+    PerformanceConfigurator.SetMatrixPrecision(!!options.useHighPrecisionMatrix);
+    const engineState = {
+        // module: {},
+        uniqueId: engineCounter++,
+        _type: EngineType.BASE,
+        get description() {
+            let description = engineState.name + engineState._version;
+            if (engineState._caps.parallelShaderCompile) {
+                description += " - Parallel shader compilation";
+            }
+            return description;
+        },
+        name: "Base",
+        _version: 1,
+        _isDisposed: false,
+        get isDisposed() {
+            return engineState._isDisposed;
+        },
+        forcePOTTextures: false,
+        isFullscreen: false,
+        cullBackFaces: null,
+        renderEvenInBackground: true,
+        preventCacheWipeBetweenFrames: false,
+        validateShaderPrograms: false,
+        _useReverseDepthBuffer: false,
+        get useReverseDepthBuffer() {
+            return engineState._useReverseDepthBuffer;
+        },
+        set useReverseDepthBuffer(useReverse) {
+            if (useReverse === engineState._useReverseDepthBuffer) {
+                return;
+            }
+            engineState._useReverseDepthBuffer = useReverse;
+            if (engineState._depthCullingState) {
+                if (useReverse) {
+                    engineState._depthCullingState.depthFunc = 518 /* 518 */;
+                }
+                else {
+                    engineState._depthCullingState.depthFunc = 515 /* 515 */;
+                }
+            }
+        },
+        isNDCHalfZRange: false,
+        hasOriginBottomLeft: true,
+        disableUniformBuffers: false,
+        onDisposeObservable: new Observable(),
+        _frameId: 0,
+        get frameId() {
+            return engineState._frameId;
+        },
+        startTime: PrecisionDate.Now,
+        get needPOTTextures() {
+            return engineState.forcePOTTextures;
+        },
+        _renderingQueueLaunched: false,
+        _activeRenderLoops: [],
+        get activeRenderLoops() {
+            return engineState._activeRenderLoops;
+        },
+        onContextLostObservable: new Observable(),
+        onContextRestoredObservable: new Observable(),
+        doNotHandleContextLost: false,
+        disableVertexArrayObjects: false,
+        adaptToDeviceRatio: (_e = options.adaptToDeviceRatio) !== null && _e !== void 0 ? _e : false,
+        get currentViewport() {
+            return engineState._cachedViewport;
+        },
+        premultipliedAlpha: true,
+        onBeforeTextureInitObservable: new Observable(),
+        get isWebGPU() {
+            return engineState._type === EngineType.WEBGPU;
+        },
+        get shaderPlatformName() {
+            return engineState._shaderPlatformName;
+        },
+        get supportsUniformBuffers() {
+            return false;
+        },
+        useExactSrgbConversions: options.useExactSrgbConversions || false,
+        onBeginFrameObservable: new Observable(),
+        onEndFrameObservable: new Observable(),
+        onBeforeShaderCompilationObservable: new Observable(),
+        onAfterShaderCompilationObservable: new Observable(),
+        scenes: [],
+        postProcesses: [],
+        onResizeObservable: new Observable(),
+        onCanvasBlurObservable: new Observable(),
+        onCanvasFocusObservable: new Observable(),
+        onCanvasPointerOutObservable: new Observable(),
+        disableContextMenu: true,
+        disablePerformanceMonitorInBackground: false,
+        isPointerLock: false,
+        get isStencilEnable() {
+            return engineState._isStencilEnable;
+        },
+        enableOfflineSupport: false,
+        disableManifestCheck: false,
+        onNewSceneAddedObservable: new Observable(),
+        customAnimationFrameRequester: null,
+        canvasTabIndex: 1,
+        currentRenderPassId: 0,
+        get alphaState() {
+            return engineState._alphaState;
+        },
+        emptyTexture: null,
+        emptyCubeTexture: null,
+        emptyTexture3D: null,
+        emptyTexture2DArray: null,
+        // internals
+        _uniformBuffers: [],
+        _storageBuffers: [],
+        _windowIsBackground: false,
+        get _shouldUseHighPrecisionShader() {
+            return !!(engineState._caps.highPrecisionShaderSupported && engineState._highPrecisionShadersAllowed);
+        },
+        _badOS: false,
+        _badDesktopOS: false,
+        _contextWasLost: false,
+        _internalTexturesCache: [],
+        _renderTargetWrapperCache: [],
+        _activeChannel: 0,
+        _currentTextureChannel: -1,
+        _boundTexturesCache: {},
+        _compiledEffects: {},
+        _vertexAttribArraysEnabled: [],
+        _lastDevicePixelRatio: devicePixelRatio,
+        _hardwareScalingLevel: options.adaptToDeviceRatio ? 1.0 / Math.min(limitDeviceRatio, devicePixelRatio) : 1.0,
+        _transformTextureUrl: null,
+        _renderWidthOverride: null,
+        _creationOptions: options,
+        _isStencilEnable: !!options.stencil,
+        _virtualScenes: [],
+        _videoTextureSupported: false,
+        _stencilState: new StencilState(),
+        // Missing vars
+        _shaderProcessor: null,
+        _renderingCanvas: null,
+        _caps: {},
+        _features: {},
+        _alphaState: new AlphaState(),
+        _alphaMode: 1 /* 1 */,
+        _alphaEquation: 0 /* 0 */,
+        _currentRenderTarget: null,
+        _boundRenderFunction: () => void 0,
+        _frameHandler: -1,
+        _highPrecisionShadersAllowed: true,
+        _colorWrite: true,
+        _colorWriteChanged: true,
+        // _depthCullingState: null,
+        // _stencilStateComposer: null,
+        // _stencilState: null,
+        _currentEffect: null,
+        _cachedViewport: null,
+        _workingCanvas: null,
+        _workingContext: null,
+        _shaderPlatformName: "",
+        _emptyTexture: null,
+        _emptyCubeTexture: null,
+        _emptyTexture3D: null,
+        _emptyTexture2DArray: null,
+        _dimensionsObject: null,
+        _viewportCached: { x: 0, y: 0, z: 0, w: 0 },
+        _activeRequests: [],
+        _performanceMonitor: null,
+        _fps: 60,
+        _deltaTime: 0,
+        _pointerLockRequested: false,
+        _deterministicLockstep: false,
+        _lockstepMaxSteps: 4,
+        _timeStep: 1 / 60,
+        _renderPassNames: ["main"],
+        _cachedStencilBuffer: false,
+        _cachedStencilFunction: -1,
+        _cachedStencilMask: -1,
+        _cachedStencilOperationPass: -1,
+        _cachedStencilOperationFail: -1,
+        _cachedStencilOperationDepthFail: -1,
+        _cachedStencilReference: -1,
+    };
+    // TODO is getOwnPropertyDescriptors supported in native? if it doesn't we will need to use getOwnPropertyNames
+    // Extend the engine state with the overrides
+    Object.defineProperties(engineState, Object.getOwnPropertyDescriptors(overrides));
+    // TODO - this actually prevents tree shaking. Should be done by the dev, apart from the most basic functions.
+    // populateBaseModule(engineState);
+    EngineStore.Instances.push(engineState);
+    augmentEngineStateWithExtensions(engineState);
+    return engineState;
+}
+export function getPerformanceMonitor(engineState) {
+    if (!engineState._performanceMonitor) {
+        engineState._performanceMonitor = new PerformanceMonitor();
+    }
+    return engineState._performanceMonitor;
+}
+export function getFps(engineState) {
+    return engineState._fps;
+}
+export function getDeltaTime(engineState) {
+    return engineState._deltaTime;
+}
+/**
+ * Force a specific size of the canvas
+ * @param engineState defines the engine state
+ * @param width defines the new canvas' width
+ * @param height defines the new canvas' height
+ * @param forceSetSize true to force setting the sizes of the underlying canvas
+ * @returns true if the size was changed
+ */
+export function setSizeBase(engineState, width, height, forceSetSize = false) {
+    const fes = engineState;
+    if (!fes._renderingCanvas) {
+        return false;
+    }
+    width = width | 0;
+    height = height | 0;
+    if (!forceSetSize && fes._renderingCanvas.width === width && fes._renderingCanvas.height === height) {
+        return false;
+    }
+    fes._renderingCanvas.width = width;
+    fes._renderingCanvas.height = height;
+    return true;
+}
+/**
+ * Gets the default empty texture
+ * @param engineState defines the engine state
+ * @param createRawTexture defines a function used to create the raw texture from the rawTexture extension
+ * @returns the default empty texture
+ */
+export function getEmptyTexture(engineState, { createRawTexture }) {
+    if (!engineState._emptyTexture) {
+        engineState._emptyTexture = createRawTexture(engineState, new Uint8Array(4), 1, 1, 5 /* 5 */, false, false, 1 /* 1 */);
+    }
+    return engineState._emptyTexture;
+}
+/**
+ * Gets the default empty 3D texture
+ * @param engineState defines the engine state
+ * @param createRawTexture3D defines a function used to create the raw texture from the rawTexture extension
+ * @returns the default empty 3D texture
+ */
+export function getEmptyTexture3D(engineState, { createRawTexture3D }) {
+    if (!engineState._emptyTexture3D) {
+        engineState._emptyTexture3D = createRawTexture3D(engineState, new Uint8Array(4), 1, 1, 1, 5 /* 5 */, false, false, 1 /* 1 */);
+    }
+    return engineState._emptyTexture3D;
+}
+/**
+ * Gets the default empty texture 2D
+ * @param engineState defines the engine state
+ * @param createRawCubeTexture defines a function used to create the raw texture 2D from the rawTexture extension
+ * @returns the default empty texture 2D
+ */
+export function getEmptyTexture2DArray(engineState, { createRawTexture2DArray }) {
+    if (!engineState._emptyTexture2DArray) {
+        engineState._emptyTexture2DArray = createRawTexture2DArray(engineState, new Uint8Array(4), 1, 1, 1, 5 /* 5 */, false, false, 1 /* 1 */);
+    }
+    return engineState._emptyTexture2DArray;
+}
+/**
+ * Gets the default empty cube texture
+ * @param engineState defines the engine state
+ * @param createRawCubeTexture defines a function used to create the raw cube texture from the rawTexture extension
+ * @returns the default empty cube texture
+ */
+export function getEmptyCubeTexture(engineState, { createRawCubeTexture }) {
+    if (!engineState._emptyCubeTexture) {
+        const faceData = new Uint8Array(4);
+        const cubeData = [faceData, faceData, faceData, faceData, faceData, faceData];
+        engineState._emptyCubeTexture = createRawCubeTexture(engineState, cubeData, 1, 5 /* 5 */, 0 /* 0 */, false, false, 1 /* 1 */);
+    }
+    return engineState._emptyCubeTexture;
+}
+/**
+ * Gets a boolean indicating if all created effects are ready
+ * @param engineState defines the engine state
+ * @returns true if all effects are ready
+ */
+export function areAllEffectsReady(engineState) {
+    const fes = engineState;
+    for (const key in fes._compiledEffects) {
+        const effect = fes._compiledEffects[key];
+        if (!effect.isReady()) {
+            return false;
+        }
+    }
+    return true;
+}
+/**
+ * @internal
+ */
+export function _rebuildBuffers(engineState) {
+    const fes = engineState;
+    // from Engine
+    // Index / Vertex
+    for (const scene of engineState.scenes) {
+        scene.resetCachedMaterial();
+        scene._rebuildGeometries();
+        scene._rebuildTextures();
+    }
+    for (const scene of fes._virtualScenes) {
+        scene.resetCachedMaterial();
+        scene._rebuildGeometries();
+        scene._rebuildTextures();
+    }
+    // From ThinEngine
+    // Uniforms
+    for (const uniformBuffer of fes._uniformBuffers) {
+        uniformBuffer._rebuild();
+    }
+    // Storage buffers
+    for (const storageBuffer of fes._storageBuffers) {
+        storageBuffer._rebuild();
+    }
+}
+/**
+ * Reset the texture cache to empty state
+ */
+export function resetTextureCache(engineState) {
+    const fes = engineState;
+    for (const key in fes._boundTexturesCache) {
+        if (!Object.prototype.hasOwnProperty.call(fes._boundTexturesCache, key)) {
+            continue;
+        }
+        fes._boundTexturesCache[key] = null;
+    }
+    fes._currentTextureChannel = -1;
+}
+function _measureFps(engineState) {
+    const fes = engineState;
+    if (fes._performanceMonitor) {
+        fes._performanceMonitor.sampleFrame();
+        fes._fps = fes._performanceMonitor.averageFPS;
+        fes._deltaTime = fes._performanceMonitor.instantaneousFrameTime || 0;
+    }
+}
+/**
+ * Begin a new frame
+ */
+export function beginFrame(engineState) {
+    _measureFps(engineState);
+    engineState.onBeginFrameObservable.notifyObservers(engineState);
+}
+/**
+ * stop executing a render loop function and remove it from the execution array
+ * @param engineState defines the engine state
+ * @param renderFunction defines the function to be removed. If not provided all functions will be removed.
+ */
+export function stopRenderLoop(engineState, renderFunction, cancelFrame = _cancelFrame) {
+    const fes = engineState;
+    if (!renderFunction) {
+        fes._activeRenderLoops.length = 0;
+        cancelFrame(engineState);
+        return;
+    }
+    const index = fes._activeRenderLoops.indexOf(renderFunction);
+    if (index >= 0) {
+        fes._activeRenderLoops.splice(index, 1);
+        if (fes._activeRenderLoops.length == 0) {
+            cancelFrame(engineState);
+        }
+    }
+}
+/**
+ * Enf the current frame
+ */
+export function endFrame(engineState) {
+    const fes = engineState;
+    fes._frameId++;
+}
+// Just for thin engine reconstruction
+export function _cancelFrameThin(engineState) {
+    const fes = engineState;
+    if (fes._renderingQueueLaunched && fes._frameHandler) {
+        fes._renderingQueueLaunched = false;
+        if (!IsWindowObjectExist()) {
+            if (typeof cancelAnimationFrame === "function") {
+                return cancelAnimationFrame(fes._frameHandler);
+            }
+        }
+        else {
+            const { cancelAnimationFrame } = getHostWindow(fes) || window;
+            if (typeof cancelAnimationFrame === "function") {
+                return cancelAnimationFrame(fes._frameHandler);
+            }
+        }
+        return clearTimeout(fes._frameHandler);
+    }
+}
+// Was protected, now passed as a variable
+export function _cancelFrame(engineState) {
+    const fes = engineState;
+    if (fes._renderingQueueLaunched && fes.customAnimationFrameRequester) {
+        fes._renderingQueueLaunched = false;
+        const { cancelAnimationFrame } = fes.customAnimationFrameRequester;
+        if (cancelAnimationFrame) {
+            cancelAnimationFrame(fes.customAnimationFrameRequester.requestID);
+        }
+    }
+    else if (fes._renderingQueueLaunched && fes._frameHandler) {
+        fes._renderingQueueLaunched = false;
+        if (!IsWindowObjectExist()) {
+            if (typeof cancelAnimationFrame === "function") {
+                return cancelAnimationFrame(fes._frameHandler);
+            }
+        }
+        else {
+            const { cancelAnimationFrame } = getHostWindow(engineState) || window;
+            if (typeof cancelAnimationFrame === "function") {
+                return cancelAnimationFrame(fes._frameHandler);
+            }
+        }
+        return clearTimeout(fes._frameHandler);
+    }
+}
+/**
+ * Gets host window
+ * @returns the host window object
+ */
+export function getHostWindow(engineState) {
+    const fes = engineState;
+    if (!IsWindowObjectExist()) {
+        return null;
+    }
+    if (fes._renderingCanvas && fes._renderingCanvas.ownerDocument && fes._renderingCanvas.ownerDocument.defaultView) {
+        return fes._renderingCanvas.ownerDocument.defaultView;
+    }
+    return window;
+}
+/**
+ * Gets host document
+ * @returns the host document object
+ */
+export function getHostDocument(engineState) {
+    const fes = engineState;
+    if (fes._renderingCanvas && fes._renderingCanvas.ownerDocument) {
+        return fes._renderingCanvas.ownerDocument;
+    }
+    return IsDocumentAvailable() ? document : null;
+}
+/**
+ * Gets the current render width
+ * @param engineState defines the engine state
+ * @param useScreen defines if screen size must be used (or the current render target if any)
+ * @returns a number defining the current render width
+ */
+export function getRenderWidth(engineState, useScreen = false) {
+    const fes = engineState;
+    if (!useScreen && fes._currentRenderTarget) {
+        return fes._currentRenderTarget.width;
+    }
+    return fes._dimensionsObject ? fes._dimensionsObject.width : 0;
+}
+/**
+ * Gets the current render height
+ * @param engineState defines the engine state
+ * @param useScreen defines if screen size must be used (or the current render target if any)
+ * @returns a number defining the current render height
+ */
+export function getRenderHeight(engineState, useScreen = false) {
+    const fes = engineState;
+    if (!useScreen && fes._currentRenderTarget) {
+        return fes._currentRenderTarget.height;
+    }
+    return fes._dimensionsObject ? fes._dimensionsObject.height : 0;
+}
+/**
+ * @internal
+ */
+export function _viewport(engineState, x, y, width, height) {
+    const fes = engineState;
+    fes._viewportCached.x = x;
+    fes._viewportCached.y = y;
+    fes._viewportCached.z = width;
+    fes._viewportCached.w = height;
+}
+/** @internal */
+export function _getGlobalDefines(engineState, defines) {
+    if (defines) {
+        if (engineState.isNDCHalfZRange) {
+            defines["IS_NDC_HALF_ZRANGE"] = "";
+        }
+        else {
+            delete defines["IS_NDC_HALF_ZRANGE"];
+        }
+        if (engineState.useReverseDepthBuffer) {
+            defines["USE_REVERSE_DEPTHBUFFER"] = "";
+        }
+        else {
+            delete defines["USE_REVERSE_DEPTHBUFFER"];
+        }
+        if (engineState.useExactSrgbConversions) {
+            defines["USE_EXACT_SRGB_CONVERSIONS"] = "";
+        }
+        else {
+            delete defines["USE_EXACT_SRGB_CONVERSIONS"];
+        }
+        return;
+    }
+    else {
+        let s = "";
+        if (engineState.isNDCHalfZRange) {
+            s += "#define IS_NDC_HALF_ZRANGE";
+        }
+        if (engineState.useReverseDepthBuffer) {
+            if (s) {
+                s += "\n";
+            }
+            s += "#define USE_REVERSE_DEPTHBUFFER";
+        }
+        if (engineState.useExactSrgbConversions) {
+            if (s) {
+                s += "\n";
+            }
+            s += "#define USE_EXACT_SRGB_CONVERSIONS";
+        }
+        return s;
+    }
+}
+/**
+ * Clears the list of texture accessible through engine.
+ * This can help preventing texture load conflict due to name collision.
+ */
+export function clearInternalTexturesCache(engineState) {
+    engineState._internalTexturesCache.length = 0;
+}
+/** @internal */
+export function _prepareWorkingCanvas(engineState) {
+    const fes = engineState;
+    if (fes._workingCanvas) {
+        return;
+    }
+    fes._workingCanvas = _CreateCanvas(1, 1);
+    const context = fes._workingCanvas.getContext("2d");
+    if (context) {
+        fes._workingContext = context;
+    }
+}
+export function _setupMobileChecks(engineState) {
+    const fes = engineState;
+    if (!(navigator && navigator.userAgent)) {
+        return;
+    }
+    // Function to check if running on mobile device
+    fes._checkForMobile = () => {
+        const currentUA = navigator.userAgent;
+        hostInformation.isMobile =
+            currentUA.indexOf("Mobile") !== -1 ||
+                // Needed for iOS 13+ detection on iPad (inspired by solution from https://stackoverflow.com/questions/9038625/detect-if-device-is-ios)
+                (currentUA.indexOf("Mac") !== -1 && IsDocumentAvailable() && "ontouchend" in document);
+    };
+    // Set initial isMobile value
+    fes._checkForMobile();
+    // Set up event listener to check when window is resized (used to get emulator activation to work properly)
+    if (IsWindowObjectExist()) {
+        window.addEventListener("resize", fes._checkForMobile);
+    }
+}
+/**
+ * Dispose and release all associated resources
+ */
+export function dispose(engineState) {
+    const fes = engineState;
+    fes._isDisposed = true;
+    stopRenderLoop(engineState);
+    hideLoadingUI(engineState);
+    engineState.onNewSceneAddedObservable.clear();
+    // Release postProcesses
+    while (engineState.postProcesses.length) {
+        engineState.postProcesses[0].dispose();
+    }
+    // Release scenes
+    while (fes.scenes.length) {
+        fes.scenes[0].dispose();
+    }
+    while (fes._virtualScenes.length) {
+        fes._virtualScenes[0].dispose();
+    }
+    // TODO Release audio engine
+    // if (EngineStore.Instances.length === 1 && Engine.audioEngine) {
+    //     Engine.audioEngine.dispose();
+    //     Engine.audioEngine = null;
+    // }
+    // Clear observables
+    if (engineState.onBeforeTextureInitObservable) {
+        engineState.onBeforeTextureInitObservable.clear();
+    }
+    if (IsWindowObjectExist()) {
+        if (fes._checkForMobile) {
+            window.removeEventListener("resize", fes._checkForMobile);
+        }
+    }
+    // Events
+    const hostWindow = getHostWindow(engineState); // it calls IsWindowObjectExist()
+    if (hostWindow && typeof hostWindow.removeEventListener === "function") {
+        fes._onBlur && hostWindow.removeEventListener("blur", fes._onBlur);
+        fes._onFocus && hostWindow.removeEventListener("focus", fes._onFocus);
+    }
+    if (fes._renderingCanvas) {
+        fes._onCanvasFocus && fes._renderingCanvas.removeEventListener("focus", fes._onCanvasFocus);
+        fes._onCanvasBlur && fes._renderingCanvas.removeEventListener("blur", fes._onCanvasBlur);
+        fes._onCanvasPointerOut && fes._renderingCanvas.removeEventListener("pointerout", fes._onCanvasPointerOut);
+        fes._onCanvasContextMenu && fes._renderingCanvas.removeEventListener("contextmenu", fes._onCanvasContextMenu);
+    }
+    if (IsDocumentAvailable()) {
+        if (fes._onFullscreenChange) {
+            document.removeEventListener("fullscreenchange", fes._onFullscreenChange);
+            document.removeEventListener("mozfullscreenchange", fes._onFullscreenChange);
+            document.removeEventListener("webkitfullscreenchange", fes._onFullscreenChange);
+            document.removeEventListener("msfullscreenchange", fes._onFullscreenChange);
+        }
+        if (fes._onPointerLockChange) {
+            document.removeEventListener("pointerlockchange", fes._onPointerLockChange);
+            document.removeEventListener("mspointerlockchange", fes._onPointerLockChange);
+            document.removeEventListener("mozpointerlockchange", fes._onPointerLockChange);
+            document.removeEventListener("webkitpointerlockchange", fes._onPointerLockChange);
+        }
+    }
+    fes._workingCanvas = null;
+    fes._workingContext = null;
+    fes._renderingCanvas = null;
+    Effect.ResetCache();
+    // Abort active requests
+    for (const request of fes._activeRequests) {
+        request.abort();
+    }
+    // Remove from Instances
+    const index = EngineStore.Instances.indexOf(engineState);
+    if (index >= 0) {
+        EngineStore.Instances.splice(index, 1);
+    }
+    // no more engines left in the engine store? Notify!
+    if (!EngineStore.Instances.length) {
+        EngineStore.OnEnginesDisposedObservable.notifyObservers(engineState);
+    }
+    // Observables
+    engineState.onResizeObservable.clear();
+    engineState.onCanvasBlurObservable.clear();
+    engineState.onCanvasFocusObservable.clear();
+    engineState.onCanvasPointerOutObservable.clear();
+    engineState.onBeginFrameObservable.clear();
+    engineState.onEndFrameObservable.clear();
+    fes.onDisposeObservable.notifyObservers(fes);
+    fes.onDisposeObservable.clear();
+}
+// Loading screen
+/**
+ * Display the loading screen
+ * @see https://doc.babylonjs.com/features/featuresDeepDive/scene/customLoadingScreen
+ */
+export function displayLoadingUI(engineState) {
+    if (!IsWindowObjectExist()) {
+        return;
+    }
+    const loadingScreen = getLoadingScreen(engineState);
+    if (loadingScreen) {
+        loadingScreen.displayLoadingUI();
+    }
+}
+/**
+ * Hide the loading screen
+ * @see https://doc.babylonjs.com/features/featuresDeepDive/scene/customLoadingScreen
+ */
+export function hideLoadingUI(engineState) {
+    if (!IsWindowObjectExist()) {
+        return;
+    }
+    const loadingScreen = engineState._loadingScreen;
+    if (loadingScreen) {
+        loadingScreen.hideLoadingUI();
+    }
+}
+/**
+ * Gets the current loading screen object
+ * @see https://doc.babylonjs.com/features/featuresDeepDive/scene/customLoadingScreen
+ */
+export function getLoadingScreen(engineState) {
+    var _a;
+    const fes = engineState;
+    if (!fes._loadingScreen && fes._renderingCanvas) {
+        fes._loadingScreen = (_a = EngineStore.DefaultLoadingScreenFactory) === null || _a === void 0 ? void 0 : _a.call(EngineStore, fes._renderingCanvas);
+    }
+    return fes._loadingScreen;
+}
+/**
+ * Sets the current loading screen object
+ * @see https://doc.babylonjs.com/features/featuresDeepDive/scene/customLoadingScreen
+ */
+export function setLoadingScreen(engineState, loadingScreen) {
+    engineState._loadingScreen = loadingScreen;
+}
+/**
+ * creates and returns a new video element
+ * @param constraints video constraints
+ * @returns video element
+ */
+export function createVideoElement(_engineState, _constraints) {
+    return document.createElement("video");
+}
+/**
+ * Gets the object containing all engine capabilities
+ * @param engineState defines the engine state
+ * @returns the EngineCapabilities object
+ */
+export function getCaps(engineState) {
+    const fes = engineState;
+    return fes._caps;
+}
+// From Engine
+// createImageBitmap is just a proxy to the browser's native implementation
+// Should not be implemented
+/**
+ * Shared initialization across engines types.
+ * @param canvas The canvas associated with this instance of the engine.
+ */
+export function _sharedInit(engineState, canvas) {
+    const fes = engineState;
+    // moved from thinEngine
+    fes._renderingCanvas = canvas;
+    fes._onCanvasFocus = () => {
+        fes.onCanvasFocusObservable.notifyObservers(engineState);
+    };
+    fes._onCanvasBlur = () => {
+        fes.onCanvasBlurObservable.notifyObservers(engineState);
+    };
+    fes._onCanvasContextMenu = (evt) => {
+        if (fes.disableContextMenu) {
+            evt.preventDefault();
+        }
+    };
+    canvas.addEventListener("focus", fes._onCanvasFocus);
+    canvas.addEventListener("blur", fes._onCanvasBlur);
+    canvas.addEventListener("contextmenu", fes._onCanvasContextMenu);
+    const performanceMonitor = getPerformanceMonitor(engineState);
+    fes._onBlur = () => {
+        if (fes.disablePerformanceMonitorInBackground) {
+            performanceMonitor.disable();
+        }
+        fes._windowIsBackground = true;
+    };
+    fes._onFocus = () => {
+        if (fes.disablePerformanceMonitorInBackground) {
+            performanceMonitor.enable();
+        }
+        fes._windowIsBackground = false;
+    };
+    fes._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) {
+            fes.onCanvasPointerOutObservable.notifyObservers(ev);
+        }
+    };
+    const hostWindow = getHostWindow(engineState); // it calls IsWindowObjectExist()
+    if (hostWindow && typeof hostWindow.addEventListener === "function") {
+        hostWindow.addEventListener("blur", fes._onBlur);
+        hostWindow.addEventListener("focus", fes._onFocus);
+    }
+    canvas.addEventListener("pointerout", fes._onCanvasPointerOut);
+    if (!fes._creationOptions.doNotHandleTouchAction) {
+        _disableTouchAction(fes);
+    }
+    // Create Audio Engine if needed.
+    // if (!Engine.audioEngine && fes._creationOptions.audioEngine && Engine.AudioEngineFactory) {
+    //     Engine.audioEngine = Engine.AudioEngineFactory(this.getRenderingCanvas(), this.getAudioContext(), this.getAudioDestination());
+    // }
+    if (IsDocumentAvailable()) {
+        // Fullscreen
+        fes._onFullscreenChange = () => {
+            fes.isFullscreen = !!document.fullscreenElement;
+            // Pointer lock
+            if (fes.isFullscreen && fes._pointerLockRequested && canvas) {
+                _RequestPointerlock(canvas);
+            }
+        };
+        document.addEventListener("fullscreenchange", fes._onFullscreenChange, false);
+        document.addEventListener("webkitfullscreenchange", fes._onFullscreenChange, false);
+        // Pointer lock
+        fes._onPointerLockChange = () => {
+            fes.isPointerLock = document.pointerLockElement === canvas;
+        };
+        document.addEventListener("pointerlockchange", fes._onPointerLockChange, false);
+        document.addEventListener("webkitpointerlockchange", fes._onPointerLockChange, false);
+    }
+    // fes.enableOfflineSupport = Engine.OfflineProviderFactory !== undefined; // ESMTODO
+    fes._deterministicLockstep = !!fes._creationOptions.deterministicLockstep;
+    fes._lockstepMaxSteps = fes._creationOptions.lockstepMaxSteps || 0;
+    fes._timeStep = fes._creationOptions.timeStep || 1 / 60;
+}
+function _disableTouchAction(engineState) {
+    const fes = engineState;
+    if (!fes._renderingCanvas || !fes._renderingCanvas.setAttribute) {
+        return;
+    }
+    fes._renderingCanvas.setAttribute("touch-action", "none");
+    fes._renderingCanvas.style.touchAction = "none";
+    fes._renderingCanvas.style.webkitTapHighlightColor = "transparent";
+}
+/** @internal */
+export function _verifyPointerLock(engineState) {
+    var _a, _b;
+    (_b = (_a = engineState)._onPointerLockChange) === null || _b === void 0 ? void 0 : _b.call(_a);
+}
+/**
+ * Gets the list of loaded textures
+ * @returns an array containing all loaded textures
+ */
+export function getLoadedTexturesCache(engineState) {
+    return engineState._internalTexturesCache;
+}
+/**
+ * Gets the HTML canvas attached with the current webGL context
+ * @returns a HTML canvas
+ */
+export function getRenderingCanvas(engineState) {
+    return engineState._renderingCanvas;
+}
+/**
+ * Gets the client rect of the HTML canvas attached with the current webGL context
+ * @returns a client rectangle
+ */
+export function getRenderingCanvasClientRect(engineState) {
+    const fes = engineState;
+    if (!fes._renderingCanvas) {
+        return null;
+    }
+    return fes._renderingCanvas.getBoundingClientRect();
+}
+/**
+ * Gets the HTML element used to attach event listeners
+ * @returns a HTML element
+ */
+export function getInputElement(engineState) {
+    return engineState._renderingCanvas;
+}
+/**
+ * Gets the client rect of the HTML element used for events
+ * @returns a client rectangle
+ */
+export function getInputElementClientRect(engineState) {
+    const fes = engineState;
+    if (!fes._renderingCanvas) {
+        return null;
+    }
+    return getInputElement(fes).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
+ */
+export function isDeterministicLockStep(engineState) {
+    return engineState._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
+ */
+export function getLockstepMaxSteps(engineState) {
+    return engineState._lockstepMaxSteps;
+}
+/**
+ * Returns the time in ms between steps when using deterministic lock step.
+ * @returns time step in (ms)
+ */
+export function getTimeStep(engineState) {
+    return engineState._timeStep * 1000;
+}
+/** States */
+/**
+ * Gets a boolean indicating if depth writing is enabled
+ * @returns the current depth writing state
+ */
+export function getDepthWrite(engineState) {
+    return engineState._depthCullingState.depthMask;
+}
+/**
+ * Enable or disable depth writing
+ * @param enable defines the state to set
+ */
+export function setDepthWrite(engineState, enable) {
+    engineState._depthCullingState.depthMask = enable;
+}
+/**
+ * Gets a boolean indicating if stencil buffer is enabled
+ * @returns the current stencil buffer state
+ */
+export function getStencilBuffer(engineState) {
+    return engineState._stencilState.stencilTest;
+}
+/**
+ * Enable or disable the stencil buffer
+ * @param enable defines if the stencil buffer must be enabled or disabled
+ */
+export function setStencilBuffer(engineState, enable) {
+    engineState._stencilState.stencilTest = enable;
+}
+/**
+ * Gets the current stencil mask
+ * @returns a number defining the new stencil mask to use
+ */
+export function getStencilMask(engineState) {
+    return engineState._stencilState.stencilMask;
+}
+/**
+ * Sets the current stencil mask
+ * @param mask defines the new stencil mask to use
+ */
+export function setStencilMask(engineState, mask) {
+    engineState._stencilState.stencilMask = mask;
+}
+/**
+ * Gets the current stencil function
+ * @returns a number defining the stencil function to use
+ */
+export function getStencilFunction(engineState) {
+    return engineState._stencilState.stencilFunc;
+}
+/**
+ * Gets the current stencil reference value
+ * @returns a number defining the stencil reference value to use
+ */
+export function getStencilFunctionReference(engineState) {
+    return engineState._stencilState.stencilFuncRef;
+}
+/**
+ * Gets the current stencil mask
+ * @returns a number defining the stencil mask to use
+ */
+export function getStencilFunctionMask(engineState) {
+    return engineState._stencilState.stencilFuncMask;
+}
+/**
+ * Sets the current stencil function
+ * @param stencilFunc defines the new stencil function to use
+ */
+export function setStencilFunction(engineState, stencilFunc) {
+    engineState._stencilState.stencilFunc = stencilFunc;
+}
+/**
+ * Sets the current stencil reference
+ * @param reference defines the new stencil reference to use
+ */
+export function setStencilFunctionReference(engineState, reference) {
+    engineState._stencilState.stencilFuncRef = reference;
+}
+/**
+ * Sets the current stencil mask
+ * @param mask defines the new stencil mask to use
+ */
+export function setStencilFunctionMask(engineState, mask) {
+    engineState._stencilState.stencilFuncMask = mask;
+}
+/**
+ * Gets the current stencil operation when stencil fails
+ * @returns a number defining stencil operation to use when stencil fails
+ */
+export function getStencilOperationFail(engineState) {
+    return engineState._stencilState.stencilOpStencilFail;
+}
+/**
+ * Gets the current stencil operation when depth fails
+ * @returns a number defining stencil operation to use when depth fails
+ */
+export function getStencilOperationDepthFail(engineState) {
+    return engineState._stencilState.stencilOpDepthFail;
+}
+/**
+ * Gets the current stencil operation when stencil passes
+ * @returns a number defining stencil operation to use when stencil passes
+ */
+export function getStencilOperationPass(engineState) {
+    return engineState._stencilState.stencilOpStencilDepthPass;
+}
+/**
+ * Sets the stencil operation to use when stencil fails
+ * @param operation defines the stencil operation to use when stencil fails
+ */
+export function setStencilOperationFail(engineState, operation) {
+    engineState._stencilState.stencilOpStencilFail = operation;
+}
+/**
+ * Sets the stencil operation to use when depth fails
+ * @param operation defines the stencil operation to use when depth fails
+ */
+export function setStencilOperationDepthFail(engineState, operation) {
+    engineState._stencilState.stencilOpDepthFail = operation;
+}
+/**
+ * Sets the stencil operation to use when stencil passes
+ * @param operation defines the stencil operation to use when stencil passes
+ */
+export function setStencilOperationPass(engineState, operation) {
+    engineState._stencilState.stencilOpStencilDepthPass = operation;
+}
+/**
+ * Gets the current depth function
+ * @returns a number defining the depth function
+ */
+export function getDepthFunction(engineState) {
+    return engineState._depthCullingState.depthFunc;
+}
+/**
+ * Sets the current depth function
+ * @param depthFunc defines the function to use
+ */
+export function setDepthFunction(engineState, depthFunc) {
+    engineState._depthCullingState.depthFunc = depthFunc;
+}
+/**
+ * Sets the current depth function to GREATER
+ */
+export function setDepthFunctionToGreater(engineState) {
+    setDepthFunction(engineState, 516 /* 516 */);
+}
+/**
+ * Sets the current depth function to GEQUAL
+ */
+export function setDepthFunctionToGreaterOrEqual(engineState) {
+    setDepthFunction(engineState, 518 /* 518 */);
+}
+/**
+ * Sets the current depth function to LESS
+ */
+export function setDepthFunctionToLess(engineState) {
+    setDepthFunction(engineState, 513 /* 513 */);
+}
+/**
+ * Sets the current depth function to LEQUAL
+ */
+export function setDepthFunctionToLessOrEqual(engineState) {
+    setDepthFunction(engineState, 515 /* 515 */);
+}
+/**
+ * Caches the state of the stencil buffer
+ */
+export function cacheStencilState(engineState) {
+    const fes = engineState;
+    fes._cachedStencilBuffer = getStencilBuffer(engineState);
+    fes._cachedStencilFunction = getStencilFunction(engineState);
+    fes._cachedStencilMask = getStencilMask(engineState);
+    fes._cachedStencilOperationPass = getStencilOperationPass(engineState);
+    fes._cachedStencilOperationFail = getStencilOperationFail(engineState);
+    fes._cachedStencilOperationDepthFail = getStencilOperationDepthFail(engineState);
+    fes._cachedStencilReference = getStencilFunctionReference(engineState);
+}
+/**
+ * Restores the state of the stencil buffer
+ */
+export function restoreStencilState(engineState) {
+    const fes = engineState;
+    setStencilFunction(engineState, fes._cachedStencilFunction);
+    setStencilMask(engineState, fes._cachedStencilMask);
+    setStencilBuffer(engineState, fes._cachedStencilBuffer);
+    setStencilOperationPass(engineState, fes._cachedStencilOperationPass);
+    setStencilOperationFail(engineState, fes._cachedStencilOperationFail);
+    setStencilOperationDepthFail(engineState, fes._cachedStencilOperationDepthFail);
+    setStencilFunctionReference(engineState, fes._cachedStencilReference);
+}
+/**
+ * Toggle full screen mode
+ * @param requestPointerLock defines if a pointer lock should be requested from the user
+ */
+export function switchFullscreen(engineState, requestPointerLock) {
+    if (engineState.isFullscreen) {
+        exitFullscreen(engineState);
+    }
+    else {
+        enterFullscreen(engineState, requestPointerLock);
+    }
+}
+/**
+ * Enters full screen mode
+ * @param requestPointerLock defines if a pointer lock should be requested from the user
+ */
+export function enterFullscreen(engineState, requestPointerLock) {
+    const fes = engineState;
+    if (!engineState.isFullscreen) {
+        fes._pointerLockRequested = requestPointerLock;
+        if (fes._renderingCanvas) {
+            _RequestFullscreen(fes._renderingCanvas);
+        }
+    }
+}
+/**
+ * Exits full screen mode
+ */
+export function exitFullscreen(engineState) {
+    if (engineState.isFullscreen) {
+        _ExitFullscreen();
+    }
+}
+/**
+ * Enters Pointerlock mode
+ */
+export function enterPointerlock(engineState) {
+    const fes = engineState;
+    if (fes._renderingCanvas) {
+        _RequestPointerlock(fes._renderingCanvas);
+    }
+}
+/**
+ * // TODO - this is probably not needed...
+ * Exits Pointerlock mode
+ */
+export function exitPointerlock(engineState) {
+    _ExitPointerlock();
+}
+/**
+ * @internal
+ */
+export function _releaseRenderTargetWrapper(engineState, rtWrapper) {
+    const fes = engineState;
+    const index = fes._renderTargetWrapperCache.indexOf(rtWrapper);
+    if (index !== -1) {
+        fes._renderTargetWrapperCache.splice(index, 1);
+    }
+    // From Engine
+    // Set output texture of post process to null if the framebuffer has been released/disposed
+    fes.scenes.forEach((scene) => {
+        scene.postProcesses.forEach((postProcess) => {
+            if (postProcess._outputTexture === rtWrapper) {
+                postProcess._outputTexture = null;
+            }
+        });
+        scene.cameras.forEach((camera) => {
+            camera._postProcesses.forEach((postProcess) => {
+                if (postProcess) {
+                    if (postProcess._outputTexture === rtWrapper) {
+                        postProcess._outputTexture = null;
+                    }
+                }
+            });
+        });
+    });
+}
+let renderPassIdCounter = 0;
+/**
+ * Gets the names of the render passes that are currently created
+ * @returns list of the render pass names
+ */
+export function getRenderPassNames(engineState) {
+    return engineState._renderPassNames;
+}
+/**
+ * Gets the name of the current render pass
+ * @returns name of the current render pass
+ */
+export function getCurrentRenderPassName(engineState) {
+    return engineState._renderPassNames[engineState.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
+ */
+export function createRenderPassId(engineState, name) {
+    // Note: render pass id == 0 is always for the main render pass
+    const id = ++renderPassIdCounter;
+    engineState._renderPassNames[id] = name !== null && name !== void 0 ? name : "NONAME";
+    return id;
+}
+/**
+ * Releases a render pass id
+ * @param id id of the render pass to release
+ */
+export function releaseRenderPassId(engineState, id) {
+    engineState._renderPassNames[id] = undefined;
+    for (let s = 0; s < engineState.scenes.length; ++s) {
+        const scene = engineState.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);
+                }
+            }
+        }
+    }
+}
+/**
+ * Enable or disable color writing
+ * @param enable defines the state to set
+ */
+export function setColorWrite(engineState, enable) {
+    const fes = engineState;
+    if (enable !== fes._colorWrite) {
+        fes._colorWriteChanged = true;
+        fes._colorWrite = enable;
+    }
+}
+/**
+ * Gets a boolean indicating if color writing is enabled
+ * @returns the current color writing state
+ */
+export function getColorWrite(engineState) {
+    return engineState._colorWrite;
+}
+export function _renderFrame(engineState) {
+    const fes = engineState;
+    for (let index = 0; index < fes._activeRenderLoops.length; index++) {
+        const renderFunction = fes._activeRenderLoops[index];
+        renderFunction();
+    }
+}
+//# sourceMappingURL=engine.base.js.map