REFACTOR: move game code out of main into its own class

src/CMakeLists.txt

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

src/callbacks.cpp

@@ -1,4 +1,5 @@
 #include "callbacks.h"
+#include <glad/glad.h>
 
 
 void error_callback(int error, const char* description)
@@ -15,4 +16,4 @@ void framebuffer_size_callback(GLFWwindow* window, int width, int height)
 {
     (void)window;
     glViewport(0, 0, width, height);
-}
+}

src/callbacks.h

@@ -1,11 +1,13 @@
-#pragma once
+#ifndef CALLBACKS_H
+#define CALLBACKS_H
 
 #define GLFW_INCLUDE_NONE
 #include <GLFW/glfw3.h>
-#include <glad/glad.h>
 
 #include <spdlog/spdlog.h>
 
 void error_callback(int error, const char* description);
 void key_callback(GLFWwindow* window, int key, int scancode, int action, int mods);
-void framebuffer_size_callback(GLFWwindow* window, int width, int height);
+void framebuffer_size_callback(GLFWwindow* window, int width, int height);
+
+#endif //CALLBACKS_H

src/game.cpp

@@ -0,0 +1,106 @@
+#include "game.h"
+#include "callbacks.h"
+#include <spdlog/spdlog.h>
+#include <glm/gtc/matrix_transform.hpp>
+
+Game::Game() {
+    m_window_height = 600;
+    m_window_width = 800;
+
+    if (!glfwInit()) {
+		spdlog::error("Could not intialize GLFW.");
+		return;
+	}
+
+	glfwSetErrorCallback(error_callback);
+	glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 4);
+	glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 5);
+	glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
+
+}
+
+Game::Game(int width, int height): m_window_width(width), m_window_height(height) {
+    Game();
+}
+
+Game::~Game() {
+   	glfwDestroyWindow(m_window);
+	glfwTerminate();
+}
+
+void Game::init() {
+    m_window = 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);
+	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+
+	m_is_initialized = true;
+
+}
+
+void Game::run() {
+
+    if(!m_is_initialized) {
+        spdlog::error("Game is not initialized properly");
+        return;
+    }
+
+    double deltaTime = 0.0f;
+    double lastFrame = 0.0f;
+
+   	while (!glfwWindowShouldClose(m_window)) {
+
+
+		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);
+
+		glClearColor(0.2f, 0.3f, 0.3f, 1.0f);
+		glClear(GL_COLOR_BUFFER_BIT);
+
+		for(Renderer &r: m_renderer_objects) {
+		  r.draw();
+		}
+		spdlog::warn("deltaTime {}", 1.0f/deltaTime);
+
+		glfwSwapBuffers(m_window);
+	}
+
+}
+
+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

@@ -0,0 +1,32 @@
+#pragma once
+#define GLFW_INCLUDE_NONE
+#include <GLFW/glfw3.h>
+#include <glad/glad.h>
+#include <vector>
+#include "renderer.h"
+
+class Game {
+public:
+        Game(int, int);
+        Game();
+        ~Game();
+
+        void init();
+        void run();
+
+        void add_renderer_object(Renderer);
+
+private:
+
+    GLFWwindow* m_window = nullptr;
+    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,6 +1,3 @@
-#define GLFW_INCLUDE_NONE
-#include <GLFW/glfw3.h>
-#include <glad/glad.h>
 
 #include <spdlog/spdlog.h>
 #include <glm/gtc/matrix_transform.hpp>
@@ -8,6 +5,7 @@
 #include "callbacks.h"
 #include "shader.h"
 #include "renderer.h"
+#include "game.h"
 
 #define WINDOW_WIDTH 800
 #define WINDOW_HEIGHT 600
@@ -16,36 +14,8 @@ void process_input(GLFWwindow* window);
 
 int main() {
 
-	if (!glfwInit()) {
-		spdlog::error("Could not intialize GLFW.");
-		return EXIT_FAILURE;
-	}
-	glfwSetErrorCallback(error_callback);
-	glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 4);
-	glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 5);
-	glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
-
-
-	GLFWwindow *window = glfwCreateWindow(WINDOW_WIDTH, WINDOW_HEIGHT, "My New Window", NULL, NULL);
-	if (!window) {
-		spdlog::error("Could not create GLFW Window.");
-		glfwTerminate();
-		return EXIT_FAILURE;
-	}
-	glfwMakeContextCurrent(window);
-
-	if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress)) {
-		spdlog::error("Failed to initialize GLAD");
-		return EXIT_FAILURE;
-	}
-	glfwSetKeyCallback(window, key_callback);
-	glfwSetFramebufferSizeCallback(window, framebuffer_size_callback);
-
-
-	glViewport(0, 0, WINDOW_WIDTH, WINDOW_HEIGHT);
-	glEnable(GL_BLEND);
-	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
-
+    Game game;
+    game.init();
 
 	Shader basic = Shader("shaders/vert.glsl", "shaders/frag.glsl");
 	basic.use();
