2022-10-18 19:20:08 +08:00
44 changed files with 856 additions and 288 deletions
--- a/.gitignore
+++ b/.gitignore
@ -362,3 +362,5 @@ MigrationBackup/
 *.csproj

 *.filters
+
+Assets/Editor/Layouts/UserLayout.ini
--- a/Assets/Editor/Layouts/Default.ini
+++ b/Assets/Editor/Layouts/Default.ini
@ -0,0 +1,48 @@
+[Window][MainStatusBar]
+Pos=0,1060
+Size=1920,20
+Collapsed=0
+
+[Window][SHEditorMenuBar]
+Pos=0,24
+Size=1920,1036
+Collapsed=0
+
+[Window][Hierarchy Panel]
+Pos=0,120
+Size=225,940
+Collapsed=0
+DockId=0x00000004,0
+
+[Window][Debug##Default]
+Pos=60,60
+Size=400,400
+Collapsed=0
+
+[Window][Inspector]
+Pos=1686,24
+Size=234,1036
+Collapsed=0
+DockId=0x00000006,0
+
+[Window][Profiler]
+Pos=0,24
+Size=225,94
+Collapsed=0
+DockId=0x00000003,0
+
+[Window][Viewport]
+Pos=227,24
+Size=1457,1036
+Collapsed=0
+DockId=0x00000002,0
+
+[Docking][Data]
+DockSpace       ID=0xC5C9B8AB Window=0xBE4044E9 Pos=8,55 Size=1920,1036 Split=X
+  DockNode      ID=0x00000005 Parent=0xC5C9B8AB SizeRef=1684,1036 Split=X
+    DockNode    ID=0x00000001 Parent=0x00000005 SizeRef=225,1036 Split=Y Selected=0x1E6EB881
+      DockNode  ID=0x00000003 Parent=0x00000001 SizeRef=225,94 Selected=0x1E6EB881
+      DockNode  ID=0x00000004 Parent=0x00000001 SizeRef=225,940 Selected=0xE096E5AE
+    DockNode    ID=0x00000002 Parent=0x00000005 SizeRef=1293,1036 CentralNode=1 Selected=0x13926F0B
+  DockNode      ID=0x00000006 Parent=0xC5C9B8AB SizeRef=234,1036 Selected=0xE7039252
+
--- a/Assets/Editor/Layouts/UserLayout.ini
+++ b/Assets/Editor/Layouts/UserLayout.ini
@ -0,0 +1,48 @@
+[Window][MainStatusBar]
+Pos=0,1060
+Size=1920,20
+Collapsed=0
+
+[Window][SHEditorMenuBar]
+Pos=0,48
+Size=1920,1012
+Collapsed=0
+
+[Window][Hierarchy Panel]
+Pos=0,142
+Size=321,918
+Collapsed=0
+DockId=0x00000004,0
+
+[Window][Debug##Default]
+Pos=60,60
+Size=400,400
+Collapsed=0
+
+[Window][Inspector]
+Pos=1649,48
+Size=271,1012
+Collapsed=0
+DockId=0x00000006,0
+
+[Window][Profiler]
+Pos=0,48
+Size=321,92
+Collapsed=0
+DockId=0x00000003,0
+
+[Window][Viewport]
+Pos=323,48
+Size=1324,1012
+Collapsed=0
+DockId=0x00000002,0
+
+[Docking][Data]
+DockSpace       ID=0xC5C9B8AB Window=0xBE4044E9 Pos=617,298 Size=1920,1012 Split=X
+  DockNode      ID=0x00000005 Parent=0xC5C9B8AB SizeRef=1992,1036 Split=X
+    DockNode    ID=0x00000001 Parent=0x00000005 SizeRef=321,1036 Split=Y Selected=0x1E6EB881
+      DockNode  ID=0x00000003 Parent=0x00000001 SizeRef=225,94 Selected=0x1E6EB881
+      DockNode  ID=0x00000004 Parent=0x00000001 SizeRef=225,940 Selected=0xE096E5AE
+    DockNode    ID=0x00000002 Parent=0x00000005 SizeRef=1324,1036 CentralNode=1 Selected=0x13926F0B
+  DockNode      ID=0x00000006 Parent=0xC5C9B8AB SizeRef=271,1036 Selected=0xE7039252
+
--- a/SHADE_Application/src/Application/SBApplication.cpp
+++ b/SHADE_Application/src/Application/SBApplication.cpp
@ -132,14 +132,19 @@ namespace Sandbox
  void SBApplication::Update(void)
  {
    SHGraphicsSystem* graphicsSystem = SHADE::SHSystemManager::GetSystem<SHGraphicsSystem>();
+    SHEditor* editor = SHADE::SHSystemManager::GetSystem<SHEditor>();
    //TODO: Change true to window is open
    while (!window.WindowShouldClose())
    {
      SHFrameRateController::UpdateFRC();
      SHInputManager::UpdateInput(SHFrameRateController::GetRawDeltaTime());
      SHSceneManager::UpdateSceneManager();
+#ifdef SHEDITOR
+      if(editor->editorState == SHEditor::State::PLAY)
        SHSceneManager::SceneUpdate(0.016f);
-      SHSystemManager::RunRoutines(false, 0.016f);
+#endif
+      SHSystemManager::RunRoutines(editor->editorState != SHEditor::State::PLAY, 0.016f);
+      editor->PollPicking();
    }

    // Finish all graphics jobs first
--- a/SHADE_Engine/src/Editor/EditorWindow/HierarchyPanel/SHHierarchyPanel.cpp
+++ b/SHADE_Engine/src/Editor/EditorWindow/HierarchyPanel/SHHierarchyPanel.cpp
@ -66,8 +66,8 @@ namespace SHADE
          editor->selectedEntities.clear();
      }
      ImGui::SeparatorEx(ImGuiSeparatorFlags_Horizontal);
-      ImGui::End();
    }
+    ImGui::End();
  }

  void SHHierarchyPanel::Exit()
@ -75,6 +75,11 @@ namespace SHADE
    SHEditorWindow::Exit();
  }

+  void SHHierarchyPanel::SetScrollTo(EntityID eid)
+  {
+    scrollTo = eid;
+  }
+
  //#==============================================================#
  //||                  Private Member Functions                  ||
  //#==============================================================#
@ -82,7 +87,20 @@ namespace SHADE
  {
    if (ImGui::BeginMenuBar())
    {
-      if (ImGui::SmallButton(ICON_MD_ADD))
+      
+      ImGui::SetCursorPosX(ImGui::GetContentRegionAvail().x - 35.0f);
+      if(ImGui::SmallButton(ICON_MD_DESELECT))
+      {
+        auto editor = SHSystemManager::GetSystem<SHEditor>();
+        editor->selectedEntities.clear();
+      }
+      if (ImGui::IsItemHovered())
+      {
+        ImGui::BeginTooltip();
+        ImGui::Text("Clear Selections");
+        ImGui::EndTooltip();
+      }
+      if (ImGui::SmallButton(ICON_MD_ADD_CIRCLE))
      {
        SHEntityManager::CreateEntity();
      }
@ -103,6 +121,13 @@ namespace SHADE
    //Get node data (Children, eid, selected)
    auto& children = currentNode->GetChildren();
    EntityID eid = currentNode->GetEntityID();
+
+    if(scrollTo != MAX_EID && eid == scrollTo)
+    {
+      ImGui::SetScrollHereY();
+      scrollTo = MAX_EID;
+    }
+
    auto editor = SHSystemManager::GetSystem<SHEditor>();

    const bool isSelected = (std::ranges::find(editor->selectedEntities, eid) != editor->selectedEntities.end());
--- a/SHADE_Engine/src/Editor/EditorWindow/HierarchyPanel/SHHierarchyPanel.h
+++ b/SHADE_Engine/src/Editor/EditorWindow/HierarchyPanel/SHHierarchyPanel.h
@ -23,11 +23,13 @@ namespace SHADE
    void Init() override;
    void Update() override;
    void Exit() override;
+    void SetScrollTo(EntityID eid);
  private:
    void DrawMenuBar() const noexcept;
    ImRect RecursivelyDrawEntityNode(SHSceneNode*);
    void CreateChildEntity(EntityID parentEID) const noexcept;
    std::string filter;
    bool isAnyNodeSelected = false;
+    EntityID scrollTo = MAX_EID;
  };//class SHHierarchyPanel
 }//namespace SHADE
--- a/SHADE_Engine/src/Editor/EditorWindow/Inspector/SHEditorComponentView.hpp
+++ b/SHADE_Engine/src/Editor/EditorWindow/Inspector/SHEditorComponentView.hpp
@ -207,8 +207,10 @@ namespace SHADE
      auto& colliders = component->GetColliders();
      int const size = static_cast<int>(colliders.size());
      ImGui::BeginChild("Colliders", {0.0f,  colliders.empty() ? 1.0f : 250.0f}, true);
+      std::optional<int> colliderToDelete{std::nullopt};
      for (int i{}; i < size; ++i)
      {
+        ImGui::PushID(i);
        SHCollider& collider = component->GetCollider(i);
        auto cursorPos = ImGui::GetCursorPos();

@ -235,9 +237,14 @@ namespace SHADE
        }
        if(ImGui::Button(std::format("{} Remove Collider #{}", ICON_MD_REMOVE, i).data()))
        {
-          component->RemoveCollider(i);
+          colliderToDelete = i;
        }
        SHEditorWidgets::EndPanel();
+        ImGui::PopID();
+      }
+      if(colliderToDelete.has_value())
+      {
+        component->RemoveCollider(colliderToDelete.value());
      }
      ImGui::EndChild();

--- a/SHADE_Engine/src/Editor/EditorWindow/Inspector/SHEditorInspector.cpp
+++ b/SHADE_Engine/src/Editor/EditorWindow/Inspector/SHEditorInspector.cpp
@ -99,8 +99,8 @@ namespace SHADE
        }

      }
-      ImGui::End();
    }
+    ImGui::End();
  }

  void SHEditorInspector::Exit()
--- a/SHADE_Engine/src/Editor/EditorWindow/MenuBar/SHEditorMenuBar.cpp
+++ b/SHADE_Engine/src/Editor/EditorWindow/MenuBar/SHEditorMenuBar.cpp
@ -36,6 +36,11 @@ namespace SHADE
  void SHEditorMenuBar::Init()
  {
    SHEditorWindow::Init();
+    constexpr std::string_view path = "../../Assets/Editor/Layouts";
+    for(auto const& entry : std::filesystem::directory_iterator(path))
+    {
+      layoutPaths.push_back(entry.path());
+    }
  }

  void SHEditorMenuBar::Update()
@ -87,20 +92,6 @@ namespace SHADE
          ImGui::EndDisabled();
          ImGui::EndMenu();
        }
