@babylonjs/core 7.2.2 → 7.2.3

package/Engines/thinEngine.d.ts

@@ -1,124 +1,32 @@
-import type { IInternalTextureLoader } from "../Materials/Textures/internalTextureLoader";
 import type { IEffectCreationOptions, IShaderPath } from "../Materials/effect";
-import { Effect } from "../Materials/effect";
-import type { IShaderProcessor } from "./Processors/iShaderProcessor";
 import type { ShaderProcessingContext } from "./Processors/shaderProcessingOptions";
-import type { UniformBuffer } from "../Materials/uniformBuffer";
 import type { Nullable, DataArray, IndicesArray, FloatArray, DeepImmutable } from "../types";
-import type { EngineCapabilities } from "./engineCapabilities";
-import { Observable } from "../Misc/observable";
-import { DepthCullingState } from "../States/depthCullingState";
-import { StencilState } from "../States/stencilState";
-import { AlphaState } from "../States/alphaCullingState";
-import { InternalTexture, InternalTextureSource } from "../Materials/Textures/internalTexture";
-import type { IViewportLike, IColor4Like } from "../Maths/math.like";
+import type { IColor4Like } from "../Maths/math.like";
 import type { DataBuffer } from "../Buffers/dataBuffer";
-import type { IFileRequest } from "../Misc/fileRequest";
 import type { IPipelineContext } from "./IPipelineContext";
-import { WebGLPipelineContext } from "./WebGL/webGLPipelineContext";
 import type { VertexBuffer } from "../Buffers/buffer";
 import type { InstancingAttributeInfo } from "./instancingAttributeInfo";
 import type { ThinTexture } from "../Materials/Textures/thinTexture";
-import type { IOfflineProvider } from "../Offline/IOfflineProvider";
 import type { IEffectFallbacks } from "../Materials/iEffectFallbacks";
-import type { IWebRequest } from "../Misc/interfaces/iWebRequest";
-import type { EngineFeatures } from "./engineFeatures";
 import type { HardwareTextureWrapper } from "../Materials/Textures/hardwareTextureWrapper";
-import { DrawWrapper } from "../Materials/drawWrapper";
+import type { DrawWrapper } from "../Materials/drawWrapper";
 import type { IMaterialContext } from "./IMaterialContext";
 import type { IDrawContext } from "./IDrawContext";
-import type { ICanvas, ICanvasRenderingContext, IImage } from "./ICanvas";
-import { StencilStateComposer } from "../States/stencilStateComposer";
-import type { StorageBuffer } from "../Buffers/storageBuffer";
-import type { IAudioEngineOptions } from "../Audio/Interfaces/IAudioEngineOptions";
+import type { ICanvas, ICanvasRenderingContext } from "./ICanvas";
 import type { IStencilState } from "../States/IStencilState";
 import type { InternalTextureCreationOptions, TextureSize } from "../Materials/Textures/textureCreationOptions";
-import { ShaderLanguage } from "../Materials/shaderLanguage";
 import type { RenderTargetWrapper } from "./renderTargetWrapper";
