.clang-format

@@ -9,6 +9,6 @@ AllowShortLoopsOnASingleLine: false
 AlwaysBreakBeforeMultilineStrings: true
 AlwaysBreakTemplateDeclarations: true
 IndentWidth: 4
-ColumnLimit: 120
+ColumnLimit: 80
 
 ...

SConstruct

@@ -6,8 +6,7 @@ def add_third_party_includes(env):
 
 
 def add_strict_compile_flags(env):
-    # TODO: Would be good to add "-Werror", but glad.c makes that break
-    env.Append(CCFLAGS=["-Wall", "-Wextra", "-pedantic", "-std=c++17"])
+    env.Append(CCFLAGS=["-Wall", "-Wextra", "-Werror", "-pedantic"])
 
 
 # Create the environment and create a Compilation Database for use in VSCodium
@@ -15,13 +14,12 @@ env = Environment(tools=['default', 'compilation_db'])
 env.CompilationDatabase()
 
 env.Append(CPPPATH=['cpp/', 'include/'])
-env.Append(LIBS=['glfw', 'dl'])
 
 add_third_party_includes(env)
 add_strict_compile_flags(env)
 
 # Build the library
-gedeng = env.SharedLibrary('lib/gedeng', Glob('cpp/*.cpp') + ['cpp/vendor/glad.c'])
+gedeng = env.SharedLibrary('lib/gedeng', Glob('cpp/*.cpp'))
 
 # Install the library to the test application's build directory
 env.Install('test/bin/lib/', gedeng)

cpp/Application.cpp

@@ -1,36 +1,10 @@
 #include "Gedeng/Application.h"
-#include "Gedeng/Input.h"
-#include "Gedeng/Logger.h"
-#include "Gedeng/RenderBackend.h"
-#include "Gedeng/Time.h"
 
 namespace Gedeng {
 
 void Application::run() {
-    // Setup Rendering
-    // FIXME: Make these parameters variable, maybe move this to a different function
-    RenderBackend::initialize_window(WINDOW_SIZE_X, WINDOW_SIZE_Y, WINDOW_NAME);
-    Input::initialize(RenderBackend::get_window());
-
-    unsigned long previous_time_ms = Time::get_time_ms();
-    unsigned long time_until_fixed_update_ms = 0.0;
-
-    while (!RenderBackend::does_window_want_to_close()) {
-        unsigned long current_time_ms = Time::get_time_ms();
-        unsigned long elapsed_time_ms = current_time_ms - previous_time_ms;
-
-        previous_time_ms = current_time_ms;
-        time_until_fixed_update_ms += elapsed_time_ms;
-
-        Input::poll_input();
-
-        // Update fixed time step
-        while (time_until_fixed_update_ms >= MS_PER_UPDATE) {
-            fixed_update(static_cast<double>(MS_PER_UPDATE) / 1000.0);
-            time_until_fixed_update_ms -= MS_PER_UPDATE;
-        }
-
-        dynamic_update(static_cast<double>(elapsed_time_ms) / 1000.0);
+    while (true) {
+        // TODO: Implement
     }
 }
 

cpp/Framebuffer3D.cpp

@@ -1,44 +0,0 @@
-#include "Gedeng/Framebuffer3D.h"
-
-namespace Gedeng {
-
-Framebuffer3D::Framebuffer3D(int width, int height, int depth) {
-    glGenTextures(1, &texture);
-    glBindTexture(GL_TEXTURE_3D, texture);
-    glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
-    glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
-    glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_BORDER);
-    glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_BORDER);
-    glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_BORDER);
-    glTexImage3D(GL_TEXTURE_3D, 0, GL_R32F, width, height, depth, 0, GL_RED, GL_FLOAT, nullptr);
-
-    glGenFramebuffers(1, &buffer);
-    glBindFramebuffer(GL_FRAMEBUFFER, buffer);
-
-    GLenum c = GL_COLOR_ATTACHMENT0;
-
-    glFramebufferTexture3D(GL_FRAMEBUFFER, c, GL_TEXTURE_3D, texture, 0, 0);
-    glDrawBuffers(1, &c);
-}
-
-Framebuffer3D::~Framebuffer3D() {
-    glDeleteFramebuffers(1, &buffer);
-    glDeleteTextures(1, &texture);
-}
-
-void Framebuffer3D::bind_and_clear() {
-    glBindFramebuffer(GL_FRAMEBUFFER, buffer);
-    glClear(GL_COLOR_BUFFER_BIT);
-}
-
-void Framebuffer3D::bind_to(int unit) const {
-    glActiveTexture(GL_TEXTURE0 + unit);
-    glBindTexture(GL_TEXTURE_3D, texture);
-}
-
-void Framebuffer3D::bind_layer(int layer) {
-    glBindFramebuffer(GL_FRAMEBUFFER, buffer);
-    glFramebufferTexture3D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_3D, texture, 0, layer);
-}
-
-}

