Graphics refactor more or less tested and working

- Descriptors sets are now independent from a set index. Camera matrices for example can be bound to set index 1 for the batching system but index 2 for compute shaders.
- Truly global descriptors sets (misc data, textures and light data) are now manually bound to a global static class that allows retrieval of these sets to be bound whenever in the middle end. 
- Predefined descriptor set layouts (but not truly global such as camera data, materials and font) have their layouts predefined in a class and used for descriptor set initialization within the middle end. The sets themselves are allocated using these layouts (also accessible globally). 
- Descriptor sets that are more flexible with their bindings such as render graph resources are introspected from shaders and not predefined at all (though their types are recorded in SHGraphicsPredefinedData to avoid magic numbers when binding descriptor sets in some systems).
- Systems now have fixed mappings for descriptors used in shaders and these are defined in SHGraphicsPredefinedData. Batching for example has 3 fixed descriptors: Static global bound at 0, camera data bound at 1, materials bound at 2.
- Viewports no longer contain renderers and renderers no longer contain render graphs. The graphics system only has 1 render graph and subpasses can have both viewports and renderers bound to them to have options for viewport/scissor and camera settings. 
- Light data is now bound before every compute system.
- There is only 1 render graph in the entire system and contains only 6 nodes: G-Buffer pass (with lighting compute pass), debug draw with depth, debug draw, screen space pass, dummy pass for transition to input attachment for imGui and lastly the imGui pass for rendering editor to swapchain.

SHADE_Engine/src/Camera/SHCameraComponent.cpp

@@ -226,7 +226,7 @@ namespace SHADE
 
   const SHMatrix& SHCameraComponent::GetPerspectiveMatrix() const noexcept
   {
-    return orthoProjMatrix;
+    return perspProjMatrix;
   }
 
 	//void SHCameraComponent::SetMainCamera(size_t directorCameraIndex) noexcept

SHADE_Engine/src/Editor/EditorWindow/MaterialInspector/SHMaterialInspector.cpp

@@ -201,7 +201,7 @@ namespace SHADE
     // Get interface for the shader combination
     auto interface = fragShader->GetReflectedData().GetDescriptorBindingInfo().GetShaderBlockInterface
     (
-      mappings.at(SHGraphicsConstants::DescriptorSetTypes::MATERIALS),
+      mappings.at(SHPredefinedDescriptorTypes::MATERIALS),
       SHGraphicsConstants::DescriptorSetBindings::BATCHED_PER_INST_DATA
     );
     if (!interface)

SHADE_Engine/src/Graphics/MiddleEnd/Batching/SHBatch.cpp

@@ -416,7 +416,7 @@ namespace SHADE
       // - Material Properties Data
       const Handle<SHShaderBlockInterface> SHADER_INFO = pipeline->GetPipelineLayout()->GetShaderBlockInterface
       (
-        descMappings.at(SHGraphicsConstants::DescriptorSetTypes::MATERIALS),
+        descMappings.at(SHPredefinedDescriptorTypes::MATERIALS),
         SHGraphicsConstants::DescriptorSetBindings::BATCHED_PER_INST_DATA,
         vk::ShaderStageFlagBits::eFragment
       );
@@ -578,7 +578,7 @@ namespace SHADE
         matPropsDescSet[frameIndex],
         SH_PIPELINE_TYPE::GRAPHICS,
         //SHGraphicsConstants::DescriptorSetIndex::PER_INSTANCE,
-        descMappings.at(SHGraphicsConstants::DescriptorSetTypes::MATERIALS),
+        descMappings.at(SHPredefinedDescriptorTypes::MATERIALS),
         dynamicOffset
       );
     }
