ADD: SSR

src/core/assets/ibl_manager.cpp

@@ -237,7 +237,29 @@ bool IBLManager::load(const IBLPaths &paths)
         _diff = _spec;
     }
 
-    // If background is still missing but specular is valid, reuse the specular environment.
+    if (!paths.background2D.empty())
+    {
+        ktxutil::Ktx2D bg{};
+        if (ktxutil::load_ktx2_2d(paths.background2D.c_str(), bg))
+        {
+            std::vector<ResourceManager::MipLevelCopy> lv;
+            lv.reserve(bg.mipLevels);
+            for (uint32_t mip = 0; mip < bg.mipLevels; ++mip)
+            {
+                const auto &r = bg.copies[mip];
+                lv.push_back(ResourceManager::MipLevelCopy{
+                    .offset = r.bufferOffset,
+                    .length = 0,
+                    .width  = r.imageExtent.width,
+                    .height = r.imageExtent.height,
+                });
+            }
+            _background = rm->create_image_compressed(
+                bg.bytes.data(), bg.bytes.size(), bg.fmt, lv,
+                VK_IMAGE_USAGE_SAMPLED_BIT);
+        }
+    }
+
     if (_background.image == VK_NULL_HANDLE && _spec.image != VK_NULL_HANDLE)
     {
         _background = _spec;

src/core/context.h

@@ -75,6 +75,7 @@ public:
 
     // Runtime settings visible to passes/shaders
     ShadowSettings shadowSettings{};
+    bool enableSSR = false;                      // optional screen-space reflections toggle
 
     // Ray tracing manager (optional, nullptr if unsupported)
     RayTracingManager* ray = nullptr;

src/core/engine.cpp

@@ -268,6 +268,8 @@ void VulkanEngine::init()
 
     _resourceManager->set_deferred_uploads(true);
 
+    _context->enableSSR = true;
+
     //everything went fine
     _isInitialized = true;
 }
@@ -716,16 +718,49 @@ void VulkanEngine::draw()
                 lighting->register_graph(_renderGraph.get(), hDraw, hGBufferPosition, hGBufferNormal, hGBufferAlbedo,
                                          std::span<RGImageHandle>(hShadowCascades.data(), hShadowCascades.size()));
             }
+
+            // Optional Screen Space Reflections pass: consumes HDR draw + G-Buffer and
+            // produces an SSR-augmented HDR image. Controlled by EngineContext::enableSSR.
+            RGImageHandle hSSR{};
+            SSRPass *ssr = _renderPassManager->getPass<SSRPass>();
+            const bool ssrEnabled = (_context && _context->enableSSR && ssr != nullptr);
+            if (ssrEnabled)
+            {
+                RGImageDesc ssrDesc{};
+                ssrDesc.name = "hdr.ssr";
+                ssrDesc.format = _swapchainManager->drawImage().imageFormat;
+                ssrDesc.extent = _drawExtent;
+                ssrDesc.usage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT
+                                | VK_IMAGE_USAGE_SAMPLED_BIT
+                                | VK_IMAGE_USAGE_STORAGE_BIT;
+                hSSR = _renderGraph->create_image(ssrDesc);
+
+                ssr->register_graph(_renderGraph.get(),
+                                    hDraw,
+                                    hGBufferPosition,
+                                    hGBufferNormal,
+                                    hGBufferAlbedo,
+                                    hSSR);
+            }
+
             if (auto *transparent = _renderPassManager->getPass<TransparentPass>())
             {
-                transparent->register_graph(_renderGraph.get(), hDraw, hDepth);
+                // Transparent objects draw on top of either the SSR output or the raw HDR draw.
+                RGImageHandle hdrTarget = (ssrEnabled && hSSR.valid()) ? hSSR : hDraw;
+                transparent->register_graph(_renderGraph.get(), hdrTarget, hDepth);
             }
             imguiPass = _renderPassManager->getImGuiPass();
 
             // Optional Tonemap pass: sample HDR draw -> LDR intermediate
             if (auto *tonemap = _renderPassManager->getPass<TonemapPass>())
             {
-                finalColor = tonemap->register_graph(_renderGraph.get(), hDraw);
+                RGImageHandle hdrInput = (ssrEnabled && hSSR.valid()) ? hSSR : hDraw;
+                finalColor = tonemap->register_graph(_renderGraph.get(), hdrInput);
+            }
+            else
+            {
+                // If tonemapping is disabled, present whichever HDR buffer we ended up with.
+                finalColor = (ssrEnabled && hSSR.valid()) ? hSSR : hDraw;
             }
         }
 

src/core/engine.h

@@ -26,6 +26,7 @@
 #include "frame/resources.h"
 #include "descriptor/manager.h"
 #include "pipeline/sampler.h"
+#include "render/passes/ssr.h"
 #include "core/context.h"
 #include "core/pipeline/manager.h"
 #include "core/assets/manager.h"