Fixed window resizing

src/Editor/Asset/EnvironmentLoader.cpp

@@ -143,10 +143,6 @@ void EnvironmentLoader::import(EnvironmentImportArgs args, PEnvironmentMapAsset
             .dstAccess = Gfx::SE_ACCESS_SHADER_READ_BIT,
         }
         },
-        URect{
-            .size = {SOURCE_RESOLUTION, SOURCE_RESOLUTION},
-            .offset = {0, 0},
-        },
         "EnvironmentRenderPass", {0b111111}, {0b111111});
     cubeRenderPipeline = graphics->createGraphicsPipeline(Gfx::LegacyPipelineCreateInfo{
         .vertexShader = cubeRenderVertex,
@@ -180,10 +176,6 @@ void EnvironmentLoader::import(EnvironmentImportArgs args, PEnvironmentMapAsset
                                                              Gfx::SE_ATTACHMENT_LOAD_OP_DONT_CARE, Gfx::SE_ATTACHMENT_STORE_OP_STORE)},
         },
         {},
-        URect{
-            .size = {CONVOLUTED_RESOLUTION, CONVOLUTED_RESOLUTION},
-            .offset = {0, 0},
-        },
         "EnvironmentRenderPass", {0b111111}, {0b111111});
     convolutionPipeline = graphics->createGraphicsPipeline(Gfx::LegacyPipelineCreateInfo{
         .vertexShader = cubeRenderVertex,

src/Engine/Graphics/Graphics.h

@@ -55,7 +55,7 @@ class Graphics {
     virtual OWindow createWindow(const WindowCreateInfo& createInfo) = 0;
     virtual OViewport createViewport(PWindow owner, const ViewportCreateInfo& createInfo) = 0;
 
-    virtual ORenderPass createRenderPass(RenderTargetLayout layout, Array<SubPassDependency> dependencies, URect renderArea,
+    virtual ORenderPass createRenderPass(RenderTargetLayout layout, Array<SubPassDependency> dependencies,
                                          std::string name = "", Array<uint32> viewMasks = {0}, Array<uint32> correlationMasks = {}) = 0;
     virtual void beginRenderPass(PRenderPass renderPass) = 0;
     virtual void endRenderPass() = 0;

src/Engine/Graphics/RenderPass/BasePass.cpp

@@ -472,7 +472,7 @@ void BasePass::createRenderPass() {
                          Gfx::SE_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT,
         },
     };
-    renderPass = graphics->createRenderPass(std::move(layout), std::move(dependency), viewport->getRenderArea(), "BasePass");
+    renderPass = graphics->createRenderPass(std::move(layout), std::move(dependency), "BasePass");
     oLightIndexList = resources->requestBuffer("LIGHTCULLING_OLIGHTLIST");
     tLightIndexList = resources->requestBuffer("LIGHTCULLING_TLIGHTLIST");
     oLightGrid = resources->requestTexture("LIGHTCULLING_OLIGHTGRID");

src/Engine/Graphics/RenderPass/CachedDepthPass.cpp

@@ -203,5 +203,5 @@ void CachedDepthPass::createRenderPass() {
                          Gfx::SE_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT,
         },
     };
-    renderPass = graphics->createRenderPass(std::move(layout), std::move(dependency), viewport->getRenderArea(), "CachedDepthPass");
+    renderPass = graphics->createRenderPass(std::move(layout), std::move(dependency), "CachedDepthPass");
 }

src/Engine/Graphics/RenderPass/DepthCullingPass.cpp

@@ -306,5 +306,5 @@ void DepthCullingPass::createRenderPass() {
                          Gfx::SE_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT,
         },
     };
-    renderPass = graphics->createRenderPass(std::move(layout), std::move(dependency), viewport->getRenderArea(), "DepthCullingPass");
+    renderPass = graphics->createRenderPass(std::move(layout), std::move(dependency), "DepthCullingPass");
 }

src/Engine/Graphics/RenderPass/ToneMappingPass.cpp

