@babylonjs/core 6.29.0 → 6.29.2

package/Engines/webgpuEngine.js

@@ -15,7 +15,6 @@ import { WebGPUTextureHelper } from "./WebGPU/webgpuTextureHelper.js";
 import { WebGPUBufferManager } from "./WebGPU/webgpuBufferManager.js";
 import { WebGPUHardwareTexture } from "./WebGPU/webgpuHardwareTexture.js";
 import { UniformBuffer } from "../Materials/uniformBuffer.js";
-import { WebGPURenderPassWrapper } from "./WebGPU/webgpuRenderPassWrapper.js";
 import { WebGPUCacheSampler } from "./WebGPU/webgpuCacheSampler.js";
 import { WebGPUCacheRenderPipelineTree } from "./WebGPU/webgpuCacheRenderPipelineTree.js";
 import { WebGPUStencilStateComposer } from "./WebGPU/webgpuStencilStateComposer.js";
@@ -28,7 +27,6 @@ import { WebGPUClearQuad } from "./WebGPU/webgpuClearQuad.js";
 import { WebGPURenderItemBlendColor, WebGPURenderItemScissor, WebGPURenderItemStencilRef, WebGPURenderItemViewport, WebGPUBundleList } from "./WebGPU/webgpuBundleList.js";
 import { WebGPUTimestampQuery } from "./WebGPU/webgpuTimestampQuery.js";
 import { WebGPUOcclusionQuery } from "./WebGPU/webgpuOcclusionQuery.js";
-import { Observable } from "../Misc/observable.js";
 import { ShaderCodeInliner } from "./Processors/shaderCodeInliner.js";
 import { WebGPUTintWASM } from "./WebGPU/webgpuTintWASM.js";
 import { WebGPUShaderProcessor } from "./WebGPU/webgpuShaderProcessor.js";
