@babylonjs/core 7.2.2 → 7.3.0

package/Engines/webgpuEngine.d.ts

@@ -1,5 +1,4 @@
 import type { Nullable, DataArray, IndicesArray, Immutable, FloatArray } from "../types";
-import { Engine } from "../Engines/engine";
 import { InternalTexture, InternalTextureSource } from "../Materials/Textures/internalTexture";
 import type { IEffectCreationOptions, IShaderPath } from "../Materials/effect";
 import { Effect } from "../Materials/effect";
@@ -11,14 +10,14 @@ import type { BaseTexture } from "../Materials/Textures/baseTexture";
 import type { IShaderProcessor } from "./Processors/iShaderProcessor";
 import type { ShaderProcessingContext } from "./Processors/shaderProcessingOptions";
 import { WebGPUTextureManager } from "./WebGPU/webgpuTextureManager";
-import type { ISceneLike, ThinEngineOptions } from "./thinEngine";
+import { type ISceneLike, AbstractEngine } from "./abstractEngine";
 import { WebGPUBufferManager } from "./WebGPU/webgpuBufferManager";
 import type { HardwareTextureWrapper } from "../Materials/Textures/hardwareTextureWrapper";
 import { WebGPUHardwareTexture } from "./WebGPU/webgpuHardwareTexture";
 import type { IColor4Like } from "../Maths/math.like";
 import { WebGPUCacheSampler } from "./WebGPU/webgpuCacheSampler";
 import type { WebGPUCacheRenderPipeline } from "./WebGPU/webgpuCacheRenderPipeline";
-import { DrawWrapper } from "../Materials/drawWrapper";
+import type { DrawWrapper } from "../Materials/drawWrapper";
 import { WebGPUMaterialContext } from "./WebGPU/webgpuMaterialContext";
 import { WebGPUDrawContext } from "./WebGPU/webgpuDrawContext";
 import type { IStencilState } from "../States/IStencilState";
@@ -33,8 +32,18 @@ import type { InternalTextureCreationOptions, TextureSize } from "../Materials/T
 import type { WebGPUDataBuffer } from "../Meshes/WebGPU/webgpuDataBuffer";
 import "../Buffers/buffer.align";
 import "../ShadersWGSL/postprocess.vertex";
+import type { RenderTargetTexture } from "../Materials/Textures/renderTargetTexture";
 import type { RenderTargetWrapper } from "./renderTargetWrapper";
 import { WebGPUPerfCounter } from "./WebGPU/webgpuPerfCounter";
