@combeenation/3d-viewer 0.0.1-types

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

@@ -0,0 +1,483 @@
+/**
+ * Options to create the null engine
+ */
+export class NullEngineOptions {
+    /**
+     * Render width (Default: 512)
+     */
+    renderWidth: number;
+    /**
+     * Render height (Default: 256)
+     */
+    renderHeight: number;
+    /**
+     * Texture size (Default: 512)
+     */
+    textureSize: number;
+    /**
+     * If delta time between frames should be constant
+     * @see https://doc.babylonjs.com/babylon101/animations#deterministic-lockstep
+     */
+    deterministicLockstep: boolean;
+    /**
+     * Maximum about of steps between frames (Default: 4)
+     * @see https://doc.babylonjs.com/babylon101/animations#deterministic-lockstep
+     */
+    lockstepMaxSteps: number;
+}
+/**
+ * The null engine class provides support for headless version of babylon.js.
+ * This can be used in server side scenario or for testing purposes
+ */
+export class NullEngine extends Engine {
+    constructor(options?: NullEngineOptions);
+    _options: NullEngineOptions;
+    _caps: {
+        maxTexturesImageUnits: number;
+        maxVertexTextureImageUnits: number;
+        maxCombinedTexturesImageUnits: number;
+        maxTextureSize: number;
+        maxCubemapTextureSize: number;
+        maxRenderTextureSize: number;
+        maxVertexAttribs: number;
+        maxVaryingVectors: number;
+        maxFragmentUniformVectors: number;
+        maxVertexUniformVectors: number;
+        standardDerivatives: boolean;
+        astc: null;
+        pvrtc: null;
+        etc1: null;
+        etc2: null;
+        bptc: null;
+        maxAnisotropy: number;
+        uintIndices: boolean;
+        fragmentDepthSupported: boolean;
+        highPrecisionShaderSupported: boolean;
+        colorBufferFloat: boolean;
+        textureFloat: boolean;
+        textureFloatLinearFiltering: boolean;
+        textureFloatRender: boolean;
+        textureHalfFloat: boolean;
+        textureHalfFloatLinearFiltering: boolean;
+        textureHalfFloatRender: boolean;
+        textureLOD: boolean;
+        drawBuffersExtension: boolean;
+        depthTextureExtension: boolean;
+        vertexArrayObject: boolean;
+        instancedArrays: boolean;
+        supportOcclusionQuery: boolean;
+        canUseTimestampForTimerQuery: boolean;
+        maxMSAASamples: number;
+        blendMinMax: boolean;
+        canUseGLInstanceID: boolean;
+        canUseGLVertexID: boolean;
+        supportComputeShaders: boolean;
+        supportSRGBBuffers: boolean;
+        supportTransformFeedbacks: boolean;
+        textureMaxLevel: boolean;
+        texture2DArrayMaxLayerCount: number;
+    };
+    /**
+     * Creates a vertex buffer
+     * @param vertices the data for the vertex buffer
+     * @returns the new WebGL static buffer
+     */
+    createVertexBuffer(vertices: any): DataBuffer;
+    /**
+     * Creates a new index buffer
+     * @param indices defines the content of the index buffer
+     * @returns a new webGL buffer
+     */
+    createIndexBuffer(indices: any): DataBuffer;
+    /**
+     * Clear the current render buffer or the current render target (if any is set up)
+     * @param color defines the color to use
+     * @param backBuffer defines if the back buffer must be cleared
+     * @param depth defines if the depth buffer must be cleared
+     * @param stencil defines if the stencil buffer must be cleared
+     */
+    clear(color: any, backBuffer: any, depth: any, stencil?: boolean): void;
+    /**
+     * Set the WebGL's viewport
+     * @param viewport defines the viewport element to be used
+     * @param requiredWidth defines the width required for rendering. If not provided the rendering canvas' width is used
+     * @param requiredHeight defines the height required for rendering. If not provided the rendering canvas' height is used
+     */
+    setViewport(viewport: any, requiredWidth: any, requiredHeight: any): void;
+    createShaderProgram(pipelineContext: any, vertexCode: any, fragmentCode: any, defines: any, context: any): {
+        __SPECTOR_rebuildProgram: null;
+    };
+    /**
+     * Gets the list of webGL uniform locations associated with a specific program based on a list of uniform names
+     * @param pipelineContext defines the pipeline context to use
+     * @param uniformsNames defines the list of uniform names
+     * @returns an array of webGL uniform locations
+     */
+    getUniforms(pipelineContext: any, uniformsNames: any): never[];
+    /**
+     * Gets the lsit of active attributes for a given webGL program
+     * @param pipelineContext defines the pipeline context to use
+     * @param attributesNames defines the list of attribute names to get
+     * @returns an array of indices indicating the offset of each attribute
+     */
+    getAttributes(pipelineContext: any, attributesNames: any): never[];
+    /**
+     * Binds an effect to the webGL context
+     * @param effect defines the effect to bind
+     */
+    bindSamplers(effect: any): void;
+    /**
+     * Activates an effect, making it the current one (ie. the one used for rendering)
+     * @param effect defines the effect to activate
+     */
+    enableEffect(effect: any): void;
+    /**
+     * Set various states to the webGL context
+     * @param culling defines culling state: true to enable culling, false to disable it
+     * @param zOffset defines the value to apply to zOffset (0 by default)
+     * @param force defines if states must be applied even if cache is up to date
+     * @param reverseSide defines if culling must be reversed (CCW if false, CW if true)
+     * @param cullBackFaces true to cull back faces, false to cull front faces (if culling is enabled)
+     * @param stencil stencil states to set
+     * @param zOffsetUnits defines the value to apply to zOffsetUnits (0 by default)
+     */
+    setState(culling: any, zOffset: number | undefined, force: any, reverseSide: boolean | undefined, cullBackFaces: any, stencil: any, zOffsetUnits?: number): void;
+    /**
+     * 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 value was set
+     */
+    setIntArray(uniform: any, array: any): boolean;
+    /**
+     * Set the value of an uniform to an array of int32 (stored as vec2)
+     * @param uniform defines the webGL uniform location where to store the value
+     * @param array defines the array of int32 to store
+     * @returns true if value was set
+     */
+    setIntArray2(uniform: any, array: any): boolean;
+    /**
+     * Set the value of an uniform to an array of int32 (stored as vec3)
+     * @param uniform defines the webGL uniform location where to store the value
+     * @param array defines the array of int32 to store
+     * @returns true if value was set
+     */
+    setIntArray3(uniform: any, array: any): boolean;
+    /**
+     * Set the value of an uniform to an array of int32 (stored as vec4)
+     * @param uniform defines the webGL uniform location where to store the value
+     * @param array defines the array of int32 to store
+     * @returns true if value was set
+     */
+    setIntArray4(uniform: any, array: any): boolean;
+    /**
+     * Set the value of an uniform to an array of float32
+     * @param uniform defines the webGL uniform location where to store the value
+     * @param array defines the array of float32 to store
+     * @returns true if value was set
+     */
+    setFloatArray(uniform: any, array: any): boolean;
+    /**
+     * Set the value of an uniform to an array of float32 (stored as vec2)
+     * @param uniform defines the webGL uniform location where to store the value
+     * @param array defines the array of float32 to store
+     * @returns true if value was set
+     */
+    setFloatArray2(uniform: any, array: any): boolean;
+    /**
+     * Set the value of an uniform to an array of float32 (stored as vec3)
+     * @param uniform defines the webGL uniform location where to store the value
+     * @param array defines the array of float32 to store
+     * @returns true if value was set
+     */
+    setFloatArray3(uniform: any, array: any): boolean;
+    /**
+     * Set the value of an uniform to an array of float32 (stored as vec4)
+     * @param uniform defines the webGL uniform location where to store the value
+     * @param array defines the array of float32 to store
+     * @returns true if value was set
+     */
+    setFloatArray4(uniform: any, array: any): boolean;
+    /**
+     * Set the value of an uniform to an array of number
+     * @param uniform defines the webGL uniform location where to store the value
+     * @param array defines the array of number to store
+     * @returns true if value was set
+     */
+    setArray(uniform: any, array: any): boolean;
+    /**
+     * Set the value of an uniform to an array of number (stored as vec2)
+     * @param uniform defines the webGL uniform location where to store the value
+     * @param array defines the array of number to store
+     * @returns true if value was set
+     */
+    setArray2(uniform: any, array: any): boolean;
+    /**
+     * Set the value of an uniform to an array of number (stored as vec3)
+     * @param uniform defines the webGL uniform location where to store the value
+     * @param array defines the array of number to store
+     * @returns true if value was set
+     */
+    setArray3(uniform: any, array: any): boolean;
+    /**
+     * Set the value of an uniform to an array of number (stored as vec4)
+     * @param uniform defines the webGL uniform location where to store the value
+     * @param array defines the array of number to store
+     * @returns true if value was set
+     */
+    setArray4(uniform: any, array: any): boolean;
+    /**
+     * Set the value of an uniform to an array of float32 (stored as matrices)
+     * @param uniform defines the webGL uniform location where to store the value
+     * @param matrices defines the array of float32 to store
+     * @returns true if value was set
+     */
+    setMatrices(uniform: any, matrices: any): boolean;
+    /**
+     * Set the value of an uniform to a matrix (3x3)
+     * @param uniform defines the webGL uniform location where to store the value
+     * @param matrix defines the Float32Array representing the 3x3 matrix to store
+     * @returns true if value was set
+     */
+    setMatrix3x3(uniform: any, matrix: any): boolean;
+    /**
+     * Set the value of an uniform to a matrix (2x2)
+     * @param uniform defines the webGL uniform location where to store the value
+     * @param matrix defines the Float32Array representing the 2x2 matrix to store
+     * @returns true if value was set
+     */
+    setMatrix2x2(uniform: any, matrix: any): boolean;
+    /**
+     * Set the value of an uniform to a number (float)
+     * @param uniform defines the webGL uniform location where to store the value
+     * @param value defines the float number to store
+     * @returns true if value was set
+     */
+    setFloat(uniform: any, value: any): boolean;
+    /**
+     * Set the value of an uniform to a vec2
+     * @param uniform defines the webGL uniform location where to store the value
+     * @param x defines the 1st component of the value
+     * @param y defines the 2nd component of the value
+     * @returns true if value was set
+     */
+    setFloat2(uniform: any, x: any, y: any): boolean;
+    /**
+     * Set the value of an uniform to a vec3
+     * @param uniform defines the webGL uniform location where to store the value
+     * @param x defines the 1st component of the value
+     * @param y defines the 2nd component of the value
+     * @param z defines the 3rd component of the value
+     * @returns true if value was set
+     */
+    setFloat3(uniform: any, x: any, y: any, z: any): boolean;
+    /**
+     * Set the value of an uniform to a boolean
+     * @param uniform defines the webGL uniform location where to store the value
+     * @param bool defines the boolean to store
+     * @returns true if value was set
+     */
+    setBool(uniform: any, bool: any): boolean;
+    /**
+     * Set the value of an uniform to a vec4
+     * @param uniform defines the webGL uniform location where to store the value
+     * @param x defines the 1st component of the value
+     * @param y defines the 2nd component of the value
+     * @param z defines the 3rd component of the value
+     * @param w defines the 4th component of the value
+     * @returns true if value was set
+     */
+    setFloat4(uniform: any, x: any, y: any, z: any, w: any): boolean;
+    /**
+     * Sets the current alpha mode
+     * @param mode defines the mode to use (one of the Engine.ALPHA_XXX)
+     * @param noDepthWriteChange defines if depth writing state should remains unchanged (false by default)
+     * @see https://doc.babylonjs.com/resources/transparency_and_how_meshes_are_rendered
+     */
+    setAlphaMode(mode: any, noDepthWriteChange?: boolean): void;
+    /**
+     * Bind webGl buffers directly to the webGL context
+     * @param vertexBuffers defines the vertex buffer to bind
+     * @param indexBuffer defines the index buffer to bind
+     * @param effect defines the effect associated with the vertex buffer
+     */
+    bindBuffers(vertexBuffers: any, indexBuffer: any, effect: any): void;
+    /**
+     * Force the entire cache to be cleared
+     * You should not have to use this function unless your engine needs to share the webGL context with another engine
+     * @param bruteForce defines a boolean to force clearing ALL caches (including stencil, detoh and alpha states)
+     */
+    wipeCaches(bruteForce: any): void;
+    /**
+     * Send a draw order
+     * @param useTriangles defines if triangles must be used to draw (else wireframe will be used)
+     * @param indexStart defines the starting index
+     * @param indexCount defines the number of index to draw
+     * @param instancesCount defines the number of instances to draw (if instantiation is enabled)
+     */
+    draw(useTriangles: any, indexStart: any, indexCount: any, instancesCount: any): void;
+    /**
+     * Draw a list of indexed primitives
+     * @param fillMode defines the primitive to use
+     * @param indexStart defines the starting index
+     * @param indexCount defines the number of index to draw
+     * @param instancesCount defines the number of instances to draw (if instantiation is enabled)
+     */
+    drawElementsType(fillMode: any, indexStart: any, indexCount: any, instancesCount: any): void;
+    /**
+     * Draw a list of unindexed primitives
+     * @param fillMode defines the primitive to use
+     * @param verticesStart defines the index of first vertex to draw
+     * @param verticesCount defines the count of vertices to draw
+     * @param instancesCount defines the number of instances to draw (if instantiation is enabled)
+     */
+    drawArraysType(fillMode: any, verticesStart: any, verticesCount: any, instancesCount: any): void;
+    /**
+     * @internal
+     */
+    _releaseTexture(texture: any): void;
+    /**
+     * Usually called from Texture.ts.
+     * Passed information to create a WebGLTexture
+     * @param urlArg 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
+     * @returns a InternalTexture for assignment back into BABYLON.Texture
+     */
+    createTexture(urlArg: any, noMipmap: any, invertY: any, scene: any, samplingMode: number | undefined, onLoad: null | undefined, onError: null | undefined, buffer: null | undefined, fallback: null | undefined, format: null | undefined, forcedExtension: null | undefined, mimeType: any): any;
+    /**
+     * @internal
+     */
+    _createHardwareRenderTargetWrapper(isMulti: any, isCube: any, size: any): RenderTargetWrapper;
+    /**
+     * Creates a new render target wrapper
+     * @param size defines the size of the texture
+     * @param options defines the options used to create the texture
+     * @returns a new render target wrapper
+     */
+    createRenderTargetTexture(size: any, options: any): RenderTargetWrapper;
+    /**
+     * Update the sampling mode of a given texture
+     * @param samplingMode defines the required sampling mode
+     * @param texture defines the texture to update
+     */
+    updateTextureSamplingMode(samplingMode: any, texture: any): void;
+    /**
+     * Creates a raw texture
+     * @param data defines the data to store in the texture
+     * @param width defines the width of the texture
+     * @param height defines the height of the texture
+     * @param format defines the format of the data
+     * @param generateMipMaps defines if the engine should generate the mip levels
+     * @param invertY defines if data must be stored with Y axis inverted
+     * @param samplingMode defines the required sampling mode (Texture.NEAREST_SAMPLINGMODE by default)
+     * @param compression defines the compression used (null by default)
+     * @param type defines the type fo the data (Engine.TEXTURETYPE_UNSIGNED_INT by default)
+     * @param creationFlags specific flags to use when creating the texture (1 for storage textures, for eg)
+     * @param useSRGBBuffer defines if the texture must be loaded in a sRGB GPU buffer (if supported by the GPU).
+     * @returns the raw texture inside an InternalTexture
+     */
+    createRawTexture(data: any, width: any, height: any, format: any, generateMipMaps: any, invertY: any, samplingMode: any, compression?: null, type?: number, creationFlags?: number, useSRGBBuffer?: boolean): any;
+    /**
+     * Update a raw texture
+     * @param texture defines the texture to update
+     * @param data defines the data to store in the texture
+     * @param format defines the format of the data
+     * @param invertY defines if data must be stored with Y axis inverted
+     * @param compression defines the compression used (null by default)
+     * @param type defines the type fo the data (Engine.TEXTURETYPE_UNSIGNED_INT by default)
+     * @param useSRGBBuffer defines if the texture must be loaded in a sRGB GPU buffer (if supported by the GPU).
+     */
+    updateRawTexture(texture: any, data: any, format: any, invertY: any, compression?: null, type?: number, useSRGBBuffer?: boolean): 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
+     * @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
+     */
+    bindFramebuffer(rtWrapper: any, faceIndex: any, requiredWidth: any, requiredHeight: any, forceFullscreenViewport: any): void;
+    /**
+     * Unbind the current render target texture from the webGL context
+     * @param rtWrapper defines the render target wrapper to unbind
+     * @param disableGenerateMipMaps defines a boolean indicating that mipmaps must not be generated
+     * @param onBeforeUnbind defines a function which will be called before the effective unbind
+     */
+    unBindFramebuffer(rtWrapper: any, disableGenerateMipMaps: boolean | undefined, onBeforeUnbind: any): void;
+    /**
+     * Creates a dynamic vertex buffer
+     * @param vertices the data for the dynamic vertex buffer
+     * @returns the new WebGL dynamic buffer
+     */
+    createDynamicVertexBuffer(vertices: any): DataBuffer;
+    /**
+     * Update the content of a dynamic texture
+     * @param texture defines the texture to update
+     * @param canvas defines the canvas containing the source
+     * @param invertY defines if data must be stored with Y axis inverted
+     * @param premulAlpha defines if alpha is stored as premultiplied
+     * @param format defines the format of the data
+     */
+    updateDynamicTexture(texture: any, canvas: any, invertY: any, premulAlpha: boolean | undefined, format: any): void;
+    /**
+     * @internal
+     */
+    _unpackFlipY(value: any): void;
+    /**
+     * Update a dynamic index buffer
+     * @param indexBuffer defines the target index buffer
+     * @param indices defines the data to update
+     * @param offset defines the offset in the target index buffer where update should start
+     */
+    updateDynamicIndexBuffer(indexBuffer: any, indices: any, offset?: number): void;
+    /**
+     * Updates a dynamic vertex buffer.
+     * @param vertexBuffer the vertex buffer to update
+     * @param vertices the data used to update the vertex buffer
+     * @param byteOffset the byte offset of the data (optional)
+     * @param byteLength the byte length of the data (optional)
+     */
+    updateDynamicVertexBuffer(vertexBuffer: any, vertices: any, byteOffset: any, byteLength: any): void;
+    /**
+     * @internal
+     */
+    _bindTextureDirectly(target: any, texture: any): boolean;
+    /**
+     * @internal
+     */
+    _bindTexture(channel: any, texture: any): void;
+    _deleteBuffer(buffer: any): void;
+    set loadingUIText(arg: any);
+    /**
+     * @internal
+     */
+    _uploadCompressedDataToTextureDirectly(texture: any, internalFormat: any, width: any, height: any, data: any, faceIndex?: number, lod?: number): void;
+    /**
+     * @internal
+     */
+    _uploadDataToTextureDirectly(texture: any, imageData: any, faceIndex?: number, lod?: number): void;
+    /**
+     * @internal
+     */
+    _uploadArrayBufferViewToTexture(texture: any, imageData: any, faceIndex?: number, lod?: number): void;
+    /**
+     * @internal
+     */
+    _uploadImageToTexture(texture: any, image: any, faceIndex?: number, lod?: number): void;
+}
+import { Engine } from "../Engines/engine.js";
+import { DataBuffer } from "../Buffers/dataBuffer.js";
+import { RenderTargetWrapper } from "./renderTargetWrapper.js";

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