-        if(ImGui::BeginMenu("Theme"))
-        {
-          auto styles = rttr::type::get<SHEditor::Style>().get_enumeration();
-          auto values = styles.get_values();
-          for (auto style : values)
-          {
-            if(ImGui::Selectable(style.to_string().c_str()))
-            {
-              if(auto editor = SHSystemManager::GetSystem<SHEditor>())
-                editor->SetStyle(style.convert<SHEditor::Style>());
-            }
-          }
-          ImGui::EndMenu();
-        }
        if (ImGui::BeginMenu("Scripts"))
        {
          if (ImGui::Selectable("Generate Visual Studio Project"))
@ -120,18 +111,79 @@ namespace SHADE
          }
          ImGui::EndMenu();
        }
+
+        if (ImGui::BeginMenu("Window"))
+        {
+          for (const auto& window : SHEditorWindowManager::editorWindows | std::views::values)
+          {
+            if (window.get() != this)
+              ImGui::Checkbox(window->windowName.data(), &window->isOpen);
+          }
+          ImGui::EndMenu();
+        }
+        if (ImGui::BeginMenu("Theme"))
+        {
+          const auto styles = rttr::type::get<SHEditor::Style>().get_enumeration();
+          auto values = styles.get_values();
+          for (auto style : values)
+          {
+            if (ImGui::Selectable(style.to_string().c_str()))
+            {
+              if (auto editor = SHSystemManager::GetSystem<SHEditor>())
+                editor->SetStyle(style.convert<SHEditor::Style>());
+            }
+          }
+          ImGui::EndMenu();
+        }
+        if(ImGui::BeginMenu("Layout"))
+        {
+          for(auto const& entry : layoutPaths)
+          {
+            if(ImGui::Selectable(entry.stem().string().c_str()))
+            {
+              ImGui::LoadIniSettingsFromDisk(entry.string().c_str());
+            }
+          }
+          ImGui::EndMenu();
+        }
        ImGui::EndMainMenuBar();
      }

-      const ImGuiID dockspace_id = ImGui::GetID("DockSpace");
-      ImGui::DockSpace(dockspace_id, ImVec2(0.0f, 0.0f), dockspaceFlags);
+      const ImGuiID dockspaceId = ImGui::GetID("DockSpace");
+      ImGui::DockSpace(dockspaceId, ImVec2(0.0f, 0.0f), dockspaceFlags);
      ImGui::End();
    }
  }

  void SHEditorMenuBar::DrawSecondaryBar() const noexcept
  {
-
+    ImGuiViewport* viewport = ImGui::GetMainViewport();
+    if(ImGui::BeginViewportSideBar("##SecondaryMenuBar", viewport, ImGuiDir_Up, ImGui::GetFrameHeight(), ImGuiWindowFlags_NoScrollbar | ImGuiWindowFlags_NoSavedSettings | ImGuiWindowFlags_NoNav | ImGuiWindowFlags_MenuBar))
+    {
+      ImGui::BeginMenuBar();
+      ImGui::SetCursorPosX(ImGui::GetContentRegionAvail().x * 0.5f - 80.f);
+      const auto editor = SHSystemManager::GetSystem<SHEditor>();
+      ImGui::BeginDisabled(editor->editorState == SHEditor::State::PLAY);
+      if(ImGui::SmallButton(ICON_MD_PLAY_ARROW))
+      {
+        editor->editorState = SHEditor::State::PLAY;
+      }
+      ImGui::EndDisabled();
+      ImGui::BeginDisabled(editor->editorState == SHEditor::State::PAUSE);
+      if(ImGui::SmallButton(ICON_MD_PAUSE))
+      {
+        editor->editorState = SHEditor::State::PAUSE;
+      }
+      ImGui::EndDisabled();
+      ImGui::BeginDisabled(editor->editorState == SHEditor::State::STOP);
+      if(ImGui::SmallButton(ICON_MD_STOP))
+      {
+        editor->editorState = SHEditor::State::STOP;
+      }
+      ImGui::EndDisabled();
+      ImGui::EndMenuBar();
+    }
+    ImGui::End();
  }

  void SHEditorMenuBar::DrawStatusBar() const noexcept
@ -142,8 +194,8 @@ namespace SHADE
    if (ImGui::BeginViewportSideBar("MainStatusBar", ImGui::GetMainViewport(), ImGuiDir_Down, menuBarHeight, editorMenuBarFlags))
    {
      ImGui::Text("Entity count: ");
-      ImGui::End();
    }
+    ImGui::End();
    ImGui::PopStyleVar(3);

  }
--- a/SHADE_Engine/src/Editor/EditorWindow/MenuBar/SHEditorMenuBar.h
+++ b/SHADE_Engine/src/Editor/EditorWindow/MenuBar/SHEditorMenuBar.h
@ -18,5 +18,6 @@ namespace SHADE
    void DrawSecondaryBar() const noexcept;
    void DrawStatusBar() const noexcept;
    float menuBarHeight = 20.0f;
+    std::vector<std::filesystem::path> layoutPaths;
  };//class SHEditorMenuBar
 }//namespace SHADE
--- a/SHADE_Engine/src/Editor/EditorWindow/Profiling/SHEditorProfiler.cpp
+++ b/SHADE_Engine/src/Editor/EditorWindow/Profiling/SHEditorProfiler.cpp
@ -37,8 +37,8 @@ namespace SHADE
    if(Begin())
    {
      ImGui::PlotLines("DT", frames.data(), static_cast<int>(frames.size()), 0, nullptr, 0.0f, 16.0f);
-      ImGui::End();
    }
+    ImGui::End();
  }

  void SHEditorProfiler::Exit()
--- a/SHADE_Engine/src/Editor/EditorWindow/SHEditorWindow.cpp
+++ b/SHADE_Engine/src/Editor/EditorWindow/SHEditorWindow.cpp
@ -19,7 +19,7 @@ namespace SHADE
 //||                  Public Member Functions                   ||
 //#==============================================================#
  SHEditorWindow::SHEditorWindow(std::string_view const& name, ImGuiWindowFlags const& inFlags)
-    : isOpen(true), windowName(name), windowFlags(inFlags), io(ImGui::GetIO())
+    : windowName(name), windowFlags(inFlags), io(ImGui::GetIO())
  {
  }

@ -40,7 +40,30 @@ namespace SHADE
  //#==============================================================#
  bool SHEditorWindow::Begin()
  {
-    return ImGui::Begin(windowName.data(), &isOpen, windowFlags);
+    bool result = ImGui::Begin(windowName.data(), &isOpen, windowFlags);
+
+    auto wndSize = ImGui::GetWindowSize();
+    if(windowSize.x != wndSize.x || windowSize.y != wndSize.y)
+    {
+      windowSize = {wndSize.x, wndSize.y};
+      OnResize();
+    }
+    auto wndPos = ImGui::GetWindowPos();
+    if(windowPos.x != wndPos.x || windowPos.y != wndPos.y)
+    {
+      windowPos = {wndPos.x, wndPos.y};
+      OnPosChange();
+    }
+    isWindowHovered = ImGui::IsWindowHovered();
+    return result;
+  }
+
+  void SHEditorWindow::OnResize()
+  {
+  }
+
+  void SHEditorWindow::OnPosChange()
+  {
  }
 }//namespace SHADE

--- a/SHADE_Engine/src/Editor/EditorWindow/SHEditorWindow.h
+++ b/SHADE_Engine/src/Editor/EditorWindow/SHEditorWindow.h
@ -5,6 +5,8 @@
 //#==============================================================#
 #include <string>

+#include "Math/Vector/SHVec2.h"
+
 //#==============================================================#
 //||                    Forward Declarations                    ||
 //#==============================================================#
@ -21,11 +23,18 @@ namespace SHADE
    virtual void Init();
    virtual void Update();
    virtual void Exit();
-    bool isOpen = false;
+    bool isOpen;
+    bool isWindowHovered;
    std::string_view windowName;
  protected:
    virtual bool Begin();
+    virtual void OnResize();
+    virtual void OnPosChange();
+
    ImGuiWindowFlags windowFlags = 0;
    ImGuiIO& io;
+    SHVec2 windowSize;
+    SHVec2 windowPos;
+    SHVec2 viewportMousePos;
  };//class SHEditorWindow
 }//namespace SHADE
--- a/SHADE_Engine/src/Editor/EditorWindow/SHEditorWindowIncludes.h
+++ b/SHADE_Engine/src/Editor/EditorWindow/SHEditorWindowIncludes.h
@ -3,3 +3,4 @@
 #include "HierarchyPanel/SHHierarchyPanel.h"  //Hierarchy Panel
 #include "Inspector/SHEditorInspector.h"      //Inspector
 #include "Profiling/SHEditorProfiler.h"       //Profiler
