@combeenation/3d-viewer 0.0.1-types

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

@@ -0,0 +1,274 @@
+/**
+ * This represents a texture in babylon. It can be easily loaded from a network, base64 or html input.
+ * @see https://doc.babylonjs.com/babylon101/materials#texture
+ */
+export class Texture extends BaseTexture {
+    /**
+     * Parse the JSON representation of a texture in order to recreate the texture in the given scene.
+     * @param parsedTexture Define the JSON representation of the texture
+     * @param scene Define the scene the parsed texture should be instantiated in
+     * @param rootUrl Define the root url of the parsing sequence in the case of relative dependencies
+     * @returns The parsed texture if successful
+     */
+    static Parse(parsedTexture: any, scene: any, rootUrl: any): any;
+    /**
+     * Creates a texture from its base 64 representation.
+     * @param data Define the base64 payload without the data: prefix
+     * @param name Define the name of the texture in the scene useful fo caching purpose for instance
+     * @param scene Define the scene the texture should belong to
+     * @param noMipmapOrOptions defines if the texture will require mip maps or not or set of all options to create the texture
+     * @param invertY define if the texture needs to be inverted on the y axis during loading
+     * @param samplingMode define the sampling mode we want for the texture while fetching from it (Texture.NEAREST_SAMPLINGMODE...)
+     * @param onLoad define a callback triggered when the texture has been loaded
+     * @param onError define a callback triggered when an error occurred during the loading session
+     * @param format define the format of the texture we are trying to load (Engine.TEXTUREFORMAT_RGBA...)
+     * @param creationFlags specific flags to use when creating the texture (1 for storage textures, for eg)
+     * @returns the created texture
+     */
+    static CreateFromBase64String(data: any, name: any, scene: any, noMipmapOrOptions: any, invertY: any, samplingMode: number | undefined, onLoad: null | undefined, onError: null | undefined, format: number | undefined, creationFlags: any): Texture;
+    /**
+     * Creates a texture from its data: representation. (data: will be added in case only the payload has been passed in)
+     * @param name Define the name of the texture in the scene useful fo caching purpose for instance
+     * @param buffer define the buffer to load the texture from in case the texture is loaded from a buffer representation
+     * @param scene Define the scene the texture should belong to
+     * @param deleteBuffer define if the buffer we are loading the texture from should be deleted after load
+     * @param noMipmapOrOptions defines if the texture will require mip maps or not or set of all options to create the texture
+     * @param invertY define if the texture needs to be inverted on the y axis during loading
+     * @param samplingMode define the sampling mode we want for the texture while fetching from it (Texture.NEAREST_SAMPLINGMODE...)
+     * @param onLoad define a callback triggered when the texture has been loaded
+     * @param onError define a callback triggered when an error occurred during the loading session
+     * @param format define the format of the texture we are trying to load (Engine.TEXTUREFORMAT_RGBA...)
+     * @param creationFlags specific flags to use when creating the texture (1 for storage textures, for eg)
+     * @returns the created texture
+     */
+    static LoadFromDataString(name: any, buffer: any, scene: any, deleteBuffer: boolean | undefined, noMipmapOrOptions: any, invertY: boolean | undefined, samplingMode: number | undefined, onLoad: null | undefined, onError: null | undefined, format: number | undefined, creationFlags: any): Texture;
+    /**
+     * Instantiates a new texture.
+     * This represents a texture in babylon. It can be easily loaded from a network, base64 or html input.
+     * @see https://doc.babylonjs.com/babylon101/materials#texture
+     * @param url defines the url of the picture to load as a texture
+     * @param sceneOrEngine defines the scene or engine the texture will belong to
+     * @param noMipmapOrOptions defines if the texture will require mip maps or not or set of all options to create the texture
+     * @param invertY defines if the texture needs to be inverted on the y axis during loading
+     * @param samplingMode defines the sampling mode we want for the texture while fetching from it (Texture.NEAREST_SAMPLINGMODE...)
+     * @param onLoad defines a callback triggered when the texture has been loaded
+     * @param onError defines a callback triggered when an error occurred during the loading session
+     * @param buffer defines the buffer to load the texture from in case the texture is loaded from a buffer representation
+     * @param deleteBuffer defines if the buffer we are loading the texture from should be deleted after load
+     * @param format defines the format of the texture we are trying to load (Engine.TEXTUREFORMAT_RGBA...)
+     * @param mimeType defines an optional mime type information
+     * @param loaderOptions options to be passed to the loader
+     * @param creationFlags specific flags to use when creating the texture (1 for storage textures, for eg)
+     * @param forcedExtension defines the extension to use to pick the right loader
+     */
+    constructor(url: any, sceneOrEngine: any, noMipmapOrOptions: any, invertY: any, samplingMode: number | undefined, onLoad: null | undefined, onError: null | undefined, buffer: null | undefined, deleteBuffer: boolean | undefined, format: any, mimeType: any, loaderOptions: any, creationFlags: any, forcedExtension: any);
+    /**
+     * Define the url of the texture.
+     */
+    url: any;
+    /**
+     * Define an offset on the texture to offset the u coordinates of the UVs
+     * @see https://doc.babylonjs.com/how_to/more_materials#offsetting
+     */
+    uOffset: number;
+    /**
+     * Define an offset on the texture to offset the v coordinates of the UVs
+     * @see https://doc.babylonjs.com/how_to/more_materials#offsetting
+     */
+    vOffset: number;
+    /**
+     * Define an offset on the texture to scale the u coordinates of the UVs
+     * @see https://doc.babylonjs.com/how_to/more_materials#tiling
+     */
+    uScale: number;
+    /**
+     * Define an offset on the texture to scale the v coordinates of the UVs
+     * @see https://doc.babylonjs.com/how_to/more_materials#tiling
+     */
+    vScale: number;
+    /**
+     * Define an offset on the texture to rotate around the u coordinates of the UVs
+     * The angle is defined in radians.
+     * @see https://doc.babylonjs.com/how_to/more_materials
+     */
+    uAng: number;
+    /**
+     * Define an offset on the texture to rotate around the v coordinates of the UVs
+     * The angle is defined in radians.
+     * @see https://doc.babylonjs.com/how_to/more_materials
+     */
+    vAng: number;
+    /**
+     * Define an offset on the texture to rotate around the w coordinates of the UVs (in case of 3d texture)
+     * The angle is defined in radians.
+     * @see https://doc.babylonjs.com/how_to/more_materials
+     */
+    wAng: number;
+    /**
+     * Defines the center of rotation (U)
+     */
+    uRotationCenter: number;
+    /**
+     * Defines the center of rotation (V)
+     */
+    vRotationCenter: number;
+    /**
+     * Defines the center of rotation (W)
+     */
+    wRotationCenter: number;
+    /**
+     * Sets this property to true to avoid deformations when rotating the texture with non-uniform scaling
+     */
+    homogeneousRotationInUVTransform: boolean;
+    /**
+     * List of inspectable custom properties (used by the Inspector)
+     * @see https://doc.babylonjs.com/how_to/debug_layer#extensibility
+     */
+    inspectableCustomProperties: any;
+    _noMipmap: any;
+    /** @internal */
+    _invertY: any;
+    _rowGenerationMatrix: Matrix | null;
+    _cachedTextureMatrix: Matrix | null;
+    _projectionModeMatrix: Matrix | null;
+    _t0: Vector3 | null;
+    _t1: Vector3 | null;
+    _t2: Vector3 | null;
+    _cachedUOffset: number;
+    _cachedVOffset: number;
+    _cachedUScale: number;
+    _cachedVScale: number;
+    _cachedUAng: number;
+    _cachedVAng: number;
+    _cachedWAng: number;
+    _cachedReflectionProjectionMatrixId: number;
+    _cachedURotationCenter: number;
+    _cachedVRotationCenter: number;
+    _cachedWRotationCenter: number;
+    _cachedHomogeneousRotationInUVTransform: boolean;
+    _cachedReflectionTextureMatrix: Matrix | null;
+    _cachedReflectionUOffset: number;
+    _cachedReflectionVOffset: number;
+    _cachedReflectionUScale: number;
+    _cachedReflectionVScale: number;
+    _cachedReflectionCoordinatesMode: number;
+    /** @internal */
+    _buffer: any;
+    _deleteBuffer: boolean;
+    _format: any;
+    _delayedOnLoad: (() => void) | null;
+    _delayedOnError: ((message: any, exception: any) => void) | null;
+    /**
+     * Observable triggered once the texture has been loaded.
+     */
+    onLoadObservable: Observable<any>;
+    _isBlocking: boolean;
+    name: any;
+    _mimeType: any;
+    _loaderOptions: any;
+    _creationFlags: any;
+    _useSRGBBuffer: boolean;
+    _forcedExtension: any;
+    _errorObject: {
+        message?: string | undefined;
+        exception?: any;
+    } | undefined;
+    _texture: any;
+    /**
+     * Are mip maps generated for this texture or not.
+     */
+    get noMipmap(): any;
+    /** Returns the texture mime type if it was defined by a loader (undefined else) */
+    get mimeType(): any;
+    /**
+     * Is the texture preventing material to render while loading.
+     * If false, a default texture will be used instead of the loading one during the preparation step.
+     */
+    set isBlocking(arg: boolean);
+    get isBlocking(): boolean;
+    /**
+     * Gets a boolean indicating if the texture needs to be inverted on the y axis during loading
+     */
+    get invertY(): any;
+    /**
+     * Update the url (and optional buffer) of this texture if url was null during construction.
+     * @param url the url of the texture
+     * @param buffer the buffer of the texture (defaults to null)
+     * @param onLoad callback called when the texture is loaded  (defaults to null)
+     * @param forcedExtension defines the extension to use to pick the right loader
+     */
+    updateURL(url: any, buffer: null | undefined, onLoad: any, forcedExtension: any): void;
+    _prepareRowForTextureGeneration(x: any, y: any, z: any, t: any): void;
+    /**
+     * Checks if the texture has the same transform matrix than another texture
+     * @param texture texture to check against
+     * @returns true if the transforms are the same, else false
+     */
+    checkTransformsAreIdentical(texture: any): boolean;
+    /**
+     * Get the current texture matrix which includes the requested offsetting, tiling and rotation components.
+     * @param uBase
+     * @returns the transform matrix of the texture.
+     */
+    getTextureMatrix(uBase?: number): Matrix | null;
+    /**
+     * Get the current matrix used to apply reflection. This is useful to rotate an environment texture for instance.
+     * @returns The reflection texture transform
+     */
+    getReflectionTextureMatrix(): Matrix | null;
+    /**
+     * Clones the texture.
+     * @returns the cloned texture
+     */
+    clone(): Texture;
+}
+export namespace Texture {
+    const SerializeBuffers: boolean;
+    const ForceSerializeBuffers: boolean;
+    const OnTextureLoadErrorObservable: Observable<any>;
+    /**
+     * @internal
+     */
+    function _CubeTextureParser(jsonTexture: any, scene: any, rootUrl: any): never;
+    /**
+     * @internal
+     */
+    function _CreateMirror(name: any, renderTargetSize: any, scene: any, generateMipMaps: any): never;
+    /**
+     * @internal
+     */
+    function _CreateRenderTargetTexture(name: any, renderTargetSize: any, scene: any, generateMipMaps: any, creationFlags: any): never;
+    const NEAREST_SAMPLINGMODE: number;
+    const NEAREST_NEAREST_MIPLINEAR: number;
+    const BILINEAR_SAMPLINGMODE: number;
+    const LINEAR_LINEAR_MIPNEAREST: number;
+    const TRILINEAR_SAMPLINGMODE: number;
+    const LINEAR_LINEAR_MIPLINEAR: number;
+    const NEAREST_NEAREST_MIPNEAREST: number;
+    const NEAREST_LINEAR_MIPNEAREST: number;
+    const NEAREST_LINEAR_MIPLINEAR: number;
+    const NEAREST_LINEAR: number;
+    const NEAREST_NEAREST: number;
+    const LINEAR_NEAREST_MIPNEAREST: number;
+    const LINEAR_NEAREST_MIPLINEAR: number;
+    const LINEAR_LINEAR: number;
+    const LINEAR_NEAREST: number;
+    const EXPLICIT_MODE: number;
+    const SPHERICAL_MODE: number;
+    const PLANAR_MODE: number;
+    const CUBIC_MODE: number;
+    const PROJECTION_MODE: number;
+    const SKYBOX_MODE: number;
+    const INVCUBIC_MODE: number;
+    const EQUIRECTANGULAR_MODE: number;
+    const FIXED_EQUIRECTANGULAR_MODE: number;
+    const FIXED_EQUIRECTANGULAR_MIRRORED_MODE: number;
+    const CLAMP_ADDRESSMODE: number;
+    const WRAP_ADDRESSMODE: number;
+    const MIRROR_ADDRESSMODE: number;
+    const UseSerializedUrlIfAny: boolean;
+}
+import { BaseTexture } from "../../Materials/Textures/baseTexture.js";
+import { Matrix } from "../../Maths/math.vector.js";
+import { Vector3 } from "../../Maths/math.vector.js";
+import { Observable } from "../../Misc/observable.js";

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,82 @@
+/**
+ * Class used to store a texture sampler data
+ */
+export class TextureSampler {
+    /**
+     * Gets the sampling mode of the texture
+     */
+    samplingMode: number;
+    _useMipMaps: boolean;
+    /** @internal */
+    _cachedWrapU: any;
+    /** @internal */
+    _cachedWrapV: any;
+    /** @internal */
+    _cachedWrapR: any;
+    /** @internal */
+    _cachedAnisotropicFilteringLevel: any;
+    /** @internal */
+    _comparisonFunction: number;
+    set wrapU(arg: any);
+    /**
+     * | Value | Type               | Description |
+     * | ----- | ------------------ | ----------- |
+     * | 0     | CLAMP_ADDRESSMODE  |             |
+     * | 1     | WRAP_ADDRESSMODE   |             |
+     * | 2     | MIRROR_ADDRESSMODE |             |
+     */
+    get wrapU(): any;
+    set wrapV(arg: any);
+    /**
+     * | Value | Type               | Description |
+     * | ----- | ------------------ | ----------- |
+     * | 0     | CLAMP_ADDRESSMODE  |             |
+     * | 1     | WRAP_ADDRESSMODE   |             |
+     * | 2     | MIRROR_ADDRESSMODE |             |
+     */
+    get wrapV(): any;
+    set wrapR(arg: any);
+    /**
+     * | Value | Type               | Description |
+     * | ----- | ------------------ | ----------- |
+     * | 0     | CLAMP_ADDRESSMODE  |             |
+     * | 1     | WRAP_ADDRESSMODE   |             |
+     * | 2     | MIRROR_ADDRESSMODE |             |
+     */
+    get wrapR(): any;
+    set anisotropicFilteringLevel(arg: any);
+    /**
+     * With compliant hardware and browser (supporting anisotropic filtering)
+     * this defines the level of anisotropic filtering in the texture.
+     * The higher the better but the slower.
+     */
+    get anisotropicFilteringLevel(): any;
+    set comparisonFunction(arg: number);
+    /**
+     * Gets or sets the comparison function (513, 514, etc). Set 0 to not use a comparison function
+     */
+    get comparisonFunction(): number;
+    set useMipMaps(arg: boolean);
+    /**
+     * Indicates to use the mip maps (if available on the texture).
+     * Thanks to this flag, you can instruct the sampler to not sample the mipmaps even if they exist (and if the sampling mode is set to a value that normally samples the mipmaps!)
+     */
+    get useMipMaps(): boolean;
+    /**
+     * Sets all the parameters of the sampler
+     * @param wrapU u address mode (default: TEXTURE_WRAP_ADDRESSMODE)
+     * @param wrapV v address mode (default: TEXTURE_WRAP_ADDRESSMODE)
+     * @param wrapR r address mode (default: TEXTURE_WRAP_ADDRESSMODE)
+     * @param anisotropicFilteringLevel anisotropic level (default: 1)
+     * @param samplingMode sampling mode (default: 2)
+     * @param comparisonFunction comparison function (default: 0 - no comparison function)
+     * @returns the current sampler instance
+     */
+    setParameters(wrapU?: number, wrapV?: number, wrapR?: number, anisotropicFilteringLevel?: number, samplingMode?: number, comparisonFunction?: number): TextureSampler;
+    /**
+     * Compares this sampler with another one
+     * @param other sampler to compare with
+     * @returns true if the samplers have the same parametres, else false
+     */
+    compareSampler(other: any): boolean;
+}

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