@@ -0,0 +1,13 @@
+/** @internal */
+export class PerformanceConfigurator {
+    /**
+     * @internal
+     */
+    static SetMatrixPrecision(use64bits: any): void;
+}
+export namespace PerformanceConfigurator {
+    const MatrixUse64Bits: boolean;
+    const MatrixTrackPrecisionChange: boolean;
+    const MatrixCurrentType: Float32ArrayConstructor;
+    const MatrixTrackedMatrices: any[];
+}

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

@@ -0,0 +1,129 @@
+/**
+ * Wrapper around a render target (either single or multi textures)
+ */
+export class RenderTargetWrapper {
+    /**
+     * Initializes the render target wrapper
+     * @param isMulti true if the wrapper is a multi render target
+     * @param isCube true if the wrapper should render to a cube texture
+     * @param size size of the render target (width/height/layers)
+     * @param engine engine used to create the render target
+     */
+    constructor(isMulti: any, isCube: any, size: any, engine: any);
+    _textures: any[] | null;
+    _samples: number;
+    /** @internal */
+    _attachments: any;
+    /** @internal */
+    _generateStencilBuffer: boolean;
+    /** @internal */
+    _generateDepthBuffer: boolean;
+    /** @internal */
+    _depthStencilTextureWithStencil: boolean;
+    _isMulti: any;
+    _isCube: any;
+    _size: any;
+    _engine: any;
+    _depthStencilTexture: any;
+    /**
+     * Gets the depth/stencil texture (if created by a createDepthStencilTexture() call)
+     */
+    get depthStencilTexture(): any;
+    /**
+     * Indicates if the depth/stencil texture has a stencil aspect
+     */
+    get depthStencilTextureWithStencil(): boolean;
+    /**
+     * Defines if the render target wrapper is for a cube texture or if false a 2d texture
+     */
+    get isCube(): any;
+    /**
+     * Defines if the render target wrapper is for a single or multi target render wrapper
+     */
+    get isMulti(): any;
+    /**
+     * Defines if the render target wrapper is for a single or an array of textures
+     */
+    get is2DArray(): boolean;
+    /**
+     * Gets the size of the render target wrapper (used for cubes, as width=height in this case)
+     */
+    get size(): any;
+    /**
+     * Gets the width of the render target wrapper
+     */
+    get width(): any;
+    /**
+     * Gets the height of the render target wrapper
+     */
+    get height(): any;
+    /**
+     * Gets the number of layers of the render target wrapper (only used if is2DArray is true)
+     */
+    get layers(): any;
+    /**
+     * Gets the render texture. If this is a multi render target, gets the first texture
+     */
+    get texture(): any;
+    /**
+     * Gets the list of render textures. If we are not in a multi render target, the list will be null (use the texture getter instead)
+     */
+    get textures(): any[] | null;
+    /**
+     * Gets the sample count of the render target
+     */
+    get samples(): number;
+    /**
+     * Sets the sample count of the render target
+     * @param value sample count
+     * @param initializeBuffers If set to true, the engine will make an initializing call to drawBuffers (only used when isMulti=true).
+     * @param force true to force calling the update sample count engine function even if the current sample count is equal to value
+     * @returns the sample count that has been set
+     */
+    setSamples(value: any, initializeBuffers?: boolean, force?: boolean): any;
+    /**
+     * Sets the render target texture(s)
+     * @param textures texture(s) to set
+     */
+    setTextures(textures: any): void;
+    /**
+     * Set a texture in the textures array
+     * @param texture the texture to set
+     * @param index the index in the textures array to set
+     * @param disposePrevious If this function should dispose the previous texture
+     */
+    setTexture(texture: any, index?: number, disposePrevious?: boolean): void;
+    /**
+     * Creates the depth/stencil texture
+     * @param comparisonFunction Comparison function to use for the texture
+     * @param bilinearFiltering true if bilinear filtering should be used when sampling the texture
+     * @param generateStencil true if the stencil aspect should also be created
+     * @param samples sample count to use when creating the texture
+     * @param format format of the depth texture
+     * @returns the depth/stencil created texture
+     */
+    createDepthStencilTexture(comparisonFunction?: number, bilinearFiltering?: boolean, generateStencil?: boolean, samples?: number, format?: number): any;
+    /**
+     * Shares the depth buffer of this render target with another render target.
+     * @internal
+     * @param renderTarget Destination renderTarget
+     */
+    _shareDepth(renderTarget: any): void;
+    /**
+     * @internal
+     */
+    _swapAndDie(target: any): void;
+    _cloneRenderTargetWrapper(): any;
+    _swapRenderTargetWrapper(target: any): void;
+    /** @internal */
+    _rebuild(): void;
+    /**
+     * Releases the internal render textures
+     */
+    releaseTextures(): void;
+    /**
+     * Disposes the whole render target wrapper
+     * @param disposeOnlyFramebuffers true if only the frame buffers should be released (used for the WebGL engine). If false, all the textures will also be released
+     */
+    dispose(disposeOnlyFramebuffers?: boolean): void;
+}

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

@@ -0,0 +1,32 @@
+/**
+ * Defines the shader related stores and directory
+ */
+export class ShaderStore {
+    /**
+     * Gets the shaders repository path for a given shader language
+     * @param shaderLanguage the shader language
+     * @returns the path to the shaders repository
+     */
+    static GetShadersRepository(shaderLanguage?: ShaderLanguage): string;
+    /**
+     * Gets the shaders store of a given shader language
+     * @param shaderLanguage the shader language
+     * @returns the shaders store
+     */
+    static GetShadersStore(shaderLanguage?: ShaderLanguage): {};
+    /**
+     * Gets the include shaders store of a given shader language
+     * @param shaderLanguage the shader language
+     * @returns the include shaders store
+     */
+    static GetIncludesShadersStore(shaderLanguage?: ShaderLanguage): {};
+}
+export namespace ShaderStore {
+    const ShadersRepository: string;
+    const ShadersStore: {};
+    const IncludesShadersStore: {};
+    const ShadersRepositoryWGSL: string;
+    const ShadersStoreWGSL: {};
+    const IncludesShadersStoreWGSL: {};
+}
+import { ShaderLanguage } from "../Materials/shaderLanguage.js";