+#include "ViewportWindow/SHEditorViewport.h"  //Editor Viewport
--- a/SHADE_Engine/src/Editor/EditorWindow/ViewportWindow/SHEditorViewport.cpp
+++ b/SHADE_Engine/src/Editor/EditorWindow/ViewportWindow/SHEditorViewport.cpp
@ -0,0 +1,84 @@
+#include "SHpch.h"
+#include "SHEditorViewport.h"
+
+#include "ECS_Base/Managers/SHSystemManager.h"
+#include "Editor/SHEditor.hpp"
+#include "Editor/EditorWindow/HierarchyPanel/SHHierarchyPanel.h"
+#include "Graphics/MiddleEnd/Interface/SHGraphicsSystem.h"
+#include "Graphics/Descriptors/SHVkDescriptorSetGroup.h"
+#include "Graphics/MiddleEnd/Interface/SHMousePickSystem.h"
+
+namespace SHADE
+{
+  SHEditorViewport::SHEditorViewport()
+    :SHEditorWindow("Viewport", ImGuiWindowFlags_MenuBar | ImGuiWindowFlags_NoScrollbar)
+  {
+  }
+
+  void SHEditorViewport::Init()
+  {
+    SHEditorWindow::Init();
+
+  }
+
+  void SHEditorViewport::Update()
+  {
+    SHEditorWindow::Update();
+    if(Begin())
+    {
+      DrawMenuBar();
+      auto gfxSystem = SHSystemManager::GetSystem<SHGraphicsSystem>();
+      auto const& descriptorSet = gfxSystem->GetPostOffscreenRenderSystem()->GetDescriptorSetGroup()->GetVkHandle()[0];
+      auto mousePos = ImGui::GetMousePos();
+      auto cursorPos = ImGui::GetCursorScreenPos();
+      viewportMousePos = {mousePos.x - cursorPos.x, mousePos.y - cursorPos.y};
+      gfxSystem->GetMousePickSystem ()->SetViewportMousePos (viewportMousePos);
+      //if (ImGui::IsMouseReleased(ImGuiMouseButton_Left))
+      //{
+      //  auto eid = gfxSystem->GetMousePickSystem ()->GetPickedEntity();
+      //  if(eid != MAX_EID)
+      //  {
+      //    auto editor = SHSystemManager::GetSystem<SHEditor>();
+      //    editor->selectedEntities.clear();
+      //    editor->selectedEntities.push_back(eid);
+      //    if (const auto hierarchyPanel = SHEditorWindowManager::GetEditorWindow<SHHierarchyPanel>())
+      //    {
+      //      hierarchyPanel->SetScrollTo(eid);
+      //    }
+      //  }
+      //}
+
+      ImGui::Image((ImTextureID)descriptorSet, ImGui::GetWindowSize());
+    }
+    ImGui::End();
+  }
+
+  void SHEditorViewport::Exit()
+  {
+    SHEditorWindow::Exit();
+  }
+
+  void SHEditorViewport::OnResize()
+  {
+    SHEditorWindow::OnResize();
+    //Get graphics system to resize swapchain image
+    auto gfxSystem = SHSystemManager::GetSystem<SHGraphicsSystem>();
+
+    //auto pos = ImGui::GetCursorPos();
+    //windowCursorPos = {}
+    gfxSystem->PrepareResize(static_cast<uint32_t>(windowSize.x), static_cast<uint32_t>(windowSize.y));
+  }
+
+  void SHEditorViewport::OnPosChange()
+  {
+    SHEditorWindow::OnPosChange();
+  }
+
+  void SHEditorViewport::DrawMenuBar() const noexcept
+  {
+    if(ImGui::BeginMenuBar())
+    {
+      ImGui::EndMenuBar();
+    }
+  }
+}//namespace SHADE
--- a/SHADE_Engine/src/Editor/EditorWindow/ViewportWindow/SHEditorViewport.h
+++ b/SHADE_Engine/src/Editor/EditorWindow/ViewportWindow/SHEditorViewport.h
@ -0,0 +1,29 @@
+#pragma once
+//#==============================================================#
+//||                      Library Includes                      ||
+//#==============================================================#
+#include <imgui.h>
+
+//#==============================================================#
+//||                       SHADE Includes                       ||
+//#==============================================================#
+#include "imgui_internal.h"
+#include "ECS_Base/SHECSMacros.h"
+#include "Editor/EditorWindow/SHEditorWindow.h"
+
+namespace SHADE
+{
+    class SHEditorViewport final : public SHEditorWindow
+  {
+  public:
+    SHEditorViewport();
+    void Init() override;
+    void Update() override;
+    void Exit() override;
+  protected:
+    void OnResize() override;
+    void OnPosChange() override;
+  private:
+    void DrawMenuBar() const noexcept;
+  };//class SHEditorViewport
+}//namespace SHADE
--- a/SHADE_Engine/src/Editor/SHEditor.cpp
+++ b/SHADE_Engine/src/Editor/SHEditor.cpp
@ -43,6 +43,8 @@
 #include <backends/imgui_impl_sdl.h>
 #include <backends/imgui_impl_vulkan.h>

+#include "Graphics/MiddleEnd/Interface/SHMousePickSystem.h"
+
 RTTR_REGISTRATION
 {
  using namespace SHADE;
@ -73,6 +75,7 @@ namespace SHADE
  //#==============================================================#
  void SHEditor::Init()
  {
+
    IMGUI_CHECKVERSION();
    if(auto context = ImGui::CreateContext())
    {
@ -82,11 +85,21 @@ namespace SHADE
      }
    }

-    ImGuiIO& io = ImGui::GetIO(); (void)io;
+    //Add editor windows
+    SHEditorWindowManager::CreateEditorWindow<SHEditorMenuBar>();
+    SHEditorWindowManager::CreateEditorWindow<SHEditorViewport>();
+    SHEditorWindowManager::CreateEditorWindow<SHHierarchyPanel>();
+    SHEditorWindowManager::CreateEditorWindow<SHEditorInspector>();
+    SHEditorWindowManager::CreateEditorWindow<SHEditorProfiler>();

-    io.ConfigFlags |= ImGuiConfigFlags_NavEnableKeyboard;     // Enable Keyboard Controls
-    io.ConfigFlags |= ImGuiConfigFlags_ViewportsEnable; //Enable for Multi-Viewports
-    io.ConfigFlags |= ImGuiConfigFlags_DockingEnable; //Enable docking
+    io = &ImGui::GetIO();
+
+    io->ConfigFlags |= ImGuiConfigFlags_NavEnableKeyboard;     // Enable Keyboard Controls
+    io->ConfigFlags |= ImGuiConfigFlags_ViewportsEnable; //Enable for Multi-Viewports
+    io->ConfigFlags |= ImGuiConfigFlags_DockingEnable; //Enable docking
+    io->IniFilename = "../../Assets/Editor/Layouts/UserLayout.ini";
+
+    InitLayout();

    InitFonts();

@ -98,11 +111,11 @@ namespace SHADE

    SetStyle(Style::SHADE);
    
-    //Add editor windows
-    SHEditorWindowManager::CreateEditorWindow<SHEditorMenuBar>();
-    SHEditorWindowManager::CreateEditorWindow<SHHierarchyPanel>();
-    SHEditorWindowManager::CreateEditorWindow<SHEditorInspector>();
-    SHEditorWindowManager::CreateEditorWindow<SHEditorProfiler>();
+
+    for (const auto& window : SHEditorWindowManager::editorWindows | std::views::values)
+    {
+      window->Init();
+    }

    SHLOG_INFO("Successfully initialised SHADE Engine Editor")
  }
@ -126,35 +139,45 @@ namespace SHADE
      SHCommandManager::UndoCommand();
    }
    
-
    Render();
  }

  void SHEditor::Render()
  {
    ImGui::Render();
-    ImGuiIO& io = ImGui::GetIO();
-    if (io.ConfigFlags & ImGuiConfigFlags_ViewportsEnable)
+    if (io->ConfigFlags & ImGuiConfigFlags_ViewportsEnable)
    {
      ImGui::UpdatePlatformWindows();
      ImGui::RenderPlatformWindowsDefault();
    }
  }

+  void SHEditor::InitLayout() noexcept
+  {
+    if(!std::filesystem::exists(io->IniFilename))
+    {
+      std::filesystem::copy_file("../../Assets/Editor/Layouts/Default.ini", io->IniFilename);
+    }
+    //eventually load preferred layout here
+  }
+
  void SHEditor::InitFonts() noexcept
  {
-    ImGuiIO& io = ImGui::GetIO();
-    ImFont* mainFont = io.Fonts->AddFontFromFileTTF("../../Assets/Editor/Fonts/Segoe UI.ttf", 20.f);//TODO: Change to config based assets path
+    ImFont* mainFont = io->Fonts->AddFontFromFileTTF("../../Assets/Editor/Fonts/Segoe UI.ttf", 20.f);//TODO: Change to config based assets path

-    static const ImWchar icon_ranges[] = { ICON_MIN_MD, ICON_MAX_16_MD, 0 };
+    constexpr ImWchar icon_ranges[] = { ICON_MIN_MD, ICON_MAX_16_MD, 0 };
    ImFontConfig icons_config{}; icons_config.MergeMode = true; icons_config.GlyphOffset.y = 5.f;
-    ImFont* UIFont = io.Fonts->AddFontFromFileTTF("../../Assets/Editor/Fonts/MaterialIcons-Regular.ttf", 20.f, &icons_config, icon_ranges); //TODO: Change to config based assets path
+    ImFont* UIFont = io->Fonts->AddFontFromFileTTF("../../Assets/Editor/Fonts/MaterialIcons-Regular.ttf", 20.f, &icons_config, icon_ranges); //TODO: Change to config based assets path

-    io.Fonts->Build();
+    io->Fonts->Build();
  }

  void SHEditor::Exit()
  {
+    for (const auto& window : SHEditorWindowManager::editorWindows | std::views::values)
+    {
+      window->Init();
+    }
    ImGui_ImplVulkan_Shutdown();
    ImGui_ImplSDL2_Shutdown();
    ImGui::DestroyContext();
@ -281,10 +304,11 @@ namespace SHADE
    imguiCommandPool = gfxSystem->GetDevice()->CreateCommandPool(SH_QUEUE_FAMILY_ARRAY_INDEX::GRAPHICS, SH_CMD_POOL_RESET::POOL_BASED, true);
    imguiCommandBuffer = imguiCommandPool->RequestCommandBuffer(SH_CMD_BUFFER_TYPE::PRIMARY);

-    auto const& renderers = gfxSystem->GetDefaultViewport()->GetRenderers();
+    //auto const& renderers = gfxSystem->GetDefaultViewport()->GetRenderers();
+    auto const& renderers = gfxSystem->GetEditorViewport()->GetRenderers();

    SHASSERT(!renderers.empty(), "No Renderers available")
-    auto renderGraph = renderers[0]->GetRenderGraph();
+    auto renderGraph = renderers[SHGraphicsConstants::RenderGraphIndices::EDITOR]->GetRenderGraph();
    auto renderPass = renderGraph->GetNode("ImGui Node")->GetRenderpass();

    if(ImGui_ImplVulkan_Init(&initInfo, renderPass->GetVkRenderpass()) == false)
@ -309,6 +333,29 @@ namespace SHADE
      });
  }

+  void SHEditor::PollPicking()
+  {
+    if (auto gfxSystem = SHSystemManager::GetSystem<SHGraphicsSystem>())
+    {
+      auto viewportWindow = SHEditorWindowManager::GetEditorWindow<SHEditorViewport>();
+      if (viewportWindow->isWindowHovered && ImGui::IsMouseReleased(ImGuiMouseButton_Left))
+      {
+        EntityID pickedEID = gfxSystem->GetMousePickSystem()->GetPickedEntity();
+        if(pickedEID == MAX_EID)
+          return;
+        if (!ImGui::IsKeyDown(ImGuiKey_LeftCtrl))
+        {
+          if (const auto hierarchyPanel = SHEditorWindowManager::GetEditorWindow<SHHierarchyPanel>())
+          {
+            hierarchyPanel->SetScrollTo(pickedEID);
+          }
+          selectedEntities.clear();
+        }
+        selectedEntities.push_back(pickedEID);
+      }
+    }
+  }
+
  void SHEditor::NewFrame()
  {
    SDL_Event event;
--- a/SHADE_Engine/src/Editor/SHEditor.hpp
+++ b/SHADE_Engine/src/Editor/SHEditor.hpp
@ -90,11 +90,11 @@ namespace SHADE
      return reinterpret_cast<T*>(editorWindows[GetEditorWindowID<T>()].get());
    }