-import type { WebRequest } from "../Misc/webRequest";
-import type { LoadFileError } from "../Misc/fileTools";
-import type { Texture } from "../Materials/Textures/texture";
-/**
- * Defines the interface used by objects working like Scene
- * @internal
- */
-export interface ISceneLike {
-    addPendingData(data: any): void;
-    removePendingData(data: any): void;
-    offlineProvider: IOfflineProvider;
-}
-/**
- * Information about the current host
- */
-export interface HostInformation {
-    /**
-     * Defines if the current host is a mobile
-     */
-    isMobile: boolean;
-}
-/** Interface defining initialization parameters for ThinEngine class */
-export interface ThinEngineOptions {
-    /**
-     * Defines if the engine should no exceed a specified device ratio
-     * @see https://developer.mozilla.org/en-US/docs/Web/API/Window/devicePixelRatio
-     */
-    limitDeviceRatio?: number;
-    /**
-     * Defines if webaudio should be initialized as well
-     * @see https://doc.babylonjs.com/features/featuresDeepDive/audio/playingSoundsMusic
-     */
-    audioEngine?: boolean;
-    /**
-     * Specifies options for the audio engine
-     */
-    audioEngineOptions?: IAudioEngineOptions;
-    /**
-     * Defines if animations should run using a deterministic lock step
-     * @see https://doc.babylonjs.com/features/featuresDeepDive/animation/advanced_animations#deterministic-lockstep
-     */
-    deterministicLockstep?: boolean;
-    /** Defines the maximum steps to use with deterministic lock step mode */
-    lockstepMaxSteps?: number;
-    /** Defines the seconds between each deterministic lock step */
-    timeStep?: number;
-    /**
-     * Defines that engine should ignore context lost events
-     * If this event happens when this parameter is true, you will have to reload the page to restore rendering
-     */
-    doNotHandleContextLost?: boolean;
-    /**
-     * Defines that engine should ignore modifying touch action attribute and style
-     * If not handle, you might need to set it up on your side for expected touch devices behavior.
-     */
-    doNotHandleTouchAction?: boolean;
-    /**
-     * Make the matrix computations to be performed in 64 bits instead of 32 bits. False by default
-     */
-    useHighPrecisionMatrix?: boolean;
-    /**
-     * Defines whether to adapt to the device's viewport characteristics (default: false)
-     */
-    adaptToDeviceRatio?: boolean;
-    /**
-     * True if the more expensive but exact conversions should be used for transforming colors to and from linear space within shaders.
-     * Otherwise, the default is to use a cheaper approximation.
-     */
-    useExactSrgbConversions?: boolean;
-    /**
-     * Defines whether MSAA is enabled on the canvas.
-     */
-    antialias?: boolean;
-    /**
-     * Defines whether the stencil buffer should be enabled.
-     */
-    stencil?: boolean;
-    /**
-     * Defines whether the canvas should be created in "premultiplied" mode (if false, the canvas is created in the "opaque" mode) (true by default)
-     */
-    premultipliedAlpha?: boolean;
-}
+import type { RenderTargetTexture } from "../Materials/Textures/renderTargetTexture";
+import type { AbstractEngineOptions, ISceneLike } from "./abstractEngine";
+import type { PostProcess } from "../PostProcesses/postProcess";
+import type { PerformanceMonitor } from "../Misc/performanceMonitor";
+import { AbstractEngine } from "./abstractEngine";
+import { ShaderLanguage } from "../Materials/shaderLanguage";
+import { WebGLPipelineContext } from "./WebGL/webGLPipelineContext";
+import { InternalTexture, InternalTextureSource } from "../Materials/Textures/internalTexture";
+import { Effect } from "../Materials/effect";
 /** Interface defining initialization parameters for Engine class */
