Fix stencil texture invalidation on RenderPass reset

Author: egorodet

Modules/Graphics/RHI/Base/Sources/Methane/Graphics/Base/RenderPass.cpp

@@ -55,6 +55,7 @@ bool RenderPass::Update(const Rhi::RenderPassSettings& settings)
         m_non_frame_buffer_attachment_textures.clear();
         m_color_attachment_textures.clear();
         m_depth_attachment_texture_ptr = nullptr;
+        m_stencil_attachment_texture_ptr = nullptr;
     }
 
     InitAttachmentStates();

Tests/Graphics/RHI/RenderPassTest.cpp

@@ -28,6 +28,8 @@ Unit-tests of the RHI RenderPass
 #include <Methane/Graphics/RHI/RenderPattern.h>
 #include <Methane/Graphics/RHI/RenderPass.h>
 #include <Methane/Graphics/RHI/ObjectRegistry.h>
+#include <Methane/Graphics/Base/RenderPass.h>
+#include <Methane/Graphics/Base/Texture.h>
 
 #include <memory>
 #include <taskflow/taskflow.hpp>
@@ -132,6 +134,25 @@ TEST_CASE("RHI Render Pass Functions", "[rhi][render][pass]")
         CHECK(render_pass.GetSettings() == new_render_pass_resources.settings);
     }
 
+    SECTION("Update Settings Invalidates Attachment Textures Cache")
+    {
+        const auto& base_render_pass = dynamic_cast<const Base::RenderPass&>(render_pass.GetInterface());
+
+        // Populate lazily-initialized attachment texture caches with the original attachments
+        const Base::Texture* orig_color_texture_ptr = &base_render_pass.GetColorAttachmentTextures().front().get();
+        const Base::Texture* orig_depth_texture_ptr = base_render_pass.GetDepthAttachmentTexture();
+        CHECK(orig_color_texture_ptr == render_pass_resources.frame_buffer_texture.GetInterfacePtr().get());
+        CHECK(orig_depth_texture_ptr == render_pass_resources.depth_stencil_texture.GetInterfacePtr().get());
+
+        const Test::RenderPassResources new_render_pass_resources = Test::GetRenderPassResources(render_pattern);
+        CHECK(render_pass.Update(new_render_pass_resources.settings));
+
+        CHECK(&base_render_pass.GetColorAttachmentTextures().front().get() ==
+              new_render_pass_resources.frame_buffer_texture.GetInterfacePtr().get());
+        CHECK(base_render_pass.GetDepthAttachmentTexture() ==
+              new_render_pass_resources.depth_stencil_texture.GetInterfacePtr().get());
+    }
+
     SECTION("Release Attachment Textures")
     {
         const Rhi::RenderPassSettings& render_pass_settings = render_pass.GetSettings();
@@ -140,3 +161,50 @@ TEST_CASE("RHI Render Pass Functions", "[rhi][render][pass]")
         CHECK(render_pass_settings.attachments.empty());
     }
 }
