GLSL 'include' support

2023-11-28 16:13:49 +03:00
parent e6ecd558a9
commit a60cc70246
20 changed files with 238 additions and 35 deletions
@@ -0,0 +1,145 @@
+#include "GLSLExtension.h"
+#include <iostream>
+#include <sstream>
+#include <stdexcept>
+#include "../util/stringutil.h"
+#include "../typedefs.h"
+#include "../files/files.h"
+
+using std::string;
+using std::filesystem::path;
+namespace fs = std::filesystem;
+
+path GLSLExtension::getHeaderPath(string name) {
+    return libFolder/path(name+".glsl");
+}
+
+void GLSLExtension::setLibFolder(path folder) {
+    this->libFolder = folder;
+}
+
+void GLSLExtension::setVersion(string version) {
+    this->version = version;
+}
+
+void GLSLExtension::loadHeader(string name) {
+    path file = getHeaderPath(name);
+    string source = files::read_string(file);
+    addHeader(name, source);
+}
+
+void GLSLExtension::addHeader(string name, string source) {
+    headers[name] = source;
+}
+
+void GLSLExtension::define(string name, string value) {
+    defines[name] = value;
+}
+
+const string& GLSLExtension::getHeader(const string name) const {
+    auto found = headers.find(name);
+    if (found == headers.end()) {
+        throw std::runtime_error("no header '"+name+"' loaded");
+    }
+    return found->second;
+}
+
+const string GLSLExtension::getDefine(const string name) const {
+    auto found = defines.find(name);
+    if (found == defines.end()) {
+        return "";
+    }
+    return found->second;
+}
+
+bool GLSLExtension::hasDefine(const string name) const {
+    return defines.find(name) != defines.end();
+}
+
+bool GLSLExtension::hasHeader(const string name) const {
+    return headers.find(name) != headers.end();
+}
+
+void GLSLExtension::undefine(string name) {
+    if (hasDefine(name)) {
+        defines.erase(name);
+    }
+}
+
+inline std::runtime_error parsing_error(
+        const path& file, 
+        uint linenum, 
+        const string message) {
+    return std::runtime_error("file "+file.string()+": "+message+
+                          " at line "+std::to_string(linenum));
+}
+
+inline void parsing_warning(
+        const path& file, 
+        uint linenum, const 
+        string message) {
+    std::cerr << "file "+file.string()+": warning: "+message+
+             " at line "+std::to_string(linenum) << std::endl;
+}
+
+inline void source_line(std::stringstream& ss, const path& file, uint linenum) {
+    ss << "#line " << linenum << " " << file << '\n';
+}
+
+const string GLSLExtension::process(const path file, const string& source) {
+    std::stringstream ss;
+    size_t pos = 0;
+    uint linenum = 1;
+    ss << "#version " << version << '\n';
+    for (auto& entry : defines) {
+        ss << "#define " << entry.first << " " << entry.second << '\n';
+    }
+    source_line(ss, file, linenum);
+    while (pos < source.length()) {
+        size_t endline = source.find('\n', pos);
+        if (endline == string::npos) {
+            endline = source.length();
+        }
+        // parsing preprocessor directives
+        if (source[pos] == '#') {
+            string line = source.substr(pos+1, endline-pos);
+            util::trim(line);
+            // parsing 'include' directive
+            if (line.find("include") != string::npos) {
+                line = line.substr(7);
+                util::trim(line);
+                if (line.length() < 3) {
+                    throw parsing_error(file, linenum, 
+                        "invalid 'include' syntax");
+                }
+                if (line[0] != '<' || line[line.length()-1] != '>') {
+                    throw parsing_error(file, linenum,
+                        "expected '#include <filename>' syntax");
+                }
+                string name = line.substr(1, line.length()-2);
+                path hfile = getHeaderPath(name);
+                if (!hasHeader(name)) {
+                    loadHeader(name);
+                }
+                source_line(ss, hfile, 1);
+                ss << getHeader(name) << '\n';
+                pos = endline+1;
+                linenum++;
+                source_line(ss, file, linenum);
+                continue;
+            } 
+            // removing extra 'include' directives
+            else if (line.find("version") != string::npos) {
+                parsing_warning(file, linenum, "removed #version directive");
+                pos = endline+1;
+                linenum++;
+                source_line(ss, file, linenum);
+                continue;
+            }
+        }
+        linenum++;
+        ss << source.substr(pos, endline+1-pos);
+        pos = endline+1;
+    }
+    return ss.str();    
+}