Restructuring renderpasses

src/Engine/Window/CMakeLists.txt

@@ -1,13 +1,11 @@
 target_sources(SeeleEngine
     PRIVATE
+        Frame.h
+        Frame.cpp
         InspectorView.h
         InspectorView.cpp
-        RenderPath.h
-        RenderPath.cpp
         SceneView.h
         SceneView.cpp
-        SceneRenderPath.h
-        SceneRenderPath.cpp
         View.h
         View.cpp
         Window.cpp

src/Engine/Window/InspectorView.cpp

@@ -8,8 +8,7 @@ InspectorView::InspectorView(Gfx::PGraphics graphics, PWindow window, const View
 {
     renderGraph = new RenderGraph();
     Gfx::PRenderTargetAttachment attachment = new Gfx::SwapchainAttachment(window->getGfxHandle());
-    uiPass = new UIPass(renderGraph, graphics, viewport, attachment);
-    renderGraph->addRenderPass(uiPass);
+    renderGraph->addRenderPass(new UIPass(renderGraph, graphics, viewport, attachment));
     renderGraph->setup();
 }
 
@@ -19,17 +18,14 @@ InspectorView::~InspectorView()
 
 void InspectorView::beginFrame() 
 {
-    uiPass->beginFrame();
 }
 
 void InspectorView::render() 
 {
-    uiPass->render();
 }
 
 void InspectorView::endFrame() 
 {
-    uiPass->endFrame();
 }
 
 void InspectorView::keyCallback(KeyCode code, InputAction action, KeyModifier modifier) 

src/Engine/Window/InspectorView.h

@@ -2,10 +2,18 @@
 #include "View.h"
 #include "Graphics/RenderPass/RenderGraph.h"
 #include "Graphics/RenderPass/UIPass.h"
+#include "UI/Elements/Panel.h"
 
 namespace Seele
 {
 DECLARE_REF(Actor)
+class InspectorViewFrame : public ViewFrame
+{
+public:
+protected:
+    const UI::RenderHierarchy hierarchy;
+};
+
 class InspectorView : public View
 {
 public:
@@ -17,10 +25,8 @@ public:
     void selectActor();
 
 protected:
-    Array<UI::PElement> rootElements;
-    PUIPass uiPass;
+    UI::PPanel rootPanel;
     PActor selectedActor;
-    PRenderGraph renderGraph;
     
 	virtual void keyCallback(KeyCode code, InputAction action, KeyModifier modifier) override;
 	virtual void mouseMoveCallback(double xPos, double yPos) override;

src/Engine/Window/RenderPath.cpp

@@ -1,18 +0,0 @@
-#include "RenderPath.h"
-#include "Graphics/GraphicsResources.h"
-#include "Material/MaterialAsset.h"
-
-Seele::RenderPath::RenderPath(Gfx::PGraphics graphics, Gfx::PViewport target)
-	: graphics(graphics), target(target)
-{
-}
-
-Seele::RenderPath::~RenderPath()
-{
-}
-
-void Seele::RenderPath::applyArea(URect newArea)
-{
-	target->resize(newArea.size.x, newArea.size.y);
-	target->move(newArea.offset.x, newArea.offset.y);
-}

src/Engine/Window/RenderPath.h

@@ -1,22 +0,0 @@
-#pragma once
-#include "Graphics/Graphics.h"
-namespace Seele
-{
-//A renderpath is a general Renderer for a view.
-class RenderPath
-{
-public:
-	RenderPath(Gfx::PGraphics graphics, Gfx::PViewport target);
-	virtual ~RenderPath();
-	virtual void applyArea(URect area);
-	virtual void init() = 0;
-	virtual void beginFrame() = 0;
-	virtual void render() = 0;
-	virtual void endFrame() = 0;
-
-protected:
-	Gfx::PGraphics graphics;
-	Gfx::PViewport target;
-};
-DEFINE_REF(RenderPath)
-} // namespace Seele

src/Engine/Window/SceneRenderPath.cpp

@@ -1,56 +0,0 @@
-#include "SceneRenderPath.h"
-#include "Scene/Scene.h"
-#include "Material/Material.h"
-#include "Asset/AssetRegistry.h"
-#include "Graphics/RenderPass/RenderGraph.h"
-
-using namespace Seele;
-
-SceneRenderPath::SceneRenderPath(PScene scene, Gfx::PGraphics graphics, Gfx::PViewport target, PCameraActor source)
-	: RenderPath(graphics, target)
-	, scene(scene)
-{
-	renderGraph = new RenderGraph();
-	depthPrepass = new DepthPrepass(renderGraph, scene, graphics, target, source);
-	lightCullingPass = new LightCullingPass(renderGraph, scene, graphics, target, source);
-	basePass = new BasePass(renderGraph, scene, graphics, target, source);
-	renderGraph->addRenderPass(depthPrepass);
-	renderGraph->addRenderPass(lightCullingPass);
-	renderGraph->addRenderPass(basePass);
-	renderGraph->setup();
-}
-
-SceneRenderPath::~SceneRenderPath()
-{
-}
-
-void SceneRenderPath::setTargetScene(PScene newScene)
-{
-	scene = newScene;
-}
-
-void SceneRenderPath::init() 
-{
-    
-}
-
-void SceneRenderPath::beginFrame() 
-{
-	depthPrepass->beginFrame();
-	lightCullingPass->beginFrame();
-	basePass->beginFrame();
-}
-
-void SceneRenderPath::render() 
-{
-    depthPrepass->render();
-	lightCullingPass->render();
-	basePass->render();
-}
-
-void SceneRenderPath::endFrame() 
-{
-    depthPrepass->endFrame();
-	lightCullingPass->endFrame();
-	basePass->endFrame();
-}

src/Engine/Window/SceneRenderPath.h

@@ -1,29 +0,0 @@
-#pragma once
-#include "RenderPath.h"
-#include "Graphics/RenderPass/DepthPrepass.h"
-#include "Graphics/RenderPass/LightCullingPass.h"
-#include "Graphics/RenderPass/BasePass.h"
-
-namespace Seele
-{
-DECLARE_REF(Scene)
-DECLARE_REF(CameraActor)
-class SceneRenderPath : public RenderPath
-{
-public:
-	SceneRenderPath(PScene scene, Gfx::PGraphics graphics, Gfx::PViewport target, PCameraActor source);
-	virtual ~SceneRenderPath();
-	void setTargetScene(PScene scene);
-	virtual void init();
-	virtual void beginFrame();
-	virtual void render();
-	virtual void endFrame();
-
-protected:
-	PScene scene;
-	PRenderGraph renderGraph;
-	PDepthPrepass depthPrepass;
-	PLightCullingPass lightCullingPass;
-	PBasePass basePass;
-};
-} // namespace Seele

src/Engine/Window/SceneView.cpp

@@ -1,9 +1,11 @@
 #include "SceneView.h"
-#include "SceneRenderPath.h"
 #include "Scene/Scene.h"
 #include "Window.h"
 #include "Scene/Actor/CameraActor.h"
 #include "Scene/Components/CameraComponent.h"
+#include "Graphics/RenderPass/DepthPrepass.h"
+#include "Graphics/RenderPass/LightCullingPass.h"
+#include "Graphics/RenderPass/BasePass.h"
 
 using namespace Seele;
 
@@ -13,7 +15,11 @@ Seele::SceneView::SceneView(Gfx::PGraphics graphics, PWindow owner, const Viewpo
 	scene = new Scene(graphics);
 	activeCamera = new CameraActor();
 	scene->addActor(activeCamera);
-	renderer = new SceneRenderPath(scene, graphics, viewport, activeCamera);
+	renderGraph = new RenderGraph();
+	renderGraph->addRenderPass(new DepthPrepass(renderGraph, scene, graphics, viewport, activeCamera));
+	renderGraph->addRenderPass(new LightCullingPass(renderGraph, scene, graphics, viewport, activeCamera));
+	renderGraph->addRenderPass(new BasePass(renderGraph, scene, graphics, viewport, activeCamera));
+	renderGraph->setup();
 }
 
 Seele::SceneView::~SceneView()
@@ -23,7 +29,7 @@ Seele::SceneView::~SceneView()
 void SceneView::beginFrame() 
 {
 	View::beginFrame();
-	scene->tick(Gfx::currentFrameDelta);//TODO: update in separate thread
+	scene->tick(Gfx::currentFrameDelta);
 }
 
 void SceneView::keyCallback(KeyCode code, InputAction action, KeyModifier)

src/Engine/Window/SceneView.h

@@ -4,6 +4,15 @@ namespace Seele
 {
 DECLARE_REF(Scene)
 DECLARE_REF(CameraActor)
+
+class SceneViewFrame : public ViewFrame
+{
+public:
+protected:
+	const PScene scene;
+};
+DEFINE_REF(SceneViewFrame)
+
 class SceneView : public View
 {
 public:
@@ -14,6 +23,7 @@ public:
 private:
 	PScene scene;
 	PCameraActor activeCamera;
+
 	virtual void keyCallback(KeyCode code, InputAction action, KeyModifier modifier) override;
 	virtual void mouseMoveCallback(double xPos, double yPos) override;
 	virtual void mouseButtonCallback(MouseButton button, InputAction action, KeyModifier modifier) override;

src/Engine/Window/View.cpp

@@ -1,6 +1,6 @@
-#pragma once
 #include "View.h"
 #include "Window.h"
+#include "Graphics/Graphics.h"
 
 Seele::View::View(Gfx::PGraphics graphics, PWindow window, const ViewportCreateInfo &viewportInfo)
 	: graphics(graphics), owner(window)
@@ -14,22 +14,20 @@ Seele::View::~View()
 
 void Seele::View::beginFrame()
 {
-	renderer->beginFrame();
 }
 
 void Seele::View::render()
 {
-	renderer->render();
 }
 
 void Seele::View::endFrame()
 {
-	renderer->endFrame();
+
 }
 
 void Seele::View::applyArea(URect area)
 {
-	renderer->applyArea(area);
+
 }
 
 void View::setFocused() 

src/Engine/Window/View.h

@@ -1,9 +1,19 @@
 #pragma once
-#include "RenderPath.h"
+#include "Graphics/RenderPass/RenderGraph.h"
+
 namespace Seele
 {
 DECLARE_REF(Window)
-// A view is a part of the window, which can be anything from a viewport to an inspector
+
+// A ViewFrame is the render relevant data of a View
+class ViewFrame
+{
+public:
+protected:
+};
+DEFINE_REF(ViewFrame)
+
+// A view is a part of the window, which can be anything from a scene viewport to an inspector
 class View
 {
 public:
@@ -16,10 +26,11 @@ public:
 	void setFocused();
 
 protected:
+	UPViewFrame currentFrame;
 	Gfx::PGraphics graphics;
 	Gfx::PViewport viewport;
 	PWindow owner;
-	PRenderPath renderer;
+	PRenderGraph renderGraph;
 
 	virtual void keyCallback(KeyCode code, InputAction action, KeyModifier modifier) = 0;
 	virtual void mouseMoveCallback(double xPos, double yPos) = 0;

src/Engine/Window/Window.cpp

@@ -1,54 +1,51 @@
 #include "Window.h"
 #include <functional>
 
-Seele::Window::Window(Gfx::PWindow handle)
+using namespace Seele;
+
+Window::Window(Gfx::PWindow handle)
     : gfxHandle(handle)
 {
 }
 
-Seele::Window::~Window()
+Window::~Window()
 {
 }
 
-void Seele::Window::addView(PView view)
+void Window::addView(PView view)
 {
-    viewports.add(view);
+    WindowView* windowView = new WindowView();
+    windowView->view = view;
+    windowView->renderGraph = view->renderGraph;
+    windowView->worker = std::thread(&Window::viewWorker, this, windowView);
+    views.add(windowView); 
 }
 
-void Seele::Window::beginFrame()
+void Window::render() 
 {
     gfxHandle->beginFrame();
-    for (auto view : viewports)
+    for(auto& windowView : views)
     {
-        view->beginFrame();
+        UPViewFrame frame;
+        {
+            std::lock_guard lock(windowView->workerMutex);
+            frame = std::move(windowView->currentFrame);
+        }
+        if(frame != nullptr)
+        {
+            windowView->renderGraph->render(std::move(frame));
+        }
     }
-}
-
-void Seele::Window::render()
-{
-    for (auto view : viewports)
-    {
-        view->render();
-    }
-}
-
-void Seele::Window::endFrame()
-{
     gfxHandle->endFrame();
-    for (auto view : viewports)
-    {
-        view->endFrame();
-    }
 }
 
-Gfx::PWindow Seele::Window::getGfxHandle()
+Gfx::PWindow Window::getGfxHandle()
 {
     return gfxHandle;
 }
     
 void Window::setFocused(PView view) 
 {
-    focusedView = view;
     auto keyFunction = std::bind(&View::keyCallback, view.getHandle(), std::placeholders::_1, std::placeholders::_2, std::placeholders::_3);
     auto mouseMoveFunction = std::bind(&View::mouseMoveCallback, view.getHandle(), std::placeholders::_1, std::placeholders::_2);
     auto mouseButtonFunction = std::bind(&View::mouseButtonCallback, view.getHandle(), std::placeholders::_1, std::placeholders::_2, std::placeholders::_3);
@@ -60,3 +57,16 @@ void Window::setFocused(PView view)
     gfxHandle->setScrollCallback(scrollFunction);
     gfxHandle->setFileCallback(fileFunction);
 }
+
+
+void Window::viewWorker(WindowView* windowView) 
+{
+    while(true)
+    {
+        windowView->view->beginFrame();
+        windowView->view->render();
+        windowView->view->endFrame();
+        std::lock_guard lock(windowView->workerMutex);
+        windowView->currentFrame = std::move(windowView->view->currentFrame);
+    }
+}

src/Engine/Window/Window.h

@@ -4,6 +4,15 @@
 
 namespace Seele
 {
+struct WindowView
+{
+    PView view;
+    PRenderGraph renderGraph;
+    UPViewFrame currentFrame;
+    std::thread worker;
+    std::mutex workerMutex;
+};
+DEFINE_REF(WindowView)
 // The logical window, with the graphics proxy
 class Window
 {
@@ -11,16 +20,15 @@ public:
     Window(Gfx::PWindow handle);
     ~Window();
     void addView(PView view);
-    void beginFrame();
     void render();
-    void endFrame();
     Gfx::PWindow getGfxHandle();
     void setFocused(PView view);
 
-private:
-    Array<PView> viewports;
-    PView focusedView;
+protected:
+    Array<WindowView*> views;
     Gfx::PWindow gfxHandle;
+
+    void viewWorker(WindowView* view);
 };
 DEFINE_REF(Window)
 } // namespace Seele

src/Engine/Window/WindowManager.cpp

@@ -1,9 +1,11 @@
 #include "WindowManager.h"
 #include "Graphics/Vulkan/VulkanGraphics.h"
 
+using namespace Seele;
+
 Gfx::PGraphics WindowManager::graphics;
 
-Seele::WindowManager::WindowManager()
+WindowManager::WindowManager()
 {
 	graphics = new Vulkan::Graphics();
 	GraphicsInitializer initializer;
@@ -22,11 +24,11 @@ Seele::WindowManager::WindowManager()
 	Gfx::PUniformBuffer testUniform = graphics->createUniformBuffer(uniformInitializer);
 }
 
-Seele::WindowManager::~WindowManager()
+WindowManager::~WindowManager()
 {
 }
 
-PWindow Seele::WindowManager::addWindow(const WindowCreateInfo &createInfo)
+PWindow WindowManager::addWindow(const WindowCreateInfo &createInfo)
 {
 	Gfx::PWindow handle = graphics->createWindow(createInfo);
 	PWindow window = new Window(handle);
@@ -34,14 +36,6 @@ PWindow Seele::WindowManager::addWindow(const WindowCreateInfo &createInfo)
 	return window;
 }
 
-void Seele::WindowManager::beginFrame()
-{
-	for (auto window : windows)
-	{
-		window->beginFrame();
-	}
-}
-
 void WindowManager::render() 
 {
 	for(auto window : windows)
@@ -50,10 +44,3 @@ void WindowManager::render()
 	}	
 }
 
-void Seele::WindowManager::endFrame()
-{
-	for (auto window : windows)
-	{
-		window->endFrame();
-	}
-}

src/Engine/Window/WindowManager.h

@@ -12,9 +12,7 @@ public:
 	WindowManager();
 	~WindowManager();
 	PWindow addWindow(const WindowCreateInfo &createInfo);
-	void beginFrame();
 	void render();
-	void endFrame();
 	static Gfx::PGraphics getGraphics()
 	{
 		return graphics;