@combeenation/3d-viewer 0.0.1-types

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

@@ -0,0 +1,763 @@
+/**
+ * The web GPU engine class provides support for WebGPU version of babylon.js.
+ * @since 5.0.0
+ */
+export class WebGPUEngine extends Engine {
+    /**
+     * Create a new instance of the gpu engine asynchronously
+     * @param canvas Defines the canvas to use to display the result
+     * @param options Defines the options passed to the engine to create the GPU context dependencies
+     * @returns a promise that resolves with the created engine
+     */
+    static CreateAsync(canvas: any, options?: {}): Promise<any>;
+    /**
+     * Create a new instance of the gpu engine.
+     * @param canvas Defines the canvas to use to display the result
+     * @param options Defines the options passed to the engine to create the GPU context dependencies
+     */
+    constructor(canvas: any, options?: {});
+    _uploadEncoderDescriptor: {
+        label: string;
+    };
+    _renderEncoderDescriptor: {
+        label: string;
+    };
+    _renderTargetEncoderDescriptor: {
+        label: string;
+    };
+    /** @internal */
+    _clearDepthValue: number;
+    /** @internal */
+    _clearReverseDepthValue: number;
+    /** @internal */
+    _clearStencilValue: number;
+    _defaultSampleCount: number;
+    _glslang: any;
+    _tintWASM: WebGPUTintWASM | null;
+    /** @internal */
+    _compiledComputeEffects: {};
+    /** @internal */
+    _counters: {
+        numEnableEffects: number;
+        numEnableDrawWrapper: number;
+        numBundleCreationNonCompatMode: number;
+        numBundleReuseNonCompatMode: number;
+    };
+    /**
+     * Counters from last frame
+     */
+    countersLastFrame: {
+        numEnableEffects: number;
+        numEnableDrawWrapper: number;
+        numBundleCreationNonCompatMode: number;
+        numBundleReuseNonCompatMode: number;
+    };
+    /**
+     * Max number of uncaptured error messages to log
+     */
+    numMaxUncapturedErrors: number;
+    _commandBuffers: null[];
+    /** @internal */
+    _currentRenderPass: any;
+    /** @internal */
+    _mainRenderPassWrapper: WebGPURenderPassWrapper;
+    /** @internal */
+    _rttRenderPassWrapper: WebGPURenderPassWrapper;
+    /** @internal */
+    _pendingDebugCommands: any[];
+    /** @internal */
+    _onAfterUnbindFrameBufferObservable: Observable<any>;
+    _currentOverrideVertexBuffers: any;
+    _currentIndexBuffer: any;
+    _colorWriteLocal: boolean;
+    _forceEnableEffect: boolean;
+    /** @internal */
+    dbgShowShaderCode: boolean;
+    /** @internal */
+    dbgSanityChecks: boolean;
+    /** @internal */
+    dbgVerboseLogsForFirstFrames: boolean;
+    /** @internal */
+    dbgVerboseLogsNumFrames: number;
+    /** @internal */
+    dbgLogIfNotDrawWrapper: boolean;
+    /** @internal */
+    dbgShowEmptyEnableEffectCalls: boolean;
+    _viewportsCurrent: {
+        x: number;
+        y: number;
+        w: number;
+        h: number;
+    }[];
+    _scissorsCurrent: {
+        x: number;
+        y: number;
+        w: number;
+        h: number;
+    }[];
+    _scissorCached: {
+        x: number;
+        y: number;
+        z: number;
+        w: number;
+    };
+    _stencilRefsCurrent: number[];
+    _blendColorsCurrent: null[][];
+    isNDCHalfZRange: boolean;
+    hasOriginBottomLeft: boolean;
+    _deterministicLockstep: any;
+    _lockstepMaxSteps: any;
+    _timeStep: any;
+    _canvas: any;
+    _options: {} | undefined;
+    premultipliedAlpha: any;
+    _mainPassSampleCount: number | undefined;
+    _isStencilEnable: any;
+    _shaderProcessor: import("@babylonjs/core").Nullable<import("@babylonjs/core").IShaderProcessor> | WebGPUShaderProcessorGLSL;
+    _shaderProcessorWGSL: WebGPUShaderProcessorWGSL | undefined;
+    set disableCacheSamplers(arg: boolean);
+    /**
+     * Sets this to true to disable the cache for the samplers. You should do it only for testing purpose!
+     */
+    get disableCacheSamplers(): boolean;
+    set disableCacheRenderPipelines(arg: boolean);
+    /**
+     * Sets this to true to disable the cache for the render pipelines. You should do it only for testing purpose!
+     */
+    get disableCacheRenderPipelines(): boolean;
+    set disableCacheBindGroups(arg: any);
+    /**
+     * Sets this to true to disable the cache for the bind groups. You should do it only for testing purpose!
+     */
+    get disableCacheBindGroups(): any;
+    /** Gets the supported extensions by the WebGPU adapter */
+    get supportedExtensions(): any[] | undefined;
+    /** Gets the currently enabled extensions on the WebGPU device */
+    get enabledExtensions(): any[] | undefined;
+    set compatibilityMode(arg: any);
+    /**
+     * (WebGPU only) True (default) to be in compatibility mode, meaning rendering all existing scenes without artifacts (same rendering than WebGL).
+     * Setting the property to false will improve performances but may not work in some scenes if some precautions are not taken.
+     * See https://doc.babylonjs.com/advanced_topics/webGPU/webGPUOptimization/webGPUNonCompatibilityMode for more details
+     */
+    get compatibilityMode(): any;
+    _compatibilityMode: any;
+    /** @internal */
+    get currentSampleCount(): any;
+    /**
+     * Initializes the WebGPU context and dependencies.
+     * @param glslangOptions Defines the GLSLang compiler options if necessary
+     * @param twgslOptions Defines the Twgsl compiler options if necessary
+     * @returns a promise notifying the readiness of the engine.
+     */
+    initAsync(glslangOptions: any, twgslOptions: any): any;
+    _adapter: any;
+    _adapterSupportedExtensions: any[] | undefined;
+    _device: any;
+    _deviceEnabledExtensions: any[] | undefined;
+    _bufferManager: WebGPUBufferManager | undefined;
+    _textureHelper: WebGPUTextureHelper | undefined;
+    _cacheSampler: WebGPUCacheSampler | undefined;
+    _cacheBindGroups: any;
+    _timestampQuery: WebGPUTimestampQuery | undefined;
+    _occlusionQuery: WebGPUOcclusionQuery | undefined;
+    _bundleList: WebGPUBundleList | undefined;
+    _bundleListRenderTarget: WebGPUBundleList | undefined;
+    _snapshotRendering: WebGPUSnapshotRendering | undefined;
+    _ubInvertY: import("@babylonjs/core").WebGPUDataBuffer | undefined;
+    _ubDontInvertY: import("@babylonjs/core").WebGPUDataBuffer | undefined;
+    _count: number | undefined;
+    _uploadEncoder: any;
+    _renderEncoder: any;
+    _renderTargetEncoder: any;
+    _emptyVertexBuffer: VertexBuffer | undefined;
+    _cacheRenderPipeline: WebGPUCacheRenderPipelineTree | undefined;
+    _clearQuad: any;
+    _defaultDrawContext: WebGPUDrawContext | undefined;
+    _defaultMaterialContext: WebGPUMaterialContext | undefined;
+    _initGlslang(glslangOptions: any): any;
+    _initializeLimits(): void;
+    _initializeContextAndSwapChain(): void;
+    _context: any;
+    _colorFormat: any;
+    _initializeMainAttachments(): void;
+    _mainTextureExtends: {
+        width: any;
+        height: any;
+        depthOrArrayLayers: number;
+    } | undefined;
+    _mainTexture: any;
+    _depthTexture: any;
+    _configureContext(): void;
+    /**
+     * Force a specific size of the canvas
+     * @param width defines the new canvas' width
+     * @param height defines the new canvas' height
+     * @param forceSetSize true to force setting the sizes of the underlying canvas
+     * @returns true if the size was changed
+     */
+    setSize(width: any, height: any, forceSetSize?: boolean): boolean;
+    /**
+     * @internal
+     */
+    _getShaderProcessor(shaderLanguage: any): import("@babylonjs/core").Nullable<import("@babylonjs/core").IShaderProcessor> | WebGPUShaderProcessorGLSL | WebGPUShaderProcessorWGSL | undefined;
+    /**
+     * @internal
+     */
+    _getShaderProcessingContext(shaderLanguage: any): WebGPUShaderProcessingContext;
+    /**
+     * Force the entire cache to be cleared
+     * You should not have to use this function unless your engine needs to share the WebGPU context with another engine
+     * @param bruteForce defines a boolean to force clearing ALL caches (including stencil, detoh and alpha states)
+     */
+    wipeCaches(bruteForce: any): void;
+    /**
+     * Enable or disable color writing
+     * @param enable defines the state to set
+     */
+    setColorWrite(enable: any): void;
+    _resetCurrentViewport(index: any): void;
+    _mustUpdateViewport(renderPass: any): boolean;
+    _applyViewport(renderPass: any): void;
+    /**
+     * @internal
+     */
+    _viewport(x: any, y: any, width: any, height: any): void;
+    _resetCurrentScissor(index: any): void;
+    _mustUpdateScissor(renderPass: any): boolean;
+    _applyScissor(renderPass: any): void;
+    _scissorIsActive(): boolean;
+    enableScissor(x: any, y: any, width: any, height: any): void;
+    _resetCurrentStencilRef(index: any): void;
+    _mustUpdateStencilRef(renderPass: any): boolean;
+    /**
+     * @internal
+     */
+    _applyStencilRef(renderPass: any): void;
+    _resetCurrentColorBlend(index: any): void;
+    _mustUpdateBlendColor(renderPass: any): boolean;
+    _applyBlendColor(renderPass: any): void;
+    /**
+     * 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;
+    _clearFullQuad(clearColor: any, clearDepth: any, clearStencil: any): void;
+    /**
+     * Creates a vertex buffer
+     * @param data the data for the vertex buffer
+     * @returns the new buffer
+     */
+    createVertexBuffer(data: any): import("@babylonjs/core").WebGPUDataBuffer;
+    /**
+     * Creates a vertex buffer
+     * @param data the data for the dynamic vertex buffer
+     * @returns the new buffer
+     */
+    createDynamicVertexBuffer(data: any): import("@babylonjs/core").WebGPUDataBuffer;
+    /**
+     * Creates a new index buffer
+     * @param indices defines the content of the index buffer
+     * @returns a new buffer
+     */
+    createIndexBuffer(indices: any): import("@babylonjs/core").WebGPUDataBuffer;
+    /**
+     * @internal
+     */
+    _createBuffer(data: any, creationFlags: any): import("@babylonjs/core").WebGPUDataBuffer;
+    /**
+     * @internal
+     */
+    bindBuffersDirectly(): void;
+    /**
+     * @internal
+     */
+    updateAndBindInstancesBuffer(): void;
+    /**
+     * Bind a list of vertex buffers with the engine
+     * @param vertexBuffers defines the list of vertex buffers to bind
+     * @param indexBuffer defines the index buffer to bind
+     * @param effect defines the effect associated with the vertex buffers
+     * @param overrideVertexBuffers defines optional list of avertex buffers that overrides the entries in vertexBuffers
+     */
+    bindBuffers(vertexBuffers: any, indexBuffer: any, effect: any, overrideVertexBuffers: any): void;
+    /**
+     * @internal
+     */
+    _releaseBuffer(buffer: any): boolean;
+    /**
+     * Create a new effect (used to store vertex/fragment shaders)
+     * @param baseName defines the base name of the effect (The name of file without .fragment.fx or .vertex.fx)
+     * @param attributesNamesOrOptions defines either a list of attribute names or an IEffectCreationOptions object
+     * @param uniformsNamesOrEngine defines either a list of uniform names or the engine to use
+     * @param samplers defines an array of string used to represent textures
+     * @param defines defines the string containing the defines to use to compile the shaders
+     * @param fallbacks defines the list of potential fallbacks to use if shader compilation fails
+     * @param onCompiled defines a function to call when the effect creation is successful
+     * @param onError defines a function to call when the effect creation has failed
+     * @param indexParameters defines an object containing the index values to use to compile shaders (like the maximum number of simultaneous lights)
+     * @param shaderLanguage the language the shader is written in (default: GLSL)
+     * @returns the new Effect
+     */
+    createEffect(baseName: any, attributesNamesOrOptions: any, uniformsNamesOrEngine: any, samplers: any, defines: any, fallbacks: any, onCompiled: any, onError: any, indexParameters: any, shaderLanguage?: ShaderLanguage): Effect;
+    _compileRawShaderToSpirV(source: any, type: any): any;
+    _compileShaderToSpirV(source: any, type: any, defines: any, shaderVersion: any): any;
+    _getWGSLShader(source: any, type: any, defines: any): any;
+    _createPipelineStageDescriptor(vertexShader: any, fragmentShader: any, shaderLanguage: any): {
+        vertexStage: {
+            module: any;
+            entryPoint: string;
+        };
+        fragmentStage: {
+            module: any;
+            entryPoint: string;
+        };
+    };
+    _compileRawPipelineStageDescriptor(vertexCode: any, fragmentCode: any, shaderLanguage: any): {
+        vertexStage: {
+            module: any;
+            entryPoint: string;
+        };
+        fragmentStage: {
+            module: any;
+            entryPoint: string;
+        };
+    };
+    _compilePipelineStageDescriptor(vertexCode: any, fragmentCode: any, defines: any, shaderLanguage: any): {
+        vertexStage: {
+            module: any;
+            entryPoint: string;
+        };
+        fragmentStage: {
+            module: any;
+            entryPoint: string;
+        };
+    };
+    /**
+     * @internal
+     */
+    createRawShaderProgram(): void;
+    /**
+     * @internal
+     */
+    createShaderProgram(): void;
+    /**
+     * Inline functions in shader code that are marked to be inlined
+     * @param code code to inline
+     * @returns inlined code
+     */
+    inlineShaderCode(code: any): string;
+    /**
+     * Creates a new pipeline context
+     * @param shaderProcessingContext defines the shader processing context used during the processing if available
+     * @returns the new pipeline
+     */
+    createPipelineContext(shaderProcessingContext: any): WebGPUPipelineContext;
+    /**
+     * Creates a new material context
+     * @returns the new context
+     */
+    createMaterialContext(): WebGPUMaterialContext;
+    /**
+     * Creates a new draw context
+     * @returns the new context
+     */
+    createDrawContext(): WebGPUDrawContext;
+    /**
+     * @internal
+     */
+    _preparePipelineContext(pipelineContext: any, vertexSourceCode: any, fragmentSourceCode: any, createAsRaw: any, rawVertexSourceCode: any, rawFragmentSourceCode: any, rebuildRebind: any, defines: any): void;
+    /**
+     * Gets the list of active attributes for a given WebGPU 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): any[];
+    /**
+     * 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;
+    _currentEffect: any;
+    /**
+     * @internal
+     */
+    _releaseEffect(effect: any): void;
+    _deletePipelineContext(pipelineContext: any): void;
+    /** @internal */
+    _createHardwareTexture(): WebGPUHardwareTexture;
+    /**
+     * @internal
+     */
+    _releaseTexture(texture: any): void;
+    /**
+     * @internal
+     */
+    _getRGBABufferInternalSizedFormat(): number;
+    updateTextureComparisonFunction(texture: any, comparisonFunction: any): void;
+    /**
+     * Creates an internal texture without binding it to a framebuffer
+     * @internal
+     * @param size defines the size of the texture
+     * @param options defines the options used to create the texture
+     * @param delayGPUTextureCreation true to delay the texture creation the first time it is really needed. false to create it right away
+     * @param source source type of the texture
+     * @returns a new internal texture
+     */
+    _createInternalTexture(size: any, options: any, delayGPUTextureCreation?: boolean, source?: InternalTextureSource): InternalTexture;
+    /**
+     * Usually called from Texture.ts.
+     * Passed information to create a hardware texture
+     * @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: any): InternalTexture;
+    /**
+     * Wraps an external web gpu texture in a Babylon texture.
+     * @param texture defines the external texture
+     * @returns the babylon internal texture
+     */
+    wrapWebGPUTexture(texture: any): InternalTexture;
+    /**
+     * Wraps an external web gl texture in a Babylon texture.
+     * @returns the babylon internal texture
+     */
+    wrapWebGLTexture(): void;
+    generateMipMapsForCubemap(texture: any): void;
+    /**
+     * Update the sampling mode of a given texture
+     * @param samplingMode defines the required sampling mode
+     * @param texture defines the texture to update
+     * @param generateMipMaps defines whether to generate mipmaps for the texture
+     */
+    updateTextureSamplingMode(samplingMode: any, texture: any, generateMipMaps?: boolean): void;
+    /**
+     * Update the sampling mode of a given texture
+     * @param texture defines the texture to update
+     * @param wrapU defines the texture wrap mode of the u coordinates
+     * @param wrapV defines the texture wrap mode of the v coordinates
+     * @param wrapR defines the texture wrap mode of the r coordinates
+     */
+    updateTextureWrappingMode(texture: any, wrapU: any, wrapV?: null, wrapR?: null): void;
+    /**
+     * Update the dimensions of a texture
+     * @param texture texture to update
+     * @param width new width of the texture
+     * @param height new height of the texture
+     * @param depth new depth of the texture
+     */
+    updateTextureDimensions(texture: any, width: any, height: any, depth?: number): void;
+    /**
+     * @internal
+     */
+    _setInternalTexture(name: any, texture: any, baseName: any): void;
+    /**
+     * Sets a texture to the according uniform.
+     * @param channel The texture channel
+     * @param unused unused parameter
+     * @param texture The texture to apply
+     * @param name The name of the uniform in the effect
+     */
+    setTexture(channel: any, unused: any, texture: any, name: any): void;
+    /**
+     * Sets an array of texture to the WebGPU context
+     * @param channel defines the channel where the texture array must be set
+     * @param unused unused parameter
+     * @param textures defines the array of textures to bind
+     * @param name name of the channel
+     */
+    setTextureArray(channel: any, unused: any, textures: any, name: any): void;
+    _setTexture(channel: any, texture: any, isPartOfTextureArray: boolean | undefined, depthStencilTexture: boolean | undefined, name: string | undefined, baseName: any): boolean;
+    /**
+     * @internal
+     */
+    _setAnisotropicLevel(target: any, internalTexture: any, anisotropicFilteringLevel: any): void;
+    /**
+     * @internal
+     */
+    _bindTexture(channel: any, texture: any, name: any): void;
+    /**
+     * Generates the mipmaps for a texture
+     * @param texture texture to generate the mipmaps for
+     */
+    generateMipmaps(texture: any): void;
+    /**
+     * @internal
+     */
+    _generateMipmaps(texture: any, commandEncoder: any): void;
+    /**
+     * Update a portion of an internal texture
+     * @param texture defines the texture to update
+     * @param imageData defines the data to store into the texture
+     * @param xOffset defines the x coordinates of the update rectangle
+     * @param yOffset defines the y coordinates of the update rectangle
+     * @param width defines the width of the update rectangle
+     * @param height defines the height of the update rectangle
+     * @param faceIndex defines the face index if texture is a cube (0 by default)
+     * @param lod defines the lod level to update (0 by default)
+     * @param generateMipMaps defines whether to generate mipmaps or not
+     */
+    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, imageData: any, faceIndex?: number, lod?: number): void;
+    /**
+     * @internal
+     */
+    _uploadDataToTextureDirectly(texture: any, imageData: any, faceIndex: number | undefined, lod: number | undefined, babylonInternalFormat: any, useTextureWidthAndHeight?: boolean): void;
+    /**
+     * @internal
+     */
+    _uploadArrayBufferViewToTexture(texture: any, imageData: any, faceIndex?: number, lod?: number): void;
+    /**
+     * @internal
+     */
+    _uploadImageToTexture(texture: any, image: any, faceIndex?: number, lod?: number): void;
+    /**
+     * Reads pixels from the current frame buffer. Please note that this function can be slow
+     * @param x defines the x coordinate of the rectangle where pixels must be read
+     * @param y defines the y coordinate of the rectangle where pixels must be read
+     * @param width defines the width of the rectangle where pixels must be read
+     * @param height defines the height of the rectangle where pixels must be read
+     * @param hasAlpha defines whether the output should have alpha or not (defaults to true)
+     * @param flushRenderer true to flush the renderer from the pending commands before reading the pixels
+     * @returns a ArrayBufferView promise (Uint8Array) containing RGBA colors
+     */
+    readPixels(x: any, y: any, width: any, height: any, hasAlpha?: boolean, flushRenderer?: boolean): Promise<ArrayBufferView> | Promise<Uint8Array>;
+    /**
+     * Force a WebGPU flush (ie. a flush of all waiting commands)
+     * @param reopenPass true to reopen at the end of the function the pass that was active when entering the function
+     */
+    flushFramebuffer(reopenPass?: boolean): void;
+    _startRenderTargetRenderPass(renderTargetWrapper: any, setClearStates: any, clearColor: any, clearDepth: any, clearStencil: any): void;
+    _mrtAttachments: any;
+    /** @internal */
+    _endRenderTargetRenderPass(): void;
+    _getCurrentRenderPass(): any;
+    /** @internal */
+    _getCurrentRenderPassIndex(): 1 | -1 | 0;
+    _startMainRenderPass(setClearStates: any, clearColor: any, clearDepth: any, clearStencil: any): void;
+    _swapChainTexture: any;
+    _endMainRenderPass(): void;
+    /**
+     * Binds the frame buffer to the specified texture.
+     * @param texture 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
+     * @param lodLevel defines the lod level to bind to the frame buffer
+     * @param layer defines the 2d array index to bind to frame buffer to
+     */
+    bindFramebuffer(texture: any, faceIndex: number | undefined, requiredWidth: any, requiredHeight: any, forceFullscreenViewport: any, lodLevel?: number, layer?: number): void;
+    _currentRenderTarget: any;
+    /**
+     * Unbind the current render target texture from the WebGPU context
+     * @param texture defines the render target wrapper to unbind
+     * @param disableGenerateMipMaps defines a boolean indicating that mipmaps must not be generated
+     * @param onBeforeUnbind defines a function which will be called before the effective unbind
+     */
+    unBindFramebuffer(texture: any, disableGenerateMipMaps: boolean | undefined, onBeforeUnbind: any): void;
+    /**
+     * @internal
+     */
+    _setColorFormat(wrapper: any): void;
+    /**
+     * @internal
+     */
+    _setDepthTextureFormat(wrapper: any): void;
+    _depthTextureFormat: any;
+    setDitheringState(): void;
+    setRasterizerState(): 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;
+    _applyRenderPassChanges(renderPass: any, bundleList: any): void;
+    _draw(drawType: any, fillMode: any, start: any, count: 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?: number): void;
+    /**
+     * Draw a list of unindexed primitives
+     * @param fillMode defines the primitive to use
+     * @param verticesStart defines the index of first vertex to draw
+     * @param verticesCount defines the count of vertices to draw
+     * @param instancesCount defines the number of instances to draw (if instantiation is enabled)
+     */
+    drawArraysType(fillMode: any, verticesStart: any, verticesCount: any, instancesCount?: number): void;
+    /**
+     * Gets the current render width
+     * @param useScreen defines if screen size must be used (or the current render target if any)
+     * @returns a number defining the current render width
+     */
+    getRenderWidth(useScreen?: boolean): any;
+    /**
+     * Gets the current render height
+     * @param useScreen defines if screen size must be used (or the current render target if any)
+     * @returns a number defining the current render height
+     */
+    getRenderHeight(useScreen?: boolean): any;
+    /**
+     * Gets the HTML canvas attached with the current WebGPU context
+     * @returns a HTML canvas
+     */
+    getRenderingCanvas(): any;
+    /**
+     * @internal
+     */
+    bindSamplers(): void;
+    /**
+     * @internal
+     */
+    _bindTextureDirectly(): boolean;
+    /**
+     * @internal
+     */
+    _executeWhenRenderingStateIsCompiled(pipelineContext: any, action: any): void;
+    /**
+     * @internal
+     */
+    _isRenderingStateCompiled(): boolean;
+    /**
+     * @internal
+     */
+    _unpackFlipY(): void;
+    /**
+     * @internal
+     */
+    _bindUnboundFramebuffer(): void;
+    /**
+     * @internal
+     */
+    _getSamplingParameters(): void;
+    /**
+     * @internal
+     */
+    getUniforms(): never[];
+    /**
+     * @internal
+     */
+    setIntArray(): boolean;
+    /**
+     * @internal
+     */
+    setIntArray2(): boolean;
+    /**
+     * @internal
+     */
+    setIntArray3(): boolean;
+    /**
+     * @internal
+     */
+    setIntArray4(): boolean;
+    /**
+     * @internal
+     */
+    setArray(): boolean;
+    /**
+     * @internal
+     */
+    setArray2(): boolean;
+    /**
+     * @internal
+     */
+    setArray3(): boolean;
+    /**
+     * @internal
+     */
+    setArray4(): boolean;
+    /**
+     * @internal
+     */
+    setMatrices(): boolean;
+    /**
+     * @internal
+     */
+    setMatrix3x3(): boolean;
+    /**
+     * @internal
+     */
+    setMatrix2x2(): boolean;
+    /**
+     * @internal
+     */
+    setFloat(): boolean;
+    /**
+     * @internal
+     */
+    setFloat2(): boolean;
+    /**
+     * @internal
+     */
+    setFloat3(): boolean;
+    /**
+     * @internal
+     */
+    setFloat4(): boolean;
+}
+export namespace WebGPUEngine {
+    namespace _GLSLslangDefaultOptions {
+        const jsPath: string;
+        const wasmPath: string;
+    }
+    const UseTWGSL: boolean;
+}
+import { Engine } from "../Engines/engine.js";
+import { WebGPUTintWASM } from "./WebGPU/webgpuTintWASM.js";
+import { WebGPURenderPassWrapper } from "./WebGPU/webgpuRenderPassWrapper.js";
+import { Observable } from "../Misc/observable.js";
+import { WebGPUShaderProcessorGLSL } from "./WebGPU/webgpuShaderProcessorsGLSL.js";
+import { WebGPUShaderProcessorWGSL } from "./WebGPU/webgpuShaderProcessorsWGSL.js";
+import { WebGPUBufferManager } from "./WebGPU/webgpuBufferManager.js";
+import { WebGPUTextureHelper } from "./WebGPU/webgpuTextureHelper.js";
+import { WebGPUCacheSampler } from "./WebGPU/webgpuCacheSampler.js";
+import { WebGPUTimestampQuery } from "./WebGPU/webgpuTimestampQuery.js";
+import { WebGPUOcclusionQuery } from "./WebGPU/webgpuOcclusionQuery.js";
+import { WebGPUBundleList } from "./WebGPU/webgpuBundleList.js";
+import { WebGPUSnapshotRendering } from "./WebGPU/webgpuSnapshotRendering.js";
+import { VertexBuffer } from "../Buffers/buffer.js";
+import { WebGPUCacheRenderPipelineTree } from "./WebGPU/webgpuCacheRenderPipelineTree.js";
+import { WebGPUDrawContext } from "./WebGPU/webgpuDrawContext.js";
+import { WebGPUMaterialContext } from "./WebGPU/webgpuMaterialContext.js";
+import { WebGPUShaderProcessingContext } from "./WebGPU/webgpuShaderProcessingContext.js";
+import { ShaderLanguage } from "../Materials/shaderLanguage.js";
+import { Effect } from "../Materials/effect.js";
+import { WebGPUPipelineContext } from "./WebGPU/webgpuPipelineContext.js";
+import { WebGPUHardwareTexture } from "./WebGPU/webgpuHardwareTexture.js";
+import { InternalTextureSource } from "../Materials/Textures/internalTexture.js";
+import { InternalTexture } from "../Materials/Textures/internalTexture.js";