+
+TEST_CASE("RHI Render Pass with Stencil Attachment Functions", "[rhi][render][pass]")
+{
+    const Rhi::RenderPattern        render_pattern        = render_context.CreateRenderPattern(Test::GetRenderPatternSettings(true));
+    const Test::RenderPassResources render_pass_resources = Test::GetRenderPassResources(render_pattern);
+    const Rhi::RenderPass           render_pass           = render_pattern.CreateRenderPass(render_pass_resources.settings);
+    const auto& base_render_pass = dynamic_cast<const Base::RenderPass&>(render_pass.GetInterface());
+
+    SECTION("Get Stencil Attachment Texture")
+    {
+        REQUIRE(render_pass_resources.stencil_texture.IsInitialized());
+        CHECK(base_render_pass.GetStencilAttachmentTexture() ==
+              render_pass_resources.stencil_texture.GetInterfacePtr().get());
+    }
+
+    SECTION("Update Settings Invalidates Stencil Attachment Texture Cache")
+    {
+        // Populate the lazily-initialized stencil attachment texture cache with the original attachment
+        REQUIRE(base_render_pass.GetStencilAttachmentTexture() ==
+                render_pass_resources.stencil_texture.GetInterfacePtr().get());
+
+        const Test::RenderPassResources new_render_pass_resources = Test::GetRenderPassResources(render_pattern);
+        REQUIRE(new_render_pass_resources.stencil_texture.GetInterfacePtr() !=
+                render_pass_resources.stencil_texture.GetInterfacePtr());
+        CHECK(render_pass.Update(new_render_pass_resources.settings));
+
+        CHECK(base_render_pass.GetStencilAttachmentTexture() ==
+              new_render_pass_resources.stencil_texture.GetInterfacePtr().get());
+    }
+
+    SECTION("Update Settings Invalidates Non-Frame-Buffer Attachment Textures Cache")
+    {
+        // Frame buffer color attachment is excluded from the non-frame-buffer textures, so only depth & stencil remain
+        const Ptrs<Base::Texture>& orig_textures = base_render_pass.GetNonFrameBufferAttachmentTextures();
+        REQUIRE(orig_textures.size() == 2U);
+        CHECK(orig_textures[0].get() == render_pass_resources.depth_stencil_texture.GetInterfacePtr().get());
+        CHECK(orig_textures[1].get() == render_pass_resources.stencil_texture.GetInterfacePtr().get());
+
+        const Test::RenderPassResources new_render_pass_resources = Test::GetRenderPassResources(render_pattern);
+        CHECK(render_pass.Update(new_render_pass_resources.settings));
+
+        const Ptrs<Base::Texture>& new_textures = base_render_pass.GetNonFrameBufferAttachmentTextures();
+        REQUIRE(new_textures.size() == 2U);
+        CHECK(new_textures[0].get() == new_render_pass_resources.depth_stencil_texture.GetInterfacePtr().get());
+        CHECK(new_textures[1].get() == new_render_pass_resources.stencil_texture.GetInterfacePtr().get());
+    }
+}

Tests/Graphics/RHI/RhiSettings.hpp

@@ -49,7 +49,7 @@ inline Rhi::RenderContextSettings GetRenderContextSettings()
     };
 }
 
-inline Rhi::RenderPatternSettings GetRenderPatternSettings()
+inline Rhi::RenderPatternSettings GetRenderPatternSettings(bool with_stencil_attachment = false)
 {
     return Rhi::RenderPatternSettings
     {
@@ -67,7 +67,14 @@ inline Rhi::RenderPatternSettings GetRenderPatternSettings()
             Rhi::RenderPassAttachment::StoreAction::Store,
             0.F
         },
-        .stencil_attachment = std::nullopt,
+        .stencil_attachment = with_stencil_attachment
+                            ? Opt<Rhi::RenderPassStencilAttachment>(Rhi::RenderPassStencilAttachment{
+                                  2U, PixelFormat::Depth32Float, 1U,
+                                  Rhi::RenderPassAttachment::LoadAction::Clear,
+                                  Rhi::RenderPassAttachment::StoreAction::Store,
+                                  0U
+                              })
+                            : std::nullopt,
         .shader_access = Rhi::RenderPassAccessMask{ Rhi::RenderPassAccess::ShaderResources },
         .is_final_pass = true
     };
@@ -77,6 +84,7 @@ struct RenderPassResources
 {
     Rhi::Texture frame_buffer_texture;
     Rhi::Texture depth_stencil_texture;
+    Rhi::Texture stencil_texture;
     Rhi::RenderPassSettings settings;
 };
 
@@ -97,6 +105,20 @@ inline RenderPassResources GetRenderPassResources(const Rhi::RenderPattern& rend
     resources.settings.frame_size = frame_size;
     resources.settings.attachments.push_back(resources.frame_buffer_texture.GetTextureView());
     resources.settings.attachments.push_back(resources.depth_stencil_texture.GetTextureView());
+
+    // Separate stencil attachment texture is added only when the render pattern declares a stencil attachment,
+    // so that its index in the render pass attachments matches RenderPassStencilAttachment::attachment_index.
+    if (const Opt<Rhi::RenderPassStencilAttachment>& stencil_attachment = render_pattern.GetSettings().stencil_attachment;
+        stencil_attachment)
+    {
+        resources.stencil_texture = render_pattern.GetRenderContext().CreateTexture(
+                                        Rhi::TextureSettings::ForDepthStencil(
+                                            Dimensions(frame_size),
+                                            stencil_attachment->format,
+                                            DepthStencilValues(0.f, 0.f),
+                                            Rhi::ResourceUsageMask({ Rhi::ResourceUsage::RenderTarget })));
+        resources.settings.attachments.push_back(resources.stencil_texture.GetTextureView());
+    }
     return resources;
 }