+    static EditorWindowMap editorWindows;
  private:
    // Number of windows; used for Editor Window ID Generation
    static EditorWindowID windowCount;
    // Map of Editor Windows
-    static EditorWindowMap editorWindows;
    friend class SHEditor;
  };

@ -110,10 +110,17 @@ namespace SHADE
    class SH_API EditorRoutine final : public SHSystemRoutine
    {
    public:
-        EditorRoutine() = default;
+        EditorRoutine():SHSystemRoutine("Editor routine", true) {};
        void Execute(double dt) noexcept override final;
    };

+    enum class State : uint8_t
+    {
+      PLAY,
+      PAUSE,
+      STOP
+    };
+
    /**
     * @brief Style options
     *
@ -162,9 +169,13 @@ namespace SHADE

    void SetSDLWindow(SDL_Window* inSDLWindow){sdlWindow = inSDLWindow;};

+    void PollPicking();
+
    // List of selected entities
    std::vector<EntityID> selectedEntities;

+    State editorState = State::STOP;
+
  private:
    /**
     * @brief Start new frame for editor
@ -177,7 +188,7 @@ namespace SHADE
     */
    void Render();

-    
+    void InitLayout() noexcept;

    void InitFonts() noexcept;

@ -186,6 +197,8 @@ namespace SHADE
    // Handle to command buffer used for ImGui Vulkan Backend
    Handle<SHVkCommandBuffer> imguiCommandBuffer;

-    SDL_Window* sdlWindow;
+    SDL_Window* sdlWindow {nullptr};
+
+    ImGuiIO* io{nullptr};
  };//class SHEditor
 }//namespace SHADE
--- a/SHADE_Engine/src/Graphics/Debugging/SHVulkanDebugUtil.cpp
+++ b/SHADE_Engine/src/Graphics/Debugging/SHVulkanDebugUtil.cpp
@ -99,7 +99,7 @@ namespace SHADE

  void SHVulkanDebugUtil::ReportVkSuccess(std::string_view message) noexcept
  {
-    SHLOGV_INFO(message);
+    //SHLOGV_INFO(message);
  }

  /***************************************************************************/
--- a/SHADE_Engine/src/Graphics/Descriptors/SHVkDescriptorSetGroup.cpp
+++ b/SHADE_Engine/src/Graphics/Descriptors/SHVkDescriptorSetGroup.cpp
@ -172,7 +172,7 @@ namespace SHADE
      // write sampler and image view
      auto& [view, sampler, layout] = imageViewsAndSamplers[i];
      writeInfo.descImageInfos[i].imageView = view->GetImageView();
-      writeInfo.descImageInfos[i].sampler = sampler->GetVkSampler();
+      writeInfo.descImageInfos[i].sampler = sampler ? sampler->GetVkSampler() : nullptr;
      writeInfo.descImageInfos[i].imageLayout = layout;
    }
  }
--- a/SHADE_Engine/src/Graphics/Descriptors/SHVkDescriptorSetLayout.cpp
+++ b/SHADE_Engine/src/Graphics/Descriptors/SHVkDescriptorSetLayout.cpp
@ -1,16 +1,18 @@
 #include "SHPch.h"
 #include "SHVkDescriptorSetLayout.h"
 #include "Graphics/Devices/SHVkLogicalDevice.h"
+#include "Graphics/Images/SHVkSampler.h"

 namespace SHADE
 {
    /*---------------------------------------------------------------------------------*/
    /* Constructor/Destructor                                                          */
    /*---------------------------------------------------------------------------------*/
-    SHVkDescriptorSetLayout::SHVkDescriptorSetLayout(Handle<SHVkLogicalDevice> device, SetIndex set, const std::vector<Binding>& bindings)
+    SHVkDescriptorSetLayout::SHVkDescriptorSetLayout(Handle<SHVkLogicalDevice> device, SetIndex set, const std::vector<Binding>& bindings, bool genImmutableSamplers/* = false*/)
    : device     { device }
    , layoutDesc { bindings }
    , setIndex {set}
+    , immutableSampler{}
    {
        // Check if auto-binding point calculation configuration is valid
        bool autoCalc = false;
@ -26,6 +28,25 @@ namespace SHADE
            }
        }

+        vk::Sampler tempVkSampler = nullptr;
+        if (genImmutableSamplers)
+        {
+          // Create sampler
+          immutableSampler = device->CreateSampler(
+            {
+              .minFilter = vk::Filter::eLinear,
+              .magFilter = vk::Filter::eLinear,
+              .addressMode = vk::SamplerAddressMode::eRepeat,
+              .mipmapMode = vk::SamplerMipmapMode::eLinear,
+              .minLod = -1000,
+              .maxLod = 1000
+            }
+          );
+
+          tempVkSampler = immutableSampler->GetVkSampler();
+        }
+
+
        // Fill up VK bindings with auto calculated bind points if needed
        std::vector<vk::DescriptorSetLayoutBinding> layoutBindings;
        layoutBindings.reserve(bindings.size());
@ -39,7 +60,7 @@ namespace SHADE
                .descriptorType     = binding.Type,
                .descriptorCount    = binding.DescriptorCount,
                .stageFlags         = binding.Stage,
-                .pImmutableSamplers = nullptr // We will create our own samplers
+                .pImmutableSamplers = genImmutableSamplers ? &tempVkSampler : nullptr,
            };
            layoutBindings.emplace_back(VK_BINDING);

@ -75,7 +96,8 @@ namespace SHADE
      : device {rhs.device}
      , setLayout {rhs.setLayout}
      , layoutDesc{std::move (rhs.layoutDesc)}
-      , setIndex {rhs.setIndex}
+      , setIndex{ rhs.setIndex }
+      , immutableSampler{ rhs.immutableSampler }
    {
      rhs.setLayout = VK_NULL_HANDLE;
    }
@ -106,6 +128,7 @@ namespace SHADE
      setLayout = rhs.setLayout;
      layoutDesc = std::move(rhs.layoutDesc);
      setIndex = rhs.setIndex;
+      immutableSampler = rhs.immutableSampler;

      rhs.setLayout = VK_NULL_HANDLE;

--- a/SHADE_Engine/src/Graphics/Descriptors/SHVkDescriptorSetLayout.h
+++ b/SHADE_Engine/src/Graphics/Descriptors/SHVkDescriptorSetLayout.h
@ -10,6 +10,7 @@ namespace SHADE
    /* Forward Declarations                                                            */
    /*---------------------------------------------------------------------------------*/
    class SHVkLogicalDevice;
+    class SHVkSampler;

    /*---------------------------------------------------------------------------------*/
    /* Type Definitions                                                                */
@ -74,7 +75,7 @@ namespace SHADE
        /// </summary>
        /// <param name="device"></param>
        /// <param name="bindings"></param>
-        SHVkDescriptorSetLayout(Handle<SHVkLogicalDevice> device, SetIndex setIndex, const std::vector<Binding>& bindings);
+        SHVkDescriptorSetLayout(Handle<SHVkLogicalDevice> device, SetIndex setIndex, const std::vector<Binding>& bindings, bool genImmutableSamplers = false);
        SHVkDescriptorSetLayout(const SHVkDescriptorSetLayout&) = delete;
        SHVkDescriptorSetLayout(SHVkDescriptorSetLayout&& rhs) noexcept;
        /// <summary>
@ -107,5 +108,6 @@ namespace SHADE
        vk::DescriptorSetLayout   setLayout;
        std::vector<Binding>      layoutDesc; // Stores description of the layout
        SetIndex                  setIndex;   // Index of the set
+        Handle<SHVkSampler>       immutableSampler;
    };
 }
--- a/SHADE_Engine/src/Graphics/Devices/SHVkLogicalDevice.cpp
+++ b/SHADE_Engine/src/Graphics/Devices/SHVkLogicalDevice.cpp
@ -550,10 +550,9 @@ namespace SHADE

  }

-  Handle<SHVkDescriptorSetLayout> SHVkLogicalDevice::CreateDescriptorSetLayout(SetIndex setIndex, std::vector<SHVkDescriptorSetLayout::Binding> const& bindings) noexcept
+  Handle<SHVkDescriptorSetLayout> SHVkLogicalDevice::CreateDescriptorSetLayout(SetIndex setIndex, std::vector<SHVkDescriptorSetLayout::Binding> const& bindings, bool genImmutableSamplers/* = false*/) noexcept
  {
-    return SHVkInstance::GetResourceManager().Create <SHVkDescriptorSetLayout>(GetHandle(), setIndex,  bindings);
-
+    return SHVkInstance::GetResourceManager().Create <SHVkDescriptorSetLayout>(GetHandle(), setIndex,  bindings, genImmutableSamplers);
  }

  Handle<SHVkDescriptorPool> SHVkLogicalDevice::CreateDescriptorPools(const SHVkDescriptorPool::Config& config /*= {}*/) noexcept
--- a/SHADE_Engine/src/Graphics/Devices/SHVkLogicalDevice.h
+++ b/SHADE_Engine/src/Graphics/Devices/SHVkLogicalDevice.h
@ -186,7 +186,7 @@ namespace SHADE
    Handle<SHVkRenderpass>          CreateRenderpass          (std::span<vk::AttachmentDescription> const vkDescriptions, std::vector<SHVkSubpassParams> const& subpasses) noexcept;
    Handle<SHVkRenderpass>          CreateRenderpass          (std::span<vk::AttachmentDescription> const vkDescriptions, std::span<vk::SubpassDescription> const spDescs, std::span<vk::SubpassDependency> const spDeps) noexcept;
    Handle<SHVkFramebuffer>         CreateFramebuffer         (Handle<SHVkRenderpass> const& renderpassHdl, std::vector<Handle<SHVkImageView>> const& attachments, uint32_t inWidth, uint32_t inHeight) noexcept;
-    Handle<SHVkDescriptorSetLayout> CreateDescriptorSetLayout (SetIndex setIndex, std::vector<SHVkDescriptorSetLayout::Binding> const& bindings) noexcept;
+    Handle<SHVkDescriptorSetLayout> CreateDescriptorSetLayout (SetIndex setIndex, std::vector<SHVkDescriptorSetLayout::Binding> const& bindings, bool genImmutableSamplers = false) noexcept;
    Handle<SHVkDescriptorPool>      CreateDescriptorPools     (const SHVkDescriptorPool::Config& config = {}) noexcept;
    Handle<SHVkDescriptorSetGroup>  CreateDescriptorSetGroup(Handle<SHVkDescriptorPool> pool,
      std::vector<Handle<SHVkDescriptorSetLayout>> const& layouts,
--- a/SHADE_Engine/src/Graphics/Images/SHVkSampler.cpp
+++ b/SHADE_Engine/src/Graphics/Images/SHVkSampler.cpp
@ -30,8 +30,9 @@ namespace SHADE
      .addressModeU  = params.addressMode,
      .addressModeV  = params.addressMode,
      .addressModeW  = params.addressMode,
+      .maxAnisotropy = 1.0f,
      .minLod        = params.minLod,
-      .maxLod       = params.maxLod
+      .maxLod        = params.maxLod,
    };

    // Create the sampler
