@combeenation/3d-viewer 0.0.1-types

package/dist/types/node_modules/@babylonjs/core/Materials/Textures/rawTexture.d.ts

@@ -0,0 +1,138 @@
+/**
+ * Raw texture can help creating a texture directly from an array of data.
+ * This can be super useful if you either get the data from an uncompressed source or
+ * if you wish to create your texture pixel by pixel.
+ */
+export class RawTexture extends Texture {
+    /**
+     * Creates a luminance texture from some data.
+     * @param data Define the texture data
+     * @param width Define the width of the texture
+     * @param height Define the height of the texture
+     * @param sceneOrEngine defines the scene or engine the texture will belong to
+     * @param generateMipMaps Define whether or not to create mip maps for the texture
+     * @param invertY define if the data should be flipped on Y when uploaded to the GPU
+     * @param samplingMode define the texture sampling mode (Texture.xxx_SAMPLINGMODE)
+     * @returns the luminance texture
+     */
+    static CreateLuminanceTexture(data: any, width: any, height: any, sceneOrEngine: any, generateMipMaps?: boolean, invertY?: boolean, samplingMode?: number): RawTexture;
+    /**
+     * Creates a luminance alpha texture from some data.
+     * @param data Define the texture data
+     * @param width Define the width of the texture
+     * @param height Define the height of the texture
+     * @param sceneOrEngine defines the scene or engine the texture will belong to
+     * @param generateMipMaps Define whether or not to create mip maps for the texture
+     * @param invertY define if the data should be flipped on Y when uploaded to the GPU
+     * @param samplingMode define the texture sampling mode (Texture.xxx_SAMPLINGMODE)
+     * @returns the luminance alpha texture
+     */
+    static CreateLuminanceAlphaTexture(data: any, width: any, height: any, sceneOrEngine: any, generateMipMaps?: boolean, invertY?: boolean, samplingMode?: number): RawTexture;
+    /**
+     * Creates an alpha texture from some data.
+     * @param data Define the texture data
+     * @param width Define the width of the texture
+     * @param height Define the height of the texture
+     * @param sceneOrEngine defines the scene or engine the texture will belong to
+     * @param generateMipMaps Define whether or not to create mip maps for the texture
+     * @param invertY define if the data should be flipped on Y when uploaded to the GPU
+     * @param samplingMode define the texture sampling mode (Texture.xxx_SAMPLINGMODE)
+     * @returns the alpha texture
+     */
+    static CreateAlphaTexture(data: any, width: any, height: any, sceneOrEngine: any, generateMipMaps?: boolean, invertY?: boolean, samplingMode?: number): RawTexture;
+    /**
+     * Creates a RGB texture from some data.
+     * @param data Define the texture data
+     * @param width Define the width of the texture
+     * @param height Define the height of the texture
+     * @param sceneOrEngine defines the scene or engine the texture will belong to
+     * @param generateMipMaps Define whether or not to create mip maps for the texture
+     * @param invertY define if the data should be flipped on Y when uploaded to the GPU
+     * @param samplingMode define the texture sampling mode (Texture.xxx_SAMPLINGMODE)
+     * @param type define the format of the data (int, float... Engine.TEXTURETYPE_xxx)
+     * @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 RGB alpha texture
+     */
+    static CreateRGBTexture(data: any, width: any, height: any, sceneOrEngine: any, generateMipMaps?: boolean, invertY?: boolean, samplingMode?: number, type?: number, creationFlags?: number, useSRGBBuffer?: boolean): RawTexture;
+    /**
+     * Creates a RGBA texture from some data.
+     * @param data Define the texture data
+     * @param width Define the width of the texture
+     * @param height Define the height of the texture
+     * @param sceneOrEngine defines the scene or engine the texture will belong to
+     * @param generateMipMaps Define whether or not to create mip maps for the texture
+     * @param invertY define if the data should be flipped on Y when uploaded to the GPU
+     * @param samplingMode define the texture sampling mode (Texture.xxx_SAMPLINGMODE)
+     * @param type define the format of the data (int, float... Engine.TEXTURETYPE_xxx)
+     * @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 RGBA texture
+     */
+    static CreateRGBATexture(data: any, width: any, height: any, sceneOrEngine: any, generateMipMaps?: boolean, invertY?: boolean, samplingMode?: number, type?: number, creationFlags?: number, useSRGBBuffer?: boolean): RawTexture;
+    /**
+     * Creates a RGBA storage texture from some data.
+     * @param data Define the texture data
+     * @param width Define the width of the texture
+     * @param height Define the height of the texture
+     * @param sceneOrEngine defines the scene or engine the texture will belong to
+     * @param generateMipMaps Define whether or not to create mip maps for the texture
+     * @param invertY define if the data should be flipped on Y when uploaded to the GPU
+     * @param samplingMode define the texture sampling mode (Texture.xxx_SAMPLINGMODE)
+     * @param type define the format of the data (int, float... Engine.TEXTURETYPE_xxx)
+     * @param useSRGBBuffer defines if the texture must be loaded in a sRGB GPU buffer (if supported by the GPU).
+     * @returns the RGBA texture
+     */
+    static CreateRGBAStorageTexture(data: any, width: any, height: any, sceneOrEngine: any, generateMipMaps?: boolean, invertY?: boolean, samplingMode?: number, type?: number, useSRGBBuffer?: boolean): RawTexture;
+    /**
+     * Creates a R texture from some data.
+     * @param data Define the texture data
+     * @param width Define the width of the texture
+     * @param height Define the height of the texture
+     * @param sceneOrEngine defines the scene or engine the texture will belong to
+     * @param generateMipMaps Define whether or not to create mip maps for the texture
+     * @param invertY define if the data should be flipped on Y when uploaded to the GPU
+     * @param samplingMode define the texture sampling mode (Texture.xxx_SAMPLINGMODE)
+     * @param type define the format of the data (int, float... Engine.TEXTURETYPE_xxx)
+     * @returns the R texture
+     */
+    static CreateRTexture(data: any, width: any, height: any, sceneOrEngine: any, generateMipMaps?: boolean, invertY?: boolean, samplingMode?: number, type?: number): RawTexture;
+    /**
+     * Creates a R storage texture from some data.
+     * @param data Define the texture data
+     * @param width Define the width of the texture
+     * @param height Define the height of the texture
+     * @param sceneOrEngine defines the scene or engine the texture will belong to
+     * @param generateMipMaps Define whether or not to create mip maps for the texture
+     * @param invertY define if the data should be flipped on Y when uploaded to the GPU
+     * @param samplingMode define the texture sampling mode (Texture.xxx_SAMPLINGMODE)
+     * @param type define the format of the data (int, float... Engine.TEXTURETYPE_xxx)
+     * @returns the R texture
+     */
+    static CreateRStorageTexture(data: any, width: any, height: any, sceneOrEngine: any, generateMipMaps?: boolean, invertY?: boolean, samplingMode?: number, type?: number): RawTexture;
+    /**
+     * Instantiates a new RawTexture.
+     * Raw texture can help creating a texture directly from an array of data.
+     * This can be super useful if you either get the data from an uncompressed source or
+     * if you wish to create your texture pixel by pixel.
+     * @param data define the array of data to use to create the texture (null to create an empty texture)
+     * @param width define the width of the texture
+     * @param height define the height of the texture
+     * @param format define the format of the data (RGB, RGBA... Engine.TEXTUREFORMAT_xxx)
+     * @param sceneOrEngine defines the scene or engine the texture will belong to
+     * @param generateMipMaps define whether mip maps should be generated or not
+     * @param invertY define if the data should be flipped on Y when uploaded to the GPU
+     * @param samplingMode define the texture sampling mode (Texture.xxx_SAMPLINGMODE)
+     * @param type define the format of the data (int, float... Engine.TEXTURETYPE_xxx)
+     * @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).
+     */
+    constructor(data: any, width: any, height: any, format: any, sceneOrEngine: any, generateMipMaps: boolean | undefined, invertY: boolean | undefined, samplingMode: number | undefined, type: number | undefined, creationFlags: any, useSRGBBuffer: any);
+    format: any;
+    /**
+     * Updates the texture underlying data.
+     * @param data Define the new data of the texture
+     */
+    update(data: any): void;
+}
+import { Texture } from "./texture.js";