cpp/RenderBackend.cpp

@@ -1,44 +0,0 @@
-#include "Gedeng/RenderBackend.h"
-
-namespace Gedeng {
-
-void RenderBackend::initialize_window(unsigned int width, unsigned int height, String title) {
-    glfwInit();
-    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
-    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
-    glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
-
-#ifdef __APPLE__
-    glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);
-#endif
-
-    window = glfwCreateWindow(width, height, title, NULL, NULL);
-    glfwMakeContextCurrent(window);
-    gladLoadGLLoader((GLADloadproc)glfwGetProcAddress);
-}
-
-bool RenderBackend::is_window_created() {
-    return window != nullptr;
-}
-
-void RenderBackend::set_depth_test_enabled(bool enabled) {
-    if (enabled) {
-        glEnable(GL_DEPTH_TEST);
-    } else {
-        glDisable(GL_DEPTH_TEST);
-    }
-}
-
-bool RenderBackend::does_window_want_to_close() {
-    return glfwWindowShouldClose(window);
-}
-
-GLFWwindow *RenderBackend::get_window() {
-    return window;
-}
-
-void RenderBackend::render() {
-    glfwSwapBuffers(window);
-}
-
-} // namespace Gedeng

cpp/Texture.cpp

@@ -1,60 +0,0 @@
-#include "Gedeng/Texture.h"
-#include <iostream>
-
-#define STB_IMAGE_IMPLEMENTATION
-#include "vendor/stb_image.h"
-
-namespace Gedeng {
-
-bool Texture::is_valid() const {
-    return valid;
-}
-
-uint Texture::load_texture(const std::string &path, Settings settings) {
-    uint gl_id;
-
-    glGenTextures(1, &gl_id);
-    glBindTexture(GL_TEXTURE_2D, gl_id);
-
-    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
-    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
-
-    if (settings.mipmaps) {
-        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
-    } else {
-        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
-    }
-    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
-
-    int width, height, nrChannels;
-    unsigned char *data = stbi_load(path.c_str(), &width, &height, &nrChannels, 0);
-
-    if (data) {
-        // Check number of channels
-        unsigned int glChannels = GL_RED;
-        if (nrChannels == 3)
-            glChannels = GL_RGB;
-        else if (nrChannels == 4)
-            glChannels = GL_RGBA;
-
-        glTexImage2D(GL_TEXTURE_2D, 0, glChannels, width, height, 0, glChannels, GL_UNSIGNED_BYTE,
-                     data);
-
-        if (settings.mipmaps) {
-            glGenerateMipmap(GL_TEXTURE_2D);
-        }
-
-        valid = true;
-    }
-
-    stbi_image_free(data);
-
-    return gl_id;
-}
-
-void Texture::bind_to(int unit) {
-    glActiveTexture(GL_TEXTURE0 + unit);
-    glBindTexture(GL_TEXTURE_2D, id);
-}
-
-}

cpp/Time.cpp

@@ -1,14 +0,0 @@
-#include "Gedeng/Time.h"
-
-#include <chrono>
-
-namespace Gedeng {
-
-unsigned long Time::get_time_ms() {
-    auto now = std::chrono::high_resolution_clock::now();
-    auto now_ms = std::chrono::time_point_cast<std::chrono::milliseconds>(now);
-
-    return now_ms.time_since_epoch().count();
-}
-
-}

cpp/VertexBuffer.cpp