@@ -217,7 +215,6 @@ export class WebGPUEngine extends Engine {
         // Page Life cycle and constants
         this._uploadEncoderDescriptor = { label: "upload" };
         this._renderEncoderDescriptor = { label: "render" };
-        this._renderTargetEncoderDescriptor = { label: "renderTarget" };
         /** @internal */
         this._clearDepthValue = 1;
         /** @internal */
@@ -255,18 +252,26 @@ export class WebGPUEngine extends Engine {
          * Max number of uncaptured error messages to log
          */
         this.numMaxUncapturedErrors = 20;
-        this._commandBuffers = [null, null, null];
+        this._commandBuffers = [null, null];
         // Frame Buffer Life Cycle (recreated for each render target pass)
         /** @internal */
         this._currentRenderPass = null;
-        /** @internal */
-        this._mainRenderPassWrapper = new WebGPURenderPassWrapper();
-        /** @internal */
-        this._rttRenderPassWrapper = new WebGPURenderPassWrapper();
+        this._mainRenderPassWrapper = {
+            renderPassDescriptor: null,
+            colorAttachmentViewDescriptor: null,
+            depthAttachmentViewDescriptor: null,
+            colorAttachmentGPUTextures: [],
+            depthTextureFormat: undefined,
+        };
+        this._rttRenderPassWrapper = {
+            renderPassDescriptor: null,
+            colorAttachmentViewDescriptor: null,
+            depthAttachmentViewDescriptor: null,
+            colorAttachmentGPUTextures: [],
+            depthTextureFormat: undefined,
+        };
         /** @internal */
         this._pendingDebugCommands = [];
-        /** @internal */
-        this._onAfterUnbindFrameBufferObservable = new Observable();
         this._currentOverrideVertexBuffers = null;
         this._currentIndexBuffer = null;
         this._colorWriteLocal = true;
@@ -296,20 +301,11 @@ export class WebGPUEngine extends Engine {
         //                              Dynamic WebGPU States
         //------------------------------------------------------------------------------
         // index 0 is for main render pass, 1 for RTT render pass
-        this._viewportsCurrent = [
-            { x: 0, y: 0, w: 0, h: 0 },
-            { x: 0, y: 0, w: 0, h: 0 },
-        ];
-        this._scissorsCurrent = [
-            { x: 0, y: 0, w: 0, h: 0 },
-            { x: 0, y: 0, w: 0, h: 0 },
-        ];
+        this._viewportsCurrent = { x: 0, y: 0, w: 0, h: 0 };
+        this._scissorsCurrent = { x: 0, y: 0, w: 0, h: 0 };
         this._scissorCached = { x: 0, y: 0, z: 0, w: 0 };
-        this._stencilRefsCurrent = [-1, -1];
-        this._blendColorsCurrent = [
-            [null, null, null, null],
-            [null, null, null, null],
-        ];
+        this._stencilRefsCurrent = -1;
+        this._blendColorsCurrent = [null, null, null, null];
         this._name = "WebGPU";
         options.deviceDescriptor = options.deviceDescriptor || {};
         options.enableGPUDebugMarkers = (_b = options.enableGPUDebugMarkers) !== null && _b !== void 0 ? _b : false;
@@ -431,8 +427,7 @@ export class WebGPUEngine extends Engine {
             this._timestampQuery = new WebGPUTimestampQuery(this._device, this._bufferManager);
             this._occlusionQuery = this._device.createQuerySet ? new WebGPUOcclusionQuery(this, this._device, this._bufferManager) : undefined;
             this._bundleList = new WebGPUBundleList(this._device);
-            this._bundleListRenderTarget = new WebGPUBundleList(this._device);
-            this._snapshotRendering = new WebGPUSnapshotRendering(this, this._snapshotRenderingMode, this._bundleList, this._bundleListRenderTarget);
+            this._snapshotRendering = new WebGPUSnapshotRendering(this, this._snapshotRenderingMode, this._bundleList);
             this._ubInvertY = this._bufferManager.createBuffer(new Float32Array([-1, 0]), WebGPUConstants.BufferUsage.Uniform | WebGPUConstants.BufferUsage.CopyDst, "UBInvertY");
             this._ubDontInvertY = this._bufferManager.createBuffer(new Float32Array([1, 0]), WebGPUConstants.BufferUsage.Uniform | WebGPUConstants.BufferUsage.CopyDst, "UBDontInvertY");
             if (this.dbgVerboseLogsForFirstFrames) {
@@ -443,10 +438,9 @@ export class WebGPUEngine extends Engine {
             }
             this._uploadEncoder = this._device.createCommandEncoder(this._uploadEncoderDescriptor);
             this._renderEncoder = this._device.createCommandEncoder(this._renderEncoderDescriptor);
-            this._renderTargetEncoder = this._device.createCommandEncoder(this._renderTargetEncoderDescriptor);
             this._initializeLimits();
             this._emptyVertexBuffer = new VertexBuffer(this, [0], "", false, false, 1, false, 0, 1);
-            this._cacheRenderPipeline = new WebGPUCacheRenderPipelineTree(this._device, this._emptyVertexBuffer, !this._caps.textureFloatLinearFiltering);
+            this._cacheRenderPipeline = new WebGPUCacheRenderPipelineTree(this._device, this._emptyVertexBuffer);
             this._depthCullingState = new WebGPUDepthCullingState(this._cacheRenderPipeline);
             this._stencilStateComposer = new WebGPUStencilStateComposer(this._cacheRenderPipeline);
             this._stencilStateComposer.stencilGlobal = this._stencilState;
@@ -513,6 +507,7 @@ export class WebGPUEngine extends Engine {
             fragmentDepthSupported: true,
             highPrecisionShaderSupported: true,
             colorBufferFloat: true,
+            supportFloatTexturesResolve: false,
             textureFloat: true,
             textureFloatLinearFiltering: this._deviceEnabledExtensions.indexOf(WebGPUConstants.FeatureName.Float32Filterable) >= 0,
             textureFloatRender: true,
@@ -580,13 +575,14 @@ export class WebGPUEngine extends Engine {
         this._colorFormat = this._options.swapChainFormat;
         this._mainRenderPassWrapper.colorAttachmentGPUTextures = [new WebGPUHardwareTexture()];
         this._mainRenderPassWrapper.colorAttachmentGPUTextures[0].format = this._colorFormat;
+        this._setColorFormat(this._mainRenderPassWrapper);
     }
     // Set default values as WebGL with depth and stencil attachment for the broadest Compat.
     _initializeMainAttachments() {
         if (!this._bufferManager) {
             return;
         }
-        this.flushFramebuffer(false);
+        this.flushFramebuffer();
         this._mainTextureExtends = {
             width: this.getRenderWidth(true),
             height: this.getRenderHeight(true),
@@ -637,6 +633,7 @@ export class WebGPUEngine extends Engine {
         }
         this._mainRenderPassWrapper.depthTextureFormat = this.isStencilEnable ? WebGPUConstants.TextureFormat.Depth24PlusStencil8 : WebGPUConstants.TextureFormat.Depth32Float;
         this._setDepthTextureFormat(this._mainRenderPassWrapper);
+        this._setColorFormat(this._mainRenderPassWrapper);
         const depthTextureDescriptor = {
             label: `Texture_MainDepthStencil_${this._mainTextureExtends.width}x${this._mainTextureExtends.height}`,
             size: this._mainTextureExtends,
@@ -695,7 +692,7 @@ export class WebGPUEngine extends Engine {
                 this._count = 0;
             }
             if (!this._count || this._count < this.dbgVerboseLogsNumFrames) {
-                console.log("frame #" + this._count + " - setSize called -", width, height);
+                console.log("frame #" + this._count + " - setSize -", width, height);
             }
         }
         this._initializeMainAttachments();
@@ -720,6 +717,23 @@ export class WebGPUEngine extends Engine {
     _getShaderProcessingContext(shaderLanguage) {
         return new WebGPUShaderProcessingContext(shaderLanguage);
     }
+    _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
+            this._startRenderTargetRenderPass(this._currentRenderTarget, false, null, false, false);
+        }
+        else if (!this._currentRenderPass) {
+            this._startMainRenderPass(false);
+        }
+        return this._currentRenderPass;
+    }
+    /** @internal */
+    _getCurrentRenderPassWrapper() {
+        return this._currentRenderTarget ? this._rttRenderPassWrapper : this._mainRenderPassWrapper;
+    }
     //------------------------------------------------------------------------------
     //                          Static Pipeline WebGPU States
     //------------------------------------------------------------------------------
@@ -773,37 +787,37 @@ export class WebGPUEngine extends Engine {
     getColorWrite() {
         return this._colorWriteLocal;
     }
-    _resetCurrentViewport(index) {
-        this._viewportsCurrent[index].x = 0;
-        this._viewportsCurrent[index].y = 0;
-        this._viewportsCurrent[index].w = 0;
-        this._viewportsCurrent[index].h = 0;
-    }
-    _mustUpdateViewport(renderPass) {
-        const index = renderPass === this._mainRenderPassWrapper.renderPass ? 0 : 1;
+    _mustUpdateViewport() {
         const x = this._viewportCached.x, y = this._viewportCached.y, w = this._viewportCached.z, h = this._viewportCached.w;
-        const update = this._viewportsCurrent[index].x !== x || this._viewportsCurrent[index].y !== y || this._viewportsCurrent[index].w !== w || this._viewportsCurrent[index].h !== h;
+        const update = this._viewportsCurrent.x !== x || this._viewportsCurrent.y !== y || this._viewportsCurrent.w !== w || this._viewportsCurrent.h !== h;
         if (update) {
-            this._viewportsCurrent[index].x = this._viewportCached.x;
-            this._viewportsCurrent[index].y = this._viewportCached.y;
-            this._viewportsCurrent[index].w = this._viewportCached.z;
-            this._viewportsCurrent[index].h = this._viewportCached.w;
+            this._viewportsCurrent.x = this._viewportCached.x;
+            this._viewportsCurrent.y = this._viewportCached.y;
+            this._viewportsCurrent.w = this._viewportCached.z;
+            this._viewportsCurrent.h = this._viewportCached.w;
         }
         return update;
     }
-    _applyViewport(renderPass) {
-        let y = Math.floor(this._viewportCached.y);
+    _applyViewport(bundleList) {
+        const x = Math.floor(this._viewportCached.x);
+        const w = Math.floor(this._viewportCached.z);
         const h = Math.floor(this._viewportCached.w);
+        let y = Math.floor(this._viewportCached.y);
         if (!this._currentRenderTarget) {
             y = this.getRenderHeight(true) - y - h;
         }
-        renderPass.setViewport(Math.floor(this._viewportCached.x), y, Math.floor(this._viewportCached.z), h, 0, 1);
+        if (bundleList) {
+            bundleList.addItem(new WebGPURenderItemViewport(x, y, w, h));
+        }
+        else {
+            this._getCurrentRenderPass().setViewport(x, y, w, h, 0, 1);
+        }
         if (this.dbgVerboseLogsForFirstFrames) {
             if (this._count === undefined) {
                 this._count = 0;
             }
             if (!this._count || this._count < this.dbgVerboseLogsNumFrames) {
-                console.log("frame #" + this._count + " - viewport applied - (", this._viewportCached.x, this._viewportCached.y, this._viewportCached.z, this._viewportCached.w, ") current pass is main pass=" + (renderPass === this._mainRenderPassWrapper.renderPass));
+                console.log("frame #" + this._count + " - viewport applied - (", this._viewportCached.x, this._viewportCached.y, this._viewportCached.z, this._viewportCached.w, ") current pass is main pass=" + this._currentPassIsMainPass());
             }
         }
     }
@@ -816,32 +830,31 @@ export class WebGPUEngine extends Engine {
         this._viewportCached.z = width;
         this._viewportCached.w = height;
     }
-    _resetCurrentScissor(index) {
-        this._scissorsCurrent[index].x = 0;
-        this._scissorsCurrent[index].y = 0;
-        this._scissorsCurrent[index].w = 0;
-        this._scissorsCurrent[index].h = 0;
-    }
-    _mustUpdateScissor(renderPass) {
-        const index = renderPass === this._mainRenderPassWrapper.renderPass ? 0 : 1;
+    _mustUpdateScissor() {
         const x = this._scissorCached.x, y = this._scissorCached.y, w = this._scissorCached.z, h = this._scissorCached.w;
-        const update = this._scissorsCurrent[index].x !== x || this._scissorsCurrent[index].y !== y || this._scissorsCurrent[index].w !== w || this._scissorsCurrent[index].h !== h;
+        const update = this._scissorsCurrent.x !== x || this._scissorsCurrent.y !== y || this._scissorsCurrent.w !== w || this._scissorsCurrent.h !== h;
         if (update) {
-            this._scissorsCurrent[index].x = this._scissorCached.x;
-            this._scissorsCurrent[index].y = this._scissorCached.y;
-            this._scissorsCurrent[index].w = this._scissorCached.z;
-            this._scissorsCurrent[index].h = this._scissorCached.w;
+            this._scissorsCurrent.x = this._scissorCached.x;
+            this._scissorsCurrent.y = this._scissorCached.y;
+            this._scissorsCurrent.w = this._scissorCached.z;
+            this._scissorsCurrent.h = this._scissorCached.w;
         }
         return update;
     }
-    _applyScissor(renderPass) {
-        renderPass.setScissorRect(this._scissorCached.x, this._currentRenderTarget ? this._scissorCached.y : this.getRenderHeight() - this._scissorCached.w - this._scissorCached.y, this._scissorCached.z, this._scissorCached.w);
+    _applyScissor(bundleList) {
+        const y = this._currentRenderTarget ? this._scissorCached.y : this.getRenderHeight() - this._scissorCached.w - this._scissorCached.y;
+        if (bundleList) {
+            bundleList.addItem(new WebGPURenderItemScissor(this._scissorCached.x, y, this._scissorCached.z, this._scissorCached.w));
+        }
+        else {
+            this._getCurrentRenderPass().setScissorRect(this._scissorCached.x, y, this._scissorCached.z, this._scissorCached.w);
+        }
         if (this.dbgVerboseLogsForFirstFrames) {
             if (this._count === undefined) {
                 this._count = 0;
             }
             if (!this._count || this._count < this.dbgVerboseLogsNumFrames) {
-                console.log("frame #" + this._count + " - scissor applied - (", this._scissorCached.x, this._scissorCached.y, this._scissorCached.z, this._scissorCached.w, ") current pass is main pass=" + (renderPass === this._mainRenderPassWrapper.renderPass));
+                console.log("frame #" + this._count + " - scissor applied - (", this._scissorCached.x, this._scissorCached.y, this._scissorCached.z, this._scissorCached.w, ") current pass is main pass=" + this._currentPassIsMainPass());
             }
         }
     }
@@ -855,51 +868,52 @@ export class WebGPUEngine extends Engine {
         this._scissorCached.w = height;
     }
     disableScissor() {
-        this._scissorCached.x = 0;
-        this._scissorCached.y = 0;
-        this._scissorCached.z = 0;
-        this._scissorCached.w = 0;
-        this._resetCurrentScissor(0);
-        this._resetCurrentScissor(1);
-    }
-    _resetCurrentStencilRef(index) {
-        this._stencilRefsCurrent[index] = -1;
-    }
-    _mustUpdateStencilRef(renderPass) {
-        const index = renderPass === this._mainRenderPassWrapper.renderPass ? 0 : 1;
-        const update = this._stencilStateComposer.funcRef !== this._stencilRefsCurrent[index];
+        this._scissorCached.x = this._scissorCached.y = this._scissorCached.z = this._scissorCached.w = 0;
+        this._scissorsCurrent.x = this._scissorsCurrent.y = this._scissorsCurrent.w = this._scissorsCurrent.h = 0;
+    }
+    _mustUpdateStencilRef() {
+        const update = this._stencilStateComposer.funcRef !== this._stencilRefsCurrent;
         if (update) {
-            this._stencilRefsCurrent[index] = this._stencilStateComposer.funcRef;
+            this._stencilRefsCurrent = this._stencilStateComposer.funcRef;
         }
         return update;
     }
-    /**
-     * @internal
-     */
-    _applyStencilRef(renderPass) {
-        var _a;
-        renderPass.setStencilReference((_a = this._stencilStateComposer.funcRef) !== null && _a !== void 0 ? _a : 0);
-    }
-    _resetCurrentColorBlend(index) {
-        this._blendColorsCurrent[index][0] = this._blendColorsCurrent[index][1] = this._blendColorsCurrent[index][2] = this._blendColorsCurrent[index][3] = null;
+    _applyStencilRef(bundleList) {
+        var _a, _b;
+        if (bundleList) {
+            bundleList.addItem(new WebGPURenderItemStencilRef((_a = this._stencilStateComposer.funcRef) !== null && _a !== void 0 ? _a : 0));
+        }
+        else {
+            this._getCurrentRenderPass().setStencilReference((_b = this._stencilStateComposer.funcRef) !== null && _b !== void 0 ? _b : 0);
+        }
     }
-    _mustUpdateBlendColor(renderPass) {
-        const index = renderPass === this._mainRenderPassWrapper.renderPass ? 0 : 1;
+    _mustUpdateBlendColor() {
         const colorBlend = this._alphaState._blendConstants;
-        const update = colorBlend[0] !== this._blendColorsCurrent[index][0] ||
-            colorBlend[1] !== this._blendColorsCurrent[index][1] ||
-            colorBlend[2] !== this._blendColorsCurrent[index][2] ||
-            colorBlend[3] !== this._blendColorsCurrent[index][3];
+        const update = colorBlend[0] !== this._blendColorsCurrent[0] ||
+            colorBlend[1] !== this._blendColorsCurrent[1] ||
+            colorBlend[2] !== this._blendColorsCurrent[2] ||
+            colorBlend[3] !== this._blendColorsCurrent[3];
         if (update) {
-            this._blendColorsCurrent[index][0] = colorBlend[0];
-            this._blendColorsCurrent[index][1] = colorBlend[1];
-            this._blendColorsCurrent[index][2] = colorBlend[2];
-            this._blendColorsCurrent[index][3] = colorBlend[3];
+            this._blendColorsCurrent[0] = colorBlend[0];
+            this._blendColorsCurrent[1] = colorBlend[1];
+            this._blendColorsCurrent[2] = colorBlend[2];
+            this._blendColorsCurrent[3] = colorBlend[3];
         }
         return update;
     }
-    _applyBlendColor(renderPass) {
-        renderPass.setBlendConstant(this._alphaState._blendConstants);
+    _applyBlendColor(bundleList) {
+        if (bundleList) {
+            bundleList.addItem(new WebGPURenderItemBlendColor(this._alphaState._blendConstants.slice()));
+        }
+        else {
+            this._getCurrentRenderPass().setBlendConstant(this._alphaState._blendConstants);
+        }
+    }
+    _resetRenderPassStates() {
+        this._viewportsCurrent.x = this._viewportsCurrent.y = this._viewportsCurrent.w = this._viewportsCurrent.h = 0;
+        this._scissorsCurrent.x = this._scissorsCurrent.y = this._scissorsCurrent.w = this._scissorsCurrent.h = 0;
+        this._stencilRefsCurrent = -1;
+        this._blendColorsCurrent[0] = this._blendColorsCurrent[1] = this._blendColorsCurrent[2] = this._blendColorsCurrent[3] = null;
     }
     /**
      * Clear the current render buffer or the current render target (if any is set up)
@@ -919,67 +933,55 @@ export class WebGPUEngine extends Engine {
                 this._count = 0;
             }
             if (!this._count || this._count < this.dbgVerboseLogsNumFrames) {
-                console.log("frame #" + this._count + " - clear called - backBuffer=", backBuffer, " depth=", depth, " stencil=", stencil, " scissor is active=", hasScissor);
+                console.log("frame #" + this._count + " - clear - backBuffer=", backBuffer, " depth=", depth, " stencil=", stencil, " scissor is active=", hasScissor);
             }
         }
         // We need to recreate the render pass so that the new parameters for clear color / depth / stencil are taken into account
         if (this._currentRenderTarget) {
             if (hasScissor) {
-                if (!this._rttRenderPassWrapper.renderPass) {
+                if (!this._currentRenderPass) {
                     this._startRenderTargetRenderPass(this._currentRenderTarget, false, backBuffer ? color : null, depth, stencil);
                 }
-                if (!this.compatibilityMode) {
-                    this._bundleListRenderTarget.addItem(new WebGPURenderItemScissor(this._scissorCached.x, this._scissorCached.y, this._scissorCached.z, this._scissorCached.w));
-                }
-                else {
-                    this._applyScissor(this._currentRenderPass);
-                }
+                this._applyScissor(!this.compatibilityMode ? this._bundleList : null);
                 this._clearFullQuad(backBuffer ? color : null, depth, stencil);
             }
             else {
                 if (this._currentRenderPass) {
-                    this._endRenderTargetRenderPass();
+                    this._endCurrentRenderPass();
                 }
                 this._startRenderTargetRenderPass(this._currentRenderTarget, true, backBuffer ? color : null, depth, stencil);
             }
         }
         else {
-            if (!this._mainRenderPassWrapper.renderPass || !hasScissor) {
+            if (!this._currentRenderPass || !hasScissor) {
                 this._startMainRenderPass(!hasScissor, backBuffer ? color : null, depth, stencil);
             }
             if (hasScissor) {
-                if (!this.compatibilityMode) {
-                    this._bundleList.addItem(new WebGPURenderItemScissor(this._scissorCached.x, this._scissorCached.y, this._scissorCached.z, this._scissorCached.w));
-                }
-                else {
-                    this._applyScissor(this._currentRenderPass);
-                }
+                this._applyScissor(!this.compatibilityMode ? this._bundleList : null);
                 this._clearFullQuad(backBuffer ? color : null, depth, stencil);
             }
         }
     }
     _clearFullQuad(clearColor, clearDepth, clearStencil) {
-        var _a, _b, _c;
+        var _a, _b;
         const renderPass = !this.compatibilityMode ? null : this._getCurrentRenderPass();
-        const renderPassIndex = this._getCurrentRenderPassIndex();
-        const bundleList = renderPassIndex === 0 ? this._bundleList : this._bundleListRenderTarget;
         this._clearQuad.setColorFormat(this._colorFormat);
         this._clearQuad.setDepthStencilFormat(this._depthTextureFormat);
         this._clearQuad.setMRTAttachments((_a = this._cacheRenderPipeline.mrtAttachments) !== null && _a !== void 0 ? _a : [], (_b = this._cacheRenderPipeline.mrtTextureArray) !== null && _b !== void 0 ? _b : [], this._cacheRenderPipeline.mrtTextureCount);
         if (!this.compatibilityMode) {
-            bundleList.addItem(new WebGPURenderItemStencilRef(this._clearStencilValue));
+            this._bundleList.addItem(new WebGPURenderItemStencilRef(this._clearStencilValue));
         }
         else {
             renderPass.setStencilReference(this._clearStencilValue);
         }
         const bundle = this._clearQuad.clear(renderPass, clearColor, clearDepth, clearStencil, this.currentSampleCount);
         if (!this.compatibilityMode) {
-            bundleList.addBundle(bundle);
-            bundleList.addItem(new WebGPURenderItemStencilRef((_c = this._stencilStateComposer.funcRef) !== null && _c !== void 0 ? _c : 0));
+            this._bundleList.addBundle(bundle);
+            this._applyStencilRef(this._bundleList);
             this._reportDrawCall();
         }
         else {
-            this._applyStencilRef(renderPass);
+            this._applyStencilRef(null);
         }
     }
     //------------------------------------------------------------------------------
@@ -1550,7 +1552,7 @@ export class WebGPUEngine extends Engine {
             if (!gpuTexture) {
                 this._textureHelper.createGPUTextureForInternalTexture(texture);
             }
-            this._generateMipmaps(texture, texture.source === InternalTextureSource.RenderTarget || texture.source === InternalTextureSource.MultiRenderTarget ? this._renderTargetEncoder : undefined);
+            this._generateMipmaps(texture);
         }
     }
     /**
@@ -1734,20 +1736,21 @@ export class WebGPUEngine extends Engine {
      * @param texture texture to generate the mipmaps for
      */
     generateMipmaps(texture) {
-        this._generateMipmaps(texture, this._renderTargetEncoder);
+        this._generateMipmaps(texture);
     }
     /**
      * @internal
      */
     _generateMipmaps(texture, commandEncoder) {
+        commandEncoder = commandEncoder !== null && commandEncoder !== void 0 ? commandEncoder : this._renderEncoder;
         const gpuHardwareTexture = texture._hardwareTexture;
         if (!gpuHardwareTexture) {
             return;
         }
-        // try as much as possible to use the command encoder corresponding to the current pass.
-        // If not possible (because the pass is started - generateMipmaps itself creates a pass and it's not allowed to have a pass inside a pass), use _uploadEncoder
-        commandEncoder =
-            commandEncoder !== null && commandEncoder !== void 0 ? commandEncoder : (this._currentRenderTarget && !this._currentRenderPass ? this._renderTargetEncoder : !this._currentRenderPass ? this._renderEncoder : this._uploadEncoder);
+        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) {
@@ -1755,7 +1758,16 @@ export class WebGPUEngine extends Engine {
                 this._count = 0;
             }
             if (!this._count || this._count < this.dbgVerboseLogsNumFrames) {
-                console.log("frame #" + this._count + " - generate mipmaps called - width=", texture.width, "height=", texture.height, "isCube=", texture.isCube);
+                console.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) {
@@ -1786,7 +1798,7 @@ export class WebGPUEngine extends Engine {
         const data = new Uint8Array(imageData.buffer, imageData.byteOffset, imageData.byteLength);
         this._textureHelper.updateTexture(data, texture, width, height, texture.depth, gpuTextureWrapper.format, faceIndex, lod, texture.invertY, false, xOffset, yOffset);
         if (generateMipMaps) {
-            this._generateMipmaps(texture, this._renderTargetEncoder);
+            this._generateMipmaps(texture);
         }
     }
     /**
@@ -1853,7 +1865,7 @@ export class WebGPUEngine extends Engine {
      */
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
     readPixels(x, y, width, height, hasAlpha = true, flushRenderer = true) {
-        const renderPassWrapper = this._rttRenderPassWrapper.renderPass ? this._rttRenderPassWrapper : this._mainRenderPassWrapper;
+        const renderPassWrapper = this._getCurrentRenderPassWrapper();
         const hardwareTexture = renderPassWrapper.colorAttachmentGPUTextures[0];
         if (!hardwareTexture) {
             // we are calling readPixels for a render pass with no color texture bound
@@ -1883,18 +1895,10 @@ export class WebGPUEngine extends Engine {
      * End the current frame
      */
     endFrame() {
-        this._snapshotRendering.endFrame(this._mainRenderPassWrapper.renderPass);
-        this._endMainRenderPass();
+        this._endCurrentRenderPass();
+        this._snapshotRendering.endFrame();
         this._timestampQuery.endFrame(this._renderEncoder);
-        this.flushFramebuffer(false);
-        if (this.dbgVerboseLogsForFirstFrames) {
-            if (this._count === undefined) {
-                this._count = 0;
-            }
-            if (!this._count || this._count < this.dbgVerboseLogsNumFrames) {
-                console.log("frame #" + this._count + " - counters");
-            }
-        }
+        this.flushFramebuffer();
         this._textureHelper.destroyDeferredTextures();
         this._bufferManager.destroyDeferredBuffers();
         if (this._features._collectUbosUpdatedInFrame) {
@@ -1941,53 +1945,29 @@ export class WebGPUEngine extends Engine {
     }
     /**
      * 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 = true) {
+    flushFramebuffer() {
         // we need to end the current render pass (main or rtt) if any as we are not allowed to submit the command buffers when being in a pass
-        const currentRenderPassIsNULL = !this._currentRenderPass;
-        let currentPasses = 0; // 0 if no pass, 1 for rtt, 2 for main pass
-        if (this._currentRenderPass && this._currentRenderTarget) {
-            currentPasses |= 1;
-            this._endRenderTargetRenderPass();
-        }
-        if (this._mainRenderPassWrapper.renderPass) {
-            currentPasses |= 2;
-            this._endMainRenderPass();
-        }
+        this._endCurrentRenderPass();
         this._commandBuffers[0] = this._uploadEncoder.finish();
-        this._commandBuffers[1] = this._renderTargetEncoder.finish();
-        this._commandBuffers[2] = this._renderEncoder.finish();
+        this._commandBuffers[1] = this._renderEncoder.finish();
         this._device.queue.submit(this._commandBuffers);
         this._uploadEncoder = this._device.createCommandEncoder(this._uploadEncoderDescriptor);
         this._renderEncoder = this._device.createCommandEncoder(this._renderEncoderDescriptor);
-        this._renderTargetEncoder = this._device.createCommandEncoder(this._renderTargetEncoderDescriptor);
         this._timestampQuery.startFrame(this._uploadEncoder);
         this._textureHelper.setCommandEncoder(this._uploadEncoder);
         this._bundleList.reset();
-        this._bundleListRenderTarget.reset();
-        // restart the render pass
-        if (reopenPass) {
-            if (currentPasses & 2) {
-                this._startMainRenderPass(false);
-            }
-            if (currentPasses & 1) {
-                this._startRenderTargetRenderPass(this._currentRenderTarget, false, null, false, false);
-            }
-            if (currentRenderPassIsNULL && this._currentRenderTarget) {
-                this._currentRenderPass = null;
-            }
-        }
     }
     /** @internal */
     _currentFrameBufferIsDefaultFrameBuffer() {
-        return this._currentRenderTarget === null;
+        return this._currentPassIsMainPass();
     }
     //------------------------------------------------------------------------------
     //                              Render Pass
     //------------------------------------------------------------------------------
     _startRenderTargetRenderPass(renderTargetWrapper, setClearStates, clearColor, clearDepth, clearStencil) {
         var _a, _b, _c, _d, _e, _f, _g, _h;
+        this._endCurrentRenderPass();
         const rtWrapper = renderTargetWrapper;
         const depthStencilTexture = rtWrapper._depthStencilTexture;
         const gpuDepthStencilWrapper = depthStencilTexture === null || depthStencilTexture === void 0 ? void 0 : depthStencilTexture._hardwareTexture;
@@ -2084,73 +2064,36 @@ export class WebGPUEngine extends Engine {
                 : undefined,
             occlusionQuerySet: ((_g = this._occlusionQuery) === null || _g === void 0 ? void 0 : _g.hasQueries) ? this._occlusionQuery.querySet : undefined,
         };
-        this._rttRenderPassWrapper.renderPass = this._renderTargetEncoder.beginRenderPass(this._rttRenderPassWrapper.renderPassDescriptor);
+        this._currentRenderPass = this._renderEncoder.beginRenderPass(this._rttRenderPassWrapper.renderPassDescriptor);
         if (this.dbgVerboseLogsForFirstFrames) {
             if (this._count === undefined) {
                 this._count = 0;
             }
             if (!this._count || this._count < this.dbgVerboseLogsNumFrames) {
                 const internalTexture = rtWrapper.texture;
-                console.log("frame #" + this._count + " - render target begin pass - internalTexture.uniqueId=", internalTexture.uniqueId, "width=", internalTexture.width, "height=", internalTexture.height, this._rttRenderPassWrapper.renderPassDescriptor);
+                console.log("frame #" +
+                    this._count +
+                    " - render target begin pass - rtt name=" +
+                    renderTargetWrapper.label +
+                    ", internalTexture.uniqueId=" +
+                    internalTexture.uniqueId +
+                    ", width=" +
+                    internalTexture.width +
+                    ", height=" +
+                    internalTexture.height +
+                    ", setClearStates=" +
+                    setClearStates, "renderPassDescriptor=", this._rttRenderPassWrapper.renderPassDescriptor);
             }
         }
-        this._currentRenderPass = this._rttRenderPassWrapper.renderPass;
         (_h = this._debugFlushPendingCommands) === null || _h === void 0 ? void 0 : _h.call(this);
-        this._resetCurrentViewport(1);
-        this._resetCurrentScissor(1);
-        this._resetCurrentStencilRef(1);
-        this._resetCurrentColorBlend(1);
+        this._resetRenderPassStates();
         if (!gpuDepthStencilWrapper || !WebGPUTextureHelper.HasStencilAspect(gpuDepthStencilWrapper.format)) {
             this._stencilStateComposer.enabled = false;
         }
     }
-    /** @internal */
-    _endRenderTargetRenderPass() {
-        var _a, _b, _c, _d;
-        if (this._currentRenderPass) {
-            const gpuWrapper = (_a = this._currentRenderTarget.texture) === null || _a === void 0 ? void 0 : _a._hardwareTexture;
-            if (gpuWrapper && !this._snapshotRendering.endRenderTargetPass(this._currentRenderPass, gpuWrapper) && !this.compatibilityMode) {
-                this._bundleListRenderTarget.run(this._currentRenderPass);
-                this._bundleListRenderTarget.reset();
-            }
-            this._currentRenderPass.end();
-            if (this.dbgVerboseLogsForFirstFrames) {
-                if (this._count === undefined) {
-                    this._count = 0;
-                }
-                if (!this._count || this._count < this.dbgVerboseLogsNumFrames) {
-                    console.log("frame #" + this._count + " - render target end pass - internalTexture.uniqueId=", (_c = (_b = this._currentRenderTarget) === null || _b === void 0 ? void 0 : _b.texture) === null || _c === void 0 ? void 0 : _c.uniqueId);
-                }
-            }
-            (_d = this._debugPopGroup) === null || _d === void 0 ? void 0 : _d.call(this, 1);
-            this._resetCurrentViewport(1);
-            this._viewport(0, 0, 0, 0);
-            this._resetCurrentScissor(1);
-            this._resetCurrentStencilRef(1);
-            this._resetCurrentColorBlend(1);
-            this._currentRenderPass = null;
-            this._rttRenderPassWrapper.reset();
-        }
-    }
-    _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
-            this._startRenderTargetRenderPass(this._currentRenderTarget, false, null, false, false);
-        }
-        else if (!this._currentRenderPass) {
-            this._startMainRenderPass(false);
-        }
-        return this._currentRenderPass;
-    }
-    /** @internal */
-    _getCurrentRenderPassIndex() {
-        return this._currentRenderPass === null ? -1 : this._currentRenderPass === this._mainRenderPassWrapper.renderPass ? 0 : 1;
-    }
     _startMainRenderPass(setClearStates, clearColor, clearDepth, clearStencil) {
         var _a, _b, _c;
-        if (this._mainRenderPassWrapper.renderPass) {
-            this.flushFramebuffer(false);
-        }
+        this._endCurrentRenderPass();
         if (this.useReverseDepthBuffer) {
             this.setDepthFunctionToGreaterOrEqual();
         }
@@ -2188,48 +2131,47 @@ export class WebGPUEngine extends Engine {
                 this._count = 0;
             }
             if (!this._count || this._count < this.dbgVerboseLogsNumFrames) {
-                console.log("frame #" + this._count + " - main begin pass - texture width=" + this._mainTextureExtends.width, " height=" + this._mainTextureExtends.height, this._mainRenderPassWrapper.renderPassDescriptor);
+                console.log("frame #" + this._count + " - main begin pass - texture width=" + this._mainTextureExtends.width, " height=" + this._mainTextureExtends.height + ", setClearStates=" + setClearStates, "renderPassDescriptor=", this._mainRenderPassWrapper.renderPassDescriptor);
             }
         }
         (_b = this._debugPushGroup) === null || _b === void 0 ? void 0 : _b.call(this, "main pass", 0);
         this._currentRenderPass = this._renderEncoder.beginRenderPass(this._mainRenderPassWrapper.renderPassDescriptor);
-        this._mainRenderPassWrapper.renderPass = this._currentRenderPass;
+        this._setDepthTextureFormat(this._mainRenderPassWrapper);
+        this._setColorFormat(this._mainRenderPassWrapper);
         (_c = this._debugFlushPendingCommands) === null || _c === void 0 ? void 0 : _c.call(this);
-        this._resetCurrentViewport(0);
-        this._resetCurrentScissor(0);
-        this._resetCurrentStencilRef(0);
-        this._resetCurrentColorBlend(0);
+        this._resetRenderPassStates();
         if (!this._isStencilEnable) {
             this._stencilStateComposer.enabled = false;
         }
     }
-    _endMainRenderPass() {
-        var _a;
-        if (this._mainRenderPassWrapper.renderPass !== null) {
-            this._snapshotRendering.endMainRenderPass();
-            if (!this.compatibilityMode && !this._snapshotRendering.play) {
-                this._bundleList.run(this._mainRenderPassWrapper.renderPass);
-                this._bundleList.reset();
-            }
-            this._mainRenderPassWrapper.renderPass.end();
-            if (this.dbgVerboseLogsForFirstFrames) {
-                if (this._count === undefined) {
-                    this._count = 0;
-                }
-                if (!this._count || this._count < this.dbgVerboseLogsNumFrames) {
-                    console.log("frame #" + this._count + " - main end pass");
-                }
+    /** @internal */
+    _endCurrentRenderPass() {
+        var _a, _b, _c;
+        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();
+        if (this.dbgVerboseLogsForFirstFrames) {
+            if (this._count === undefined) {
+                this._count = 0;
             }
-            (_a = this._debugPopGroup) === null || _a === void 0 ? void 0 : _a.call(this, 0);
-            this._resetCurrentViewport(0);
-            this._resetCurrentScissor(0);
-            this._resetCurrentStencilRef(0);
-            this._resetCurrentColorBlend(0);
-            if (this._mainRenderPassWrapper.renderPass === this._currentRenderPass) {
-                this._currentRenderPass = null;
+            if (!this._count || this._count < this.dbgVerboseLogsNumFrames) {
+                console.log("frame #" +
+                    this._count +
+                    " - " +
+                    (currentPassIndex === 2 ? "main" : "render target") +
+                    " end pass" +
+                    (currentPassIndex === 1 ? " - internalTexture.uniqueId=" + ((_b = (_a = this._currentRenderTarget) === null || _a === void 0 ? void 0 : _a.texture) === null || _b === void 0 ? void 0 : _b.uniqueId) : ""));
             }
-            this._mainRenderPassWrapper.reset(false);
         }
+        (_c = this._debugPopGroup) === null || _c === void 0 ? void 0 : _c.call(this, 0);
+        this._currentRenderPass = null;
+        return currentPassIndex;
     }
     /**
      * Binds the frame buffer to the specified texture.
@@ -2247,10 +2189,10 @@ export class WebGPUEngine extends Engine {
         if (this._currentRenderTarget) {
             this.unBindFramebuffer(this._currentRenderTarget);
         }
-        this._currentRenderTarget = texture;
-        if (hardwareTexture) {
-            hardwareTexture._currentLayer = texture.isCube ? layer * 6 + faceIndex : layer;
+        else {
+            this._endCurrentRenderPass();
         }
+        this._currentRenderTarget = texture;
         this._rttRenderPassWrapper.colorAttachmentGPUTextures[0] = hardwareTexture;
         this._rttRenderPassWrapper.depthTextureFormat = this._currentRenderTarget._depthStencilTexture
             ? WebGPUTextureHelper.GetWebGPUTextureFormat(-1, this._currentRenderTarget._depthStencilTexture.format)
@@ -2280,14 +2222,21 @@ export class WebGPUEngine extends Engine {
                 this._count = 0;
             }
             if (!this._count || this._count < this.dbgVerboseLogsNumFrames) {
-                console.log("frame #" + this._count + " - bindFramebuffer called - internalTexture.uniqueId=", (_b = texture.texture) === null || _b === void 0 ? void 0 : _b.uniqueId, "face=", faceIndex, "lodLevel=", lodLevel, "layer=", layer, this._rttRenderPassWrapper.colorAttachmentViewDescriptor, this._rttRenderPassWrapper.depthAttachmentViewDescriptor);
-            }
-        }
-        this._currentRenderPass = null; // lazy creation of the render pass, hoping the render pass will be created by a call to clear()...
-        if (this.snapshotRendering && this.snapshotRenderingMode === 1) {
-            // force the creation of the render pass as we know in fast snapshot rendering mode clear() won't be called
-            this._getCurrentRenderPass();
-        }
+                console.log("frame #" +
+                    this._count +
+                    " - bindFramebuffer - rtt name=" +
+                    texture.label +
+                    ", internalTexture.uniqueId=" +
+                    ((_b = texture.texture) === null || _b === void 0 ? void 0 : _b.uniqueId) +
+                    ", face=" +
+                    faceIndex +
+                    ", lodLevel=" +
+                    lodLevel +
+                    ", layer=" +
+                    layer, "colorAttachmentViewDescriptor=", this._rttRenderPassWrapper.colorAttachmentViewDescriptor, "depthAttachmentViewDescriptor=", this._rttRenderPassWrapper.depthAttachmentViewDescriptor);
+            }
+        }
+        // We don't create the render pass just now, we do a lazy creation of the render pass, hoping the render pass will be created by a call to clear()...
         if (this._cachedViewport && !forceFullscreenViewport) {
             this.setViewport(this._cachedViewport, requiredWidth, requiredHeight);
         }
@@ -2322,28 +2271,22 @@ export class WebGPUEngine extends Engine {
             onBeforeUnbind();
         }
         this._currentRenderTarget = saveCRT;
-        if (this._currentRenderPass && this._currentRenderPass !== this._mainRenderPassWrapper.renderPass) {
-            this._endRenderTargetRenderPass();
-        }
+        this._endCurrentRenderPass();
         if (((_a = texture.texture) === null || _a === void 0 ? void 0 : _a.generateMipMaps) && !disableGenerateMipMaps && !texture.isCube) {
             this._generateMipmaps(texture.texture);
         }
         this._currentRenderTarget = null;
-        this._onAfterUnbindFrameBufferObservable.notifyObservers(this);
         if (this.dbgVerboseLogsForFirstFrames) {
             if (this._count === undefined) {
                 this._count = 0;
             }
             if (!this._count || this._count < this.dbgVerboseLogsNumFrames) {
-                console.log("frame #" + this._count + " - unBindFramebuffer called - internalTexture.uniqueId=", (_b = texture.texture) === null || _b === void 0 ? void 0 : _b.uniqueId);
+                console.log("frame #" + this._count + " - unBindFramebuffer - rtt name=" + texture.label + ", internalTexture.uniqueId=", (_b = texture.texture) === null || _b === void 0 ? void 0 : _b.uniqueId);
             }
         }
         this._mrtAttachments = [];
         this._cacheRenderPipeline.setMRT([]);
         this._cacheRenderPipeline.setMRTAttachments(this._mrtAttachments);
-        this._currentRenderPass = this._mainRenderPassWrapper.renderPass;
-        this._setDepthTextureFormat(this._mainRenderPassWrapper);
-        this._setColorFormat(this._mainRenderPassWrapper);
     }
     /**
      * Unbind the current render target and bind the default framebuffer
@@ -2352,15 +2295,11 @@ export class WebGPUEngine extends Engine {
         if (this._currentRenderTarget) {
             this.unBindFramebuffer(this._currentRenderTarget);
         }
-        else {
-            this._currentRenderPass = this._mainRenderPassWrapper.renderPass;
-            this._setDepthTextureFormat(this._mainRenderPassWrapper);
-            this._setColorFormat(this._mainRenderPassWrapper);
+        else if (!this._currentRenderPass) {
+            this._startMainRenderPass(false);
         }
-        if (this._currentRenderPass) {
-            if (this._cachedViewport) {
-                this.setViewport(this._cachedViewport);
-            }
+        if (this._cachedViewport) {
+            this.setViewport(this._cachedViewport);
         }
         this.wipeCaches();
     }
@@ -2426,46 +2365,26 @@ export class WebGPUEngine extends Engine {
         }
         this._stencilStateComposer.stencilMaterial = stencil;
     }
-    _applyRenderPassChanges(renderPass, bundleList) {
-        var _a;
-        const mustUpdateViewport = this._mustUpdateViewport(renderPass);
-        const mustUpdateScissor = this._mustUpdateScissor(renderPass);
-        const mustUpdateStencilRef = !this._stencilStateComposer.enabled ? false : this._mustUpdateStencilRef(renderPass);
-        const mustUpdateBlendColor = !this._alphaState.alphaBlend ? false : this._mustUpdateBlendColor(renderPass);
-        if (bundleList) {
-            if (mustUpdateViewport) {
-                bundleList.addItem(new WebGPURenderItemViewport(this._viewportCached.x, this._viewportCached.y, this._viewportCached.z, this._viewportCached.w));
-            }
-            if (mustUpdateScissor) {
-                bundleList.addItem(new WebGPURenderItemScissor(this._scissorCached.x, this._scissorCached.y, this._scissorCached.z, this._scissorCached.w));
-            }
-            if (mustUpdateStencilRef) {
-                bundleList.addItem(new WebGPURenderItemStencilRef((_a = this._stencilStateComposer.funcRef) !== null && _a !== void 0 ? _a : 0));
-            }
-            if (mustUpdateBlendColor) {
-                bundleList.addItem(new WebGPURenderItemBlendColor(this._alphaState._blendConstants.slice()));
-            }
+    _applyRenderPassChanges(bundleList) {
+        const mustUpdateStencilRef = !this._stencilStateComposer.enabled ? false : this._mustUpdateStencilRef();
+        const mustUpdateBlendColor = !this._alphaState.alphaBlend ? false : this._mustUpdateBlendColor();
+        if (this._mustUpdateViewport()) {
+            this._applyViewport(bundleList);
         }
-        else {
-            if (mustUpdateViewport) {
-                this._applyViewport(renderPass);
-            }
-            if (mustUpdateScissor) {
-                this._applyScissor(renderPass);
-            }
-            if (mustUpdateStencilRef) {
-                this._applyStencilRef(renderPass);
-            }
-            if (mustUpdateBlendColor) {
-                this._applyBlendColor(renderPass);
-            }
+        if (this._mustUpdateScissor()) {
+            this._applyScissor(bundleList);
+        }
+        if (mustUpdateStencilRef) {
+            this._applyStencilRef(bundleList);
+        }
+        if (mustUpdateBlendColor) {
+            this._applyBlendColor(bundleList);
         }
     }
     _draw(drawType, fillMode, start, count, instancesCount) {
         var _a;
         const renderPass = this._getCurrentRenderPass();
-        const renderPassIndex = this._getCurrentRenderPassIndex();
-        const bundleList = renderPassIndex === 0 ? this._bundleList : this._bundleListRenderTarget;
+        const bundleList = this._bundleList;
         this.applyStates();
         const webgpuPipelineContext = this._currentEffect._pipelineContext;
         this.bindUniformBufferBase(this._currentRenderTarget ? this._ubInvertY : this._ubDontInvertY, 0, WebGPUShaderProcessor.InternalsUBOName);
@@ -2484,7 +2403,7 @@ export class WebGPUEngine extends Engine {
         const useFastPath = !this.compatibilityMode && this._currentDrawContext.fastBundle;
         let renderPass2 = renderPass;
         if (useFastPath || this._snapshotRendering.record) {
-            this._applyRenderPassChanges(renderPass, bundleList);
+            this._applyRenderPassChanges(bundleList);
             if (!this._snapshotRendering.record) {
                 this._counters.numBundleReuseNonCompatMode++;
                 if (this._currentDrawContext.indirectDrawBuffer) {
@@ -2498,12 +2417,13 @@ export class WebGPUEngine extends Engine {
             bundleList.numDrawCalls++;
         }
         let textureState = 0;
-        if (!this._caps.textureFloatLinearFiltering && this._currentMaterialContext.hasFloatTextures) {
+        if (this._currentMaterialContext.hasFloatOrDepthTextures) {
             let bitVal = 1;
             for (let i = 0; i < webgpuPipelineContext.shaderProcessingContext.textureNames.length; ++i) {
                 const textureName = webgpuPipelineContext.shaderProcessingContext.textureNames[i];
                 const texture = (_a = this._currentMaterialContext.textures[textureName]) === null || _a === void 0 ? void 0 : _a.texture;
-                if ((texture === null || texture === void 0 ? void 0 : texture.type) === 1) {
+                const textureIsDepth = texture && texture.format >= 13 && texture.format <= 18;
+                if (((texture === null || texture === void 0 ? void 0 : texture.type) === 1 && !this._caps.textureFloatLinearFiltering) || textureIsDepth) {
                     textureState |= bitVal;
                 }
                 bitVal = bitVal << 1;
@@ -2513,13 +2433,13 @@ export class WebGPUEngine extends Engine {
         const pipeline = this._cacheRenderPipeline.getRenderPipeline(fillMode, this._currentEffect, this.currentSampleCount, textureState);
         const bindGroups = this._cacheBindGroups.getBindGroups(webgpuPipelineContext, this._currentDrawContext, this._currentMaterialContext);
         if (!this._snapshotRendering.record) {
-            this._applyRenderPassChanges(renderPass, !this.compatibilityMode ? bundleList : null);
+            this._applyRenderPassChanges(!this.compatibilityMode ? bundleList : null);
             if (!this.compatibilityMode) {
                 this._counters.numBundleCreationNonCompatMode++;
                 renderPass2 = this._device.createRenderBundleEncoder({
                     colorFormats: this._cacheRenderPipeline.colorFormats,
                     depthStencilFormat: this._depthTextureFormat,
-                    sampleCount: this.currentSampleCount,
+                    sampleCount: WebGPUTextureHelper.GetSample(this.currentSampleCount),
                 });
             }
         }