Implement testing GLSL preprocessing and #include support.

assets/shader_programs/shared.glsl

@@ -0,0 +1,30 @@
+#ifndef include_shared
+#define include_shared
+#version 120
+
+vec3 rgb2hsb( in vec3 c ){
+    vec4 K = vec4(0.0, -1.0 / 3.0, 2.0 / 3.0, -1.0);
+    vec4 p = mix(vec4(c.bg, K.wz),
+                 vec4(c.gb, K.xy),
+                 step(c.b, c.g));
+    vec4 q = mix(vec4(p.xyw, c.r),
+                 vec4(c.r, p.yzx),
+                 step(p.x, c.r));
+    float d = q.x - min(q.w, q.y);
+    float e = 1.0e-10;
+    return vec3(abs(q.z + (q.w - q.y) / (6.0 * d + e)),
+    d / (q.x + e),
+    q.x);
+}
+
+//  Function from Iñigo Quiles
+//  https://www.shadertoy.com/view/MsS3Wc
+vec3 hsb2rgb( in vec3 c ){
+    vec3 rgb = clamp(abs(mod(c.x*6.0+vec3(0.0,4.0,2.0),
+                             6.0)-3.0)-1.0,
+                     0.0,
+                     1.0 );
+    rgb = rgb*rgb*(3.0-2.0*rgb);
+    return c.z * mix(vec3(1.0), rgb, c.y);
+}
+#endif

assets/shader_programs/test_fragment.glsl

@@ -4,36 +4,14 @@
 precision mediump float;
 #endif
 
+#include "shared.glsl"
+
 attribute vec4 gl_Color;
 
 uniform vec2 u_resolution;
 uniform float u_time;
 
-vec3 rgb2hsb( in vec3 c ){
-    vec4 K = vec4(0.0, -1.0 / 3.0, 2.0 / 3.0, -1.0);
-    vec4 p = mix(vec4(c.bg, K.wz),
-                 vec4(c.gb, K.xy),
-                 step(c.b, c.g));
-    vec4 q = mix(vec4(p.xyw, c.r),
-                 vec4(c.r, p.yzx),
-                 step(p.x, c.r));
-    float d = q.x - min(q.w, q.y);
-    float e = 1.0e-10;
-    return vec3(abs(q.z + (q.w - q.y) / (6.0 * d + e)),
-                d / (q.x + e),
-                q.x);
-}
 