@@ -1,41 +0,0 @@
-#include "Gedeng/VertexBuffer.h"
-
-namespace Gedeng {
-
-VertexBuffer::VertexBuffer() {
-    glGenVertexArrays(1, &vertex_array);
-    glGenBuffers(1, &vertex_buffer);
-}
-
-void VertexBuffer::set_data(int size, int dimension, const void *data, int flag) {
-    // We can't just do size = sizeof(data) here because of array to pointer decay!
-    this->size = size;
-
-    bind_array();
-    bind_buffer();
-
-    // Create the data on the GPU
-    glBufferData(GL_ARRAY_BUFFER, size, data, flag);
-
-    // Specify the dimension of the vectors in the data, so that the GPU knows how much to read from
-    // it at a time. (Currently only one type of vector is supported)
-    glEnableVertexAttribArray(0);
-    glVertexAttribPointer(0, dimension, GL_FLOAT, false, dimension * sizeof(float), 0);
-
-    glBindVertexArray(0);
-}
-
-void VertexBuffer::bind_buffer() {
-    glBindBuffer(GL_ARRAY_BUFFER, vertex_buffer);
-}
-
-void VertexBuffer::bind_array() {
-    glBindVertexArray(vertex_array);
-}
-
-void VertexBuffer::draw() {
-    bind_array();
-    glDrawArrays(GL_TRIANGLES, 0, size);
-}
-
-}

cpp/vendor/stb_setup.cpp

@@ -1,2 +0,0 @@
-#define STB_IMAGE_IMPLEMENTATION
-#include "stb_image.h"

include/Gedeng.h

@@ -4,14 +4,5 @@
 #include "Gedeng/Logger.h"
 #include "Gedeng/String.h"
 #include "Gedeng/Vector.h"
-#include "Gedeng/Time.h"
-#include "Gedeng/Shader.h"
-#include "Gedeng/QuadMesh.h"
-#include "Gedeng/Spatial.h"
-#include "Gedeng/Texture.h"
-#include "Gedeng/Camera.h"
-#include "Gedeng/VertexBuffer.h"
-#include "Gedeng/Framebuffer3D.h"
-#include "Gedeng/Input.h"
 
 #include "Gedeng/EntryPoint.h"

include/Gedeng/Application.h

@@ -1,39 +1,15 @@
 #pragma once
 