package/dist/types/node_modules/@babylonjs/core/Materials/Textures/rawTexture2DArray.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Class used to store 2D array textures containing user data
+ */
+export class RawTexture2DArray extends Texture {
+    /**
+     * Creates a RGBA texture from some data.
+     * @param data Define the texture data
+     * @param width Define the width of the texture
+     * @param height Define the height of the texture
+     * @param depth defines the number of layers of the texture
+     * @param scene defines the scene the texture will belong to
+     * @param generateMipMaps Define whether or not to create mip maps for the texture
+     * @param invertY define if the data should be flipped on Y when uploaded to the GPU
+     * @param samplingMode define the texture sampling mode (Texture.xxx_SAMPLINGMODE)
+     * @param type define the format of the data (int, float... Engine.TEXTURETYPE_xxx)
+     * @returns the RGBA texture
+     */
+    static CreateRGBATexture(data: any, width: any, height: any, depth: any, scene: any, generateMipMaps?: boolean, invertY?: boolean, samplingMode?: number, type?: number): RawTexture2DArray;
+    /**
+     * Create a new RawTexture2DArray
+     * @param data defines the data of 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 texture format to use
+     * @param scene defines the hosting scene
+     * @param generateMipMaps defines a boolean indicating if mip levels should be generated (true by default)
+     * @param invertY defines if texture must be stored with Y axis inverted
+     * @param samplingMode defines the sampling mode to use (Texture.TRILINEAR_SAMPLINGMODE by default)
+     * @param textureType defines the texture Type (Engine.TEXTURETYPE_UNSIGNED_INT, Engine.TEXTURETYPE_FLOAT...)
+     */
+    constructor(data: any, width: any, height: any, depth: any, format: any, scene: any, generateMipMaps?: boolean, invertY?: boolean, samplingMode?: number, textureType?: number);
+    format: any;
+    _texture: any;
+    _depth: any;
+    /**
+     * Gets the number of layers of the texture
+     */
+    get depth(): any;
+    /**
+     * Update the texture with new data
+     * @param data defines the data to store in the texture
+     */
+    update(data: any): void;
+}
+import { Texture } from "./texture.js";

