shader reloading

src/level.cpp

@@ -8,6 +8,7 @@ class level {
     std::vector<int> phys_meshes;
     std::vector<int> sounds;
     std::vector<int> static_models;
+    std::vector<int> lights;
 
     public:
         level(); 

src/main.cpp

@@ -433,15 +433,15 @@ class SDLGLGLWindow {
         //Success flag
         bool success = true;
         //Generate program
-        shader = new Shader("data/shaders/instanced.vert", "data/shaders/test.frag");
-        modelShader = new Shader("data/shaders/instanced.vert", "data/shaders/test.frag");
+        shader = new Shader("data/shaders/test.vert", "data/shaders/test.frag");
+        modelShader = new Shader("data/shaders/test.vert", "data/shaders/test.frag");
         texShader = new Shader("data/shaders/screentexture.vert", "data/shaders/screentexture.frag");
         skyboxShader = new Shader("data/shaders/sky.vert", "data/shaders/sky.frag");
         glCheckError();
 
         objects = new simple_object_draw_system(shader);
 
-        modelShader->use();
+        //modelShader->use();
         stbi_set_flip_vertically_on_load(true);
         objects->add(Model(fmt::format("{}/backpack/backpack.obj", OBJ_DIR)), {0,0,0}, glm::mat4(1.0));
 
@@ -451,18 +451,15 @@ class SDLGLGLWindow {
         //Link program
         stbi_set_flip_vertically_on_load(true);
 
-        modelShader->use();
+        //modelShader->use();
         bp_model = new Model(fmt::format("{}/backpack/backpack.obj", OBJ_DIR));
         glCheckError();
-        shader->use();
+        //shader->use();
 
         view = glm::translate(view, glm::vec3(0.0f, 0.0f, -3.0f));
         projection = glm::perspective(glm::radians(45.0f), 800.0f / 600.0f, 0.1f, 100.0f);
 
 
-
-
-
         /* generate a framebuffer to draw to 
         glGenFramebuffers(1, &framebuffer);
         glBindFramebuffer(GL_FRAMEBUFFER, framebuffer);
@@ -532,7 +529,7 @@ class SDLGLGLWindow {
         std::default_random_engine generator;
         std::uniform_real_distribution<float> distribution(-50,50);
 
-        for (int i = 0; i < 1000; i ++) {
+        for (int i = 0; i < 10; i ++) {
             float x = distribution(generator) ;
             float y = distribution(generator) ;
             float z = distribution(generator) ;
@@ -540,7 +537,7 @@ class SDLGLGLWindow {
         }
 
         glCheckError();
-        shader->use();
+        //shader->use();
 
         glGenBuffers(1, &instance_VBO);
         glBindBuffer(GL_ARRAY_BUFFER, instance_VBO);
@@ -548,8 +545,6 @@ class SDLGLGLWindow {
 
 
         glCheckError();
-        glCheckError();
-        glCheckError();
 
 
 
@@ -599,7 +594,6 @@ class SDLGLGLWindow {
         glBindTexture(GL_TEXTURE_2D, texture[0]);
         glCheckError();
 
-        shader->use();
         shader->setInt("material.texture_diffuse1", 0);
 
         glActiveTexture(GL_TEXTURE0 + 1);
@@ -687,7 +681,6 @@ class SDLGLGLWindow {
 
         glBindBuffer(GL_ARRAY_BUFFER,  gVBO);
         glBufferData( GL_ARRAY_BUFFER, sizeof cubeVertices, cubeVertices, GL_STATIC_DRAW );
-        glCheckError();
 
         glCheckError();
 
@@ -715,12 +708,12 @@ class SDLGLGLWindow {
         /********** CUBEMAPS ***************/
 
         std::vector<std::string> faces {
-            fmt::format("{}/skybox/right.jpg", SKYBOX_DIR),
-            fmt::format("{}/skybox/left.jpg",SKYBOX_DIR),
-            fmt::format("{}/skybox/top.jpg",SKYBOX_DIR),
-            fmt::format("{}/skybox/bottom.jpg",SKYBOX_DIR),
-            fmt::format("{}/skybox/front.jpg",SKYBOX_DIR),
-            fmt::format("{}/skybox/back.jpg",SKYBOX_DIR),
+            fmt::format("{}/sky/right.jpg", SKYBOX_DIR),
+            fmt::format("{}/sky/left.jpg",SKYBOX_DIR),
+            fmt::format("{}/sky/top.jpg",SKYBOX_DIR),
+            fmt::format("{}/sky/bottom.jpg",SKYBOX_DIR),
+            fmt::format("{}/sky/front.jpg",SKYBOX_DIR),
+            fmt::format("{}/sky/back.jpg",SKYBOX_DIR),
         };
 
         stbi_set_flip_vertically_on_load(false);
@@ -941,65 +934,6 @@ class SDLGLGLWindow {
         glDrawArraysInstanced(GL_TRIANGLES, 0,36,1000);
         glCheckError();
 
-        /*
-        std::map<float, glm::vec3> sorted;
-
-        glCheckError();
-        for (auto pos: cubePositions) {
-            float dist = glm::length(camera_pos - pos);
-            sorted[dist] = pos;
-        }
-
-        glCheckError();
-        
-        shader->use();
-        for(auto it = sorted.rbegin(); it != sorted.rend(); ++it) {
-
-            model = glm::mat4(1.0f);
-
-            model = glm::translate(model, it->second);
-//            model = glm::rotate(model, glm::radians( i * 20.0f + 160.0f *(float)SDL_GetTicks() / 1000.0f), glm::vec3(0.6, 0.3, 1.0));
-
-            unsigned int loc = shader->get_uniform("model");
-            glUniformMatrix4fv(loc, 1, GL_FALSE, glm::value_ptr(model));
-
-            loc = shader->get_uniform("view");
-            glUniformMatrix4fv(loc, 1, GL_FALSE, glm::value_ptr(view));
-
-            loc = shader->get_uniform("projection"); 
-            glUniformMatrix4fv(loc, 1, GL_FALSE, glm::value_ptr(projection));
-
-            glBindTexture(GL_TEXTURE_CUBE_MAP, cubemap);
-        glCheckError();
-            glDrawArrays(GL_TRIANGLES, 0, 36);
-        glCheckError();
-        }
-        */
-
-        /*
-        glBindVertexArray(lightVAO);
-        shader->setBool("lighting_emit", true);
-
-        for (glm::vec3 pos : lightPositions) {
-            model = glm::mat4(1.0f);
-            model = glm::translate(model, pos);
-            model = glm::scale(model, glm::vec3(0.2f));
-
-            unsigned int loc = glGetUniformLocation(gProgramID, "model");
-            glUniformMatrix4fv(loc, 1, GL_FALSE, glm::value_ptr(model));
-            glDrawArrays(GL_TRIANGLES, 0, 36);
-        }
-
-        //Disable vertex position
-        //glDisableVertexAttribArray( gVertexPos2DLocation );
-
-        //Unbind program
-        //
-        */
-
-
-
-
         /** draw skybox cubemap  */
 
 
@@ -1020,7 +954,6 @@ class SDLGLGLWindow {
 
         glBindVertexArray(gVAO);
         glBindTexture(GL_TEXTURE_CUBE_MAP, cubemap);
-        glCheckError();
         glDrawArrays(GL_TRIANGLES, 0, 36);
         glCheckError();
 
@@ -1135,6 +1068,14 @@ int main(int argc, char **argv) {
                     case SDL_SCANCODE_D:
                         cont.camera_pos += camera_speed * glm::cross(cont.camera_front, cont.camera_up);
                         break;
+                    case SDL_SCANCODE_R:
+                        cont.shader->reload();
+                        cont.modelShader->reload();
+                        glCheckError();
+                        glCheckError();
+                        //cont.texShader->reload();
+                        //cont.skyboxShader->reload();
+                        break;
                 }
             } if (e.type == SDL_MOUSEMOTION) {
 

src/shaders.cpp

@@ -1,12 +1,13 @@
 #include "shaders.h"
 #include <fstream>
+#include <string>
 #include <vector>
 #include "errors.h"
 
-bool Shader::handle_error(std::string &filename) 
+bool Shader::handle_error(std::string &filename, GLuint shader) 
 {
     GLint fShaderCompiled = GL_FALSE;
-    glGetShaderiv( shader, GL_COMPILE_STATUS, &fShaderCompiled );
+    glGetShaderiv(shader, GL_COMPILE_STATUS, &fShaderCompiled );
     if( fShaderCompiled == GL_TRUE ) {
         return false;
     }
@@ -22,15 +23,32 @@ bool Shader::handle_error(std::string &filename)
 
     std::cerr<< (char *)(&err_log[0]) << " (" << filename << ")" << std::endl;
 
+    filename_vertex = filename;
+    filename_fragment = {};
+
     return true;
 }
 
-void Shader::add_shader(GLuint type, std::string filename)
+GLuint Shader::add_shader(GLuint type, std::string filename)
 {
+    auto shader = compile_shader(type, filename);
+
+    if (shader) {
+        glAttachShader(program, *shader);
+        return *shader;
+    }
+
+    return 0;
 
-    shader = glCreateShader(type);
+
+}
+
+std::optional<GLuint> Shader::compile_shader(GLuint type, std::string filename) {
+    GLuint new_shader = glCreateShader(type);
 
     // read source
+    //
+    std::string source;
     std::ifstream source_file(filename, std::fstream::in);
     if (source_file.is_open()) {
         source = std::string(std::istreambuf_iterator<char>(source_file), 
@@ -39,24 +57,70 @@ void Shader::add_shader(GLuint type, std::string filename)
 
     if (!source_file.is_open() || source.size() == 0) {
         fmt::print("Shader not found {}\n", filename);
-        A_ERROR("shader"); }
-
+        return {};
+    }
 
     const char *cstr = source.c_str();
-    glShaderSource(shader, 1, &cstr, NULL);
+    glShaderSource(new_shader, 1, &cstr, NULL);
 
-    glCompileShader(shader);
+    glCompileShader(new_shader);
 
-    if (handle_error(filename)) {
+    if (handle_error(filename, new_shader)) {
         // compilation failed
-        glDeleteShader(shader);
-        A_ERROR(""); 
+        glDeleteShader(new_shader);
+        return {};
     }
 
-    glAttachShader(program, shader);
+    return new_shader;
 
 }
 
+void Shader::reload() {
+    auto new_program = program;
+
+    auto new_vert_shader = compile_shader(GL_VERTEX_SHADER, filename_vertex);
+    if (new_vert_shader)  {
+        glDetachShader(program, shader_vert);
+        glDeleteShader(shader_vert);
+        glAttachShader(new_program, *new_vert_shader);
+        shader_vert = *new_vert_shader;
+    } else {
+        fmt::print("Shader reload failed.");
+        return;
+    }
+
+    if (filename_fragment) {
+        auto new_frag_shader = compile_shader(GL_FRAGMENT_SHADER, *filename_fragment);
+        if (new_frag_shader) {
+            glDetachShader(program, shader_frag);
+            glDeleteShader(shader_frag);
+            glAttachShader(new_program, *new_frag_shader);
+            shader_frag = *new_frag_shader;
+        } else {
+            fmt::print("Shader reload failed.");
+            return;
+        }
+    }
+
+    glLinkProgram(new_program);
+
+    //Check for errors
+    GLint programSuccess = GL_TRUE;
+    glGetProgramiv(new_program, GL_LINK_STATUS, &programSuccess );
+    if( programSuccess != GL_TRUE )
+    {
+        fmt::print( "Error linking program {}!\n", program );
+        return;
+    }
+
+    program = new_program;
+    fmt::print("reloaded shader program\n");
+
+}
+
+
+
+
 Shader::Shader()
 {
     program = glCreateProgram();
@@ -65,29 +129,36 @@ Shader::Shader()
 Shader::Shader(std::string filename)
 {
     program = glCreateProgram();
-    add_shader(GL_VERTEX_SHADER, filename);
+    shader_vert = add_shader(GL_VERTEX_SHADER, filename);
+    filename_vertex = filename;
+    filename_fragment = {};
 }
 
 Shader::Shader(std::string filename, std::string filename2)
 {
     program = glCreateProgram();
-    add_shader(GL_VERTEX_SHADER, filename);
-    add_shader(GL_FRAGMENT_SHADER, filename2);
-    link();
-}
+    shader_vert = add_shader(GL_VERTEX_SHADER, filename);
+    shader_frag = add_shader(GL_FRAGMENT_SHADER, filename2);
 
-void Shader::link() {
-        glLinkProgram(program);
+    filename_vertex = filename;
+    filename_fragment = filename2;
+    if (!link()) {
+        throw std::exception();
+    }
+}
 
-        //Check for errors
-        GLint programSuccess = GL_TRUE;
-        glGetProgramiv( program, GL_LINK_STATUS, &programSuccess );
-        if( programSuccess != GL_TRUE )
-        {
-            fmt::print( "Error linking program {}!\n", program );
-            A_ERROR(""); 
-        }
+bool Shader::link() {
+    glLinkProgram(program);
 
+    //Check for errors
+    GLint programSuccess = GL_TRUE;
+    glGetProgramiv( program, GL_LINK_STATUS, &programSuccess );
+    if( programSuccess != GL_TRUE )
+    {
+        fmt::print( "Error linking program {}!\n", program );
+        return false;
+    }
+    return true;
 }
 
 void Shader::use() {
@@ -135,6 +206,8 @@ GLint Shader::get_uniform(std::string unif)
 
 
 Shader::~Shader() {
+    glDeleteShader(shader_vert);
+    glDeleteShader(shader_frag);
     glDeleteProgram(program);
 }
 

src/shaders.h

@@ -10,19 +10,21 @@
 #include <GL/glu.h>
 #include <string>
 #include <iostream>
+#include <optional>
 
 #include <glm/vec3.hpp>
 
 class Shader {
-
-    std::string source;
-    std::string filename;
-    bool handle_error(std::string &filename);
-
+    std::string filename_vertex;
+    std::optional<std::string> filename_fragment;
+    std::optional<GLuint> compile_shader(GLuint type, std::string filename); 
+    bool handle_error(std::string &filename, GLuint shader);
+    bool link(); 
+
+    GLuint shader_vert = 0;
+    GLuint shader_frag = 0;
     public:
     GLuint program = 0;
-    GLuint shader;
-    GLuint type;
 
     Shader();
     Shader(std::string filename);
@@ -30,8 +32,8 @@ class Shader {
     ~Shader();
 
     void use();
-    void link(); 
-    void add_shader(GLuint type, std::string filename);
+    void reload(); 
+    GLuint add_shader(GLuint type, std::string filename);
 
     void set(const std::string &name, float value);
     void set(const std::string &name, bool value);