REFACTOR: move glfw objects into Unique_Ptr for a cleaner destruction process

src/CMakeLists.txt

@@ -6,6 +6,7 @@ set(SOURCES
     shader.cpp
     callbacks.cpp
     game.cpp
+    window.cpp
 )
 
 set(EXECUTABLE_OUTPUT_PATH ..)

src/game.cpp

@@ -1,8 +1,11 @@
 #include "game.h"
-#include "callbacks.h"
+
 #include <spdlog/spdlog.h>
 #include <glm/gtc/matrix_transform.hpp>
 
+#include "window.h"
+#include "callbacks.h"
+
 Game::Game() {
     m_window_height = 600;
     m_window_width = 800;
@@ -12,6 +15,8 @@ Game::Game() {
 		return;
 	}
 
+    m_window = std::make_unique<Window>(m_window_height, m_window_height);
+
 	glfwSetErrorCallback(error_callback);
 	glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 4);
 	glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 5);
@@ -24,34 +29,10 @@ Game::Game(int width, int height): m_window_width(width), m_window_height(height
 }
 
 Game::~Game() {
-   	glfwDestroyWindow(*m_window);
-	glfwTerminate();
+    glfwTerminate();
 }
 
 void Game::init() {
-    m_window = std::make_unique<GLFWwindow *>(glfwCreateWindow(
-          m_window_width
-        , m_window_height
-        , "My New Window"
-        , NULL
-        , NULL)
-    );
-
-	if (!m_window) {
-		spdlog::error("Could not create GLFW Window.");
-		glfwTerminate();
-		return;
-	}
-	glfwMakeContextCurrent(*m_window);
-
-	if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress)) {
-		spdlog::error("Failed to initialize GLAD");
-		return;
-	}
-
-	glfwSetKeyCallback(*m_window, key_callback);
-	glfwSetFramebufferSizeCallback(*m_window, framebuffer_size_callback);
-
 
 	glViewport(0, 0, m_window_width, m_window_height);
 	glEnable(GL_BLEND);
