Some refactoring and better usage of text

The initialization order in the Application was wrong, so some code has been moved from run to the constructor.

SConstruct

@@ -10,12 +10,16 @@ def add_strict_compile_flags(env):
     env.Append(CCFLAGS=["-Wall", "-Wextra", "-pedantic", "-std=c++17"])
 
 
+def add_debug_compile_flags(env):
+    env.Append(CCFLAGS=["-g"])
+
+
 # Create the environment and create a Compilation Database for use in VSCodium
 env = Environment(tools=['default', 'compilation_db'])
 env.CompilationDatabase()
 
 env.Append(CPPPATH=['cpp/', 'include/'])
-env.Append(LIBS=['glfw', 'dl'])
+env.Append(LIBS=['glfw', 'dl', 'freetype'])
 
 add_third_party_includes(env)
 add_strict_compile_flags(env)
@@ -45,9 +49,11 @@ testEnv.Append(LINKFLAGS=[
 
 add_third_party_includes(testEnv)
 add_strict_compile_flags(testEnv)
+add_debug_compile_flags(testEnv)
 
 # Build the test programs
 catch_cpp = "test/catch_amalgamated.cpp"
 testEnv.Program('test/bin/vector-test.out', [catch_cpp, 'test/vector/vector-test.cpp'])
 
 testEnv.Program('test/bin/test-app.out', Glob('test/test-app/*.cpp'))
+testEnv.Program('test/bin/parallax-demo.out', Glob('test/parallax-demo/*.cpp'))

cpp/Application.cpp

@@ -6,12 +6,16 @@
 
 namespace Gedeng {
 
-void Application::run() {
+Application::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) {
     // Setup Rendering
-    // FIXME: Make these parameters variable, maybe move this to a different function
-    RenderBackend::initialize_window(1920, 1080, String("Application"));
+    RenderBackend::initialize_window(WINDOW_SIZE_X, WINDOW_SIZE_Y, WINDOW_NAME);
     Input::initialize(RenderBackend::get_window());
+}
 
+void Application::run() {
     unsigned long previous_time_ms = Time::get_time_ms();
     unsigned long time_until_fixed_update_ms = 0.0;
 
@@ -26,13 +30,13 @@ void Application::run() {
 
         // Update fixed time step
         while (time_until_fixed_update_ms >= MS_PER_UPDATE) {
-            // Fixed Update
-            GG_CORE_INFO("Fixed Update");
+            fixed_update(static_cast<double>(MS_PER_UPDATE) / 1000.0);
             time_until_fixed_update_ms -= MS_PER_UPDATE;
         }
 
-        // Variable update
-        GG_CORE_INFO("Variable Update");
+        dynamic_update(static_cast<double>(elapsed_time_ms) / 1000.0);
+
+        RenderBackend::render();
     }
 }
 

cpp/RenderBackend.cpp

@@ -15,6 +15,11 @@ void RenderBackend::initialize_window(unsigned int width, unsigned int height, S
     window = glfwCreateWindow(width, height, title, NULL, NULL);
     glfwMakeContextCurrent(window);
     gladLoadGLLoader((GLADloadproc)glfwGetProcAddress);
+
+    glEnable(GL_DEPTH_TEST);
+    glEnable(GL_CULL_FACE);
+    glEnable(GL_BLEND);
+    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 }
 
 bool RenderBackend::is_window_created() {

cpp/String.cpp

@@ -5,13 +5,11 @@ namespace Gedeng {
 String::String() : String("") {
 }
 
-String::String(const char *stringText)
-    : length(strlen(stringText)), text(new char[length + sizeof(char)]) {
+String::String(const char *stringText) : length(strlen(stringText)), text(new char[length + sizeof(char)]) {
     memcpy(text, stringText, length + sizeof(char));
 }
 
-String::String(const String &other)
-    : length(other.getLength()), text(new char[length + sizeof(char)]) {
+String::String(const String &other) : length(other.get_length()), text(new char[length + sizeof(char)]) {
     memcpy(text, other.c_str(), length + sizeof(char));
 }
 
@@ -116,7 +114,7 @@ const char *String::c_str() const {
     return text;
 }
 
-size_t String::getLength() const {
+size_t String::get_length() const {
     return length;
 }
 

cpp/TextLabel.cpp

@@ -0,0 +1,132 @@
+// Must be the first include
+#include <glad/glad.h>
+
+// Other includes
+#include <GLFW/glfw3.h>
+#include <glm/ext/matrix_clip_space.hpp>
+#include <glm/gtc/type_ptr.hpp>
+
+#include "Gedeng/Logger.h"
+#include "Gedeng/TextLabel.h"
+
+namespace Gedeng {
+
+TextLabel::TextLabel(const String &text) : text(text), shader(Shader("Shader/text.vs", "Shader/text.fs")) {
+    FT_Library ft;
+    if (FT_Init_FreeType(&ft)) {
+        GG_CORE_ERROR("Couldn't create font library!");
+        return;
+    }
+
+    FT_Face face;
+    if (FT_New_Face(ft, "Resources/Fonts/Inter.ttf", 0, &face)) {
+        GG_CORE_ERROR("Couldn't load font from path!");
+        return;
+    }
+
+    // Set size
+    FT_Set_Pixel_Sizes(face, 0, 12);
+
+    // Load first 128 ASCII Characters
+    glPixelStorei(GL_UNPACK_ALIGNMENT, 1); // disable byte-alignment restriction
+
+    for (unsigned char c = 0; c < 128; c++) {
+        // load character glyph
+        if (FT_Load_Char(face, c, FT_LOAD_RENDER)) {
+            GG_CORE_ERROR("Couldn't load character glyph!");
+            continue;
+        }
+        // generate texture
+        unsigned int texture;
+        glGenTextures(1, &texture);
+        glBindTexture(GL_TEXTURE_2D, texture);
+        glTexImage2D(GL_TEXTURE_2D, 0, GL_RED, face->glyph->bitmap.width, face->glyph->bitmap.rows, 0, GL_RED,
+                     GL_UNSIGNED_BYTE, face->glyph->bitmap.buffer);
+        // set texture options
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+        // now store character for later use
+        Character character = {texture, glm::ivec2(face->glyph->bitmap.width, face->glyph->bitmap.rows),
+                               glm::ivec2(face->glyph->bitmap_left, face->glyph->bitmap_top),
+                               static_cast<unsigned int>(face->glyph->advance.x)};
+        characters.insert(std::pair<char, Character>(c, character));
+    }
+
+    glBindTexture(GL_TEXTURE_2D, 0);
+
+    // destroy FreeType once we're finished
+    FT_Done_Face(face);
+    FT_Done_FreeType(ft);
+
+    // configure VAO/VBO for texture quads
+    // -----------------------------------
+    glGenVertexArrays(1, &vao);
+    glGenBuffers(1, &vbo);
+    glBindVertexArray(vao);
+    glBindBuffer(GL_ARRAY_BUFFER, vbo);
+    glBufferData(GL_ARRAY_BUFFER, sizeof(float) * 6 * 4, NULL, GL_DYNAMIC_DRAW);
+    glEnableVertexAttribArray(0);
+    glVertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, 4 * sizeof(float), 0);
+    glBindBuffer(GL_ARRAY_BUFFER, 0);
+    glBindVertexArray(0);
+
+    valid = true;
+}
+
+void TextLabel::set_text(const String &text) {
+    this->text = text;
+}
+
+void TextLabel::render_text(float x, float y, float scale, Vector3 color) {
+    // activate corresponding render state
+    shader.use();
+
+    glUniform3f(glGetUniformLocation(shader.ID, "textColor"), color.x, color.y, color.z);
+
+    // FIXME: We need the screen size here... (or UI module size?)
+    glm::mat4 projection = glm::ortho(0.0f, static_cast<float>(900), 0.0f, static_cast<float>(600));
+    glUniformMatrix4fv(glGetUniformLocation(shader.ID, "projection"), 1, GL_FALSE, glm::value_ptr(projection));
+
+    glActiveTexture(GL_TEXTURE0);
+    glBindVertexArray(vao);
+
+    // iterate through all characters
+    for (size_t i = 0; i < text.get_length(); i++) {
+        Character ch = characters[text[i]];
+
+        float xpos = x + ch.bearing.x * scale;
+        float ypos = y - (ch.size.y - ch.bearing.y) * scale;
+
+        float w = ch.size.x * scale;
+        float h = ch.size.y * scale;
+        // update VBO for each character
+        float vertices[6][4] = {
+            {xpos, ypos + h, 0.0f, 0.0f}, {xpos, ypos, 0.0f, 1.0f},     {xpos + w, ypos, 1.0f, 1.0f},
+
+            {xpos, ypos + h, 0.0f, 0.0f}, {xpos + w, ypos, 1.0f, 1.0f}, {xpos + w, ypos + h, 1.0f, 0.0f}};
+        // render glyph texture over quad
+        glBindTexture(GL_TEXTURE_2D, ch.texture_id);
+        // update content of VBO memory
+        glBindBuffer(GL_ARRAY_BUFFER, vbo);
+        glBufferSubData(GL_ARRAY_BUFFER, 0, sizeof(vertices),
+                        vertices); // be sure to use glBufferSubData and not glBufferData
+
+        glBindBuffer(GL_ARRAY_BUFFER, 0);
+        // render quad
+        glDrawArrays(GL_TRIANGLES, 0, 6);
+        // now advance cursors for next glyph (note that advance is number of 1/64 pixels)
+        x += (ch.advance >> 6) * scale; // bitshift by 6 to get value in pixels (2^6 = 64 (divide amount of 1/64th
+                                        // pixels by 64 to get amount of pixels))
+    }
+
+    glBindVertexArray(0);
+    glBindTexture(GL_TEXTURE_2D, 0);
+}
+
+bool TextLabel::is_valid() {
+    return valid;
+}
+
+} // namespace Gedeng

cpp/vendor/glad.c

@@ -19,12 +19,12 @@
         https://glad.dav1d.de/#profile=core&language=c&specification=gl&loader=on&api=gl%3D4.3
 */
 
+#include <glad/glad.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
-#include <glad/glad.h>
 
-static void* get_proc(const char *namez);
+static void *get_proc(const char *namez);
 
 #if defined(_WIN32) || defined(__CYGWIN__)
 #ifndef _WINDOWS_
@@ -33,34 +33,33 @@ static void* get_proc(const char *namez);
 #include <windows.h>
 static HMODULE libGL;
 
-typedef void* (APIENTRYP PFNWGLGETPROCADDRESSPROC_PRIVATE)(const char*);
+typedef void *(APIENTRYP PFNWGLGETPROCADDRESSPROC_PRIVATE)(const char *);
 static PFNWGLGETPROCADDRESSPROC_PRIVATE gladGetProcAddressPtr;
 
 #ifdef _MSC_VER
 #ifdef __has_include
-  #if __has_include(<winapifamily.h>)
-    #define HAVE_WINAPIFAMILY 1
-  #endif
+#if __has_include(<winapifamily.h>)
+#define HAVE_WINAPIFAMILY 1
+#endif
 #elif _MSC_VER >= 1700 && !_USING_V110_SDK71_
-  #define HAVE_WINAPIFAMILY 1
+#define HAVE_WINAPIFAMILY 1
 #endif
 #endif
 
 #ifdef HAVE_WINAPIFAMILY
-  #include <winapifamily.h>
-  #if !WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) && WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP)
-    #define IS_UWP 1
-  #endif
+#include <winapifamily.h>
+#if !WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) && WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP)
+#define IS_UWP 1
+#endif
 #endif
 
-static
-int open_gl(void) {
+static int open_gl(void) {
 #ifndef IS_UWP
     libGL = LoadLibraryW(L"opengl32.dll");
-    if(libGL != NULL) {
-        void (* tmp)(void);
-        tmp = (void(*)(void)) GetProcAddress(libGL, "wglGetProcAddress");
-        gladGetProcAddressPtr = (PFNWGLGETPROCADDRESSPROC_PRIVATE) tmp;
+    if (libGL != NULL) {
+        void (*tmp)(void);
+        tmp = (void (*)(void))GetProcAddress(libGL, "wglGetProcAddress");
+        gladGetProcAddressPtr = (PFNWGLGETPROCADDRESSPROC_PRIVATE)tmp;
         return gladGetProcAddressPtr != NULL;
     }
 #endif
@@ -68,45 +67,40 @@ int open_gl(void) {
     return 0;
 }
 
-static
-void close_gl(void) {
-    if(libGL != NULL) {
-        FreeLibrary((HMODULE) libGL);
+static void close_gl(void) {
+    if (libGL != NULL) {
+        FreeLibrary((HMODULE)libGL);
         libGL = NULL;
     }
 }
 #else
 #include <dlfcn.h>
-static void* libGL;
+static void *libGL;
 
 #if !defined(__APPLE__) && !defined(__HAIKU__)
-typedef void* (APIENTRYP PFNGLXGETPROCADDRESSPROC_PRIVATE)(const char*);
+typedef void *(APIENTRYP PFNGLXGETPROCADDRESSPROC_PRIVATE)(const char *);
 static PFNGLXGETPROCADDRESSPROC_PRIVATE gladGetProcAddressPtr;
 #endif
 
-static
-int open_gl(void) {
+static int open_gl(void) {
 #ifdef __APPLE__
-    static const char *NAMES[] = {
-        "../Frameworks/OpenGL.framework/OpenGL",
+    static const char *NAMES[] = {"../Frameworks/OpenGL.framework/OpenGL",
                                   "/Library/Frameworks/OpenGL.framework/OpenGL",
                                   "/System/Library/Frameworks/OpenGL.framework/OpenGL",
-        "/System/Library/Frameworks/OpenGL.framework/Versions/Current/OpenGL"
-    };
+                                  "/System/Library/Frameworks/OpenGL.framework/Versions/Current/OpenGL"};
 #else
     static const char *NAMES[] = {"libGL.so.1", "libGL.so"};
 #endif
 
     unsigned int index = 0;
-    for(index = 0; index < (sizeof(NAMES) / sizeof(NAMES[0])); index++) {
+    for (index = 0; index < (sizeof(NAMES) / sizeof(NAMES[0])); index++) {
         libGL = dlopen(NAMES[index], RTLD_NOW | RTLD_GLOBAL);
 
-        if(libGL != NULL) {
+        if (libGL != NULL) {
 #if defined(__APPLE__) || defined(__HAIKU__)
             return 1;
 #else
-            gladGetProcAddressPtr = (PFNGLXGETPROCADDRESSPROC_PRIVATE)dlsym(libGL,
-                "glXGetProcAddressARB");
+            gladGetProcAddressPtr = (PFNGLXGETPROCADDRESSPROC_PRIVATE)dlsym(libGL, "glXGetProcAddressARB");
             return gladGetProcAddressPtr != NULL;
 #endif
         }
@@ -115,28 +109,26 @@ int open_gl(void) {
     return 0;
 }
 
-static
-void close_gl(void) {
-    if(libGL != NULL) {
+static void close_gl(void) {
+    if (libGL != NULL) {
         dlclose(libGL);
         libGL = NULL;
     }
 }
 #endif
 
-static
-void* get_proc(const char *namez) {
-    void* result = NULL;
-    if(libGL == NULL) return NULL;
+static void *get_proc(const char *namez) {
+    void *result = NULL;
+    if (libGL == NULL) return NULL;
 
 #if !defined(__APPLE__) && !defined(__HAIKU__)
-    if(gladGetProcAddressPtr != NULL) {
+    if (gladGetProcAddressPtr != NULL) {
         result = gladGetProcAddressPtr(namez);
     }
 #endif
-    if(result == NULL) {
+    if (result == NULL) {
 #if defined(_WIN32) || defined(__CYGWIN__)
-        result = (void*)GetProcAddress((HMODULE) libGL, namez);
+        result = (void *)GetProcAddress((HMODULE)libGL, namez);
 #else
         result = dlsym(libGL, namez);
 #endif
@@ -148,7 +140,7 @@ void* get_proc(const char *namez) {
 int gladLoadGL(void) {
     int status = 0;
 
-    if(open_gl()) {
+    if (open_gl()) {
         status = gladLoadGLLoader(&get_proc);
         close_gl();
     }
@@ -156,7 +148,7 @@ int gladLoadGL(void) {
     return status;
 }
 
-struct gladGLversionStruct GLVersion = { 0, 0 };
+struct gladGLversionStruct GLVersion = {0, 0};
 
 #if defined(GL_ES_VERSION_3_0) || defined(GL_VERSION_3_0)
 #define _GLAD_IS_SOME_NEW_VERSION 1
@@ -171,7 +163,7 @@ static char **exts_i = NULL;
 
 static int get_exts(void) {
 #ifdef _GLAD_IS_SOME_NEW_VERSION
-    if(max_loaded_major < 3) {
+    if (max_loaded_major < 3) {
 #endif
         exts = (const char *)glGetString(GL_EXTENSIONS);
 #ifdef _GLAD_IS_SOME_NEW_VERSION
@@ -188,13 +180,13 @@ static int get_exts(void) {
             return 0;
         }
 
-        for(index = 0; index < (unsigned)num_exts_i; index++) {
-            const char *gl_str_tmp = (const char*)glGetStringi(GL_EXTENSIONS, index);
+        for (index = 0; index < (unsigned)num_exts_i; index++) {
+            const char *gl_str_tmp = (const char *)glGetStringi(GL_EXTENSIONS, index);
             size_t len = strlen(gl_str_tmp);
 
-            char *local_str = (char*)malloc((len+1) * sizeof(char));
-            if(local_str != NULL) {
-                memcpy(local_str, gl_str_tmp, (len+1) * sizeof(char));
+            char *local_str = (char *)malloc((len + 1) * sizeof(char));
+            if (local_str != NULL) {
+                memcpy(local_str, gl_str_tmp, (len + 1) * sizeof(char));
             }
             exts_i[index] = local_str;
         }
@@ -206,7 +198,7 @@ static int get_exts(void) {
 static void free_exts(void) {
     if (exts_i != NULL) {
         int index;
-        for(index = 0; index < num_exts_i; index++) {
+        for (index = 0; index < num_exts_i; index++) {
             free((char *)exts_i[index]);
         }
         free((void *)exts_i);
@@ -216,25 +208,24 @@ static void free_exts(void) {
 
 static int has_ext(const char *ext) {
 #ifdef _GLAD_IS_SOME_NEW_VERSION
-    if(max_loaded_major < 3) {
+    if (max_loaded_major < 3) {
 #endif
         const char *extensions;
         const char *loc;
         const char *terminator;
         extensions = exts;
-        if(extensions == NULL || ext == NULL) {
+        if (extensions == NULL || ext == NULL) {
             return 0;
         }
 
-        while(1) {
+        while (1) {
             loc = strstr(extensions, ext);
-            if(loc == NULL) {
+            if (loc == NULL) {
                 return 0;
             }
 
             terminator = loc + strlen(ext);
-            if((loc == extensions || *(loc - 1) == ' ') &&
-                (*terminator == ' ' || *terminator == '\0')) {
+            if ((loc == extensions || *(loc - 1) == ' ') && (*terminator == ' ' || *terminator == '\0')) {
                 return 1;
             }
             extensions = terminator;
@@ -242,11 +233,11 @@ static int has_ext(const char *ext) {
 #ifdef _GLAD_IS_SOME_NEW_VERSION
     } else {
         int index;
-        if(exts_i == NULL) return 0;
-        for(index = 0; index < num_exts_i; index++) {
+        if (exts_i == NULL) return 0;
+        for (index = 0; index < num_exts_i; index++) {
             const char *e = exts_i[index];
 
-            if(exts_i[index] != NULL && strcmp(e, ext) == 0) {
+            if (exts_i[index] != NULL && strcmp(e, ext) == 0) {
                 return 1;
             }
         }
@@ -836,7 +827,7 @@ PFNGLVIEWPORTINDEXEDFPROC glad_glViewportIndexedf = NULL;
 PFNGLVIEWPORTINDEXEDFVPROC glad_glViewportIndexedfv = NULL;
 PFNGLWAITSYNCPROC glad_glWaitSync = NULL;
 static void load_GL_VERSION_1_0(GLADloadproc load) {
-	if(!GLAD_GL_VERSION_1_0) return;
+    if (!GLAD_GL_VERSION_1_0) return;
     glad_glCullFace = (PFNGLCULLFACEPROC)load("glCullFace");
     glad_glFrontFace = (PFNGLFRONTFACEPROC)load("glFrontFace");
     glad_glHint = (PFNGLHINTPROC)load("glHint");
@@ -887,7 +878,7 @@ static void load_GL_VERSION_1_0(GLADloadproc load) {
     glad_glViewport = (PFNGLVIEWPORTPROC)load("glViewport");
 }
 static void load_GL_VERSION_1_1(GLADloadproc load) {
-	if(!GLAD_GL_VERSION_1_1) return;
+    if (!GLAD_GL_VERSION_1_1) return;
     glad_glDrawArrays = (PFNGLDRAWARRAYSPROC)load("glDrawArrays");
     glad_glDrawElements = (PFNGLDRAWELEMENTSPROC)load("glDrawElements");
     glad_glPolygonOffset = (PFNGLPOLYGONOFFSETPROC)load("glPolygonOffset");
@@ -903,14 +894,14 @@ static void load_GL_VERSION_1_1(GLADloadproc load) {
     glad_glIsTexture = (PFNGLISTEXTUREPROC)load("glIsTexture");
 }
 static void load_GL_VERSION_1_2(GLADloadproc load) {
-	if(!GLAD_GL_VERSION_1_2) return;
+    if (!GLAD_GL_VERSION_1_2) return;
     glad_glDrawRangeElements = (PFNGLDRAWRANGEELEMENTSPROC)load("glDrawRangeElements");
     glad_glTexImage3D = (PFNGLTEXIMAGE3DPROC)load("glTexImage3D");
     glad_glTexSubImage3D = (PFNGLTEXSUBIMAGE3DPROC)load("glTexSubImage3D");
     glad_glCopyTexSubImage3D = (PFNGLCOPYTEXSUBIMAGE3DPROC)load("glCopyTexSubImage3D");
 }
 static void load_GL_VERSION_1_3(GLADloadproc load) {
-	if(!GLAD_GL_VERSION_1_3) return;
+    if (!GLAD_GL_VERSION_1_3) return;
     glad_glActiveTexture = (PFNGLACTIVETEXTUREPROC)load("glActiveTexture");
     glad_glSampleCoverage = (PFNGLSAMPLECOVERAGEPROC)load("glSampleCoverage");
     glad_glCompressedTexImage3D = (PFNGLCOMPRESSEDTEXIMAGE3DPROC)load("glCompressedTexImage3D");
@@ -922,7 +913,7 @@ static void load_GL_VERSION_1_3(GLADloadproc load) {
     glad_glGetCompressedTexImage = (PFNGLGETCOMPRESSEDTEXIMAGEPROC)load("glGetCompressedTexImage");
 }
 static void load_GL_VERSION_1_4(GLADloadproc load) {
-	if(!GLAD_GL_VERSION_1_4) return;
+    if (!GLAD_GL_VERSION_1_4) return;
     glad_glBlendFuncSeparate = (PFNGLBLENDFUNCSEPARATEPROC)load("glBlendFuncSeparate");
     glad_glMultiDrawArrays = (PFNGLMULTIDRAWARRAYSPROC)load("glMultiDrawArrays");
     glad_glMultiDrawElements = (PFNGLMULTIDRAWELEMENTSPROC)load("glMultiDrawElements");
@@ -934,7 +925,7 @@ static void load_GL_VERSION_1_4(GLADloadproc load) {
     glad_glBlendEquation = (PFNGLBLENDEQUATIONPROC)load("glBlendEquation");
 }
 static void load_GL_VERSION_1_5(GLADloadproc load) {
-	if(!GLAD_GL_VERSION_1_5) return;
+    if (!GLAD_GL_VERSION_1_5) return;
     glad_glGenQueries = (PFNGLGENQUERIESPROC)load("glGenQueries");
     glad_glDeleteQueries = (PFNGLDELETEQUERIESPROC)load("glDeleteQueries");
     glad_glIsQuery = (PFNGLISQUERYPROC)load("glIsQuery");
@@ -956,7 +947,7 @@ static void load_GL_VERSION_1_5(GLADloadproc load) {
     glad_glGetBufferPointerv = (PFNGLGETBUFFERPOINTERVPROC)load("glGetBufferPointerv");
 }
 static void load_GL_VERSION_2_0(GLADloadproc load) {
-	if(!GLAD_GL_VERSION_2_0) return;
+    if (!GLAD_GL_VERSION_2_0) return;
     glad_glBlendEquationSeparate = (PFNGLBLENDEQUATIONSEPARATEPROC)load("glBlendEquationSeparate");
     glad_glDrawBuffers = (PFNGLDRAWBUFFERSPROC)load("glDrawBuffers");
     glad_glStencilOpSeparate = (PFNGLSTENCILOPSEPARATEPROC)load("glStencilOpSeparate");
@@ -1052,7 +1043,7 @@ static void load_GL_VERSION_2_0(GLADloadproc load) {
     glad_glVertexAttribPointer = (PFNGLVERTEXATTRIBPOINTERPROC)load("glVertexAttribPointer");
 }
 static void load_GL_VERSION_2_1(GLADloadproc load) {
-	if(!GLAD_GL_VERSION_2_1) return;
+    if (!GLAD_GL_VERSION_2_1) return;
     glad_glUniformMatrix2x3fv = (PFNGLUNIFORMMATRIX2X3FVPROC)load("glUniformMatrix2x3fv");
     glad_glUniformMatrix3x2fv = (PFNGLUNIFORMMATRIX3X2FVPROC)load("glUniformMatrix3x2fv");
     glad_glUniformMatrix2x4fv = (PFNGLUNIFORMMATRIX2X4FVPROC)load("glUniformMatrix2x4fv");
@@ -1061,7 +1052,7 @@ static void load_GL_VERSION_2_1(GLADloadproc load) {
     glad_glUniformMatrix4x3fv = (PFNGLUNIFORMMATRIX4X3FVPROC)load("glUniformMatrix4x3fv");
 }
 static void load_GL_VERSION_3_0(GLADloadproc load) {
-	if(!GLAD_GL_VERSION_3_0) return;
+    if (!GLAD_GL_VERSION_3_0) return;
     glad_glColorMaski = (PFNGLCOLORMASKIPROC)load("glColorMaski");
     glad_glGetBooleani_v = (PFNGLGETBOOLEANI_VPROC)load("glGetBooleani_v");
     glad_glGetIntegeri_v = (PFNGLGETINTEGERI_VPROC)load("glGetIntegeri_v");
@@ -1135,10 +1126,12 @@ static void load_GL_VERSION_3_0(GLADloadproc load) {
     glad_glFramebufferTexture2D = (PFNGLFRAMEBUFFERTEXTURE2DPROC)load("glFramebufferTexture2D");
     glad_glFramebufferTexture3D = (PFNGLFRAMEBUFFERTEXTURE3DPROC)load("glFramebufferTexture3D");
     glad_glFramebufferRenderbuffer = (PFNGLFRAMEBUFFERRENDERBUFFERPROC)load("glFramebufferRenderbuffer");
-	glad_glGetFramebufferAttachmentParameteriv = (PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC)load("glGetFramebufferAttachmentParameteriv");
+    glad_glGetFramebufferAttachmentParameteriv =
+        (PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC)load("glGetFramebufferAttachmentParameteriv");
     glad_glGenerateMipmap = (PFNGLGENERATEMIPMAPPROC)load("glGenerateMipmap");
     glad_glBlitFramebuffer = (PFNGLBLITFRAMEBUFFERPROC)load("glBlitFramebuffer");
-	glad_glRenderbufferStorageMultisample = (PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC)load("glRenderbufferStorageMultisample");
+    glad_glRenderbufferStorageMultisample =
+        (PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC)load("glRenderbufferStorageMultisample");
     glad_glFramebufferTextureLayer = (PFNGLFRAMEBUFFERTEXTURELAYERPROC)load("glFramebufferTextureLayer");
     glad_glMapBufferRange = (PFNGLMAPBUFFERRANGEPROC)load("glMapBufferRange");
     glad_glFlushMappedBufferRange = (PFNGLFLUSHMAPPEDBUFFERRANGEPROC)load("glFlushMappedBufferRange");
@@ -1148,7 +1141,7 @@ static void load_GL_VERSION_3_0(GLADloadproc load) {
     glad_glIsVertexArray = (PFNGLISVERTEXARRAYPROC)load("glIsVertexArray");
 }
 static void load_GL_VERSION_3_1(GLADloadproc load) {
-	if(!GLAD_GL_VERSION_3_1) return;
+    if (!GLAD_GL_VERSION_3_1) return;
     glad_glDrawArraysInstanced = (PFNGLDRAWARRAYSINSTANCEDPROC)load("glDrawArraysInstanced");
     glad_glDrawElementsInstanced = (PFNGLDRAWELEMENTSINSTANCEDPROC)load("glDrawElementsInstanced");
     glad_glTexBuffer = (PFNGLTEXBUFFERPROC)load("glTexBuffer");
@@ -1166,10 +1159,11 @@ static void load_GL_VERSION_3_1(GLADloadproc load) {
     glad_glGetIntegeri_v = (PFNGLGETINTEGERI_VPROC)load("glGetIntegeri_v");
 }
 static void load_GL_VERSION_3_2(GLADloadproc load) {
-	if(!GLAD_GL_VERSION_3_2) return;
+    if (!GLAD_GL_VERSION_3_2) return;
     glad_glDrawElementsBaseVertex = (PFNGLDRAWELEMENTSBASEVERTEXPROC)load("glDrawElementsBaseVertex");
     glad_glDrawRangeElementsBaseVertex = (PFNGLDRAWRANGEELEMENTSBASEVERTEXPROC)load("glDrawRangeElementsBaseVertex");
-	glad_glDrawElementsInstancedBaseVertex = (PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXPROC)load("glDrawElementsInstancedBaseVertex");
+    glad_glDrawElementsInstancedBaseVertex =
+        (PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXPROC)load("glDrawElementsInstancedBaseVertex");
     glad_glMultiDrawElementsBaseVertex = (PFNGLMULTIDRAWELEMENTSBASEVERTEXPROC)load("glMultiDrawElementsBaseVertex");
     glad_glProvokingVertex = (PFNGLPROVOKINGVERTEXPROC)load("glProvokingVertex");
     glad_glFenceSync = (PFNGLFENCESYNCPROC)load("glFenceSync");
@@ -1188,7 +1182,7 @@ static void load_GL_VERSION_3_2(GLADloadproc load) {
     glad_glSampleMaski = (PFNGLSAMPLEMASKIPROC)load("glSampleMaski");
 }
 static void load_GL_VERSION_3_3(GLADloadproc load) {
-	if(!GLAD_GL_VERSION_3_3) return;
+    if (!GLAD_GL_VERSION_3_3) return;
     glad_glBindFragDataLocationIndexed = (PFNGLBINDFRAGDATALOCATIONINDEXEDPROC)load("glBindFragDataLocationIndexed");
     glad_glGetFragDataIndex = (PFNGLGETFRAGDATAINDEXPROC)load("glGetFragDataIndex");
     glad_glGenSamplers = (PFNGLGENSAMPLERSPROC)load("glGenSamplers");
@@ -1249,7 +1243,7 @@ static void load_GL_VERSION_3_3(GLADloadproc load) {
     glad_glSecondaryColorP3uiv = (PFNGLSECONDARYCOLORP3UIVPROC)load("glSecondaryColorP3uiv");
 }
 static void load_GL_VERSION_4_0(GLADloadproc load) {
-	if(!GLAD_GL_VERSION_4_0) return;
+    if (!GLAD_GL_VERSION_4_0) return;
     glad_glMinSampleShading = (PFNGLMINSAMPLESHADINGPROC)load("glMinSampleShading");
     glad_glBlendEquationi = (PFNGLBLENDEQUATIONIPROC)load("glBlendEquationi");
     glad_glBlendEquationSeparatei = (PFNGLBLENDEQUATIONSEPARATEIPROC)load("glBlendEquationSeparatei");
@@ -1278,7 +1272,8 @@ static void load_GL_VERSION_4_0(GLADloadproc load) {
     glad_glGetSubroutineUniformLocation = (PFNGLGETSUBROUTINEUNIFORMLOCATIONPROC)load("glGetSubroutineUniformLocation");
     glad_glGetSubroutineIndex = (PFNGLGETSUBROUTINEINDEXPROC)load("glGetSubroutineIndex");
     glad_glGetActiveSubroutineUniformiv = (PFNGLGETACTIVESUBROUTINEUNIFORMIVPROC)load("glGetActiveSubroutineUniformiv");
-	glad_glGetActiveSubroutineUniformName = (PFNGLGETACTIVESUBROUTINEUNIFORMNAMEPROC)load("glGetActiveSubroutineUniformName");
+    glad_glGetActiveSubroutineUniformName =
+        (PFNGLGETACTIVESUBROUTINEUNIFORMNAMEPROC)load("glGetActiveSubroutineUniformName");
     glad_glGetActiveSubroutineName = (PFNGLGETACTIVESUBROUTINENAMEPROC)load("glGetActiveSubroutineName");
     glad_glUniformSubroutinesuiv = (PFNGLUNIFORMSUBROUTINESUIVPROC)load("glUniformSubroutinesuiv");
     glad_glGetUniformSubroutineuiv = (PFNGLGETUNIFORMSUBROUTINEUIVPROC)load("glGetUniformSubroutineuiv");
@@ -1298,7 +1293,7 @@ static void load_GL_VERSION_4_0(GLADloadproc load) {
     glad_glGetQueryIndexediv = (PFNGLGETQUERYINDEXEDIVPROC)load("glGetQueryIndexediv");
 }
 static void load_GL_VERSION_4_1(GLADloadproc load) {
-	if(!GLAD_GL_VERSION_4_1) return;
+    if (!GLAD_GL_VERSION_4_1) return;
     glad_glReleaseShaderCompiler = (PFNGLRELEASESHADERCOMPILERPROC)load("glReleaseShaderCompiler");
     glad_glShaderBinary = (PFNGLSHADERBINARYPROC)load("glShaderBinary");
     glad_glGetShaderPrecisionFormat = (PFNGLGETSHADERPRECISIONFORMATPROC)load("glGetShaderPrecisionFormat");
@@ -1390,22 +1385,28 @@ static void load_GL_VERSION_4_1(GLADloadproc load) {
     glad_glGetDoublei_v = (PFNGLGETDOUBLEI_VPROC)load("glGetDoublei_v");
 }
 static void load_GL_VERSION_4_2(GLADloadproc load) {
-	if(!GLAD_GL_VERSION_4_2) return;
-	glad_glDrawArraysInstancedBaseInstance = (PFNGLDRAWARRAYSINSTANCEDBASEINSTANCEPROC)load("glDrawArraysInstancedBaseInstance");
-	glad_glDrawElementsInstancedBaseInstance = (PFNGLDRAWELEMENTSINSTANCEDBASEINSTANCEPROC)load("glDrawElementsInstancedBaseInstance");
-	glad_glDrawElementsInstancedBaseVertexBaseInstance = (PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXBASEINSTANCEPROC)load("glDrawElementsInstancedBaseVertexBaseInstance");
+    if (!GLAD_GL_VERSION_4_2) return;
+    glad_glDrawArraysInstancedBaseInstance =
+        (PFNGLDRAWARRAYSINSTANCEDBASEINSTANCEPROC)load("glDrawArraysInstancedBaseInstance");
+    glad_glDrawElementsInstancedBaseInstance =
+        (PFNGLDRAWELEMENTSINSTANCEDBASEINSTANCEPROC)load("glDrawElementsInstancedBaseInstance");
+    glad_glDrawElementsInstancedBaseVertexBaseInstance =
+        (PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXBASEINSTANCEPROC)load("glDrawElementsInstancedBaseVertexBaseInstance");
     glad_glGetInternalformativ = (PFNGLGETINTERNALFORMATIVPROC)load("glGetInternalformativ");
-	glad_glGetActiveAtomicCounterBufferiv = (PFNGLGETACTIVEATOMICCOUNTERBUFFERIVPROC)load("glGetActiveAtomicCounterBufferiv");
+    glad_glGetActiveAtomicCounterBufferiv =
+        (PFNGLGETACTIVEATOMICCOUNTERBUFFERIVPROC)load("glGetActiveAtomicCounterBufferiv");
     glad_glBindImageTexture = (PFNGLBINDIMAGETEXTUREPROC)load("glBindImageTexture");
     glad_glMemoryBarrier = (PFNGLMEMORYBARRIERPROC)load("glMemoryBarrier");
     glad_glTexStorage1D = (PFNGLTEXSTORAGE1DPROC)load("glTexStorage1D");
     glad_glTexStorage2D = (PFNGLTEXSTORAGE2DPROC)load("glTexStorage2D");
     glad_glTexStorage3D = (PFNGLTEXSTORAGE3DPROC)load("glTexStorage3D");
-	glad_glDrawTransformFeedbackInstanced = (PFNGLDRAWTRANSFORMFEEDBACKINSTANCEDPROC)load("glDrawTransformFeedbackInstanced");
-	glad_glDrawTransformFeedbackStreamInstanced = (PFNGLDRAWTRANSFORMFEEDBACKSTREAMINSTANCEDPROC)load("glDrawTransformFeedbackStreamInstanced");
+    glad_glDrawTransformFeedbackInstanced =
+        (PFNGLDRAWTRANSFORMFEEDBACKINSTANCEDPROC)load("glDrawTransformFeedbackInstanced");
+    glad_glDrawTransformFeedbackStreamInstanced =
+        (PFNGLDRAWTRANSFORMFEEDBACKSTREAMINSTANCEDPROC)load("glDrawTransformFeedbackStreamInstanced");
 }
 static void load_GL_VERSION_4_3(GLADloadproc load) {
-	if(!GLAD_GL_VERSION_4_3) return;
+    if (!GLAD_GL_VERSION_4_3) return;
     glad_glClearBufferData = (PFNGLCLEARBUFFERDATAPROC)load("glClearBufferData");
     glad_glClearBufferSubData = (PFNGLCLEARBUFFERSUBDATAPROC)load("glClearBufferSubData");
     glad_glDispatchCompute = (PFNGLDISPATCHCOMPUTEPROC)load("glDispatchCompute");
@@ -1427,7 +1428,8 @@ static void load_GL_VERSION_4_3(GLADloadproc load) {
     glad_glGetProgramResourceName = (PFNGLGETPROGRAMRESOURCENAMEPROC)load("glGetProgramResourceName");
     glad_glGetProgramResourceiv = (PFNGLGETPROGRAMRESOURCEIVPROC)load("glGetProgramResourceiv");
     glad_glGetProgramResourceLocation = (PFNGLGETPROGRAMRESOURCELOCATIONPROC)load("glGetProgramResourceLocation");
-	glad_glGetProgramResourceLocationIndex = (PFNGLGETPROGRAMRESOURCELOCATIONINDEXPROC)load("glGetProgramResourceLocationIndex");
+    glad_glGetProgramResourceLocationIndex =
+        (PFNGLGETPROGRAMRESOURCELOCATIONINDEXPROC)load("glGetProgramResourceLocationIndex");
     glad_glShaderStorageBlockBinding = (PFNGLSHADERSTORAGEBLOCKBINDINGPROC)load("glShaderStorageBlockBinding");
     glad_glTexBufferRange = (PFNGLTEXBUFFERRANGEPROC)load("glTexBufferRange");
     glad_glTexStorage2DMultisample = (PFNGLTEXSTORAGE2DMULTISAMPLEPROC)load("glTexStorage2DMultisample");
@@ -1466,15 +1468,10 @@ static void find_coreGL(void) {
      */
     int i, major, minor;
 
-    const char* version;
-    const char* prefixes[] = {
-        "OpenGL ES-CM ",
-        "OpenGL ES-CL ",
-        "OpenGL ES ",
-        NULL
-    };
+    const char *version;
+    const char *prefixes[] = {"OpenGL ES-CM ", "OpenGL ES-CL ", "OpenGL ES ", NULL};
 
-    version = (const char*) glGetString(GL_VERSION);
+    version = (const char *)glGetString(GL_VERSION);
     if (!version) return;
 
     for (i = 0; prefixes[i]; i++) {
@@ -1492,8 +1489,10 @@ static void find_coreGL(void) {
     sscanf(version, "%d.%d", &major, &minor);
 #endif
 
-    GLVersion.major = major; GLVersion.minor = minor;
-    max_loaded_major = major; max_loaded_minor = minor;
+    GLVersion.major = major;
+    GLVersion.minor = minor;
+    max_loaded_major = major;
+    max_loaded_minor = minor;
     GLAD_GL_VERSION_1_0 = (major == 1 && minor >= 0) || major > 1;
     GLAD_GL_VERSION_1_1 = (major == 1 && minor >= 1) || major > 1;
     GLAD_GL_VERSION_1_2 = (major == 1 && minor >= 2) || major > 1;
@@ -1517,10 +1516,11 @@ static void find_coreGL(void) {
 }
 
 int gladLoadGLLoader(GLADloadproc load) {
-	GLVersion.major = 0; GLVersion.minor = 0;
+    GLVersion.major = 0;
+    GLVersion.minor = 0;
     glGetString = (PFNGLGETSTRINGPROC)load("glGetString");
-	if(glGetString == NULL) return 0;
-	if(glGetString(GL_VERSION) == NULL) return 0;
+    if (glGetString == NULL) return 0;
+    if (glGetString(GL_VERSION) == NULL) return 0;
     find_coreGL();
     load_GL_VERSION_1_0(load);
     load_GL_VERSION_1_1(load);
@@ -1542,4 +1542,3 @@ int gladLoadGLLoader(GLADloadproc load) {
     if (!find_extensionsGL()) return 0;
     return GLVersion.major != 0 || GLVersion.minor != 0;
 }
-

include/Gedeng/Application.h

@@ -1,18 +1,34 @@
 #pragma once
 
+#include "String.h"
+
 namespace Gedeng {
 
 class Application {
   public:
-    Application() = default;
+    Application(unsigned long ms_per_update, unsigned int window_size_x, unsigned int window_size_y,
+                String window_name);
 
     // 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;
+
   private:
-    const unsigned long MS_PER_UPDATE = 20;
+    // 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/Input.h

@@ -17,7 +17,8 @@ class Input {
         glfwSetKeyCallback(window, key_callback);
     }
 
-    // FIXME: Ignore warnings produced by these unused variables -- they're required for the callback to work
+    // 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);
 

include/Gedeng/Shader.h

@@ -2,7 +2,11 @@
 
 // Adapted from LearnOpenGL
 
+// Must be the first include
 #include <glad/glad.h>
+
+// Other includes
+#include <GLFW/glfw3.h>
 #include <glm/glm.hpp>
 
 #include <fstream>
@@ -152,21 +156,17 @@ class Shader {
             if (!success) {
                 glGetShaderInfoLog(shader, 1024, NULL, infoLog);
                 std::cout << "ERROR::SHADER_COMPILATION_ERROR of type: " << type << "\n"
-                          << infoLog
-                          << "\n -- --------------------------------------------------- -- "
-                          << std::endl;
+                          << 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;
+                          << infoLog << "\n -- --------------------------------------------------- -- " << std::endl;
             }
         }
     }
 };
 
-}
+} // namespace Gedeng

include/Gedeng/String.h

@@ -48,7 +48,7 @@ class String {
     const char *c_str() const;
 
     /// Return the length of the String (without the terminator).
-    size_t getLength() const;
+    size_t get_length() const;
 
   private:
     size_t length;

include/Gedeng/TextLabel.h

@@ -0,0 +1,41 @@
+#pragma once
+
+#include <ft2build.h>
+#include <glm/glm.hpp>
+#include <map>
+#include FT_FREETYPE_H
+
+#include "Gedeng/Shader.h"
+#include "Gedeng/String.h"
+#include "Gedeng/Vector3.h"
+
+namespace Gedeng {
+
+class TextLabel {
+  public:
+    TextLabel(const String &text = String(""));
+
+    void set_text(const String &text);
+
+    void render_text(float x, float y, float scale, Vector3 color);
+
+    bool is_valid();
+
+  private:
+    struct Character {
+        unsigned int texture_id; // ID handle of the glyph texture
+        glm::ivec2 size;         // Size of glyph
+        glm::ivec2 bearing;      // Offset from baseline to left/top of glyph
+        unsigned int advance;    // Offset to advance to next glyph
+    };
+
+    std::map<char, Character> characters;
+    unsigned int vao, vbo;
+
+    String text;
+    bool valid;
+
+    Shader shader;
+};
+
+} // namespace Gedeng

include/Gedeng/Vector3.h

@@ -2,6 +2,14 @@
 
 namespace Gedeng {
 
-class Vector3 {};
+class Vector3 {
+  public:
+    Vector3(float x, float y, float z) : x(x), y(y), z(z) {
+    }
+
+    float x;
+    float y;
+    float z;
+};
 
 } // namespace Gedeng

test/parallax-demo/main.cpp

@@ -0,0 +1,112 @@
+#include "Gedeng/Logger.h"
+#include "Gedeng/TextLabel.h"
+#include "Gedeng/Vector3.h"
+#define GEDENG_MAIN
+#include <Gedeng.h>
+
+class ParallaxApp : public Gedeng::Application {
+  public:
+    ParallaxApp(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), number_of_steps(10.0),
+          number_of_refinement_steps(10.0), bump_depth(0.1),
+          render_shader(Gedeng::Shader("Shader/bump.vs", "Shader/bump.fs")),
+          camera(Gedeng::Camera(90, 1920, 1080, 0.1, 1000.0)),
+          albedo("Resources/Textures/PavingStones/PavingStones070_2K_Color.jpg", Gedeng::Texture::Settings()),
+          bump("Resources/Textures/PavingStones/PavingStones070_2K_Displacement.jpg", Gedeng::Texture::Settings()),
+          normal("Resources/Textures/PavingStones/PavingStones070_2K_Normal.jpg", Gedeng::Texture::Settings()) {
+        // Move and rotate the camera so we see the quad well
+        camera.translate(glm::vec3(0.0, -1.0, 1.0));
+        camera.rotate(30, glm::vec3(1.0, 0.0, 0.0));
+    }
+
+    ~ParallaxApp() = default;
+
+    void fixed_update(double delta) override {
+        // Settings for bump mapping
+        if (Gedeng::Input::is_key_down(GLFW_KEY_Q)) {
+            number_of_steps += delta * 5.0;
+        }
+        if (Gedeng::Input::is_key_down(GLFW_KEY_W)) {
+            number_of_steps -= delta * 5.0;
+        }
+        if (Gedeng::Input::is_key_down(GLFW_KEY_A)) {
+            number_of_refinement_steps += delta * 5.0;
+        }
+        if (Gedeng::Input::is_key_down(GLFW_KEY_S)) {
+            number_of_refinement_steps -= delta * 5.0;
+        }
+        if (Gedeng::Input::is_key_down(GLFW_KEY_Z)) {
+            bump_depth += delta * 0.1;
+        }
+        if (Gedeng::Input::is_key_down(GLFW_KEY_X)) {
+            bump_depth -= delta * 0.1;
+        }
+
+        Gedeng::String text;
+        text += std::to_string(number_of_steps).c_str();
+        text += " steps, ";
+
+        text += std::to_string(number_of_refinement_steps).c_str();
+        text += " refinement steps, ";
+
+        text += std::to_string(bump_depth).c_str();
+        text += " bump depth";
+
+        debug_text.set_text(text);
+    }
+
+    void dynamic_update(double delta) override {
+        glClearColor(0.1f, 0.1f, 0.1f, 1.0f);
+        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+
+        render_shader.use();
+
+        // Camera
+        render_shader.setMat4("projection", camera.get_projection());
+        render_shader.setMat4("view", camera.get_view());
+        render_shader.setVec3("viewPos", camera.get_translation());
+
+        // Lighting
+        render_shader.setVec3("lightPos", glm::vec3(0.0, 1.0, 5.0));
+
+        render_shader.setFloat("number_of_steps", glm::max(0.0f, number_of_steps));
+        render_shader.setFloat("number_of_refinement_steps", glm::max(0.0f, number_of_refinement_steps));
+        render_shader.setFloat("bump_depth", glm::max(0.0f, bump_depth));
+
+        // Textures
+        albedo.bind_to(0);
+        normal.bind_to(1);
+        bump.bind_to(2);
+
+        // Quad which is rendered onto
+        quad_mesh.rotate(delta * 25.0f, glm::normalize(glm::vec3(0.0, 0.0, 1.0)));
+        quad_mesh.render(render_shader);
+
+        debug_text.render_text(25.0f, 25.0f, 1.0f, Gedeng::Vector3(1.0, 1.0, 0.0));
+    }
+
+  private:
+    float number_of_steps;
+    float number_of_refinement_steps;
+    float bump_depth;
+
+    Gedeng::Shader render_shader;
+
+    Gedeng::VertexBuffer vertex_rectangle;
+
+    Gedeng::Camera camera;
+
+    Gedeng::Texture albedo;
+    Gedeng::Texture bump;
+    Gedeng::Texture normal;
+
+    Gedeng::QuadMesh quad_mesh;
+
+    Gedeng::TextLabel debug_text;
+};
+
+Gedeng::Application *Gedeng::create_application() {
+    GG_CLIENT_INFO("Creating Application");
+    return new ParallaxApp(20, 900, 600, String("Parallax Demo"));
+}

test/test-app/main.cpp

@@ -4,12 +4,23 @@
 
 class TestApp : public Gedeng::Application {
   public:
-    TestApp() = default;
+    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;
+
+    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();
+    return new TestApp(20, 900, 600, String("Test App"));
 }