--- a/SHADE_Engine/src/Graphics/MiddleEnd/Interface/SHGraphicsConstants.h
+++ b/SHADE_Engine/src/Graphics/MiddleEnd/Interface/SHGraphicsConstants.h
@ -25,6 +25,12 @@ namespace SHADE
  struct SHGraphicsConstants
  {
  public:
+    struct RenderGraphIndices
+    {
+      static constexpr uint32_t WORLD  = 0;
+      static constexpr uint32_t EDITOR = 0;
+    };
+
    struct DescriptorSetIndex
    {
      /***************************************************************************/
--- a/SHADE_Engine/src/Graphics/MiddleEnd/Interface/SHGraphicsSystem.cpp
+++ b/SHADE_Engine/src/Graphics/MiddleEnd/Interface/SHGraphicsSystem.cpp
@ -36,11 +36,9 @@ of DigiPen Institute of Technology is prohibited.

 namespace SHADE
 {
+#pragma region INIT_EXIT

-  /*---------------------------------------------------------------------------------*/
-  /* Constructor/Destructors                                                         */
-  /*---------------------------------------------------------------------------------*/
-  void SHGraphicsSystem::Init(void)
+  void SHGraphicsSystem::InitBoilerplate(void) noexcept
  {
    /*-----------------------------------------------------------------------*/
    /* BACKEND BOILERPLATE                                                   */
@ -71,7 +69,15 @@ namespace SHADE
        if (width == 0 || height == 0)
          return;

-        renderContext.SetIsResized(true);
+#ifdef SHEDITOR
+
+        //PrepareResize(1, 1, SHVec2(0, 0));
+
+#else
+
+        PrepareResize(resizeWidth, resizeHeight, SHVec2(0, 0));
+
+#endif
      });

    window->RegisterWindowCloseCallback([&](void)
@ -106,9 +112,10 @@ namespace SHADE
    graphicsCmdPool = device->CreateCommandPool(SH_QUEUE_FAMILY_ARRAY_INDEX::GRAPHICS, SH_CMD_POOL_RESET::POOL_BASED, true);
    transferCmdBuffer = graphicsCmdPool->RequestCommandBuffer(SH_CMD_BUFFER_TYPE::PRIMARY);
    graphicsTexCmdBuffer = graphicsCmdPool->RequestCommandBuffer(SH_CMD_BUFFER_TYPE::PRIMARY);
+  }

-
-
+  void SHGraphicsSystem::InitSceneRenderGraph(void) noexcept
+  {
    /*-----------------------------------------------------------------------*/
    /* MIDDLE END SETUP
       - Viewports
@ -118,8 +125,8 @@ namespace SHADE
       - Default vertex input state
       - Global data
    /*-----------------------------------------------------------------------*/
+    auto windowDims = window->GetWindowSize();

-    SHGraphicsGlobalData::Init(device);

    // Set Up Cameras
    screenCamera = resourceManager.Create<SHCamera>();
@ -131,12 +138,12 @@ namespace SHADE
    worldCamera->SetPerspective(90.0f, static_cast<float>(windowDims.first), static_cast<float>(windowDims.second), 0.0f, 100.0f);

    // Create Default Viewport
-    defaultViewport = AddViewport(vk::Viewport(0.0f, 0.0f, static_cast<float>(window->GetWindowSize().first), static_cast<float>(window->GetWindowSize().second), 0.0f, 1.0f));
+    worldViewport = AddViewport(vk::Viewport(0.0f, 0.0f, static_cast<float>(window->GetWindowSize().first), static_cast<float>(window->GetWindowSize().second), 0.0f, 1.0f));

    // Get render graph from default viewport world renderer
    worldRenderGraph = resourceManager.Create<SHRenderGraph>();

-    std::vector<Handle<SHVkCommandPool>> renderContextCmdPools{swapchain->GetNumImages()};
+    std::vector<Handle<SHVkCommandPool>> renderContextCmdPools{ swapchain->GetNumImages() };
    for (uint32_t i = 0; i < renderContextCmdPools.size(); ++i)
    {
      renderContextCmdPools[i] = renderContext.GetFrameData(i).cmdPoolHdls[0];
@ -144,51 +151,30 @@ namespace SHADE

    // Initialize world render graph
    worldRenderGraph->Init(device, swapchain);
-    worldRenderGraph->AddResource("Present", {SH_ATT_DESC_TYPE_FLAGS::COLOR_PRESENT}, windowDims.first, windowDims.second);
-    worldRenderGraph->AddResource("Scene", {SH_ATT_DESC_TYPE_FLAGS::COLOR, SH_ATT_DESC_TYPE_FLAGS::INPUT}, windowDims.first, windowDims.second);
-    worldRenderGraph->AddResource("Depth Buffer", {SH_ATT_DESC_TYPE_FLAGS::DEPTH_STENCIL}, windowDims.first, windowDims.second, vk::Format::eD32SfloatS8Uint);
-    worldRenderGraph->AddResource("Entity ID", {SH_ATT_DESC_TYPE_FLAGS::COLOR}, windowDims.first, windowDims.second, vk::Format::eR32Uint, 1, vk::ImageUsageFlagBits::eTransferSrc);
+    worldRenderGraph->AddResource("Scene", { SH_ATT_DESC_TYPE_FLAGS::COLOR, SH_ATT_DESC_TYPE_FLAGS::INPUT }, windowDims.first, windowDims.second);
+    worldRenderGraph->AddResource("Depth Buffer", { SH_ATT_DESC_TYPE_FLAGS::DEPTH_STENCIL }, windowDims.first, windowDims.second, vk::Format::eD32SfloatS8Uint);
+    worldRenderGraph->AddResource("Entity ID", { SH_ATT_DESC_TYPE_FLAGS::COLOR }, windowDims.first, windowDims.second, vk::Format::eR32Uint, 1, vk::ImageUsageFlagBits::eTransferSrc);

-    //worldRenderGraph->AddResource("Position", SH_ATT_DESC_TYPE::COLOR, windowDims.first, windowDims.second, vk::Format::eR16G16B16A16Sfloat);
-    //worldRenderGraph->AddResource("Normals", SH_ATT_DESC_TYPE::COLOR, windowDims.first, windowDims.second, vk::Format::eR16G16B16A16Sfloat);
-    //worldRenderGraph->AddResource("Composite", SH_ATT_DESC_TYPE::COLOR, windowDims.first, windowDims.second, vk::Format::eR16G16B16A16Sfloat);
-    //worldRenderGraph->AddResource("Scene", SH_ATT_DESC_TYPE::COLOR, windowDims.first, windowDims.second, vk::Format::eB8G8R8A8Unorm);
    auto node = worldRenderGraph->AddNode("G-Buffer", { "Entity ID", "Depth Buffer", "Scene"}, {}); // no predecessors

     //First subpass to write to G-Buffer
    auto gBufferWriteSubpass = node->AddSubpass("G-Buffer Write");
    gBufferWriteSubpass->AddColorOutput("Scene");
    gBufferWriteSubpass->AddColorOutput("Entity ID");
-    gBufferWriteSubpass->AddDepthOutput ("Depth Buffer", SH_ATT_DESC_TYPE_FLAGS::DEPTH_STENCIL);
+    gBufferWriteSubpass->AddDepthOutput("Depth Buffer", SH_ATT_DESC_TYPE_FLAGS::DEPTH_STENCIL);

    // We do this to just transition our scene layout to shader read
    auto sceneLayoutTransitionSubpass = node->AddSubpass("Scene Layout Transition");
    sceneLayoutTransitionSubpass->AddInput("Scene");

-#ifdef SHEDITOR
-    auto imguiNode = worldRenderGraph->AddNode("ImGui Node", { "Present" }, {"G-Buffer"});
-    auto imguiSubpass = imguiNode->AddSubpass("ImGui Draw");
-    imguiSubpass->AddColorOutput("Present");
-#endif
-
+    // Generate world render graph
    worldRenderGraph->Generate();

-    // Create Semaphore
-    for (auto& semaHandle : graphSemaphores)
-    {
-      semaHandle = device->CreateSemaphore();
-    }
-
-    // Create Debug Renderers
-    /*debugScreenRenderer = defaultViewport->AddRenderer(resourceManager, worldRenderGraph);
-    debugScreenRenderer->SetCamera(screenCamera);
-    debugWorldRenderer = defaultViewport->AddRenderer(resourceManager, worldRenderGraph);
-    debugWorldRenderer->SetCamera(worldCamera);*/
-
    // Add world renderer to default viewport
-    worldRenderer = defaultViewport->AddRenderer(resourceManager, swapchain->GetNumImages(), renderContextCmdPools, descPool, SHGraphicsGlobalData::GetDescSetLayouts()[SHGraphicsConstants::DescriptorSetIndex::HIGH_FREQUENCY_GLOBALS], worldRenderGraph);
+    worldRenderer = worldViewport->AddRenderer(resourceManager, swapchain->GetNumImages(), renderContextCmdPools, descPool, SHGraphicsGlobalData::GetDescSetLayouts()[SHGraphicsConstants::DescriptorSetIndex::HIGH_FREQUENCY_GLOBALS], worldRenderGraph);
    worldRenderer->SetCamera(worldCamera);

+
    // TODO: This is VERY temporarily here until a more solid resource management system is implemented
    shaderSourceLibrary.Init("../../TempShaderFolder/");

@ -202,6 +188,27 @@ namespace SHADE
    cubeFS->Reflect();

    defaultMaterial = AddMaterial(cubeVS, cubeFS, gBufferWriteSubpass);
+  }
+
+  void SHGraphicsSystem::InitMiddleEnd(void) noexcept
+  {
+    SHGraphicsGlobalData::Init(device);
+
+    InitSceneRenderGraph();
+
+#ifdef SHEDITOR
+    InitEditorRenderGraph();
+#endif
+
+    // Create Semaphore
+    for (auto& semaHandle : graphSemaphores)
+    {
+      semaHandle = device->CreateSemaphore();
+    }
+  }
+
+  void SHGraphicsSystem::InitSubsystems(void) noexcept
+  {

    mousePickSystem = resourceManager.Create<SHMousePickSystem>();

@ -217,6 +224,61 @@ namespace SHADE
    postOffscreenRender->Init(device, worldRenderGraph->GetRenderGraphResource("Scene"), descPool);
  }

+#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(device, swapchain);
+    editorRenderGraph->AddResource("Present", { SH_ATT_DESC_TYPE_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 = editorViewport->AddRenderer(resourceManager, swapchain->GetNumImages(), renderContextCmdPools, descPool, SHGraphicsGlobalData::GetDescSetLayouts()[SHGraphicsConstants::DescriptorSetIndex::HIGH_FREQUENCY_GLOBALS], editorRenderGraph);
+    editorRenderer->SetCamera(worldCamera);
+  }
+#endif
+
+  /*---------------------------------------------------------------------------------*/
+  /* Constructor/Destructors                                                         */
+  /*---------------------------------------------------------------------------------*/
+  void SHGraphicsSystem::Init(void)
+  {
+    InitBoilerplate();
+    InitMiddleEnd();
+    InitSubsystems();
+
+
+  }
+
+  void SHGraphicsSystem::Exit(void)
+  {
+  }
+
+#pragma endregion INIT_EXIT
+
+#pragma region LIFECYCLE
+
+  /*---------------------------------------------------------------------------------*/
+  /* Lifecycle Functions                                                             */
+  /*---------------------------------------------------------------------------------*/
  /***************************************************************************/
  /*!
  
@ -235,12 +297,6 @@ namespace SHADE
    if (window->IsMinimized() || renderContext.GetWindowIsDead())
      return;

-    if (renderContext.GetResized())
-    {
-      return;
-    }
-
-
    // Frame data for the current frame
    auto const& frameData = renderContext.GetCurrentFrameData();
    uint32_t frameIndex = renderContext.GetCurrentFrame();
@ -337,13 +393,6 @@ namespace SHADE
    }
  }
  
-  void SHGraphicsSystem::Exit(void)
-  {
-  }
-
-  /*---------------------------------------------------------------------------------*/
-  /* Lifecycle Functions                                                             */
-  /*---------------------------------------------------------------------------------*/
  /***************************************************************************/
  /*!

@ -408,12 +457,6 @@ namespace SHADE
    if (window->IsMinimized() || renderContext.GetWindowIsDead())
      return;

-    if (renderContext.GetResized())
-    {
-      return;
-    }
-
-
    const uint32_t CURR_FRAME_IDX = renderContext.GetCurrentFrame();
    auto& currFrameData = renderContext.GetCurrentFrameData();

@ -425,9 +468,7 @@ namespace SHADE
      // If swapchain is incompatible/outdated
      if (result == vk::Result::eErrorOutOfDateKHR || result == vk::Result::eSuboptimalKHR)
      {
-
        HandleResize();
-
      }
    }

@ -435,6 +476,10 @@ namespace SHADE
    renderContext.AdvanceFrame();
  }

+#pragma endregion LIFECYCLE
+
+#pragma region ADD_REMOVE_BUILD
+
  Handle<SHViewport> SHGraphicsSystem::AddViewport(const vk::Viewport& viewport)
  {
    // Create the viewport
@ -545,43 +590,14 @@ namespace SHADE
      );
  }

-  void SHGraphicsSystem::HandleResize(void) noexcept
-  {
-    if (window->IsMinimized() || renderContext.GetWindowIsDead())
-      return;
-
-    auto windowDims = window->GetWindowSize();
-
-    // Resize the swapchain
-    swapchain->Resize(surface, windowDims.first, windowDims.second);
-
-    renderContext.HandleResize();
-
-    worldRenderGraph->HandleResize(windowDims.first, windowDims.second);
-
-    mousePickSystem->HandleResize();
-
-    defaultViewport->SetWidth(static_cast<float>(windowDims.first));
-    defaultViewport->SetHeight(static_cast<float>(windowDims.second));
-
-    worldCamera->SetPerspective(90.0f, static_cast<float>(windowDims.first), static_cast<float>(windowDims.second), 0.0f, 100.0f);
-  }
-  
-  void SHGraphicsSystem::AwaitGraphicsExecution()
-  {
-    device->WaitIdle();
-  }
-
-  void SHGraphicsSystem::SetWindow(SHWindow* wind) noexcept
-  {
-    window = wind;
-  }
+#pragma endregion ADD_REMOVE

+#pragma region ROUTINES
  /*-----------------------------------------------------------------------------------*/
  /* System Routine Functions - BeginRoutine                                           */
  /*-----------------------------------------------------------------------------------*/
  SHGraphicsSystem::BeginRoutine::BeginRoutine()
-  : SHSystemRoutine("Graphics System Frame Set Up", false)
+  : SHSystemRoutine("Graphics System Frame Set Up", true)
  {}

  void SHGraphicsSystem::BeginRoutine::Execute(double) noexcept
@ -593,7 +609,7 @@ namespace SHADE
  /* System Routine Functions - RenderRoutine                                          */
  /*-----------------------------------------------------------------------------------*/
  SHGraphicsSystem::RenderRoutine::RenderRoutine()
-  : SHSystemRoutine("Graphics System Render", false)
+  : SHSystemRoutine("Graphics System Render", true)
  {}

  void SHGraphicsSystem::RenderRoutine::Execute(double dt) noexcept
@ -605,7 +621,7 @@ namespace SHADE
  /* System Routine Functions - EndRoutine                                             */
  /*-----------------------------------------------------------------------------------*/
  SHGraphicsSystem::EndRoutine::EndRoutine()
-  : SHSystemRoutine("Graphics System Frame Clean Up", false)
+  : SHSystemRoutine("Graphics System Frame Clean Up", true)
  {}

  void SHGraphicsSystem::EndRoutine::Execute(double) noexcept
@ -617,7 +633,7 @@ namespace SHADE
  /* System Routine Functions - BatcherDispatcherRoutine                               */
  /*-----------------------------------------------------------------------------------*/
  SHGraphicsSystem::BatcherDispatcherRoutine::BatcherDispatcherRoutine()
-  : SHSystemRoutine("Graphics System Batcher Dispatcher", false)
+  : SHSystemRoutine("Graphics System Batcher Dispatcher", true)
  {}

  void SHGraphicsSystem::BatcherDispatcherRoutine::Execute(double) noexcept
@ -648,5 +664,62 @@ namespace SHADE
      renderable.ResetChangedFlag();
    }
  }
+#pragma endregion ROUTINES

+#pragma region MISC
+
+  void SHGraphicsSystem::PrepareResize(uint32_t newWidth, uint32_t newHeight) noexcept
+  {
+    resizeWidth = newWidth;
+    resizeHeight = newHeight;
+
+    renderContext.SetIsResized(true);
+  }
+
+  void SHGraphicsSystem::HandleResize(void) noexcept
+  {
+    device->WaitIdle();
+
+    if (window->IsMinimized() || renderContext.GetWindowIsDead())
+      return;
+
+    graphSemaphores[0].Free();
+    graphSemaphores[1].Free();
+
+    auto windowDims = window->GetWindowSize();
+
+    // Resize the swapchain
+    swapchain->Resize(surface, windowDims.first, windowDims.second);
+
+    renderContext.HandleResize();
+
+    worldRenderGraph->HandleResize(resizeWidth, resizeHeight);
+    editorRenderGraph->HandleResize(windowDims.first, windowDims.second);
+
+    mousePickSystem->HandleResize();
+    postOffscreenRender->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);
+
+    for (auto& semaHandle : graphSemaphores)
+      semaHandle = device->CreateSemaphore();
+
+
+  }
+  
+  void SHGraphicsSystem::AwaitGraphicsExecution()
+  {
+    device->WaitIdle();
+  }
+
+  void SHGraphicsSystem::SetWindow(SHWindow* wind) noexcept
+  {
+    window = wind;
+  }
+
+
+#pragma endregion MISC
 }
