@babylonjs/core 6.33.1 → 6.34.0-alpha.0

package/esm/Engines/WebGL/engine.webgl.d.ts

@@ -0,0 +1,1030 @@
+import type { DataArray, IndicesArray, Nullable } from "../../../types.js";
+import type { IBaseEngineProtected, IBaseEnginePublic, IBaseEngineInternals, IBaseEngineOptions } from "../engine.base";
+import type { DataBuffer } from "../../../Buffers/dataBuffer.js";
+import type { IEffectCreationOptions } from "../../../Materials/effect.js";
+import { Effect } from "../../../Materials/effect.js";
+import type { IColor4Like, IViewportLike } from "../../../Maths/math.like.js";
+import { Constants } from "../engine.constants";
+import type { RenderTargetWrapper } from "../../../Engines/renderTargetWrapper.js";
+import { WebGLPipelineContext } from "../../../Engines/WebGL/webGLPipelineContext.js";
+import type { IPipelineContext } from "../../../Engines/IPipelineContext.js";
+import type { VertexBuffer } from "../../../Buffers/buffer.js";
+import type { InstancingAttributeInfo } from "../../../Engines/instancingAttributeInfo.js";
+import { InternalTextureSource, InternalTexture } from "../../../Materials/Textures/internalTexture.js";
+import type { RenderTargetTexture } from "../../../Materials/Textures/renderTargetTexture.js";
+import type { ThinTexture } from "../../../Materials/Textures/thinTexture.js";
+import type { ISceneLike } from "../engine.interfaces";
+import type { InternalTextureCreationOptions, TextureSize } from "../../../Materials/Textures/textureCreationOptions.js";
+import type { HardwareTextureWrapper } from "../../../Materials/Textures/hardwareTextureWrapper.js";
+import { DrawWrapper } from "../../../Materials/drawWrapper.js";
+import type { IEffectFallbacks } from "../../../Materials/iEffectFallbacks.js";
+import { ShaderLanguage } from "../../../Materials/shaderLanguage.js";
+import { StencilStateComposer } from "../../../States/stencilStateComposer.js";
+import { DepthCullingState } from "../../../States/depthCullingState.js";
+import type { ThinEngine } from "../../../Engines/thinEngine.js";
+import type { ShaderProcessingContext } from "../../../Engines/Processors/shaderProcessingOptions.js";
+import type { PostProcess } from "../../../PostProcesses/postProcess.js";
+import type { IShaderProcessor } from "../../../Engines/Processors/iShaderProcessor.js";
+import { PerfCounter } from "../../../Misc/perfCounter.js";
+import type { IStencilState } from "../../../States/IStencilState.js";
+interface IWebGLEngineProtected extends IBaseEngineProtected {
+    _currentProgram: Nullable<WebGLProgram>;
+    _cachedVertexBuffers: any;
+    _cachedIndexBuffer: Nullable<DataBuffer>;
+    _cachedEffectForVertexBuffers: Nullable<Effect>;
+    _currentBoundBuffer: Array<Nullable<DataBuffer>>;
+    _depthCullingState: DepthCullingState;
+    _stencilStateComposer: StencilStateComposer;
+    _creationOptions: IWebGLEngineOptions;
+}
+interface TexImageParameters {
+    internalFormat: number;
+    format: number;
+    type: number;
+}
+export interface IWebGLEngineInternals extends IBaseEngineInternals {
+    /** @internal */
+    _webGLVersion: number;
+    /** @internal */
+    _gl: WebGL2RenderingContext;
+    /** @internal */
+    _glSRGBExtensionValues: {
+        SRGB: typeof WebGL2RenderingContext.SRGB;
+        SRGB8: typeof WebGL2RenderingContext.SRGB8 | EXT_sRGB["SRGB_ALPHA_EXT"];
+        SRGB8_ALPHA8: typeof WebGL2RenderingContext.SRGB8_ALPHA8 | EXT_sRGB["SRGB_ALPHA_EXT"];
+    };
+    _currentFramebuffer: Nullable<WebGLFramebuffer>;
+    _dummyFramebuffer: Nullable<WebGLFramebuffer>;
+    _drawCalls: PerfCounter;
+}
+export interface IWebGLEnginePublic extends IBaseEnginePublic {
+    webGLVersion: number;
+    enableUnpackFlipYCached: boolean;
+}
+export interface IWebGLEngineOptions extends IBaseEngineOptions, WebGLContextAttributes {
+    /**
+     * If sRGB Buffer support is not set during construction, use this value to force a specific state
+     * This is added due to an issue when processing textures in chrome/edge/firefox
+     * This will not influence NativeEngine and WebGPUEngine which set the behavior to true during construction.
+     */
+    forceSRGBBufferSupportState?: boolean;
+    /**
+     * Defines that engine should compile shaders with high precision floats (if supported). True by default
+     */
+    useHighPrecisionFloats?: boolean;
+    /**
+     * Defines if webgl2 should be turned off even if supported
+     * @see https://doc.babylonjs.com/setup/support/webGL2
+     */
+    disableWebGL2Support?: boolean;
+    /**
+     * Defines if the gl context should be released.
+     * It's false by default for backward compatibility, but you should probably pass true (see https://registry.khronos.org/webgl/extensions/WEBGL_lose_context/)
+     */
+    loseContextOnDispose?: boolean;
+}
+export type WebGLEngineState = IWebGLEnginePublic & IWebGLEngineInternals & IWebGLEngineProtected;
+export declare function initWebGLEngineState(canvasOrContext: Nullable<HTMLCanvasElement | OffscreenCanvas | WebGLRenderingContext | WebGL2RenderingContext>, options?: IWebGLEngineOptions): WebGLEngineState;
+export declare function _getShaderProcessor(engineState: IWebGLEnginePublic, _shaderLanguage: ShaderLanguage): Nullable<IShaderProcessor>;
+/**
+ * Gets an object containing information about the current webGL context
+ * @param engineState defines the engine state
+ * @returns an object containing the vendor, the renderer and the version of the current webGL context
+ */
+export declare function getGlInfo(engineState: IWebGLEnginePublic): {
+    glVersion: string;
+    glRenderer: string;
+    glVendor: string;
+};
+/**
+ * Gets the current render width
+ * @param engineState defines the engine state
+ * @param useScreen defines if screen size must be used (or the current render target if any)
+ * @returns a number defining the current render width
+ */
+export declare function getRenderWidth(engineState: IWebGLEnginePublic, useScreen?: boolean): number;
+/**
+ * Gets the current render height
+ * @param engineState defines the engine state
+ * @param useScreen defines if screen size must be used (or the current render target if any)
+ * @returns a number defining the current render height
+ */
+export declare function getRenderHeight(engineState: IWebGLEnginePublic, useScreen?: boolean): number;
+/**
+ * End the current frame
+ * @param engineState defines the engine state
+ */
+export declare function endFrame(engineState: IWebGLEnginePublic): void;
+/**
+ * Clear the current render buffer or the current render target (if any is set up)
+ * @param engineState defines the engine state
+ * @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
+ */
+export declare function clear(engineState: IWebGLEnginePublic, color: Nullable<IColor4Like>, backBuffer: boolean, depth: boolean, stencil?: boolean): void;
+/**
+ * Apply all cached states (depth, culling, stencil and alpha)
+ */
+export declare function applyStates(engineState: IWebGLEnginePublic): void;
+/**
+ * Force a WebGPU flush (ie. a flush of all waiting commands)
+ * @param reopenPass true to reopen at the end of the function the pass that was active when entering the function
+ */
+export declare function flushFramebuffer(engineState: IWebGLEnginePublic): void;
+export declare const setViewport: (engineState: IWebGLEnginePublic, viewport: IViewportLike, requiredWidth?: number, requiredHeight?: number) => void;
+/**
+ * Binds the frame buffer to the specified texture.
+ * @param rtWrapper The render target wrapper to render to
+ * @param faceIndex The face of the texture to render to in case of cube texture and if the render target wrapper is not a multi render target
+ * @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 the frame buffer if the render target wrapper is not a multi render target
+ */
+export declare function bindFramebuffer(engineState: IWebGLEnginePublic, rtWrapper: RenderTargetWrapper, faceIndex?: number, requiredWidth?: number, requiredHeight?: number, forceFullscreenViewport?: boolean, lodLevel?: number, layer?: number): void;
+/**
+ * @internal
+ */
+export declare function _viewport(engineState: IWebGLEnginePublic, x: number, y: number, width: number, height: number): void;
+/**
+ * @internal
+ */
+export declare function _bindUnboundFramebuffer(engineState: IWebGLEnginePublic, framebuffer: Nullable<WebGLFramebuffer>): 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
+ */
+export declare function unBindFramebuffer(engineState: IWebGLEnginePublic, texture: RenderTargetWrapper, disableGenerateMipMaps?: boolean, onBeforeUnbind?: () => void): void;
+/**
+ * Generates the mipmaps for a texture
+ * @param texture texture to generate the mipmaps for
+ */
+export declare function generateMipmaps(engineState: IWebGLEnginePublic, texture: InternalTexture): void;
+/**
+ * Unbind the current render target and bind the default framebuffer
+ */
+export declare function restoreDefaultFramebuffer(engineState: IWebGLEnginePublic): void;
+/**
+ * Bind a webGL buffer to the webGL context
+ * @param buffer defines the buffer to bind
+ */
+export declare function bindArrayBuffer(engineState: IWebGLEnginePublic, buffer: Nullable<DataBuffer>): void;
+/** @internal */
+export declare function _resetVertexBufferBinding(engineState: IWebGLEnginePublic): void;
+/**
+ * Creates a dynamic vertex buffer
+ * @param data the data for the dynamic vertex buffer
+ * @param _label defines the label of the buffer (for debug purpose)
+ * @returns the new WebGL dynamic buffer
+ */
+export declare function createDynamicVertexBuffer(engineState: IWebGLEnginePublic, data: DataArray, _label?: string): DataBuffer;
+/**
+ * Creates a vertex buffer
+ * @param data the data for the vertex buffer
+ * @param _updatable whether the buffer should be created as updatable
+ * @param _label defines the label of the buffer (for debug purpose)
+ * @returns the new WebGL static buffer
+ */
+export declare function createVertexBuffer(engineState: IWebGLEnginePublic, data: DataArray, _updatable?: boolean, _label?: string): DataBuffer;
+/**
+ * @internal
+ */
+export declare function _resetIndexBufferBinding(engineState: IWebGLEnginePublic): void;
+/**
+ * Creates a new index buffer
+ * @param indices defines the content of the index buffer
+ * @param updatable defines if the index buffer must be updatable
+ * @param _label defines the label of the buffer (for debug purpose)
+ * @returns a new webGL buffer
+ */
+export declare function createIndexBuffer(engineState: IWebGLEnginePublic, indices: IndicesArray, updatable?: boolean, _label?: string): DataBuffer;
+/**
+ * @internal
+ */
+export declare function _normalizeIndexData(engineState: IWebGLEnginePublic, indices: IndicesArray): Uint16Array | Uint32Array;
+/**
+ * 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
+ */
+export declare function bindUniformBlock(engineState: IWebGLEnginePublic, pipelineContext: IPipelineContext, blockName: string, index: number): void;
+/**
+ * was bindIndexBuffer
+ * @internal
+ */
+export declare function _bindIndexBuffer(engineState: IWebGLEnginePublic, buffer: Nullable<DataBuffer>): void;
+/**
+ * update the bound buffer with the given data
+ * @param data defines the data to update
+ */
+export declare function updateArrayBuffer(engineState: IWebGLEnginePublic, data: Float32Array): void;
+/**
+ * @internal
+ */
+export declare function _bindIndexBufferWithCache(engineState: IWebGLEnginePublic, indexBuffer: Nullable<DataBuffer>): void;
+/**
+ * Records a vertex array object
+ * @see https://doc.babylonjs.com/setup/support/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
+ */
+export declare function recordVertexArrayObject(engineState: IWebGLEnginePublic, vertexBuffers: {
+    [key: string]: VertexBuffer;
+}, indexBuffer: Nullable<DataBuffer>, effect: Effect, overrideVertexBuffers?: {
+    [kind: string]: Nullable<VertexBuffer>;
+}): WebGLVertexArrayObject;
+/**
+ * Bind a specific vertex array object
+ * @see https://doc.babylonjs.com/setup/support/webGL2#vertex-array-objects
+ * @param vertexArrayObject defines the vertex array object to bind
+ * @param indexBuffer defines the index buffer to bind
+ */
+export declare function bindVertexArrayObject(engineState: IWebGLEnginePublic, vertexArrayObject: WebGLVertexArrayObject, indexBuffer: Nullable<DataBuffer>): void;
+/**
+ * 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
+ */
+export declare function bindBuffersDirectly(engineState: IWebGLEnginePublic, vertexBuffer: DataBuffer, indexBuffer: DataBuffer, vertexDeclaration: number[], vertexStrideSize: number, effect: Effect): 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
+ */
+export declare function bindBuffers(engineState: IWebGLEnginePublic, vertexBuffers: {
+    [key: string]: Nullable<VertexBuffer>;
+}, indexBuffer: Nullable<DataBuffer>, effect: Effect, overrideVertexBuffers?: {
+    [kind: string]: Nullable<VertexBuffer>;
+}): void;
+/**
+ * Unbind all instance attributes
+ */
+export declare function unbindInstanceAttributes(engineState: IWebGLEnginePublic): void;
+/**
+ * Release and free the memory of a vertex array object
+ * @param vao defines the vertex array object to delete
+ */
+export declare function releaseVertexArrayObject(engineState: IWebGLEnginePublic, vao: WebGLVertexArrayObject): void;
+/**
+ * @internal
+ */
+export declare function _releaseBuffer(engineState: IWebGLEnginePublic, buffer: DataBuffer): boolean;
+export declare function _deleteBuffer(engineState: IWebGLEnginePublic, buffer: DataBuffer): 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
+ */
+export declare function updateAndBindInstancesBuffer(engineState: IWebGLEnginePublic, instancesBuffer: DataBuffer, data: Float32Array, offsetLocations: number[] | InstancingAttributeInfo[]): 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
+ */
+export declare function bindInstancesBuffer(engineState: IWebGLEnginePublic, instancesBuffer: DataBuffer, attributesInfo: InstancingAttributeInfo[], computeStride?: boolean): void;
+/**
+ * Disable the instance attribute corresponding to the name in parameter
+ * @param name defines the name of the attribute to disable
+ */
+export declare function disableInstanceAttributeByName(engineState: IWebGLEnginePublic, name: string): void;
+/**
+ * Disable the instance attribute corresponding to the location in parameter
+ * @param attributeLocation defines the attribute location of the attribute to disable
+ */
+export declare function disableInstanceAttribute(engineState: IWebGLEnginePublic, attributeLocation: number): void;
+/**
+ * Disable the attribute corresponding to the location in parameter
+ * @param attributeLocation defines the attribute location of the attribute to disable
+ */
+export declare function disableAttributeByIndex(engineState: IWebGLEnginePublic, attributeLocation: number): 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)
+ */
+export declare function drawElementsType(engineState: IWebGLEnginePublic, fillMode: number, indexStart: number, indexCount: number, instancesCount?: number): 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)
+ */
+export declare function drawArraysType(engineState: IWebGLEnginePublic, fillMode: number, verticesStart: number, verticesCount: number, instancesCount?: number): void;
+/**
+ * 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
+ */
+export declare function createEffect(engineState: IWebGLEnginePublic, baseName: any, attributesNamesOrOptions: string[] | IEffectCreationOptions, uniformsNamesOrEngine: string[] | ThinEngine, samplers?: string[], defines?: string, fallbacks?: IEffectFallbacks, onCompiled?: Nullable<(effect: Effect) => void>, onError?: Nullable<(effect: Effect, errors: string) => void>, indexParameters?: any, shaderLanguage?: ShaderLanguage): Effect;
+/**
+ * @internal
+ */
+export declare function _getShaderSource(engineState: IWebGLEnginePublic, shader: WebGLShader): Nullable<string>;
+/**
+ * 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
+ */
+export declare function createRawShaderProgram(engineState: IWebGLEnginePublic, pipelineContext: IPipelineContext, vertexCode: string, fragmentCode: string, context?: WebGLRenderingContext, transformFeedbackVaryings?: Nullable<string[]>): WebGLProgram;
+/**
+ * @internal
+ */
+export declare function _deletePipelineContext(engineState: IWebGLEnginePublic, pipelineContext: IPipelineContext): void;
+/**
+ * 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
+ */
+export declare function createThinShaderProgram(engineState: IWebGLEnginePublic, pipelineContext: IPipelineContext, vertexCode: string, fragmentCode: string, defines: Nullable<string>, context?: WebGLRenderingContext, transformFeedbackVaryings?: Nullable<string[]>): WebGLProgram;
+export declare function createShaderProgram(engineState: IWebGLEnginePublic, pipelineContext: IPipelineContext, vertexCode: string, fragmentCode: string, defines: Nullable<string>, context?: WebGLRenderingContext, transformFeedbackVaryings?: Nullable<string[]>): WebGLProgram;
+/**
+ * Creates a new pipeline context
+ * @param shaderProcessingContext defines the shader processing context used during the processing if available
+ * @returns the new pipeline
+ */
+export declare function createPipelineContext(engineState: IWebGLEnginePublic, shaderProcessingContext: Nullable<ShaderProcessingContext>): IPipelineContext;
+/**
+ * @internal
+ */
+export declare function _getUseSRGBBuffer(engineState: IWebGLEnginePublic, useSRGBBuffer: boolean, noMipmap: boolean): boolean;
+export declare function _createShaderProgramThin(engineState: WebGLEngineState, pipelineContext: WebGLPipelineContext, vertexShader: WebGLShader, fragmentShader: WebGLShader, context: WebGLRenderingContext, _transformFeedbackVaryings?: Nullable<string[]>): WebGLProgram;
+export declare function _createShaderProgram(engineState: WebGLEngineState, pipelineContext: WebGLPipelineContext, vertexShader: WebGLShader, fragmentShader: WebGLShader, context: WebGLRenderingContext, transformFeedbackVaryings?: Nullable<string[]>): WebGLProgram;
+export declare function _finalizePipelineContext(engineState: WebGLEngineState, pipelineContext: WebGLPipelineContext): void;
+/**
+ * @internal
+ */
+export declare function _preparePipelineContext(engineState: IWebGLEnginePublic, pipelineContext: IPipelineContext, vertexSourceCode: string, fragmentSourceCode: string, createAsRaw: boolean, _rawVertexSourceCode: string, _rawFragmentSourceCode: string, rebuildRebind: any, defines: Nullable<string>, transformFeedbackVaryings: Nullable<string[]>, _key: string): void;
+/**
+ * @internal
+ */
+export declare function _isRenderingStateCompiled(engineState: IWebGLEnginePublic, pipelineContext: IPipelineContext): boolean;
+/**
+ * @internal
+ */
+export declare function _executeWhenRenderingStateIsCompiled(_engineState: IWebGLEnginePublic, pipelineContext: IPipelineContext, action: () => void): 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
+ */
+export declare function getUniforms(engineState: IWebGLEnginePublic, pipelineContext: IPipelineContext, uniformsNames: string[]): Nullable<WebGLUniformLocation>[];
+/**
+ * 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
+ */
+export declare function getAttributes(engineState: IWebGLEnginePublic, pipelineContext: IPipelineContext, attributesNames: string[]): number[];
+/**
+ * Activates an effect, making it the current one (ie. the one used for rendering)
+ * @param effect defines the effect to activate
+ */
+export declare function enableEffect(engineState: IWebGLEnginePublic, effect: Nullable<Effect | DrawWrapper>): 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)
+ */
+export declare function wipeCaches(engineState: IWebGLEnginePublic, bruteForce?: boolean): void;
+/**
+ * @internal
+ */
+export declare function _getSamplingParameters(engineState: WebGLEngineState, samplingMode: number, generateMipMaps: boolean): {
+    min: number;
+    mag: number;
+};
+/** @internal */
+export declare function _createTexture(engineState: WebGLEngineState): WebGLTexture;
+/** @internal */
+export declare function _createHardwareTexture(engineState: WebGLEngineState): HardwareTextureWrapper;
+/**
+ * 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
+ */
+export declare function _createInternalTexture(engineState: IWebGLEnginePublic, size: TextureSize, options: boolean | InternalTextureCreationOptions, _delayGPUTextureCreation?: boolean, source?: InternalTextureSource): 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 (Constants.TEXTURE_CREATIONFLAG_STORAGE 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
+ */
+export declare function createTexture(engineState: IWebGLEnginePublic, url: Nullable<string>, noMipmap: boolean, invertY: boolean, scene: Nullable<ISceneLike>, samplingMode?: number, onLoad?: Nullable<(texture: InternalTexture) => void>, onError?: Nullable<(message: string, exception: any) => void>, buffer?: Nullable<string | ArrayBuffer | ArrayBufferView | HTMLImageElement | Blob | ImageBitmap>, fallback?: Nullable<InternalTexture>, format?: Nullable<number>, forcedExtension?: Nullable<string>, mimeType?: string, loaderOptions?: any, creationFlags?: number, useSRGBBuffer?: boolean): InternalTexture;
+/**
+ * Calls to the GL texImage2D and texImage3D functions require three arguments describing the pixel format of the texture.
+ * createTexture derives these from the babylonFormat and useSRGBBuffer arguments and also the file extension of the URL it's working with.
+ * This function encapsulates that derivation for easy unit testing.
+ * @param babylonFormat Babylon's format enum, as specified in ITextureCreationOptions.
+ * @param fileExtension The file extension including the dot, e.g. .jpg.
+ * @param useSRGBBuffer Use SRGB not linear.
+ * @returns The options to pass to texImage2D or texImage3D calls.
+ * @internal
+ */
+export declare function _getTexImageParametersForCreateTexture(engineState: IWebGLEnginePublic, babylonFormat: Nullable<number>, fileExtension: string, useSRGBBuffer: boolean): TexImageParameters;
+/**
+ * @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
+ */
+export declare function _rescaleTexture(engineState: IWebGLEnginePublic, source: InternalTexture, destination: InternalTexture, scene: Nullable<any>, internalFormat: number, onComplete: () => void): void;
+/**
+ * @internal
+ */
+export declare function _unpackFlipY(engineState: IWebGLEnginePublic, value: boolean): void;
+/** @internal */
+export declare function _getUnpackAlignement(engineState: IWebGLEnginePublic): number;
+export declare function _getTextureTarget(engineState: IWebGLEnginePublic, texture: InternalTexture): number;
+/**
+ * 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
+ */
+export declare function updateTextureSamplingMode(engineState: IWebGLEnginePublic, samplingMode: number, texture: InternalTexture, generateMipMaps?: boolean): 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
+ */
+export declare function updateTextureWrappingMode(engineState: IWebGLEnginePublic, texture: InternalTexture, wrapU: Nullable<number>, wrapV?: Nullable<number>, wrapR?: Nullable<number>): void;
+/**
+ * @internal
+ */
+export declare function _setupDepthStencilTexture(engineState: IWebGLEnginePublic, internalTexture: InternalTexture, size: number | {
+    width: number;
+    height: number;
+    layers?: number;
+}, generateStencil: boolean, bilinearFiltering: boolean, comparisonFunction: number, samples?: number): void;
+/**
+ * @internal
+ */
+export declare function _uploadCompressedDataToTextureDirectly(engineState: IWebGLEnginePublic, texture: InternalTexture, internalFormat: number, width: number, height: number, data: ArrayBufferView, faceIndex?: number, lod?: number): void;
+/**
+ * @internal
+ */
+export declare function _uploadDataToTextureDirectly(engineState: IWebGLEnginePublic, texture: InternalTexture, imageData: ArrayBufferView, faceIndex?: number, lod?: number, babylonInternalFormat?: number, 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
+ */
+export declare function updateTextureData(engineState: IWebGLEnginePublic, texture: InternalTexture, imageData: ArrayBufferView, xOffset: number, yOffset: number, width: number, height: number, faceIndex?: number, lod?: number, generateMipMaps?: boolean): void;
+/**
+ * @internal
+ */
+export declare function _uploadArrayBufferViewToTexture(engineState: IWebGLEnginePublic, texture: InternalTexture, imageData: ArrayBufferView, faceIndex?: number, lod?: number): void;
+export declare function _prepareWebGLTextureContinuation(engineState: IWebGLEnginePublic, texture: InternalTexture, scene: Nullable<ISceneLike>, noMipmap: boolean, isCompressed: boolean, samplingMode: number): void;
+/**
+ * @internal
+ */
+export declare function _setupFramebufferDepthAttachments(engineState: IWebGLEnginePublic, generateStencilBuffer: boolean, generateDepthBuffer: boolean, width: number, height: number, samples?: number): Nullable<WebGLRenderbuffer>;
+/**
+ * @internal
+ */
+export declare function _createRenderBuffer(engineState: IWebGLEnginePublic, width: number, height: number, samples: number, internalFormat: number, msInternalFormat: number, attachment: number, unbindBuffer?: boolean): Nullable<WebGLRenderbuffer>;
+/**
+ * @internal
+ */
+export declare function _updateRenderBuffer(engineState: IWebGLEnginePublic, renderBuffer: Nullable<WebGLRenderbuffer>, width: number, height: number, samples: number, internalFormat: number, msInternalFormat: number, attachment: number, unbindBuffer?: boolean): Nullable<WebGLRenderbuffer>;
+/**
+ * @internal
+ */
+export declare function _releaseTexture(engineState: IWebGLEnginePublic, texture: InternalTexture): void;
+export declare function _deleteTexture(engineState: IWebGLEnginePublic, texture: Nullable<WebGLTexture>): void;
+export declare function _setProgram(engineState: IWebGLEnginePublic, program: WebGLProgram): void;
+/**
+ * Binds an effect to the webGL context
+ * @param effect defines the effect to bind
+ */
+export declare function bindSamplers(engineState: IWebGLEnginePublic, effect: Effect): void;
+/**
+ * @internal
+ */
+export declare function _bindTextureDirectly(engineState: IWebGLEnginePublic, target: number, texture: Nullable<InternalTexture>, forTextureDataUpdate?: boolean, force?: boolean): boolean;
+/**
+ * @internal
+ */
+export declare function _bindTexture(engineState: IWebGLEnginePublic, channel: number, texture: Nullable<InternalTexture>, name: string): void;
+/**
+ * Unbind all textures from the webGL context
+ */
+export declare function unbindAllTextures(engineState: IWebGLEnginePublic): 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
+ */
+export declare function setTexture(engineState: IWebGLEnginePublic, channel: number, uniform: Nullable<WebGLUniformLocation>, texture: Nullable<ThinTexture>, name: string): void;
+export declare function _setTexture(engineState: IWebGLEnginePublic, channel: number, texture: Nullable<ThinTexture>, 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
+ */
+export declare function setTextureArray(engineState: IWebGLEnginePublic, channel: number, uniform: Nullable<WebGLUniformLocation>, textures: ThinTexture[], name: string): void;
+/**
+ * @internal
+ */
+export declare function _setAnisotropicLevel(engineState: IWebGLEnginePublic, target: number, internalTexture: InternalTexture, anisotropicFilteringLevel: number): void;
+export declare function _setTextureParameterFloat(engineState: IWebGLEnginePublic, target: number, parameter: number, value: number, texture: InternalTexture): void;
+export declare function _setTextureParameterInteger(engineState: IWebGLEnginePublic, target: number, parameter: number, value: number, texture?: InternalTexture): void;
+/**
+ * Unbind all vertex attributes from the webGL context
+ */
+export declare function unbindAllAttributes(engineState: IWebGLEnginePublic): 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
+ */
+export declare function releaseEffects(engineState: IWebGLEnginePublic): void;
+/**
+ * Attach a new callback raised when context lost event is fired
+ * @param callback defines the callback to call
+ */
+export declare function attachContextLostEvent(engineState: IWebGLEnginePublic, callback: (event: WebGLContextEvent) => void): void;
+/**
+ * Attach a new callback raised when context restored event is fired
+ * @param callback defines the callback to call
+ */
+export declare function attachContextRestoredEvent(engineState: IWebGLEnginePublic, callback: (event: WebGLContextEvent) => void): 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
+ */
+export declare function getError(engineState: IWebGLEnginePublic): number;
+export declare function _initGLContext(engineState: IWebGLEnginePublic): void;
+export declare function _initFeatures(engineState: IWebGLEnginePublic): void;
+/**
+ * @internal
+ */
+export declare function _getWebGLTextureType(engineState: IWebGLEnginePublic, type: number): number;
+/**
+ * @internal
+ */
+export declare function _getInternalFormat(engineState: IWebGLEnginePublic, format: number, useSRGBBuffer?: boolean): number;
+/**
+ * @internal
+ */
+export declare function _getRGBABufferInternalSizedFormat(engineState: IWebGLEnginePublic, type: number, format?: number, useSRGBBuffer?: boolean): number;
+/**
+ * @internal
+ */
+export declare function _getRGBAMultiSampleBufferFormat(engineState: IWebGLEnginePublic, type: number, format?: Constants): number;
+/**
+ * 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
+ */
+export declare function readPixels(engineState: IWebGLEnginePublic, x: number, y: number, width: number, height: number, hasAlpha?: boolean, flushRenderer?: boolean): Promise<ArrayBufferView>;
+/**
+ * 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
+ */
+export declare function setInt(engineState: IWebGLEnginePublic, uniform: Nullable<WebGLUniformLocation>, value: number): 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
+ */
+export declare function setInt2(engineState: IWebGLEnginePublic, uniform: Nullable<WebGLUniformLocation>, x: number, y: number): 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
+ */
+export declare function setInt3(engineState: IWebGLEnginePublic, uniform: Nullable<WebGLUniformLocation>, x: number, y: number, z: number): 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
+ */
+export declare function setInt4(engineState: IWebGLEnginePublic, uniform: Nullable<WebGLUniformLocation>, x: number, y: number, z: number, w: number): 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
+ */
+export declare function setIntArray(engineState: IWebGLEnginePublic, uniform: Nullable<WebGLUniformLocation>, array: Int32Array): 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
+ */
+export declare function setIntArray2(engineState: IWebGLEnginePublic, uniform: Nullable<WebGLUniformLocation>, array: Int32Array): 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
+ */
+export declare function setIntArray3(engineState: IWebGLEnginePublic, uniform: Nullable<WebGLUniformLocation>, array: Int32Array): 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
+ */
+export declare function setIntArray4(engineState: IWebGLEnginePublic, uniform: Nullable<WebGLUniformLocation>, array: Int32Array): boolean;
+/**
+ * Set the value of an uniform to a number (unsigned int)
+ * @param uniform defines the webGL uniform location where to store the value
+ * @param value defines the unsigned int number to store
+ * @returns true if the value was set
+ */
+export declare function setUInt(engineState: IWebGLEnginePublic, uniform: Nullable<WebGLUniformLocation>, value: number): boolean;
+/**
+ * Set the value of an uniform to a unsigned 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
+ */
+export declare function setUInt2(engineState: IWebGLEnginePublic, uniform: Nullable<WebGLUniformLocation>, x: number, y: number): boolean;
+/**
+ * Set the value of an uniform to a unsigned 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
+ */
+export declare function setUInt3(engineState: IWebGLEnginePublic, uniform: Nullable<WebGLUniformLocation>, x: number, y: number, z: number): boolean;
+/**
+ * Set the value of an uniform to a unsigned 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
+ */
+export declare function setUInt4(engineState: IWebGLEnginePublic, uniform: Nullable<WebGLUniformLocation>, x: number, y: number, z: number, w: number): boolean;
+/**
+ * Set the value of an uniform to an array of unsigned int32
+ * @param uniform defines the webGL uniform location where to store the value
+ * @param array defines the array of unsigned int32 to store
+ * @returns true if the value was set
+ */
+export declare function setUIntArray(engineState: IWebGLEnginePublic, uniform: Nullable<WebGLUniformLocation>, array: Uint32Array): boolean;
+/**
+ * Set the value of an uniform to an array of unsigned int32 (stored as vec2)
+ * @param uniform defines the webGL uniform location where to store the value
+ * @param array defines the array of unsigned int32 to store
+ * @returns true if the value was set
+ */
+export declare function setUIntArray2(engineState: IWebGLEnginePublic, uniform: Nullable<WebGLUniformLocation>, array: Uint32Array): boolean;
+/**
+ * Set the value of an uniform to an array of unsigned int32 (stored as vec3)
+ * @param uniform defines the webGL uniform location where to store the value
+ * @param array defines the array of unsigned int32 to store
+ * @returns true if the value was set
+ */
+export declare function setUIntArray3(engineState: IWebGLEnginePublic, uniform: Nullable<WebGLUniformLocation>, array: Uint32Array): boolean;
+/**
+ * Set the value of an uniform to an array of unsigned int32 (stored as vec4)
+ * @param uniform defines the webGL uniform location where to store the value
+ * @param array defines the array of unsigned int32 to store
+ * @returns true if the value was set
+ */
+export declare function setUIntArray4(engineState: IWebGLEnginePublic, uniform: Nullable<WebGLUniformLocation>, array: Uint32Array): 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
+ */
+export declare function setArray(engineState: IWebGLEnginePublic, uniform: Nullable<WebGLUniformLocation>, array: number[] | Float32Array): 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
+ */
+export declare function setArray2(engineState: IWebGLEnginePublic, uniform: Nullable<WebGLUniformLocation>, array: number[] | Float32Array): 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
+ */
+export declare function setArray3(engineState: IWebGLEnginePublic, uniform: Nullable<WebGLUniformLocation>, array: number[] | Float32Array): 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
+ */
+export declare function setArray4(engineState: IWebGLEnginePublic, uniform: Nullable<WebGLUniformLocation>, array: number[] | Float32Array): 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
+ */
+export declare function setMatrices(engineState: IWebGLEnginePublic, uniform: Nullable<WebGLUniformLocation>, matrices: Float32Array): 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
+ */
+export declare function setMatrix3x3(engineState: IWebGLEnginePublic, uniform: Nullable<WebGLUniformLocation>, matrix: Float32Array): 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
+ */
+export declare function setMatrix2x2(engineState: IWebGLEnginePublic, uniform: Nullable<WebGLUniformLocation>, matrix: Float32Array): 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
+ */
+export declare function setFloat(engineState: IWebGLEnginePublic, uniform: Nullable<WebGLUniformLocation>, value: number): 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
+ */
+export declare function setFloat2(engineState: IWebGLEnginePublic, uniform: Nullable<WebGLUniformLocation>, x: number, y: number): 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
+ */
+export declare function setFloat3(engineState: IWebGLEnginePublic, uniform: Nullable<WebGLUniformLocation>, x: number, y: number, z: number): 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
+ */
+export declare function setFloat4(engineState: IWebGLEnginePublic, uniform: Nullable<WebGLUniformLocation>, x: number, y: number, z: number, w: number): boolean;
+/**
+ * Dispose and release all associated resources
+ */
+export declare function dispose(engineState: IWebGLEnginePublic): void;
+/**
+ * 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.
+ */
+export declare function generateMipMapsForCubemap(engineState: IWebGLEnginePublic, texture: InternalTexture, unbind?: boolean): void;
+/**
+ * Sets a boolean indicating if the dithering state is enabled or disabled
+ * @param value defines the dithering state
+ */
+export declare function setDitheringState(engineState: IWebGLEnginePublic, value: boolean): void;
+/**
+ * Sets a boolean indicating if the rasterizer state is enabled or disabled
+ * @param value defines the rasterizer state
+ */
+export declare function setRasterizerState(engineState: IWebGLEnginePublic, value: boolean): 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
+ */
+export declare function setDirectViewport(engineState: IWebGLEnginePublic, x: number, y: number, width: number, height: number): Nullable<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
+ */
+export declare function scissorClear(engineState: IWebGLEnginePublic, x: number, y: number, width: number, height: number, clearColor: IColor4Like): 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
+ */
+export declare function enableScissor(engineState: IWebGLEnginePublic, x: number, y: number, width: number, height: number): void;
+/**
+ * Disable previously set scissor test rectangle
+ */
+export declare function disableScissor(engineState: IWebGLEnginePublic): void;
+/**
+ * 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
+ */
+export declare function getVertexShaderSource(engineState: IWebGLEnginePublic, program: WebGLProgram): Nullable<string>;
+/**
+ * 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
+ */
+export declare function getFragmentShaderSource(engineState: IWebGLEnginePublic, program: WebGLProgram): Nullable<string>;
+/**
+ * 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
+ */
+export declare function setDepthStencilTexture(engineState: IWebGLEnginePublic, channel: number, uniform: Nullable<WebGLUniformLocation>, texture: Nullable<RenderTargetTexture>, name?: string): 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
+ */
+export declare function setTextureFromPostProcess(engineState: IWebGLEnginePublic, channel: number, postProcess: Nullable<PostProcess>, name: string): 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
+ */
+export declare function setTextureFromPostProcessOutput(engineState: IWebGLEnginePublic, channel: number, postProcess: Nullable<PostProcess>, name: string): void;
+export declare function resize(engineState: IWebGLEnginePublic, forceSetSize?: boolean): void;
+export declare function setHardwareScalingLevel(engineState: IWebGLEnginePublic, level: number): 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
+ */
+export declare function setSize(engineState: IWebGLEnginePublic, width: number, height: number, forceSetSize?: boolean): boolean;
+/**
+ * Wraps an external web gl texture in a Babylon texture.
+ * @param texture defines the external texture
+ * @param hasMipMaps defines whether the external texture has mip maps (default: false)
+ * @param samplingMode defines the sampling mode for the external texture (default: Constants.Constants.TEXTURE_TRILINEAR_SAMPLINGMODE)
+ * @param width defines the width for the external texture (default: 0)
+ * @param height defines the height for the external texture (default: 0)
+ * @returns the babylon internal texture
+ */
+export declare function wrapWebGLTexture(engineState: IWebGLEnginePublic, texture: WebGLTexture, hasMipMaps?: boolean, samplingMode?: number, width?: number, height?: number): InternalTexture;
+/**
+ * @internal
+ */
+export declare function _uploadImageToTexture(engineState: IWebGLEnginePublic, texture: InternalTexture, image: HTMLImageElement | ImageBitmap, 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
+ */
+export declare function updateTextureComparisonFunction(engineState: IWebGLEnginePublic, texture: InternalTexture, comparisonFunction: number): void;
+/**
+ * Creates a webGL buffer to use with instantiation
+ * @param capacity defines the size of the buffer
+ * @returns the webGL buffer
+ */
+export declare function createInstancesBuffer(engineState: IWebGLEnginePublic, capacity: number): DataBuffer;
+/**
+ * Delete a webGL buffer used with instantiation
+ * @param buffer defines the webGL buffer to delete
+ */
+export declare function deleteInstancesBuffer(engineState: IWebGLEnginePublic, buffer: WebGLBuffer): void;
+/**
+ * @internal
+ */
+export declare function _readPixelsAsync(engineState: IWebGLEnginePublic, x: number, y: number, w: number, h: number, format: number, type: number, outputBuffer: ArrayBufferView): Promise<ArrayBufferView> | null;
+export declare function setState(engineState: IWebGLEnginePublic, culling: boolean, zOffset?: number, force?: boolean, reverseSide?: boolean, cullBackFaces?: boolean, stencil?: IStencilState, zOffsetUnits?: number): void;
+/**
+ * Gets a boolean indicating if depth testing is enabled
+ * @returns the current state
+ */
+export declare function getDepthBuffer(engineState: IWebGLEnginePublic): boolean;
+/**
+ * Enable or disable depth buffering
+ * @param enable defines the state to set
+ */
+export declare function setDepthBuffer(engineState: IWebGLEnginePublic, enable: boolean): void;
+/**
+ * Set the z offset Factor to apply to current rendering
+ * @param value defines the offset to apply
+ */
+export declare function setZOffset(engineState: IWebGLEnginePublic, value: number): void;
+/**
+ * Gets the current value of the zOffset Factor
+ * @returns the current zOffset Factor state
+ */
+export declare function getZOffset(engineState: IWebGLEnginePublic): number;
+/**
+ * Set the z offset Units to apply to current rendering
+ * @param value defines the offset to apply
+ */
+export declare function setZOffsetUnits(engineState: IWebGLEnginePublic, value: number): void;
+/**
+ * Gets the current value of the zOffset Units
+ * @returns the current zOffset Units state
+ */
+export declare function getZOffsetUnits(engineState: IWebGLEnginePublic): number;
+export declare function _releaseEffect(engineState: IWebGLEnginePublic, effect: Effect): void;
+export {};