@@ -0,0 +1,37 @@
+/**
+ * This is a tiny helper class to wrap a RenderTargetWrapper in a texture
+ * usable as the input of an effect.
+ */
+export class ThinRenderTargetTexture extends ThinTexture {
+    /**
+     * Instantiates a new ThinRenderTargetTexture.
+     * Tiny helper class to wrap a RenderTargetWrapper in a texture.
+     * This can be used as an internal texture wrapper in ThinEngine to benefit from the cache and to hold on the associated RTT
+     * @param engine Define the internalTexture to wrap
+     * @param size Define the size of the RTT to create
+     * @param options Define rendertarget options
+     */
+    constructor(engine: any, size: any, options: any);
+    _renderTarget: any;
+    _engine: any;
+    _renderTargetOptions: any;
+    /**
+     * Gets the render target wrapper associated with this render target
+     */
+    get renderTarget(): any;
+    /**
+     * 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 }
+     */
+    resize(size: any): void;
+    _size: any;
+    /**
+     * Dispose the texture and release its associated resources.
+     * @param disposeOnlyFramebuffers
+     */
+    dispose(disposeOnlyFramebuffers?: boolean): void;
+}
+import { ThinTexture } from "./thinTexture.js";

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

@@ -0,0 +1,146 @@
+/**
+ * Base class of all the textures in babylon.
+ * It groups all the common properties required to work with Thin Engine.
+ */
+export class ThinTexture {
+    /**
+     * Instantiates a new ThinTexture.
+     * Base class of all the textures in babylon.
+     * This can be used as an internal texture wrapper in ThinEngine to benefit from the cache
+     * @param internalTexture Define the internalTexture to wrap
+     */
+    constructor(internalTexture: any);
+    _wrapU: number;
+    _wrapV: number;
+    /**
+     * | Value | Type               | Description |
+     * | ----- | ------------------ | ----------- |
+     * | 0     | CLAMP_ADDRESSMODE  |             |
+     * | 1     | WRAP_ADDRESSMODE   |             |
+     * | 2     | MIRROR_ADDRESSMODE |             |
+     */
+    wrapR: number;
+    /**
+     * With compliant hardware and browser (supporting anisotropic filtering)
+     * this defines the level of anisotropic filtering in the texture.
+     * The higher the better but the slower. This defaults to 4 as it seems to be the best tradeoff.
+     */
+    anisotropicFilteringLevel: number;
+    /**
+     * Define the current state of the loading sequence when in delayed load mode.
+     */
+    delayLoadState: number;
+    /** @internal */
+    _texture: any;
+    _engine: any;
+    _cachedSize: Size;
+    _cachedBaseSize: Size;
+    /** @internal */
+    _initialSamplingMode: number;
+    set wrapU(arg: number);
+    /**
+     * | Value | Type               | Description |
+     * | ----- | ------------------ | ----------- |
+     * | 0     | CLAMP_ADDRESSMODE  |             |
+     * | 1     | WRAP_ADDRESSMODE   |             |
+     * | 2     | MIRROR_ADDRESSMODE |             |
+     */
+    get wrapU(): number;
+    set wrapV(arg: number);
+    /**
+     * | Value | Type               | Description |
+     * | ----- | ------------------ | ----------- |
+     * | 0     | CLAMP_ADDRESSMODE  |             |
+     * | 1     | WRAP_ADDRESSMODE   |             |
+     * | 2     | MIRROR_ADDRESSMODE |             |
+     */
+    get wrapV(): number;
+    /**
+     * How a texture is mapped.
+     * Unused in thin texture mode.
+     */
+    get coordinatesMode(): number;
+    set isCube(arg: any);
+    /**
+     * Define if the texture is a cube texture or if false a 2d texture.
+     */
+    get isCube(): any;
+    set is3D(arg: any);
+    /**
+     * Define if the texture is a 3d texture (webgl 2) or if false a 2d texture.
+     */
+    get is3D(): any;
+    set is2DArray(arg: any);
+    /**
+     * Define if the texture is a 2d array texture (webgl 2) or if false a 2d texture.
+     */
+    get is2DArray(): any;
+    /**
+     * Get the class name of the texture.
+     * @returns "ThinTexture"
+     */
+    getClassName(): string;
+    /**
+     * Get if the texture is ready to be used (downloaded, converted, mip mapped...).
+     * @returns true if fully ready
+     */
+    isReady(): any;
+    /**
+     * Triggers the load sequence in delayed load mode.
+     */
+    delayLoad(): void;
+    /**
+     * Get the underlying lower level texture from Babylon.
+     * @returns the internal texture
+     */
+    getInternalTexture(): any;
+    /**
+     * Get the size of the texture.
+     * @returns the texture size.
+     */
+    getSize(): Size;
+    /**
+     * Get the base size of the texture.
+     * It can be different from the size if the texture has been resized for POT for instance
+     * @returns the base size
+     */
+    getBaseSize(): Size;
+    /**
+     * Get the current sampling mode associated with the texture.
+     */
+    get samplingMode(): any;
+    /**
+     * Update the sampling mode of the texture.
+     * Default is Trilinear mode.
+     *
+     * | Value | Type               | Description |
+     * | ----- | ------------------ | ----------- |
+     * | 1     | NEAREST_SAMPLINGMODE or NEAREST_NEAREST_MIPLINEAR  | Nearest is: mag = nearest, min = nearest, mip = linear |
+     * | 2     | BILINEAR_SAMPLINGMODE or LINEAR_LINEAR_MIPNEAREST | Bilinear is: mag = linear, min = linear, mip = nearest |
+     * | 3     | TRILINEAR_SAMPLINGMODE or LINEAR_LINEAR_MIPLINEAR | Trilinear is: mag = linear, min = linear, mip = linear |
+     * | 4     | NEAREST_NEAREST_MIPNEAREST |             |
+     * | 5    | NEAREST_LINEAR_MIPNEAREST |             |
+     * | 6    | NEAREST_LINEAR_MIPLINEAR |             |
+     * | 7    | NEAREST_LINEAR |             |
+     * | 8    | NEAREST_NEAREST |             |
+     * | 9   | LINEAR_NEAREST_MIPNEAREST |             |
+     * | 10   | LINEAR_NEAREST_MIPLINEAR |             |
+     * | 11   | LINEAR_LINEAR |             |
+     * | 12   | LINEAR_NEAREST |             |
+     *
+     *    > _mag_: magnification filter (close to the viewer)
+     *    > _min_: minification filter (far from the viewer)
+     *    > _mip_: filter used between mip map levels
+     *@param samplingMode Define the new sampling mode of the texture
+     */
+    updateSamplingMode(samplingMode: any): void;
+    /**
+     * Release and destroy the underlying lower level texture aka internalTexture.
+     */
+    releaseInternalTexture(): void;
+    /**
+     * Dispose the texture and release its associated resources.
+     */
+    dispose(): void;
+}
+import { Size } from "../../Maths/math.size.js";

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

