Add Parallax Demo + some bugfixes

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

SConstruct

@@ -10,6 +10,10 @@ 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()
@@ -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(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;
 
@@ -31,6 +35,8 @@ void Application::run() {
         }
 
         dynamic_update(static_cast<double>(elapsed_time_ms) / 1000.0);
+
+        RenderBackend::render();
     }
 }
 

cpp/vendor/glad.c

@@ -19,10 +19,10 @@
         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);
 
@@ -53,8 +53,7 @@ static PFNWGLGETPROCADDRESSPROC_PRIVATE gladGetProcAddressPtr;
 #endif
 #endif
 
-static
+static int open_gl(void) {
-int open_gl(void) {
 #ifndef IS_UWP
     libGL = LoadLibraryW(L"opengl32.dll");
     if (libGL != NULL) {
@@ -68,8 +67,7 @@ int open_gl(void) {
     return 0;
 }
 
-static
+static void close_gl(void) {
-void close_gl(void) {
     if (libGL != NULL) {
         FreeLibrary((HMODULE)libGL);
         libGL = NULL;
@@ -84,15 +82,12 @@ typedef void* (APIENTRYP PFNGLXGETPROCADDRESSPROC_PRIVATE)(const char*);
 static PFNGLXGETPROCADDRESSPROC_PRIVATE gladGetProcAddressPtr;
 #endif
 
-static
+static int open_gl(void) {
-int open_gl(void) {
 #ifdef __APPLE__
-    static const char *NAMES[] = {
+    static const char *NAMES[] = {"../Frameworks/OpenGL.framework/OpenGL",
-        "../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
@@ -105,8 +100,7 @@ int open_gl(void) {
 #if defined(__APPLE__) || defined(__HAIKU__)
             return 1;
 #else
-            gladGetProcAddressPtr = (PFNGLXGETPROCADDRESSPROC_PRIVATE)dlsym(libGL,
+            gladGetProcAddressPtr = (PFNGLXGETPROCADDRESSPROC_PRIVATE)dlsym(libGL, "glXGetProcAddressARB");
-                "glXGetProcAddressARB");
             return gladGetProcAddressPtr != NULL;
 #endif
         }
@@ -115,8 +109,7 @@ int open_gl(void) {
     return 0;
 }
 
-static
+static void close_gl(void) {
-void close_gl(void) {
     if (libGL != NULL) {
         dlclose(libGL);
         libGL = NULL;
@@ -124,8 +117,7 @@ void close_gl(void) {
 }
 #endif
 
-static
+static void *get_proc(const char *namez) {
-void* get_proc(const char *namez) {
     void *result = NULL;
     if (libGL == NULL) return NULL;
 
@@ -233,8 +225,7 @@ static int has_ext(const char *ext) {
             }
 
             terminator = loc + strlen(ext);
-            if((loc == extensions || *(loc - 1) == ' ') &&
+            if ((loc == extensions || *(loc - 1) == ' ') && (*terminator == ' ' || *terminator == '\0')) {
-                (*terminator == ' ' || *terminator == '\0')) {
                 return 1;
             }
             extensions = terminator;
@@ -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");
@@ -1169,7 +1162,8 @@ static void load_GL_VERSION_3_2(GLADloadproc load) {
     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");
@@ -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");
@@ -1391,18 +1386,24 @@ static void load_GL_VERSION_4_1(GLADloadproc load) {
 }
 static void load_GL_VERSION_4_2(GLADloadproc load) {
     if (!GLAD_GL_VERSION_4_2) return;
-	glad_glDrawArraysInstancedBaseInstance = (PFNGLDRAWARRAYSINSTANCEDBASEINSTANCEPROC)load("glDrawArraysInstancedBaseInstance");
+    glad_glDrawArraysInstancedBaseInstance =
-	glad_glDrawElementsInstancedBaseInstance = (PFNGLDRAWELEMENTSINSTANCEDBASEINSTANCEPROC)load("glDrawElementsInstancedBaseInstance");
+        (PFNGLDRAWARRAYSINSTANCEDBASEINSTANCEPROC)load("glDrawArraysInstancedBaseInstance");
-	glad_glDrawElementsInstancedBaseVertexBaseInstance = (PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXBASEINSTANCEPROC)load("glDrawElementsInstancedBaseVertexBaseInstance");
+    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_glDrawTransformFeedbackInstanced =
-	glad_glDrawTransformFeedbackStreamInstanced = (PFNGLDRAWTRANSFORMFEEDBACKSTREAMINSTANCEDPROC)load("glDrawTransformFeedbackStreamInstanced");
+        (PFNGLDRAWTRANSFORMFEEDBACKINSTANCEDPROC)load("glDrawTransformFeedbackInstanced");
+    glad_glDrawTransformFeedbackStreamInstanced =
+        (PFNGLDRAWTRANSFORMFEEDBACKSTREAMINSTANCEDPROC)load("glDrawTransformFeedbackStreamInstanced");
 }
 static void load_GL_VERSION_4_3(GLADloadproc load) {
     if (!GLAD_GL_VERSION_4_3) return;
@@ -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");
@@ -1467,12 +1469,7 @@ static void find_coreGL(void) {
     int i, major, minor;
 
     const char *version;
-    const char* prefixes[] = {
+    const char *prefixes[] = {"OpenGL ES-CM ", "OpenGL ES-CL ", "OpenGL ES ", NULL};
-        "OpenGL ES-CM ",
-        "OpenGL ES-CL ",
-        "OpenGL ES ",
-        NULL
-    };
 
     version = (const char *)glGetString(GL_VERSION);
     if (!version) return;
@@ -1492,8 +1489,10 @@ static void find_coreGL(void) {
     sscanf(version, "%d.%d", &major, &minor);
 #endif
 
-    GLVersion.major = major; GLVersion.minor = minor;
+    GLVersion.major = major;
-    max_loaded_major = major; max_loaded_minor = minor;
+    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,7 +1516,8 @@ 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;
@@ -1542,4 +1542,3 @@ int gladLoadGLLoader(GLADloadproc load) {
     if (!find_extensionsGL()) return 0;
     return GLVersion.major != 0 || GLVersion.minor != 0;
 }
-

include/Gedeng/Application.h

@@ -6,10 +6,8 @@ namespace Gedeng {
 
 class Application {
   public:
-    Application(unsigned long ms_per_update, unsigned int window_size_x, unsigned int window_size_y, String window_name)
+    Application(unsigned long ms_per_update, unsigned int window_size_x, unsigned int window_size_y,
-        : MS_PER_UPDATE(ms_per_update), WINDOW_SIZE_X(window_size_x), WINDOW_SIZE_Y(window_size_y),
+                String window_name);
-          WINDOW_NAME(window_name) {
-    }
 
     // Virtual since this class will be inherited by user-created applications
     virtual ~Application() = default;

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
+                          << infoLog << "\n -- --------------------------------------------------- -- " << std::endl;
-                          << "\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
+                          << infoLog << "\n -- --------------------------------------------------- -- " << std::endl;
-                          << "\n -- --------------------------------------------------- -- "
-                          << std::endl;
             }
         }
     }
 };
 
-}
+} // namespace Gedeng

test/parallax-demo/main.cpp

@@ -0,0 +1,94 @@
+#include "Gedeng/Logger.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;
+        }
+    }
+
+    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);
+    }
+
+  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::Application *Gedeng::create_application() {
+    GG_CLIENT_INFO("Creating Application");
+    return new ParallaxApp(20, 900, 600, String("Parallax Demo"));
+}