-//  Function from Iñigo Quiles
-//  https://www.shadertoy.com/view/MsS3Wc
-vec3 hsb2rgb( in vec3 c ){
-    vec3 rgb = clamp(abs(mod(c.x*6.0+vec3(0.0,4.0,2.0),
-                             6.0)-3.0)-1.0,
-                     0.0,
-                     1.0 );
-    rgb = rgb*rgb*(3.0-2.0*rgb);
-    return c.z * mix(vec3(1.0), rgb, c.y);
-}
 
 void main(){
     vec2 st = gl_FragCoord.xy/u_resolution;

include/JGL/types/Shader.h

@@ -24,11 +24,18 @@ class JGL::Shader {
 public:
     static inline Event<std::string, std::string> OnCompilationErrorMessage;
 
+    static bool HasFile(const std::filesystem::path& path)
+    {
+        return std::filesystem::exists(path);
+    }
+
+    static std::string ReadFile(const std::filesystem::path& path);
+
     /// The default constructor does not initialize any member values.
     Shader() = default;
 
     /// Creates a shader by compiling a vertex and fragment program from the sources in the respective filesystem paths.
-    Shader(std::filesystem::path vertex_source_path, std::filesystem::path fragment_source_path);
+    Shader(const std::filesystem::path& vertex_source_path, const std::filesystem::path& fragment_source_path);
 
     /// Creates a shader by compiling a vertex and fragment program from the respective GLSL source-strings.
     Shader(const std::string& vertex_code, const std::string& fragment_code);
@@ -110,6 +117,8 @@ protected:
 private:
     unsigned int id = 0;
     std::string vertexPath;
+    std::string vertexSource;
+    std::string fragmentSource;
     std::string fragmentPath;
     static void checkCompileErrors(GLuint shader, const std::string& type);
 };

src/types/Shader.cpp

@@ -3,102 +3,122 @@
 #include <glad/glad.h>
 
 namespace JGL {
-    Shader::Shader(std::filesystem::path vertex_source_path, std::filesystem::path fragment_source_path) {
-        std::string vertex_code;
-        std::string fragment_code;
-        std::string geometry_code; // Currently unused, might be supported later.
-        std::string compute_code;  // Currently unused, might be supported later.
 
-        std::ifstream vShaderFile;
-        std::ifstream fShaderFile;
-        std::ifstream gShaderFile;
-        std::ifstream cShaderFile;
+    class ShaderPreprocessor {
+    public:
+        std::string include_keyword = "#include";
+        ShaderPreprocessor() {}
+        std::string LoadShaderFile(const std::filesystem::path& filepath)
+        {
+            // if size is 0, it indicates, that we are at the top of the recursive load stack
+            bool stack_top = (already_included.size() == 0);
 
-
-        vShaderFile.exceptions(std::ifstream::failbit | std::ifstream::badbit);
-        fShaderFile.exceptions(std::ifstream::failbit | std::ifstream::badbit);
-        gShaderFile.exceptions(std::ifstream::failbit | std::ifstream::badbit);
-        cShaderFile.exceptions(std::ifstream::failbit | std::ifstream::badbit);
-
-        try {
-            // Open Files
-            vShaderFile.open(vertex_source_path);
-            fShaderFile.open(fragment_source_path);
-
-            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
-
-            vertex_code = vShaderStream.str();
-            fragment_code = fShaderStream.str();
-
-            if (false) {
-                gShaderFile.open("");
-                std::stringstream gShaderStream;
-                gShaderStream << gShaderFile.rdbuf();
-                gShaderFile.close();
-                geometry_code = gShaderStream.str();
+            if (stack_top) {
+                already_included.emplace_back(filepath);
             }
-        } catch (std::ifstream::failure& e) {
-            std::cout << "ERROR::SHADER::FILE_NOT_SUCCESSFULLY_READ: " << e.what() << std::endl;
+
+            std::string ret_data = "";
+            std::ifstream file(filepath);
+
+            if (!file.good())
+            {
+                std::cout << "ERROR [ ShaderLoader::load_shader ]: Failed to start fstream, check if '" << filepath << "' exists\n";
+                return ret_data;
+            }
+
+            if (file.is_open()) {
+                std::string line;
+                while (getline(file, line)) {
+                    if (line.find(include_keyword) == 0)
+                    {
+                        // Get path between double quotes
+                        std::string rel_include_path = extract_first_between(line.substr(include_keyword.length()), '"', '"');
+
+                        // Modify path according to os
+                        // TODO: Use std::filesystem dummy...
+                        // later, let me get this stolen code to work first.
+                    #ifdef _WIN32
+                        std::replace(rel_include_path.begin(), rel_include_path.end(), '/', '\\');
+                    #elif __linux__
+                        std::replace(rel_include_path.begin(), rel_include_path.end(), '\\', '/');
+                    #endif
+                        std::string full_include_path = extract_path(filepath) + rel_include_path;
+
+                        // Avoid including self
+                        if (filepath == full_include_path) {
+                            std::cout << "WARNING [ ShaderLoader::load_shader ]: '"<< filepath <<"' tried to include itself\n";
+                            continue;
+                        } else {
+                            bool include_flag = true;
+                            // check if the current file is already included
+                            for (const auto& file_to_check : already_included) {
+                                // Avoid duplicate includes
+                                if (file_to_check == full_include_path) {
+                                    include_flag = false;
+                                    break;
+                                }
+                            }
+
+                            // If not yet included, push path to include vector and replace line with file contents
+                            if (include_flag) {
+                                already_included.push_back(full_include_path);
+                                // Repeat recursively.
+                                ret_data += LoadShaderFile(full_include_path) + '\n';
+                            }
+                        }
+                    } else {
+                        ret_data += line + "\n";
+                    }
+                }
+                file.close();
+            } else {
+                std::cout << "ERROR [ ShaderLoader::load_shader ]: Unable to open file '" << filepath << "'\n";
+            }
+
+            // We are back to the first call
+            if (stack_top) {
+                already_included.clear();
+            }
+            return ret_data;
         }
 
-        const char* vShaderCode = vertex_code.c_str();
-        const char* fShaderCode = fragment_code.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");
+        std::string PreprocessShaderSource(const std::string& source);
+    private:
+        std::vector<std::string> already_included;
+        /// Helper function that strips filename from a path, basically getting the path to the directory containing the file.
+        std::string extract_path(const std::string& path)
+        {
+            // find the position of the last directory separator.
+            std::size_t pos = path.find_last_of("\\/");
 
-        // if geometry shader is given, compile geometry shader.
-        unsigned int geometry;
-        if (false) {
-            // const char* gShaderCode = geometry_code.c_str();
-            // geometry = glCreateShader(GL_GEOMETRY_SHADER);
-            // glShaderSource(geometry, 1 &gShaderCode, NULL);
-            // glCompileShader(geometry);
-            // checkCompileErrors(geometry, "GEOMETRY");
+            // strip fname from path
+            if (pos != std::string::npos) {
+                return path.substr(0, pos+1);
+            }
+            return "";
         }
+        std::string extract_first_between(const std::string& input, char start_symbol, char end_symbol)
+        {
+            size_t start_index = input.find(start_symbol);
+            size_t end_index = input.find(end_symbol, start_index+1);
 
-        // shader Program
-        id = glCreateProgram();
-        glAttachShader(id, vertex);
-        glAttachShader(id, fragment);
-
-        if (false)
-            glAttachShader(id, geometry);
-
-        glLinkProgram(id);
-        checkCompileErrors(id, "PROGRAM");
-
-        // delete the shaders as they're linked into our program now and are no longer necessary
-        glDeleteShader(vertex);
-        glDeleteShader(fragment);
-        if (false)
-            glDeleteShader(geometry);
-
-
+            std::string extracted = "";
+            if (start_index != std::string::npos && end_index != std::string::npos) {
+                extracted = input.substr(start_index + 1, end_index - start_index - 1);
+            } else {
+                std::cout << "ERROR [ ShaderLoader::extract_first_between ]: Start '" << start_symbol << "' or end symbol '" << end_symbol << "' not found" << std::endl;
+            }
+            return extracted;
+        }
+    };
 
+    Shader::Shader(const std::filesystem::path& vertex_source_path, const std::filesystem::path& fragment_source_path) :
+    Shader(ReadFile(vertex_source_path), ReadFile(fragment_source_path)) {
+        vertexPath = vertex_source_path;
+        fragmentPath = fragment_source_path;
     }
 
     void Shader::checkCompileErrors(GLuint shader, const std::string& type) {
@@ -132,6 +152,11 @@ namespace JGL {
     }
 
     Shader::Shader(const std::string &vertex_code, const std::string &fragment_code) {
+        vertexSource = vertex_code;
+        fragmentSource = fragment_code;
+
+
+
         const char* vShaderCode = vertex_code.c_str();
         const char* fShaderCode = fragment_code.c_str();
 
@@ -229,4 +254,35 @@ namespace JGL {
         bool transpose = false;
         glUniformMatrix4fv(Uniform(name), 16, transpose, value.ptr());
     }
+
+    std::string Shader::ReadFile(const std::filesystem::path &path) {
+        /*std::string contents;
+
+        std::ifstream file;
+
+        file.exceptions(std::ifstream::failbit | std::ifstream::badbit);
+
+        try {
+            // Open Files
+            file.open(path);
+            std::stringstream stream;
+
+            // Read file's buffer contents into streams
+            stream << file.rdbuf();
+
+            // close file handlers
+            file.close();
+
+            // convert stream into string
+            contents = stream.str();
+
+            return contents;
+        } catch (std::ifstream::failure& e) {
+            std::cout << "ERROR::FILE_READ_FAILURE: " << e.what() << std::endl;
+            return "";
+        }*/
+
+        ShaderPreprocessor processor;
+        return processor.LoadShaderFile(path);
+    }
 }