-#include "String.h"
-
 namespace Gedeng {
 
 class Application {
   public:
-    Application(unsigned long ms_per_update, unsigned int window_size_x, unsigned int window_size_y, String window_name)
-        : MS_PER_UPDATE(ms_per_update), WINDOW_SIZE_X(window_size_x), WINDOW_SIZE_Y(window_size_y),
-          WINDOW_NAME(window_name) {
-    }
+    Application() = default;
 
     // Virtual since this class will be inherited by user-created applications
     virtual ~Application() = default;
 
-    // Game Loop
     void run();
-
-    // Primarily for gameplay and physics
-    // To be overridden by client applications
-    virtual void fixed_update(double delta) = 0;
-
-    // Primarily for rendering
-    // To be overridden by client applications
-    virtual void dynamic_update(double delta) = 0;
-
-    // TODO: Write note for this: `undefined reference to vtable` can be caused by forgetting `= 0` for pure virtual
-    // stuff
-
-  private:
-    // TODO: These will probably become a separate Settings struct
-    const unsigned long MS_PER_UPDATE;
-    const unsigned int WINDOW_SIZE_X;
-    const unsigned int WINDOW_SIZE_Y;
-    const String WINDOW_NAME;
 };
 
 // To be defined in client applications

include/Gedeng/Camera.h

@@ -1,31 +0,0 @@
-#pragma once
-
-#include <glm/glm.hpp>
-#include <glm/gtc/matrix_transform.hpp>
-#include <glm/gtx/dual_quaternion.hpp>
-
-#include "Spatial.h"
-
-namespace Gedeng {
-
-class Camera : public Spatial {
-  public:
-    /// Create a camera with a field of view (in degrees), width and height (in any unit) and near
-    /// and far distances
-    Camera(float fov, float width, float height, float near, float far)
-        : projection(glm::perspective(glm::radians(fov), width / height, near, far)) {
-    }
-
-    glm::mat4 get_projection() {
-        return projection;
-    }
-
-    glm::mat4 get_view() {
-        return glm::inverse(get_matrix());
-    }
-
-  private:
-    glm::mat4 projection;
-};
-
-}

include/Gedeng/Framebuffer3D.h

@@ -1,25 +0,0 @@
-#pragma once
-
-// Must be the first include
-#include <glad/glad.h>
-
-// Other includes
-#include <GLFW/glfw3.h>
-
-namespace Gedeng {
-
-class Framebuffer3D {
-  public:
-    Framebuffer3D(int width, int height, int depth);
-    ~Framebuffer3D();
-
-    void bind_and_clear();
-    void bind_to(int unit) const;
-    void bind_layer(int layer);
-
-  private:
-    GLuint texture;
-    GLuint buffer;
-};
-
-}

include/Gedeng/Input.h

@@ -1,43 +0,0 @@
-#pragma once
-
-// Must be the first include
-#include <glad/glad.h>
-
-// Other includes
-#include <GLFW/glfw3.h>
-
-#include "RenderBackend.h"
-#include <map>
-
-namespace Gedeng {
-
-class Input {
-  public:
-    static void initialize(GLFWwindow *window) {
-        glfwSetKeyCallback(window, key_callback);
-    }
-
-    // FIXME: Ignore warnings produced by these unused variables -- they're required for the callback to work:
-    // https://gcc.gnu.org/onlinedocs/gcc/Diagnostic-Pragmas.html
-    static void key_callback(GLFWwindow *window, int key, int scancode, int action, int mods) {
-        if (key == GLFW_KEY_ESCAPE && action == GLFW_PRESS) glfwSetWindowShouldClose(window, GLFW_TRUE);
-
-        Input::set_key_down(key, action == GLFW_RELEASE ? false : true);
-    }
-
-    static void poll_input() {
-        glfwPollEvents();
-    }
-
-    static void set_key_down(int key, bool down) {
-        keys_down[key] = down;
-    }
-
-    static bool is_key_down(int key) {
-        return keys_down[key];
-    }
-
-    inline static std::map<int, bool> keys_down;
-};
-
-} // namespace Gedeng

include/Gedeng/QuadMesh.h

@@ -1,123 +0,0 @@
-#pragma once
-
-// Must be the first include
-#include <glad/glad.h>
-
-// Other includes
-#include "Shader.h"
-#include "Spatial.h"
-#include <GLFW/glfw3.h>
-
-namespace Gedeng {
-
-// A simple 2x2 quad mesh consisting of two triangles. Oriented upwards by default.
-class QuadMesh : public Spatial {
-  public:
-    QuadMesh() {
-        // Positions
-        glm::vec3 pos1(-1.0f, 1.0f, 0.0f);
-        glm::vec3 pos2(-1.0f, -1.0f, 0.0f);
-        glm::vec3 pos3(1.0f, -1.0f, 0.0f);
-        glm::vec3 pos4(1.0f, 1.0f, 0.0f);
-
-        // Texture coordinates
-        glm::vec2 uv1(0.0f, 1.0f);
-        glm::vec2 uv2(0.0f, 0.0f);
-        glm::vec2 uv3(1.0f, 0.0f);
-        glm::vec2 uv4(1.0f, 1.0f);
-
-        // Normal vector
-        glm::vec3 nm(0.0f, 0.0f, 1.0f);
-
-        // Calculate tangent/bitangent vectors of both triangles
-        glm::vec3 tangent1, bitangent1;
-        glm::vec3 tangent2, bitangent2;
-
-        // Triangle 1
-        glm::vec3 edge1 = pos2 - pos1;
-        glm::vec3 edge2 = pos3 - pos1;
-        glm::vec2 deltaUV1 = uv2 - uv1;
-        glm::vec2 deltaUV2 = uv3 - uv1;
-
-        float f = 1.0f / (deltaUV1.x * deltaUV2.y - deltaUV2.x * deltaUV1.y);
-
-        tangent1.x = f * (deltaUV2.y * edge1.x - deltaUV1.y * edge2.x);
-        tangent1.y = f * (deltaUV2.y * edge1.y - deltaUV1.y * edge2.y);
-        tangent1.z = f * (deltaUV2.y * edge1.z - deltaUV1.y * edge2.z);
-        tangent1 = glm::normalize(tangent1);
-
-        bitangent1.x = f * (-deltaUV2.x * edge1.x + deltaUV1.x * edge2.x);
-        bitangent1.y = f * (-deltaUV2.x * edge1.y + deltaUV1.x * edge2.y);
-        bitangent1.z = f * (-deltaUV2.x * edge1.z + deltaUV1.x * edge2.z);
-        bitangent1 = glm::normalize(bitangent1);
-
-        // Triangle 2
-        edge1 = pos3 - pos1;
-        edge2 = pos4 - pos1;
-        deltaUV1 = uv3 - uv1;
-        deltaUV2 = uv4 - uv1;
-
-        f = 1.0f / (deltaUV1.x * deltaUV2.y - deltaUV2.x * deltaUV1.y);
-
-        tangent2.x = f * (deltaUV2.y * edge1.x - deltaUV1.y * edge2.x);
-        tangent2.y = f * (deltaUV2.y * edge1.y - deltaUV1.y * edge2.y);
-        tangent2.z = f * (deltaUV2.y * edge1.z - deltaUV1.y * edge2.z);
-        tangent2 = glm::normalize(tangent2);
-
-        bitangent2.x = f * (-deltaUV2.x * edge1.x + deltaUV1.x * edge2.x);
-        bitangent2.y = f * (-deltaUV2.x * edge1.y + deltaUV1.x * edge2.y);
-        bitangent2.z = f * (-deltaUV2.x * edge1.z + deltaUV1.x * edge2.z);
-        bitangent2 = glm::normalize(bitangent2);
-
-        float quadVertices[] = {
-            // positions            // normal         // texcoords  // tangent // bitangent
-            pos1.x, pos1.y,     pos1.z,     nm.x,       nm.y,         nm.z,         uv1.x,
-            uv1.y,  tangent1.x, tangent1.y, tangent1.z, bitangent1.x, bitangent1.y, bitangent1.z,
-            pos2.x, pos2.y,     pos2.z,     nm.x,       nm.y,         nm.z,         uv2.x,
-            uv2.y,  tangent1.x, tangent1.y, tangent1.z, bitangent1.x, bitangent1.y, bitangent1.z,
-            pos3.x, pos3.y,     pos3.z,     nm.x,       nm.y,         nm.z,         uv3.x,
-            uv3.y,  tangent1.x, tangent1.y, tangent1.z, bitangent1.x, bitangent1.y, bitangent1.z,
-
-            pos1.x, pos1.y,     pos1.z,     nm.x,       nm.y,         nm.z,         uv1.x,
-            uv1.y,  tangent2.x, tangent2.y, tangent2.z, bitangent2.x, bitangent2.y, bitangent2.z,
-            pos3.x, pos3.y,     pos3.z,     nm.x,       nm.y,         nm.z,         uv3.x,
-            uv3.y,  tangent2.x, tangent2.y, tangent2.z, bitangent2.x, bitangent2.y, bitangent2.z,
-            pos4.x, pos4.y,     pos4.z,     nm.x,       nm.y,         nm.z,         uv4.x,
-            uv4.y,  tangent2.x, tangent2.y, tangent2.z, bitangent2.x, bitangent2.y, bitangent2.z};
-
-        // Configure plane VAO
-        glGenVertexArrays(1, &quadVAO);
-        glGenBuffers(1, &quadVBO);
-        glBindVertexArray(quadVAO);
-        glBindBuffer(GL_ARRAY_BUFFER, quadVBO);
-        glBufferData(GL_ARRAY_BUFFER, sizeof(quadVertices), &quadVertices, GL_STATIC_DRAW);
-        glEnableVertexAttribArray(0);
-        glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 14 * sizeof(float), (void *)0);
-        glEnableVertexAttribArray(1);
-        glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 14 * sizeof(float),
-                              (void *)(3 * sizeof(float)));
-        glEnableVertexAttribArray(2);
-        glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, 14 * sizeof(float),
-                              (void *)(6 * sizeof(float)));
-        glEnableVertexAttribArray(3);
-        glVertexAttribPointer(3, 3, GL_FLOAT, GL_FALSE, 14 * sizeof(float),
-                              (void *)(8 * sizeof(float)));
-        glEnableVertexAttribArray(4);
-        glVertexAttribPointer(4, 3, GL_FLOAT, GL_FALSE, 14 * sizeof(float),
-                              (void *)(11 * sizeof(float)));
-    }
-
-    void render(Shader &shader) {
-        shader.setMat4("model", get_matrix());
-
-        glBindVertexArray(quadVAO);
-        glDrawArrays(GL_TRIANGLES, 0, 6);
-        glBindVertexArray(0);
-    }
-
-  private:
-    unsigned int quadVAO = 0;
-    unsigned int quadVBO;
-};
-
-}