-export interface EngineOptions extends ThinEngineOptions, WebGLContextAttributes {
+export interface EngineOptions extends AbstractEngineOptions, WebGLContextAttributes {
     /**
      * Defines if webgl2 should be turned off even if supported
      * @see https://doc.babylonjs.com/setup/support/webGL2
@@ -151,7 +59,7 @@ export interface EngineOptions extends ThinEngineOptions, WebGLContextAttributes
 /**
  * The base engine class (root of all engines)
  */
-export declare class ThinEngine {
+export declare class ThinEngine extends AbstractEngine {
     private static _TempClearColorUint32;
     private static _TempClearColorInt32;
     /** Use this array to turn off some WebGL2 features on known buggy browsers version */
@@ -167,19 +75,7 @@ export declare class ThinEngine {
         targets: string[];
     })[];
     /** @internal */
-    static _TextureLoaders: IInternalTextureLoader[];
-    /**
-     * Returns the current npm package of the sdk
-     */
-    static get NpmPackage(): string;
-    /**
-     * Returns the current version of the framework
-     */
-    static get Version(): string;
-    /**
-     * Returns a string describing the current engine
-     */
-    get description(): string;
+    protected _creationOptions: EngineOptions;
     /** @internal */
     protected _name: string;
     /**
@@ -191,8 +87,6 @@ export declare class ThinEngine {
      * Returns the version of the engine
      */
     get version(): number;
-    protected _isDisposed: boolean;
-    get isDisposed(): boolean;
     /**
      * Gets or sets the epsilon value used by collision engine
      */
@@ -202,70 +96,16 @@ export declare class ThinEngine {
      */
     static get ShadersRepository(): string;
     static set ShadersRepository(value: string);
-    protected _shaderProcessor: Nullable<IShaderProcessor>;
-    /**
-     * @internal
-     */
-    _getShaderProcessor(shaderLanguage: ShaderLanguage): Nullable<IShaderProcessor>;
     /**
      * Gets or sets a boolean that indicates if textures must be forced to power of 2 size even if not required
      */
     forcePOTTextures: boolean;
-    /**
-     * Gets a boolean indicating if the engine is currently rendering in fullscreen mode
-     */
-    isFullscreen: boolean;
-    /**
-     * 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
-     */
-    cullBackFaces: Nullable<boolean>;
-    /**
-     * Gets or sets a boolean indicating if the engine must keep rendering even if the window is not in foreground
-     */
-    renderEvenInBackground: boolean;
-    /**
-     * Gets or sets a boolean indicating that cache can be kept between frames
-     */
-    preventCacheWipeBetweenFrames: boolean;
     /** Gets or sets a boolean indicating if the engine should validate programs after compilation */
     validateShaderPrograms: boolean;
-    private _useReverseDepthBuffer;
-    /**
-     * 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(): boolean;
-    set useReverseDepthBuffer(useReverse: boolean);
-    /**
-     * Indicates if the z range in NDC space is 0..1 (value: true) or -1..1 (value: false)
-     */
-    readonly isNDCHalfZRange: boolean;
-    /**
-     * Indicates that the origin of the texture/framebuffer space is the bottom left corner. If false, the origin is top left
-     */
-    readonly hasOriginBottomLeft: boolean;
     /**
      * Gets or sets a boolean indicating that uniform buffers must be disabled even if they are supported
      */
     disableUniformBuffers: boolean;
-    /**
-     * An event triggered when the engine is disposed.
-     */
-    readonly onDisposeObservable: Observable<ThinEngine>;
-    private _frameId;
-    /**
-     * Gets the current frame id
-     */
-    get frameId(): number;
-    /**
-     * The time (in milliseconds elapsed since the current page has been loaded) when the engine was initialized
-     */
-    readonly startTime: number;
-    /** @internal */
-    _uniformBuffers: UniformBuffer[];
-    /** @internal */
-    _storageBuffers: StorageBuffer[];
     /**
      * Gets a boolean indicating that the engine supports uniform buffers
      * @see https://doc.babylonjs.com/setup/support/webGL2#uniform-buffer-objets
@@ -275,11 +115,6 @@ export declare class ThinEngine {
     _gl: WebGL2RenderingContext;
     /** @internal */
     _webGLVersion: number;
-    protected _renderingCanvas: Nullable<HTMLCanvasElement>;
-    protected _windowIsBackground: boolean;
-    protected _creationOptions: EngineOptions;
-    protected _audioContext: Nullable<AudioContext>;
-    protected _audioDestination: Nullable<AudioDestinationNode | MediaStreamAudioDestinationNode>;
     /** @internal */
     _glSRGBExtensionValues: {
         SRGB: typeof WebGL2RenderingContext.SRGB;
@@ -291,108 +126,20 @@ export declare class ThinEngine {
      * @returns EngineOptions object
      */
     getCreationOptions(): EngineOptions;
-    protected _highPrecisionShadersAllowed: boolean;
-    /** @internal */
-    get _shouldUseHighPrecisionShader(): boolean;
     /**
      * 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
      */
     get needPOTTextures(): boolean;
-    /** @internal */
-    _badOS: boolean;
-    /** @internal */
-    _badDesktopOS: boolean;
-    /** @internal */
-    _hardwareScalingLevel: number;
-    /** @internal */
-    _caps: EngineCapabilities;
-    /** @internal */
-    _features: EngineFeatures;
-    protected _isStencilEnable: boolean;
     private _glVersion;
     private _glRenderer;
     private _glVendor;
     /** @internal */
-    _videoTextureSupported: boolean;
-    protected _activeRenderLoops: (() => void)[];
-    /**
-     * Gets the list of current active render loop functions
-     * @returns a read only array with the current render loop functions
-     */
-    get activeRenderLoops(): ReadonlyArray<() => void>;
-    /**
-     * Observable signaled when a context lost event is raised
-     */
-    onContextLostObservable: Observable<ThinEngine>;
-    /**
-     * Observable signaled when a context restored event is raised
-     */
-    onContextRestoredObservable: Observable<ThinEngine>;
-    private _onContextLost;
-    private _onContextRestored;
-    protected _contextWasLost: boolean;
-    /** @internal */
-    _doNotHandleContextLost: boolean;
-    /**
-     * 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(): boolean;
-    set doNotHandleContextLost(value: boolean);
-    /**
-     * Gets or sets a boolean indicating that vertex array object must be disabled even if they are supported
-     */
-    disableVertexArrayObjects: boolean;
-    /** @internal */
-    protected _colorWrite: boolean;
-    /** @internal */
-    protected _colorWriteChanged: boolean;
-    /** @internal */
-    protected _depthCullingState: DepthCullingState;
-    /** @internal */
-    protected _stencilStateComposer: StencilStateComposer;
-    /** @internal */
-    protected _stencilState: StencilState;
-    /** @internal */
-    _alphaState: AlphaState;
-    /** @internal */
-    _alphaMode: number;
-    /** @internal */
-    _alphaEquation: number;
-    /** @internal */
-    _internalTexturesCache: InternalTexture[];
-    /** @internal */
-    _renderTargetWrapperCache: RenderTargetWrapper[];
-    /** @internal */
-    protected _activeChannel: number;
-    private _currentTextureChannel;
-    /** @internal */
-    protected _boundTexturesCache: {
-        [key: string]: Nullable<InternalTexture>;
-    };
-    protected _currentEffect: Nullable<Effect>;
-    /** @internal */
-    _currentDrawContext: IDrawContext;
-    /** @internal */
     _currentMaterialContext: IMaterialContext;
     /** @internal */
     protected _currentProgram: Nullable<WebGLProgram>;
-    protected _compiledEffects: {
-        [key: string]: Effect;
-    };
     private _vertexAttribArraysEnabled;
-    /** @internal */
-    protected _cachedViewport: Nullable<IViewportLike>;
     private _cachedVertexArrayObject;
-    /** @internal */
-    protected _cachedVertexBuffers: any;
-    /** @internal */
-    protected _cachedIndexBuffer: Nullable<DataBuffer>;
-    /** @internal */
-    protected _cachedEffectForVertexBuffers: Nullable<Effect>;
-    /** @internal */
-    _currentRenderTarget: Nullable<RenderTargetWrapper>;
     private _uintIndicesCurrentlySet;
     protected _currentBoundBuffer: Nullable<DataBuffer>[];
     /** @internal */
@@ -407,32 +154,11 @@ export declare class ThinEngine {
     _workingCanvas: Nullable<ICanvas>;
     /** @internal */
     _workingContext: Nullable<ICanvasRenderingContext>;
-    /** @internal */
-    _boundRenderFunction: any;
     private _vaoRecordInProgress;
     private _mustWipeVertexAttributes;
-    private _emptyTexture;
-    private _emptyCubeTexture;
-    private _emptyTexture3D;
-    private _emptyTexture2DArray;
-    /** @internal */
-    _frameHandler: number;
     private _nextFreeTextureSlots;
     private _maxSimultaneousTextures;
     private _maxMSAASamplesOverride;
-    private _activeRequests;
-    /**
-     * If set to true zooming in and out in the browser will rescale the hardware-scaling correctly.
-     */
-    adaptToDeviceRatio: boolean;
-    /** @internal */
-    protected _lastDevicePixelRatio: number;
-    /** @internal */
-    _transformTextureUrl: Nullable<(url: string) => string>;
-    /**
-     * Gets information about the current host
-     */
-    hostInformation: HostInformation;
     protected get _supportsHardwareTextureRescaling(): boolean;
     protected _framebufferDimensionsObject: Nullable<{
         framebufferWidth: number;
@@ -447,80 +173,10 @@ export declare class ThinEngine {
         framebufferWidth: number;
         framebufferHeight: number;
     }>);
-    /**
-     * Gets the current viewport
-     */
-    get currentViewport(): Nullable<IViewportLike>;
-    /**
-     * Gets the default empty texture
-     */
-    get emptyTexture(): InternalTexture;
-    /**
-     * Gets the default empty 3D texture
-     */
-    get emptyTexture3D(): InternalTexture;
-    /**
-     * Gets the default empty 2D array texture
-     */
-    get emptyTexture2DArray(): InternalTexture;
-    /**
-     * Gets the default empty cube texture
-     */
-    get emptyCubeTexture(): InternalTexture;
-    /**
-     * Defines whether the engine has been created with the premultipliedAlpha option on or not.
-     */
-    premultipliedAlpha: boolean;
-    /**
-     * Observable event triggered before each texture is initialized
-     */
-    onBeforeTextureInitObservable: Observable<Texture>;
-    /** @internal */
-    protected _isWebGPU: boolean;
-    /**
-     * Gets a boolean indicating if the engine runs in WebGPU or not.
-     */
-    get isWebGPU(): boolean;
-    /** @internal */
-    protected _shaderPlatformName: string;
-    /**
-     * Gets the shader platform name used by the effects.
-     */
-    get shaderPlatformName(): string;
-    /**
-     * 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(): boolean;
-    set snapshotRendering(activate: boolean);
-    protected _snapshotRenderingMode: number;
-    /**
-     * Gets or sets the snapshot rendering mode
-     */
-    get snapshotRenderingMode(): number;
-    set snapshotRenderingMode(mode: number);
-    /**
-     * Gets a boolean indicating if the exact sRGB conversions or faster approximations are used for converting to and from linear space.
-     */
-    readonly useExactSrgbConversions: boolean;
     /**
      * Creates a new snapshot at the next frame using the current snapshotRenderingMode
      */
     snapshotRenderingReset(): void;
-    private _checkForMobile;
-    private static _CreateCanvas;
-    /**
-     * Create a canvas. This method is overridden by other engines
-     * @param width width
-     * @param height height
-     * @returns ICanvas interface
-     */
-    createCanvas(width: number, height: number): ICanvas;
-    /**
-     * Create an image to use with canvas
-     * @returns IImage interface
-     */
-    createCanvasImage(): IImage;
     /**
      * 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
@@ -529,30 +185,16 @@ export declare class ThinEngine {
      * @param adaptToDeviceRatio defines whether to adapt to the device's viewport characteristics (default: false)
      */
     constructor(canvasOrContext: Nullable<HTMLCanvasElement | OffscreenCanvas | WebGLRenderingContext | WebGL2RenderingContext>, antialias?: boolean, options?: EngineOptions, adaptToDeviceRatio?: boolean);
-    protected _setupMobileChecks(): void;
     protected _clearEmptyResources(): void;
-    protected _rebuildGraphicsResources(): void;
-    protected _flagContextRestored(): void;
-    protected _restoreEngineAfterContextLost(initEngine: () => void): void;
-    /**
-     * Shared initialization across engines types.
-     * @param canvas The canvas associated with this instance of the engine.
-     */
-    protected _sharedInit(canvas: HTMLCanvasElement): void;
     /**
      * @internal
      */
     _getShaderProcessingContext(shaderLanguage: ShaderLanguage): Nullable<ShaderProcessingContext>;
-    private _rebuildInternalTextures;
-    private _rebuildRenderTargetWrappers;
-    private _rebuildEffects;
     /**
      * Gets a boolean indicating if all created effects are ready
      * @returns true if all effects are ready
      */
     areAllEffectsReady(): boolean;
-    protected _rebuildBuffers(): void;
-    protected _rebuildTextures(): void;
     protected _initGLContext(): void;
     protected _initFeatures(): void;
     /**
@@ -565,16 +207,8 @@ export declare class ThinEngine {
      * @returns "Engine" string
      */
     getClassName(): string;
-    /**
-     * Returns true if the stencil buffer has been enabled through the creation option of the context.
-     */
-    get isStencilEnable(): boolean;
     /** @internal */
     _prepareWorkingCanvas(): void;
-    /**
-     * Reset the texture cache to empty state
-     */
-    resetTextureCache(): void;
     /**
      * 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
@@ -593,58 +227,8 @@ export declare class ThinEngine {
         renderer: string;
         version: string;
     };
-    /**
-     * 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: number): void;
-    /**
-     * 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(): number;
-    /**
-     * Gets the list of loaded textures
-     * @returns an array containing all loaded textures
-     */
-    getLoadedTexturesCache(): InternalTexture[];
-    /**
-     * Gets the object containing all engine capabilities
-     * @returns the EngineCapabilities object
-     */
-    getCaps(): EngineCapabilities;
-    /**
-     * 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?: () => void): void;
-    protected _cancelFrame(): void;
-    /** @internal */
-    _renderLoop(): void;
-    /**
-     * Gets the HTML canvas attached with the current webGL context
-     * @returns a HTML canvas
-     */
-    getRenderingCanvas(): Nullable<HTMLCanvasElement>;
-    /**
-     * Gets the audio context specified in engine initialization options
-     * @returns an Audio Context
-     */
-    getAudioContext(): Nullable<AudioContext>;
-    /**
-     * Gets the audio destination specified in engine initialization options
-     * @returns an audio destination node
-     */
-    getAudioDestination(): Nullable<AudioDestinationNode | MediaStreamAudioDestinationNode>;
-    /**
-     * Gets host window
-     * @returns the host window object
-     */
-    getHostWindow(): Nullable<Window>;
+    /**Gets driver info if available */
+    extractDriverInfo(): string;
     /**
      * Gets the current render width
      * @param useScreen defines if screen size must be used (or the current render target if any)
@@ -657,16 +241,6 @@ export declare class ThinEngine {
      * @returns a number defining the current render height
      */
     getRenderHeight(useScreen?: boolean): number;
-    /**
-     * Can be used to override the current requestAnimationFrame requester.
-     * @internal
-     */
-    protected _queueNewFrame(bindedRenderFunction: any, requester?: any): number;
-    /**
-     * 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: () => void): void;
     /**
      * Clear the current render buffer or the current render target (if any is set up)
      * @param color defines the color to use
@@ -675,44 +249,19 @@ export declare class ThinEngine {
      * @param stencil defines if the stencil buffer must be cleared
      */
     clear(color: Nullable<IColor4Like>, backBuffer: boolean, depth: boolean, stencil?: boolean): void;
-    protected _viewportCached: {
-        x: number;
-        y: number;
-        z: number;
-        w: number;
-    };
     /**
      * @internal
      */
     _viewport(x: number, y: number, width: number, height: number): void;
     /**
-     * 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: IViewportLike, requiredWidth?: number, requiredHeight?: number): void;
-    /**
-     * Begin a new frame
-     */
-    beginFrame(): void;
-    /**
-     * Enf the current frame
+     * End the current frame
      */
     endFrame(): void;
     /**
-     * Resize the view according to the canvas' size
-     * @param forceSetSize true to force setting the sizes of the underlying canvas
+     * Gets the performance monitor attached to this engine
+     * @see https://doc.babylonjs.com/features/featuresDeepDive/scene/optimize_your_scene#engineinstrumentation
      */
-    resize(forceSetSize?: boolean): void;
-    /**
-     * 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
-     */
-    setSize(width: number, height: number, forceSetSize?: boolean): boolean;
+    get performanceMonitor(): PerformanceMonitor;
     /**
      * Binds the frame buffer to the specified texture.
      * @param rtWrapper The render target wrapper to render to
@@ -735,36 +284,6 @@ export declare class ThinEngine {
      * @param zOffsetUnits defines the value to apply to zOffsetUnits (0 by default)
      */
     setState(culling: boolean, zOffset?: number, force?: boolean, reverseSide?: boolean, cullBackFaces?: boolean, stencil?: IStencilState, zOffsetUnits?: number): void;
-    /**
-     * Gets a boolean indicating if depth testing is enabled
-     * @returns the current state
-     */
-    getDepthBuffer(): boolean;
-    /**
-     * Enable or disable depth buffering
-     * @param enable defines the state to set
-     */
-    setDepthBuffer(enable: boolean): void;
-    /**
-     * Set the z offset Factor to apply to current rendering
-     * @param value defines the offset to apply
-     */
-    setZOffset(value: number): void;
-    /**
-     * Gets the current value of the zOffset Factor
-     * @returns the current zOffset Factor state
-     */
-    getZOffset(): number;
-    /**
-     * Set the z offset Units to apply to current rendering
-     * @param value defines the offset to apply
-     */
-    setZOffsetUnits(value: number): void;
-    /**
-     * Gets the current value of the zOffset Units
-     * @returns the current zOffset Units state
-     */
-    getZOffsetUnits(): number;
     /**
      * @internal
      */
@@ -963,8 +482,6 @@ export declare class ThinEngine {
      */
     drawArraysType(fillMode: number, verticesStart: number, verticesCount: number, instancesCount?: number): void;
     private _drawMode;
-    /** @internal */
-    protected _reportDrawCall(): void;
     /**
      * @internal
      */
@@ -973,10 +490,6 @@ export declare class ThinEngine {
      * @internal
      */
     _deletePipelineContext(pipelineContext: IPipelineContext): void;
-    /** @internal */
-    _getGlobalDefines(defines?: {
-        [key: string]: string;
-    }): string | undefined;
     /**
      * 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)
@@ -1289,43 +802,15 @@ export declare class ThinEngine {
      * Apply all cached states (depth, culling, stencil and alpha)
      */
     applyStates(): void;
-    /**
-     * Enable or disable color writing
-     * @param enable defines the state to set
-     */
-    setColorWrite(enable: boolean): void;
-    /**
-     * Gets a boolean indicating if color writing is enabled
-     * @returns the current color writing state
-     */
-    getColorWrite(): boolean;
-    /**
-     * Gets the depth culling state manager
-     */
-    get depthCullingState(): DepthCullingState;
-    /**
-     * Gets the alpha state manager
-     */
-    get alphaState(): AlphaState;
-    /**
-     * Gets the stencil state manager
-     */
-    get stencilState(): StencilState;
-    /**
-     * Gets the stencil state composer
-     */
-    get stencilStateComposer(): StencilStateComposer;
-    /**
-     * Clears the list of texture accessible through engine.
-     * This can help preventing texture load conflict due to name collision.
-     */
-    clearInternalTexturesCache(): void;
     /**
      * 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
      * @param bruteForce defines a boolean to force clearing ALL caches (including stencil, detoh and alpha states)
      */
     wipeCaches(bruteForce?: boolean): void;
+    setTextureFromPostProcess(channel: number, postProcess: Nullable<PostProcess>, name: string): void;
+    setTextureFromPostProcessOutput(channel: number, postProcess: Nullable<PostProcess>, name: string): void;
+    setDepthStencilTexture(channel: number, uniform: Nullable<WebGLUniformLocation>, texture: Nullable<RenderTargetTexture>, name?: string): void;
     /**
      * @internal
      */
@@ -1351,16 +836,6 @@ export declare class ThinEngine {
      * @internal
      */
     _getUseSRGBBuffer(useSRGBBuffer: boolean, noMipmap: boolean): boolean;
-    protected _createTextureBase(url: Nullable<string>, noMipmap: boolean, invertY: boolean, scene: Nullable<ISceneLike>, samplingMode: number | undefined, onLoad: Nullable<(texture: InternalTexture) => void> | undefined, onError: Nullable<(message: string, exception: any) => void> | undefined, prepareTexture: (texture: InternalTexture, extension: string, scene: Nullable<ISceneLike>, img: HTMLImageElement | ImageBitmap | {
-        width: number;
-        height: number;
-    }, invertY: boolean, noMipmap: boolean, isCompressed: boolean, processFunction: (width: number, height: number, img: HTMLImageElement | ImageBitmap | {
-        width: number;
-        height: number;
-    }, extension: string, texture: InternalTexture, continuationCallback: () => void) => boolean, samplingMode: number) => void, prepareTextureProcessFunction: (width: number, height: number, img: HTMLImageElement | ImageBitmap | {
-        width: number;
-        height: number;
-    }, extension: string, texture: InternalTexture, continuationCallback: () => void) => boolean, buffer?: Nullable<string | ArrayBuffer | ArrayBufferView | HTMLImageElement | Blob | ImageBitmap>, fallback?: Nullable<InternalTexture>, format?: Nullable<number>, forcedExtension?: Nullable<string>, mimeType?: string, loaderOptions?: any, useSRGBBuffer?: boolean): InternalTexture;
     /**
      * Usually called from Texture.ts.
      * Passed information to create a WebGLTexture
@@ -1396,18 +871,6 @@ export declare class ThinEngine {
      * @internal
      */
     _getTexImageParametersForCreateTexture(babylonFormat: Nullable<number>, fileExtension: string, useSRGBBuffer: boolean): TexImageParameters;
-    /**
-     * 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: string | ArrayBuffer | ArrayBufferView | Blob, onLoad: (img: HTMLImageElement | ImageBitmap) => void, onError: (message?: string, exception?: any) => void, offlineProvider: Nullable<IOfflineProvider>, mimeType?: string, imageBitmapOptions?: ImageBitmapOptions): Nullable<HTMLImageElement>;
     /**
      * @internal
      */
@@ -1493,10 +956,6 @@ export declare class ThinEngine {
      * @internal
      */
     _releaseTexture(texture: InternalTexture): void;
-    /**
-     * @internal
-     */
-    _releaseRenderTargetWrapper(rtWrapper: RenderTargetWrapper): void;
     protected _deleteTexture(texture: Nullable<WebGLTexture>): void;
     protected _setProgram(program: WebGLProgram): void;
     protected _boundUniforms: {
@@ -1588,22 +1047,6 @@ export declare class ThinEngine {
      * @internal
      */
     _getRGBABufferInternalSizedFormat(type: number, format?: number, useSRGBBuffer?: boolean): number;
-    /**
-     * @internal
-     */
-    _loadFile(url: string, onSuccess: (data: string | ArrayBuffer, responseURL?: string) => void, onProgress?: (data: any) => void, offlineProvider?: IOfflineProvider, useArrayBuffer?: boolean, onError?: (request?: IWebRequest, exception?: any) => void): IFileRequest;
-    /**
-     * 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: string, onSuccess: (data: string | ArrayBuffer, responseURL?: string) => void, onProgress?: (ev: ProgressEvent) => void, offlineProvider?: IOfflineProvider, useArrayBuffer?: boolean, onError?: (request?: WebRequest, exception?: LoadFileError) => void): IFileRequest;
     /**
      * 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
@@ -1615,6 +1058,12 @@ export declare class ThinEngine {
      * @returns a ArrayBufferView promise (Uint8Array) containing RGBA colors
      */
     readPixels(x: number, y: number, width: number, height: number, hasAlpha?: boolean, flushRenderer?: boolean): Promise<ArrayBufferView>;
+    /**
+     * 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: InternalTexture, unbind: boolean): void;
     private static _IsSupported;
     private static _HasMajorPerformanceCaveat;
     /**
@@ -1640,19 +1089,19 @@ export declare class ThinEngine {
      * @param x Number to start search from.
      * @returns Next highest power of two.
      */
-    static CeilingPOT(x: number): number;
+    static CeilingPOT: (x: number) => number;
     /**
      * Find the next lowest power of two.
      * @param x Number to start search from.
      * @returns Next lowest power of two.
      */
-    static FloorPOT(x: number): number;
+    static FloorPOT: (x: number) => number;
     /**
      * Find the nearest power of two.
      * @param x Number to start search from.
      * @returns Next nearest power of two.
      */
-    static NearestPOT(x: number): number;
+    static NearestPOT: (x: number) => number;
     /**
      * Get the closest exponent of two
      * @param value defines the value to approximate
@@ -1660,19 +1109,14 @@ export declare class ThinEngine {
      * @param mode defines how to define the closest value
      * @returns closest exponent of two of the given value
      */
-    static GetExponentOfTwo(value: number, max: number, mode?: number): number;
+    static GetExponentOfTwo: (value: number, max: number, mode: number) => number;
     /**
      * 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: () => void, requester?: any): number;
-    /**
-     * Gets host document
-     * @returns the host document object
-     */
-    getHostDocument(): Nullable<Document>;
+    static QueueNewFrame: (func: () => void, requester?: any) => number;
 }
 interface TexImageParameters {
     internalFormat: number;