@combeenation/3d-viewer 0.0.1-types

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

@@ -0,0 +1,734 @@
+/**
+ * Returns _native only after it has been defined by BabylonNative.
+ * @internal
+ */
+export function AcquireNativeObjectAsync(): Promise<any>;
+/**
+ * Registers a constructor on the _native object. See NativeXRFrame for an example.
+ * @internal
+ */
+export function RegisterNativeTypeAsync(typeName: any, constructor: any): Promise<void>;
+/** @internal */
+export class NativeEngine extends Engine {
+    /** @internal */
+    static _createNativeDataStream(): NativeDataStream;
+    constructor(options?: {});
+    _engine: any;
+    _camera: any;
+    _commandBufferEncoder: CommandBufferEncoder;
+    _boundBuffersVertexArray: any;
+    _currentDepthTest: any;
+    _stencilTest: boolean;
+    _stencilMask: number;
+    _stencilFunc: number;
+    _stencilFuncRef: number;
+    _stencilFuncMask: number;
+    _stencilOpStencilFail: number;
+    _stencilOpDepthFail: number;
+    _stencilOpStencilDepthPass: number;
+    _zOffset: number;
+    _zOffsetUnits: number;
+    _depthWrite: boolean;
+    _caps: {
+        maxTexturesImageUnits: number;
+        maxVertexTextureImageUnits: number;
+        maxCombinedTexturesImageUnits: number;
+        maxTextureSize: any;
+        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;
+        blendMinMax: boolean;
+        maxMSAASamples: number;
+        canUseGLInstanceID: boolean;
+        canUseGLVertexID: boolean;
+        supportComputeShaders: boolean;
+        supportSRGBBuffers: boolean;
+        supportTransformFeedbacks: boolean;
+        textureMaxLevel: boolean;
+        texture2DArrayMaxLayerCount: any;
+    };
+    _shaderProcessor: WebGL2ShaderProcessor;
+    getHardwareScalingLevel(): any;
+    setHardwareScalingLevel(level: any): void;
+    /**
+     * Can be used to override the current requestAnimationFrame requester.
+     * @internal
+     */
+    _queueNewFrame(bindedRenderFunction: any, requester: any): number;
+    /**
+     * Override default engine behavior.
+     * @param framebuffer
+     */
+    _bindUnboundFramebuffer(framebuffer: any): void;
+    /**
+     * Gets host document
+     * @returns the host document object
+     */
+    getHostDocument(): null;
+    clear(color: any, backBuffer: any, depth: any, stencil?: boolean): void;
+    createIndexBuffer(indices: any, updateable: any): NativeDataBuffer;
+    createVertexBuffer(vertices: any, updateable: any): NativeDataBuffer;
+    _recordVertexArrayObject(vertexArray: any, vertexBuffers: any, indexBuffer: any, effect: any, overrideVertexBuffers: any): void;
+    bindBuffers(vertexBuffers: any, indexBuffer: any, effect: any): void;
+    recordVertexArrayObject(vertexBuffers: any, indexBuffer: any, effect: any, overrideVertexBuffers: any): any;
+    _deleteVertexArray(vertexArray: any): void;
+    bindVertexArrayObject(vertexArray: any): void;
+    releaseVertexArrayObject(vertexArray: any): void;
+    getAttributes(pipelineContext: any, attributesNames: any): any;
+    /**
+     * 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;
+    createPipelineContext(): NativePipelineContext;
+    createMaterialContext(): undefined;
+    createDrawContext(): undefined;
+    _preparePipelineContext(pipelineContext: any, vertexSourceCode: any, fragmentSourceCode: any, createAsRaw: any, rawVertexSourceCode: any, rawFragmentSourceCode: any, rebuildRebind: any, defines: any, transformFeedbackVaryings: any): void;
+    /**
+     * @internal
+     */
+    _isRenderingStateCompiled(pipelineContext: any): boolean;
+    /**
+     * @internal
+     */
+    _executeWhenRenderingStateIsCompiled(pipelineContext: any, action: any): void;
+    createRawShaderProgram(pipelineContext: any, vertexCode: any, fragmentCode: any, context: any, transformFeedbackVaryings?: null): void;
+    createShaderProgram(pipelineContext: any, vertexCode: any, fragmentCode: any, defines: any, context: any, transformFeedbackVaryings?: null): any;
+    /**
+     * Inline functions in shader code that are marked to be inlined
+     * @param code code to inline
+     * @returns inlined code
+     */
+    inlineShaderCode(code: any): string;
+    _setProgram(program: any): void;
+    _deletePipelineContext(pipelineContext: any): void;
+    getUniforms(pipelineContext: any, uniformsNames: any): any;
+    bindUniformBlock(pipelineContext: any, blockName: any, index: any): void;
+    bindSamplers(effect: any): void;
+    setMatrix(uniform: any, matrix: any): void;
+    getRenderWidth(useScreen?: boolean): any;
+    getRenderHeight(useScreen?: boolean): any;
+    setViewport(viewport: any, requiredWidth: any, requiredHeight: any): void;
+    setState(culling: any, zOffset: number | undefined, force: any, reverseSide: boolean | undefined, cullBackFaces: any, stencil: any, zOffsetUnits?: number): void;
+    /**
+     * Gets the client rect of native canvas.  Needed for InputManager.
+     * @returns a client rectangle
+     */
+    getInputElementClientRect(): {
+        bottom: any;
+        height: any;
+        left: number;
+        right: any;
+        top: number;
+        width: any;
+        x: number;
+        y: number;
+        toJSON: () => void;
+    };
+    /**
+     * Set the z offset Factor to apply to current rendering
+     * @param value defines the offset to apply
+     */
+    setZOffset(value: any): void;
+    /**
+     * Set the z offset Units to apply to current rendering
+     * @param value defines the offset to apply
+     */
+    setZOffsetUnits(value: any): void;
+    /**
+     * Enable or disable depth buffering
+     * @param enable defines the state to set
+     */
+    setDepthBuffer(enable: any): void;
+    getDepthFunction(): 512 | 519 | 513 | 514 | 515 | 516 | 518 | 517 | null;
+    setDepthFunction(depthFunc: any): void;
+    /**
+     * Enable or disable depth writing
+     * @param enable defines the state to set
+     */
+    setDepthWrite(enable: any): void;
+    /**
+     * Enable or disable color writing
+     * @param enable defines the state to set
+     */
+    setColorWrite(enable: any): void;
+    applyStencil(): void;
+    _setStencil(mask: any, stencilOpFail: any, depthOpFail: any, depthOpPass: any, func: any, ref: any): void;
+    /**
+     * Enable or disable the stencil buffer
+     * @param enable defines if the stencil buffer must be enabled or disabled
+     */
+    setStencilBuffer(enable: any): void;
+    /**
+     * Sets the stencil operation to use when stencil passes
+     * @param operation defines the stencil operation to use when stencil passes
+     */
+    setStencilOperationPass(operation: any): void;
+    /**
+     * Sets the current stencil mask
+     * @param mask defines the new stencil mask to use
+     */
+    setStencilMask(mask: any): void;
+    /**
+     * Sets the current stencil function
+     * @param stencilFunc defines the new stencil function to use
+     */
+    setStencilFunction(stencilFunc: any): void;
+    /**
+     * Sets the current stencil reference
+     * @param reference defines the new stencil reference to use
+     */
+    setStencilFunctionReference(reference: any): void;
+    /**
+     * Sets the current stencil mask
+     * @param mask defines the new stencil mask to use
+     */
+    setStencilFunctionMask(mask: any): void;
+    /**
+     * Sets the stencil operation to use when stencil fails
+     * @param operation defines the stencil operation to use when stencil fails
+     */
+    setStencilOperationFail(operation: any): void;
+    /**
+     * Sets the stencil operation to use when depth fails
+     * @param operation defines the stencil operation to use when depth fails
+     */
+    setStencilOperationDepthFail(operation: any): void;
+    /**
+     * Sets alpha constants used by some alpha blending modes
+     * @param r defines the red component
+     * @param g defines the green component
+     * @param b defines the blue component
+     * @param a defines the alpha component
+     */
+    setAlphaConstants(r: any, g: any, b: any, a: any): void;
+    /**
+     * Sets the current alpha mode
+     * @param mode defines the mode to use (one of the BABYLON.undefined)
+     * @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;
+    setInt(uniform: any, int: any): boolean;
+    setIntArray(uniform: any, array: any): boolean;
+    setIntArray2(uniform: any, array: any): boolean;
+    setIntArray3(uniform: any, array: any): boolean;
+    setIntArray4(uniform: any, array: any): boolean;
+    setFloatArray(uniform: any, array: any): boolean;
+    setFloatArray2(uniform: any, array: any): boolean;
+    setFloatArray3(uniform: any, array: any): boolean;
+    setFloatArray4(uniform: any, array: any): boolean;
+    setArray(uniform: any, array: any): boolean;
+    setArray2(uniform: any, array: any): boolean;
+    setArray3(uniform: any, array: any): boolean;
+    setArray4(uniform: any, array: any): boolean;
+    setMatrices(uniform: any, matrices: any): boolean;
+    setMatrix3x3(uniform: any, matrix: any): boolean;
+    setMatrix2x2(uniform: any, matrix: any): boolean;
+    setFloat(uniform: any, value: any): boolean;
+    setFloat2(uniform: any, x: any, y: any): boolean;
+    setFloat3(uniform: any, x: any, y: any, z: any): boolean;
+    setFloat4(uniform: any, x: any, y: any, z: any, w: any): boolean;
+    setColor3(uniform: any, color3: any): boolean;
+    setColor4(uniform: any, color3: any, alpha: any): boolean;
+    wipeCaches(bruteForce: any): void;
+    _createTexture(): any;
+    _deleteTexture(texture: any): void;
+    /**
+     * 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;
+    createDynamicTexture(width: any, height: any, generateMipMaps: any, samplingMode: any): InternalTexture;
+    createVideoElement(constraints: any): any;
+    updateVideoTexture(texture: any, video: any, invertY: any): void;
+    createRawTexture(data: any, width: any, height: any, format: any, generateMipMaps: any, invertY: any, samplingMode: any, compression?: null, type?: number, creationFlags?: number, useSRGBBuffer?: boolean): InternalTexture;
+    createRawTexture2DArray(data: any, width: any, height: any, depth: any, format: any, generateMipMaps: any, invertY: any, samplingMode: any, compression?: null, textureType?: number): InternalTexture;
+    updateRawTexture(texture: any, bufferView: any, format: any, invertY: any, compression?: null, type?: number, useSRGBBuffer?: boolean): void;
+    /**
+     * Usually called from Texture.ts.
+     * Passed information to create a WebGLTexture
+     * @param url defines a value which contains one of the following:
+     * * A conventional http URL, e.g. 'http://...' or 'file://...'
+     * * A base64 string of in-line texture data, e.g. 'data:image/jpg;base64,/...'
+     * * An indicator that data being passed using the buffer parameter, e.g. 'data:mytexture.jpg'
+     * @param noMipmap defines a boolean indicating that no mipmaps shall be generated.  Ignored for compressed textures.  They must be in the file
+     * @param invertY when true, image is flipped when loaded.  You probably want true. Certain compressed textures may invert this if their default is inverted (eg. ktx)
+     * @param scene needed for loading to the correct scene
+     * @param samplingMode mode with should be used sample / access the texture (Default: Texture.TRILINEAR_SAMPLINGMODE)
+     * @param onLoad optional callback to be called upon successful completion
+     * @param onError optional callback to be called upon failure
+     * @param buffer a source of a file previously fetched as either a base64 string, an ArrayBuffer (compressed or image format), HTMLImageElement (image format), or a Blob
+     * @param fallback an internal argument in case the function must be called again, due to etc1 not having alpha capabilities
+     * @param format internal format.  Default: RGB when extension is '.jpg' else RGBA.  Ignored for compressed textures
+     * @param forcedExtension defines the extension to use to pick the right loader
+     * @param mimeType defines an optional mime type
+     * @param loaderOptions options to be passed to the loader
+     * @param creationFlags specific flags to use when creating the texture (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 a InternalTexture for assignment back into BABYLON.Texture
+     */
+    createTexture(url: 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, loaderOptions: any, creationFlags: any, useSRGBBuffer?: boolean): InternalTexture;
+    /**
+     * Wraps an external native texture in a Babylon texture.
+     * @param texture defines the external texture
+     * @returns the babylon internal texture
+     */
+    wrapNativeTexture(texture: any): InternalTexture;
+    /**
+     * Wraps an external web gl texture in a Babylon texture.
+     * @returns the babylon internal texture
+     */
+    wrapWebGLTexture(): void;
+    _createDepthStencilTexture(size: any, options: any, rtWrapper: any): InternalTexture;
+    /**
+     * @internal
+     */
+    _releaseFramebufferObjects(framebuffer: any): void;
+    /** @internal */
+    /**
+     * Engine abstraction for loading and creating an image bitmap from a given source string.
+     * @param imageSource source to load the image from.
+     * @param options An object that sets options for the image's extraction.
+     * @returns ImageBitmap
+     */
+    _createImageBitmapFromSource(imageSource: any, options: any): Promise<any>;
+    /**
+     * Engine abstraction for createImageBitmap
+     * @param image source for image
+     * @param options An object that sets options for the image's extraction.
+     * @returns ImageBitmap
+     */
+    createImageBitmap(image: any, options: any): Promise<any>;
+    /**
+     * Resize an image and returns the image data as an uint8array
+     * @param image image to resize
+     * @param bufferWidth destination buffer width
+     * @param bufferHeight destination buffer height
+     * @returns an uint8array containing RGBA values of bufferWidth * bufferHeight size
+     */
+    resizeImageBitmap(image: any, bufferWidth: any, bufferHeight: any): any;
+    /**
+     * Creates a cube texture
+     * @param rootUrl defines the url where the files to load is located
+     * @param scene defines the current scene
+     * @param files defines the list of files to load (1 per face)
+     * @param noMipmap defines a boolean indicating that no mipmaps shall be generated (false by default)
+     * @param onLoad defines an optional callback raised when the texture is loaded
+     * @param onError defines an optional callback raised if there is an issue to load the texture
+     * @param format defines the format of the data
+     * @param forcedExtension defines the extension to use to pick the right loader
+     * @param createPolynomials if a polynomial sphere should be created for the cube texture
+     * @param lodScale defines the scale applied to environment texture. This manages the range of LOD level used for IBL according to the roughness
+     * @param lodOffset defines the offset applied to environment texture. This manages first LOD level used for IBL according to the roughness
+     * @param fallback defines texture to use while falling back when (compressed) texture file not found.
+     * @param loaderOptions options to be passed to the loader
+     * @param useSRGBBuffer defines if the texture must be loaded in a sRGB GPU buffer (if supported by the GPU).
+     * @returns the cube texture as an InternalTexture
+     */
+    createCubeTexture(rootUrl: any, scene: any, files: any, noMipmap: any, onLoad: null | undefined, onError: null | undefined, format: any, forcedExtension: null | undefined, createPolynomials: boolean | undefined, lodScale: number | undefined, lodOffset: number | undefined, fallback: null | undefined, loaderOptions: any, useSRGBBuffer?: boolean): InternalTexture;
+    /**
+     * @internal
+     */
+    _createHardwareRenderTargetWrapper(isMulti: any, isCube: any, size: any): NativeRenderTargetWrapper;
+    createRenderTargetTexture(size: any, options: any): NativeRenderTargetWrapper;
+    updateTextureSamplingMode(samplingMode: any, texture: any): void;
+    bindFramebuffer(texture: any, faceIndex: any, requiredWidth: any, requiredHeight: any, forceFullscreenViewport: any): void;
+    unBindFramebuffer(texture: any, disableGenerateMipMaps: boolean | undefined, onBeforeUnbind: any): void;
+    createDynamicVertexBuffer(data: any): NativeDataBuffer;
+    updateDynamicIndexBuffer(indexBuffer: any, indices: any, offset?: number): void;
+    updateDynamicVertexBuffer(vertexBuffer: any, verticies: any, byteOffset: any, byteLength: any): void;
+    _setTexture(channel: any, texture: any, isPartOfTextureArray?: boolean, depthStencilTexture?: boolean): boolean;
+    _setTextureSampling(texture: any, filter: any): void;
+    _setTextureWrapMode(texture: any, addressModeU: any, addressModeV: any, addressModeW: any): void;
+    _setTextureCore(uniform: any, texture: any): void;
+    _updateAnisotropicLevel(texture: any): void;
+    _getAddressMode(wrapMode: any): any;
+    /**
+     * @internal
+     */
+    _bindTexture(channel: any, texture: any): void;
+    _deleteBuffer(buffer: any): void;
+    /**
+     * Create a canvas
+     * @param width width
+     * @param height height
+     * @returns ICanvas interface
+     */
+    createCanvas(width: any, height: any): any;
+    /**
+     * Create an image to use with canvas
+     * @returns IImage interface
+     */
+    createCanvasImage(): any;
+    /**
+     * Update a portion of an internal texture
+     * @param texture defines the texture to update
+     * @param imageData defines the data to store into the texture
+     * @param xOffset defines the x coordinates of the update rectangle
+     * @param yOffset defines the y coordinates of the update rectangle
+     * @param width defines the width of the update rectangle
+     * @param height defines the height of the update rectangle
+     * @param faceIndex defines the face index if texture is a cube (0 by default)
+     * @param lod defines the lod level to update (0 by default)
+     * @param generateMipMaps defines whether to generate mipmaps or not
+     */
+    updateTextureData(texture: any, imageData: any, xOffset: any, yOffset: any, width: any, height: any, faceIndex?: number, lod?: number, generateMipMaps?: boolean): void;
+    /**
+     * @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;
+    _getNativeSamplingMode(samplingMode: any): any;
+    _getStencilFunc(func: any): any;
+    _getStencilOpFail(opFail: any): any;
+    _getStencilDepthFail(depthFail: any): any;
+    _getStencilDepthPass(opPass: any): any;
+    _getNativeTextureFormat(format: any, type: any): any;
+    _getNativeAlphaMode(mode: any): any;
+    _getNativeAttribType(type: any): any;
+    getFontOffset(font: any): {
+        ascent: number;
+        height: number;
+        descent: number;
+    };
+    _readTexturePixels(texture: any, width: any, height: any, faceIndex: any, level: any, buffer: any, flushRenderer: any, noDataConversion: any, x: any, y: any): any;
+}
+export namespace NativeEngine {
+    const PROTOCOL_VERSION: number;
+}
+import { Engine } from "../Engines/engine.js";
+/** @internal */
+declare class CommandBufferEncoder {
+    constructor(_engine: any);
+    _engine: any;
+    _pending: any[];
+    _isCommandBufferScopeActive: boolean;
+    _commandStream: NativeDataStream;
+    beginCommandScope(): void;
+    endCommandScope(): void;
+    startEncodingCommand(command: any): void;
+    encodeCommandArgAsUInt32(commandArg: any): void;
+    encodeCommandArgAsUInt32s(commandArg: any): void;
+    encodeCommandArgAsInt32(commandArg: any): void;
+    encodeCommandArgAsInt32s(commandArg: any): void;
+    encodeCommandArgAsFloat32(commandArg: any): void;
+    encodeCommandArgAsFloat32s(commandArg: any): void;
+    encodeCommandArgAsNativeData(commandArg: any): void;
+    finishEncodingCommand(): void;
+    _submit(): void;
+}
+import { WebGL2ShaderProcessor } from "../Engines/WebGL/webGL2ShaderProcessors.js";
+/**
+ * Container for accessors for natively-stored mesh data buffers.
+ */
+declare class NativeDataBuffer extends DataBuffer {
+}
+declare class NativePipelineContext {
+    constructor(engine: any);
+    isAsync: boolean;
+    isReady: boolean;
+    _valueCache: {};
+    engine: any;
+    _getVertexShaderCode(): null;
+    _getFragmentShaderCode(): null;
+    _handlesSpectorRebuildCallback(onCompiled: any): void;
+    _fillEffectInformation(effect: any, uniformBuffersNames: any, uniformsNames: any, uniforms: any, samplerList: any, samplers: any, attributesNames: any, attributes: any): void;
+    _uniforms: any;
+    /**
+     * Release all associated resources.
+     **/
+    dispose(): void;
+    /**
+     * @internal
+     */
+    _cacheMatrix(uniformName: any, matrix: any): boolean;
+    /**
+     * @internal
+     */
+    _cacheFloat2(uniformName: any, x: any, y: any): boolean;
+    /**
+     * @internal
+     */
+    _cacheFloat3(uniformName: any, x: any, y: any, z: any): boolean;
+    /**
+     * @internal
+     */
+    _cacheFloat4(uniformName: any, x: any, y: any, z: any, w: any): boolean;
+    /**
+     * Sets an integer value on a uniform variable.
+     * @param uniformName Name of the variable.
+     * @param value Value to be set.
+     */
+    setInt(uniformName: any, value: any): void;
+    /**
+     * Sets a int2 on a uniform variable.
+     * @param uniformName Name of the variable.
+     * @param x First int in int2.
+     * @param y Second int in int2.
+     */
+    setInt2(uniformName: any, x: any, y: any): void;
+    /**
+     * Sets a int3 on a uniform variable.
+     * @param uniformName Name of the variable.
+     * @param x First int in int3.
+     * @param y Second int in int3.
+     * @param z Third int in int3.
+     */
+    setInt3(uniformName: any, x: any, y: any, z: any): void;
+    /**
+     * Sets a int4 on a uniform variable.
+     * @param uniformName Name of the variable.
+     * @param x First int in int4.
+     * @param y Second int in int4.
+     * @param z Third int in int4.
+     * @param w Fourth int in int4.
+     */
+    setInt4(uniformName: any, x: any, y: any, z: any, w: any): void;
+    /**
+     * Sets an int array on a uniform variable.
+     * @param uniformName Name of the variable.
+     * @param array array to be set.
+     */
+    setIntArray(uniformName: any, array: any): void;
+    /**
+     * Sets an int array 2 on a uniform variable. (Array is specified as single array eg. [1,2,3,4] will result in [[1,2],[3,4]] in the shader)
+     * @param uniformName Name of the variable.
+     * @param array array to be set.
+     */
+    setIntArray2(uniformName: any, array: any): void;
+    /**
+     * Sets an int array 3 on a uniform variable. (Array is specified as single array eg. [1,2,3,4,5,6] will result in [[1,2,3],[4,5,6]] in the shader)
+     * @param uniformName Name of the variable.
+     * @param array array to be set.
+     */
+    setIntArray3(uniformName: any, array: any): void;
+    /**
+     * Sets an int array 4 on a uniform variable. (Array is specified as single array eg. [1,2,3,4,5,6,7,8] will result in [[1,2,3,4],[5,6,7,8]] in the shader)
+     * @param uniformName Name of the variable.
+     * @param array array to be set.
+     */
+    setIntArray4(uniformName: any, array: any): void;
+    /**
+     * Sets an float array on a uniform variable.
+     * @param uniformName Name of the variable.
+     * @param array array to be set.
+     */
+    setFloatArray(uniformName: any, array: any): void;
+    /**
+     * Sets an float array 2 on a uniform variable. (Array is specified as single array eg. [1,2,3,4] will result in [[1,2],[3,4]] in the shader)
+     * @param uniformName Name of the variable.
+     * @param array array to be set.
+     */
+    setFloatArray2(uniformName: any, array: any): void;
+    /**
+     * Sets an float array 3 on a uniform variable. (Array is specified as single array eg. [1,2,3,4,5,6] will result in [[1,2,3],[4,5,6]] in the shader)
+     * @param uniformName Name of the variable.
+     * @param array array to be set.
+     */
+    setFloatArray3(uniformName: any, array: any): void;
+    /**
+     * Sets an float array 4 on a uniform variable. (Array is specified as single array eg. [1,2,3,4,5,6,7,8] will result in [[1,2,3,4],[5,6,7,8]] in the shader)
+     * @param uniformName Name of the variable.
+     * @param array array to be set.
+     */
+    setFloatArray4(uniformName: any, array: any): void;
+    /**
+     * Sets an array on a uniform variable.
+     * @param uniformName Name of the variable.
+     * @param array array to be set.
+     */
+    setArray(uniformName: any, array: any): void;
+    /**
+     * Sets an array 2 on a uniform variable. (Array is specified as single array eg. [1,2,3,4] will result in [[1,2],[3,4]] in the shader)
+     * @param uniformName Name of the variable.
+     * @param array array to be set.
+     */
+    setArray2(uniformName: any, array: any): void;
+    /**
+     * Sets an array 3 on a uniform variable. (Array is specified as single array eg. [1,2,3,4,5,6] will result in [[1,2,3],[4,5,6]] in the shader)
+     * @param uniformName Name of the variable.
+     * @param array array to be set.
+     * @returns this effect.
+     */
+    setArray3(uniformName: any, array: any): void;
+    /**
+     * Sets an array 4 on a uniform variable. (Array is specified as single array eg. [1,2,3,4,5,6,7,8] will result in [[1,2,3,4],[5,6,7,8]] in the shader)
+     * @param uniformName Name of the variable.
+     * @param array array to be set.
+     */
+    setArray4(uniformName: any, array: any): void;
+    /**
+     * Sets matrices on a uniform variable.
+     * @param uniformName Name of the variable.
+     * @param matrices matrices to be set.
+     */
+    setMatrices(uniformName: any, matrices: any): void;
+    /**
+     * Sets matrix on a uniform variable.
+     * @param uniformName Name of the variable.
+     * @param matrix matrix to be set.
+     */
+    setMatrix(uniformName: any, matrix: any): void;
+    /**
+     * Sets a 3x3 matrix on a uniform variable. (Specified as [1,2,3,4,5,6,7,8,9] will result in [1,2,3][4,5,6][7,8,9] matrix)
+     * @param uniformName Name of the variable.
+     * @param matrix matrix to be set.
+     */
+    setMatrix3x3(uniformName: any, matrix: any): void;
+    /**
+     * Sets a 2x2 matrix on a uniform variable. (Specified as [1,2,3,4] will result in [1,2][3,4] matrix)
+     * @param uniformName Name of the variable.
+     * @param matrix matrix to be set.
+     */
+    setMatrix2x2(uniformName: any, matrix: any): void;
+    /**
+     * Sets a float on a uniform variable.
+     * @param uniformName Name of the variable.
+     * @param value value to be set.
+     * @returns this effect.
+     */
+    setFloat(uniformName: any, value: any): void;
+    /**
+     * Sets a boolean on a uniform variable.
+     * @param uniformName Name of the variable.
+     * @param bool value to be set.
+     */
+    setBool(uniformName: any, bool: any): void;
+    /**
+     * Sets a Vector2 on a uniform variable.
+     * @param uniformName Name of the variable.
+     * @param vector2 vector2 to be set.
+     */
+    setVector2(uniformName: any, vector2: any): void;
+    /**
+     * Sets a float2 on a uniform variable.
+     * @param uniformName Name of the variable.
+     * @param x First float in float2.
+     * @param y Second float in float2.
+     */
+    setFloat2(uniformName: any, x: any, y: any): void;
+    /**
+     * Sets a Vector3 on a uniform variable.
+     * @param uniformName Name of the variable.
+     * @param vector3 Value to be set.
+     */
+    setVector3(uniformName: any, vector3: any): void;
+    /**
+     * Sets a float3 on a uniform variable.
+     * @param uniformName Name of the variable.
+     * @param x First float in float3.
+     * @param y Second float in float3.
+     * @param z Third float in float3.
+     */
+    setFloat3(uniformName: any, x: any, y: any, z: any): void;
+    /**
+     * Sets a Vector4 on a uniform variable.
+     * @param uniformName Name of the variable.
+     * @param vector4 Value to be set.
+     */
+    setVector4(uniformName: any, vector4: any): void;
+    /**
+     * Sets a Quaternion on a uniform variable.
+     * @param uniformName Name of the variable.
+     * @param quaternion Value to be set.
+     */
+    setQuaternion(uniformName: any, quaternion: any): void;
+    /**
+     * Sets a float4 on a uniform variable.
+     * @param uniformName Name of the variable.
+     * @param x First float in float4.
+     * @param y Second float in float4.
+     * @param z Third float in float4.
+     * @param w Fourth float in float4.
+     * @returns this effect.
+     */
+    setFloat4(uniformName: any, x: any, y: any, z: any, w: any): void;
+    /**
+     * Sets a Color3 on a uniform variable.
+     * @param uniformName Name of the variable.
+     * @param color3 Value to be set.
+     */
+    setColor3(uniformName: any, color3: any): void;
+    /**
+     * Sets a Color4 on a uniform variable.
+     * @param uniformName Name of the variable.
+     * @param color3 Value to be set.
+     * @param alpha Alpha value to be set.
+     */
+    setColor4(uniformName: any, color3: any, alpha: any): void;
+    /**
+     * Sets a Color4 on a uniform variable
+     * @param uniformName defines the name of the variable
+     * @param color4 defines the value to be set
+     */
+    setDirectColor4(uniformName: any, color4: any): void;
+}
+import { InternalTexture } from "../Materials/Textures/internalTexture.js";
+declare class NativeRenderTargetWrapper extends RenderTargetWrapper {
+    constructor(isMulti: any, isCube: any, size: any, engine: any);
+    __framebuffer: any;
+    __framebufferDepthStencil: any;
+    _engine: any;
+    set _framebuffer(arg: any);
+    get _framebuffer(): any;
+    set _framebufferDepthStencil(arg: any);
+    get _framebufferDepthStencil(): any;
+}
+import { NativeDataStream } from "./Native/nativeDataStream.js";
+import { DataBuffer } from "../Buffers/dataBuffer.js";
+import { RenderTargetWrapper } from "./renderTargetWrapper.js";
+export {};