@combeenation/3d-viewer 0.0.1-types

package/dist/types/node_modules/@babylonjs/core/Engines/thinEngine.d.ts

@@ -0,0 +1,1589 @@
+/**
+ * The base engine class (root of all engines)
+ */
+export class ThinEngine {
+    /**
+     * Returns the current npm package of the sdk
+     */
+    static get NpmPackage(): string;
+    /**
+     * Returns the current version of the framework
+     */
+    static get Version(): string;
+    static set ShadersRepository(arg: string);
+    /**
+     * Gets or sets the relative url used to load shaders if using the engine in non-minified mode
+     */
+    static get ShadersRepository(): string;
+    static _CreateCanvas(width: any, height: any): OffscreenCanvas;
+    static _ConcatenateShader(source: any, defines: any, shaderVersion?: string): string;
+    /**
+     * 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: any, onLoad: any, onError: any, offlineProvider: any, mimeType: any, imageBitmapOptions: any): void;
+    /**
+     * 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: any, onSuccess: any, onProgress: any, offlineProvider: any, useArrayBuffer: any, onError: any): void;
+    /**
+     * Gets a Promise<boolean> indicating if the engine can be instantiated (ie. if a webGL context can be found)
+     */
+    static get IsSupportedAsync(): Promise<boolean | undefined>;
+    /**
+     * Gets a boolean indicating if the engine can be instantiated (ie. if a webGL context can be found)
+     */
+    static get IsSupported(): boolean | undefined;
+    /**
+     * Gets a boolean indicating if the engine can be instantiated (ie. if a webGL context can be found)
+     * @returns true if the engine can be created
+     * @ignorenaming
+     */
+    static isSupported(): boolean | undefined;
+    /**
+     * Gets a boolean indicating if the engine can be instantiated on a performant device (ie. if a webGL context can be found and it does not use a slow implementation)
+     */
+    static get HasMajorPerformanceCaveat(): boolean | undefined;
+    /**
+     * Find the next highest power of two.
+     * @param x Number to start search from.
+     * @returns Next highest power of two.
+     */
+    static CeilingPOT(x: any): any;
+    /**
+     * Find the next lowest power of two.
+     * @param x Number to start search from.
+     * @returns Next lowest power of two.
+     */
+    static FloorPOT(x: any): number;
+    /**
+     * Find the nearest power of two.
+     * @param x Number to start search from.
+     * @returns Next nearest power of two.
+     */
+    static NearestPOT(x: any): any;
+    /**
+     * 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: any, max: any, mode?: number): number;
+    /**
+     * Queue a new function into the requested animation frame pool (ie. this function will be executed byt the browser 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: any, requester: any): any;
+    /**
+     * 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
+     * @param antialias defines enable antialiasing (default: false)
+     * @param options defines further options to be sent to the getContext() function
+     * @param adaptToDeviceRatio defines whether to adapt to the device's viewport characteristics (default: false)
+     */
+    constructor(canvasOrContext: any, antialias: any, options: any, adaptToDeviceRatio: any);
+    /** @internal */
+    _name: string;
+    /**
+     * 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: any;
+    /**
+     * 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;
+    _useReverseDepthBuffer: boolean;
+    /**
+     * Indicates if the z range in NDC space is 0..1 (value: true) or -1..1 (value: false)
+     */
+    isNDCHalfZRange: boolean;
+    /**
+     * Indicates that the origin of the texture/framebuffer space is the bottom left corner. If false, the origin is top left
+     */
+    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.
+     */
+    onDisposeObservable: Observable<any>;
+    _frameId: number;
+    /** @internal */
+    _uniformBuffers: any[];
+    /** @internal */
+    _storageBuffers: any[];
+    /** @internal */
+    _webGLVersion: number;
+    _windowIsBackground: boolean;
+    _highPrecisionShadersAllowed: any;
+    /** @internal */
+    _badOS: boolean;
+    /** @internal */
+    _badDesktopOS: boolean;
+    _renderingQueueLaunched: boolean;
+    _activeRenderLoops: any[];
+    /**
+     * Observable signaled when a context lost event is raised
+     */
+    onContextLostObservable: Observable<any>;
+    /**
+     * Observable signaled when a context restored event is raised
+     */
+    onContextRestoredObservable: Observable<any>;
+    _contextWasLost: boolean;
+    /** @internal */
+    _doNotHandleContextLost: boolean;
+    /**
+     * Gets or sets a boolean indicating that vertex array object must be disabled even if they are supported
+     */
+    disableVertexArrayObjects: boolean;
+    /** @internal */
+    _colorWrite: boolean;
+    /** @internal */
+    _colorWriteChanged: boolean;
+    /** @internal */
+    _depthCullingState: DepthCullingState;
+    /** @internal */
+    _stencilStateComposer: StencilStateComposer;
+    /** @internal */
+    _stencilState: StencilState;
+    /** @internal */
+    _alphaState: AlphaState;
+    /** @internal */
+    _alphaMode: number;
+    /** @internal */
+    _alphaEquation: number;
+    /** @internal */
+    _internalTexturesCache: any[];
+    /** @internal */
+    _renderTargetWrapperCache: any[];
+    /** @internal */
+    _activeChannel: number;
+    _currentTextureChannel: number;
+    /** @internal */
+    _boundTexturesCache: {};
+    _compiledEffects: {};
+    _vertexAttribArraysEnabled: any[];
+    _uintIndicesCurrentlySet: boolean;
+    _currentBoundBuffer: any[];
+    /** @internal */
+    _currentFramebuffer: any;
+    /** @internal */
+    _dummyFramebuffer: any;
+    _currentBufferPointers: any[];
+    _currentInstanceLocations: any[];
+    _currentInstanceBuffers: any[];
+    _vaoRecordInProgress: boolean;
+    _mustWipeVertexAttributes: boolean;
+    _nextFreeTextureSlots: any[];
+    _maxSimultaneousTextures: number;
+    _maxMSAASamplesOverride: number | null;
+    _activeRequests: any[];
+    /**
+     * If set to true zooming in and out in the browser will rescale the hardware-scaling correctly.
+     */
+    adaptToDeviceRatio: any;
+    /** @internal */
+    _lastDevicePixelRatio: number;
+    /** @internal */
+    _transformTextureUrl: any;
+    /**
+     * Gets information about the current host
+     */
+    hostInformation: {
+        isMobile: boolean;
+    };
+    /**
+     * 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<any>;
+    /** @internal */
+    _isWebGPU: boolean;
+    _snapshotRenderingMode: number;
+    _useExactSrgbConversions: any;
+    _viewportCached: {
+        x: number;
+        y: number;
+        z: number;
+        w: number;
+    };
+    _unpackFlipYCached: any;
+    /**
+     * In case you are sharing the context with other applications, it might
+     * be interested to not cache the unpack flip y state to ensure a consistent
+     * value would be set.
+     */
+    enableUnpackFlipYCached: boolean;
+    _boundUniforms: {};
+    _creationOptions: any;
+    _renderingCanvas: any;
+    _audioContext: any;
+    _audioDestination: any;
+    _checkForMobile: (() => void) | undefined;
+    _onContextLost: ((evt: any) => void) | undefined;
+    _onContextRestored: (() => void) | undefined;
+    _gl: any;
+    _shaderPlatformName: string | undefined;
+    _hardwareScalingLevel: number | undefined;
+    _isStencilEnable: boolean | undefined;
+    _shaderProcessor: WebGL2ShaderProcessor | WebGLShaderProcessor | undefined;
+    /**
+     * Returns a string describing the current engine
+     */
+    get description(): string;
+    set name(arg: string);
+    /**
+     * Gets or sets the name of the engine
+     */
+    get name(): string;
+    /**
+     * Returns the version of the engine
+     */
+    get version(): number;
+    /**
+     * @internal
+     */
+    _getShaderProcessor(shaderLanguage: any): WebGL2ShaderProcessor | WebGLShaderProcessor | undefined;
+    set useReverseDepthBuffer(arg: boolean);
+    /**
+     * 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;
+    /**
+     * Gets the current frame id
+     */
+    get frameId(): number;
+    /**
+     * Gets a boolean indicating that the engine supports uniform buffers
+     * @see https://doc.babylonjs.com/features/webgl2#uniform-buffer-objets
+     */
+    get supportsUniformBuffers(): boolean;
+    /**
+     * Gets the options used for engine creation
+     * @returns EngineOptions object
+     */
+    getCreationOptions(): any;
+    /** @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;
+    /**
+     * Gets the list of current active render loop functions
+     * @returns an array with the current render loop functions
+     */
+    get activeRenderLoops(): any[];
+    set doNotHandleContextLost(arg: 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/how_to/optimizing_your_scene#handling-webgl-context-lost
+     */
+    get doNotHandleContextLost(): boolean;
+    get _supportsHardwareTextureRescaling(): boolean;
+    /**
+     * sets the object from which width and height will be taken from when getting render width and height
+     * Will fallback to the gl object
+     * @param dimensions the framebuffer width and height that will be used.
+     */
+    set framebufferDimensionsObject(arg: any);
+    _framebufferDimensionsObject: any;
+    /**
+     * Gets the current viewport
+     */
+    get currentViewport(): any;
+    /**
+     * Gets the default empty texture
+     */
+    get emptyTexture(): void;
+    _emptyTexture: void | null | undefined;
+    /**
+     * Gets the default empty 3D texture
+     */
+    get emptyTexture3D(): void;
+    _emptyTexture3D: void | undefined;
+    /**
+     * Gets the default empty 2D array texture
+     */
+    get emptyTexture2DArray(): void;
+    _emptyTexture2DArray: void | undefined;
+    /**
+     * Gets the default empty cube texture
+     */
+    get emptyCubeTexture(): void;
+    _emptyCubeTexture: void | null | undefined;
+    /**
+     * Gets a boolean indicating if the engine runs in WebGPU or not.
+     */
+    get isWebGPU(): boolean;
+    /**
+     * Gets the shader platform name used by the effects.
+     */
+    get shaderPlatformName(): string | undefined;
+    set snapshotRendering(arg: boolean);
+    /**
+     * 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 snapshotRenderingMode(arg: number);
+    /**
+     * Gets or sets the snapshot rendering mode
+     */
+    get snapshotRenderingMode(): number;
+    /**
+     * Gets a boolean indicating if the exact sRGB conversions or faster approximations are used for converting to and from linear space.
+     */
+    get useExactSrgbConversions(): any;
+    /**
+     * Creates a new snapshot at the next frame using the current snapshotRenderingMode
+     */
+    snapshotRenderingReset(): void;
+    /**
+     * Create a canvas. This method is overridden by other engines
+     * @param width width
+     * @param height height
+     * @returns ICanvas interface
+     */
+    createCanvas(width: any, height: any): OffscreenCanvas;
+    /**
+     * Create an image to use with canvas
+     * @returns IImage interface
+     */
+    createCanvasImage(): HTMLImageElement;
+    _restoreEngineAfterContextLost(initEngine: any): void;
+    /**
+     * Shared initialization across engines types.
+     * @param canvas The canvas associated with this instance of the engine.
+     * @param doNotHandleTouchAction Defines that engine should ignore modifying touch action attribute and style
+     * @param audioEngine Defines if an audio engine should be created by default
+     */
+    _sharedInit(canvas: any, doNotHandleTouchAction: any, audioEngine: any): void;
+    /**
+     * @internal
+     */
+    _getShaderProcessingContext(shaderLanguage: any): null;
+    _rebuildInternalTextures(): void;
+    _rebuildRenderTargetWrappers(): void;
+    _rebuildEffects(): void;
+    /**
+     * Gets a boolean indicating if all created effects are ready
+     * @returns true if all effects are ready
+     */
+    areAllEffectsReady(): boolean;
+    _rebuildBuffers(): void;
+    _initGLContext(): void;
+    _caps: {
+        maxTexturesImageUnits: any;
+        maxCombinedTexturesImageUnits: any;
+        maxVertexTextureImageUnits: any;
+        maxTextureSize: any;
+        maxSamples: any;
+        maxCubemapTextureSize: any;
+        maxRenderTextureSize: any;
+        maxVertexAttribs: any;
+        maxVaryingVectors: any;
+        maxFragmentUniformVectors: any;
+        maxVertexUniformVectors: any;
+        parallelShaderCompile: any;
+        standardDerivatives: boolean;
+        maxAnisotropy: number;
+        astc: any;
+        bptc: any;
+        s3tc: any;
+        s3tc_srgb: any;
+        pvrtc: any;
+        etc1: any;
+        etc2: any;
+        textureAnisotropicFilterExtension: any;
+        uintIndices: boolean;
+        fragmentDepthSupported: boolean;
+        highPrecisionShaderSupported: boolean;
+        timerQuery: any;
+        supportOcclusionQuery: boolean;
+        canUseTimestampForTimerQuery: boolean;
+        drawBuffersExtension: boolean;
+        maxMSAASamples: number;
+        colorBufferFloat: boolean;
+        textureFloat: boolean;
+        textureHalfFloat: boolean;
+        textureHalfFloatRender: boolean;
+        textureFloatLinearFiltering: boolean;
+        textureFloatRender: boolean;
+        textureHalfFloatLinearFiltering: boolean;
+        vertexArrayObject: boolean;
+        instancedArrays: boolean;
+        textureLOD: boolean;
+        blendMinMax: boolean;
+        multiview: any;
+        oculusMultiview: any;
+        depthTextureExtension: boolean;
+        canUseGLInstanceID: boolean;
+        canUseGLVertexID: boolean;
+        supportComputeShaders: boolean;
+        supportSRGBBuffers: boolean;
+        supportTransformFeedbacks: boolean;
+        textureMaxLevel: boolean;
+        texture2DArrayMaxLayerCount: number;
+    } | undefined;
+    _glVersion: any;
+    _glRenderer: any;
+    _glVendor: any;
+    _initFeatures(): void;
+    _features: {
+        forceBitmapOverHTMLImageElement: boolean;
+        supportRenderAndCopyToLodForFloatTextures: boolean;
+        supportDepthStencilTexture: boolean;
+        supportShadowSamplers: boolean;
+        uniformBufferHardCheckMatrix: boolean;
+        allowTexturePrefiltering: boolean;
+        trackUbosInFrame: boolean;
+        checkUbosContentBeforeUpload: boolean;
+        supportCSM: boolean;
+        basisNeedsPOT: boolean;
+        support3DTextures: boolean;
+        needTypeSuffixInShaderConstants: boolean;
+        supportMSAA: boolean;
+        supportSSAO2: boolean;
+        supportExtendedTextureFormats: boolean;
+        supportSwitchCaseInShader: boolean;
+        supportSyncTextureRead: boolean;
+        needsInvertingBitmap: boolean;
+        useUBOBindingCache: boolean;
+        needShaderCodeInlining: boolean;
+        needToAlwaysBindUniformBuffers: boolean;
+        supportRenderPasses: boolean;
+        supportSpriteInstancing: boolean;
+        _collectUbosUpdatedInFrame: boolean;
+    } | undefined;
+    /**
+     * Gets version of the current webGL context
+     * Keep it for back compat - use version instead
+     */
+    get webGLVersion(): number;
+    /**
+     * Gets a string identifying the name of the class
+     * @returns "Engine" string
+     */
+    getClassName(): string;
+    /**
+     * Returns true if the stencil buffer has been enabled through the creation option of the context.
+     */
+    get isStencilEnable(): boolean | undefined;
+    /** @internal */
+    _prepareWorkingCanvas(): void;
+    _workingCanvas: OffscreenCanvas | null | undefined;
+    _workingContext: any;
+    /**
+     * 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
+     */
+    getInfo(): {
+        vendor: any;
+        renderer: any;
+        version: any;
+    };
+    /**
+     * Gets an object containing information about the current webGL context
+     * @returns an object containing the vendor, the renderer and the version of the current webGL context
+     */
+    getGlInfo(): {
+        vendor: any;
+        renderer: any;
+        version: any;
+    };
+    /**
+     * 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: any): 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 | undefined;
+    /**
+     * Gets the list of loaded textures
+     * @returns an array containing all loaded textures
+     */
+    getLoadedTexturesCache(): any[];
+    /**
+     * Gets the object containing all engine capabilities
+     * @returns the EngineCapabilities object
+     */
+    getCaps(): {
+        maxTexturesImageUnits: any;
+        maxCombinedTexturesImageUnits: any;
+        maxVertexTextureImageUnits: any;
+        maxTextureSize: any;
+        maxSamples: any;
+        maxCubemapTextureSize: any;
+        maxRenderTextureSize: any;
+        maxVertexAttribs: any;
+        maxVaryingVectors: any;
+        maxFragmentUniformVectors: any;
+        maxVertexUniformVectors: any;
+        parallelShaderCompile: any;
+        standardDerivatives: boolean;
+        maxAnisotropy: number;
+        astc: any;
+        bptc: any;
+        s3tc: any;
+        s3tc_srgb: any;
+        pvrtc: any;
+        etc1: any;
+        etc2: any;
+        textureAnisotropicFilterExtension: any;
+        uintIndices: boolean;
+        fragmentDepthSupported: boolean;
+        highPrecisionShaderSupported: boolean;
+        timerQuery: any;
+        supportOcclusionQuery: boolean;
+        canUseTimestampForTimerQuery: boolean;
+        drawBuffersExtension: boolean;
+        maxMSAASamples: number;
+        colorBufferFloat: boolean;
+        textureFloat: boolean;
+        textureHalfFloat: boolean;
+        textureHalfFloatRender: boolean;
+        textureFloatLinearFiltering: boolean;
+        textureFloatRender: boolean;
+        textureHalfFloatLinearFiltering: boolean;
+        vertexArrayObject: boolean;
+        instancedArrays: boolean;
+        textureLOD: boolean;
+        blendMinMax: boolean;
+        multiview: any;
+        oculusMultiview: any;
+        depthTextureExtension: boolean;
+        canUseGLInstanceID: boolean;
+        canUseGLVertexID: boolean;
+        supportComputeShaders: boolean;
+        supportSRGBBuffers: boolean;
+        supportTransformFeedbacks: boolean;
+        textureMaxLevel: boolean;
+        texture2DArrayMaxLayerCount: number;
+    } | undefined;
+    /**
+     * 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: any): void;
+    /** @internal */
+    _renderLoop(): void;
+    _frameHandler: any;
+    /**
+     * Gets the HTML canvas attached with the current webGL context
+     * @returns a HTML canvas
+     */
+    getRenderingCanvas(): any;
+    /**
+     * Gets the audio context specified in engine initialization options
+     * @returns an Audio Context
+     */
+    getAudioContext(): any;
+    /**
+     * Gets the audio destination specified in engine initialization options
+     * @returns an audio destination node
+     */
+    getAudioDestination(): any;
+    /**
+     * Gets host window
+     * @returns the host window object
+     */
+    getHostWindow(): any;
+    /**
+     * Gets the current render width
+     * @param useScreen defines if screen size must be used (or the current render target if any)
+     * @returns a number defining the current render width
+     */
+    getRenderWidth(useScreen?: boolean): any;
+    /**
+     * Gets the current render height
+     * @param useScreen defines if screen size must be used (or the current render target if any)
+     * @returns a number defining the current render height
+     */
+    getRenderHeight(useScreen?: boolean): any;
+    /**
+     * Can be used to override the current requestAnimationFrame requester.
+     * @internal
+     */
+    _queueNewFrame(bindedRenderFunction: any, requester: any): any;
+    /**
+     * 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: any): void;
+    _boundRenderFunction: (() => void) | null | undefined;
+    /**
+     * Clear the current render buffer or the current render target (if any is set up)
+     * @param color defines the color to use
+     * @param backBuffer defines if the back buffer must be cleared
+     * @param depth defines if the depth buffer must be cleared
+     * @param stencil defines if the stencil buffer must be cleared
+     */
+    clear(color: any, backBuffer: any, depth: any, stencil?: boolean): void;
+    /**
+     * @internal
+     */
+    _viewport(x: any, y: any, width: any, height: any): 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: any, requiredWidth: any, requiredHeight: any): void;
+    _cachedViewport: any;
+    /**
+     * Begin a new frame
+     */
+    beginFrame(): void;
+    /**
+     * Enf 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
+     */
+    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: any, height: any, forceSetSize?: boolean): boolean;
+    /**
+     * Binds the frame buffer to the specified texture.
+     * @param texture The render target wrapper to render to
+     * @param faceIndex The face of the texture to render to in case of cube texture
+     * @param requiredWidth The width of the target to render to
+     * @param requiredHeight The height of the target to render to
+     * @param forceFullscreenViewport Forces the viewport to be the entire texture/screen if true
+     * @param lodLevel defines the lod level to bind to the frame buffer
+     * @param layer defines the 2d array index to bind to frame buffer to
+     */
+    bindFramebuffer(texture: any, faceIndex: number | undefined, requiredWidth: any, requiredHeight: any, forceFullscreenViewport: any, lodLevel?: number, layer?: number): void;
+    _currentRenderTarget: any;
+    /**
+     * Set various states to the webGL context
+     * @param culling defines culling state: true to enable culling, false to disable it
+     * @param zOffset defines the value to apply to zOffset (0 by default)
+     * @param force defines if states must be applied even if cache is up to date
+     * @param reverseSide defines if culling must be reversed (CCW if false, CW if true)
+     * @param cullBackFaces true to cull back faces, false to cull front faces (if culling is enabled)
+     * @param stencil stencil states to set
+     * @param zOffsetUnits defines the value to apply to zOffsetUnits (0 by default)
+     */
+    setState(culling: any, zOffset: number | undefined, force: any, reverseSide: boolean | undefined, cullBackFaces: any, stencil: any, 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: any): void;
+    /**
+     * Set the z offset Factor to apply to current rendering
+     * @param value defines the offset to apply
+     */
+    setZOffset(value: any): 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: any): void;
+    /**
+     * Gets the current value of the zOffset Units
+     * @returns the current zOffset Units state
+     */
+    getZOffsetUnits(): number;
+    /**
+     * @internal
+     */
+    _bindUnboundFramebuffer(framebuffer: any): void;
+    /** @internal */
+    _currentFrameBufferIsDefaultFrameBuffer(): boolean;
+    /**
+     * Generates the mipmaps for a texture
+     * @param texture texture to generate the mipmaps for
+     */
+    generateMipmaps(texture: any): void;
+    /**
+     * Unbind the current render target texture from the webGL context
+     * @param texture defines the render target wrapper to unbind
+     * @param disableGenerateMipMaps defines a boolean indicating that mipmaps must not be generated
+     * @param onBeforeUnbind defines a function which will be called before the effective unbind
+     */
+    unBindFramebuffer(texture: any, disableGenerateMipMaps: boolean | undefined, onBeforeUnbind: any): void;
+    /**
+     * Force a webGL flush (ie. a flush of all waiting webGL commands)
+     */
+    flushFramebuffer(): void;
+    /**
+     * Unbind the current render target and bind the default framebuffer
+     */
+    restoreDefaultFramebuffer(): void;
+    /** @internal */
+    _resetVertexBufferBinding(): void;
+    _cachedVertexBuffers: any;
+    /**
+     * Creates a vertex buffer
+     * @param data the data for the vertex buffer
+     * @returns the new WebGL static buffer
+     */
+    createVertexBuffer(data: any): WebGLDataBuffer;
+    _createVertexBuffer(data: any, usage: any): WebGLDataBuffer;
+    /**
+     * Creates a dynamic vertex buffer
+     * @param data the data for the dynamic vertex buffer
+     * @returns the new WebGL dynamic buffer
+     */
+    createDynamicVertexBuffer(data: any): WebGLDataBuffer;
+    _resetIndexBufferBinding(): void;
+    _cachedIndexBuffer: any;
+    /**
+     * Creates a new index buffer
+     * @param indices defines the content of the index buffer
+     * @param updatable defines if the index buffer must be updatable
+     * @returns a new webGL buffer
+     */
+    createIndexBuffer(indices: any, updatable: any): WebGLDataBuffer;
+    _normalizeIndexData(indices: any): any;
+    /**
+     * Bind a webGL buffer to the webGL context
+     * @param buffer defines the buffer to bind
+     */
+    bindArrayBuffer(buffer: any): void;
+    /**
+     * Bind a specific block at a given index in a specific shader program
+     * @param pipelineContext defines the pipeline context to use
+     * @param blockName defines the block name
+     * @param index defines the index where to bind the block
+     */
+    bindUniformBlock(pipelineContext: any, blockName: any, index: any): void;
+    bindIndexBuffer(buffer: any): void;
+    _bindBuffer(buffer: any, target: any): void;
+    /**
+     * update the bound buffer with the given data
+     * @param data defines the data to update
+     */
+    updateArrayBuffer(data: any): void;
+    _vertexAttribPointer(buffer: any, indx: any, size: any, type: any, normalized: any, stride: any, offset: any): void;
+    /**
+     * @internal
+     */
+    _bindIndexBufferWithCache(indexBuffer: any): void;
+    _bindVertexBuffersAttributes(vertexBuffers: any, effect: any, overrideVertexBuffers: any): void;
+    /**
+     * Records a vertex array object
+     * @see https://doc.babylonjs.com/features/webgl2#vertex-array-objects
+     * @param vertexBuffers defines the list of vertex buffers to store
+     * @param indexBuffer defines the index buffer to store
+     * @param effect defines the effect to store
+     * @param overrideVertexBuffers defines optional list of avertex buffers that overrides the entries in vertexBuffers
+     * @returns the new vertex array object
+     */
+    recordVertexArrayObject(vertexBuffers: any, indexBuffer: any, effect: any, overrideVertexBuffers: any): any;
+    /**
+     * Bind a specific vertex array object
+     * @see https://doc.babylonjs.com/features/webgl2#vertex-array-objects
+     * @param vertexArrayObject defines the vertex array object to bind
+     * @param indexBuffer defines the index buffer to bind
+     */
+    bindVertexArrayObject(vertexArrayObject: any, indexBuffer: any): void;
+    _cachedVertexArrayObject: any;
+    /**
+     * Bind webGl buffers directly to the webGL context
+     * @param vertexBuffer defines the vertex buffer to bind
+     * @param indexBuffer defines the index buffer to bind
+     * @param vertexDeclaration defines the vertex declaration to use with the vertex buffer
+     * @param vertexStrideSize defines the vertex stride of the vertex buffer
+     * @param effect defines the effect associated with the vertex buffer
+     */
+    bindBuffersDirectly(vertexBuffer: any, indexBuffer: any, vertexDeclaration: any, vertexStrideSize: any, effect: any): void;
+    _cachedEffectForVertexBuffers: any;
+    _unbindVertexArrayObject(): void;
+    /**
+     * Bind a list of vertex buffers to the webGL context
+     * @param vertexBuffers defines the list of vertex buffers to bind
+     * @param indexBuffer defines the index buffer to bind
+     * @param effect defines the effect associated with the vertex buffers
+     * @param overrideVertexBuffers defines optional list of avertex buffers that overrides the entries in vertexBuffers
+     */
+    bindBuffers(vertexBuffers: any, indexBuffer: any, effect: any, overrideVertexBuffers: any): void;
+    /**
+     * Unbind all instance attributes
+     */
+    unbindInstanceAttributes(): void;
+    /**
+     * Release and free the memory of a vertex array object
+     * @param vao defines the vertex array object to delete
+     */
+    releaseVertexArrayObject(vao: any): void;
+    /**
+     * @internal
+     */
+    _releaseBuffer(buffer: any): boolean;
+    _deleteBuffer(buffer: any): void;
+    /**
+     * Update the content of a webGL buffer used with instantiation and bind it to the webGL context
+     * @param instancesBuffer defines the webGL buffer to update and bind
+     * @param data defines the data to store in the buffer
+     * @param offsetLocations defines the offsets or attributes information used to determine where data must be stored in the buffer
+     */
+    updateAndBindInstancesBuffer(instancesBuffer: any, data: any, offsetLocations: any): void;
+    /**
+     * Bind the content of a webGL buffer used with instantiation
+     * @param instancesBuffer defines the webGL buffer to bind
+     * @param attributesInfo defines the offsets or attributes information used to determine where data must be stored in the buffer
+     * @param computeStride defines Whether to compute the strides from the info or use the default 0
+     */
+    bindInstancesBuffer(instancesBuffer: any, attributesInfo: any, computeStride?: boolean): void;
+    /**
+     * Disable the instance attribute corresponding to the name in parameter
+     * @param name defines the name of the attribute to disable
+     */
+    disableInstanceAttributeByName(name: any): void;
+    /**
+     * Disable the instance attribute corresponding to the location in parameter
+     * @param attributeLocation defines the attribute location of the attribute to disable
+     */
+    disableInstanceAttribute(attributeLocation: any): void;
+    /**
+     * Disable the attribute corresponding to the location in parameter
+     * @param attributeLocation defines the attribute location of the attribute to disable
+     */
+    disableAttributeByIndex(attributeLocation: any): void;
+    /**
+     * Send a draw order
+     * @param useTriangles defines if triangles must be used to draw (else wireframe will be used)
+     * @param indexStart defines the starting index
+     * @param indexCount defines the number of index to draw
+     * @param instancesCount defines the number of instances to draw (if instantiation is enabled)
+     */
+    draw(useTriangles: any, indexStart: any, indexCount: any, instancesCount: any): void;
+    /**
+     * Draw a list of points
+     * @param verticesStart defines the index of first vertex to draw
+     * @param verticesCount defines the count of vertices to draw
+     * @param instancesCount defines the number of instances to draw (if instantiation is enabled)
+     */
+    drawPointClouds(verticesStart: any, verticesCount: any, instancesCount: any): void;
+    /**
+     * Draw a list of unindexed primitives
+     * @param useTriangles defines if triangles must be used to draw (else wireframe will be used)
+     * @param verticesStart defines the index of first vertex to draw
+     * @param verticesCount defines the count of vertices to draw
+     * @param instancesCount defines the number of instances to draw (if instantiation is enabled)
+     */
+    drawUnIndexed(useTriangles: any, verticesStart: any, verticesCount: any, instancesCount: any): void;
+    /**
+     * Draw a list of indexed primitives
+     * @param fillMode defines the primitive to use
+     * @param indexStart defines the starting index
+     * @param indexCount defines the number of index to draw
+     * @param instancesCount defines the number of instances to draw (if instantiation is enabled)
+     */
+    drawElementsType(fillMode: any, indexStart: any, indexCount: any, instancesCount: any): void;
+    /**
+     * Draw a list of unindexed primitives
+     * @param fillMode defines the primitive to use
+     * @param verticesStart defines the index of first vertex to draw
+     * @param verticesCount defines the count of vertices to draw
+     * @param instancesCount defines the number of instances to draw (if instantiation is enabled)
+     */
+    drawArraysType(fillMode: any, verticesStart: any, verticesCount: any, instancesCount: any): void;
+    _drawMode(fillMode: any): any;
+    /** @internal */
+    _reportDrawCall(): void;
+    /**
+     * @internal
+     */
+    _releaseEffect(effect: any): void;
+    /**
+     * @internal
+     */
+    _deletePipelineContext(pipelineContext: any): void;
+    /** @internal */
+    _getGlobalDefines(defines: any): 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)
+     * @param attributesNamesOrOptions defines either a list of attribute names or an IEffectCreationOptions object
+     * @param uniformsNamesOrEngine defines either a list of uniform names or the engine to use
+     * @param samplers defines an array of string used to represent textures
+     * @param defines defines the string containing the defines to use to compile the shaders
+     * @param fallbacks defines the list of potential fallbacks to use if shader compilation fails
+     * @param onCompiled defines a function to call when the effect creation is successful
+     * @param onError defines a function to call when the effect creation has failed
+     * @param indexParameters defines an object containing the index values to use to compile shaders (like the maximum number of simultaneous lights)
+     * @param shaderLanguage the language the shader is written in (default: GLSL)
+     * @returns the new Effect
+     */
+    createEffect(baseName: any, attributesNamesOrOptions: any, uniformsNamesOrEngine: any, samplers: any, defines: any, fallbacks: any, onCompiled: any, onError: any, indexParameters: any, shaderLanguage?: ShaderLanguage): any;
+    _compileShader(source: any, type: any, defines: any, shaderVersion: any): any;
+    _compileRawShader(source: any, type: any): any;
+    /**
+     * @internal
+     */
+    _getShaderSource(shader: any): any;
+    /**
+     * Directly creates a webGL program
+     * @param pipelineContext  defines the pipeline context to attach to
+     * @param vertexCode defines the vertex shader code to use
+     * @param fragmentCode defines the fragment shader code to use
+     * @param context defines the webGL context to use (if not set, the current one will be used)
+     * @param transformFeedbackVaryings defines the list of transform feedback varyings to use
+     * @returns the new webGL program
+     */
+    createRawShaderProgram(pipelineContext: any, vertexCode: any, fragmentCode: any, context: any, transformFeedbackVaryings?: null): any;
+    /**
+     * Creates a webGL program
+     * @param pipelineContext  defines the pipeline context to attach to
+     * @param vertexCode  defines the vertex shader code to use
+     * @param fragmentCode defines the fragment shader code to use
+     * @param defines defines the string containing the defines to use to compile the shaders
+     * @param context defines the webGL context to use (if not set, the current one will be used)
+     * @param transformFeedbackVaryings defines the list of transform feedback varyings to use
+     * @returns the new webGL program
+     */
+    createShaderProgram(pipelineContext: any, vertexCode: any, fragmentCode: any, defines: any, context: any, transformFeedbackVaryings?: null): any;
+    /**
+     * Inline functions in shader code that are marked to be inlined
+     * @param code code to inline
+     * @returns inlined code
+     */
+    inlineShaderCode(code: any): any;
+    /**
+     * Creates a new pipeline context
+     * @param shaderProcessingContext defines the shader processing context used during the processing if available
+     * @returns the new pipeline
+     */
+    createPipelineContext(shaderProcessingContext: any): WebGLPipelineContext;
+    /**
+     * Creates a new material context
+     * @returns the new context
+     */
+    createMaterialContext(): undefined;
+    /**
+     * Creates a new draw context
+     * @returns the new context
+     */
+    createDrawContext(): undefined;
+    _createShaderProgram(pipelineContext: any, vertexShader: any, fragmentShader: any, context: any, transformFeedbackVaryings?: null): any;
+    _finalizePipelineContext(pipelineContext: any): void;
+    /**
+     * @internal
+     */
+    _preparePipelineContext(pipelineContext: any, vertexSourceCode: any, fragmentSourceCode: any, createAsRaw: any, rawVertexSourceCode: any, rawFragmentSourceCode: any, rebuildRebind: any, defines: any, transformFeedbackVaryings: any, key: any): void;
+    /**
+     * @internal
+     */
+    _isRenderingStateCompiled(pipelineContext: any): boolean;
+    /**
+     * @internal
+     */
+    _executeWhenRenderingStateIsCompiled(pipelineContext: any, action: any): void;
+    /**
+     * Gets the list of webGL uniform locations associated with a specific program based on a list of uniform names
+     * @param pipelineContext defines the pipeline context to use
+     * @param uniformsNames defines the list of uniform names
+     * @returns an array of webGL uniform locations
+     */
+    getUniforms(pipelineContext: any, uniformsNames: any): any[];
+    /**
+     * Gets the list of active attributes for a given webGL program
+     * @param pipelineContext defines the pipeline context to use
+     * @param attributesNames defines the list of attribute names to get
+     * @returns an array of indices indicating the offset of each attribute
+     */
+    getAttributes(pipelineContext: any, attributesNames: any): any[];
+    /**
+     * Activates an effect, making it the current one (ie. the one used for rendering)
+     * @param effect defines the effect to activate
+     */
+    enableEffect(effect: any): void;
+    _currentEffect: any;
+    /**
+     * Set the value of an uniform to a number (int)
+     * @param uniform defines the webGL uniform location where to store the value
+     * @param value defines the int number to store
+     * @returns true if the value was set
+     */
+    setInt(uniform: any, value: any): boolean;
+    /**
+     * Set the value of an uniform to a int2
+     * @param uniform defines the webGL uniform location where to store the value
+     * @param x defines the 1st component of the value
+     * @param y defines the 2nd component of the value
+     * @returns true if the value was set
+     */
+    setInt2(uniform: any, x: any, y: any): boolean;
+    /**
+     * Set the value of an uniform to a int3
+     * @param uniform defines the webGL uniform location where to store the value
+     * @param x defines the 1st component of the value
+     * @param y defines the 2nd component of the value
+     * @param z defines the 3rd component of the value
+     * @returns true if the value was set
+     */
+    setInt3(uniform: any, x: any, y: any, z: any): boolean;
+    /**
+     * Set the value of an uniform to a int4
+     * @param uniform defines the webGL uniform location where to store the value
+     * @param x defines the 1st component of the value
+     * @param y defines the 2nd component of the value
+     * @param z defines the 3rd component of the value
+     * @param w defines the 4th component of the value
+     * @returns true if the value was set
+     */
+    setInt4(uniform: any, x: any, y: any, z: any, w: any): boolean;
+    /**
+     * Set the value of an uniform to an array of int32
+     * @param uniform defines the webGL uniform location where to store the value
+     * @param array defines the array of int32 to store
+     * @returns true if the value was set
+     */
+    setIntArray(uniform: any, array: any): boolean;
+    /**
+     * Set the value of an uniform to an array of int32 (stored as vec2)
+     * @param uniform defines the webGL uniform location where to store the value
+     * @param array defines the array of int32 to store
+     * @returns true if the value was set
+     */
+    setIntArray2(uniform: any, array: any): boolean;
+    /**
+     * Set the value of an uniform to an array of int32 (stored as vec3)
+     * @param uniform defines the webGL uniform location where to store the value
+     * @param array defines the array of int32 to store
+     * @returns true if the value was set
+     */
+    setIntArray3(uniform: any, array: any): boolean;
+    /**
+     * Set the value of an uniform to an array of int32 (stored as vec4)
+     * @param uniform defines the webGL uniform location where to store the value
+     * @param array defines the array of int32 to store
+     * @returns true if the value was set
+     */
+    setIntArray4(uniform: any, array: any): boolean;
+    /**
+     * Set the value of an uniform to an array of number
+     * @param uniform defines the webGL uniform location where to store the value
+     * @param array defines the array of number to store
+     * @returns true if the value was set
+     */
+    setArray(uniform: any, array: any): boolean;
+    /**
+     * Set the value of an uniform to an array of number (stored as vec2)
+     * @param uniform defines the webGL uniform location where to store the value
+     * @param array defines the array of number to store
+     * @returns true if the value was set
+     */
+    setArray2(uniform: any, array: any): boolean;
+    /**
+     * Set the value of an uniform to an array of number (stored as vec3)
+     * @param uniform defines the webGL uniform location where to store the value
+     * @param array defines the array of number to store
+     * @returns true if the value was set
+     */
+    setArray3(uniform: any, array: any): boolean;
+    /**
+     * Set the value of an uniform to an array of number (stored as vec4)
+     * @param uniform defines the webGL uniform location where to store the value
+     * @param array defines the array of number to store
+     * @returns true if the value was set
+     */
+    setArray4(uniform: any, array: any): boolean;
+    /**
+     * Set the value of an uniform to an array of float32 (stored as matrices)
+     * @param uniform defines the webGL uniform location where to store the value
+     * @param matrices defines the array of float32 to store
+     * @returns true if the value was set
+     */
+    setMatrices(uniform: any, matrices: any): boolean;
+    /**
+     * Set the value of an uniform to a matrix (3x3)
+     * @param uniform defines the webGL uniform location where to store the value
+     * @param matrix defines the Float32Array representing the 3x3 matrix to store
+     * @returns true if the value was set
+     */
+    setMatrix3x3(uniform: any, matrix: any): boolean;
+    /**
+     * Set the value of an uniform to a matrix (2x2)
+     * @param uniform defines the webGL uniform location where to store the value
+     * @param matrix defines the Float32Array representing the 2x2 matrix to store
+     * @returns true if the value was set
+     */
+    setMatrix2x2(uniform: any, matrix: any): boolean;
+    /**
+     * Set the value of an uniform to a number (float)
+     * @param uniform defines the webGL uniform location where to store the value
+     * @param value defines the float number to store
+     * @returns true if the value was transferred
+     */
+    setFloat(uniform: any, value: any): boolean;
+    /**
+     * Set the value of an uniform to a vec2
+     * @param uniform defines the webGL uniform location where to store the value
+     * @param x defines the 1st component of the value
+     * @param y defines the 2nd component of the value
+     * @returns true if the value was set
+     */
+    setFloat2(uniform: any, x: any, y: any): boolean;
+    /**
+     * Set the value of an uniform to a vec3
+     * @param uniform defines the webGL uniform location where to store the value
+     * @param x defines the 1st component of the value
+     * @param y defines the 2nd component of the value
+     * @param z defines the 3rd component of the value
+     * @returns true if the value was set
+     */
+    setFloat3(uniform: any, x: any, y: any, z: any): boolean;
+    /**
+     * Set the value of an uniform to a vec4
+     * @param uniform defines the webGL uniform location where to store the value
+     * @param x defines the 1st component of the value
+     * @param y defines the 2nd component of the value
+     * @param z defines the 3rd component of the value
+     * @param w defines the 4th component of the value
+     * @returns true if the value was set
+     */
+    setFloat4(uniform: any, x: any, y: any, z: any, w: any): boolean;
+    /**
+     * 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: any): 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: any): void;
+    _currentProgram: any;
+    /**
+     * @internal
+     */
+    _getSamplingParameters(samplingMode: any, generateMipMaps: any): {
+        min: any;
+        mag: any;
+    };
+    /** @internal */
+    _createTexture(): any;
+    /** @internal */
+    _createHardwareTexture(): WebGLHardwareTexture;
+    /**
+     * Creates an internal texture without binding it to a framebuffer
+     * @internal
+     * @param size defines the size of the texture
+     * @param options defines the options used to create the texture
+     * @param delayGPUTextureCreation true to delay the texture creation the first time it is really needed. false to create it right away
+     * @param source source type of the texture
+     * @returns a new internal texture
+     */
+    _createInternalTexture(size: any, options: any, delayGPUTextureCreation?: boolean, source?: InternalTextureSource): InternalTexture;
+    /**
+     * @internal
+     */
+    _getUseSRGBBuffer(useSRGBBuffer: any, noMipmap: any): any;
+    _createTextureBase(url: any, noMipmap: any, invertY: any, scene: any, samplingMode: number | undefined, onLoad: null | undefined, onError: null | undefined, prepareTexture: any, prepareTextureProcessFunction: any, buffer: null | undefined, fallback: null | undefined, format: null | undefined, forcedExtension: null | undefined, mimeType: any, loaderOptions: any, useSRGBBuffer: any): InternalTexture;
+    /**
+     * Usually called from Texture.ts.
+     * Passed information to create a WebGLTexture
+     * @param url defines a value which contains one of the following:
+     * * A conventional http URL, e.g. 'http://...' or 'file://...'
+     * * A base64 string of in-line texture data, e.g. 'data:image/jpg;base64,/...'
+     * * An indicator that data being passed using the buffer parameter, e.g. 'data:mytexture.jpg'
+     * @param noMipmap defines a boolean indicating that no mipmaps shall be generated.  Ignored for compressed textures.  They must be in the file
+     * @param invertY when true, image is flipped when loaded.  You probably want true. Certain compressed textures may invert this if their default is inverted (eg. ktx)
+     * @param scene needed for loading to the correct scene
+     * @param samplingMode mode with should be used sample / access the texture (Default: Texture.TRILINEAR_SAMPLINGMODE)
+     * @param onLoad optional callback to be called upon successful completion
+     * @param onError optional callback to be called upon failure
+     * @param buffer a source of a file previously fetched as either a base64 string, an ArrayBuffer (compressed or image format), HTMLImageElement (image format), or a Blob
+     * @param fallback an internal argument in case the function must be called again, due to etc1 not having alpha capabilities
+     * @param format internal format.  Default: RGB when extension is '.jpg' else RGBA.  Ignored for compressed textures
+     * @param forcedExtension defines the extension to use to pick the right loader
+     * @param mimeType defines an optional mime type
+     * @param loaderOptions options to be passed to the loader
+     * @param creationFlags specific flags to use when creating the texture (1 for storage textures, for eg)
+     * @param useSRGBBuffer defines if the texture must be loaded in a sRGB GPU buffer (if supported by the GPU).
+     * @returns a InternalTexture for assignment back into BABYLON.Texture
+     */
+    createTexture(url: any, noMipmap: any, invertY: any, scene: any, samplingMode: number | undefined, onLoad: null | undefined, onError: null | undefined, buffer: null | undefined, fallback: null | undefined, format: null | undefined, forcedExtension: null | undefined, mimeType: any, loaderOptions: any, creationFlags: any, useSRGBBuffer: any): InternalTexture;
+    /**
+     * @internal
+     */
+    _rescaleTexture(source: any, destination: any, scene: any, internalFormat: any, onComplete: any): void;
+    /**
+     * Creates a raw texture
+     * @param data defines the data to store in the texture
+     * @param width defines the width of the texture
+     * @param height defines the height of the texture
+     * @param format defines the format of the data
+     * @param generateMipMaps defines if the engine should generate the mip levels
+     * @param invertY defines if data must be stored with Y axis inverted
+     * @param samplingMode defines the required sampling mode (Texture.NEAREST_SAMPLINGMODE by default)
+     * @param compression defines the compression used (null by default)
+     * @param type defines the type fo the data (Engine.TEXTURETYPE_UNSIGNED_INT by default)
+     * @param creationFlags specific flags to use when creating the texture (1 for storage textures, for eg)
+     * @param useSRGBBuffer defines if the texture must be loaded in a sRGB GPU buffer (if supported by the GPU).
+     * @returns the raw texture inside an InternalTexture
+     */
+    createRawTexture(data: any, width: any, height: any, format: any, generateMipMaps: any, invertY: any, samplingMode: any, compression?: null, type?: number, creationFlags?: number, useSRGBBuffer?: boolean): void;
+    /**
+     * Creates a new raw cube texture
+     * @param data defines the array of data to use to create each face
+     * @param size defines the size of the textures
+     * @param format defines the format of the data
+     * @param type defines the type of the data (like Engine.TEXTURETYPE_UNSIGNED_INT)
+     * @param generateMipMaps  defines if the engine should generate the mip levels
+     * @param invertY defines if data must be stored with Y axis inverted
+     * @param samplingMode defines the required sampling mode (like Texture.NEAREST_SAMPLINGMODE)
+     * @param compression defines the compression used (null by default)
+     * @returns the cube texture as an InternalTexture
+     */
+    createRawCubeTexture(data: any, size: any, format: any, type: any, generateMipMaps: any, invertY: any, samplingMode: any, compression?: null): void;
+    /**
+     * Creates a new raw 3D texture
+     * @param data defines the data used to create the texture
+     * @param width defines the width of the texture
+     * @param height defines the height of the texture
+     * @param depth defines the depth of the texture
+     * @param format defines the format of the texture
+     * @param generateMipMaps defines if the engine must generate mip levels
+     * @param invertY defines if data must be stored with Y axis inverted
+     * @param samplingMode defines the required sampling mode (like Texture.NEAREST_SAMPLINGMODE)
+     * @param compression defines the compressed used (can be null)
+     * @param textureType defines the compressed used (can be null)
+     * @returns a new raw 3D texture (stored in an InternalTexture)
+     */
+    createRawTexture3D(data: any, width: any, height: any, depth: any, format: any, generateMipMaps: any, invertY: any, samplingMode: any, compression?: null, textureType?: number): void;
+    /**
+     * Creates a new raw 2D array texture
+     * @param data defines the data used to create the texture
+     * @param width defines the width of the texture
+     * @param height defines the height of the texture
+     * @param depth defines the number of layers of the texture
+     * @param format defines the format of the texture
+     * @param generateMipMaps defines if the engine must generate mip levels
+     * @param invertY defines if data must be stored with Y axis inverted
+     * @param samplingMode defines the required sampling mode (like Texture.NEAREST_SAMPLINGMODE)
+     * @param compression defines the compressed used (can be null)
+     * @param textureType defines the compressed used (can be null)
+     * @returns a new raw 2D array texture (stored in an InternalTexture)
+     */
+    createRawTexture2DArray(data: any, width: any, height: any, depth: any, format: any, generateMipMaps: any, invertY: any, samplingMode: any, compression?: null, textureType?: number): void;
+    /**
+     * @internal
+     */
+    _unpackFlipY(value: any): void;
+    /** @internal */
+    _getUnpackAlignement(): any;
+    _getTextureTarget(texture: any): any;
+    /**
+     * Update the sampling mode of a given texture
+     * @param samplingMode defines the required sampling mode
+     * @param texture defines the texture to update
+     * @param generateMipMaps defines whether to generate mipmaps for the texture
+     */
+    updateTextureSamplingMode(samplingMode: any, texture: any, generateMipMaps?: boolean): void;
+    /**
+     * Update the dimensions of a texture
+     * @param texture texture to update
+     * @param width new width of the texture
+     * @param height new height of the texture
+     * @param depth new depth of the texture
+     */
+    updateTextureDimensions(texture: any, width: any, height: any, depth?: number): void;
+    /**
+     * Update the sampling mode of a given texture
+     * @param texture defines the texture to update
+     * @param wrapU defines the texture wrap mode of the u coordinates
+     * @param wrapV defines the texture wrap mode of the v coordinates
+     * @param wrapR defines the texture wrap mode of the r coordinates
+     */
+    updateTextureWrappingMode(texture: any, wrapU: any, wrapV?: null, wrapR?: null): void;
+    /**
+     * @internal
+     */
+    _setupDepthStencilTexture(internalTexture: any, size: any, generateStencil: any, bilinearFiltering: any, comparisonFunction: any, samples?: number): void;
+    /**
+     * @internal
+     */
+    _uploadCompressedDataToTextureDirectly(texture: any, internalFormat: any, width: any, height: any, data: any, faceIndex?: number, lod?: number): void;
+    /**
+     * @internal
+     */
+    _uploadDataToTextureDirectly(texture: any, imageData: any, faceIndex: number | undefined, lod: number | undefined, babylonInternalFormat: any, useTextureWidthAndHeight?: boolean): void;
+    /**
+     * Update a portion of an internal texture
+     * @param texture defines the texture to update
+     * @param imageData defines the data to store into the texture
+     * @param xOffset defines the x coordinates of the update rectangle
+     * @param yOffset defines the y coordinates of the update rectangle
+     * @param width defines the width of the update rectangle
+     * @param height defines the height of the update rectangle
+     * @param faceIndex defines the face index if texture is a cube (0 by default)
+     * @param lod defines the lod level to update (0 by default)
+     * @param generateMipMaps defines whether to generate mipmaps or not
+     */
+    updateTextureData(texture: any, imageData: any, xOffset: any, yOffset: any, width: any, height: any, faceIndex?: number, lod?: number, generateMipMaps?: boolean): void;
+    /**
+     * @internal
+     */
+    _uploadArrayBufferViewToTexture(texture: any, imageData: any, faceIndex?: number, lod?: number): void;
+    _prepareWebGLTextureContinuation(texture: any, scene: any, noMipmap: any, isCompressed: any, samplingMode: any): void;
+    _prepareWebGLTexture(texture: any, extension: any, scene: any, img: any, invertY: any, noMipmap: any, isCompressed: any, processFunction: any, samplingMode?: number): void;
+    /**
+     * @internal
+     */
+    _setupFramebufferDepthAttachments(generateStencilBuffer: any, generateDepthBuffer: any, width: any, height: any, samples?: number): any;
+    /**
+     * @internal
+     */
+    _createRenderBuffer(width: any, height: any, samples: any, internalFormat: any, msInternalFormat: any, attachment: any, unbindBuffer?: boolean): any;
+    _updateRenderBuffer(renderBuffer: any, width: any, height: any, samples: any, internalFormat: any, msInternalFormat: any, attachment: any, unbindBuffer?: boolean): any;
+    /**
+     * @internal
+     */
+    _releaseTexture(texture: any): void;
+    /**
+     * @internal
+     */
+    _releaseRenderTargetWrapper(rtWrapper: any): void;
+    _deleteTexture(texture: any): void;
+    _setProgram(program: any): void;
+    /**
+     * Binds an effect to the webGL context
+     * @param effect defines the effect to bind
+     */
+    bindSamplers(effect: any): void;
+    _activateCurrentTexture(): void;
+    /**
+     * @internal
+     */
+    _bindTextureDirectly(target: any, texture: any, forTextureDataUpdate?: boolean, force?: boolean): boolean;
+    /**
+     * @internal
+     */
+    _bindTexture(channel: any, texture: any, name: any): void;
+    /**
+     * Unbind all textures from the webGL context
+     */
+    unbindAllTextures(): void;
+    /**
+     * Sets a texture to the according uniform.
+     * @param channel The texture channel
+     * @param uniform The uniform to set
+     * @param texture The texture to apply
+     * @param name The name of the uniform in the effect
+     */
+    setTexture(channel: any, uniform: any, texture: any, name: any): void;
+    _bindSamplerUniformToChannel(sourceSlot: any, destination: any): void;
+    _getTextureWrapMode(mode: any): any;
+    _setTexture(channel: any, texture: any, isPartOfTextureArray?: boolean, depthStencilTexture?: boolean, name?: string): boolean;
+    /**
+     * Sets an array of texture to the webGL context
+     * @param channel defines the channel where the texture array must be set
+     * @param uniform defines the associated uniform location
+     * @param textures defines the array of textures to bind
+     * @param name name of the channel
+     */
+    setTextureArray(channel: any, uniform: any, textures: any, name: any): void;
+    _textureUnits: Int32Array | undefined;
+    /**
+     * @internal
+     */
+    _setAnisotropicLevel(target: any, internalTexture: any, anisotropicFilteringLevel: any): void;
+    _setTextureParameterFloat(target: any, parameter: any, value: any, texture: any): void;
+    _setTextureParameterInteger(target: any, parameter: any, value: any, texture: any): void;
+    /**
+     * Unbind all vertex attributes from the webGL context
+     */
+    unbindAllAttributes(): void;
+    /**
+     * Force the engine to release all cached effects. This means that next effect compilation will have to be done completely even if a similar effect was already compiled
+     */
+    releaseEffects(): void;
+    /**
+     * Dispose and release all associated resources
+     */
+    dispose(): void;
+    /**
+     * Attach a new callback raised when context lost event is fired
+     * @param callback defines the callback to call
+     */
+    attachContextLostEvent(callback: any): void;
+    /**
+     * Attach a new callback raised when context restored event is fired
+     * @param callback defines the callback to call
+     */
+    attachContextRestoredEvent(callback: any): void;
+    /**
+     * Get the current error code of the webGL context
+     * @returns the error code
+     * @see https://developer.mozilla.org/en-US/docs/Web/API/WebGLRenderingContext/getError
+     */
+    getError(): any;
+    _canRenderToFloatFramebuffer(): boolean;
+    _canRenderToHalfFloatFramebuffer(): boolean;
+    _canRenderToFramebuffer(type: any): boolean;
+    /**
+     * @internal
+     */
+    _getWebGLTextureType(type: any): any;
+    /**
+     * @internal
+     */
+    _getInternalFormat(format: any, useSRGBBuffer?: boolean): any;
+    /**
+     * @internal
+     */
+    _getRGBABufferInternalSizedFormat(type: any, format: any, useSRGBBuffer?: boolean): any;
+    /**
+     * @internal
+     */
+    _getRGBAMultiSampleBufferFormat(type: any): any;
+    /**
+     * @internal
+     */
+    _loadFile(url: any, onSuccess: any, onProgress: any, offlineProvider: any, useArrayBuffer: any, onError: any): void;
+    /**
+     * 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
+     * @param y defines the y coordinate of the rectangle where pixels must be read
+     * @param width defines the width of the rectangle where pixels must be read
+     * @param height defines the height of the rectangle where pixels must be read
+     * @param hasAlpha defines whether the output should have alpha or not (defaults to true)
+     * @param flushRenderer true to flush the renderer from the pending commands before reading the pixels
+     * @returns a ArrayBufferView promise (Uint8Array) containing RGBA colors
+     */
+    readPixels(x: any, y: any, width: any, height: any, hasAlpha?: boolean, flushRenderer?: boolean): Promise<Uint8Array>;
+    /**
+     * Gets host document
+     * @returns the host document object
+     */
+    getHostDocument(): any;
+}
+export namespace ThinEngine {
+    const _IsSupported: boolean | null | undefined;
+    const _HasMajorPerformanceCaveat: boolean | null | undefined;
+    const ExceptionList: ({
+        key: string;
+        capture: string;
+        captureConstraint: number;
+        targets: string[];
+    } | {
+        key: string;
+        capture: null;
+        captureConstraint: null;
+        targets: string[];
+    })[];
+    const _TextureLoaders: any[];
+    const CollisionsEpsilon: number;
+}
+import { Observable } from "../Misc/observable.js";
+import { DepthCullingState } from "../States/depthCullingState.js";
+import { StencilStateComposer } from "../States/stencilStateComposer.js";
+import { StencilState } from "../States/stencilState.js";
+import { AlphaState } from "../States/alphaCullingState.js";
+import { WebGL2ShaderProcessor } from "./WebGL/webGL2ShaderProcessors.js";
+import { WebGLShaderProcessor } from "./WebGL/webGLShaderProcessors.js";
+import { WebGLDataBuffer } from "../Meshes/WebGL/webGLDataBuffer.js";
+import { ShaderLanguage } from "../Materials/shaderLanguage.js";
+import { WebGLPipelineContext } from "./WebGL/webGLPipelineContext.js";
+import { WebGLHardwareTexture } from "./WebGL/webGLHardwareTexture.js";
+import { InternalTextureSource } from "../Materials/Textures/internalTexture.js";
+import { InternalTexture } from "../Materials/Textures/internalTexture.js";