@babylonjs/core 7.2.2 → 7.3.0

package/Engines/thinEngine.js

@@ -1,25 +1,18 @@
-/* eslint-disable @typescript-eslint/no-unused-vars */
-import { EngineStore } from "./engineStore.js";
-import { Effect } from "../Materials/effect.js";
-import { _WarnImport } from "../Misc/devTools.js";
-import { Observable } from "../Misc/observable.js";
-import { DepthCullingState } from "../States/depthCullingState.js";
-import { StencilState } from "../States/stencilState.js";
-import { AlphaState } from "../States/alphaCullingState.js";
-
-import { InternalTexture, InternalTextureSource } from "../Materials/Textures/internalTexture.js";
+import { IsWrapper } from "../Materials/drawWrapper.functions.js";
 import { Logger } from "../Misc/logger.js";
-import { IsDocumentAvailable, IsWindowObjectExist } from "../Misc/domManagement.js";
+import { IsWindowObjectExist } from "../Misc/domManagement.js";
 import { WebGLShaderProcessor } from "./WebGL/webGLShaderProcessors.js";
 import { WebGL2ShaderProcessor } from "./WebGL/webGL2ShaderProcessors.js";
 import { WebGLDataBuffer } from "../Meshes/WebGL/webGLDataBuffer.js";
-import { WebGLPipelineContext } from "./WebGL/webGLPipelineContext.js";
-import { PerformanceConfigurator } from "./performanceConfigurator.js";
+import { CeilingPOT, FloorPOT, GetExponentOfTwo, NearestPOT } from "../Misc/tools.functions.js";
+import { AbstractEngine, QueueNewFrame } from "./abstractEngine.js";
+
 import { WebGLHardwareTexture } from "./WebGL/webGLHardwareTexture.js";
-import { DrawWrapper } from "../Materials/drawWrapper.js";
-import { StencilStateComposer } from "../States/stencilStateComposer.js";
 import { ShaderLanguage } from "../Materials/shaderLanguage.js";
-import { PrecisionDate } from "../Misc/precisionDate.js";
+import { WebGLPipelineContext } from "./WebGL/webGLPipelineContext.js";
+import { InternalTexture, InternalTextureSource } from "../Materials/Textures/internalTexture.js";
+import { Effect } from "../Materials/effect.js";
+import { _WarnImport } from "../Misc/devTools.js";
 /**
  * Keeps track of all the buffer info used in engine.
  */