package/dist/types/node_modules/@babylonjs/core/Materials/Textures/rawTexture3D.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Class used to store 3D textures containing user data
+ */
+export class RawTexture3D extends Texture {
+    /**
+     * Create a new RawTexture3D
+     * @param data defines the data of 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 texture format to use
+     * @param scene defines the hosting scene
+     * @param generateMipMaps defines a boolean indicating if mip levels should be generated (true by default)
+     * @param invertY defines if texture must be stored with Y axis inverted
+     * @param samplingMode defines the sampling mode to use (Texture.TRILINEAR_SAMPLINGMODE by default)
+     * @param textureType defines the texture Type (Engine.TEXTURETYPE_UNSIGNED_INT, Engine.TEXTURETYPE_FLOAT...)
+     */
+    constructor(data: any, width: any, height: any, depth: any, format: any, scene: any, generateMipMaps?: boolean, invertY?: boolean, samplingMode?: number, textureType?: number);
+    format: any;
+    _texture: any;
+    /**
+     * Update the texture with new data
+     * @param data defines the data to store in the texture
+     */
+    update(data: any): void;
+}
+import { Texture } from "./texture.js";

package/dist/types/node_modules/@babylonjs/core/Materials/Textures/refractionTexture.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Creates a refraction texture used by refraction channel of the standard material.
+ * It is like a mirror but to see through a material.
+ * @see https://doc.babylonjs.com/how_to/reflect#refraction
+ */
+export class RefractionTexture extends RenderTargetTexture {
+    /**
+     * Creates a refraction texture used by refraction channel of the standard material.
+     * It is like a mirror but to see through a material.
+     * @see https://doc.babylonjs.com/how_to/reflect#refraction
+     * @param name Define the texture name
+     * @param size Define the size of the underlying texture
+     * @param scene Define the scene the refraction belongs to
+     * @param generateMipMaps Define if we need to generate mips level for the refraction
+     */
+    constructor(name: any, size: any, scene: any, generateMipMaps: any);
+    /**
+     * Define the reflection plane we want to use. The refractionPlane is usually set to the constructed refractor.
+     * It is possible to directly set the refractionPlane by directly using a Plane(a, b, c, d) where a, b and c give the plane normal vector (a, b, c) and d is a scalar displacement from the refractionPlane to the origin. However in all but the very simplest of situations it is more straight forward to set it to the refractor as stated in the doc.
+     * @see https://doc.babylonjs.com/how_to/reflect#refraction
+     */
+    refractionPlane: Plane;
+    /**
+     * Define how deep under the surface we should see.
+     */
+    depth: number;
+    /**
+     * Clone the refraction texture.
+     * @returns the cloned texture
+     */
+    clone(): RefractionTexture;
+}
+import { RenderTargetTexture } from "../../Materials/Textures/renderTargetTexture.js";
+import { Plane } from "../../Maths/math.plane.js";