--- a/SHADE_Engine/src/Graphics/MiddleEnd/Interface/SHGraphicsSystem.h
+++ b/SHADE_Engine/src/Graphics/MiddleEnd/Interface/SHGraphicsSystem.h
@ -67,6 +67,16 @@ namespace SHADE
  /***********************************************************************************/
  class SH_API SHGraphicsSystem : public SHSystem
  {
+  private:
+    void InitBoilerplate       (void) noexcept;
+    void InitSceneRenderGraph  (void) noexcept;
+    void InitMiddleEnd         (void) noexcept;
+    void InitSubsystems        (void) noexcept;
+
+#ifdef SHEDITOR
+    void InitEditorRenderGraph (void) noexcept;
+#endif
+
  public:
    class SH_API BeginRoutine final : public SHSystemRoutine
    {
@ -252,6 +262,7 @@ namespace SHADE
    /***************************************************************************/
    void BuildTextures();

+    void PrepareResize(uint32_t newWidth, uint32_t newHeight) noexcept;
    void HandleResize(void) noexcept;
    void AwaitGraphicsExecution();

@ -269,7 +280,10 @@ namespace SHADE
    Handle<SHVkPhysicalDevice>          GetPhysicalDevice() const { return physicalDevice; }
    Handle<SHVkQueue>                   GetQueue() const { return graphicsQueue; }
    Handle<SHVkDescriptorPool>          GetDescriptorPool() const { return descPool; }
-    Handle<SHViewport>                  GetDefaultViewport() const {return defaultViewport;}
+    Handle<SHViewport>                  GetDefaultViewport() const {return worldViewport;}
+#ifdef SHEDITOR
+    Handle<SHViewport>                  GetEditorViewport () const {return editorViewport;};
+#endif
    Handle<SHMousePickSystem>           GetMousePickSystem(void) const noexcept {return mousePickSystem;};
    Handle<SHPostOffscreenRenderSystem> GetPostOffscreenRenderSystem(void) const noexcept {return postOffscreenRender;};
    //SHRenderGraph const& GetRenderGraph(void) const noexcept;
@ -278,6 +292,7 @@ namespace SHADE


  private:
+
    /*-----------------------------------------------------------------------------*/
    /* Data Members                                                                */
    /*-----------------------------------------------------------------------------*/
@ -304,7 +319,13 @@ namespace SHADE
    SHSamplerCache                                            samplerCache;
    SHMaterialInstanceCache                                   materialInstanceCache;
    // Viewports 
-    Handle<SHViewport>                                        defaultViewport;    // Whole screen
+#ifdef SHEDITOR
+    Handle<SHViewport>                                        editorViewport;
+    Handle<SHRenderer>                                        editorRenderer;
+    Handle<SHRenderGraph>                                     editorRenderGraph;
+#endif
+
+    Handle<SHViewport>                                        worldViewport;    // Whole screen
    std::vector<Handle<SHViewport>>                           viewports;          // Additional viewports

    // Debug Renderers
@ -331,5 +352,7 @@ namespace SHADE
    Handle<SHMousePickSystem>                                 mousePickSystem;
    Handle<SHPostOffscreenRenderSystem>                       postOffscreenRender;

+    uint32_t                                                  resizeWidth;
+    uint32_t                                                  resizeHeight;
  };
 }