@@ -216,7 +216,7 @@ void ToneMappingPass::createRenderPass() {
             .dstAccess = Gfx::SE_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,
         },
     };
-    renderPass = graphics->createRenderPass(targetLayout, dependency, viewport->getRenderArea(), "ToneMappingPass");
+    renderPass = graphics->createRenderPass(targetLayout, dependency, "ToneMappingPass");
     pipeline = graphics->createGraphicsPipeline(Gfx::LegacyPipelineCreateInfo{
         .vertexShader = vert,
         .fragmentShader = frag,

src/Engine/Graphics/RenderPass/UIPass.cpp

@@ -170,7 +170,7 @@ void UIPass::createRenderPass() {
                          Gfx::SE_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT,
         },
     };
-    renderPass = graphics->createRenderPass(std::move(layout), dependency, viewport->getRenderArea(), "TextPass");
+    renderPass = graphics->createRenderPass(std::move(layout), dependency, "TextPass");
 
     graphics->beginShaderCompilation(ShaderCompilationInfo{
         .name = "TextVertex",

src/Engine/Graphics/Vulkan/Command.cpp

@@ -58,7 +58,7 @@ void Command::beginRenderPass(PRenderPass renderPass, PFramebuffer framebuffer)
         .pNext = nullptr,
         .renderPass = renderPass->getHandle(),
         .framebuffer = framebuffer->getHandle(),
-        .renderArea = renderPass->getRenderArea(),
+        .renderArea = framebuffer->getRenderArea(),
         .clearValueCount = (uint32)renderPass->getClearValueCount(),
         .pClearValues = renderPass->getClearValues(),
     };

src/Engine/Graphics/Vulkan/Descriptor.cpp

@@ -197,7 +197,7 @@ DescriptorSet::DescriptorSet(PGraphics graphics, PDescriptorPool owner)
     constantData.resize(owner->getLayout()->constantsSize);
 }
 
-DescriptorSet::~DescriptorSet() {}
+DescriptorSet::~DescriptorSet() { graphics->getDestructionManager()->queueResourceForDestruction(std::move(constantsBuffer)); }
 
 void DescriptorSet::updateConstants(const std::string& mappingName, uint32 offset, void* data) {
     std::memcpy(constantData.data() + owner->getLayout()->mappings[mappingName].constantOffset, (char*)data + offset,

src/Engine/Graphics/Vulkan/Framebuffer.cpp

@@ -69,7 +69,10 @@ Framebuffer::Framebuffer(PGraphics graphics, PRenderPass renderPass, Gfx::Render
         .layers = 1,
     };
     VK_CHECK(vkCreateFramebuffer(graphics->getDevice(), &createInfo, nullptr, &handle));
-
+    renderArea = VkRect2D{
+        .offset = {0, 0},
+        .extent = {width, height},
+    };
     hash = CRC::Calculate(&description, sizeof(FramebufferDescription), CRC::CRC_32());
 }
 

src/Engine/Graphics/Vulkan/Framebuffer.h

@@ -22,9 +22,11 @@ class Framebuffer {
     virtual ~Framebuffer();
     constexpr VkFramebuffer getHandle() const { return handle; }
     constexpr uint32 getHash() const { return hash; }
+    constexpr VkRect2D getRenderArea() const { return renderArea; }
 
   private:
     uint32 hash;
+    VkRect2D renderArea;
     PGraphics graphics;
     VkFramebuffer handle;
     Gfx::RenderTargetLayout layout;

src/Engine/Graphics/Vulkan/Graphics.cpp

@@ -171,10 +171,9 @@ Gfx::OViewport Graphics::createViewport(Gfx::PWindow owner, const ViewportCreate
     return new Viewport(owner, viewportInfo);
 }
 
-Gfx::ORenderPass Graphics::createRenderPass(Gfx::RenderTargetLayout layout, Array<Gfx::SubPassDependency> dependencies,
+Gfx::ORenderPass Graphics::createRenderPass(Gfx::RenderTargetLayout layout, Array<Gfx::SubPassDependency> dependencies, std::string name,
-                                            URect renderArea, std::string name, Array<uint32> viewMasks,
+                                            Array<uint32> viewMasks, Array<uint32> correlationMasks) {
-                                            Array<uint32> correlationMasks) {
+    return new RenderPass(this, std::move(layout), std::move(dependencies), name, std::move(viewMasks), std::move(correlationMasks));
-    return new RenderPass(this, std::move(layout), std::move(dependencies), renderArea, name, std::move(viewMasks), std::move(correlationMasks));
 }
 void Graphics::beginRenderPass(Gfx::PRenderPass renderPass) {
     PRenderPass rp = renderPass.cast<RenderPass>();
@@ -322,9 +321,7 @@ Gfx::OPipelineStatisticsQuery Graphics::createPipelineStatisticsQuery(const std:
     return new PipelineStatisticsQuery(this, name);
 }
 
-Gfx::OTimestampQuery Graphics::createTimestampQuery(uint64, const std::string& name) {
+Gfx::OTimestampQuery Graphics::createTimestampQuery(uint64, const std::string& name) { return new TimestampQuery(this, name); }
-    return new TimestampQuery(this, name);
-}
 
 void Graphics::beginDebugRegion(const std::string& name) {
     VkDebugUtilsLabelEXT label = {
@@ -591,7 +588,8 @@ void Graphics::buildBottomLevelAccelerationStructures(Array<Gfx::PBottomLevelAS>
     }
 
     PCommand cmd = graphicsCommands->getCommands();
-    vkCmdBuildAccelerationStructuresKHR(cmd->getHandle(), (uint32)buildGeometries.size(), buildGeometries.data(), buildRangePointers.data());
+    vkCmdBuildAccelerationStructuresKHR(cmd->getHandle(), (uint32)buildGeometries.size(), buildGeometries.data(),
+                                        buildRangePointers.data());
     cmd->bindResource(PBufferAllocation(transformBuffer));
     destructionManager->queueResourceForDestruction(std::move(transformBuffer));
     for (auto& scratchAlloc : scratchBuffers) {

src/Engine/Graphics/Vulkan/Graphics.h

@@ -34,9 +34,8 @@ class Graphics : public Gfx::Graphics {
     virtual Gfx::OWindow createWindow(const WindowCreateInfo& createInfo) override;
     virtual Gfx::OViewport createViewport(Gfx::PWindow owner, const ViewportCreateInfo& createInfo) override;
 
-    virtual Gfx::ORenderPass createRenderPass(Gfx::RenderTargetLayout layout, Array<Gfx::SubPassDependency> dependencies,
+    virtual Gfx::ORenderPass createRenderPass(Gfx::RenderTargetLayout layout, Array<Gfx::SubPassDependency> dependencies, std::string name,
-                                              URect renderArea, std::string name, Array<uint32> viewMasks,
+                                              Array<uint32> viewMasks, Array<uint32> correlationMasks) override;
-                                              Array<uint32> correlationMasks) override;
     virtual void beginRenderPass(Gfx::PRenderPass renderPass) override;
     virtual void endRenderPass() override;
     virtual void waitDeviceIdle() override;
@@ -68,7 +67,7 @@ class Graphics : public Gfx::Graphics {
     virtual Gfx::PRayTracingPipeline createRayTracingPipeline(Gfx::RayTracingPipelineCreateInfo createInfo) override;
     virtual Gfx::PComputePipeline createComputePipeline(Gfx::ComputePipelineCreateInfo createInfo) override;
     virtual Gfx::OSampler createSampler(const SamplerCreateInfo& createInfo) override;
-    
+
     virtual Gfx::ODescriptorLayout createDescriptorLayout(const std::string& name = "") override;
     virtual Gfx::OPipelineLayout createPipelineLayout(const std::string& name = "", Gfx::PPipelineLayout baseLayout = nullptr) override;
 
@@ -83,7 +82,7 @@ class Graphics : public Gfx::Graphics {
 
     virtual void resolveTexture(Gfx::PTexture source, Gfx::PTexture destination) override;
     virtual void copyTexture(Gfx::PTexture src, Gfx::PTexture dst) override;
-    
+
     virtual void copyBuffer(Gfx::PShaderBuffer src, Gfx::PShaderBuffer dst) override;
 
     // Ray Tracing

src/Engine/Graphics/Vulkan/RenderPass.cpp

@@ -9,13 +9,9 @@
 using namespace Seele;
 using namespace Seele::Vulkan;
 
-RenderPass::RenderPass(PGraphics graphics, Gfx::RenderTargetLayout _layout, Array<Gfx::SubPassDependency> _dependencies, URect viewport,
+RenderPass::RenderPass(PGraphics graphics, Gfx::RenderTargetLayout _layout, Array<Gfx::SubPassDependency> _dependencies,
                        std::string name, Array<uint32> viewMasks, Array<uint32> correlationMasks)
     : Gfx::RenderPass(std::move(_layout), std::move(_dependencies)), graphics(graphics) {
-    renderArea.extent.width = viewport.size.x;
-    renderArea.extent.height = viewport.size.y;
-    renderArea.offset.x = viewport.offset.x;
-    renderArea.offset.y = viewport.offset.y;
     subpassContents = VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS;
     Array<VkAttachmentDescription2> attachments;
     Array<VkAttachmentReference2> inputRefs;

src/Engine/Graphics/Vulkan/RenderPass.h

@@ -6,7 +6,7 @@ namespace Seele {
 namespace Vulkan {
 class RenderPass : public Gfx::RenderPass {
   public:
-    RenderPass(PGraphics graphics, Gfx::RenderTargetLayout layout, Array<Gfx::SubPassDependency> dependencies, URect viewport,
+    RenderPass(PGraphics graphics, Gfx::RenderTargetLayout layout, Array<Gfx::SubPassDependency> dependencies,
                std::string name, Array<uint32> viewMasks = {}, Array<uint32> correlationMasks = {});
     virtual ~RenderPass();
     uint32 getFramebufferHash();
@@ -14,7 +14,6 @@ class RenderPass : public Gfx::RenderPass {
     constexpr VkRenderPass getHandle() const { return renderPass; }
     constexpr size_t getClearValueCount() const { return clearValues.size(); }
     constexpr VkClearValue* getClearValues() const { return clearValues.data(); }
-    constexpr VkRect2D getRenderArea() const { return renderArea; }
     constexpr VkSubpassContents getSubpassContents() const { return subpassContents; }
 
   private:

src/Engine/Window/GameView.cpp

@@ -10,8 +10,8 @@
 #include "Graphics/RenderPass/LightCullingPass.h"
 #include "Graphics/RenderPass/RayTracingPass.h"
 #include "Graphics/RenderPass/RenderGraphResources.h"
-#include "Graphics/RenderPass/VisibilityPass.h"
 #include "Graphics/RenderPass/ToneMappingPass.h"
+#include "Graphics/RenderPass/VisibilityPass.h"
 #include "System/CameraUpdater.h"
 #include "System/LightGather.h"
 #include "System/MeshUpdater.h"
@@ -36,7 +36,6 @@ GameView::GameView(Gfx::PGraphics graphics, PWindow window, const ViewportCreate
         rayTracingGraph.setViewport(viewport);
         rayTracingGraph.createRenderPass();
     }
-
 }
 
 GameView::~GameView() {}
@@ -77,7 +76,10 @@ void GameView::render() {
     }
 }
 
-void GameView::applyArea(URect) { renderGraph.setViewport(viewport); }
+void GameView::applyArea(URect) {
+    renderGraph.setViewport(viewport);
+    renderGraph.createRenderPass();
+}
 
 void GameView::reloadGame() {
     gameInterface.reload();

src/Engine/Window/View.cpp

@@ -15,7 +15,7 @@ View::~View() {}
 
 void View::resize(URect area) {
     createInfo.dimensions = area;
-    viewport = graphics->createViewport(owner->getGfxHandle(), createInfo);
+    viewport->resize(area.size.x, area.size.y);
     applyArea(area);
 }