@@ -0,0 +1,99 @@
+/**
+ * If you want to display a video in your scene, this is the special texture for that.
+ * This special texture works similar to other textures, with the exception of a few parameters.
+ * @see https://doc.babylonjs.com/divingDeeper/materials/using/videoTexture
+ */
+export class VideoTexture extends Texture {
+    /**
+     * Creates a video texture straight from a stream.
+     * @param scene Define the scene the texture should be created in
+     * @param stream Define the stream the texture should be created from
+     * @param constraints video constraints
+     * @param invertY Defines if the video should be stored with invert Y set to true (true by default)
+     * @returns The created video texture as a promise
+     */
+    static CreateFromStreamAsync(scene: any, stream: any, constraints: any, invertY?: boolean): Promise<any>;
+    /**
+     * Creates a video texture straight from your WebCam video feed.
+     * @param scene Define the scene the texture should be created in
+     * @param constraints Define the constraints to use to create the web cam feed from WebRTC
+     * @param audioConstaints Define the audio constraints to use to create the web cam feed from WebRTC
+     * @param invertY Defines if the video should be stored with invert Y set to true (true by default)
+     * @returns The created video texture as a promise
+     */
+    static CreateFromWebCamAsync(scene: any, constraints: any, audioConstaints?: boolean, invertY?: boolean): Promise<any>;
+    /**
+     * Creates a video texture straight from your WebCam video feed.
+     * @param scene Defines the scene the texture should be created in
+     * @param onReady Defines a callback to triggered once the texture will be ready
+     * @param constraints Defines the constraints to use to create the web cam feed from WebRTC
+     * @param audioConstaints Defines the audio constraints to use to create the web cam feed from WebRTC
+     * @param invertY Defines if the video should be stored with invert Y set to true (true by default)
+     */
+    static CreateFromWebCam(scene: any, onReady: any, constraints: any, audioConstaints?: boolean, invertY?: boolean): void;
+    /**
+     * Creates a video texture.
+     * If you want to display a video in your scene, this is the special texture for that.
+     * This special texture works similar to other textures, with the exception of a few parameters.
+     * @see https://doc.babylonjs.com/how_to/video_texture
+     * @param name optional name, will detect from video source, if not defined
+     * @param src can be used to provide an url, array of urls or an already setup HTML video element.
+     * @param scene is obviously the current scene.
+     * @param generateMipMaps can be used to turn on mipmaps (Can be expensive for videoTextures because they are often updated).
+     * @param invertY is false by default but can be used to invert video on Y axis
+     * @param samplingMode controls the sampling method and is set to TRILINEAR_SAMPLINGMODE by default
+     * @param settings allows finer control over video usage
+     * @param onError defines a callback triggered when an error occurred during the loading session
+     */
+    constructor(name: any, src: any, scene: any, generateMipMaps: boolean | undefined, invertY: boolean | undefined, samplingMode: number | undefined, settings: {} | undefined, onError: any);
+    _onUserActionRequestedObservable: Observable<any> | null;
+    _stillImageCaptured: boolean;
+    _displayingPosterTexture: boolean;
+    _frameId: number;
+    _currentSrc: any;
+    _errorFound: boolean;
+    _createInternalTexture: () => void;
+    _generateMipMaps: boolean;
+    _reset: () => void;
+    _updateInternalTexture: () => void;
+    _settings: {
+        autoPlay: boolean;
+        loop: boolean;
+        autoUpdateTexture: boolean;
+    };
+    _onError: any;
+    autoUpdateTexture: boolean;
+    name: any;
+    video: any;
+    _createInternalTextureOnEvent: string;
+    /**
+     * Event triggered when a dom action is required by the user to play the video.
+     * This happens due to recent changes in browser policies preventing video to auto start.
+     */
+    get onUserActionRequestedObservable(): Observable<any>;
+    _processError(reason: any): void;
+    _handlePlay(): void;
+    _getName(src: any): any;
+    _getVideo(src: any): any;
+    /**
+     * Update Texture in the `auto` mode. Does not do anything if `settings.autoUpdateTexture` is false.
+     */
+    update(): void;
+    /**
+     * Update Texture in `manual` mode. Does not do anything if not visible or paused.
+     * @param isVisible Visibility state, detected by user using `scene.getActiveMeshes()` or otherwise.
+     */
+    updateTexture(isVisible: any): void;
+    /**
+     * Change video content. Changing video instance or setting multiple urls (as in constructor) is not supported.
+     * @param url New url.
+     */
+    updateURL(url: any): void;
+    /**
+     * Clones the texture.
+     * @returns the cloned texture
+     */
+    clone(): VideoTexture;
+}
+import { Texture } from "../../Materials/Textures/texture.js";
+import { Observable } from "../../Misc/observable.js";