@combeenation/3d-viewer 0.0.1-types

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

@@ -0,0 +1,754 @@
+/**
+ * The engine class is responsible for interfacing with all lower-level APIs such as WebGL and Audio
+ */
+export class Engine extends ThinEngine {
+    /** Gets the list of created engines */
+    static get Instances(): import("@babylonjs/core").Engine[];
+    /**
+     * Gets the latest created engine
+     */
+    static get LastCreatedEngine(): import("@babylonjs/core").Nullable<import("@babylonjs/core").Engine>;
+    /**
+     * Gets the latest created scene
+     */
+    static get LastCreatedScene(): import("@babylonjs/core").Nullable<import("@babylonjs/core").Scene>;
+    /**
+     * Will flag all materials in all scenes in all engines as dirty to trigger new shader compilation
+     * @param flag defines which part of the materials must be marked as dirty
+     * @param predicate defines a predicate used to filter which materials should be affected
+     */
+    static MarkAllMaterialsAsDirty(flag: any, predicate: any): void;
+    /**
+     * Method called to create the default loading screen.
+     * This can be overridden in your own app.
+     * @param canvas The rendering canvas element
+     * @returns The loading screen
+     */
+    static DefaultLoadingScreenFactory(canvas: any): void;
+    /** Pointerlock and fullscreen */
+    /**
+     * Ask the browser to promote the current element to pointerlock mode
+     * @param element defines the DOM element to promote
+     */
+    static _RequestPointerlock(element: any): void;
+    /**
+     * Asks the browser to exit pointerlock mode
+     */
+    static _ExitPointerlock(): void;
+    /**
+     * Ask the browser to promote the current element to fullscreen rendering mode
+     * @param element defines the DOM element to promote
+     */
+    static _RequestFullscreen(element: any): void;
+    /**
+     * Asks the browser to exit fullscreen mode
+     */
+    static _ExitFullscreen(): void;
+    /**
+     * 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?: boolean);
+    /**
+     * Gets or sets a boolean to enable/disable IndexedDB support and avoid XHR on .manifest
+     **/
+    enableOfflineSupport: boolean;
+    /**
+     * Gets or sets a boolean to enable/disable checking manifest if IndexedDB support is enabled (js will always consider the database is up to date)
+     **/
+    disableManifestCheck: boolean;
+    /**
+     * Gets or sets a boolean to enable/disable the context menu (right-click) from appearing on the main canvas
+     */
+    disableContextMenu: boolean;
+    /**
+     * Gets the list of created scenes
+     */
+    scenes: any[];
+    /** @internal */
+    _virtualScenes: any[];
+    /**
+     * Event raised when a new scene is created
+     */
+    onNewSceneAddedObservable: Observable<any>;
+    /**
+     * Gets the list of created postprocesses
+     */
+    postProcesses: any[];
+    /**
+     * Gets a boolean indicating if the pointer is currently locked
+     */
+    isPointerLock: boolean;
+    /**
+     * Observable event triggered each time the rendering canvas is resized
+     */
+    onResizeObservable: Observable<any>;
+    /**
+     * Observable event triggered each time the canvas loses focus
+     */
+    onCanvasBlurObservable: Observable<any>;
+    /**
+     * Observable event triggered each time the canvas gains focus
+     */
+    onCanvasFocusObservable: Observable<any>;
+    /**
+     * Observable event triggered each time the canvas receives pointerout event
+     */
+    onCanvasPointerOutObservable: Observable<any>;
+    /**
+     * Observable raised when the engine begins a new frame
+     */
+    onBeginFrameObservable: Observable<any>;
+    /**
+     * If set, will be used to request the next animation frame for the render loop
+     */
+    customAnimationFrameRequester: any;
+    /**
+     * Observable raised when the engine ends the current frame
+     */
+    onEndFrameObservable: Observable<any>;
+    /**
+     * Observable raised when the engine is about to compile a shader
+     */
+    onBeforeShaderCompilationObservable: Observable<any>;
+    /**
+     * Observable raised when the engine has just compiled a shader
+     */
+    onAfterShaderCompilationObservable: Observable<any>;
+    _deterministicLockstep: boolean;
+    _lockstepMaxSteps: any;
+    _timeStep: any;
+    _fps: number;
+    _deltaTime: number;
+    /** @internal */
+    _drawCalls: PerfCounter;
+    /** Gets or sets the tab index to set to the rendering canvas. 1 is the minimum value to set to be able to capture keyboard events */
+    canvasTabIndex: number;
+    /**
+     * Turn this value on if you want to pause FPS computation when in background
+     */
+    disablePerformanceMonitorInBackground: boolean;
+    _performanceMonitor: PerformanceMonitor;
+    _compatibilityMode: boolean;
+    /**
+     * Gets or sets the current render pass id
+     */
+    currentRenderPassId: number;
+    _renderPassNames: string[];
+    _onFullscreenChange: (() => void) | undefined;
+    _onPointerLockChange: (() => void) | undefined;
+    /** @internal */
+    /**
+     * Engine abstraction for loading and creating an image bitmap from a given source string.
+     * @param imageSource source to load the image from.
+     * @param options An object that sets options for the image's extraction.
+     * @returns ImageBitmap.
+     */
+    _createImageBitmapFromSource(imageSource: any, options: any): Promise<any>;
+    /**
+     * Engine abstraction for createImageBitmap
+     * @param image source for image
+     * @param options An object that sets options for the image's extraction.
+     * @returns ImageBitmap
+     */
+    createImageBitmap(image: any, options: any): Promise<ImageBitmap>;
+    /**
+     * Resize an image and returns the image data as an uint8array
+     * @param image image to resize
+     * @param bufferWidth destination buffer width
+     * @param bufferHeight destination buffer height
+     * @returns an uint8array containing RGBA values of bufferWidth * bufferHeight size
+     */
+    resizeImageBitmap(image: any, bufferWidth: any, bufferHeight: any): Uint8ClampedArray;
+    /**
+     * Gets the performance monitor attached to this engine
+     * @see https://doc.babylonjs.com/how_to/optimizing_your_scene#engineinstrumentation
+     */
+    get performanceMonitor(): PerformanceMonitor;
+    set compatibilityMode(arg: boolean);
+    /**
+     * (WebGPU only) True (default) to be in compatibility mode, meaning rendering all existing scenes without artifacts (same rendering than WebGL).
+     * Setting the property to false will improve performances but may not work in some scenes if some precautions are not taken.
+     * See https://doc.babylonjs.com/advanced_topics/webGPU/webGPUOptimization/webGPUNonCompatibilityMode for more details
+     */
+    get compatibilityMode(): boolean;
+    /**
+     * Gets the HTML element used to attach event listeners
+     * @returns a HTML element
+     */
+    getInputElement(): import("@babylonjs/core").Nullable<HTMLCanvasElement>;
+    /**
+     * 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;
+    _onCanvasFocus: (() => void) | undefined;
+    _onCanvasBlur: (() => void) | undefined;
+    _onCanvasContextMenu: ((evt: any) => void) | undefined;
+    _onBlur: (() => void) | undefined;
+    _onFocus: (() => void) | undefined;
+    _onCanvasPointerOut: ((ev: any) => void) | undefined;
+    /**
+     * Gets current aspect ratio
+     * @param viewportOwner defines the camera to use to get the aspect ratio
+     * @param useScreen defines if screen size must be used (or the current render target if any)
+     * @returns a number defining the aspect ratio
+     */
+    getAspectRatio(viewportOwner: any, useScreen?: boolean): number;
+    /**
+     * Gets current screen aspect ratio
+     * @returns a number defining the aspect ratio
+     */
+    getScreenAspectRatio(): number;
+    /**
+     * Gets the client rect of the HTML canvas attached with the current webGL context
+     * @returns a client rectangle
+     */
+    getRenderingCanvasClientRect(): DOMRect | null;
+    /**
+     * Gets the client rect of the HTML element used for events
+     * @returns a client rectangle
+     */
+    getInputElementClientRect(): DOMRect | null;
+    /**
+     * Gets a boolean indicating that the engine is running in deterministic lock step mode
+     * @see https://doc.babylonjs.com/babylon101/animations#deterministic-lockstep
+     * @returns true if engine is in deterministic lock step mode
+     */
+    isDeterministicLockStep(): boolean;
+    /**
+     * Gets the max steps when engine is running in deterministic lock step
+     * @see https://doc.babylonjs.com/babylon101/animations#deterministic-lockstep
+     * @returns the max steps
+     */
+    getLockstepMaxSteps(): any;
+    /**
+     * Returns the time in ms between steps when using deterministic lock step.
+     * @returns time step in (ms)
+     */
+    getTimeStep(): number;
+    /**
+     * 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: any, unbind?: boolean): void;
+    /** States */
+    /**
+     * Gets a boolean indicating if depth writing is enabled
+     * @returns the current depth writing state
+     */
+    getDepthWrite(): boolean;
+    /**
+     * Enable or disable depth writing
+     * @param enable defines the state to set
+     */
+    setDepthWrite(enable: any): void;
+    /**
+     * Gets a boolean indicating if stencil buffer is enabled
+     * @returns the current stencil buffer state
+     */
+    getStencilBuffer(): boolean;
+    /**
+     * Enable or disable the stencil buffer
+     * @param enable defines if the stencil buffer must be enabled or disabled
+     */
+    setStencilBuffer(enable: any): void;
+    /**
+     * Gets the current stencil mask
+     * @returns a number defining the new stencil mask to use
+     */
+    getStencilMask(): number;
+    /**
+     * Sets the current stencil mask
+     * @param mask defines the new stencil mask to use
+     */
+    setStencilMask(mask: any): void;
+    /**
+     * Gets the current stencil function
+     * @returns a number defining the stencil function to use
+     */
+    getStencilFunction(): number;
+    /**
+     * Gets the current stencil reference value
+     * @returns a number defining the stencil reference value to use
+     */
+    getStencilFunctionReference(): number;
+    /**
+     * Gets the current stencil mask
+     * @returns a number defining the stencil mask to use
+     */
+    getStencilFunctionMask(): number;
+    /**
+     * Sets the current stencil function
+     * @param stencilFunc defines the new stencil function to use
+     */
+    setStencilFunction(stencilFunc: any): void;
+    /**
+     * Sets the current stencil reference
+     * @param reference defines the new stencil reference to use
+     */
+    setStencilFunctionReference(reference: any): void;
+    /**
+     * Sets the current stencil mask
+     * @param mask defines the new stencil mask to use
+     */
+    setStencilFunctionMask(mask: any): void;
+    /**
+     * Gets the current stencil operation when stencil fails
+     * @returns a number defining stencil operation to use when stencil fails
+     */
+    getStencilOperationFail(): number;
+    /**
+     * Gets the current stencil operation when depth fails
+     * @returns a number defining stencil operation to use when depth fails
+     */
+    getStencilOperationDepthFail(): number;
+    /**
+     * Gets the current stencil operation when stencil passes
+     * @returns a number defining stencil operation to use when stencil passes
+     */
+    getStencilOperationPass(): number;
+    /**
+     * Sets the stencil operation to use when stencil fails
+     * @param operation defines the stencil operation to use when stencil fails
+     */
+    setStencilOperationFail(operation: any): void;
+    /**
+     * Sets the stencil operation to use when depth fails
+     * @param operation defines the stencil operation to use when depth fails
+     */
+    setStencilOperationDepthFail(operation: any): void;
+    /**
+     * Sets the stencil operation to use when stencil passes
+     * @param operation defines the stencil operation to use when stencil passes
+     */
+    setStencilOperationPass(operation: any): void;
+    /**
+     * Sets a boolean indicating if the dithering state is enabled or disabled
+     * @param value defines the dithering state
+     */
+    setDitheringState(value: any): void;
+    /**
+     * Sets a boolean indicating if the rasterizer state is enabled or disabled
+     * @param value defines the rasterizer state
+     */
+    setRasterizerState(value: any): void;
+    /**
+     * Gets the current depth function
+     * @returns a number defining the depth function
+     */
+    getDepthFunction(): import("@babylonjs/core").Nullable<number>;
+    /**
+     * Sets the current depth function
+     * @param depthFunc defines the function to use
+     */
+    setDepthFunction(depthFunc: any): void;
+    /**
+     * Sets the current depth function to GREATER
+     */
+    setDepthFunctionToGreater(): void;
+    /**
+     * Sets the current depth function to GEQUAL
+     */
+    setDepthFunctionToGreaterOrEqual(): void;
+    /**
+     * Sets the current depth function to LESS
+     */
+    setDepthFunctionToLess(): void;
+    /**
+     * Sets the current depth function to LEQUAL
+     */
+    setDepthFunctionToLessOrEqual(): void;
+    /**
+     * Caches the the state of the stencil buffer
+     */
+    cacheStencilState(): void;
+    _cachedStencilBuffer: boolean | undefined;
+    _cachedStencilFunction: number | undefined;
+    _cachedStencilMask: number | undefined;
+    _cachedStencilOperationPass: number | undefined;
+    _cachedStencilOperationFail: number | undefined;
+    _cachedStencilOperationDepthFail: number | undefined;
+    _cachedStencilReference: number | undefined;
+    /**
+     * Restores the state of the stencil buffer
+     */
+    restoreStencilState(): void;
+    /**
+     * Directly set the WebGL Viewport
+     * @param x defines the x coordinate of the viewport (in screen space)
+     * @param y defines the y coordinate of the viewport (in screen space)
+     * @param width defines the width of the viewport (in screen space)
+     * @param height defines the height of the viewport (in screen space)
+     * @returns the current viewport Object (if any) that is being replaced by this call. You can restore this viewport later on to go back to the original state
+     */
+    setDirectViewport(x: any, y: any, width: any, height: any): import("@babylonjs/core").Nullable<import("@babylonjs/core/Maths/math.like.js").IViewportLike>;
+    /**
+     * Executes a scissor clear (ie. a clear on a specific portion of the screen)
+     * @param x defines the x-coordinate of the bottom left corner of the clear rectangle
+     * @param y defines the y-coordinate of the corner of the clear rectangle
+     * @param width defines the width of the clear rectangle
+     * @param height defines the height of the clear rectangle
+     * @param clearColor defines the clear color
+     */
+    scissorClear(x: any, y: any, width: any, height: any, clearColor: any): void;
+    /**
+     * Enable scissor test on a specific rectangle (ie. render will only be executed on a specific portion of the screen)
+     * @param x defines the x-coordinate of the bottom left corner of the clear rectangle
+     * @param y defines the y-coordinate of the corner of the clear rectangle
+     * @param width defines the width of the clear rectangle
+     * @param height defines the height of the clear rectangle
+     */
+    enableScissor(x: any, y: any, width: any, height: any): void;
+    /**
+     * Disable previously set scissor test rectangle
+     */
+    disableScissor(): void;
+    /**
+     * @internal
+     */
+    _reportDrawCall(numDrawCalls?: number): void;
+    /**
+     * Initializes a webVR display and starts listening to display change events
+     * The onVRDisplayChangedObservable will be notified upon these changes
+     * @returns The onVRDisplayChangedObservable
+     */
+    initWebVR(): void;
+    /** @internal */
+    _prepareVRComponent(): void;
+    /**
+     * @internal
+     */
+    _connectVREvents(canvas: any, document: any): void;
+    /** @internal */
+    _submitVRFrame(): void;
+    /**
+     * Call this function to leave webVR mode
+     * Will do nothing if webVR is not supported or if there is no webVR device
+     * @see https://doc.babylonjs.com/how_to/webvr_camera
+     */
+    disableVR(): void;
+    /**
+     * Gets a boolean indicating that the system is in VR mode and is presenting
+     * @returns true if VR mode is engaged
+     */
+    isVRPresenting(): boolean;
+    /** @internal */
+    _requestVRFrame(): void;
+    /**
+     * @internal
+     */
+    _loadFileAsync(url: any, offlineProvider: any, useArrayBuffer: any): Promise<any>;
+    /**
+     * Gets the source code of the vertex shader associated with a specific webGL program
+     * @param program defines the program to use
+     * @returns a string containing the source code of the vertex shader associated with the program
+     */
+    getVertexShaderSource(program: any): string | null;
+    /**
+     * Gets the source code of the fragment shader associated with a specific webGL program
+     * @param program defines the program to use
+     * @returns a string containing the source code of the fragment shader associated with the program
+     */
+    getFragmentShaderSource(program: any): string | null;
+    /**
+     * Sets a depth stencil texture from a render target to the according uniform.
+     * @param channel The texture channel
+     * @param uniform The uniform to set
+     * @param texture The render target texture containing the depth stencil texture to apply
+     * @param name The texture name
+     */
+    setDepthStencilTexture(channel: any, uniform: any, texture: any, name: any): void;
+    /**
+     * Sets a texture to the webGL context from a postprocess
+     * @param channel defines the channel to use
+     * @param postProcess defines the source postprocess
+     * @param name name of the channel
+     */
+    setTextureFromPostProcess(channel: any, postProcess: any, name: any): void;
+    /**
+     * Binds the output of the passed in post process to the texture channel specified
+     * @param channel The channel the texture should be bound to
+     * @param postProcess The post process which's output should be bound
+     * @param name name of the channel
+     */
+    setTextureFromPostProcessOutput(channel: any, postProcess: any, name: any): void;
+    /** @internal */
+    _renderFrame(): void;
+    /** @internal */
+    _renderViews(): boolean;
+    /**
+     * Toggle full screen mode
+     * @param requestPointerLock defines if a pointer lock should be requested from the user
+     */
+    switchFullscreen(requestPointerLock: any): void;
+    /**
+     * Enters full screen mode
+     * @param requestPointerLock defines if a pointer lock should be requested from the user
+     */
+    enterFullscreen(requestPointerLock: any): void;
+    _pointerLockRequested: any;
+    /**
+     * Exits full screen mode
+     */
+    exitFullscreen(): void;
+    /**
+     * Enters Pointerlock mode
+     */
+    enterPointerlock(): void;
+    /**
+     * Exits Pointerlock mode
+     */
+    exitPointerlock(): 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;
+    _deletePipelineContext(pipelineContext: any): void;
+    createShaderProgram(pipelineContext: any, vertexCode: any, fragmentCode: any, defines: any, context: any, transformFeedbackVaryings?: null): WebGLProgram;
+    _createShaderProgram(pipelineContext: any, vertexShader: any, fragmentShader: any, context: any, transformFeedbackVaryings?: null): any;
+    /**
+     * @internal
+     */
+    _releaseTexture(texture: any): void;
+    /**
+     * @internal
+     */
+    _releaseRenderTargetWrapper(rtWrapper: any): void;
+    /**
+     * Gets the names of the render passes that are currently created
+     * @returns list of the render pass names
+     */
+    getRenderPassNames(): string[];
+    /**
+     * Gets the name of the current render pass
+     * @returns name of the current render pass
+     */
+    getCurrentRenderPassName(): string;
+    /**
+     * Creates a render pass id
+     * @param name Name of the render pass (for debug purpose only)
+     * @returns the id of the new render pass
+     */
+    createRenderPassId(name: any): number;
+    /**
+     * Releases a render pass id
+     * @param id id of the render pass to release
+     */
+    releaseRenderPassId(id: any): void;
+    /**
+     * @internal
+     * Rescales a texture
+     * @param source input texture
+     * @param destination destination texture
+     * @param scene scene to use to render the resize
+     * @param internalFormat format to use when resizing
+     * @param onComplete callback to be called when resize has completed
+     */
+    _rescaleTexture(source: any, destination: any, scene: any, internalFormat: any, onComplete: any): void;
+    _rescalePostProcess: any;
+    /**
+     * Gets the current framerate
+     * @returns a number representing the framerate
+     */
+    getFps(): number;
+    /**
+     * Gets the time spent between current and previous frame
+     * @returns a number representing the delta time in ms
+     */
+    getDeltaTime(): number;
+    _measureFps(): void;
+    /**
+     * Wraps an external web gl texture in a Babylon texture.
+     * @param texture defines the external texture
+     * @returns the babylon internal texture
+     */
+    wrapWebGLTexture(texture: any): InternalTexture;
+    /**
+     * @internal
+     */
+    _uploadImageToTexture(texture: any, image: any, faceIndex?: number, lod?: number): void;
+    /**
+     * Updates a depth texture Comparison Mode and Function.
+     * If the comparison Function is equal to 0, the mode will be set to none.
+     * Otherwise, this only works in webgl 2 and requires a shadow sampler in the shader.
+     * @param texture The texture to set the comparison function for
+     * @param comparisonFunction The comparison function to set, 0 if no comparison required
+     */
+    updateTextureComparisonFunction(texture: any, comparisonFunction: any): void;
+    /**
+     * Creates a webGL buffer to use with instantiation
+     * @param capacity defines the size of the buffer
+     * @returns the webGL buffer
+     */
+    createInstancesBuffer(capacity: any): WebGLDataBuffer;
+    /**
+     * Delete a webGL buffer used with instantiation
+     * @param buffer defines the webGL buffer to delete
+     */
+    deleteInstancesBuffer(buffer: any): void;
+    _clientWaitAsync(sync: any, flags?: number, intervalms?: number): Promise<any>;
+    /**
+     * @internal
+     */
+    _readPixelsAsync(x: any, y: any, w: any, h: any, format: any, type: any, outputBuffer: any): Promise<any> | null;
+    _disableTouchAction(): void;
+    /**
+     * Display the loading screen
+     * @see https://doc.babylonjs.com/how_to/creating_a_custom_loading_screen
+     */
+    displayLoadingUI(): void;
+    /**
+     * Hide the loading screen
+     * @see https://doc.babylonjs.com/how_to/creating_a_custom_loading_screen
+     */
+    hideLoadingUI(): void;
+    /**
+     * Sets the current loading screen object
+     * @see https://doc.babylonjs.com/how_to/creating_a_custom_loading_screen
+     */
+    set loadingScreen(arg: any);
+    /**
+     * Gets the current loading screen object
+     * @see https://doc.babylonjs.com/how_to/creating_a_custom_loading_screen
+     */
+    get loadingScreen(): any;
+    _loadingScreen: any;
+    /**
+     * Sets the current loading screen text
+     * @see https://doc.babylonjs.com/how_to/creating_a_custom_loading_screen
+     */
+    set loadingUIText(arg: any);
+    /**
+     * Sets the current loading screen background color
+     * @see https://doc.babylonjs.com/how_to/creating_a_custom_loading_screen
+     */
+    set loadingUIBackgroundColor(arg: any);
+    /**
+     * creates and returns a new video element
+     * @param constraints video constraints
+     * @returns video element
+     */
+    createVideoElement(constraints: any): HTMLVideoElement;
+    /**
+     * Get Font size information
+     * @param font font name
+     * @returns an object containing ascent, height and descent
+     */
+    getFontOffset(font: any): {
+        ascent: number;
+        height: number;
+        descent: number;
+    };
+}
+export namespace Engine {
+    const ALPHA_DISABLE: number;
+    const ALPHA_ADD: number;
+    const ALPHA_COMBINE: number;
+    const ALPHA_SUBTRACT: number;
+    const ALPHA_MULTIPLY: number;
+    const ALPHA_MAXIMIZED: number;
+    const ALPHA_ONEONE: number;
+    const ALPHA_PREMULTIPLIED: number;
+    const ALPHA_PREMULTIPLIED_PORTERDUFF: number;
+    const ALPHA_INTERPOLATE: number;
+    const ALPHA_SCREENMODE: number;
+    const DELAYLOADSTATE_NONE: number;
+    const DELAYLOADSTATE_LOADED: number;
+    const DELAYLOADSTATE_LOADING: number;
+    const DELAYLOADSTATE_NOTLOADED: number;
+    const NEVER: number;
+    const ALWAYS: number;
+    const LESS: number;
+    const EQUAL: number;
+    const LEQUAL: number;
+    const GREATER: number;
+    const GEQUAL: number;
+    const NOTEQUAL: number;
+    const KEEP: number;
+    const REPLACE: number;
+    const INCR: number;
+    const DECR: number;
+    const INVERT: number;
+    const INCR_WRAP: number;
+    const DECR_WRAP: number;
+    const TEXTURE_CLAMP_ADDRESSMODE: number;
+    const TEXTURE_WRAP_ADDRESSMODE: number;
+    const TEXTURE_MIRROR_ADDRESSMODE: number;
+    const TEXTUREFORMAT_ALPHA: number;
+    const TEXTUREFORMAT_LUMINANCE: number;
+    const TEXTUREFORMAT_LUMINANCE_ALPHA: number;
+    const TEXTUREFORMAT_RGB: number;
+    const TEXTUREFORMAT_RGBA: number;
+    const TEXTUREFORMAT_RED: number;
+    const TEXTUREFORMAT_R: number;
+    const TEXTUREFORMAT_RG: number;
+    const TEXTUREFORMAT_RED_INTEGER: number;
+    const TEXTUREFORMAT_R_INTEGER: number;
+    const TEXTUREFORMAT_RG_INTEGER: number;
+    const TEXTUREFORMAT_RGB_INTEGER: number;
+    const TEXTUREFORMAT_RGBA_INTEGER: number;
+    const TEXTURETYPE_UNSIGNED_BYTE: number;
+    const TEXTURETYPE_UNSIGNED_INT: number;
+    const TEXTURETYPE_FLOAT: number;
+    const TEXTURETYPE_HALF_FLOAT: number;
+    const TEXTURETYPE_BYTE: number;
+    const TEXTURETYPE_SHORT: number;
+    const TEXTURETYPE_UNSIGNED_SHORT: number;
+    const TEXTURETYPE_INT: number;
+    const TEXTURETYPE_UNSIGNED_INTEGER: number;
+    const TEXTURETYPE_UNSIGNED_SHORT_4_4_4_4: number;
+    const TEXTURETYPE_UNSIGNED_SHORT_5_5_5_1: number;
+    const TEXTURETYPE_UNSIGNED_SHORT_5_6_5: number;
+    const TEXTURETYPE_UNSIGNED_INT_2_10_10_10_REV: number;
+    const TEXTURETYPE_UNSIGNED_INT_24_8: number;
+    const TEXTURETYPE_UNSIGNED_INT_10F_11F_11F_REV: number;
+    const TEXTURETYPE_UNSIGNED_INT_5_9_9_9_REV: number;
+    const TEXTURETYPE_FLOAT_32_UNSIGNED_INT_24_8_REV: number;
+    const TEXTURE_NEAREST_SAMPLINGMODE: number;
+    const TEXTURE_BILINEAR_SAMPLINGMODE: number;
+    const TEXTURE_TRILINEAR_SAMPLINGMODE: number;
+    const TEXTURE_NEAREST_NEAREST_MIPLINEAR: number;
+    const TEXTURE_LINEAR_LINEAR_MIPNEAREST: number;
+    const TEXTURE_LINEAR_LINEAR_MIPLINEAR: number;
+    const TEXTURE_NEAREST_NEAREST_MIPNEAREST: number;
+    const TEXTURE_NEAREST_LINEAR_MIPNEAREST: number;
+    const TEXTURE_NEAREST_LINEAR_MIPLINEAR: number;
+    const TEXTURE_NEAREST_LINEAR: number;
+    const TEXTURE_NEAREST_NEAREST: number;
+    const TEXTURE_LINEAR_NEAREST_MIPNEAREST: number;
+    const TEXTURE_LINEAR_NEAREST_MIPLINEAR: number;
+    const TEXTURE_LINEAR_LINEAR: number;
+    const TEXTURE_LINEAR_NEAREST: number;
+    const TEXTURE_EXPLICIT_MODE: number;
+    const TEXTURE_SPHERICAL_MODE: number;
+    const TEXTURE_PLANAR_MODE: number;
+    const TEXTURE_CUBIC_MODE: number;
+    const TEXTURE_PROJECTION_MODE: number;
+    const TEXTURE_SKYBOX_MODE: number;
+    const TEXTURE_INVCUBIC_MODE: number;
+    const TEXTURE_EQUIRECTANGULAR_MODE: number;
+    const TEXTURE_FIXED_EQUIRECTANGULAR_MODE: number;
+    const TEXTURE_FIXED_EQUIRECTANGULAR_MIRRORED_MODE: number;
+    const SCALEMODE_FLOOR: number;
+    const SCALEMODE_NEAREST: number;
+    const SCALEMODE_CEILING: number;
+    const _RescalePostProcessFactory: any;
+    const _RenderPassIdCounter: number;
+}
+import { ThinEngine } from "./thinEngine.js";
+import { Observable } from "../Misc/observable.js";
+import { PerfCounter } from "../Misc/perfCounter.js";
+import { PerformanceMonitor } from "../Misc/performanceMonitor.js";
+import { InternalTexture } from "../Materials/Textures/internalTexture.js";
+import { WebGLDataBuffer } from "../Meshes/WebGL/webGLDataBuffer.js";