From 328844c0fe6cfbc523f5b77fc8b030e998bcc1ab Mon Sep 17 00:00:00 2001
From: Tobias Frisch <tfrisch@uni-koblenz.de>
Date: Tue, 31 Aug 2021 12:32:07 +0200
Subject: [PATCH] [#89] Fixed copy mess with pointers

Signed-off-by: Tobias Frisch <tfrisch@uni-koblenz.de>
---
 config/Sources.cmake                       |  4 +--
 include/vkcv/Core.hpp                      | 10 +++----
 include/vkcv/Window.hpp                    | 24 ++++++++++-----
 projects/first_triangle/src/main.cpp       |  4 +--
 src/vkcv/Core.cpp                          | 11 ++++---
 src/vkcv/SwapchainManager.cpp              | 16 +++++-----
 {include => src}/vkcv/SwapchainManager.hpp | 11 +++----
 src/vkcv/Window.cpp                        | 24 +++++++++++----
 src/vkcv/WindowManager.cpp                 | 34 ++++++++++------------
 {include => src}/vkcv/WindowManager.hpp    | 16 ++++------
 10 files changed, 83 insertions(+), 71 deletions(-)
 rename {include => src}/vkcv/SwapchainManager.hpp (79%)
 rename {include => src}/vkcv/WindowManager.hpp (80%)

diff --git a/config/Sources.cmake b/config/Sources.cmake
index 3c2e903a..7f94800e 100644
--- a/config/Sources.cmake
+++ b/config/Sources.cmake
@@ -82,10 +82,10 @@ set(vkcv_sources
 		${vkcv_source}/vkcv/SamplerManager.hpp
 		${vkcv_source}/vkcv/SamplerManager.cpp
 
-		${vkcv_include}/vkcv/WindowManager.hpp
+		${vkcv_source}/vkcv/WindowManager.hpp
 		${vkcv_source}/vkcv/WindowManager.cpp
 
-		${vkcv_include}/vkcv/SwapchainManager.hpp
+		${vkcv_source}/vkcv/SwapchainManager.hpp
 		${vkcv_source}/vkcv/SwapchainManager.cpp
         
         ${vkcv_include}/vkcv/DescriptorWrites.hpp
diff --git a/include/vkcv/Core.hpp b/include/vkcv/Core.hpp
index f9d52110..5a8e451b 100644
--- a/include/vkcv/Core.hpp
+++ b/include/vkcv/Core.hpp
@@ -24,8 +24,8 @@
 #include "Event.hpp"
 #include "DrawcallRecording.hpp"
 #include "CommandRecordingFunctionTypes.hpp"
-#include "WindowManager.hpp"
-#include "SwapchainManager.hpp"
+#include "../../src/vkcv/WindowManager.hpp"
+#include "../../src/vkcv/SwapchainManager.hpp"
 
 
 namespace vkcv
@@ -65,9 +65,6 @@ namespace vkcv
 
         Context m_Context;
 
-		SwapchainHandle 				m_swapchainHandle;
-        WindowHandle					m_windowHandle;
-
         std::unique_ptr<PassManager>            m_PassManager;
         std::unique_ptr<PipelineManager>        m_PipelineManager;
         std::unique_ptr<DescriptorManager>      m_DescriptorManager;
@@ -77,6 +74,9 @@ namespace vkcv
         std::unique_ptr<CommandStreamManager>   m_CommandStreamManager;
 		std::unique_ptr<WindowManager>          m_WindowManager;
 		std::unique_ptr<SwapchainManager>       m_SwapchainManager;
+	
+		SwapchainHandle 				m_swapchainHandle;
+		WindowHandle					m_windowHandle;
 
 		CommandResources    m_CommandResources;
 		SyncResources       m_SyncResources;
diff --git a/include/vkcv/Window.hpp b/include/vkcv/Window.hpp
index 65627ecd..952a0876 100644
--- a/include/vkcv/Window.hpp
+++ b/include/vkcv/Window.hpp
@@ -14,11 +14,13 @@ namespace vkcv {
     class Window {
 		friend class WindowManager;
 		friend class SwapchainManager;
+		
 	private:
     	std::string m_title;
     	bool m_resizable;
 		GLFWwindow *m_window;
 		SwapchainHandle m_swapchainHandle;
+		bool m_shouldClose;
 
     public:
     	/**
@@ -34,22 +36,22 @@ namespace vkcv {
          * @param[in] height height of the window (optional)
          * @param[in] resizable resize ability of the window (optional)
          */
-    	Window(const char* title, int width = -1, int height = -1, bool resizable = false);
-    	
-    	/**
+    	explicit Window(const char* title, int width = -1, int height = -1, bool resizable = false);
+	
+		/**
 		* Copy-constructor of #Window
 		*
 		* @param other Other instance of #Window
 		*/
-    	Window(const Window& other);
-    	
-    	/**
+		Window(const Window& other) = delete;
+	
+		/**
 		* Copy-operator of #Window
 		*
 		* @param other Other instance of #Window
 		* @return Reference to itself
 		*/
-    	Window &operator=(const Window &other);
+		Window &operator=(const Window &other) = delete;
         
         /**
          * checks if the window is still open, or the close event was called
@@ -65,6 +67,12 @@ namespace vkcv {
 		 * @return
 		 */
 		static Window& getFocusedWindow();
+		
+		/**
+		 *
+		 * @return
+		 */
+		static bool hasOpenWindow();
 
         /**
          * polls all events on the GLFWwindow
@@ -125,7 +133,7 @@ namespace vkcv {
         /**
          * destroys the window
          */
-		void destroyWindow();
+		//void destroyWindow();
 
         /**
          * gets the windows framebuffer size
diff --git a/projects/first_triangle/src/main.cpp b/projects/first_triangle/src/main.cpp
index c8b69170..a95ad05c 100644
--- a/projects/first_triangle/src/main.cpp
+++ b/projects/first_triangle/src/main.cpp
@@ -18,7 +18,7 @@ int main(int argc, const char** argv) {
 		{ VK_KHR_SWAPCHAIN_EXTENSION_NAME }
 	);
 
-	vkcv::Window window = core.getWindow();
+	vkcv::Window& window = core.getWindow();
 
 	auto triangleIndexBuffer = core.createBuffer<uint16_t>(vkcv::BufferType::INDEX, 3, vkcv::BufferMemoryType::DEVICE_LOCAL);
 	uint16_t indices[3] = { 0, 1, 2 };
@@ -92,7 +92,7 @@ int main(int argc, const char** argv) {
     cameraManager.getCamera(camIndex1).setPosition(glm::vec3(0.0f, 0.0f, 0.0f));
     cameraManager.getCamera(camIndex1).setCenter(glm::vec3(0.0f, 0.0f, -1.0f));
 
-	while (vkcv::WindowManager::hasOpenWindow())
+	while (vkcv::Window::hasOpenWindow())
 	{
         vkcv::Window::pollEvents();
 
diff --git a/src/vkcv/Core.cpp b/src/vkcv/Core.cpp
index 886a20b1..75647526 100644
--- a/src/vkcv/Core.cpp
+++ b/src/vkcv/Core.cpp
@@ -13,7 +13,7 @@
 #include "SamplerManager.hpp"
 #include "ImageManager.hpp"
 #include "DescriptorManager.hpp"
-#include "vkcv/WindowManager.hpp"
+#include "WindowManager.hpp"
 #include "ImageLayoutTransitions.hpp"
 #include "vkcv/CommandStreamManager.hpp"
 #include <cmath>
@@ -57,12 +57,12 @@ namespace vkcv
             m_PassManager{std::make_unique<PassManager>(m_Context.m_Device)},
             m_PipelineManager{std::make_unique<PipelineManager>(m_Context.m_Device)},
             m_DescriptorManager(std::make_unique<DescriptorManager>(m_Context.m_Device)),
-			m_WindowManager(std::make_unique<WindowManager>()),
-			m_SwapchainManager(std::make_unique<SwapchainManager>()),
             m_BufferManager{std::unique_ptr<BufferManager>(new BufferManager())},
             m_SamplerManager(std::unique_ptr<SamplerManager>(new SamplerManager(m_Context.m_Device))),
             m_ImageManager{std::unique_ptr<ImageManager>(new ImageManager(*m_BufferManager))},
             m_CommandStreamManager{std::unique_ptr<CommandStreamManager>(new CommandStreamManager)},
+			m_WindowManager(std::make_unique<WindowManager>()),
+			m_SwapchainManager(std::make_unique<SwapchainManager>()),
             m_CommandResources(commandResources),
             m_SyncResources(syncResources)
 	{
@@ -73,7 +73,7 @@ namespace vkcv
 		m_ImageManager->m_core = this;
 
 		m_windowHandle = m_WindowManager->createWindow(*m_SwapchainManager ,"First Mesh", 800, 600, false);
-		m_swapchainHandle = m_SwapchainManager->createSwapchain(m_WindowManager->getWindow(m_windowHandle));
+		m_swapchainHandle = m_WindowManager->getWindow(m_windowHandle).getSwapchainHandle();
 		setSwapchainImages( m_swapchainHandle );
 	}
 
@@ -676,8 +676,7 @@ namespace vkcv
 	}
 
 	Swapchain Core::getSwapchainOfCurrentWindow() {
-		SwapchainHandle swapchainHandle = m_WindowManager->getFocusedWindow().getSwapchainHandle();
-		return m_SwapchainManager->getSwapchain(swapchainHandle);
+		return m_SwapchainManager->getSwapchain(Window::getFocusedWindow().getSwapchainHandle());
 	}
 
 	Swapchain Core::getSwapchainOfHandle(const SwapchainHandle handle) {
diff --git a/src/vkcv/SwapchainManager.cpp b/src/vkcv/SwapchainManager.cpp
index 7bf3518f..0caea9fd 100644
--- a/src/vkcv/SwapchainManager.cpp
+++ b/src/vkcv/SwapchainManager.cpp
@@ -1,7 +1,6 @@
-#include <vkcv/SwapchainManager.hpp>
+#include "SwapchainManager.hpp"
 
 namespace vkcv {
-	static std::vector<Swapchain> m_swapchains;
 
 	SwapchainManager::SwapchainManager() noexcept {
 	}
@@ -24,7 +23,7 @@ namespace vkcv {
 		return swapchainHandle;
 	}
 
-	Swapchain &SwapchainManager::getSwapchain(const SwapchainHandle handle) const {
+	Swapchain& SwapchainManager::getSwapchain(const SwapchainHandle& handle) {
 		return m_swapchains[handle.getId()];
 	}
 
@@ -38,23 +37,24 @@ namespace vkcv {
 
 		if (swapchain.m_Swapchain) {
 			m_context->getDevice().destroySwapchainKHR(swapchain.m_Swapchain);
+			swapchain.m_Swapchain = nullptr;
 		}
+		
 		if (swapchain.m_Surface.handle) {
 			m_context->getInstance().destroySurfaceKHR(swapchain.m_Surface.handle);
+			swapchain.m_Surface.handle = nullptr;
 		}
-		swapchain.m_Swapchain = nullptr;
-		swapchain.m_Surface.handle = nullptr;
 	}
 
-	void SwapchainManager::signalRecreation(const SwapchainHandle handle) {
+	void SwapchainManager::signalRecreation(const SwapchainHandle& handle) {
 		m_swapchains[handle.getId()].signalSwapchainRecreation();
 	}
 
-	std::vector<vk::Image> SwapchainManager::getSwapchainImages(const SwapchainHandle handle) {
+	std::vector<vk::Image> SwapchainManager::getSwapchainImages(const SwapchainHandle& handle) {
 		return m_context->getDevice().getSwapchainImagesKHR(m_swapchains[handle.getId()].getSwapchain());
 	}
 
-	std::vector<vk::ImageView> SwapchainManager::createSwapchainImageViews(SwapchainHandle handle) {
+	std::vector<vk::ImageView> SwapchainManager::createSwapchainImageViews(SwapchainHandle& handle) {
 		std::vector<vk::Image> images = getSwapchainImages(handle);
 		Swapchain &swapchain = m_swapchains[handle.getId()];
 
diff --git a/include/vkcv/SwapchainManager.hpp b/src/vkcv/SwapchainManager.hpp
similarity index 79%
rename from include/vkcv/SwapchainManager.hpp
rename to src/vkcv/SwapchainManager.hpp
index 087f4ba9..703314cd 100644
--- a/include/vkcv/SwapchainManager.hpp
+++ b/src/vkcv/SwapchainManager.hpp
@@ -3,7 +3,7 @@
 #include <vector>
 #include <GLFW/glfw3.h>
 
-#include "vkcv/WindowManager.hpp"
+#include "WindowManager.hpp"
 #include "vkcv/Swapchain.hpp"
 #include "vkcv/Handles.hpp"
 
@@ -16,6 +16,7 @@ namespace vkcv {
 		friend class WindowManager;
 
 	private:
+		std::vector<Swapchain> m_swapchains;
 
 		Context *m_context;
 
@@ -37,12 +38,12 @@ namespace vkcv {
 		SwapchainHandle createSwapchain(Window &window);
 
 		[[nodiscard]]
-		Swapchain &getSwapchain(const SwapchainHandle handle) const;
+		Swapchain &getSwapchain(const SwapchainHandle& handle);
 
-		void signalRecreation(const SwapchainHandle handle);
+		void signalRecreation(const SwapchainHandle& handle);
 
-		std::vector<vk::Image> getSwapchainImages(const SwapchainHandle handle);
+		std::vector<vk::Image> getSwapchainImages(const SwapchainHandle& handle);
 
-		std::vector<vk::ImageView> createSwapchainImageViews(SwapchainHandle handle);
+		std::vector<vk::ImageView> createSwapchainImageViews(SwapchainHandle& handle);
 	};
 }
\ No newline at end of file
diff --git a/src/vkcv/Window.cpp b/src/vkcv/Window.cpp
index 655ebe1c..164812ca 100644
--- a/src/vkcv/Window.cpp
+++ b/src/vkcv/Window.cpp
@@ -145,7 +145,7 @@ namespace vkcv {
         }
     }
 
-    void Window::destroyWindow() {
+    /*void Window::destroyWindow() {
 		Window::e_mouseButton.unlock();
 		Window::e_mouseMove.unlock();
 		Window::e_mouseScroll.unlock();
@@ -158,9 +158,9 @@ namespace vkcv {
 			s_Windows.erase(std::find(s_Windows.begin(), s_Windows.end(), m_window));
 			glfwDestroyWindow(m_window);
 		}
-	}
+	}*/
     
-    Window::Window(const Window &other) :
+    /*Window::Window(const Window &other) :
     m_title(other.getTitle()),
     m_resizable(other.isResizable()),
     m_window(createGLFWWindow(
@@ -198,7 +198,19 @@ namespace vkcv {
 		bindGLFWWindow(m_window, this);
     	
     	return *this;
-    }
+    }*/
+
+	bool Window::hasOpenWindow() {
+		for (auto glfwWindow : s_Windows) {
+			auto window = static_cast<Window *>(glfwGetWindowUserPointer(glfwWindow));
+			
+			if (window->isOpen()) {
+				return true;
+			}
+		}
+		
+		return false;
+	}
 
     void Window::pollEvents() {
 
@@ -237,6 +249,8 @@ namespace vkcv {
 			window->e_key.lock();
 			window->e_char.lock();
 			window->e_gamepad.lock();
+			
+			window->m_shouldClose |= glfwWindowShouldClose(glfwWindow);
 		}
     }
 
@@ -245,7 +259,7 @@ namespace vkcv {
 			return false;
 		}
 		
-        return !glfwWindowShouldClose(m_window);
+        return !m_shouldClose;
     }
     
     const std::string& Window::getTitle() const {
diff --git a/src/vkcv/WindowManager.cpp b/src/vkcv/WindowManager.cpp
index f1b2c9bb..48f4e277 100644
--- a/src/vkcv/WindowManager.cpp
+++ b/src/vkcv/WindowManager.cpp
@@ -1,9 +1,8 @@
-#include "vkcv/WindowManager.hpp"
+#include "WindowManager.hpp"
 #include "vkcv/Context.hpp"
 
 namespace vkcv {
-	static std::vector<Window> m_windows;
-
+	
 	WindowManager::WindowManager() noexcept {
 	}
 
@@ -11,6 +10,7 @@ namespace vkcv {
 		for (uint64_t id = 0; id < m_windows.size(); id++) {
 			destroyWindowById(id);
 		}
+		
 		m_windows.clear();
 	}
 
@@ -22,12 +22,12 @@ namespace vkcv {
 			bool resizeable) {
 		const uint64_t id = m_windows.size();
 
-		vkcv::Window window = vkcv::Window(applicationName, windowWidth, windowHeight, resizeable);
+		auto window = new Window(applicationName, windowWidth, windowHeight, resizeable);
 
-		SwapchainHandle swapchainHandle = swapchainManager.createSwapchain(window);
+		SwapchainHandle swapchainHandle = swapchainManager.createSwapchain(*window);
 
 		if (resizeable) {
-			window.e_resize.add([&](int width, int height) {
+			window->e_resize.add([&](int width, int height) {
 				swapchainManager.signalRecreation(swapchainHandle);
 			});
 		}
@@ -37,7 +37,7 @@ namespace vkcv {
 	}
 
 	Window &WindowManager::getWindow(const WindowHandle handle) const {
-		return m_windows[handle.getId()];
+		return *m_windows[handle.getId()];
 	}
 
 	void WindowManager::destroyWindowById(uint64_t id) {
@@ -47,25 +47,21 @@ namespace vkcv {
 			return;
 		}
 
-		Window &window = m_windows[id];
-		window.destroyWindow();
-		m_windows[id] = nullptr;
+		if (m_windows[id] != nullptr) {
+			delete m_windows[id];
+			m_windows[id] = nullptr;
+		}
 	}
 
-	void WindowManager::pollEvents() {
+	/*void WindowManager::pollEvents() {
 		Window::pollEvents();
 	}
 
 	bool WindowManager::hasOpenWindow() {
-		for (auto &window : m_windows) {
-			if (window.isOpen()) {
-				return true;
-			}
-		}
-		return false;
+	
 	}
 
-	const Window WindowManager::getFocusedWindow() {
+	Window& WindowManager::getFocusedWindow() {
 		return Window::getFocusedWindow();
-	}
+	}*/
 }
\ No newline at end of file
diff --git a/include/vkcv/WindowManager.hpp b/src/vkcv/WindowManager.hpp
similarity index 80%
rename from include/vkcv/WindowManager.hpp
rename to src/vkcv/WindowManager.hpp
index 441b82d3..01846b51 100644
--- a/include/vkcv/WindowManager.hpp
+++ b/src/vkcv/WindowManager.hpp
@@ -1,11 +1,12 @@
 #pragma once
 
+#include <memory>
 #include <vector>
 #include <GLFW/glfw3.h>
 
 #include "vkcv/Window.hpp"
 #include "vkcv/Handles.hpp"
-#include "vkcv/SwapchainManager.hpp"
+#include "SwapchainManager.hpp"
 
 namespace vkcv {
 	class Context;
@@ -16,7 +17,8 @@ namespace vkcv {
 		friend class Core;
 
 	private:
-
+		std::vector<Window*> m_windows;
+		
 		void destroyWindowById(uint64_t id);
 
 	public:
@@ -38,14 +40,6 @@ namespace vkcv {
 
 		[[nodiscard]]
 		Window &getWindow(const WindowHandle handle) const;
-
-		/**
-		 * Forwards the event poll to "vkcv/Window.hpp"
-		 */
-		static void pollEvents();
-
-		static bool hasOpenWindow();
-
-		static const Window getFocusedWindow();
+		
 	};
 }
\ No newline at end of file
-- 
GitLab