--- a/SHADE_Engine/src/Graphics/MiddleEnd/Interface/SHMousePickSystem.cpp
+++ b/SHADE_Engine/src/Graphics/MiddleEnd/Interface/SHMousePickSystem.cpp
@ -6,6 +6,7 @@
 #include "Graphics/Synchronization/SHVkFence.h"
 #include "Graphics/Buffers/SHVkBuffer.h"
 #include "Graphics/SHVkUtil.h"
+#include "Graphics/MiddleEnd/Interface/SHViewport.h"

 namespace SHADE
 {
@ -13,7 +14,7 @@ namespace SHADE
  {
    logicalDevice = device;

-    pickedEID = 0;
+    pickedEID = MAX_EID;

    // Create command buffers
    for (auto& pool : cmdPools)
@ -30,7 +31,7 @@ namespace SHADE
  void SHMousePickSystem::Run(Handle<SHVkQueue> queue, uint32_t frameIndex) noexcept
  {
    // if input detected
-    if (SHInputManager::GetKey(SHInputManager::SH_KEYCODE::LEFT_CTRL) && SHInputManager::GetKeyUp(SHInputManager::SH_KEYCODE::LMB))
+    if (SHInputManager::GetKeyUp(SHInputManager::SH_KEYCODE::LMB))
    {
      afterCopyFence->Reset();

@ -52,17 +53,18 @@ namespace SHADE
      // wait for the copy to be done
      afterCopyFence->Wait(true, std::numeric_limits<uint64_t>::max());

-      int mouseX = 0, mouseY = 0;
-      SHInputManager::GetMouseWindowPosition(&mouseX, &mouseY);
+      pickedEID = imageDataDstBuffer->GetDataFromMappedPointer<uint32_t>(static_cast<uint32_t>(viewportMousePos.y) * entityIDAttachment->GetWidth() + static_cast<uint32_t>(viewportMousePos.x));

-      pickedEID = imageDataDstBuffer->GetDataFromMappedPointer<uint32_t>(mouseY * entityIDAttachment->GetWidth() + mouseX);
    }
  }

  void SHMousePickSystem::HandleResize(void) noexcept
  {
    if (afterCopyFence)
+    {
+      afterCopyFence->Reset();
      afterCopyFence.Free();
+    }

    if (imageDataDstBuffer)
      imageDataDstBuffer.Free();
@ -76,6 +78,11 @@ namespace SHADE
    imageDataDstBuffer = logicalDevice->CreateBuffer(bufferSize, nullptr, bufferSize, vk::BufferUsageFlagBits::eTransferDst, VMA_MEMORY_USAGE_AUTO, VMA_ALLOCATION_CREATE_MAPPED_BIT | VMA_ALLOCATION_CREATE_HOST_ACCESS_SEQUENTIAL_WRITE_BIT);
  }

+  void SHMousePickSystem::SetViewportMousePos(SHVec2 vpMousePos) noexcept
+  {
+    viewportMousePos = vpMousePos;
+  }
+
  EntityID SHMousePickSystem::GetPickedEntity(void) const noexcept
  {
    return pickedEID;
--- a/SHADE_Engine/src/Graphics/MiddleEnd/Interface/SHMousePickSystem.h
+++ b/SHADE_Engine/src/Graphics/MiddleEnd/Interface/SHMousePickSystem.h
@ -13,6 +13,7 @@ namespace SHADE
  class SHVkFence;
  class SHVkQueue;
  class SHVkBuffer;
+  class SHViewport;

  class SHMousePickSystem
  {
@ -33,6 +34,10 @@ namespace SHADE

    //! eid picked from screen
    EntityID pickedEID;
+
+    //! mouse position relative to the viewport window displaying the world
+    SHVec2 viewportMousePos;
+
  public:
    /*-----------------------------------------------------------------------*/
    /* PUBLIC MEMBER FUNCTIONS                                              */
@ -44,6 +49,8 @@ namespace SHADE
    /*-----------------------------------------------------------------------*/
    /* SETTERS AND GETTERS                                                   */
    /*-----------------------------------------------------------------------*/
+    void SetViewportMousePos (SHVec2 vpMousePos) noexcept;
+
    EntityID GetPickedEntity (void) const noexcept;

  };
--- a/SHADE_Engine/src/Graphics/MiddleEnd/Interface/SHPostOffscreenRenderSystem.cpp
+++ b/SHADE_Engine/src/Graphics/MiddleEnd/Interface/SHPostOffscreenRenderSystem.cpp
@ -56,14 +56,19 @@ namespace SHADE
    };

    // Create descriptor set layout
-    offscreenRenderDescSetLayout = logicalDevice->CreateDescriptorSetLayout(0, { imageBinding });
+    offscreenRenderDescSetLayout = logicalDevice->CreateDescriptorSetLayout(0, { imageBinding }, false);

    // Create descriptor set
    offscreenRenderDescSet = descriptorPool->Allocate({ offscreenRenderDescSetLayout }, { 1 });
    
+    HandleResize();
+  }
+
+  void SHPostOffscreenRenderSystem::HandleResize(void) noexcept
+  {
    std::vector combinedImageSampler
    {
-      std::make_tuple(renderGraphResource->GetImageView(), offscreenRenderSampler, vk::ImageLayout::eShaderReadOnlyOptimal),
+      std::make_tuple(offscreenRender->GetImageView(), offscreenRenderSampler, vk::ImageLayout::eShaderReadOnlyOptimal),
    };

    // Register the image view and sampler with the descriptor set. Now whenever rendering to the offscreen image is done, the descriptor set will see the change
--- a/SHADE_Engine/src/Graphics/MiddleEnd/Interface/SHPostOffscreenRenderSystem.h
+++ b/SHADE_Engine/src/Graphics/MiddleEnd/Interface/SHPostOffscreenRenderSystem.h
@ -24,6 +24,8 @@ namespace SHADE
    void Init (Handle<SHVkLogicalDevice> logicalDevice, Handle<SHRenderGraphResource> renderGraphResource, Handle<SHVkDescriptorPool> descriptorPool) noexcept;
    //void Run ()

+    void HandleResize (void) noexcept;
+
    Handle<SHVkDescriptorSetGroup> GetDescriptorSetGroup (void) const noexcept;
  };
 }
--- a/SHADE_Engine/src/Graphics/MiddleEnd/Interface/SHRenderer.cpp
+++ b/SHADE_Engine/src/Graphics/MiddleEnd/Interface/SHRenderer.cpp
@ -74,6 +74,8 @@ namespace SHADE
  }

  void SHRenderer::UpdateDataAndBind(Handle<SHVkCommandBuffer> cmdBuffer, uint32_t frameIndex) noexcept
+  {
+    if (camera)
    {
      cpuCameraData.viewProjectionMatrix = camera->GetViewProjectionMatrix();
      cameraBuffer->WriteToMemory(&cpuCameraData, sizeof(SHShaderCameraData), 0, cameraDataAlignedSize * frameIndex);
@ -82,6 +84,7 @@ namespace SHADE

      cmdBuffer->BindDescriptorSet(cameraDescriptorSet, vk::PipelineBindPoint::eGraphics, SHGraphicsConstants::DescriptorSetIndex::HIGH_FREQUENCY_GLOBALS, std::span{ dynamicOffsets.data(), 1 });
    }
+  }

  void SHRenderer::UpdateCameraDataToBuffer(void) noexcept
  {
--- a/SHADE_Engine/src/Graphics/MiddleEnd/Interface/SHViewport.cpp
+++ b/SHADE_Engine/src/Graphics/MiddleEnd/Interface/SHViewport.cpp
@ -85,4 +85,14 @@ namespace SHADE

  }

+  void SHViewport::SetX(float x) noexcept
+  {
+		viewport.x = x;
+  }
+
+  void SHViewport::SetY(float y) noexcept
+  {
+    viewport.y = y;
+  }
+
 }
--- a/SHADE_Engine/src/Graphics/MiddleEnd/Interface/SHViewport.h
+++ b/SHADE_Engine/src/Graphics/MiddleEnd/Interface/SHViewport.h
@ -67,6 +67,8 @@ namespace SHADE
 		/*-----------------------------------------------------------------------------*/
 		void SetWidth(float w) noexcept;
 		void SetHeight (float h) noexcept;
+		void SetX (float x) noexcept;
+		void SetY (float y) noexcept;

 		/*-----------------------------------------------------------------------------*/
 		/* Getters                                                                     */
--- a/SHADE_Engine/src/Graphics/MiddleEnd/PerFrame/SHRenderContext.cpp
+++ b/SHADE_Engine/src/Graphics/MiddleEnd/PerFrame/SHRenderContext.cpp
@ -52,7 +52,6 @@ namespace SHADE
      {
        frameData[i].cmdPoolHdls.push_back(logicalDeviceHdl->CreateCommandPool(params.cmdPoolQueueFamilyType, params.cmdPoolResetMode, params.cmdBufferTransient));
      }
-
    }

    // Initialize all the info.
--- a/SHADE_Engine/src/Graphics/RenderGraph/SHRenderGraph.cpp
+++ b/SHADE_Engine/src/Graphics/RenderGraph/SHRenderGraph.cpp
@ -57,7 +57,7 @@ namespace SHADE
      format = swapchainHdl->GetSurfaceFormatKHR().format;
    }

-    graphResources.try_emplace(resourceName, resourceManager.Create<SHRenderGraphResource>(logicalDeviceHdl, swapchainHdl, resourceName, typeFlags, format, w, h, levels, usageFlags, createFlags));
+    graphResources.try_emplace(resourceName, resourceManager->Create<SHRenderGraphResource>(logicalDeviceHdl, swapchainHdl, resourceName, typeFlags, format, w, h, levels, usageFlags, createFlags));
  }

  /***************************************************************************/
@ -102,11 +102,11 @@ namespace SHADE
          resourceAttLayouts[input.attachment] = input.layout;
      }

-      for (uint32_t i = 0; i < node->attachmentDescriptions.size(); ++i)
+      for (uint32_t j = 0; j < node->attachmentDescriptions.size(); ++j)
      {
-        auto& att = node->attachmentDescriptions[i];
+        auto& att = node->attachmentDescriptions[j];
        att.initialLayout = vk::ImageLayout::eUndefined;
-        att.finalLayout = resourceAttLayouts[i];
+        att.finalLayout = resourceAttLayouts[j];
      }
      ++i;
    }
@ -365,10 +365,9 @@ namespace SHADE
    , swapchainHdl{ }
    , nodes{}
    , graphResources{}
-    , resourceManager{}
-
+    , resourceManager{nullptr}
  {
-
+    resourceManager = std::make_shared<ResourceManager>();
  }

  SHRenderGraph::SHRenderGraph(SHRenderGraph&& rhs) noexcept