include/Gedeng/RenderBackend.h

@@ -1,31 +0,0 @@
-#pragma once
-
-// Must be the first include
-#include <glad/glad.h>
-
-// Other includes
-#include <GLFW/glfw3.h>
-
-#include "Gedeng/String.h"
-
-namespace Gedeng {
-
-class RenderBackend {
-  private:
-    static inline GLFWwindow *window;
-
-  public:
-    static void initialize_window(unsigned int width, unsigned int height, String title);
-
-    static bool is_window_created();
-
-    static void set_depth_test_enabled(bool enabled);
-
-    static bool does_window_want_to_close();
-
-    static GLFWwindow *get_window();
-
-    static void render();
-};
-
-} // namespace Gedeng

include/Gedeng/Shader.h

@@ -1,172 +0,0 @@
-#pragma once
-
-// Adapted from LearnOpenGL
-
-#include <glad/glad.h>
-#include <glm/glm.hpp>
-
-#include <fstream>
-#include <iostream>
-#include <sstream>
-#include <string>
-
-namespace Gedeng {
-
-class Shader {
-  public:
-    unsigned int ID;
-    // constructor generates the shader on the fly
-    // ------------------------------------------------------------------------
-    Shader(const char *vertexPath, const char *fragmentPath, const char *geometryPath = nullptr) {
-        // 1. retrieve the vertex/fragment source code from filePath
-        std::string vertexCode;
-        std::string fragmentCode;
-        std::string geometryCode;
-        std::ifstream vShaderFile;
-        std::ifstream fShaderFile;
-        std::ifstream gShaderFile;
-        // ensure ifstream objects can throw exceptions:
-        vShaderFile.exceptions(std::ifstream::failbit | std::ifstream::badbit);
-        fShaderFile.exceptions(std::ifstream::failbit | std::ifstream::badbit);
-        gShaderFile.exceptions(std::ifstream::failbit | std::ifstream::badbit);
-        try {
-            // open files
-            vShaderFile.open(vertexPath);
-            fShaderFile.open(fragmentPath);
-            std::stringstream vShaderStream, fShaderStream;
-            // read file's buffer contents into streams
-            vShaderStream << vShaderFile.rdbuf();
-            fShaderStream << fShaderFile.rdbuf();
-            // close file handlers
-            vShaderFile.close();
-            fShaderFile.close();
-            // convert stream into string
-            vertexCode = vShaderStream.str();
-            fragmentCode = fShaderStream.str();
-            // if geometry shader path is present, also load a geometry shader
-            if (geometryPath != nullptr) {
-                gShaderFile.open(geometryPath);
-                std::stringstream gShaderStream;
-                gShaderStream << gShaderFile.rdbuf();
-                gShaderFile.close();
-                geometryCode = gShaderStream.str();
-            }
-        } catch (std::ifstream::failure &e) {
-            std::cout << "ERROR::SHADER::FILE_NOT_SUCCESFULLY_READ" << std::endl;
-        }
-        const char *vShaderCode = vertexCode.c_str();
-        const char *fShaderCode = fragmentCode.c_str();
-        // 2. compile shaders
-        unsigned int vertex, fragment;
-        // vertex shader
-        vertex = glCreateShader(GL_VERTEX_SHADER);
-        glShaderSource(vertex, 1, &vShaderCode, NULL);
-        glCompileShader(vertex);
-        checkCompileErrors(vertex, "VERTEX");
-        // fragment Shader
-        fragment = glCreateShader(GL_FRAGMENT_SHADER);
-        glShaderSource(fragment, 1, &fShaderCode, NULL);
-        glCompileShader(fragment);
-        checkCompileErrors(fragment, "FRAGMENT");
-        // if geometry shader is given, compile geometry shader
-        unsigned int geometry;
-        if (geometryPath != nullptr) {
-            const char *gShaderCode = geometryCode.c_str();
-            geometry = glCreateShader(GL_GEOMETRY_SHADER);
-            glShaderSource(geometry, 1, &gShaderCode, NULL);
-            glCompileShader(geometry);
-            checkCompileErrors(geometry, "GEOMETRY");
-        }
-        // shader Program
-        ID = glCreateProgram();
-        glAttachShader(ID, vertex);
-        glAttachShader(ID, fragment);
-        if (geometryPath != nullptr) glAttachShader(ID, geometry);
-        glLinkProgram(ID);
-        checkCompileErrors(ID, "PROGRAM");
-        // delete the shaders as they're linked into our program now and no longer necessery
-        glDeleteShader(vertex);
-        glDeleteShader(fragment);
-        if (geometryPath != nullptr) glDeleteShader(geometry);
-    }
-    // activate the shader
-    // ------------------------------------------------------------------------
-    void use() {
-        glUseProgram(ID);
-    }
-    // utility uniform functions
-    // ------------------------------------------------------------------------
-    void setBool(const std::string &name, bool value) const {
-        glUniform1i(glGetUniformLocation(ID, name.c_str()), (int)value);
-    }
-    // ------------------------------------------------------------------------
-    void setInt(const std::string &name, int value) const {
-        glUniform1i(glGetUniformLocation(ID, name.c_str()), value);
-    }
-    // ------------------------------------------------------------------------
-    void setFloat(const std::string &name, float value) const {
-        glUniform1f(glGetUniformLocation(ID, name.c_str()), value);
-    }
-    // ------------------------------------------------------------------------
-    void setVec2(const std::string &name, const glm::vec2 &value) const {
-        glUniform2fv(glGetUniformLocation(ID, name.c_str()), 1, &value[0]);
-    }
-    void setVec2(const std::string &name, float x, float y) const {
-        glUniform2f(glGetUniformLocation(ID, name.c_str()), x, y);
-    }
-    // ------------------------------------------------------------------------
-    void setVec3(const std::string &name, const glm::vec3 &value) const {
-        glUniform3fv(glGetUniformLocation(ID, name.c_str()), 1, &value[0]);
-    }
-    void setVec3(const std::string &name, float x, float y, float z) const {
-        glUniform3f(glGetUniformLocation(ID, name.c_str()), x, y, z);
-    }
-    // ------------------------------------------------------------------------
-    void setVec4(const std::string &name, const glm::vec4 &value) const {
-        glUniform4fv(glGetUniformLocation(ID, name.c_str()), 1, &value[0]);
-    }
-    void setVec4(const std::string &name, float x, float y, float z, float w) {
-        glUniform4f(glGetUniformLocation(ID, name.c_str()), x, y, z, w);
-    }
-    // ------------------------------------------------------------------------
-    void setMat2(const std::string &name, const glm::mat2 &mat) const {
-        glUniformMatrix2fv(glGetUniformLocation(ID, name.c_str()), 1, GL_FALSE, &mat[0][0]);
-    }
-    // ------------------------------------------------------------------------
-    void setMat3(const std::string &name, const glm::mat3 &mat) const {
-        glUniformMatrix3fv(glGetUniformLocation(ID, name.c_str()), 1, GL_FALSE, &mat[0][0]);
-    }
-    // ------------------------------------------------------------------------
-    void setMat4(const std::string &name, const glm::mat4 &mat) const {
-        glUniformMatrix4fv(glGetUniformLocation(ID, name.c_str()), 1, GL_FALSE, &mat[0][0]);
-    }
-
-  private:
-    // utility function for checking shader compilation/linking errors.
-    // ------------------------------------------------------------------------
-    void checkCompileErrors(GLuint shader, std::string type) {
-        GLint success;
-        GLchar infoLog[1024];
-        if (type != "PROGRAM") {
-            glGetShaderiv(shader, GL_COMPILE_STATUS, &success);
-            if (!success) {
-                glGetShaderInfoLog(shader, 1024, NULL, infoLog);
-                std::cout << "ERROR::SHADER_COMPILATION_ERROR of type: " << type << "\n"
-                          << infoLog
-                          << "\n -- --------------------------------------------------- -- "
-                          << std::endl;
-            }
-        } else {
-            glGetProgramiv(shader, GL_LINK_STATUS, &success);
-            if (!success) {
-                glGetProgramInfoLog(shader, 1024, NULL, infoLog);
-                std::cout << "ERROR::PROGRAM_LINKING_ERROR of type: " << type << "\n"
-                          << infoLog
-                          << "\n -- --------------------------------------------------- -- "
-                          << std::endl;
-            }
-        }
-    }
-};
-
-}