+import type { Scene } from "../scene";
+import type { AbstractEngineOptions } from "./abstractEngine";
+import type { PostProcess } from "../PostProcesses/postProcess";
+import { PerformanceMonitor } from "../Misc/performanceMonitor";
+import "./AbstractEngine/abstractEngine.loadingScreen";
+import "./AbstractEngine/abstractEngine.dom";
+import "./AbstractEngine/abstractEngine.states";
+import "./AbstractEngine/abstractEngine.renderPass";
+import "../Audio/audioEngine";
 /** @internal */
 interface IWebGPURenderPassWrapper {
     renderPassDescriptor: Nullable<GPURenderPassDescriptor>;
@@ -63,7 +72,7 @@ export interface GlslangOptions {
 /**
  * Options to create the WebGPU engine
  */
-export interface WebGPUEngineOptions extends ThinEngineOptions, GPURequestAdapterOptions {
+export interface WebGPUEngineOptions extends AbstractEngineOptions, GPURequestAdapterOptions {
     /**
      * Defines the category of adapter to use.
      * Is it the discrete or integrated device.
@@ -110,7 +119,7 @@ export interface WebGPUEngineOptions extends ThinEngineOptions, GPURequestAdapte
  * The web GPU engine class provides support for WebGPU version of babylon.js.
  * @since 5.0.0
  */
-export declare class WebGPUEngine extends Engine {
+export declare class WebGPUEngine extends AbstractEngine {
     private static readonly _GLSLslangDefaultOptions;
     private static _InstanceId;
     /** true to enable using TintWASM to convert Spir-V to WGSL */
@@ -185,6 +194,12 @@ export declare class WebGPUEngine extends Engine {
      * Max number of uncaptured error messages to log
      */
     numMaxUncapturedErrors: number;
+    /**
+     * Gets the list of created scenes
+     */
+    scenes: Scene[];
+    /** @internal */
+    _virtualScenes: Scene[];
     private _mainTexture;
     private _depthTexture;
     private _mainTextureExtends;
@@ -233,6 +248,7 @@ export declare class WebGPUEngine extends Engine {
     /** @internal */
     dbgShowEmptyEnableEffectCalls: boolean;
     private _snapshotRendering;
+    protected _snapshotRenderingMode: number;
     /**
      * Gets or sets the snapshot rendering mode
      */
@@ -263,6 +279,21 @@ export declare class WebGPUEngine extends Engine {
      */
     get disableCacheBindGroups(): boolean;
     set disableCacheBindGroups(disable: boolean);
+    /**
+     * Gets a boolean indicating if all created effects are ready
+     * @returns true if all effects are ready
+     */
+    areAllEffectsReady(): boolean;
+    /**
+     * Get Font size information
+     * @param font font name
+     * @returns an object containing ascent, height and descent
+     */
+    getFontOffset(font: string): {
+        ascent: number;
+        height: number;
+        descent: number;
+    };
     /**
      * Gets a Promise<boolean> indicating if the engine can be instantiated (ie. if a WebGPU context can be found)
      */
@@ -353,9 +384,73 @@ export declare class WebGPUEngine extends Engine {
     private _initializeLimits;
     private _initializeContextAndSwapChain;
     private _initializeMainAttachments;
+    /**
+     * Shared initialization across engines types.
+     * @param canvas The canvas associated with this instance of the engine.
+     */
+    protected _sharedInit(canvas: HTMLCanvasElement): void;
     private _configureContext;
+    /**
+     * 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: HTMLImageElement | ImageBitmap, bufferWidth: number, bufferHeight: number): Uint8Array;
+    /**
+     * 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: string, options?: ImageBitmapOptions): Promise<ImageBitmap>;
+    /**
+     * Toggle full screen mode
+     * @param requestPointerLock defines if a pointer lock should be requested from the user
+     */
+    switchFullscreen(requestPointerLock: boolean): void;
+    /**
+     * Enters full screen mode
+     * @param requestPointerLock defines if a pointer lock should be requested from the user
+     */
+    enterFullscreen(requestPointerLock: boolean): void;
+    /**
+     * Exits full screen mode
+     */
+    exitFullscreen(): void;
+    /**
+     * Enters Pointerlock mode
+     */
+    enterPointerlock(): void;
+    /**
+     * Exits Pointerlock mode
+     */
+    exitPointerlock(): void;
     protected _rebuildBuffers(): void;
     protected _restoreEngineAfterContextLost(initEngine: () => void): void;
+    /**
+     * Sets a depth stencil texture from a render target to the according uniform.
+     * @param channel The texture channel
+     * @param uniform The uniform to set
+     * @param texture The render target texture containing the depth stencil texture to apply
+     * @param name The texture name
+     */
+    setDepthStencilTexture(channel: number, uniform: Nullable<WebGLUniformLocation>, texture: Nullable<RenderTargetTexture>, name?: string): void;
+    /**
+     * Sets a texture to the context from a postprocess
+     * @param channel defines the channel to use
+     * @param postProcess defines the source postprocess
+     * @param name name of the channel
+     */
+    setTextureFromPostProcess(channel: number, postProcess: Nullable<PostProcess>, name: string): void;
+    /**
+     * Binds the output of the passed in post process to the texture channel specified
+     * @param channel The channel the texture should be bound to
+     * @param postProcess The post process which's output should be bound
+     * @param name name of the channel
+     */
+    setTextureFromPostProcessOutput(channel: number, postProcess: Nullable<PostProcess>, name: string): void;
     /**
      * Force a specific size of the canvas
      * @param width defines the new canvas' width
@@ -480,6 +575,10 @@ export declare class WebGPUEngine extends Engine {
      * @internal
      */
     updateAndBindInstancesBuffer(): void;
+    /**
+     * Unbind all instance attributes
+     */
+    unbindInstanceAttributes(): void;
     /**
      * Bind a list of vertex buffers with the engine
      * @param vertexBuffers defines the list of vertex buffers to bind
@@ -549,7 +648,7 @@ export declare class WebGPUEngine extends Engine {
     createEffect(baseName: string | (IShaderPath & {
         vertexToken?: string;
         fragmentToken?: string;
-    }), attributesNamesOrOptions: string[] | IEffectCreationOptions, uniformsNamesOrEngine: string[] | Engine, samplers?: string[], defines?: string, fallbacks?: EffectFallbacks, onCompiled?: Nullable<(effect: Effect) => void>, onError?: Nullable<(effect: Effect, errors: string) => void>, indexParameters?: any, shaderLanguage?: ShaderLanguage): Effect;
+    }), attributesNamesOrOptions: string[] | IEffectCreationOptions, uniformsNamesOrEngine: string[] | AbstractEngine, samplers?: string[], defines?: string, fallbacks?: EffectFallbacks, onCompiled?: Nullable<(effect: Effect) => void>, onError?: Nullable<(effect: Effect, errors: string) => void>, indexParameters?: any, shaderLanguage?: ShaderLanguage): Effect;
     private _compileRawShaderToSpirV;
     private _compileShaderToSpirV;
     private _getWGSLShader;
@@ -673,6 +772,10 @@ export declare class WebGPUEngine extends Engine {
      */
     wrapWebGLTexture(): InternalTexture;
     generateMipMapsForCubemap(texture: InternalTexture): void;
+    /**
+     * @internal
+     */
+    _getUseSRGBBuffer(useSRGBBuffer: boolean, noMipmap: boolean): boolean;
     /**
      * Update the sampling mode of a given texture
      * @param samplingMode defines the required sampling mode
@@ -700,6 +803,20 @@ export declare class WebGPUEngine extends Engine {
      * @internal
      */
     _setInternalTexture(name: string, texture: Nullable<InternalTexture | ExternalTexture>, baseName?: string): void;
+    /**
+     * Create a cube texture from prefiltered data (ie. the mipmaps contain ready to use data for PBR reflection)
+     * @param rootUrl defines the url where the file to load is located
+     * @param scene defines the current scene
+     * @param lodScale defines scale to apply to the mip map selection
+     * @param lodOffset defines offset to apply to the mip map selection
+     * @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 defines wheter or not to create polynomails harmonics for the texture
+     * @returns the cube texture as an InternalTexture
+     */
+    createPrefilteredCubeTexture(rootUrl: string, scene: Nullable<Scene>, lodScale: number, lodOffset: number, onLoad?: Nullable<(internalTexture: Nullable<InternalTexture>) => void>, onError?: Nullable<(message?: string, exception?: any) => void>, format?: number, forcedExtension?: any, createPolynomials?: boolean): InternalTexture;
     /**
      * Sets a texture to the according uniform.
      * @param channel The texture channel
@@ -724,7 +841,7 @@ export declare class WebGPUEngine extends Engine {
     /**
      * @internal
      */
-    _bindTexture(channel: number, texture: InternalTexture, name: string): void;
+    _bindTexture(channel: number, texture: Nullable<InternalTexture>, name: string): void;
     /**
      * Generates the mipmaps for a texture
      * @param texture texture to generate the mipmaps for
@@ -774,6 +891,13 @@ export declare class WebGPUEngine extends Engine {
      * @returns a ArrayBufferView promise (Uint8Array) containing RGBA colors
      */
     readPixels(x: number, y: number, width: number, height: number, hasAlpha?: boolean, flushRenderer?: boolean): Promise<ArrayBufferView>;
+    private _measureFps;
+    private _performanceMonitor;
+    /**
+     * Gets the performance monitor attached to this engine
+     * @see https://doc.babylonjs.com/features/featuresDeepDive/scene/optimize_your_scene#engineinstrumentation
+     */
+    get performanceMonitor(): PerformanceMonitor;
     /**
      * Begin a new frame
      */
@@ -782,6 +906,8 @@ export declare class WebGPUEngine extends Engine {
      * End the current frame
      */
     endFrame(): void;
+    /**Gets driver info if available */
+    extractDriverInfo(): string;
     /**
      * Force a WebGPU flush (ie. a flush of all waiting commands)
      */
@@ -824,6 +950,20 @@ export declare class WebGPUEngine extends Engine {
     _setDepthTextureFormat(wrapper: IWebGPURenderPassWrapper): void;
     setDitheringState(): void;
     setRasterizerState(): void;
+    /**
+     * @internal
+     */
+    _executeWhenRenderingStateIsCompiled(pipelineContext: IPipelineContext, action: () => void): void;
+    /**
+     * @internal
+     */
+    bindSamplers(): void;
+    /** @internal */
+    _getUnpackAlignement(): number;
+    /**
+     * @internal
+     */
+    _bindTextureDirectly(): boolean;
     /**
      * Set various states to the webGL context
      * @param culling defines culling state: true to enable culling, false to disable it
@@ -874,107 +1014,5 @@ export declare class WebGPUEngine extends Engine {
      * @returns the error code
      */
     getError(): number;
-    /**
-     * @internal
-     */
-    bindSamplers(): void;
-    /**
-     * @internal
-     */
-    _bindTextureDirectly(): boolean;
-    /**
-     * Gets a boolean indicating if all created effects are ready
-     * @returns always true - No parallel shader compilation
-     */
-    areAllEffectsReady(): boolean;
-    /**
-     * @internal
-     */
-    _executeWhenRenderingStateIsCompiled(pipelineContext: IPipelineContext, action: () => void): void;
-    /**
-     * @internal
-     */
-    _isRenderingStateCompiled(): boolean;
-    /** @internal */
-    _getUnpackAlignement(): number;
-    /**
-     * @internal
-     */
-    _unpackFlipY(): void;
-    /**
-     * @internal
-     */
-    _bindUnboundFramebuffer(): void;
-    /**
-     * @internal
-     */
-    _getSamplingParameters(): {
-        min: number;
-        mag: number;
-    };
-    /**
-     * @internal
-     */
-    getUniforms(): Nullable<WebGLUniformLocation>[];
-    /**
-     * @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 {};