@@ -28,30 +21,7 @@ class BufferPointer {
 /**
  * The base engine class (root of all engines)
  */
-export class ThinEngine {
-    /**
-     * Returns the current npm package of the sdk
-     */
-    // Not mixed with Version for tooling purpose.
-    static get NpmPackage() {
-        return "babylonjs@7.2.2";
-    }
-    /**
-     * Returns the current version of the framework
-     */
-    static get Version() {
-        return "7.2.2";
-    }
-    /**
-     * Returns a string describing the current engine
-     */
-    get description() {
-        let description = this.name + this.webGLVersion;
-        if (this._caps.parallelShaderCompile) {
-            description += " - Parallel shader compilation";
-        }
-        return description;
-    }
+export class ThinEngine extends AbstractEngine {
     /**
      * Gets or sets the name of the engine
      */
@@ -67,9 +37,6 @@ export class ThinEngine {
     get version() {
         return this._webGLVersion;
     }
-    get isDisposed() {
-        return this._isDisposed;
-    }
     /**
      * Gets or sets the relative url used to load shaders if using the engine in non-minified mode
      */
@@ -79,37 +46,6 @@ export class ThinEngine {
     static set ShadersRepository(value) {
         Effect.ShadersRepository = value;
     }
-    /**
-     * @internal
-     */
-    _getShaderProcessor(shaderLanguage) {
-        return this._shaderProcessor;
-    }
-    /**
-     * Gets or sets a boolean indicating if depth buffer should be reverse, going from far to near.
-     * This can provide greater z depth for distant objects.
-     */
-    get useReverseDepthBuffer() {
-        return this._useReverseDepthBuffer;
-    }
-    set useReverseDepthBuffer(useReverse) {
-        if (useReverse === this._useReverseDepthBuffer) {
-            return;
-        }
-        this._useReverseDepthBuffer = useReverse;
-        if (useReverse) {
-            this._depthCullingState.depthFunc = 518;
-        }
-        else {
-            this._depthCullingState.depthFunc = 515;
-        }
-    }
-    /**
-     * Gets the current frame id
-     */
-    get frameId() {
-        return this._frameId;
-    }
     /**
      * Gets a boolean indicating that the engine supports uniform buffers
      * @see https://doc.babylonjs.com/setup/support/webGL2#uniform-buffer-objets
@@ -117,17 +53,6 @@ export class ThinEngine {
     get supportsUniformBuffers() {
         return this.webGLVersion > 1 && !this.disableUniformBuffers;
     }
-    /**
-     * Gets the options used for engine creation
-     * @returns EngineOptions object
-     */
-    getCreationOptions() {
-        return this._creationOptions;
-    }
-    /** @internal */
-    get _shouldUseHighPrecisionShader() {
-        return !!(this._caps.highPrecisionShaderSupported && this._highPrecisionShadersAllowed);
-    }
     /**
      * Gets a boolean indicating that only power of 2 textures are supported
      * Please note that you can still use non power of 2 textures but in this case the engine will forcefully convert them
@@ -135,23 +60,6 @@ export class ThinEngine {
     get needPOTTextures() {
         return this._webGLVersion < 2 || this.forcePOTTextures;
     }
-    /**
-     * Gets the list of current active render loop functions
-     * @returns a read only array with the current render loop functions
-     */
-    get activeRenderLoops() {
-        return this._activeRenderLoops;
-    }
-    /**
-     * Gets or sets a boolean indicating if resources should be retained to be able to handle context lost events
-     * @see https://doc.babylonjs.com/features/featuresDeepDive/scene/optimize_your_scene#handling-webgl-context-lost
-     */
-    get doNotHandleContextLost() {
-        return this._doNotHandleContextLost;
-    }
-    set doNotHandleContextLost(value) {
-        this._doNotHandleContextLost = value;
-    }
     get _supportsHardwareTextureRescaling() {
         return false;
     }
@@ -163,112 +71,12 @@ export class ThinEngine {
     set framebufferDimensionsObject(dimensions) {
         this._framebufferDimensionsObject = dimensions;
     }
-    /**
-     * Gets the current viewport
-     */
-    get currentViewport() {
-        return this._cachedViewport;
-    }
-    /**
-     * Gets the default empty texture
-     */
-    get emptyTexture() {
-        if (!this._emptyTexture) {
-            this._emptyTexture = this.createRawTexture(new Uint8Array(4), 1, 1, 5, false, false, 1);
-        }
-        return this._emptyTexture;
-    }
-    /**
-     * Gets the default empty 3D texture
-     */
-    get emptyTexture3D() {
-        if (!this._emptyTexture3D) {
-            this._emptyTexture3D = this.createRawTexture3D(new Uint8Array(4), 1, 1, 1, 5, false, false, 1);
-        }
-        return this._emptyTexture3D;
-    }
-    /**
-     * Gets the default empty 2D array texture
-     */
-    get emptyTexture2DArray() {
-        if (!this._emptyTexture2DArray) {
-            this._emptyTexture2DArray = this.createRawTexture2DArray(new Uint8Array(4), 1, 1, 1, 5, false, false, 1);
-        }
-        return this._emptyTexture2DArray;
-    }
-    /**
-     * Gets the default empty cube texture
-     */
-    get emptyCubeTexture() {
-        if (!this._emptyCubeTexture) {
-            const faceData = new Uint8Array(4);
-            const cubeData = [faceData, faceData, faceData, faceData, faceData, faceData];
-            this._emptyCubeTexture = this.createRawCubeTexture(cubeData, 1, 5, 0, false, false, 1);
-        }
-        return this._emptyCubeTexture;
-    }
-    /**
-     * Gets a boolean indicating if the engine runs in WebGPU or not.
-     */
-    get isWebGPU() {
-        return this._isWebGPU;
-    }
-    /**
-     * Gets the shader platform name used by the effects.
-     */
-    get shaderPlatformName() {
-        return this._shaderPlatformName;
-    }
-    /**
-     * Enables or disables the snapshot rendering mode
-     * Note that the WebGL engine does not support snapshot rendering so setting the value won't have any effect for this engine
-     */
-    get snapshotRendering() {
-        return false;
-    }
-    set snapshotRendering(activate) {
-        // WebGL engine does not support snapshot rendering
-    }
-    /**
-     * Gets or sets the snapshot rendering mode
-     */
-    get snapshotRenderingMode() {
-        return this._snapshotRenderingMode;
-    }
-    set snapshotRenderingMode(mode) {
-        this._snapshotRenderingMode = mode;
-    }
     /**
      * Creates a new snapshot at the next frame using the current snapshotRenderingMode
      */
     snapshotRenderingReset() {
         this.snapshotRendering = false;
     }
-    static _CreateCanvas(width, height) {
-        if (typeof document === "undefined") {
-            return new OffscreenCanvas(width, height);
-        }
-        const canvas = document.createElement("canvas");
-        canvas.width = width;
-        canvas.height = height;
-        return canvas;
-    }
-    /**
-     * Create a canvas. This method is overridden by other engines
-     * @param width width
-     * @param height height
-     * @returns ICanvas interface
-     */
-    createCanvas(width, height) {
-        return ThinEngine._CreateCanvas(width, height);
-    }
-    /**
-     * Create an image to use with canvas
-     * @returns IImage interface
-     */
-    createCanvasImage() {
-        return document.createElement("img");
-    }
     /**
      * 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
@@ -277,110 +85,23 @@ export class ThinEngine {
      * @param adaptToDeviceRatio defines whether to adapt to the device's viewport characteristics (default: false)
      */
     constructor(canvasOrContext, antialias, options, adaptToDeviceRatio) {
+        options = options || {};
+        super((antialias ?? options.antialias) || false, options, adaptToDeviceRatio);
         /** @internal */
         this._name = "WebGL";
-        this._isDisposed = false;
         /**
          * Gets or sets a boolean that indicates if textures must be forced to power of 2 size even if not required
          */
         this.forcePOTTextures = false;
-        /**
-         * Gets a boolean indicating if the engine is currently rendering in fullscreen mode
-         */
-        this.isFullscreen = false;
-        /**
-         * Gets or sets a boolean indicating if back faces must be culled. If false, front faces are culled instead (true by default)
-         * If non null, this takes precedence over the value from the material
-         */
-        this.cullBackFaces = null;
-        /**
-         * Gets or sets a boolean indicating if the engine must keep rendering even if the window is not in foreground
-         */
-        this.renderEvenInBackground = true;
-        /**
-         * Gets or sets a boolean indicating that cache can be kept between frames
-         */
-        this.preventCacheWipeBetweenFrames = false;
         /** Gets or sets a boolean indicating if the engine should validate programs after compilation */
         this.validateShaderPrograms = false;
-        this._useReverseDepthBuffer = false;
-        /**
-         * Indicates if the z range in NDC space is 0..1 (value: true) or -1..1 (value: false)
-         */
-        this.isNDCHalfZRange = false;
-        /**
-         * Indicates that the origin of the texture/framebuffer space is the bottom left corner. If false, the origin is top left
-         */
-        this.hasOriginBottomLeft = true;
         /**
          * Gets or sets a boolean indicating that uniform buffers must be disabled even if they are supported
          */
         this.disableUniformBuffers = false;
-        /**
-         * An event triggered when the engine is disposed.
-         */
-        this.onDisposeObservable = new Observable();
-        this._frameId = 0;
-        /** @internal */
-        this._uniformBuffers = new Array();
-        /** @internal */
-        this._storageBuffers = new Array();
         /** @internal */
         this._webGLVersion = 1.0;
-        this._windowIsBackground = false;
-        this._highPrecisionShadersAllowed = true;
-        /** @internal */
-        this._badOS = false;
-        /** @internal */
-        this._badDesktopOS = false;
-        this._activeRenderLoops = new Array();
-        // Lost context
-        /**
-         * Observable signaled when a context lost event is raised
-         */
-        this.onContextLostObservable = new Observable();
-        /**
-         * Observable signaled when a context restored event is raised
-         */
-        this.onContextRestoredObservable = new Observable();
-        this._contextWasLost = false;
-        /** @internal */
-        this._doNotHandleContextLost = false;
-        /**
-         * Gets or sets a boolean indicating that vertex array object must be disabled even if they are supported
-         */
-        this.disableVertexArrayObjects = false;
-        // States
-        /** @internal */
-        this._colorWrite = true;
-        /** @internal */
-        this._colorWriteChanged = true;
-        /** @internal */
-        this._depthCullingState = new DepthCullingState();
-        /** @internal */
-        this._stencilStateComposer = new StencilStateComposer();
-        /** @internal */
-        this._stencilState = new StencilState();
-        /** @internal */
-        this._alphaState = new AlphaState();
-        /** @internal */
-        this._alphaMode = 1;
-        /** @internal */
-        this._alphaEquation = 0;
-        // Cache
-        /** @internal */
-        this._internalTexturesCache = new Array();
-        /** @internal */
-        this._renderTargetWrapperCache = new Array();
-        /** @internal */
-        this._activeChannel = 0;
-        this._currentTextureChannel = -1;
-        /** @internal */
-        this._boundTexturesCache = {};
-        this._compiledEffects = {};
         this._vertexAttribArraysEnabled = [];
-        /** @internal */
-        this._currentRenderTarget = null;
         this._uintIndicesCurrentlySet = false;
         this._currentBoundBuffer = new Array();
         /** @internal */
@@ -390,42 +111,11 @@ export class ThinEngine {
         this._currentBufferPointers = new Array();
         this._currentInstanceLocations = new Array();
         this._currentInstanceBuffers = new Array();
-        /** @internal */
-        this._boundRenderFunction = () => this._renderLoop();
         this._vaoRecordInProgress = false;
         this._mustWipeVertexAttributes = false;
-        /** @internal */
-        this._frameHandler = 0;
         this._nextFreeTextureSlots = new Array();
         this._maxSimultaneousTextures = 0;
         this._maxMSAASamplesOverride = null;
-        this._activeRequests = new Array();
-        /**
-         * If set to true zooming in and out in the browser will rescale the hardware-scaling correctly.
-         */
-        this.adaptToDeviceRatio = false;
-        /** @internal */
-        this._lastDevicePixelRatio = 1.0;
-        /** @internal */
-        this._transformTextureUrl = null;
-        /**
-         * Gets information about the current host
-         */
-        this.hostInformation = {
-            isMobile: false,
-        };
-        /**
-         * Defines whether the engine has been created with the premultipliedAlpha option on or not.
-         */
-        this.premultipliedAlpha = true;
-        /**
-         * Observable event triggered before each texture is initialized
-         */
-        this.onBeforeTextureInitObservable = new Observable();
-        /** @internal */
-        this._isWebGPU = false;
-        this._snapshotRenderingMode = 0;
-        this._viewportCached = { x: 0, y: 0, z: 0, w: 0 };
         this._unpackFlipYCached = null;
         /**
          * In case you are sharing the context with other applications, it might
@@ -434,35 +124,10 @@ export class ThinEngine {
          */
         this.enableUnpackFlipYCached = true;
         this._boundUniforms = {};
-        this.startTime = PrecisionDate.Now;
-        let canvas = null;
-        options = options || {};
-        this._creationOptions = options;
-        // Save this off for use in resize().
-        this.adaptToDeviceRatio = adaptToDeviceRatio ?? false;
-        this._stencilStateComposer.stencilGlobal = this._stencilState;
-        PerformanceConfigurator.SetMatrixPrecision(!!options.useHighPrecisionMatrix);
-        options.antialias = antialias ?? options.antialias;
-        options.deterministicLockstep = options.deterministicLockstep ?? false;
-        options.lockstepMaxSteps = options.lockstepMaxSteps ?? 4;
-        options.timeStep = options.timeStep ?? 1 / 60;
-        options.audioEngine = options.audioEngine ?? true;
-        options.stencil = options.stencil ?? true;
-        this._audioContext = options.audioEngineOptions?.audioContext ?? null;
-        this._audioDestination = options.audioEngineOptions?.audioDestination ?? null;
-        this.premultipliedAlpha = options.premultipliedAlpha ?? true;
-        this.useExactSrgbConversions = options.useExactSrgbConversions ?? false;
-        this._doNotHandleContextLost = !!options.doNotHandleContextLost;
-        this._isStencilEnable = options.stencil ? true : false;
-        // Viewport
-        adaptToDeviceRatio = adaptToDeviceRatio || options.adaptToDeviceRatio || false;
-        const devicePixelRatio = IsWindowObjectExist() ? window.devicePixelRatio || 1.0 : 1.0;
-        const limitDeviceRatio = options.limitDeviceRatio || devicePixelRatio;
-        this._hardwareScalingLevel = adaptToDeviceRatio ? 1.0 / Math.min(limitDeviceRatio, devicePixelRatio) : 1.0;
-        this._lastDevicePixelRatio = devicePixelRatio;
         if (!canvasOrContext) {
             return;
         }
+        let canvas = null;
         if (canvasOrContext.getContext) {
             canvas = canvasOrContext;
             this._renderingCanvas = canvas;
@@ -527,8 +192,6 @@ export class ThinEngine {
                 canvas.addEventListener("webglcontextrestored", this._onContextRestored, false);
                 options.powerPreference = options.powerPreference || "high-performance";
             }
-            // Detect if we are running on a faulty buggy desktop OS.
-            this._badDesktopOS = /^((?!chrome|android).)*safari/i.test(navigator.userAgent);
             if (this._badDesktopOS) {
                 options.xrCompatible = false;
             }
@@ -594,8 +257,6 @@ export class ThinEngine {
         }
         // Shader processor
         this._shaderProcessor = this.webGLVersion > 1 ? new WebGL2ShaderProcessor() : new WebGLShaderProcessor();
-        // Detect if we are running on a faulty buggy OS.
-        this._badOS = /iPad/i.test(navigator.userAgent) || /iPhone/i.test(navigator.userAgent);
         // Starting with iOS 14, we can trust the browser
         // let matches = navigator.userAgent.match(/Version\/(\d+)/);
         // if (matches && matches.length === 2) {
@@ -610,81 +271,9 @@ export class ThinEngine {
             this._renderingCanvas.setAttribute("data-engine", versionToLog);
         }
     }
-    _setupMobileChecks() {
-        if (!(navigator && navigator.userAgent)) {
-            return;
-        }
-        // Function to check if running on mobile device
-        this._checkForMobile = () => {
-            const currentUA = navigator.userAgent;
-            this.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
-        this._checkForMobile();
-        // Set up event listener to check when window is resized (used to get emulator activation to work properly)
-        if (IsWindowObjectExist()) {
-            window.addEventListener("resize", this._checkForMobile);
-        }
-    }
     _clearEmptyResources() {
         this._dummyFramebuffer = null;
-        this._emptyTexture = null;
-        this._emptyCubeTexture = null;
-        this._emptyTexture3D = null;
-        this._emptyTexture2DArray = null;
-    }
-    _rebuildGraphicsResources() {
-        // Ensure webgl and engine states are matching
-        this.wipeCaches(true);
-        // Rebuild effects
-        this._rebuildEffects();
-        this._rebuildComputeEffects?.();
-        // Note:
-        //  The call to _rebuildBuffers must be made before the call to _rebuildInternalTextures because in the process of _rebuildBuffers the buffers used by the post process managers will be rebuilt
-        //  and we may need to use the post process manager of the scene during _rebuildInternalTextures (in WebGL1, non-POT textures are rescaled using a post process + post process manager of the scene)
-        // Rebuild buffers
-        this._rebuildBuffers();
-        // Rebuild textures
-        this._rebuildInternalTextures();
-        // Rebuild textures
-        this._rebuildTextures();
-        // Rebuild textures
-        this._rebuildRenderTargetWrappers();
-        // Reset engine states after all the buffer/textures/... have been rebuilt
-        this.wipeCaches(true);
-    }
-    _flagContextRestored() {
-        Logger.Warn(this.name + " context successfully restored.");
-        this.onContextRestoredObservable.notifyObservers(this);
-        this._contextWasLost = false;
-    }
-    _restoreEngineAfterContextLost(initEngine) {
-        // Adding a timeout to avoid race condition at browser level
-        setTimeout(async () => {
-            this._clearEmptyResources();
-            const depthTest = this._depthCullingState.depthTest; // backup those values because the call to initEngine / wipeCaches will reset them
-            const depthFunc = this._depthCullingState.depthFunc;
-            const depthMask = this._depthCullingState.depthMask;
-            const stencilTest = this._stencilState.stencilTest;
-            // Rebuild context
-            await initEngine();
-            this._rebuildGraphicsResources();
-            this._depthCullingState.depthTest = depthTest;
-            this._depthCullingState.depthFunc = depthFunc;
-            this._depthCullingState.depthMask = depthMask;
-            this._stencilState.stencilTest = stencilTest;
-            this._flagContextRestored();
-        }, 0);
-    }
-    /**
-     * Shared initialization across engines types.
-     * @param canvas The canvas associated with this instance of the engine.
-     */
-    _sharedInit(canvas) {
-        this._renderingCanvas = canvas;
+        super._clearEmptyResources();
     }
     /**
      * @internal
@@ -692,26 +281,6 @@ export class ThinEngine {
     _getShaderProcessingContext(shaderLanguage) {
         return null;
     }
-    _rebuildInternalTextures() {
-        const currentState = this._internalTexturesCache.slice(); // Do a copy because the rebuild will add proxies
-        for (const internalTexture of currentState) {
-            internalTexture._rebuild();
-        }
-    }
-    _rebuildRenderTargetWrappers() {
-        const currentState = this._renderTargetWrapperCache.slice(); // Do a copy because the rebuild will add proxies
-        for (const renderTargetWrapper of currentState) {
-            renderTargetWrapper._rebuild();
-        }
-    }
-    _rebuildEffects() {
-        for (const key in this._compiledEffects) {
-            const effect = this._compiledEffects[key];
-            effect._pipelineContext = null; // because _prepareEffect will try to dispose this pipeline before recreating it and that would lead to webgl errors
-            effect._prepareEffect();
-        }
-        Effect.ResetCache();
-    }
     /**
      * Gets a boolean indicating if all created effects are ready
      * @returns true if all effects are ready
@@ -725,13 +294,6 @@ export class ThinEngine {
         }
         return true;
     }
-    _rebuildBuffers() {
-        // Uniforms
-        for (const uniformBuffer of this._uniformBuffers) {
-            uniformBuffer._rebuildAfterContextLost();
-        }
-    }
-    _rebuildTextures() { }
     _initGLContext() {
         // Caps
         this._caps = {
@@ -1023,12 +585,6 @@ export class ThinEngine {
     getClassName() {
         return "ThinEngine";
     }
-    /**
-     * Returns true if the stencil buffer has been enabled through the creation option of the context.
-     */
-    get isStencilEnable() {
-        return this._isStencilEnable;
-    }
     /** @internal */
     _prepareWorkingCanvas() {
         if (this._workingCanvas) {
@@ -1040,18 +596,6 @@ export class ThinEngine {
             this._workingContext = context;
         }
     }
-    /**
-     * Reset the texture cache to empty state
-     */
-    resetTextureCache() {
-        for (const key in this._boundTexturesCache) {
-            if (!Object.prototype.hasOwnProperty.call(this._boundTexturesCache, key)) {
-                continue;
-            }
-            this._boundTexturesCache[key] = null;
-        }
-        this._currentTextureChannel = -1;
-    }
     /**
      * Gets an object containing information about the current engine context
      * @returns an object containing the vendor, the renderer and the version of the current engine context
@@ -1070,131 +614,13 @@ export class ThinEngine {
             version: this._glVersion,
         };
     }
-    /**
-     * Defines the hardware scaling level.
-     * By default the hardware scaling level is computed from the window device ratio.
-     * if level = 1 then the engine will render at the exact resolution of the canvas. If level = 0.5 then the engine will render at twice the size of the canvas.
-     * @param level defines the level to use
-     */
-    setHardwareScalingLevel(level) {
-        this._hardwareScalingLevel = level;
-        this.resize();
-    }
-    /**
-     * Gets the current hardware scaling level.
-     * By default the hardware scaling level is computed from the window device ratio.
-     * if level = 1 then the engine will render at the exact resolution of the canvas. If level = 0.5 then the engine will render at twice the size of the canvas.
-     * @returns a number indicating the current hardware scaling level
-     */
-    getHardwareScalingLevel() {
-        return this._hardwareScalingLevel;
-    }
-    /**
-     * Gets the list of loaded textures
-     * @returns an array containing all loaded textures
-     */
-    getLoadedTexturesCache() {
-        return this._internalTexturesCache;
-    }
-    /**
-     * Gets the object containing all engine capabilities
-     * @returns the EngineCapabilities object
-     */
-    getCaps() {
-        return this._caps;
-    }
-    /**
-     * stop executing a render loop function and remove it from the execution array
-     * @param renderFunction defines the function to be removed. If not provided all functions will be removed.
-     */
-    stopRenderLoop(renderFunction) {
-        if (!renderFunction) {
-            this._activeRenderLoops.length = 0;
-            this._cancelFrame();
-            return;
-        }
-        const index = this._activeRenderLoops.indexOf(renderFunction);
-        if (index >= 0) {
-            this._activeRenderLoops.splice(index, 1);
-            if (this._activeRenderLoops.length == 0) {
-                this._cancelFrame();
-            }
-        }
-    }
-    _cancelFrame() {
-        if (this._frameHandler !== 0) {
-            const handlerToCancel = this._frameHandler;
-            this._frameHandler = 0;
-            if (!IsWindowObjectExist()) {
-                if (typeof cancelAnimationFrame === "function") {
-                    return cancelAnimationFrame(handlerToCancel);
-                }
-            }
-            else {
-                const { cancelAnimationFrame } = this.getHostWindow() || window;
-                if (typeof cancelAnimationFrame === "function") {
-                    return cancelAnimationFrame(handlerToCancel);
-                }
-            }
-            return clearTimeout(handlerToCancel);
-        }
-    }
-    /** @internal */
-    _renderLoop() {
-        this._frameHandler = 0;
-        if (!this._contextWasLost) {
-            let shouldRender = true;
-            if (this._isDisposed || (!this.renderEvenInBackground && this._windowIsBackground)) {
-                shouldRender = false;
-            }
-            if (shouldRender) {
-                // Start new frame
-                this.beginFrame();
-                for (let index = 0; index < this._activeRenderLoops.length; index++) {
-                    const renderFunction = this._activeRenderLoops[index];
-                    renderFunction();
-                }
-                // Present
-                this.endFrame();
-            }
-        }
-        if (this._frameHandler === 0) {
-            this._frameHandler = this._queueNewFrame(this._boundRenderFunction, this.getHostWindow());
-        }
-    }
-    /**
-     * Gets the HTML canvas attached with the current webGL context
-     * @returns a HTML canvas
-     */
-    getRenderingCanvas() {
-        return this._renderingCanvas;
-    }
-    /**
-     * Gets the audio context specified in engine initialization options
-     * @returns an Audio Context
-     */
-    getAudioContext() {
-        return this._audioContext;
-    }
-    /**
-     * Gets the audio destination specified in engine initialization options
-     * @returns an audio destination node
-     */
-    getAudioDestination() {
-        return this._audioDestination;
-    }
-    /**
-     * Gets host window
-     * @returns the host window object
-     */
-    getHostWindow() {
-        if (!IsWindowObjectExist()) {
-            return null;
-        }
-        if (this._renderingCanvas && this._renderingCanvas.ownerDocument && this._renderingCanvas.ownerDocument.defaultView) {
-            return this._renderingCanvas.ownerDocument.defaultView;
+    /**Gets driver info if available */
+    extractDriverInfo() {
+        const glInfo = this.getGlInfo();
+        if (glInfo && glInfo.renderer) {
+            return glInfo.renderer;
         }
-        return window;
+        return "";
     }
     /**
      * Gets the current render width
@@ -1218,27 +644,6 @@ export class ThinEngine {
         }
         return this._framebufferDimensionsObject ? this._framebufferDimensionsObject.framebufferHeight : this._gl.drawingBufferHeight;
     }
-    /**
-     * Can be used to override the current requestAnimationFrame requester.
-     * @internal
-     */
-    _queueNewFrame(bindedRenderFunction, requester) {
-        return ThinEngine.QueueNewFrame(bindedRenderFunction, requester);
-    }
-    /**
-     * Register and execute a render loop. The engine can have more than one render function
-     * @param renderFunction defines the function to continuously execute
-     */
-    runRenderLoop(renderFunction) {
-        if (this._activeRenderLoops.indexOf(renderFunction) !== -1) {
-            return;
-        }
-        this._activeRenderLoops.push(renderFunction);
-        // On the first added function, start the render loop.
-        if (this._activeRenderLoops.length === 1 && this._frameHandler === 0) {
-            this._frameHandler = this._queueNewFrame(this._boundRenderFunction, this.getHostWindow());
-        }
-    }
     /**
      * Clear the current render buffer or the current render target (if any is set up)
      * @param color defines the color to use
@@ -1313,90 +718,21 @@ export class ThinEngine {
         }
     }
     /**
-     * Set the WebGL's viewport
-     * @param viewport defines the viewport element to be used
-     * @param requiredWidth defines the width required for rendering. If not provided the rendering canvas' width is used
-     * @param requiredHeight defines the height required for rendering. If not provided the rendering canvas' height is used
-     */
-    setViewport(viewport, requiredWidth, requiredHeight) {
-        const width = requiredWidth || this.getRenderWidth();
-        const height = requiredHeight || this.getRenderHeight();
-        const x = viewport.x || 0;
-        const y = viewport.y || 0;
-        this._cachedViewport = viewport;
-        this._viewport(x * width, y * height, width * viewport.width, height * viewport.height);
-    }
-    /**
-     * Begin a new frame
-     */
-    beginFrame() { }
-    /**
-     * Enf the current frame
+     * End the current frame
      */
     endFrame() {
+        super.endFrame();
         // Force a flush in case we are using a bad OS.
         if (this._badOS) {
             this.flushFramebuffer();
         }
-        this._frameId++;
-    }
-    /**
-     * Resize the view according to the canvas' size
-     * @param forceSetSize true to force setting the sizes of the underlying canvas
-     */
-    resize(forceSetSize = false) {
-        let width;
-        let height;
-        // Re-query hardware scaling level to handle zoomed-in resizing.
-        if (this.adaptToDeviceRatio) {
-            const devicePixelRatio = IsWindowObjectExist() ? window.devicePixelRatio || 1.0 : 1.0;
-            const changeRatio = this._lastDevicePixelRatio / devicePixelRatio;
-            this._lastDevicePixelRatio = devicePixelRatio;
-            this._hardwareScalingLevel *= changeRatio;
-        }
-        if (IsWindowObjectExist() && IsDocumentAvailable()) {
-            // make sure it is a Node object, and is a part of the document.
-            if (this._renderingCanvas) {
-                const boundingRect = this._renderingCanvas.getBoundingClientRect
-                    ? this._renderingCanvas.getBoundingClientRect()
-                    : {
-                        // fallback to last solution in case the function doesn't exist
-                        width: this._renderingCanvas.width * this._hardwareScalingLevel,
-                        height: this._renderingCanvas.height * this._hardwareScalingLevel,
-                    };
-                width = this._renderingCanvas.clientWidth || boundingRect.width || this._renderingCanvas.width || 100;
-                height = this._renderingCanvas.clientHeight || boundingRect.height || this._renderingCanvas.height || 100;
-            }
-            else {
-                width = window.innerWidth;
-                height = window.innerHeight;
-            }
-        }
-        else {
-            width = this._renderingCanvas ? this._renderingCanvas.width : 100;
-            height = this._renderingCanvas ? this._renderingCanvas.height : 100;
-        }
-        this.setSize(width / this._hardwareScalingLevel, height / this._hardwareScalingLevel, forceSetSize);
     }
     /**
-     * Force a specific size of the canvas
-     * @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
+     * Gets the performance monitor attached to this engine
+     * @see https://doc.babylonjs.com/features/featuresDeepDive/scene/optimize_your_scene#engineinstrumentation
      */
-    setSize(width, height, forceSetSize = false) {
-        if (!this._renderingCanvas) {
-            return false;
-        }
-        width = width | 0;
-        height = height | 0;
-        if (!forceSetSize && this._renderingCanvas.width === width && this._renderingCanvas.height === height) {
-            return false;
-        }
-        this._renderingCanvas.width = width;
-        this._renderingCanvas.height = height;
-        return true;
+    get performanceMonitor() {
+        throw new Error("Not Supported by ThinEngine");
     }
     /**
      * Binds the frame buffer to the specified texture.
@@ -1498,50 +834,6 @@ export class ThinEngine {
         }
         this._stencilStateComposer.stencilMaterial = stencil;
     }
-    /**
-     * Gets a boolean indicating if depth testing is enabled
-     * @returns the current state
-     */
-    getDepthBuffer() {
-        return this._depthCullingState.depthTest;
-    }
-    /**
-     * Enable or disable depth buffering
-     * @param enable defines the state to set
-     */
-    setDepthBuffer(enable) {
-        this._depthCullingState.depthTest = enable;
-    }
-    /**
-     * Set the z offset Factor to apply to current rendering
-     * @param value defines the offset to apply
-     */
-    setZOffset(value) {
-        this._depthCullingState.zOffset = this.useReverseDepthBuffer ? -value : value;
-    }
-    /**
-     * Gets the current value of the zOffset Factor
-     * @returns the current zOffset Factor state
-     */
-    getZOffset() {
-        const zOffset = this._depthCullingState.zOffset;
-        return this.useReverseDepthBuffer ? -zOffset : zOffset;
-    }
-    /**
-     * Set the z offset Units to apply to current rendering
-     * @param value defines the offset to apply
-     */
-    setZOffsetUnits(value) {
-        this._depthCullingState.zOffsetUnits = this.useReverseDepthBuffer ? -value : value;
-    }
-    /**
-     * Gets the current value of the zOffset Units
-     * @returns the current zOffset Units state
-     */
-    getZOffsetUnits() {
-        const zOffsetUnits = this._depthCullingState.zOffsetUnits;
-        return this.useReverseDepthBuffer ? -zOffsetUnits : zOffsetUnits;
-    }
     /**
      * @internal
      */
@@ -2186,10 +1478,6 @@ export class ThinEngine {
                 return this._gl.TRIANGLES;
         }
     }
-    /** @internal */
-    _reportDrawCall() {
-        // Will be implemented by children
-    }
     // Shaders
     /**
      * @internal
@@ -2213,49 +1501,6 @@ export class ThinEngine {
             this._gl.deleteProgram(webGLPipelineContext.program);
         }
     }
-    /** @internal */
-    _getGlobalDefines(defines) {
-        if (defines) {
-            if (this.isNDCHalfZRange) {
-                defines["IS_NDC_HALF_ZRANGE"] = "";
-            }
-            else {
-                delete defines["IS_NDC_HALF_ZRANGE"];
-            }
-            if (this.useReverseDepthBuffer) {
-                defines["USE_REVERSE_DEPTHBUFFER"] = "";
-            }
-            else {
-                delete defines["USE_REVERSE_DEPTHBUFFER"];
-            }
-            if (this.useExactSrgbConversions) {
-                defines["USE_EXACT_SRGB_CONVERSIONS"] = "";
-            }
-            else {
-                delete defines["USE_EXACT_SRGB_CONVERSIONS"];
-            }
-            return;
-        }
-        else {
-            let s = "";
-            if (this.isNDCHalfZRange) {
-                s += "#define IS_NDC_HALF_ZRANGE";
-            }
-            if (this.useReverseDepthBuffer) {
-                if (s) {
-                    s += "\n";
-                }
-                s += "#define USE_REVERSE_DEPTHBUFFER";
-            }
-            if (this.useExactSrgbConversions) {
-                if (s) {
-                    s += "\n";
-                }
-                s += "#define USE_EXACT_SRGB_CONVERSIONS";
-            }
-            return s;
-        }
-    }
     /**
      * Create a new effect (used to store vertex/fragment shaders)
      * @param baseName defines the base name of the effect (The name of file without .fragment.fx or .vertex.fx)
@@ -2286,7 +1531,7 @@ export class ThinEngine {
             }
             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;
     }
@@ -2538,7 +1783,7 @@ export class ThinEngine {
      * @param effect defines the effect to activate
      */
     enableEffect(effect) {
-        effect = effect !== null && DrawWrapper.IsWrapper(effect) ? effect.effect : effect; // get only the effect, we don't need a Wrapper in the WebGL engine
+        effect = effect !== null && IsWrapper(effect) ? effect.effect : effect; // get only the effect, we don't need a Wrapper in the WebGL engine
         if (!effect || effect === this._currentEffect) {
             return;
         }
@@ -2940,55 +2185,7 @@ export class ThinEngine {
             this._gl.colorMask(enable, enable, enable, enable);
         }
     }
-    /**
-     * Enable or disable color writing
-     * @param enable defines the state to set
-     */
-    setColorWrite(enable) {
-        if (enable !== this._colorWrite) {
-            this._colorWriteChanged = true;
-            this._colorWrite = enable;
-        }
-    }
-    /**
-     * Gets a boolean indicating if color writing is enabled
-     * @returns the current color writing state
-     */
-    getColorWrite() {
-        return this._colorWrite;
-    }
-    /**
-     * Gets the depth culling state manager
-     */
-    get depthCullingState() {
-        return this._depthCullingState;
-    }
-    /**
-     * Gets the alpha state manager
-     */
-    get alphaState() {
-        return this._alphaState;
-    }
-    /**
-     * Gets the stencil state manager
-     */
-    get stencilState() {
-        return this._stencilState;
-    }
-    /**
-     * Gets the stencil state composer
-     */
-    get stencilStateComposer() {
-        return this._stencilStateComposer;
-    }
     // Textures
-    /**
-     * Clears the list of texture accessible through engine.
-     * This can help preventing texture load conflict due to name collision.
-     */
-    clearInternalTexturesCache() {
-        this._internalTexturesCache.length = 0;
-    }
     /**
      * Force the entire cache to be cleared
      * You should not have to use this function unless your engine needs to share the webGL context with another engine
@@ -3027,6 +2224,15 @@ export class ThinEngine {
         this._cachedEffectForVertexBuffers = null;
         this.bindIndexBuffer(null);
     }
+    setTextureFromPostProcess(channel, postProcess, name) {
+        // Does nothing
+    }
+    setTextureFromPostProcessOutput(channel, postProcess, name) {
+        // Does nothing
+    }
+    setDepthStencilTexture(channel, uniform, texture, name) {
+        // Does nothing
+    }
     /**
      * @internal
      */
@@ -3237,142 +2443,7 @@ export class ThinEngine {
      */
     _getUseSRGBBuffer(useSRGBBuffer, noMipmap) {
         // Generating mipmaps for sRGB textures is not supported in WebGL1 so we must disable the support if mipmaps is enabled
-        return useSRGBBuffer && this._caps.supportSRGBBuffers && (this.webGLVersion > 1 || this.isWebGPU || noMipmap);
-    }
-    _createTextureBase(url, noMipmap, invertY, scene, samplingMode = 3, onLoad = null, onError = null, prepareTexture, prepareTextureProcessFunction, buffer = null, fallback = null, format = null, forcedExtension = null, mimeType, loaderOptions, useSRGBBuffer) {
-        url = url || "";
-        const fromData = url.substr(0, 5) === "data:";
-        const fromBlob = url.substr(0, 5) === "blob:";
-        const isBase64 = fromData && url.indexOf(";base64,") !== -1;
-        const texture = fallback ? fallback : new InternalTexture(this, InternalTextureSource.Url);
-        if (texture !== fallback) {
-            texture.label = url.substring(0, 60); // default label, can be overriden by the caller
-        }
-        const originalUrl = url;
-        if (this._transformTextureUrl && !isBase64 && !fallback && !buffer) {
-            url = this._transformTextureUrl(url);
-        }
-        if (originalUrl !== url) {
-            texture._originalUrl = originalUrl;
-        }
-        // establish the file extension, if possible
-        const lastDot = url.lastIndexOf(".");
-        let extension = forcedExtension ? forcedExtension : lastDot > -1 ? url.substring(lastDot).toLowerCase() : "";
-        let loader = null;
-        // Remove query string
-        const queryStringIndex = extension.indexOf("?");
-        if (queryStringIndex > -1) {
-            extension = extension.split("?")[0];
-        }
-        for (const availableLoader of ThinEngine._TextureLoaders) {
-            if (availableLoader.canLoad(extension, mimeType)) {
-                loader = availableLoader;
-                break;
-            }
-        }
-        if (scene) {
-            scene.addPendingData(texture);
-        }
-        texture.url = url;
-        texture.generateMipMaps = !noMipmap;
-        texture.samplingMode = samplingMode;
-        texture.invertY = invertY;
-        texture._useSRGBBuffer = this._getUseSRGBBuffer(!!useSRGBBuffer, noMipmap);
-        if (!this._doNotHandleContextLost) {
-            // Keep a link to the buffer only if we plan to handle context lost
-            texture._buffer = buffer;
-        }
-        let onLoadObserver = null;
-        if (onLoad && !fallback) {
-            onLoadObserver = texture.onLoadedObservable.add(onLoad);
-        }
-        if (!fallback) {
-            this._internalTexturesCache.push(texture);
-        }
-        const onInternalError = (message, exception) => {
-            if (scene) {
-                scene.removePendingData(texture);
-            }
-            if (url === originalUrl) {
-                if (onLoadObserver) {
-                    texture.onLoadedObservable.remove(onLoadObserver);
-                }
-                if (EngineStore.UseFallbackTexture && url !== EngineStore.FallbackTexture) {
-                    this._createTextureBase(EngineStore.FallbackTexture, noMipmap, texture.invertY, scene, samplingMode, null, onError, prepareTexture, prepareTextureProcessFunction, buffer, texture);
-                }
-                message = (message || "Unknown error") + (EngineStore.UseFallbackTexture ? " - Fallback texture was used" : "");
-                texture.onErrorObservable.notifyObservers({ message, exception });
-                if (onError) {
-                    onError(message, exception);
-                }
-            }
-            else {
-                // fall back to the original url if the transformed url fails to load
-                Logger.Warn(`Failed to load ${url}, falling back to ${originalUrl}`);
-                this._createTextureBase(originalUrl, noMipmap, texture.invertY, scene, samplingMode, onLoad, onError, prepareTexture, prepareTextureProcessFunction, buffer, texture, format, forcedExtension, mimeType, loaderOptions, useSRGBBuffer);
-            }
-        };
-        // processing for non-image formats
-        if (loader) {
-            const callback = (data) => {
-                loader.loadData(data, texture, (width, height, loadMipmap, isCompressed, done, loadFailed) => {
-                    if (loadFailed) {
-                        onInternalError("TextureLoader failed to load data");
-                    }
-                    else {
-                        prepareTexture(texture, extension, scene, { width, height }, texture.invertY, !loadMipmap, isCompressed, () => {
-                            done();
-                            return false;
-                        }, samplingMode);
-                    }
-                }, loaderOptions);
-            };
-            if (!buffer) {
-                this._loadFile(url, (data) => callback(new Uint8Array(data)), undefined, scene ? scene.offlineProvider : undefined, true, (request, exception) => {
-                    onInternalError("Unable to load " + (request ? request.responseURL : url, exception));
-                });
-            }
-            else {
-                if (buffer instanceof ArrayBuffer) {
-                    callback(new Uint8Array(buffer));
-                }
-                else if (ArrayBuffer.isView(buffer)) {
-                    callback(buffer);
-                }
-                else {
-                    if (onError) {
-                        onError("Unable to load: only ArrayBuffer or ArrayBufferView is supported", null);
-                    }
-                }
-            }
-        }
-        else {
-            const onload = (img) => {
-                if (fromBlob && !this._doNotHandleContextLost) {
-                    // We need to store the image if we need to rebuild the texture
-                    // in case of a webgl context lost
-                    texture._buffer = img;
-                }
-                prepareTexture(texture, extension, scene, img, texture.invertY, noMipmap, false, prepareTextureProcessFunction, samplingMode);
-            };
-            // According to the WebGL spec section 6.10, ImageBitmaps must be inverted on creation.
-            // So, we pass imageOrientation to _FileToolsLoadImage() as it may create an ImageBitmap.
-            if (!fromData || isBase64) {
-                if (buffer && (typeof buffer.decoding === "string" || buffer.close)) {
-                    onload(buffer);
-                }
-                else {
-                    ThinEngine._FileToolsLoadImage(url, onload, onInternalError, scene ? scene.offlineProvider : null, mimeType, texture.invertY && this._features.needsInvertingBitmap ? { imageOrientation: "flipY" } : undefined);
-                }
-            }
-            else if (typeof buffer === "string" || buffer instanceof ArrayBuffer || ArrayBuffer.isView(buffer) || buffer instanceof Blob) {
-                ThinEngine._FileToolsLoadImage(buffer, onload, onInternalError, scene ? scene.offlineProvider : null, mimeType, texture.invertY && this._features.needsInvertingBitmap ? { imageOrientation: "flipY" } : undefined);
-            }
-            else if (buffer) {
-                onload(buffer);
-            }
-        }
-        return texture;
+        return useSRGBBuffer && this._caps.supportSRGBBuffers && (this.webGLVersion > 1 || noMipmap);
     }
     /**
      * Usually called from Texture.ts.
@@ -3470,20 +2541,6 @@ export class ThinEngine {
             type: this._gl.UNSIGNED_BYTE,
         };
     }
-    /**
-     * Loads an image as an HTMLImageElement.
-     * @param input url string, ArrayBuffer, or Blob to load
-     * @param onLoad callback called when the image successfully loads
-     * @param onError callback called when the image fails to load
-     * @param offlineProvider offline provider for caching
-     * @param mimeType optional mime type
-     * @param imageBitmapOptions optional the options to use when creating an ImageBitmap
-     * @returns the HTMLImageElement of the loaded image
-     * @internal
-     */
-    static _FileToolsLoadImage(input, onLoad, onError, offlineProvider, mimeType, imageBitmapOptions) {
-        throw _WarnImport("FileTools");
-    }
     /**
      * @internal
      */
@@ -3826,8 +2883,8 @@ export class ThinEngine {
     }
     _prepareWebGLTexture(texture, extension, scene, img, invertY, noMipmap, isCompressed, processFunction, samplingMode = 3) {
         const maxTextureSize = this.getCaps().maxTextureSize;
-        const potWidth = Math.min(maxTextureSize, this.needPOTTextures ? ThinEngine.GetExponentOfTwo(img.width, maxTextureSize) : img.width);
-        const potHeight = Math.min(maxTextureSize, this.needPOTTextures ? ThinEngine.GetExponentOfTwo(img.height, maxTextureSize) : img.height);
+        const potWidth = Math.min(maxTextureSize, this.needPOTTextures ? GetExponentOfTwo(img.width, maxTextureSize) : img.width);
+        const potHeight = Math.min(maxTextureSize, this.needPOTTextures ? GetExponentOfTwo(img.height, maxTextureSize) : img.height);
         const gl = this._gl;
         if (!gl) {
             return;
@@ -3926,15 +2983,6 @@ export class ThinEngine {
             texture._irradianceTexture.dispose();
         }
     }
-    /**
-     * @internal
-     */
-    _releaseRenderTargetWrapper(rtWrapper) {
-        const index = this._renderTargetWrapperCache.indexOf(rtWrapper);
-        if (index !== -1) {
-            this._renderTargetWrapperCache.splice(index, 1);
-        }
-    }
     _deleteTexture(texture) {
         if (texture) {
             this._gl.deleteTexture(texture);
@@ -4240,27 +3288,12 @@ export class ThinEngine {
      * Dispose and release all associated resources
      */
     dispose() {
-        this._isDisposed = true;
-        this.stopRenderLoop();
-        // Clear observables
-        if (this.onBeforeTextureInitObservable) {
-            this.onBeforeTextureInitObservable.clear();
-        }
-        // Empty texture
-        if (this._emptyTexture) {
-            this._releaseTexture(this._emptyTexture);
-            this._emptyTexture = null;
-        }
-        if (this._emptyCubeTexture) {
-            this._releaseTexture(this._emptyCubeTexture);
-            this._emptyCubeTexture = null;
-        }
+        super.dispose();
         if (this._dummyFramebuffer) {
             this._gl.deleteFramebuffer(this._dummyFramebuffer);
         }
         // Release effects
         this.releaseEffects();
-        this.releaseComputeEffects?.();
         // Unbind
         this.unbindAllAttributes();
         this._boundUniforms = {};
@@ -4271,22 +3304,12 @@ export class ThinEngine {
                     this._renderingCanvas.removeEventListener("webglcontextlost", this._onContextLost);
                     this._renderingCanvas.removeEventListener("webglcontextrestored", this._onContextRestored);
                 }
-                window.removeEventListener("resize", this._checkForMobile);
             }
         }
         this._workingCanvas = null;
         this._workingContext = null;
         this._currentBufferPointers.length = 0;
-        this._renderingCanvas = null;
         this._currentProgram = null;
-        this._boundRenderFunction = null;
-        Effect.ResetCache();
-        // Abort active requests
-        for (const request of this._activeRequests) {
-            request.abort();
-        }
-        this.onDisposeObservable.notifyObservers(this);
-        this.onDisposeObservable.clear();
         if (this._creationOptions.loseContextOnDispose) {
             this._gl.getExtension("WEBGL_lose_context")?.loseContext();
         }
@@ -4640,31 +3663,6 @@ export class ThinEngine {
         }
         return useSRGBBuffer ? this._glSRGBExtensionValues.SRGB8_ALPHA8 : this._gl.RGBA8;
     }
-    /**
-     * @internal
-     */
-    _loadFile(url, onSuccess, onProgress, offlineProvider, useArrayBuffer, onError) {
-        const request = ThinEngine._FileToolsLoadFile(url, onSuccess, onProgress, offlineProvider, useArrayBuffer, onError);
-        this._activeRequests.push(request);
-        request.onCompleteObservable.add((request) => {
-            this._activeRequests.splice(this._activeRequests.indexOf(request), 1);
-        });
-        return request;
-    }
-    /**
-     * Loads a file from a url
-     * @param url url to load
-     * @param onSuccess callback called when the file successfully loads
-     * @param onProgress callback called while file is loading (if the server supports this mode)
-     * @param offlineProvider defines the offline provider for caching
-     * @param useArrayBuffer defines a boolean indicating that date must be returned as ArrayBuffer
-     * @param onError callback called when the file fails to load
-     * @returns a file request object
-     * @internal
-     */
-    static _FileToolsLoadFile(url, onSuccess, onProgress, offlineProvider, useArrayBuffer, onError) {
-        throw _WarnImport("FileTools");
-    }
     /**
      * Reads pixels from the current frame buffer. Please note that this function can be slow
      * @param x defines the x coordinate of the rectangle where pixels must be read
@@ -4685,6 +3683,15 @@ export class ThinEngine {
         this._gl.readPixels(x, y, width, height, format, this._gl.UNSIGNED_BYTE, data);
         return Promise.resolve(data);
     }
+    /**
+     * 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) {
+        // Does nothing
+        // Child classes should implement this function
+    }
     /**
      * Gets a Promise<boolean> indicating if the engine can be instantiated (ie. if a webGL context can be found)
      */
@@ -4709,7 +3716,7 @@ export class ThinEngine {
         }
         if (this._IsSupported === null) {
             try {
-                const tempcanvas = this._CreateCanvas(1, 1);
+                const tempcanvas = AbstractEngine._CreateCanvas(1, 1);
                 const gl = tempcanvas.getContext("webgl") || tempcanvas.getContext("experimental-webgl");
                 this._IsSupported = gl != null && !!window.WebGLRenderingContext;
             }
@@ -4725,7 +3732,7 @@ export class ThinEngine {
     static get HasMajorPerformanceCaveat() {
         if (this._HasMajorPerformanceCaveat === null) {
             try {
-                const tempcanvas = this._CreateCanvas(1, 1);
+                const tempcanvas = AbstractEngine._CreateCanvas(1, 1);
                 const gl = tempcanvas.getContext("webgl", { failIfMajorPerformanceCaveat: true }) ||
                     tempcanvas.getContext("experimental-webgl", { failIfMajorPerformanceCaveat: true });
                 this._HasMajorPerformanceCaveat = !gl;
@@ -4736,102 +3743,6 @@ export class ThinEngine {
         }
         return this._HasMajorPerformanceCaveat;
     }
-    /**
-     * Find the next highest power of two.
-     * @param x Number to start search from.
-     * @returns Next highest power of two.
-     */
-    static CeilingPOT(x) {
-        x--;
-        x |= x >> 1;
-        x |= x >> 2;
-        x |= x >> 4;
-        x |= x >> 8;
-        x |= x >> 16;
-        x++;
-        return x;
-    }
-    /**
-     * Find the next lowest power of two.
-     * @param x Number to start search from.
-     * @returns Next lowest power of two.
-     */
-    static FloorPOT(x) {
-        x = x | (x >> 1);
-        x = x | (x >> 2);
-        x = x | (x >> 4);
-        x = x | (x >> 8);
-        x = x | (x >> 16);
-        return x - (x >> 1);
-    }
-    /**
-     * Find the nearest power of two.
-     * @param x Number to start search from.
-     * @returns Next nearest power of two.
-     */
-    static NearestPOT(x) {
-        const c = ThinEngine.CeilingPOT(x);
-        const f = ThinEngine.FloorPOT(x);
-        return c - x > x - f ? f : c;
-    }
-    /**
-     * Get the closest exponent of two
-     * @param value defines the value to approximate
-     * @param max defines the maximum value to return
-     * @param mode defines how to define the closest value
-     * @returns closest exponent of two of the given value
-     */
-    static GetExponentOfTwo(value, max, mode = 2) {
-        let pot;
-        switch (mode) {
-            case 1:
-                pot = ThinEngine.FloorPOT(value);
-                break;
-            case 2:
-                pot = ThinEngine.NearestPOT(value);
-                break;
-            case 3:
-            default:
-                pot = ThinEngine.CeilingPOT(value);
-                break;
-        }
-        return Math.min(pot, max);
-    }
-    /**
-     * Queue a new function into the requested animation frame pool (ie. this function will be executed by the browser (or the javascript engine) for the next frame)
-     * @param func - the function to be called
-     * @param requester - the object that will request the next frame. Falls back to window.
-     * @returns frame number
-     */
-    static QueueNewFrame(func, requester) {
-        // Note that there is kind of a typing issue here, as `setTimeout` might return something else than a number (NodeJs returns a NodeJS.Timeout object).
-        // Also if the global `requestAnimationFrame`'s returnType is number, `requester.requestPostAnimationFrame` and `requester.requestAnimationFrame` types
-        // are `any`.
-        if (!IsWindowObjectExist()) {
-            if (typeof requestAnimationFrame === "function") {
-                return requestAnimationFrame(func);
-            }
-        }
-        else {
-            const { requestAnimationFrame } = requester || window;
-            if (typeof requestAnimationFrame === "function") {
-                return requestAnimationFrame(func);
-            }
-        }
-        // fallback to the global `setTimeout`.
-        // In most cases (aka in the browser), `window` is the global object, so instead of calling `window.setTimeout` we could call the global `setTimeout`.
-        return setTimeout(func, 16);
-    }
-    /**
-     * Gets host document
-     * @returns the host document object
-     */
-    getHostDocument() {
-        if (this._renderingCanvas && this._renderingCanvas.ownerDocument) {
-            return this._renderingCanvas.ownerDocument;
-        }
-        return IsDocumentAvailable() ? document : null;
-    }
 }
 ThinEngine._TempClearColorUint32 = new Uint32Array(4);
 ThinEngine._TempClearColorInt32 = new Int32Array(4);
@@ -4852,8 +3763,6 @@ ThinEngine.ExceptionList = [
     // mobile browsers using safari 15.4 on ios
     { key: ".*(15.4).*AppleWebKit.*Safari", capture: null, captureConstraint: null, targets: ["antialias", "maxMSAASamples"] },
 ];
-/** @internal */
-ThinEngine._TextureLoaders = [];
 // Updatable statics so stick with vars here
 /**
  * Gets or sets the epsilon value used by collision engine
@@ -4862,4 +3771,37 @@ ThinEngine.CollisionsEpsilon = 0.001;
 // Statics
 ThinEngine._IsSupported = null;
 ThinEngine._HasMajorPerformanceCaveat = null;
+/**
+ * Find the next highest power of two.
+ * @param x Number to start search from.
+ * @returns Next highest power of two.
+ */
+ThinEngine.CeilingPOT = CeilingPOT;
+/**
+ * Find the next lowest power of two.
+ * @param x Number to start search from.
+ * @returns Next lowest power of two.
+ */
+ThinEngine.FloorPOT = FloorPOT;
+/**
+ * Find the nearest power of two.
+ * @param x Number to start search from.
+ * @returns Next nearest power of two.
+ */
+ThinEngine.NearestPOT = NearestPOT;
+/**
+ * Get the closest exponent of two
+ * @param value defines the value to approximate
+ * @param max defines the maximum value to return
+ * @param mode defines how to define the closest value
+ * @returns closest exponent of two of the given value
+ */
+ThinEngine.GetExponentOfTwo = GetExponentOfTwo;
+/**
+ * Queue a new function into the requested animation frame pool (ie. this function will be executed by the browser (or the javascript engine) for the next frame)
+ * @param func - the function to be called
+ * @param requester - the object that will request the next frame. Falls back to window.
+ * @returns frame number
+ */
+ThinEngine.QueueNewFrame = QueueNewFrame;
 //# sourceMappingURL=thinEngine.js.map