include/Gedeng/Spatial.h

@@ -1,76 +0,0 @@
-#pragma once
-
-#include <glm/glm.hpp>
-#include <glm/gtc/matrix_transform.hpp>
-#include <glm/gtc/type_ptr.hpp>
-
-#include "glm/gtx/string_cast.hpp"
-
-namespace Gedeng {
-
-class Spatial {
-  public:
-    Spatial() = default;
-
-    void translate(glm::vec3 offset) {
-        matrix = glm::translate(matrix, offset);
-    }
-
-    glm::vec3 get_translation() {
-        return glm::vec3(matrix[3]);
-    }
-
-    void uniform_scale(float factor) {
-        scale(glm::vec3(factor, factor, factor));
-    }
-
-    void scale(glm::vec3 factors) {
-        matrix = glm::scale(matrix, factors);
-    }
-
-    void rotate(float degrees, glm::vec3 axis) {
-        matrix = glm::rotate(matrix, glm::radians(degrees), axis);
-    }
-
-    void set_origin(glm::vec3 position) {
-        origin = position;
-    }
-
-    void add_to_origin(glm::vec3 addition) {
-        origin += addition;
-    }
-
-    void set_rotation_from_quat(glm::quat quaternion) {
-        // Remember translation
-        glm::vec4 save = matrix[3];
-
-        matrix = glm::mat4_cast(quaternion);
-        matrix[3] = save;
-    }
-
-    glm::vec3 get_origin() const {
-        return origin;
-    }
-
-    glm::mat4 get_matrix() {
-        return matrix;
-    }
-
-    glm::vec3 forward() const {
-        return matrix * glm::vec4(0.0, 0.0, -1.0, 0.0);
-    }
-
-    glm::vec3 up() const {
-        return matrix * glm::vec4(0.0, 1.0, 0.0, 0.0);
-    }
-
-    glm::vec3 right() const {
-        return matrix * glm::vec4(1.0, 0.0, 0.0, 0.0);
-    }
-
-  private:
-    glm::mat4 matrix = glm::mat4(1.0f); // Initialize as identity
-    glm::vec3 origin = glm::vec3(0.0f, 0.0f, 0.0f);
-};
-
-}

