@babylonjs/core 6.33.2 → 6.34.0-alpha.0

package/esm/Engines/WebGPU/engine.webgpu.d.ts

@@ -0,0 +1,277 @@
+import type { IShaderProcessor } from "../../../Engines/Processors/iShaderProcessor.js";
+import { ShaderLanguage } from "../../../Materials/shaderLanguage.js";
+import type { DataArray, Nullable } from "../../../types.js";
+import type { IBaseEngineProtected, IBaseEnginePublic, IBaseEngineInternals, IBaseEngineOptions } from "../engine.base";
+import type { IDrawContext } from "../../../Engines/IDrawContext.js";
+import type { IMaterialContext } from "../../../Engines/IMaterialContext.js";
+import type { GlslangOptions } from "../../../Engines/webgpuEngine.js";
+import { type TwgslOptions } from "../../../Engines/WebGPU/webgpuTintWASM.js";
+import { WebGPUBufferManager } from "../../../Engines/WebGPU/webgpuBufferManager.js";
+import { WebGPUBundleList } from "../../../Engines/WebGPU/webgpuBundleList.js";
+import { WebGPUCacheSampler } from "../../../Engines/WebGPU/webgpuCacheSampler.js";
+import { WebGPUOcclusionQuery } from "../../../Engines/WebGPU/webgpuOcclusionQuery.js";
+import { WebGPUTextureHelper } from "../../../Engines/WebGPU/webgpuTextureHelper.js";
+import { WebGPUTimestampQuery } from "../../../Engines/WebGPU/webgpuTimestampQuery.js";
+import type { ComputeEffect } from "../../../Compute/computeEffect.js";
+import type { WebGPUCacheRenderPipeline } from "../../../Engines/WebGPU/webgpuCacheRenderPipeline.js";
+import type { WebGPUDataBuffer } from "../../../Meshes/WebGPU/webgpuDataBuffer.js";
+import { Observable } from "../../../Misc/observable.js";
+import type { DataBuffer } from "../../../Buffers/dataBuffer.js";
+import { WebGPUDrawContext } from "../../../Engines/WebGPU/webgpuDrawContext.js";
+import { WebGPUMaterialContext } from "../../../Engines/WebGPU/webgpuMaterialContext.js";
+import type { IEffectCreationOptions } from "../../../Materials/effect.js";
+import { Effect } from "../../../Materials/effect.js";
+import type { EffectFallbacks } from "../../../Materials/effectFallbacks.js";
+import type { Engine } from "../../../Engines/engine.js";
+import { WebGPUHardwareTexture } from "../../../Engines/WebGPU/webgpuHardwareTexture.js";
+/** @internal */
+interface IWebGPURenderPassWrapper {
+    renderPassDescriptor: Nullable<GPURenderPassDescriptor>;
+    colorAttachmentViewDescriptor: Nullable<GPUTextureViewDescriptor>;
+    depthAttachmentViewDescriptor: Nullable<GPUTextureViewDescriptor>;
+    colorAttachmentGPUTextures: (WebGPUHardwareTexture | null)[];
+    depthTextureFormat: GPUTextureFormat | undefined;
+}
+/** @internal */
+export declare const _clearDepthValue = 1;
+/** @internal */
+export declare const _clearReverseDepthValue = 0;
+/** @internal */
+export declare const _clearStencilValue = 0;
+/**
+ * Counters from last frame
+ */
+export declare const countersLastFrame: {
+    numEnableEffects: number;
+    numEnableDrawWrapper: number;
+    numBundleCreationNonCompatMode: number;
+    numBundleReuseNonCompatMode: number;
+};
+export interface IWebGPUEngineOptions extends IBaseEngineOptions, GPURequestAdapterOptions {
+    /**
+     * Defines the category of adapter to use.
+     * Is it the discrete or integrated device.
+     */
+    powerPreference?: GPUPowerPreference;
+    /**
+     * When set to true, indicates that only a fallback adapter may be returned when requesting an adapter.
+     * If the user agent does not support a fallback adapter, will cause requestAdapter() to resolve to null.
+     * Default: false
+     */
+    forceFallbackAdapter?: boolean;
+    /**
+     * Defines the device descriptor used to create a device once we have retrieved an appropriate adapter
+     */
+    deviceDescriptor?: GPUDeviceDescriptor;
+    /**
+     * When requesting the device, enable all the features supported by the adapter. Default: false
+     * Note that this setting is ignored if you explicitely set deviceDescriptor.requiredFeatures
+     */
+    enableAllFeatures?: boolean;
+    /**
+     * When requesting the device, set the required limits to the maximum possible values (the ones from adapter.limits). Default: false
+     * Note that this setting is ignored if you explicitely set deviceDescriptor.requiredLimits
+     */
+    setMaximumLimits?: boolean;
+    /**
+     * Defines the requested Swap Chain Format.
+     */
+    swapChainFormat?: GPUTextureFormat;
+    /**
+     * Defines whether we should generate debug markers in the gpu command lists (can be seen with PIX for eg). Default: false
+     */
+    enableGPUDebugMarkers?: boolean;
+    /**
+     * Options to load the associated Glslang library
+     */
+    glslangOptions?: GlslangOptions;
+    /**
+     * Options to load the associated Twgsl library
+     */
+    twgslOptions?: TwgslOptions;
+}
+export interface IWebGPUEngineProtected extends IBaseEngineProtected {
+    _scissorCached: {
+        x: number;
+        y: number;
+        w: number;
+        z: number;
+    };
+}
+export interface IWebGPUEngineInternals extends IBaseEngineInternals {
+    _currentDrawContext: IDrawContext;
+    _currentMaterialContext: IMaterialContext;
+    _options: IWebGPUEngineOptions;
+}
+export interface IWebGPUEnginePublic extends IBaseEnginePublic {
+    snapshotRendering: boolean;
+    snapshotRenderingMode: number;
+    /** @internal */
+    _device: GPUDevice;
+    /** @internal */
+    _textureHelper: WebGPUTextureHelper;
+    /** @internal */
+    _bufferManager: WebGPUBufferManager;
+    /** @internal */
+    _cacheSampler: WebGPUCacheSampler;
+    /** @internal */
+    _cacheRenderPipeline: WebGPUCacheRenderPipeline;
+    /** @internal */
+    _mrtAttachments: number[];
+    /** @internal */
+    _timestampQuery: WebGPUTimestampQuery;
+    /** @internal */
+    _occlusionQuery: WebGPUOcclusionQuery;
+    /** @internal */
+    _compiledComputeEffects: {
+        [key: string]: ComputeEffect;
+    };
+    /** @internal */
+    _counters: {
+        numEnableEffects: number;
+        numEnableDrawWrapper: number;
+        numBundleCreationNonCompatMode: number;
+        numBundleReuseNonCompatMode: number;
+    };
+    /**
+     * Max number of uncaptured error messages to log
+     */
+    numMaxUncapturedErrors: number;
+    /** @internal */
+    _ubInvertY: WebGPUDataBuffer;
+    /** @internal */
+    _ubDontInvertY: WebGPUDataBuffer;
+    /** @internal */
+    _uploadEncoder: GPUCommandEncoder;
+    /** @internal */
+    _renderEncoder: GPUCommandEncoder;
+    /** @internal */
+    _renderTargetEncoder: GPUCommandEncoder;
+    /** @internal */
+    _currentRenderPass: Nullable<GPURenderPassEncoder>;
+    /** @internal */
+    _mainRenderPassWrapper: IWebGPURenderPassWrapper;
+    /** @internal */
+    _rttRenderPassWrapper: IWebGPURenderPassWrapper;
+    /** @internal */
+    _pendingDebugCommands: Array<[string, Nullable<string>]>;
+    /** @internal */
+    _bundleList: WebGPUBundleList;
+    /** @internal */
+    _bundleListRenderTarget: WebGPUBundleList;
+    /** @internal */
+    _onAfterUnbindFrameBufferObservable: Observable<IWebGPUEnginePublic>;
+    /** @internal */
+    _currentDrawContext: WebGPUDrawContext;
+    /** @internal */
+    _currentMaterialContext: WebGPUMaterialContext;
+    /** @internal */
+    dbgShowShaderCode: boolean;
+    /** @internal */
+    dbgSanityChecks: boolean;
+    /** @internal */
+    dbgVerboseLogsForFirstFrames: boolean;
+    /** @internal */
+    dbgVerboseLogsNumFrames: number;
+    /** @internal */
+    dbgLogIfNotDrawWrapper: boolean;
+    /** @internal */
+    dbgShowEmptyEnableEffectCalls: boolean;
+    /**
+     * (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/setup/support/webGPU/webGPUOptimization/webGPUNonCompatibilityMode for more details
+     */
+    compatibilityMode: boolean;
+    /** @internal */
+    readonly currentSampleCount: number;
+}
+export type WebGPUEngineState = IWebGPUEnginePublic & IWebGPUEngineInternals & IWebGPUEngineProtected;
+/**
+ * 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
+ */
+export declare function CreateAsyncWebGPUEngine(canvas: HTMLCanvasElement, options?: IWebGPUEngineOptions): Promise<IWebGPUEnginePublic>;
+export declare function initWebGPUEngineState(canvas: HTMLCanvasElement, options?: IWebGPUEngineOptions): WebGPUEngineState;
+/**
+ * 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.
+ */
+export declare function initAsync(engineState: IWebGPUEnginePublic, glslangOptions?: GlslangOptions, twgslOptions?: TwgslOptions): Promise<void>;
+export declare function _getShaderProcessor(engineState: IWebGPUEnginePublic, shaderLanguage: ShaderLanguage): Nullable<IShaderProcessor>;
+export declare function isWebGPU(engineState: IWebGPUEnginePublic): engineState is WebGPUEngineState;
+export declare function resetSnapshotRendering(engineState: IWebGPUEnginePublic): void;
+export declare function resize(engineState: IWebGPUEnginePublic, forceSetSize?: boolean): 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
+ */
+export declare function setSize(engineState: IWebGPUEnginePublic, width: number, height: number, forceSetSize?: boolean): boolean;
+/**
+ * @internal
+ */
+export declare function _getUseSRGBBuffer(engineState: IWebGPUEnginePublic, useSRGBBuffer: boolean, noMipmap: boolean): boolean;
+/**
+ * Creates a vertex buffer
+ * @param data the data for the vertex buffer
+ * @returns the new buffer
+ */
+export declare function createVertexBuffer(engineState: IWebGPUEnginePublic, data: DataArray): DataBuffer;
+/**
+ * Creates a vertex buffer
+ * @param data the data for the dynamic vertex buffer
+ * @returns the new buffer
+ * @deprecated Please use createVertexBuffer instead.
+ */
+export declare function createDynamicVertexBuffer(engineState: IWebGPUEnginePublic, data: DataArray): DataBuffer;
+/**
+ * @internal
+ */
+export declare function _releaseBuffer(engineState: IWebGPUEnginePublic, buffer: DataBuffer): 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
+ */
+export declare function createEffect(engineState: IWebGPUEnginePublic, baseName: any, attributesNamesOrOptions: string[] | IEffectCreationOptions, uniformsNamesOrEngine: string[] | Engine, // Engine is just a type here, so i don't have to change Effect's signature
+samplers?: string[], defines?: string, fallbacks?: EffectFallbacks, onCompiled?: Nullable<(effect: Effect) => void>, onError?: Nullable<(effect: Effect, errors: string) => void>, indexParameters?: any, shaderLanguage?: ShaderLanguage): Effect;
+/**
+ * Creates a new draw context
+ * @returns the new context
+ */
+export declare function createDrawContext(engineState: IWebGPUEnginePublic): WebGPUDrawContext;
+/**
+ * Creates a new material context
+ * @returns the new context
+ */
+export declare function createMaterialContext(_engineState: IWebGPUEnginePublic): WebGPUMaterialContext;
+export declare function _initializeContextAndSwapChain(engineState: IWebGPUEnginePublic): void;
+export declare function _initializeMainAttachments(engineState: IWebGPUEnginePublic): void;
+export declare function _configureContext(engineState: IWebGPUEnginePublic): void;
+/**
+ * Force a WebGPU flush (ie. a flush of all waiting commands)
+ */
+export declare function flushFramebuffer(engineState: IWebGPUEnginePublic): void;
+/** @internal */
+export declare function _endCurrentRenderPass(engineState: IWebGPUEnginePublic): number;
+/**
+ * @internal
+ */
+export declare function _setDepthTextureFormat(engineState: IWebGPUEnginePublic, wrapper: IWebGPURenderPassWrapper): void;
+export {};