package/dist/types/node_modules/@babylonjs/core/Materials/Textures/renderTargetTexture.d.ts

@@ -0,0 +1,360 @@
+/**
+ * This Helps creating a texture that will be created from a camera in your scene.
+ * It is basically a dynamic texture that could be used to create special effects for instance.
+ * Actually, It is the base of lot of effects in the framework like post process, shadows, effect layers and rendering pipelines...
+ */
+export class RenderTargetTexture extends Texture {
+    /**
+     * Instantiate a render target texture. This is mainly used to render of screen the scene to for instance apply post process
+     * or used a shadow, depth texture...
+     * @param name The friendly name of the texture
+     * @param size The size of the RTT (number if square, or {width: number, height:number} or {ratio:} to define a ratio from the main scene)
+     * @param scene The scene the RTT belongs to. The latest created scene will be used if not precised.
+     * @param generateMipMaps True if mip maps need to be generated after render.
+     * @param doNotChangeAspectRatio True to not change the aspect ratio of the scene in the RTT
+     * @param type The type of the buffer in the RTT (int, half float, float...)
+     * @param isCube True if a cube texture needs to be created
+     * @param samplingMode The sampling mode to be usedwith the render target (Linear, Nearest...)
+     * @param generateDepthBuffer True to generate a depth buffer
+     * @param generateStencilBuffer True to generate a stencil buffer
+     * @param isMulti True if multiple textures need to be created (Draw Buffers)
+     * @param format The internal format of the buffer in the RTT (RED, RG, RGB, RGBA, ALPHA...)
+     * @param delayAllocation if the texture allocation should be delayed (default: false)
+     * @param samples sample count to use when creating the RTT
+     * @param creationFlags specific flags to use when creating the texture (1 for storage textures, for eg)
+     * @param noColorTarget True to indicate that no color target should be created. Useful if you only want to write to the depth buffer, for eg
+     * @param useSRGBBuffer True to create a SRGB texture
+     */
+    constructor(name: any, size: any, scene: any, generateMipMaps: any, doNotChangeAspectRatio: boolean | undefined, type: number | undefined, isCube: boolean | undefined, samplingMode: number | undefined, generateDepthBuffer: boolean | undefined, generateStencilBuffer: boolean | undefined, isMulti: boolean | undefined, format: number | undefined, delayAllocation: boolean | undefined, samples: any, creationFlags: any, noColorTarget?: boolean, useSRGBBuffer?: boolean);
+    _unObserveRenderList: (() => void) | null;
+    _renderListHasChanged: (_functionName: any, previousLength: any) => void;
+    /**
+     * Define if particles should be rendered in your texture.
+     */
+    renderParticles: boolean;
+    /**
+     * Define if sprites should be rendered in your texture.
+     */
+    renderSprites: boolean;
+    /**
+     * Define if the camera viewport should be respected while rendering the texture or if the render should be done to the entire texture.
+     */
+    ignoreCameraViewport: boolean;
+    /**
+     * An event triggered when the texture is unbind.
+     */
+    onBeforeBindObservable: Observable<any>;
+    /**
+     * An event triggered when the texture is unbind.
+     */
+    onAfterUnbindObservable: Observable<any>;
+    /**
+     * An event triggered before rendering the texture
+     */
+    onBeforeRenderObservable: Observable<any>;
+    /**
+     * An event triggered after rendering the texture
+     */
+    onAfterRenderObservable: Observable<any>;
+    /**
+     * An event triggered after the texture clear
+     */
+    onClearObservable: Observable<any>;
+    /**
+     * An event triggered when the texture is resized.
+     */
+    onResizeObservable: Observable<any>;
+    /** @internal */
+    _cleared: boolean;
+    /**
+     * Skip the initial clear of the rtt at the beginning of the frame render loop
+     */
+    skipInitialClear: boolean;
+    _currentRefreshId: number;
+    _refreshRate: number;
+    _samples: number;
+    _canRescale: boolean;
+    _renderTarget: any;
+    /**
+     * Gets or sets the center of the bounding box associated with the texture (when in cube mode)
+     * It must define where the camera used to render the texture is set
+     */
+    boundingBoxPosition: Vector3;
+    set renderList(arg: any);
+    /**
+     * Use this list to define the list of mesh you want to render.
+     */
+    get renderList(): any;
+    name: any;
+    _initialSizeParameter: any;
+    _renderPassIds: any[] | undefined;
+    _isCubeData: boolean | undefined;
+    renderPassId: any;
+    _resizeObserver: import("@babylonjs/core").Nullable<import("../../Misc/observable.js").Observer<Engine>> | undefined;
+    _generateMipMaps: boolean | undefined;
+    _doNotChangeAspectRatio: boolean | undefined;
+    _renderingManager: RenderingManager | undefined;
+    _renderTargetOptions: {
+        generateMipMaps: any;
+        type: number;
+        format: number | undefined;
+        samplingMode: number;
+        generateDepthBuffer: boolean;
+        generateStencilBuffer: boolean;
+        samples: any;
+        creationFlags: any;
+        noColorTarget: boolean;
+        useSRGBBuffer: boolean;
+    } | undefined;
+    _textureMatrix: Matrix | undefined;
+    _texture: any;
+    set samples(arg: any);
+    /**
+     * Define the number of samples to use in case of MSAA.
+     * It defaults to one meaning no MSAA has been enabled.
+     */
+    get samples(): any;
+    _renderList: any;
+    /**
+     * Post-processes for this render target
+     */
+    get postProcesses(): any[] | undefined;
+    get _prePassEnabled(): any;
+    /**
+     * Set a after unbind callback in the texture.
+     * This has been kept for backward compatibility and use of onAfterUnbindObservable is recommended.
+     */
+    set onAfterUnbind(arg: any);
+    _onAfterUnbindObserver: import("@babylonjs/core").Nullable<import("../../Misc/observable.js").Observer<any>> | undefined;
+    /**
+     * Set a before render callback in the texture.
+     * This has been kept for backward compatibility and use of onBeforeRenderObservable is recommended.
+     */
+    set onBeforeRender(arg: any);
+    _onBeforeRenderObserver: import("@babylonjs/core").Nullable<import("../../Misc/observable.js").Observer<any>> | undefined;
+    /**
+     * Set a after render callback in the texture.
+     * This has been kept for backward compatibility and use of onAfterRenderObservable is recommended.
+     */
+    set onAfterRender(arg: any);
+    _onAfterRenderObserver: import("@babylonjs/core").Nullable<import("../../Misc/observable.js").Observer<any>> | undefined;
+    /**
+     * Set a clear callback in the texture.
+     * This has been kept for backward compatibility and use of onClearObservable is recommended.
+     */
+    set onClear(arg: any);
+    _onClearObserver: import("@babylonjs/core").Nullable<import("../../Misc/observable.js").Observer<any>> | undefined;
+    /**
+     * Gets the render pass ids used by the render target texture. For a single render target the array length will be 1, for a cube texture it will be 6 and for
+     * a 2D texture array it will return an array of ids the size of the 2D texture array
+     */
+    get renderPassIds(): any[] | undefined;
+    /**
+     * Gets the current value of the refreshId counter
+     */
+    get currentRefreshId(): number;
+    /**
+     * Sets a specific material to be used to render a mesh/a list of meshes in this render target texture
+     * @param mesh mesh or array of meshes
+     * @param material material or array of materials to use for this render pass. If undefined is passed, no specific material will be used but the regular material instead (mesh.material). It's possible to provide an array of materials to use a different material for each rendering in the case of a cube texture (6 rendering) and a 2D texture array (as many rendering as the length of the array)
+     */
+    setMaterialForRendering(mesh: any, material: any): void;
+    /**
+     * Gets render target creation options that were used.
+     */
+    get renderTargetOptions(): {
+        generateMipMaps: any;
+        type: number;
+        format: number | undefined;
+        samplingMode: number;
+        generateDepthBuffer: boolean;
+        generateStencilBuffer: boolean;
+        samples: any;
+        creationFlags: any;
+        noColorTarget: boolean;
+        useSRGBBuffer: boolean;
+    } | undefined;
+    /**
+     * Gets the render target wrapper associated with this render target
+     */
+    get renderTarget(): any;
+    _onRatioRescale(): void;
+    /**
+     * Gets or sets the size of the bounding box associated with the texture (when in cube mode)
+     * When defined, the cubemap will switch to local mode
+     * @see https://community.arm.com/graphics/b/blog/posts/reflections-based-on-local-cubemaps-in-unity
+     * @example https://www.babylonjs-playground.com/#RNASML
+     */
+    set boundingBoxSize(arg: any);
+    get boundingBoxSize(): any;
+    _boundingBoxSize: any;
+    /**
+     * In case the RTT has been created with a depth texture, get the associated
+     * depth texture.
+     * Otherwise, return null.
+     */
+    get depthStencilTexture(): any;
+    /**
+     * Creates a depth stencil texture.
+     * This is only available in WebGL 2 or with the depth texture extension available.
+     * @param comparisonFunction Specifies the comparison function to set on the texture. If 0 or undefined, the texture is not in comparison mode (default: 0)
+     * @param bilinearFiltering Specifies whether or not bilinear filtering is enable on the texture (default: true)
+     * @param generateStencil Specifies whether or not a stencil should be allocated in the texture (default: false)
+     * @param samples sample count of the depth/stencil texture (default: 1)
+     * @param format format of the depth texture (default: 14)
+     */
+    createDepthStencilTexture(comparisonFunction?: number, bilinearFiltering?: boolean, generateStencil?: boolean, samples?: number, format?: number): void;
+    _releaseRenderPassId(): void;
+    _createRenderPassId(): void;
+    _processSizeParameter(size: any): void;
+    _sizeRatio: any;
+    _size: any;
+    /**
+     * Resets the refresh counter of the texture and start bak from scratch.
+     * Could be useful to regenerate the texture if it is setup to render only once.
+     */
+    resetRefreshCounter(): void;
+    set refreshRate(arg: number);
+    /**
+     * Define the refresh rate of the texture or the rendering frequency.
+     * Use 0 to render just once, 1 to render on every frame, 2 to render every two frames and so on...
+     */
+    get refreshRate(): number;
+    /**
+     * Adds a post process to the render target rendering passes.
+     * @param postProcess define the post process to add
+     */
+    addPostProcess(postProcess: any): void;
+    _postProcessManager: PostProcessManager | null | undefined;
+    _postProcesses: any[] | undefined;
+    /**
+     * Clear all the post processes attached to the render target
+     * @param dispose define if the cleared post processes should also be disposed (false by default)
+     */
+    clearPostProcesses(dispose?: boolean): void;
+    /**
+     * Remove one of the post process from the list of attached post processes to the texture
+     * @param postProcess define the post process to remove from the list
+     */
+    removePostProcess(postProcess: any): void;
+    /** @internal */
+    _shouldRender(): boolean;
+    /**
+     * Gets the actual render size of the texture.
+     * @returns the width of the render size
+     */
+    getRenderSize(): any;
+    /**
+     * Gets the actual render width of the texture.
+     * @returns the width of the render size
+     */
+    getRenderWidth(): any;
+    /**
+     * Gets the actual render height of the texture.
+     * @returns the height of the render size
+     */
+    getRenderHeight(): any;
+    /**
+     * Gets the actual number of layers of the texture.
+     * @returns the number of layers
+     */
+    getRenderLayers(): any;
+    /**
+     * Don't allow this render target texture to rescale. Mainly used to prevent rescaling by the scene optimizer.
+     */
+    disableRescaling(): void;
+    /**
+     * Resize the texture using a ratio.
+     * @param ratio the ratio to apply to the texture size in order to compute the new target size
+     */
+    scale(ratio: any): void;
+    /**
+     * Get the texture reflection matrix used to rotate/transform the reflection.
+     * @returns the reflection matrix
+     */
+    getReflectionTextureMatrix(): Matrix | undefined;
+    /**
+     * Resize the texture to a new desired size.
+     * Be careful as it will recreate all the data in the new texture.
+     * @param size Define the new size. It can be:
+     *   - a number for squared texture,
+     *   - an object containing { width: number, height: number }
+     *   - or an object containing a ratio { ratio: number }
+     */
+    resize(size: any): void;
+    /**
+     * Renders all the objects from the render list into the texture.
+     * @param useCameraPostProcess Define if camera post processes should be used during the rendering
+     * @param dumpForDebug Define if the rendering result should be dumped (copied) for debugging purpose
+     */
+    render(useCameraPostProcess?: boolean, dumpForDebug?: boolean): void;
+    /**
+     * This function will check if the render target texture can be rendered (textures are loaded, shaders are compiled)
+     * @returns true if all required resources are ready
+     */
+    isReadyForRendering(): boolean;
+    _render(useCameraPostProcess?: boolean, dumpForDebug?: boolean, checkReadiness?: boolean): boolean;
+    _waitingRenderList: any;
+    _defaultRenderListPrepared: boolean | undefined;
+    _bestReflectionRenderTargetDimension(renderDimension: any, scale: any): number;
+    _prepareRenderingManager(currentRenderList: any, currentRenderListLength: any, camera: any, checkLayerMask: any): void;
+    /**
+     * @internal
+     * @param faceIndex face index to bind to if this is a cubetexture
+     * @param layer defines the index of the texture to bind in the array
+     */
+    _bindFrameBuffer(faceIndex?: number, layer?: number): void;
+    _unbindFrameBuffer(engine: any, faceIndex: any): void;
+    /**
+     * @internal
+     */
+    _prepareFrame(scene: any, faceIndex: any, layer: any, useCameraPostProcess: any): void;
+    _renderToTarget(faceIndex: any, useCameraPostProcess: any, dumpForDebug: any, layer?: number, camera?: null): void;
+    /**
+     * Overrides the default sort function applied in the rendering group to prepare the meshes.
+     * This allowed control for front to back rendering or reversely depending of the special needs.
+     *
+     * @param renderingGroupId The rendering group id corresponding to its index
+     * @param opaqueSortCompareFn The opaque queue comparison function use to sort.
+     * @param alphaTestSortCompareFn The alpha test queue comparison function use to sort.
+     * @param transparentSortCompareFn The transparent queue comparison function use to sort.
+     */
+    setRenderingOrder(renderingGroupId: any, opaqueSortCompareFn?: null, alphaTestSortCompareFn?: null, transparentSortCompareFn?: null): void;
+    /**
+     * Specifies whether or not the stencil and depth buffer are cleared between two rendering groups.
+     *
+     * @param renderingGroupId The rendering group id corresponding to its index
+     * @param autoClearDepthStencil Automatically clears depth and stencil between groups if true.
+     */
+    setRenderingAutoClearDepthStencil(renderingGroupId: any, autoClearDepthStencil: any): void;
+    /**
+     * Clones the texture.
+     * @returns the cloned texture
+     */
+    clone(): RenderTargetTexture;
+    /**
+     *  This will remove the attached framebuffer objects. The texture will not be able to be used as render target anymore
+     */
+    disposeFramebufferObjects(): void;
+    /**
+     * Clear the info related to rendering groups preventing retention point in material dispose.
+     */
+    freeRenderingGroups(): void;
+    /**
+     * Gets the number of views the corresponding to the texture (eg. a MultiviewRenderTarget will have > 1)
+     * @returns the view count
+     */
+    getViewCount(): number;
+}
+export namespace RenderTargetTexture {
+    const REFRESHRATE_RENDER_ONCE: number;
+    const REFRESHRATE_RENDER_ONEVERYFRAME: number;
+    const REFRESHRATE_RENDER_ONEVERYTWOFRAMES: number;
+}
+import { Texture } from "../../Materials/Textures/texture.js";
+import { Observable } from "../../Misc/observable.js";
+import { Vector3 } from "../../Maths/math.vector.js";
+import { Engine } from "../../Engines/engine.js";
+import { RenderingManager } from "../../Rendering/renderingManager.js";
+import { Matrix } from "../../Maths/math.vector.js";
+import { PostProcessManager } from "../../PostProcesses/postProcessManager.js";