@@ -71,29 +52,24 @@ void Game::run() {
     double deltaTime = 0.0f;
     double lastFrame = 0.0f;
 
-   	while (!glfwWindowShouldClose(*m_window.get())) {
-
+   	while (m_window->run()) {
 
 		double currentFrame = glfwGetTime();
 		deltaTime = currentFrame - lastFrame;
 		lastFrame = currentFrame;
-		glfwPollEvents();
-
-		process_input();
 
-		glm::vec2 pos = glm::vec2(0,0);
-		glm::vec2 size(400.0f, 300.0f);
-		glm::vec3 color(0.5f, 0.5f, 0.5f);
+  		glm::vec2 pos = glm::vec2(0,0);
+  		glm::vec2 size(400.0f, 300.0f);
+  		glm::vec3 color(0.5f, 0.5f, 0.5f);
 
-		glClearColor(0.2f, 0.3f, 0.3f, 1.0f);
-		glClear(GL_COLOR_BUFFER_BIT);
+  		glClearColor(0.2f, 0.3f, 0.3f, 1.0f);
+  		glClear(GL_COLOR_BUFFER_BIT);
 
-		for(Renderer &r: m_renderer_objects) {
+  		for(Renderer &r: m_renderer_objects) {
 		  r.draw();
-		}
-		spdlog::warn("deltaTime {}", 1.0f/deltaTime);
+  		}
 
-		glfwSwapBuffers(*m_window.get());
+		spdlog::warn("deltaTime {}", 1.0f/deltaTime);
 	}
 
 }
@@ -101,8 +77,3 @@ void Game::run() {
 void Game::add_renderer_object(Renderer obj) {
     m_renderer_objects.push_back(obj);
 }
-
-void Game::process_input() {
-	if (glfwGetKey(*m_window, GLFW_KEY_ESCAPE) == GLFW_PRESS)
-		glfwSetWindowShouldClose(*m_window, true);
-}

src/game.h

@@ -1,12 +1,11 @@
 #pragma once
 
-#define GLFW_INCLUDE_NONE
-#include <GLFW/glfw3.h>
-#include <glad/glad.h>
+
 #include <vector>
 #include <memory>
 
 #include "renderer.h"
+#include "window.h"
 
 class Game {
 public:
@@ -21,13 +20,10 @@ public:
 
 private:
 
-    std::unique_ptr<GLFWwindow *> m_window;
+    std::unique_ptr<Window> m_window;
     bool m_is_initialized = false;
     int m_window_height = 600;
     int m_window_width = 800;
-
-    void process_input();
-
     std::vector<Renderer> m_renderer_objects = {};
 
 

src/main.cpp

@@ -1,8 +1,8 @@
 
+#include <memory>
 #include <spdlog/spdlog.h>
 #include <glm/gtc/matrix_transform.hpp>
 
-#include "callbacks.h"
 #include "shader.h"
 #include "renderer.h"
 #include "game.h"
@@ -14,8 +14,8 @@ void process_input(GLFWwindow* window);
 
 int main() {
 
-    Game game;
-    game.init();
+    std::unique_ptr<Game>game = std::make_unique<Game>();
+    game->init();
 
 	Shader basic = Shader("shaders/vert.glsl", "shaders/frag.glsl");
 	basic.use();
@@ -30,8 +30,14 @@ int main() {
 	glm::vec3 color(0.5f, 0.5f, 0.5f);
 	Renderer r = Renderer(basic, pos, size, 0.0f, color);
 
-	game.add_renderer_object(r);
+	glm::vec2 pos1 = glm::vec2(200.0f, 150.0f);
+	glm::vec2 size1(60.0f, 60.0f);
+	glm::vec3 color1(0.5f, 1.0f, 0.5f);
+	Renderer r1 = Renderer(basic, pos1, size1, 0.0f, color1);
 
-	game.run();
+	game->add_renderer_object(r);
+	game->add_renderer_object(r1);
+
+	game->run();
 	return EXIT_SUCCESS;
 }

src/window.cpp

@@ -0,0 +1,59 @@
+#include "window.h"
+
+#include <GLFW/glfw3.h>
+#include <spdlog/spdlog.h>
+#include "callbacks.h"
+
+Window::Window(size_t width, size_t height) {
+
+    m_window = glfwCreateWindow(
+          width
+        , height
+        , "My New Window"
+        , NULL
+        , NULL
+    );
+
+	if (!m_window) {
+		spdlog::error("Could not create GLFW Window.");
+		glfwTerminate();
+		return;
+	}
+	glfwMakeContextCurrent(m_window);
+
+	if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress)) {
+		spdlog::error("Failed to initialize GLAD");
+		return;
+	}
+
+	glfwSetKeyCallback(m_window, key_callback);
+	glfwSetFramebufferSizeCallback(m_window, framebuffer_size_callback);
+
+}
+
+bool Window::run(){
+
+    m_running = true;
+    if (glfwWindowShouldClose(m_window)) {
+        m_running = false;
+    }
+
+    if (m_running) {
+        glfwPollEvents();
+        process_input();
+        glfwSwapBuffers(m_window);
+    }
+
+    return m_running;
+
+}
+
+bool Window::isRunning() {
+
+    return m_running;
+}
+
+void Window::process_input() {
+	if (glfwGetKey(m_window, GLFW_KEY_ESCAPE) == GLFW_PRESS)
+		glfwSetWindowShouldClose(m_window, true);
+}

src/window.h

@@ -0,0 +1,24 @@
+#pragma once
+
+#define GLFW_INCLUDE_NONE
+#include <GLFW/glfw3.h>
+#include <glad/glad.h>
+
+
+class Window {
+
+public:
+    Window(size_t, size_t);
+    ~Window() {
+        glfwDestroyWindow(m_window);
+    }
+
+    bool run();
+    bool isRunning();
+    void process_input();
+
+private:
+    GLFWwindow *m_window;
+    bool m_running = false;
+
+};