include/Gedeng/Texture.h

@@ -1,38 +0,0 @@
-#pragma once
-
-// Must be the first include
-#include <glad/glad.h>
-
-// Other includes
-#include <GLFW/glfw3.h>
-#include <iostream>
-#include <string>
-
-namespace Gedeng {
-
-class Texture {
-  public:
-    struct Settings {
-        Settings() : mipmaps(true), transparent(false){};
-
-        bool mipmaps;
-        bool transparent;
-    };
-
-    explicit Texture(const std::string &path, Settings settings)
-        : id(load_texture(path, settings)), valid(false) {
-    }
-
-    bool is_valid() const;
-
-    // Bind a texture from the given path and return its ID
-    uint load_texture(const std::string &path, Settings settings);
-
-    void bind_to(int unit);
-
-  private:
-    const uint id;
-    bool valid;
-};
-
-}

include/Gedeng/Time.h

@@ -1,10 +0,0 @@
-#pragma once
-
-namespace Gedeng {
-
-class Time {
-public:
-    static unsigned long get_time_ms();
-};
-
-} // namespace Gedeng

include/Gedeng/VertexBuffer.h

@@ -1,28 +0,0 @@
-#pragma once
-
-// Must be the first include
-#include <glad/glad.h>
-
-// Other includes
-#include <GLFW/glfw3.h>
-
-namespace Gedeng {
-
-class VertexBuffer {
-  public:
-    VertexBuffer();
-
-    void set_data(int size, int dimension, const void *data, int flag);
-
-    void bind_array();
-    void bind_buffer();
-
-    void draw();
-
-  private:
-    GLuint vertex_array;
-    GLuint vertex_buffer;
-    int size;
-};
-
-}

test/test-app/main.cpp

@@ -4,23 +4,12 @@
 
 class TestApp : public Gedeng::Application {
   public:
-    TestApp(unsigned long ms_per_update, unsigned int window_size_x, unsigned int window_size_y,
-            Gedeng::String window_name)
-        : Application(ms_per_update, window_size_x, window_size_y, window_name) {
-    }
+    TestApp() = default;
 
     ~TestApp() = default;
-
-    void fixed_update(double delta) override {
-        GG_CLIENT_INFO("Fixed update");
-    }
-
-    void dynamic_update(double delta) override {
-        GG_CLIENT_INFO("Dynamic update");
-    }
 };
 
 Gedeng::Application *Gedeng::create_application() {
     GG_CLIENT_INFO("Creating Application");
-    return new TestApp(20, 900, 600, String("Test App"));
+    return new TestApp();
 }