@@ -611,7 +611,7 @@ namespace SHADE
       {
         matPropsDescSet[frameIndex] = descPool->Allocate
         (
-          SHGraphicsPredefinedData::GetPredefinedDescSetLayouts(SHGraphicsConstants::PredefinedDescSetLayoutTypes::MATERIALS),
+          SHGraphicsPredefinedData::GetPredefinedDescSetLayouts(SHGraphicsPredefinedData::PredefinedDescSetLayoutTypes::MATERIALS),
           { 0 }
         );
 #ifdef _DEBUG

SHADE_Engine/src/Graphics/MiddleEnd/GlobalData/SHDescriptorMappings.cpp

@@ -3,7 +3,7 @@
 
 namespace SHADE
 {
-  void SHDescriptorMappings::AddMappings(std::initializer_list<std::pair<SHGraphicsConstants::DescriptorSetTypes, uint32_t>> inMappings) noexcept
+  void SHDescriptorMappings::AddMappings(std::initializer_list<std::pair<SHPredefinedDescriptorTypes, uint32_t>> inMappings) noexcept
   {
     for (auto& map : inMappings)
     	mappings.emplace(map);

SHADE_Engine/src/Graphics/MiddleEnd/GlobalData/SHDescriptorMappings.h

@@ -1,14 +1,14 @@
 #pragma once
 
 #include <unordered_map>
-#include "Graphics/MiddleEnd/Interface/SHGraphicsConstants.h"
+#include "Graphics/MiddleEnd/GlobalData/SHPredefinedDescriptorTypes.h"
 
 namespace SHADE
 {
   class SHDescriptorMappings
   {
   public:
-    using MapType = std::unordered_map<SHGraphicsConstants::DescriptorSetTypes, uint32_t>;
+    using MapType = std::unordered_map<SHPredefinedDescriptorTypes, uint32_t>;
 
   private:
     //! To map an enum value from descriptor set types to set indices
@@ -18,7 +18,7 @@ namespace SHADE
     /*-----------------------------------------------------------------------*/
     /* PUBLIC MEMBER FUNCTIONS                                               */
     /*-----------------------------------------------------------------------*/
-    void AddMappings (std::initializer_list<std::pair<SHGraphicsConstants::DescriptorSetTypes, uint32_t>> inMappings) noexcept;
+    void AddMappings (std::initializer_list<std::pair<SHPredefinedDescriptorTypes, uint32_t>> inMappings) noexcept;
 
     /*-----------------------------------------------------------------------*/
     /* SETTERS AND GETTERS                                                   */

SHADE_Engine/src/Graphics/MiddleEnd/GlobalData/SHGlobalDescriptorSets.cpp

@@ -12,7 +12,7 @@ namespace SHADE
   //void SHGlobalDescriptorSets::BindLightingData(Handle<SHVkCommandBuffer> cmdBuffer, SH_PIPELINE_TYPE pipelineType, uint32_t firstSet) noexcept
   //{
   //  // Bind descriptor set for light data
-  //  cmdBuffer->BindDescriptorSet(SHGlobalDescriptorSets::GetLightDescriptorSet(), SH_PIPELINE_TYPE::COMPUTE, descMappings[SHGraphicsConstants::PredefinedDescSetLayoutTypes::LIGHTS], const std::span{ TEX_DYNAMIC_OFFSET.data(), 1 });
+  //  cmdBuffer->BindDescriptorSet(SHGlobalDescriptorSets::GetLightDescriptorSet(), SH_PIPELINE_TYPE::COMPUTE, descMappings[SHGraphicsPredefinedData::PredefinedDescSetLayoutTypes::LIGHTS], const std::span{ TEX_DYNAMIC_OFFSET.data(), 1 });
   //}
 
   void SHGlobalDescriptorSets::BindLightingData(Handle<SHVkCommandBuffer> cmdBuffer, SH_PIPELINE_TYPE pipelineType, uint32_t setIndex, uint32_t frameIndex) noexcept

SHADE_Engine/src/Graphics/MiddleEnd/GlobalData/SHGraphicsPredefinedData.cpp

@@ -24,25 +24,25 @@ namespace SHADE
 
     perSystemData[SHUtilities::ConvertEnum(SystemType::BATCHING)].descMappings.AddMappings
     ({
-      {SHGraphicsConstants::DescriptorSetTypes::STATIC_DATA, 0},
+      {SHPredefinedDescriptorTypes::STATIC_DATA, 0},
-      {SHGraphicsConstants::DescriptorSetTypes::CAMERA,      1},
+      {SHPredefinedDescriptorTypes::CAMERA,      1},
-      {SHGraphicsConstants::DescriptorSetTypes::MATERIALS,   2},
+      {SHPredefinedDescriptorTypes::MATERIALS,   2},
     });
 
     perSystemData[SHUtilities::ConvertEnum(SystemType::TEXT_RENDERING)].descMappings.AddMappings
     ({
-      {SHGraphicsConstants::DescriptorSetTypes::STATIC_DATA, 0},
+      {SHPredefinedDescriptorTypes::STATIC_DATA, 0},
-      {SHGraphicsConstants::DescriptorSetTypes::CAMERA,      1},
+      {SHPredefinedDescriptorTypes::CAMERA,      1},
-      {SHGraphicsConstants::DescriptorSetTypes::FONT,        2},
+      {SHPredefinedDescriptorTypes::FONT,        2},
     });
 
     perSystemData[SHUtilities::ConvertEnum(SystemType::RENDER_GRAPH_NODE_COMPUTE)].descMappings.AddMappings
     ({
-      {SHGraphicsConstants::DescriptorSetTypes::STATIC_DATA,                        0},
+      {SHPredefinedDescriptorTypes::STATIC_DATA,                        0},
-      {SHGraphicsConstants::DescriptorSetTypes::LIGHTS,                             1},
+      {SHPredefinedDescriptorTypes::LIGHTS,                             1},
-      {SHGraphicsConstants::DescriptorSetTypes::CAMERA,                             2},
+      {SHPredefinedDescriptorTypes::CAMERA,                             2},
-      {SHGraphicsConstants::DescriptorSetTypes::RENDER_GRAPH_RESOURCE,              3},
+      {SHPredefinedDescriptorTypes::RENDER_GRAPH_RESOURCE,              3},
-      {SHGraphicsConstants::DescriptorSetTypes::RENDER_GRAPH_NODE_COMPUTE_RESOURCE, 4},
+      {SHPredefinedDescriptorTypes::RENDER_GRAPH_NODE_COMPUTE_RESOURCE, 4},
     });
   }
 
@@ -159,23 +159,23 @@ namespace SHADE
 
     perSystemData[SHUtilities::ConvertEnum(SystemType::BATCHING)].descSetLayouts = GetPredefinedDescSetLayouts
     (
-      SHGraphicsConstants::PredefinedDescSetLayoutTypes::STATIC_DATA |
+      SHGraphicsPredefinedData::PredefinedDescSetLayoutTypes::STATIC_DATA |
-      SHGraphicsConstants::PredefinedDescSetLayoutTypes::CAMERA |
+      SHGraphicsPredefinedData::PredefinedDescSetLayoutTypes::CAMERA |
-      SHGraphicsConstants::PredefinedDescSetLayoutTypes::MATERIALS
+      SHGraphicsPredefinedData::PredefinedDescSetLayoutTypes::MATERIALS
     );
 
     perSystemData[SHUtilities::ConvertEnum(SystemType::TEXT_RENDERING)].descSetLayouts = GetPredefinedDescSetLayouts
     (
-      SHGraphicsConstants::PredefinedDescSetLayoutTypes::STATIC_DATA |
+      SHGraphicsPredefinedData::PredefinedDescSetLayoutTypes::STATIC_DATA |
-      SHGraphicsConstants::PredefinedDescSetLayoutTypes::CAMERA | 
+      SHGraphicsPredefinedData::PredefinedDescSetLayoutTypes::CAMERA | 
-      SHGraphicsConstants::PredefinedDescSetLayoutTypes::FONT
+      SHGraphicsPredefinedData::PredefinedDescSetLayoutTypes::FONT
     );
 
     perSystemData[SHUtilities::ConvertEnum(SystemType::RENDER_GRAPH_NODE_COMPUTE)].descSetLayouts = GetPredefinedDescSetLayouts
     (
-      SHGraphicsConstants::PredefinedDescSetLayoutTypes::STATIC_DATA |
+      SHGraphicsPredefinedData::PredefinedDescSetLayoutTypes::STATIC_DATA |
-      SHGraphicsConstants::PredefinedDescSetLayoutTypes::CAMERA |
+      SHGraphicsPredefinedData::PredefinedDescSetLayoutTypes::CAMERA |
-      SHGraphicsConstants::PredefinedDescSetLayoutTypes::LIGHTS
+      SHGraphicsPredefinedData::PredefinedDescSetLayoutTypes::LIGHTS
     );
   }
 
@@ -198,10 +198,10 @@ namespace SHADE
     InitDummyPipelineLayouts (logicalDevice);
   }
 
-  std::vector<Handle<SHVkDescriptorSetLayout>> SHGraphicsPredefinedData::GetPredefinedDescSetLayouts(SHEnumWrapper<SHGraphicsConstants::PredefinedDescSetLayoutTypes> types) noexcept
+  std::vector<Handle<SHVkDescriptorSetLayout>> SHGraphicsPredefinedData::GetPredefinedDescSetLayouts(SHEnumWrapper<SHGraphicsPredefinedData::PredefinedDescSetLayoutTypes> types) noexcept
   {
     std::vector<Handle<SHVkDescriptorSetLayout>> layoutsFound;
-    for (uint8_t i = 0; i < SHGraphicsConstants::numPredefinedDescSetLayoutTypes; ++i)
+    for (uint8_t i = 0; i < numPredefinedDescSetLayoutTypes; ++i)
     {
     	if (types & (static_cast<uint64_t>(1) << i))
         layoutsFound.push_back(predefinedLayouts[i]);

SHADE_Engine/src/Graphics/MiddleEnd/GlobalData/SHGraphicsPredefinedData.h

@@ -18,6 +18,18 @@ namespace SHADE
   class SH_API SHGraphicsPredefinedData
   {
   public:
+    static constexpr uint8_t numPredefinedDescSetLayoutTypes = 64;
+
+    // This enum is mainly to initialize a bit field to retrieve bit fields from SHPRedefinedData
+    enum class PredefinedDescSetLayoutTypes : uint64_t
+    {
+      STATIC_DATA = 0x01,
+      LIGHTS = 0x02,
+      CAMERA = 0x04,
+      MATERIALS = 0x08,
+      FONT = 0x10,
+    };
+
     enum class SystemType
     {
       BATCHING = 0,
@@ -76,7 +88,7 @@ namespace SHADE
     /*-----------------------------------------------------------------------*/
     /* SETTERS AND GETTERS                                                   */
     /*-----------------------------------------------------------------------*/
-    static std::vector<Handle<SHVkDescriptorSetLayout>>         GetPredefinedDescSetLayouts (SHEnumWrapper<SHGraphicsConstants::PredefinedDescSetLayoutTypes> types) noexcept;
+    static std::vector<Handle<SHVkDescriptorSetLayout>>         GetPredefinedDescSetLayouts (SHEnumWrapper<SHGraphicsPredefinedData::PredefinedDescSetLayoutTypes> types) noexcept;
     static SHVertexInputState const&                            GetDefaultViState (void) noexcept;
     static PerSystem const&                                     GetSystemData (SystemType systemType) noexcept;
     static SHDescriptorMappings::MapType const&                 GetMappings (SystemType systemType) noexcept;

SHADE_Engine/src/Graphics/MiddleEnd/GlobalData/SHPredefinedDescriptorTypes.h

@@ -0,0 +1,19 @@
+#pragma once
+
+namespace SHADE
+{
+  // This enum is different from PredefinedDescSetLayoutTypes in that it is used to initialize a hash table to
+  // with the values here as keys and set indices as values. It is worth noting that some values here
+  // are not in the above table. This is because those values don't have predefined descriptor set layouts.
+  // Their layouts and set indices are instead created through introspection in the pipeline layout.
+  enum class SHPredefinedDescriptorTypes
+  {
+    STATIC_DATA,
+    LIGHTS,
+    CAMERA,
+    MATERIALS,
+    FONT,
+    RENDER_GRAPH_RESOURCE,
+    RENDER_GRAPH_NODE_COMPUTE_RESOURCE,
+  };
+}

SHADE_Engine/src/Graphics/MiddleEnd/Interface/SHGraphicsConstants.h

@@ -25,33 +25,6 @@ namespace SHADE
   struct SHGraphicsConstants
   {
   public:
-    static constexpr uint8_t numPredefinedDescSetLayoutTypes = 64;
-
-    // This enum is mainly to initialize a bit field to retrieve bit fields from SHPRedefinedData
-    enum class PredefinedDescSetLayoutTypes : uint64_t
-    {
-      STATIC_DATA = 0x01,
-      LIGHTS = 0x02,
-      CAMERA = 0x04,
-      MATERIALS = 0x08,
-      FONT = 0x10,
-    };
-
-    // This enum is different from the one above in that it is used to initialize a hash table to
-    // with the values here as keys and set indices as values. It is worth noting that some values here
-    // are not in the above table. This is because those values don't have predefined descriptor set layouts.
-    // Their layouts and set indices are instead created through introspection in the pipeline layout.
-    enum class DescriptorSetTypes
-    {
-      STATIC_DATA,
-      LIGHTS,
-      CAMERA,
-      MATERIALS,
-      FONT,
-      RENDER_GRAPH_RESOURCE,
-      RENDER_GRAPH_NODE_COMPUTE_RESOURCE,
-    };
-
     struct RenderGraphIndices
     {
       static constexpr uint32_t WORLD  = 0;

SHADE_Engine/src/Graphics/MiddleEnd/Interface/SHGraphicsSystem.cpp

@@ -19,7 +19,6 @@ of DigiPen Institute of Technology is prohibited.
 #include "Camera/SHCameraSystem.h"
 #include "Editor/SHEditor.h"
 #include "ECS_Base/Managers/SHSystemManager.h"
-//#include "SHRenderer.h"
 #include "Graphics/Windowing/SHWindow.h"
 #include "Graphics/MiddleEnd/PerFrame/SHPerFrameData.h"
 #include "Graphics/MiddleEnd/Interface/SHViewport.h"
@@ -125,25 +124,6 @@ namespace SHADE
 
     SHFreetypeInstance::Init();
 
-    SHAssetManager::CompileAsset("../../Assets/Shaders/DebugDraw_VS.glsl", false);
-    SHAssetManager::CompileAsset("../../Assets/Shaders/DebugDraw_FS.glsl", false);
-    SHAssetManager::CompileAsset("../../Assets/Shaders/DebugDrawMesh_VS.glsl", false);
-    SHAssetManager::CompileAsset("../../Assets/Shaders/DeferredComposite_CS.glsl", false);
-    SHAssetManager::CompileAsset("../../Assets/Shaders/Normals_FS.glsl", false);
-    SHAssetManager::CompileAsset("../../Assets/Shaders/PureCopy_CS.glsl", false);
-    SHAssetManager::CompileAsset("../../Assets/Shaders/SSAO_CS.glsl", false);
-    SHAssetManager::CompileAsset("../../Assets/Shaders/SSAOBlur_CS.glsl", false);
-    SHAssetManager::CompileAsset("../../Assets/Shaders/TestCube_FS.glsl", false);
-    SHAssetManager::CompileAsset("../../Assets/Shaders/TestCube_Tile_FS.glsl", false);
-    SHAssetManager::CompileAsset("../../Assets/Shaders/TestCube_Tile_VS.glsl", false);
-    SHAssetManager::CompileAsset("../../Assets/Shaders/TestCube_VS.glsl", false);
-    SHAssetManager::CompileAsset("../../Assets/Shaders/Text_FS.glsl", false);
-    SHAssetManager::CompileAsset("../../Assets/Shaders/Text_VS.glsl", false);
-    SHAssetManager::CompileAsset("../../Assets/Shaders/ToSwapchain_FS.glsl", false);
-    SHAssetManager::CompileAsset("../../Assets/Shaders/ToSwapchain_VS.glsl", false);
-    SHAssetManager::CompileAsset("../../Assets/Shaders/UI_FS.glsl", false);
-    SHAssetManager::CompileAsset("../../Assets/Shaders/UI_VS.glsl", false);
-
     // Load Built In Shaders
     static constexpr AssetID VS_DEFAULT    = 39210065;  defaultVertShader       = SHResourceManager::LoadOrGet<SHVkShaderModule>(VS_DEFAULT);
     static constexpr AssetID FS_DEFAULT    = 46377769;  defaultFragShader       = SHResourceManager::LoadOrGet<SHVkShaderModule>(FS_DEFAULT);
@@ -173,16 +153,6 @@ namespace SHADE
     auto windowDims = window->GetWindowSize();
 
     auto cameraSystem = SHSystemManager::GetSystem<SHCameraSystem>();
-
-    // Set Up Cameras
-    //screenCamera = resourceManager.Create<SHCamera>();
-    //screenCamera->SetLookAt(SHVec3(0.0f, 0.0f, -1.0f), SHVec3(0.0f, 0.0f, 1.0f), SHVec3(0.0f, 1.0f, 0.0f));
-    //screenCamera->SetOrthographic(static_cast<float>(windowDims.first), static_cast<float>(windowDims.second), 0.01f, 100.0f);
-
-    //worldCamera = resourceManager.Create<SHCamera>();
-    //worldCamera->SetLookAt(SHVec3(0.0f, 0.0f, 0.0f), SHVec3(0.0f, 0.0f, -2.0f), SHVec3(0.0f, 1.0f, 0.0f));
-    //worldCamera->SetPerspective(90.0f, static_cast<float>(windowDims.first), static_cast<float>(windowDims.second), 0.0f, 100.0f);
-
     worldCameraDirector = cameraSystem->CreateDirector();
 
     /*-----------------------------------------------------------------------*/
@@ -343,42 +313,6 @@ namespace SHADE
     // Generate render graph
     renderGraph->Generate();
 
-#if 0
-    /*-----------------------------------------------------------------------*/
-    /* SCREEN RENDER GRAPH                                                   */
-    /*-----------------------------------------------------------------------*/
-    // Initialize screen render graph
-    screenRenderGraph = resourceManager.Create<SHRenderGraph>();
-    screenRenderGraph->Init("Screen Render Graph", device, swapchain, &resourceManager);
-    screenRenderGraph->LinkNonOwningResource(worldRenderGraph, "Scene");
-    screenRenderGraph->LinkNonOwningResource(worldRenderGraph, "Entity ID");
-    screenRenderGraph->AddResource("Present", { SH_RENDER_GRAPH_RESOURCE_FLAGS::COLOR_PRESENT }, windowDims.first, windowDims.second);
-
-    auto screenSpaceNode = screenRenderGraph->AddNode("Screen Space Pass", { "Scene", "Entity ID"}, {});
-    auto uiSubpass = screenSpaceNode->AddSubpass("UI");
-    uiSubpass->AddColorOutput("Scene");
-    uiSubpass->AddColorOutput("Entity ID");
-    uiSubpass->AddExteriorDrawCalls([=](Handle<SHVkCommandBuffer>& cmdBuffer, uint32_t frameIndex)
-      {
-        textRenderingSubSystem->Render(cmdBuffer, frameIndex);
-      });
-
-#ifdef SHEDITOR
-    {
-      // Dummy Node to transition scene render graph resource
-      auto dummyNode = screenRenderGraph->AddNode("Dummy Pass", { "Scene" }, { "Screen Space Pass" }); // no predecessors
-      auto dummySubpass = dummyNode->AddSubpass("Dummy Subpass");
-      dummySubpass->AddInput("Scene");
-    }
-
-#else
-    screenRenderGraph->AddRenderToSwapchainNode("Scene", "Present", {"Screen Space Pass"}, {renderToSwapchainVS, renderToSwapchainFS});
-#endif
-
-    screenRenderGraph->Generate();
-
-#endif
-
     // Create debug draw pipeline
     debugDrawPipeline = createDebugDrawPipeline(debugDrawNode->GetRenderpass(), debugDrawSubpass, false, false, false);
     SET_VK_OBJ_NAME(device, vk::ObjectType::ePipeline, debugDrawPipeline->GetVkPipeline(), "[Pipeline] Debug Draw");
@@ -412,11 +346,6 @@ namespace SHADE
 
     InitRenderGraph();
 
-#if 0
-  #ifdef SHEDITOR
-      InitEditorRenderGraph();
-  #endif
-#endif
 
     // Create Semaphore
     for (auto& semaHandle : graphSemaphores)
@@ -480,38 +409,6 @@ namespace SHADE
     defaultMaterial->SetProperty("data.textureIndex", defaultTexture->TextureArrayIndex);
   }
 
-#if 0
-  #ifdef SHEDITOR
-    void SHGraphicsSystem::InitEditorRenderGraph(void) noexcept
-    {
-      auto windowDims = window->GetWindowSize();
-
-      // Create Default Viewport
-      editorViewport = AddViewport(vk::Viewport(0.0f, 0.0f, static_cast<float>(windowDims.first), static_cast<float>(windowDims.second), 0.0f, 1.0f));
-
-      // Get render graph from viewport editor renderer
-      editorRenderGraph = resourceManager.Create<SHRenderGraph>();
-
-      std::vector<Handle<SHVkCommandPool>> renderContextCmdPools{ swapchain->GetNumImages() };
-      for (uint32_t i = 0; i < renderContextCmdPools.size(); ++i)
-        renderContextCmdPools[i] = renderContext.GetFrameData(i).cmdPoolHdls[0];
-
-      editorRenderGraph->Init("Editor Render Graph", device, swapchain, &resourceManager);
-      editorRenderGraph->AddResource("Present", { SH_RENDER_GRAPH_RESOURCE_FLAGS::COLOR_PRESENT }, windowDims.first, windowDims.second);
-
-
-      auto imguiNode = editorRenderGraph->AddNode("ImGui Node", { "Present"}, {});
-      auto imguiSubpass = imguiNode->AddSubpass("ImGui Draw");
-      imguiSubpass->AddColorOutput("Present");
-
-      // Generate world render graph
-      editorRenderGraph->Generate();
-
-      // Add world renderer to default viewport
-      editorRenderer = AddRenderer(SHRenderer::PROJECTION_TYPE::PERSPECTIVE);
-    }
-  #endif
-#endif
 
   /*---------------------------------------------------------------------------------*/
   /* Constructor/Destructors                                                         */
@@ -632,99 +529,15 @@ namespace SHADE
     renderGraph->Execute(frameIndex, descPool);
     renderGraph->End(frameIndex);
 
-#if 0
+    graphicsQueue->SubmitCommandBuffer
-    // For every viewport 
+    (
-    for (int vpIndex = 0; vpIndex < static_cast<int>(viewports.size()); ++vpIndex)
+      { renderGraph->GetCommandBuffer(frameIndex) },
-    {
+      { frameData.semRenderFinishHdl },
-      auto& renderers = viewports[vpIndex]->GetRenderers();
+      { frameData.semImgAvailableHdl },
+      { vk::PipelineStageFlagBits::eColorAttachmentOutput },
+      { frameData.fenceHdl }
+    );
 
-      // For every renderer
-      for (int renIndex = 0; renIndex < static_cast<int>(renderers.size()); ++renIndex)
-      {
-        /*-----------------------------------------------------------------------*/
-        /* Renderer start                                                        */
-        /*-----------------------------------------------------------------------*/
-        // get command buffer of the renderer in the current frame 
-        auto currentCmdBuffer = renderers[renIndex]->GetCommandBuffer(frameIndex);
-
-        // Begin recording the command buffer
-        currentCmdBuffer->BeginRecording();
-
-        //// set viewport and scissor
-        //uint32_t w = static_cast<uint32_t>(viewports[vpIndex]->GetWidth());
-        //uint32_t h = static_cast<uint32_t>(viewports[vpIndex]->GetHeight());
-        //currentCmdBuffer->SetViewportScissor (static_cast<float>(w), static_cast<float>(h), w, h);
-
-        // Force set the pipeline layout 
-        currentCmdBuffer->ForceSetPipelineLayout(SHPredefinedData::GetDummyPipelineLayout(), SH_PIPELINE_TYPE::GRAPHICS);
-        currentCmdBuffer->ForceSetPipelineLayout(SHPredefinedData::GetDummyPipelineLayout(), SH_PIPELINE_TYPE::COMPUTE);
-
-        // Bind all the buffers required for meshes
-        for (auto& [buffer, bindingPoint] : MESH_DATA)
-        {
-          if (buffer->GetUsageBits() & vk::BufferUsageFlagBits::eVertexBuffer)
-            currentCmdBuffer->BindVertexBuffer(bindingPoint, buffer, 0);
-          else if (buffer->GetUsageBits() & vk::BufferUsageFlagBits::eIndexBuffer)
-            currentCmdBuffer->BindIndexBuffer(buffer, 0);
-        }
-
-        lightingSubSystem->BindDescSet(currentCmdBuffer, frameIndex);
-
-        // Bind textures
-        auto textureDescSet = texLibrary.GetTextureDescriptorSetGroup();
-        if (textureDescSet)
-        {
-          std::array<uint32_t, 1> texDynamicOffset {0};
-          currentCmdBuffer->BindDescriptorSet
-          (
-            textureDescSet,
-            SH_PIPELINE_TYPE::GRAPHICS,
-            0,
-            texDynamicOffset
-          );
-        }
-
-        // bind camera data
-        //renderers[renIndex]->UpdateDataAndBind(currentCmdBuffer, frameIndex);
-
-//#ifdef SHEDITOR
-//        if (renderers[renIndex] == worldRenderer)
-//        {
-//          auto editorSystem = SHSystemManager::GetSystem<SHEditor>();
-//          if (editorSystem->editorState != SHEditor::State::PLAY)
-//            worldRenderer->UpdateDataManual(currentCmdBuffer, frameIndex, cameraSystem->GetEditorCamera()->GetViewMatrix(), cameraSystem->GetEditorCamera()->GetProjMatrix(), cameraSystem->GetEditorCamera()->GetOrthoMatrix());
-//          else
-//            renderers[renIndex]->UpdateDataAndBind(currentCmdBuffer, frameIndex);
-//        }
-//        else
-//          renderers[renIndex]->UpdateDataAndBind(currentCmdBuffer, frameIndex);
-//#else
-//        renderers[renIndex]->UpdateDataAndBind(currentCmdBuffer, frameIndex);
-//#endif
-
-        // Draw the scene
-        renderers[renIndex]->Draw(frameIndex, descPool);
-
-        // End the command buffer recording
-        currentCmdBuffer->EndRecording();
-        /*-----------------------------------------------------------------------*/
-        /* Renderer end                                                          */
-        /*-----------------------------------------------------------------------*/
-
-        // submit a command buffer from the current render graph and make it wait for the previous render graph before submitting it to GPU. 
-        graphicsQueue->SubmitCommandBuffer
-        (
-          { currentCmdBuffer },
-          { (vpIndex == viewports.size() - 1 && renIndex == renderers.size() - 1) ? frameData.semRenderFinishHdl : graphSemaphores[!semIndex] },
-          { (vpIndex == 0 && renIndex == 0) ? frameData.semImgAvailableHdl : graphSemaphores[semIndex] },
-          { vk::PipelineStageFlagBits::eColorAttachmentOutput },
-          { (vpIndex == viewports.size() - 1 && renIndex == renderers.size() - 1) ? frameData.fenceHdl : Handle<SHVkFence>{} }
-        );
-
-        semIndex = !semIndex;
-      }
-    }
-#endif 
   }
   
 
@@ -1023,7 +836,7 @@ namespace SHADE
 
   void SHGraphicsSystem::BuildFonts(void) noexcept
   {
-    fontLibrary.BuildFonts(device, graphicsQueue, graphicsCmdPool, descPool, SHGraphicsPredefinedData::GetPredefinedDescSetLayouts(SHGraphicsConstants::PredefinedDescSetLayoutTypes::FONT)[0], resourceManager);
+    fontLibrary.BuildFonts(device, graphicsQueue, graphicsCmdPool, descPool, SHGraphicsPredefinedData::GetPredefinedDescSetLayouts(SHGraphicsPredefinedData::PredefinedDescSetLayoutTypes::FONT)[0], resourceManager);
   }
 
 #pragma endregion ADD_REMOVE
@@ -1181,26 +994,18 @@ namespace SHADE
     renderGraph->HandleResize(resizeWidth, resizeHeight);
 
 #ifdef SHEDITOR
-
     // NOTE: These 2 lines are actually not necessary because the editor viewport is not even used for 
     // setting dynamic viewport or scissor state. ImGUI takes care of that for us.
     //editorViewport->SetWidth(windowDims.first);
     //editorViewport->SetHeight(windowDims.second);
-
-    //editorRenderGraph->HandleResize(windowDims.first, windowDims.second);
 #endif
 
-    //screenRenderGraph->HandleResize(resizeWidth, resizeHeight);
-
     mousePickSubSystem->HandleResize();
     postOffscreenRenderSubSystem->HandleResize();
 
     worldViewport->SetWidth(static_cast<float>(resizeWidth));
     worldViewport->SetHeight(static_cast<float>(resizeHeight));
 
-    //worldCamera->SetPerspective(90.0f, static_cast<float>(resizeWidth), static_cast<float>(resizeHeight), 0.0f, 100.0f);
-    //screenCamera->SetOrthographic(static_cast<float>(resizeWidth), static_cast<float>(resizeHeight), 0.01f, 100.0f);
-
     auto cameraSystem = SHSystemManager::GetSystem<SHCameraSystem>();
 #ifdef SHEDITOR
     cameraSystem->GetEditorCamera()->SetWidth(static_cast<float>(resizeWidth));

SHADE_Engine/src/Graphics/MiddleEnd/Interface/SHGraphicsSystem.h

@@ -51,7 +51,6 @@ namespace SHADE
   class SHVkFramebuffer;
   class SHVkCommandBuffer;
   class SHViewport;
-  class SHCamera;
   class SHVkShaderModule;
   class SHMaterial;
   class SHMaterialInstance;

SHADE_Engine/src/Graphics/MiddleEnd/Interface/SHMaterial.cpp

@@ -100,7 +100,7 @@ namespace SHADE
     auto const& mappings = SHGraphicsPredefinedData::GetMappings(SHGraphicsPredefinedData::SystemType::BATCHING);
     return pipeline->GetPipelineLayout()->GetShaderBlockInterface
     (
-      mappings.at (SHGraphicsConstants::DescriptorSetTypes::MATERIALS),
+      mappings.at (SHPredefinedDescriptorTypes::MATERIALS),
       //SHGraphicsConstants::DescriptorSetIndex::PER_INSTANCE,
       SHGraphicsConstants::DescriptorSetBindings::BATCHED_PER_INST_DATA,
       vk::ShaderStageFlagBits::eFragment

SHADE_Engine/src/Graphics/MiddleEnd/Interface/SHMaterialInstance.cpp

@@ -81,7 +81,7 @@ namespace SHADE
   {
     return baseMaterial->GetPipeline()->GetPipelineLayout()->GetShaderBlockInterface
     (
-      SHGraphicsPredefinedData::GetMappings(SHGraphicsPredefinedData::SystemType::BATCHING).at(SHGraphicsConstants::DescriptorSetTypes::MATERIALS),
+      SHGraphicsPredefinedData::GetMappings(SHGraphicsPredefinedData::SystemType::BATCHING).at(SHPredefinedDescriptorTypes::MATERIALS),
       //SHGraphicsConstants::DescriptorSetIndex::PER_INSTANCE,
       SHGraphicsConstants::DescriptorSetBindings::BATCHED_PER_INST_DATA,
       vk::ShaderStageFlagBits::eFragment

SHADE_Engine/src/Graphics/MiddleEnd/Interface/SHRenderer.cpp

@@ -36,7 +36,7 @@ namespace SHADE
     //for (uint32_t i = 0; i < commandBuffers.size(); ++i)
     //  commandBuffers[i] = cmdPools[i]->RequestCommandBuffer(SH_CMD_BUFFER_TYPE::PRIMARY);
 
-    cameraDescriptorSet = descriptorPool->Allocate(SHGraphicsPredefinedData::GetPredefinedDescSetLayouts(SHGraphicsConstants::PredefinedDescSetLayoutTypes::CAMERA), { 1 });
+    cameraDescriptorSet = descriptorPool->Allocate(SHGraphicsPredefinedData::GetPredefinedDescSetLayouts(SHGraphicsPredefinedData::PredefinedDescSetLayoutTypes::CAMERA), { 1 });
 
 #ifdef _DEBUG
     const auto& CAM_DESC_SETS = cameraDescriptorSet->GetVkHandle();

SHADE_Engine/src/Graphics/MiddleEnd/Lights/SHLightingSubSystem.cpp

@@ -386,7 +386,7 @@ namespace SHADE
     std::fill (variableSizes.begin(), variableSizes.end(), 1);
 
     // Create the descriptor set
-    lightingDataDescSet = descPool->Allocate({ SHGraphicsPredefinedData::GetPredefinedDescSetLayouts(SHGraphicsConstants::PredefinedDescSetLayoutTypes::LIGHTS) }, variableSizes);
+    lightingDataDescSet = descPool->Allocate({ SHGraphicsPredefinedData::GetPredefinedDescSetLayouts(SHGraphicsPredefinedData::PredefinedDescSetLayoutTypes::LIGHTS) }, variableSizes);
 #ifdef _DEBUG
     const auto& CAM_DESC_SETS = lightingDataDescSet->GetVkHandle();
     for (int i = 0; i < static_cast<int>(CAM_DESC_SETS.size()); ++i)

SHADE_Engine/src/Graphics/MiddleEnd/TextRendering/SHTextRenderingSubSystem.cpp

@@ -178,9 +178,9 @@ namespace SHADE
   {
     auto& textRendererComps = SHComponentManager::GetDense<SHTextRenderableComponent>();
     auto const& mappings = SHGraphicsPredefinedData::GetMappings(SHGraphicsPredefinedData::SystemType::TEXT_RENDERING);
-    uint32_t fontSetIndex = mappings.at(SHGraphicsConstants::DescriptorSetTypes::FONT);
+    uint32_t fontSetIndex = mappings.at(SHPredefinedDescriptorTypes::FONT);
-    uint32_t staticGlobalSetIndex = mappings.at(SHGraphicsConstants::DescriptorSetTypes::STATIC_DATA);
+    uint32_t staticGlobalSetIndex = mappings.at(SHPredefinedDescriptorTypes::STATIC_DATA);
-    uint32_t cameraSetIndex = mappings.at(SHGraphicsConstants::DescriptorSetTypes::CAMERA);
+    uint32_t cameraSetIndex = mappings.at(SHPredefinedDescriptorTypes::CAMERA);
 
     for (auto& comp : textRendererComps)
     {

SHADE_Engine/src/Graphics/MiddleEnd/Textures/SHTextureLibrary.cpp

@@ -168,7 +168,7 @@ namespace SHADE
             }
             texDescriptors = descPool->Allocate
             (
-                { SHGraphicsPredefinedData::GetPredefinedDescSetLayouts(SHGraphicsConstants::PredefinedDescSetLayoutTypes::STATIC_DATA) }, 
+                { SHGraphicsPredefinedData::GetPredefinedDescSetLayouts(SHGraphicsPredefinedData::PredefinedDescSetLayoutTypes::STATIC_DATA) }, 
                 { static_cast<uint32_t>(texOrder.size()) }
             );
 #ifdef _DEBUG

SHADE_Engine/src/Graphics/RenderGraph/SHRenderGraph.cpp

@@ -646,7 +646,7 @@ namespace SHADE
     for (auto& node : nodes)
     {
       // bind static global data 
-      SHGlobalDescriptorSets::BindStaticGlobalData(cmdBuffer, SH_PIPELINE_TYPE::GRAPHICS, descMappings.at(SHGraphicsConstants::DescriptorSetTypes::STATIC_DATA));
+      SHGlobalDescriptorSets::BindStaticGlobalData(cmdBuffer, SH_PIPELINE_TYPE::GRAPHICS, descMappings.at(SHPredefinedDescriptorTypes::STATIC_DATA));
 
       node->Execute(cmdBuffer, descPool, frameIndex);
     }

SHADE_Engine/src/Graphics/RenderGraph/SHRenderGraphNode.cpp

@@ -359,10 +359,10 @@ namespace SHADE
       commandBuffer->ForceSetPipelineLayout(SHGraphicsPredefinedData::GetSystemData(SHGraphicsPredefinedData::SystemType::RENDER_GRAPH_NODE_COMPUTE).dummyPipelineLayout, SH_PIPELINE_TYPE::COMPUTE);
 
       // bind static global data 
-      SHGlobalDescriptorSets::BindStaticGlobalData(commandBuffer, SH_PIPELINE_TYPE::COMPUTE, descMappings.at(SHGraphicsConstants::DescriptorSetTypes::STATIC_DATA));
+      SHGlobalDescriptorSets::BindStaticGlobalData(commandBuffer, SH_PIPELINE_TYPE::COMPUTE, descMappings.at(SHPredefinedDescriptorTypes::STATIC_DATA));
 
       // bind lighting data
-      SHGlobalDescriptorSets::BindLightingData(commandBuffer, SH_PIPELINE_TYPE::COMPUTE, descMappings.at(SHGraphicsConstants::DescriptorSetTypes::LIGHTS), frameIndex);
+      SHGlobalDescriptorSets::BindLightingData(commandBuffer, SH_PIPELINE_TYPE::COMPUTE, descMappings.at(SHPredefinedDescriptorTypes::LIGHTS), frameIndex);
     }
 
     // Execute all subpass computes

SHADE_Engine/src/Graphics/RenderGraph/SHRenderGraphNodeCompute.cpp

@@ -53,7 +53,7 @@ namespace SHADE
 
     //Get the descriptor set layouts required to allocate. We only want the ones for allocate because 
     //global descriptors are already bound in the main system. 
-    auto const& graphResourceLayout = layouts[descMappings.at(SHGraphicsConstants::DescriptorSetTypes::RENDER_GRAPH_RESOURCE)];
+    auto const& graphResourceLayout = layouts[descMappings.at(SHPredefinedDescriptorTypes::RENDER_GRAPH_RESOURCE)];
 
     // Allocate descriptor sets to hold the images for reading (STORAGE_IMAGE)
     for (uint32_t i = 0; i < SHGraphicsConstants::NUM_FRAME_BUFFERS; ++i)
@@ -66,11 +66,11 @@ namespace SHADE
     }
 
     // check if all layouts are there
-    if (layouts.size() == descMappings.at(SHGraphicsConstants::DescriptorSetTypes::RENDER_GRAPH_NODE_COMPUTE_RESOURCE) + 1)
+    if (layouts.size() == descMappings.at(SHPredefinedDescriptorTypes::RENDER_GRAPH_NODE_COMPUTE_RESOURCE) + 1)
     {
       // create compute resources
       computeResource = graphStorage->resourceHub->Create<ComputeResource>();
-      auto computeResourceLayout = layouts[descMappings.at(SHGraphicsConstants::DescriptorSetTypes::RENDER_GRAPH_NODE_COMPUTE_RESOURCE)];
+      auto computeResourceLayout = layouts[descMappings.at(SHPredefinedDescriptorTypes::RENDER_GRAPH_NODE_COMPUTE_RESOURCE)];
       computeResource->descSet = graphStorage->descriptorPool->Allocate({ computeResourceLayout }, { 1 });
 #ifdef _DEBUG
       for (auto set : computeResource->descSet->GetVkHandle())
@@ -98,17 +98,17 @@ namespace SHADE
 
 
     // bind render graph resource
-    cmdBuffer->BindDescriptorSet(graphResourceDescSets[frameIndex], SH_PIPELINE_TYPE::COMPUTE, descMappings.at(SHGraphicsConstants::DescriptorSetTypes::RENDER_GRAPH_RESOURCE), {});
+    cmdBuffer->BindDescriptorSet(graphResourceDescSets[frameIndex], SH_PIPELINE_TYPE::COMPUTE, descMappings.at(SHPredefinedDescriptorTypes::RENDER_GRAPH_RESOURCE), {});
 
     // bind compute resource
     if (computeResource)
     {
-      cmdBuffer->BindDescriptorSet(computeResource->descSet, SH_PIPELINE_TYPE::COMPUTE, descMappings.at(SHGraphicsConstants::DescriptorSetTypes::RENDER_GRAPH_NODE_COMPUTE_RESOURCE), computeResource->dynamicOffsets[frameIndex]);
+      cmdBuffer->BindDescriptorSet(computeResource->descSet, SH_PIPELINE_TYPE::COMPUTE, descMappings.at(SHPredefinedDescriptorTypes::RENDER_GRAPH_NODE_COMPUTE_RESOURCE), computeResource->dynamicOffsets[frameIndex]);
     }
 
     // bind camera data
     if (renderer)
-      renderer->BindDescriptorSet (cmdBuffer, SH_PIPELINE_TYPE::COMPUTE, descMappings.at(SHGraphicsConstants::DescriptorSetTypes::CAMERA), frameIndex);
+      renderer->BindDescriptorSet (cmdBuffer, SH_PIPELINE_TYPE::COMPUTE, descMappings.at(SHPredefinedDescriptorTypes::CAMERA), frameIndex);
 
     // dispatch compute
     cmdBuffer->ComputeDispatch(groupSizeX, groupSizeY, 1);
@@ -121,7 +121,7 @@ namespace SHADE
   void SHRenderGraphNodeCompute::HandleResize(void) noexcept
   {
     // We need to get from mappings because we want the introspected layout from the vector of layouts (of which the first few are predefined)
-    uint32_t RENDER_GRAPH_RESOURCE_SET_INDEX = SHGraphicsPredefinedData::GetMappings(SHGraphicsPredefinedData::SystemType::RENDER_GRAPH_NODE_COMPUTE).at (SHGraphicsConstants::DescriptorSetTypes::RENDER_GRAPH_RESOURCE);
+    uint32_t RENDER_GRAPH_RESOURCE_SET_INDEX = SHGraphicsPredefinedData::GetMappings(SHGraphicsPredefinedData::SystemType::RENDER_GRAPH_NODE_COMPUTE).at (SHPredefinedDescriptorTypes::RENDER_GRAPH_RESOURCE);
 
     // Since the descriptor set is standalone, the index we want to use is not the one in the shaders, it should always be 0.
     uint32_t RENDER_GRAPH_RESOURCE_UPDATE_SET_INDEX = 0;

SHADE_Engine/src/Graphics/RenderGraph/SHRenderGraphResource.cpp

@@ -262,11 +262,13 @@ namespace SHADE
 
   void SHRenderGraphResource::HandleResize(uint32_t newWidth, uint32_t newHeight) noexcept
   {
-    width = newWidth;
-    height = newHeight;
 
     if ((resourceTypeFlags & static_cast<uint32_t>(SH_RENDER_GRAPH_RESOURCE_FLAGS::COLOR_PRESENT)) == 0)
     {
+      width = newWidth;
+      height = newHeight;
+
+
       // prepare image view details
       SHImageViewDetails viewDetails
       {
@@ -287,6 +289,9 @@ namespace SHADE
     }
     else
     {
+      width = graphStorage->swapchain->GetWidth();
+      height = graphStorage->swapchain->GetHeight();
+
       // Prepare image view details
       SHImageViewDetails viewDetails
       {

SHADE_Engine/src/Graphics/RenderGraph/SHSubpass.cpp

@@ -227,7 +227,7 @@ namespace SHADE
     auto const& descMappings = SHGraphicsPredefinedData::GetMappings(SHGraphicsPredefinedData::SystemType::BATCHING);
 
     if (renderer)
-      renderer->BindDescriptorSet(commandBuffer, SH_PIPELINE_TYPE::GRAPHICS, descMappings.at(SHGraphicsConstants::DescriptorSetTypes::CAMERA), frameIndex);
+      renderer->BindDescriptorSet(commandBuffer, SH_PIPELINE_TYPE::GRAPHICS, descMappings.at(SHPredefinedDescriptorTypes::CAMERA), frameIndex);
 
     // Draw all the batches
     superBatch->Draw(commandBuffer, frameIndex);

SHADE_Engine/src/Graphics/Swapchain/SHVkSwapchain.cpp

@@ -347,4 +347,14 @@ namespace SHADE
     return vkDepthFormat;
   }
 
+  uint32_t SHVkSwapchain::GetWidth(void) const noexcept
+  {
+    return width;
+  }
+
+  uint32_t SHVkSwapchain::GetHeight(void) const noexcept
+  {
+    return height;
+  }
+
 }

SHADE_Engine/src/Graphics/Swapchain/SHVkSwapchain.h

@@ -101,6 +101,8 @@ namespace SHADE
     vk::SwapchainKHR const&    GetVkSwapchain      (void) const noexcept;
     vk::SurfaceFormatKHR       GetSurfaceFormatKHR (void) const noexcept;
     vk::Format                 GetDepthFormat      (void) const noexcept;
+    uint32_t                   GetWidth            (void) const noexcept;
+    uint32_t                   GetHeight           (void) const noexcept;
   };
 }
 

SHADE_Engine/src/Serialization/SHSerializationHelper.hpp

@@ -266,7 +266,7 @@ namespace SHADE
           {
             auto fragShader =  SHResourceManager::LoadOrGet<SHVkShaderModule>(spec.fragShader);
             auto const& mappings = SHGraphicsPredefinedData::GetMappings(SHGraphicsPredefinedData::SystemType::BATCHING);
-            auto interface = fragShader->GetReflectedData().GetDescriptorBindingInfo().GetShaderBlockInterface(mappings.at(SHGraphicsConstants::DescriptorSetTypes::MATERIALS), SHGraphicsConstants::DescriptorSetBindings::BATCHED_PER_INST_DATA);
+            auto interface = fragShader->GetReflectedData().GetDescriptorBindingInfo().GetShaderBlockInterface(mappings.at(SHPredefinedDescriptorTypes::MATERIALS), SHGraphicsConstants::DescriptorSetBindings::BATCHED_PER_INST_DATA);
             int const varCount = static_cast<int>(interface->GetVariableCount());
 
             for (int i = 0; i < varCount; ++i)