@ -457,7 +456,7 @@ namespace SHADE
      }
    }

-    nodes.emplace_back(resourceManager.Create<SHRenderGraphNode>(resourceManager, logicalDeviceHdl, swapchainHdl, std::move(descInitParams), std::move(predecessors), &graphResources));
+    nodes.emplace_back(resourceManager->Create<SHRenderGraphNode>(resourceManager, logicalDeviceHdl, swapchainHdl, std::move(descInitParams), std::move(predecessors), &graphResources));
    nodeIndexing.emplace(nodeName, static_cast<uint32_t>(nodes.size()) - 1u);
    return nodes.at(nodeIndexing[nodeName]);
  }
--- a/SHADE_Engine/src/Graphics/RenderGraph/SHRenderGraph.h
+++ b/SHADE_Engine/src/Graphics/RenderGraph/SHRenderGraph.h
@ -16,6 +16,7 @@

 #include <string>
 #include <map>
+#include <memory>

 namespace SHADE
 {
@ -70,7 +71,7 @@ namespace SHADE
    std::unordered_map<std::string, Handle<SHRenderGraphResource>> graphResources;

    //! Resource library for graph handles
-    ResourceManager resourceManager;
+    std::shared_ptr<ResourceManager> resourceManager;

  public:
    /*-----------------------------------------------------------------------*/
--- a/SHADE_Engine/src/Graphics/RenderGraph/SHRenderGraphNode.cpp
+++ b/SHADE_Engine/src/Graphics/RenderGraph/SHRenderGraphNode.cpp
@ -104,7 +104,7 @@ namespace SHADE

  */
  /***************************************************************************/
-  SHRenderGraphNode::SHRenderGraphNode(ResourceManager& rm, Handle<SHVkLogicalDevice> const& logicalDevice, Handle<SHVkSwapchain> const& swapchain, std::vector<SHAttachmentDescInitParams> attDescInitParams, std::vector<Handle<SHRenderGraphNode>> predecessors, std::unordered_map<std::string, Handle<SHRenderGraphResource>> const* resources) noexcept
+  SHRenderGraphNode::SHRenderGraphNode(std::shared_ptr<ResourceManager> rm, Handle<SHVkLogicalDevice> const& logicalDevice, Handle<SHVkSwapchain> const& swapchain, std::vector<SHAttachmentDescInitParams> attDescInitParams, std::vector<Handle<SHRenderGraphNode>> predecessors, std::unordered_map<std::string, Handle<SHRenderGraphResource>> const* resources) noexcept
    : logicalDeviceHdl{ logicalDevice }
    , renderpass{}
    , framebuffers{}
@ -162,7 +162,7 @@ namespace SHADE
  }

  SHRenderGraphNode::SHRenderGraphNode(SHRenderGraphNode&& rhs) noexcept
-    : resourceManager{ rhs.resourceManager }
+    : resourceManager{ std::move (rhs.resourceManager) }
    , logicalDeviceHdl{ rhs.logicalDeviceHdl }
    , renderpass{ rhs.renderpass }
    , framebuffers{ std::move(rhs.framebuffers) }
@ -177,6 +177,8 @@ namespace SHADE
    , ptrToResources{ rhs.ptrToResources }
    , pipelineLibrary{ std::move(rhs.pipelineLibrary) }
    , batcher{ std::move(rhs.batcher) }
+    , spDescs{ std::move(rhs.spDescs) }
+    , spDeps{ std::move(rhs.spDeps) }

  {
    rhs.renderpass = {};
@ -187,7 +189,7 @@ namespace SHADE
    if (&rhs == this)
      return *this;

-    resourceManager = rhs.resourceManager;
+    resourceManager = std::move(rhs.resourceManager);
    logicalDeviceHdl = rhs.logicalDeviceHdl;
    renderpass = rhs.renderpass;
    framebuffers = std::move(rhs.framebuffers);
@ -200,6 +202,9 @@ namespace SHADE
    ptrToResources = std::move(rhs.ptrToResources);
    pipelineLibrary = std::move(rhs.pipelineLibrary);
    batcher = std::move(rhs.batcher);
+    spDescs = std::move(rhs.spDescs);
+    spDeps = std::move(rhs.spDeps);
+

    rhs.renderpass = {};

@ -230,10 +235,10 @@ namespace SHADE
    }

    // Add subpass to container and create mapping for it
-    subpasses.emplace_back(resourceManager.Create<SHSubpass>(resourceManager, GetHandle(), subpasses.size(), &resourceAttachmentMapping, ptrToResources));
+    subpasses.emplace_back(resourceManager->Create<SHSubpass>(GetHandle(), subpasses.size(), &resourceAttachmentMapping, ptrToResources));
    subpassIndexing.try_emplace(subpassName, static_cast<uint32_t>(subpasses.size()) - 1u);
    Handle<SHSubpass> subpass = subpasses.back();
-    subpass->Init(resourceManager);
+    subpass->Init(*resourceManager);

    // Register the SuperBatch
    batcher.RegisterSuperBatch(subpass->GetSuperBatch());
--- a/SHADE_Engine/src/Graphics/RenderGraph/SHRenderGraphNode.h
+++ b/SHADE_Engine/src/Graphics/RenderGraph/SHRenderGraphNode.h
@ -26,7 +26,7 @@ namespace SHADE
    /*-----------------------------------------------------------------------*/
    /* PRIVATE MEMBER VARIABLES                                              */
    /*-----------------------------------------------------------------------*/
-    ResourceManager& resourceManager;
+    std::shared_ptr<ResourceManager> resourceManager;

    //! For Vulkan object creation
    Handle<SHVkLogicalDevice> logicalDeviceHdl;
@ -88,7 +88,7 @@ namespace SHADE
    /*-----------------------------------------------------------------------*/
    /* CTORS AND DTORS                                                       */
    /*-----------------------------------------------------------------------*/
-    SHRenderGraphNode(ResourceManager& rm, Handle<SHVkLogicalDevice> const& logicalDevice, Handle<SHVkSwapchain> const& swapchain, std::vector<SHAttachmentDescInitParams> attDescInitParams, std::vector<Handle<SHRenderGraphNode>> predecessors, std::unordered_map<std::string, Handle<SHRenderGraphResource>> const* resources) noexcept;
+    SHRenderGraphNode(std::shared_ptr<ResourceManager> rm, Handle<SHVkLogicalDevice> const& logicalDevice, Handle<SHVkSwapchain> const& swapchain, std::vector<SHAttachmentDescInitParams> attDescInitParams, std::vector<Handle<SHRenderGraphNode>> predecessors, std::unordered_map<std::string, Handle<SHRenderGraphResource>> const* resources) noexcept;
    SHRenderGraphNode(SHRenderGraphNode&& rhs) noexcept;
    SHRenderGraphNode& operator= (SHRenderGraphNode&& rhs) noexcept;

--- a/SHADE_Engine/src/Graphics/RenderGraph/SHSubpass.cpp
+++ b/SHADE_Engine/src/Graphics/RenderGraph/SHSubpass.cpp
@ -23,7 +23,7 @@ namespace SHADE

  */
  /***************************************************************************/
-  SHSubpass::SHSubpass(ResourceManager& rm, Handle<SHRenderGraphNode> const& parent, uint32_t index, std::unordered_map<uint64_t, uint32_t> const* mapping, std::unordered_map<std::string, Handle<SHRenderGraphResource>> const* resources) noexcept
+  SHSubpass::SHSubpass(Handle<SHRenderGraphNode> const& parent, uint32_t index, std::unordered_map<uint64_t, uint32_t> const* mapping, std::unordered_map<std::string, Handle<SHRenderGraphResource>> const* resources) noexcept
    : resourceAttachmentMapping{ mapping }
    , ptrToResources{ resources }
    , parentNode{ parent }
@ -55,6 +55,8 @@ namespace SHADE
    , inputReferences{ std::move(rhs.inputReferences) }
    , resourceAttachmentMapping{ rhs.resourceAttachmentMapping }
    , ptrToResources{ rhs.ptrToResources }
+    , descriptorSetLayout{ rhs.descriptorSetLayout }
+    , exteriorDrawCalls{ std::move (rhs.exteriorDrawCalls) }
  {

  }
@ -83,6 +85,8 @@ namespace SHADE
    inputReferences = std::move(rhs.inputReferences);
    resourceAttachmentMapping = rhs.resourceAttachmentMapping;
    ptrToResources = rhs.ptrToResources;
+    descriptorSetLayout = rhs.descriptorSetLayout;
+    exteriorDrawCalls = std::move(rhs.exteriorDrawCalls);

    return *this;
  }
--- a/SHADE_Engine/src/Graphics/RenderGraph/SHSubpass.h
+++ b/SHADE_Engine/src/Graphics/RenderGraph/SHSubpass.h
@ -62,7 +62,7 @@ namespace SHADE
    /*-----------------------------------------------------------------------*/
    /* CTORS AND DTORS                                                       */
    /*-----------------------------------------------------------------------*/
-    SHSubpass(ResourceManager& rm, Handle<SHRenderGraphNode> const& parent, uint32_t index, std::unordered_map<uint64_t, uint32_t> const* mapping, std::unordered_map<std::string, Handle<SHRenderGraphResource>> const* ptrToResources) noexcept;
+    SHSubpass(Handle<SHRenderGraphNode> const& parent, uint32_t index, std::unordered_map<uint64_t, uint32_t> const* mapping, std::unordered_map<std::string, Handle<SHRenderGraphResource>> const* ptrToResources) noexcept;
    SHSubpass(SHSubpass&& rhs) noexcept;
    SHSubpass& operator=(SHSubpass&& rhs) noexcept;

--- a/SHADE_Engine/src/Graphics/Renderpass/SHVkRenderpass.cpp
+++ b/SHADE_Engine/src/Graphics/Renderpass/SHVkRenderpass.cpp
@ -253,6 +253,7 @@ namespace SHADE

  SHVkRenderpass::~SHVkRenderpass(void) noexcept
  {
+    if (vkRenderpass)
      logicalDeviceHdl->GetVkLogicalDevice().destroyRenderPass(vkRenderpass, nullptr);
  }

--- a/SHADE_Engine/src/Resource/SparseSet.h
+++ b/SHADE_Engine/src/Resource/SparseSet.h
@ -59,9 +59,9 @@ namespace SHADE
        SparseSet();
        ~SparseSet() = default;

-        // Disallow moving or copying
-        SparseSet(const SparseSet&) = delete;
-        SparseSet(SparseSet&&) = delete;
+        //// Disallow moving or copying
+        //SparseSet(const SparseSet&) = delete;
+        //SparseSet(SparseSet&&) = delete;

        /*-----------------------------------------------------------------------------*/
        /* Usage Functions                                                             */