@babylonjs/core 7.25.2 → 7.26.0

package/Engines/webgpuEngine.d.ts

@@ -1,3 +1,4 @@
+import { ThinWebGPUEngine } from "./thinWebGPUEngine";
 import type { Nullable, DataArray, IndicesArray, Immutable, FloatArray } from "../types";
 import { InternalTexture, InternalTextureSource } from "../Materials/Textures/internalTexture";
 import type { IEffectCreationOptions, IShaderPath } from "../Materials/effect";
@@ -9,7 +10,6 @@ import type { DataBuffer } from "../Buffers/dataBuffer";
 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 { AbstractEngine } from "./abstractEngine";
 import type { ISceneLike, AbstractEngineOptions } from "./abstractEngine";
 import { WebGPUBufferManager } from "./WebGPU/webgpuBufferManager";
@@ -17,13 +17,10 @@ import type { HardwareTextureWrapper } from "../Materials/Textures/hardwareTextu
 import { WebGPUHardwareTexture } from "./WebGPU/webgpuHardwareTexture";
 import type { IColor4Like } from "../Maths/math.like";
 import { WebGPUCacheSampler } from "./WebGPU/webgpuCacheSampler";
-import type { WebGPUCacheRenderPipeline } from "./WebGPU/webgpuCacheRenderPipeline";
 import type { DrawWrapper } from "../Materials/drawWrapper";
 import { WebGPUMaterialContext } from "./WebGPU/webgpuMaterialContext";
 import { WebGPUDrawContext } from "./WebGPU/webgpuDrawContext";
 import type { IStencilState } from "../States/IStencilState";
-import { WebGPUBundleList } from "./WebGPU/webgpuBundleList";
-import { WebGPUTimestampQuery } from "./WebGPU/webgpuTimestampQuery";
 import type { ComputeEffect } from "../Compute/computeEffect";
 import { WebGPUOcclusionQuery } from "./WebGPU/webgpuOcclusionQuery";
 import type { TwgslOptions } from "./WebGPU/webgpuTintWASM";
@@ -33,7 +30,6 @@ import type { InternalTextureCreationOptions, TextureSize } from "../Materials/T
 import type { WebGPUDataBuffer } from "../Meshes/WebGPU/webgpuDataBuffer";
 import "../Buffers/buffer.align";
 import type { RenderTargetWrapper } from "./renderTargetWrapper";
-import { WebGPUPerfCounter } from "./WebGPU/webgpuPerfCounter";
 import type { Scene } from "../scene";
 import { PerformanceMonitor } from "../Misc/performanceMonitor";
 import "./AbstractEngine/abstractEngine.loadingScreen";
@@ -43,6 +39,13 @@ import "./AbstractEngine/abstractEngine.renderPass";
 import "../Audio/audioEngine";
 import type { TextureSampler } from "../Materials/Textures/textureSampler";
 import type { StorageBuffer } from "../Buffers/storageBuffer";