@@ -54,41 +24,14 @@ int main() {
 		static_cast<float>(WINDOW_HEIGHT), 0.0f, -1.0f, 1.0f);
 	basic.setMatrix4("projection", projection);
 
-	Renderer r = Renderer(basic);
-	float deltaTime = 0.0f;
-	float lastFrame = 0.0f;
-
-	while (!glfwWindowShouldClose(window)) {
-
 
-		float currentFrame = glfwGetTime();
-		deltaTime = currentFrame - lastFrame;
-		lastFrame = currentFrame;
-		glfwPollEvents();
+	glm::vec2 pos = glm::vec2(0,0);
+	glm::vec2 size(400.0f, 300.0f);
+	glm::vec3 color(0.5f, 0.5f, 0.5f);
+	Renderer r = Renderer(basic, pos, size, 0.0f, color);
 
-		process_input(window);
-
-		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);
-
-		r.draw(pos, size, 0.0f, color);
-
-		spdlog::warn("deltaTime {}", 1.0f/deltaTime);
-
-		glfwSwapBuffers(window);
-	}
-
-	glfwDestroyWindow(window);
-	glfwTerminate();
+	game.add_renderer_object(r);
 
+	game.run();
 	return EXIT_SUCCESS;
 }
-
-void process_input(GLFWwindow* window) {
-	if (glfwGetKey(window, GLFW_KEY_ESCAPE) == GLFW_PRESS)
-		glfwSetWindowShouldClose(window, true);
-}

src/renderer.cpp

@@ -3,28 +3,29 @@
 #include <glad/glad.h>
 #include <glm/gtc/matrix_transform.hpp>
 
-Renderer::Renderer(Shader shader): m_shader(shader) {
+Renderer::Renderer(Shader shader, glm::vec2 position, glm::vec2 size, float rotate, glm::vec3 color)
+    : m_shader(shader), m_position(position), m_size(size), m_rotate(rotate), m_color(color) {
 
     this->init();
 }
 
-void Renderer::draw(glm::vec2 position, glm::vec2 size, float rotate, glm::vec3 color) {
+void Renderer::draw() {
 	this->m_shader.use();
 
 	glm::mat4 model = glm::mat4(1.0f);
-	model = glm::translate(model, glm::vec3(position, 0.0f));
+	model = glm::translate(model, glm::vec3(m_position, 0.0f));
 
 
-    model = glm::translate(model, glm::vec3(0.5f * size.x, 0.5f * size.y, 0.0f)); // move origin of rotation to center of quad
-    model = glm::rotate(model, glm::radians(rotate), glm::vec3(0.0f, 0.0f, 1.0f)); // then rotate
-    model = glm::translate(model, glm::vec3(-0.5f * size.x, -0.5f * size.y, 0.0f)); // move origin back
+    model = glm::translate(model, glm::vec3(0.5f * m_size.x, 0.5f * m_size.y, 0.0f)); // move origin of rotation to center of quad
+    model = glm::rotate(model, glm::radians(m_rotate), glm::vec3(0.0f, 0.0f, 1.0f)); // then rotate
+    model = glm::translate(model, glm::vec3(-0.5f * m_size.x, -0.5f * m_size.y, 0.0f)); // move origin back
 
-    model = glm::scale(model, glm::vec3(size, 1.0f)); // last scale
+    model = glm::scale(model, glm::vec3(m_size, 1.0f)); // last scale
 
     this->m_shader.setMatrix4("model", model);
 
     // render textured quad
-    this->m_shader.setVector3f("spriteColor", color);
+    this->m_shader.setVector3f("spriteColor", m_color);
 
     //glActiveTexture(GL_TEXTURE0);
     //texture.Bind();

src/renderer.h

@@ -7,16 +7,18 @@ class Renderer
 {
 
 private:
-	
+
 	unsigned int m_vao;
 	void init();
 	Shader m_shader;
 
-public:
+	glm::vec2 m_position;
+	glm::vec2 m_size;
+	float m_rotate;
+	glm::vec3 m_color;
 
-	Renderer(Shader shader);
-	void draw(glm::vec2 position, glm::vec2 size, float rotate, glm::vec3 color);
-	
+public:
 
+	Renderer(Shader shader, glm::vec2 position, glm::vec2 size, float rotate, glm::vec3 color);
+	void draw();
 };
-