+import "./WebGPU/Extensions/engine.alpha";
+import "./WebGPU/Extensions/engine.rawTexture";
+import "./WebGPU/Extensions/engine.readTexture";
+import "./WebGPU/Extensions/engine.cubeTexture";
+import "./WebGPU/Extensions/engine.renderTarget";
+import "./WebGPU/Extensions/engine.renderTargetTexture";
+import "./WebGPU/Extensions/engine.renderTargetCube";
 /** @internal */
 interface IWebGPURenderPassWrapper {
     renderPassDescriptor: Nullable<GPURenderPassDescriptor>;
@@ -118,7 +121,7 @@ export interface WebGPUEngineOptions extends AbstractEngineOptions, GPURequestAd
  * The web GPU engine class provides support for WebGPU version of babylon.js.
  * @since 5.0.0
  */
-export declare class WebGPUEngine extends AbstractEngine {
+export declare class WebGPUEngine extends ThinWebGPUEngine {
     private static readonly _GlslangDefaultOptions;
     private static _InstanceId;
     /** A unique id to identify this instance */
@@ -150,23 +153,15 @@ export declare class WebGPUEngine extends AbstractEngine {
     private _glslangOptions?;
     private _twgslOptions?;
     /** @internal */
-    _textureHelper: WebGPUTextureManager;
-    /** @internal */
     _bufferManager: WebGPUBufferManager;
     private _clearQuad;
     /** @internal */
     _cacheSampler: WebGPUCacheSampler;
-    /** @internal */
-    _cacheRenderPipeline: WebGPUCacheRenderPipeline;
     private _cacheBindGroups;
     private _emptyVertexBuffer;
     /** @internal */
     _mrtAttachments: number[];
     /** @internal */
-    _timestampQuery: WebGPUTimestampQuery;
-    /** @internal */
-    _timestampIndex: number;
-    /** @internal */
     _occlusionQuery: WebGPUOcclusionQuery;
     /** @internal */
     _compiledComputeEffects: {
@@ -207,22 +202,11 @@ export declare class WebGPUEngine extends AbstractEngine {
     _ubInvertY: WebGPUDataBuffer;
     /** @internal */
     _ubDontInvertY: WebGPUDataBuffer;
-    /** @internal */
-    _uploadEncoder: GPUCommandEncoder;
-    /** @internal */
-    _renderEncoder: GPUCommandEncoder;
     private _commandBuffers;
-    /** @internal */
-    _currentRenderPass: Nullable<GPURenderPassEncoder>;
     private _mainRenderPassWrapper;
     private _rttRenderPassWrapper;
     /** @internal */
     _pendingDebugCommands: Array<[string, Nullable<string>]>;
-    /**
-     * Used for both the compatibilityMode=false and the snapshot rendering modes (as both can't be enabled at the same time)
-     * @internal
-     */
-    _bundleList: WebGPUBundleList;
     private _defaultDrawContext;
     private _defaultMaterialContext;
     /** @internal */
@@ -233,20 +217,6 @@ export declare class WebGPUEngine extends AbstractEngine {
     private _currentIndexBuffer;
     private _colorWriteLocal;
     private _forceEnableEffect;
-    /** @internal */
-    dbgShowShaderCode: boolean;
-    /** @internal */
-    dbgSanityChecks: boolean;
-    /** @internal */
-    dbgVerboseLogsForFirstFrames: boolean;
-    /** @internal */
-    dbgVerboseLogsNumFrames: number;
-    /** @internal */
-    dbgLogIfNotDrawWrapper: boolean;
-    /** @internal */
-    dbgShowEmptyEnableEffectCalls: boolean;
-    private _snapshotRendering;
-    protected _snapshotRenderingMode: number;
     /**
      * Gets or sets the snapshot rendering mode
      */
@@ -336,18 +306,6 @@ export declare class WebGPUEngine extends AbstractEngine {
      */
     get compatibilityMode(): boolean;
     set compatibilityMode(mode: boolean);
-    /**
-     * Enables or disables GPU timing measurements.
-     * Note that this is only supported if the "timestamp-query" extension is enabled in the options.
-     */
-    get enableGPUTimingMeasurements(): boolean;
-    set enableGPUTimingMeasurements(enable: boolean);
-    /**
-     * Gets the GPU time spent in the main render pass for the last frame rendered (in nanoseconds).
-     * You have to enable the "timestamp-query" extension in the engine constructor options and set engine.enableGPUTimingMeasurements = true.
-     * It will only return time spent in the main pass, not additional render target / compute passes (if any)!
-     */
-    readonly gpuTimeInFrameForMainPass?: WebGPUPerfCounter;
     /** @internal */
     get currentSampleCount(): number;
     /**
@@ -450,7 +408,6 @@ export declare class WebGPUEngine extends AbstractEngine {
      * @internal
      */
     _getShaderProcessingContext(shaderLanguage: ShaderLanguage, pureMode: boolean): Nullable<ShaderProcessingContext>;
-    private _currentPassIsMainPass;
     private _getCurrentRenderPass;
     /** @internal */
     _getCurrentRenderPassWrapper(): IWebGPURenderPassWrapper;
@@ -836,10 +793,6 @@ export declare class WebGPUEngine extends AbstractEngine {
      * @param texture texture to generate the mipmaps for
      */
     generateMipmaps(texture: InternalTexture): void;
-    /**
-     * @internal
-     */
-    _generateMipmaps(texture: InternalTexture, commandEncoder?: GPUCommandEncoder): void;
     /**
      * Update a portion of an internal texture
      * @param texture defines the texture to update
@@ -905,8 +858,6 @@ export declare class WebGPUEngine extends AbstractEngine {
     _currentFrameBufferIsDefaultFrameBuffer(): boolean;
     private _startRenderTargetRenderPass;
     private _startMainRenderPass;
-    /** @internal */
-    _endCurrentRenderPass(): number;
     /**
      * Binds the frame buffer to the specified texture.
      * @param texture The render target wrapper to render to

package/Engines/webgpuEngine.js

@@ -1,5 +1,6 @@
 /* eslint-disable babylonjs/available */
 import { Logger } from "../Misc/logger.js";
+import { ThinWebGPUEngine } from "./thinWebGPUEngine.js";
 import { Color4 } from "../Maths/math.js";
 import { InternalTexture } from "../Materials/Textures/internalTexture.js";
 import { Effect } from "../Materials/effect.js";
@@ -34,7 +35,6 @@ import { WebGPUTintWASM } from "./WebGPU/webgpuTintWASM.js";
 import { WebGPUShaderProcessor } from "./WebGPU/webgpuShaderProcessor.js";
 import { WebGPUSnapshotRendering } from "./WebGPU/webgpuSnapshotRendering.js";
 import "../Buffers/buffer.align.js";
-import { WebGPUPerfCounter } from "./WebGPU/webgpuPerfCounter.js";
 import { SphericalPolynomial } from "../Maths/sphericalPolynomial.js";
 import { PerformanceMonitor } from "../Misc/performanceMonitor.js";
 import { CreateImageBitmapFromSource, ExitFullscreen, ExitPointerlock, GetFontOffset, RequestFullscreen, RequestPointerlock, ResizeImageBitmap, _CommonDispose, _CommonInit, } from "./engine.common.js";
@@ -47,6 +47,13 @@ import "./AbstractEngine/abstractEngine.renderPass.js";
 import "../Audio/audioEngine.js";
 import { resetCachedPipeline } from "../Materials/effect.functions.js";
 import { WebGPUExternalTexture } from "./WebGPU/webgpuExternalTexture.js";
+import "./WebGPU/Extensions/engine.alpha.js";
+import "./WebGPU/Extensions/engine.rawTexture.js";
+import "./WebGPU/Extensions/engine.readTexture.js";
+import "./WebGPU/Extensions/engine.cubeTexture.js";
+import "./WebGPU/Extensions/engine.renderTarget.js";
+import "./WebGPU/Extensions/engine.renderTargetTexture.js";
+import "./WebGPU/Extensions/engine.renderTargetCube.js";
 const viewDescriptorSwapChainAntialiasing = {
     label: `TextureView_SwapChain_ResolveTarget`,
     dimension: "2d" /* WebGPUConstants.TextureDimension.E2d */,
@@ -66,7 +73,7 @@ const tempColor4 = new Color4();
  * The web GPU engine class provides support for WebGPU version of babylon.js.
  * @since 5.0.0
  */
-export class WebGPUEngine extends AbstractEngine {
+export class WebGPUEngine extends ThinWebGPUEngine {
     /**
      * Gets or sets the snapshot rendering mode
      */
@@ -215,20 +222,6 @@ export class WebGPUEngine extends AbstractEngine {
     set compatibilityMode(mode) {
         this._compatibilityMode = mode;
     }
-    /**
-     * Enables or disables GPU timing measurements.
-     * Note that this is only supported if the "timestamp-query" extension is enabled in the options.
-     */
-    get enableGPUTimingMeasurements() {
-        return this._timestampQuery.enable;
-    }
-    set enableGPUTimingMeasurements(enable) {
-        if (this._timestampQuery.enable === enable) {
-            return;
-        }
-        this.gpuTimeInFrameForMainPass = enable ? new WebGPUPerfCounter() : undefined;
-        this._timestampQuery.enable = enable;
-    }
     /** @internal */
     get currentSampleCount() {
         return this._currentRenderTarget ? this._currentRenderTarget.samples : this._mainPassSampleCount;
@@ -274,8 +267,6 @@ export class WebGPUEngine extends AbstractEngine {
             description: "",
         };
         /** @internal */
-        this._timestampIndex = 0;
-        /** @internal */
         this._compiledComputeEffects = {};
         /** @internal */
         this._counters = {
@@ -305,8 +296,6 @@ export class WebGPUEngine extends AbstractEngine {
         this._virtualScenes = new Array();
         this._commandBuffers = [null, null];
         // Frame Buffer Life Cycle (recreated for each render target pass)
-        /** @internal */
-        this._currentRenderPass = null;
         this._mainRenderPassWrapper = {
             renderPassDescriptor: null,
             colorAttachmentViewDescriptor: null,
@@ -327,20 +316,6 @@ export class WebGPUEngine extends AbstractEngine {
         this._currentIndexBuffer = null;
         this._colorWriteLocal = true;
         this._forceEnableEffect = false;
-        // TODO WEBGPU remove those variables when code stabilized
-        /** @internal */
-        this.dbgShowShaderCode = false;
-        /** @internal */
-        this.dbgSanityChecks = true;
-        /** @internal */
-        this.dbgVerboseLogsForFirstFrames = false;
-        /** @internal */
-        this.dbgVerboseLogsNumFrames = 10;
-        /** @internal */
-        this.dbgLogIfNotDrawWrapper = true;
-        /** @internal */
-        this.dbgShowEmptyEnableEffectCalls = true;
-        this._snapshotRenderingMode = 0;
         /**
          * Indicates if the z range in NDC space is 0..1 (value: true) or -1..1 (value: false)
          */
@@ -917,9 +892,6 @@ export class WebGPUEngine extends AbstractEngine {
     _getShaderProcessingContext(shaderLanguage, pureMode) {
         return new WebGPUShaderProcessingContext(shaderLanguage, pureMode);
     }
-    _currentPassIsMainPass() {
-        return this._currentRenderTarget === null;
-    }
     _getCurrentRenderPass() {
         if (this._currentRenderTarget && !this._currentRenderPass) {
             // delayed creation of the render target pass, but we now need to create it as we are requested the render pass
@@ -2139,45 +2111,6 @@ export class WebGPUEngine extends AbstractEngine {
     generateMipmaps(texture) {
         this._generateMipmaps(texture);
     }
-    /**
-     * @internal
-     */
-    _generateMipmaps(texture, commandEncoder) {
-        commandEncoder = commandEncoder ?? this._renderEncoder;
-        const gpuHardwareTexture = texture._hardwareTexture;
-        if (!gpuHardwareTexture) {
-            return;
-        }
-        if (commandEncoder === this._renderEncoder) {
-            // We must close the current pass (if any) because we are going to use the render encoder to generate the mipmaps (so, we are going to create a new render pass)
-            this._endCurrentRenderPass();
-        }
-        const format = texture._hardwareTexture.format;
-        const mipmapCount = WebGPUTextureHelper.ComputeNumMipmapLevels(texture.width, texture.height);
-        if (this.dbgVerboseLogsForFirstFrames) {
-            if (this._count === undefined) {
-                this._count = 0;
-            }
-            if (!this._count || this._count < this.dbgVerboseLogsNumFrames) {
-                Logger.Log("frame #" +
-                    this._count +
-                    " - generate mipmaps - width=" +
-                    texture.width +
-                    ", height=" +
-                    texture.height +
-                    ", isCube=" +
-                    texture.isCube +
-                    ", command encoder=" +
-                    (commandEncoder === this._renderEncoder ? "render" : "copy"));
-            }
-        }
-        if (texture.isCube) {
-            this._textureHelper.generateCubeMipmaps(gpuHardwareTexture, format, mipmapCount, commandEncoder);
-        }
-        else {
-            this._textureHelper.generateMipmaps(gpuHardwareTexture, format, mipmapCount, 0, texture.is3D, commandEncoder);
-        }
-    }
     /**
      * Update a portion of an internal texture
      * @param texture defines the texture to update
@@ -2586,38 +2519,6 @@ export class WebGPUEngine extends AbstractEngine {
             this._stencilStateComposer.enabled = false;
         }
     }
-    /** @internal */
-    _endCurrentRenderPass() {
-        if (!this._currentRenderPass) {
-            return 0;
-        }
-        const currentPassIndex = this._currentPassIsMainPass() ? 2 : 1;
-        if (!this._snapshotRendering.endRenderPass(this._currentRenderPass) && !this.compatibilityMode) {
-            this._bundleList.run(this._currentRenderPass);
-            this._bundleList.reset();
-        }
-        this._currentRenderPass.end();
-        this._timestampQuery.endPass(this._timestampIndex, (this._currentRenderTarget && this._currentRenderTarget.gpuTimeInFrame
-            ? this._currentRenderTarget.gpuTimeInFrame
-            : this.gpuTimeInFrameForMainPass));
-        this._timestampIndex += 2;
-        if (this.dbgVerboseLogsForFirstFrames) {
-            if (this._count === undefined) {
-                this._count = 0;
-            }
-            if (!this._count || this._count < this.dbgVerboseLogsNumFrames) {
-                Logger.Log("frame #" +
-                    this._count +
-                    " - " +
-                    (currentPassIndex === 2 ? "main" : "render target") +
-                    " end pass" +
-                    (currentPassIndex === 1 ? " - internalTexture.uniqueId=" + this._currentRenderTarget?.texture?.uniqueId : ""));
-            }
-        }
-        this._debugPopGroup?.(0);
-        this._currentRenderPass = null;
-        return currentPassIndex;
-    }
     /**
      * Binds the frame buffer to the specified texture.
      * @param texture The render target wrapper to render to