Add shader engine version directives, so engine can use old shaders

Data/GLSL/envobject.frag

@@ -16,6 +16,9 @@
 #version 150
 #extension GL_ARB_shading_language_420pack : enable
 
+#og_version_major 1
+#og_version_minor 5
+
 /*#if defined(WATER)
 #define NO_DECALS
 #endif

Data/GLSL/envobject.vert

@@ -16,6 +16,9 @@
 #version 150
 #extension GL_ARB_shading_language_420pack : enable
 
+#og_version_major 1
+#og_version_minor 5
+
 #include "lighting150.glsl"
 
 in vec3 vertex_attrib;

Source/Graphics/shaders.cpp

@@ -100,7 +100,9 @@ enum Type {
     INCLUDE,
     UNKNOWN,
     PRAGMA,
-    VERSION
+    VERSION,
+    OG_VERSION_MAJOR,
+    OG_VERSION_MINOR,
 };
 }
 
@@ -157,6 +159,32 @@ static void ParsePreprocessorDirective(const char *text, int line_break, Preproc
         pd->data = buf;
         pd->type = PREPROC::VERSION;
     }
+    if (strcmp(buf, "og_version_major") == 0) {
+        int first_char = strlen("#og_version_major");
+        while (IsCharInString(text[first_char], " \t") && first_char < line_break) {
+            ++first_char;
+        }
+        int second_char = first_char;
+        while (!IsCharInString(text[second_char], " \t") && second_char < line_break) {
+            ++second_char;
+        }
+        CopySubString(&text[first_char], buf, "", min(BUF_SIZE - 1, second_char - first_char));
+        pd->data = buf;
+        pd->type = PREPROC::OG_VERSION_MAJOR;
+    }
+    if (strcmp(buf, "og_version_minor") == 0) {
+        int first_char = strlen("#og_version_minor");
+        while (IsCharInString(text[first_char], " \t") && first_char < line_break) {
+            ++first_char;
+        }
+        int second_char = first_char;
+        while (!IsCharInString(text[second_char], " \t") && second_char < line_break) {
+            ++second_char;
+        }
+        CopySubString(&text[first_char], buf, "", min(BUF_SIZE - 1, second_char - first_char));
+        pd->data = buf;
+        pd->type = PREPROC::OG_VERSION_MINOR;
+    }
     return;
 }
 
@@ -208,6 +236,8 @@ static void Preprocess(Shader *shader, ShaderType type, const std::vector<std::s
     }
 
     int version = -1;
+    int og_version_major = -1;
+    int og_version_minor = -1;
     int line_start = 0;
     for (int cursor = 0; text[cursor] != '\0'; ++cursor) {
         // Check each line one at a time
@@ -270,13 +300,25 @@ static void Preprocess(Shader *shader, ShaderType type, const std::vector<std::s
                         }
                         break;
                     case PREPROC::VERSION:
+                    case PREPROC::OG_VERSION_MAJOR:
+                    case PREPROC::OG_VERSION_MINOR:
                         // Comment out current version definition
                         // So we can add it later at the beginning
                         text.insert(line_start, "//");
                         cursor += 2;
                         text.insert(cursor, "\n");
                         cursor += 1;
-                        version = atoi(pd.data.c_str());
+                        switch (pd.type) {
+                            case PREPROC::VERSION:
+                                version = atoi(pd.data.c_str());
+                                break;
+                            case PREPROC::OG_VERSION_MAJOR:
+                                og_version_major = atoi(pd.data.c_str());
+                                break;
+                            case PREPROC::OG_VERSION_MINOR:
+                                og_version_minor = atoi(pd.data.c_str());
+                                break;
+                        }
                         break;
                 }
             }
@@ -328,7 +370,11 @@ static void Preprocess(Shader *shader, ShaderType type, const std::vector<std::s
         shader->blend_src = GL_SRC_ALPHA;
         shader->blend_dst = GL_ONE_MINUS_SRC_ALPHA;
     }
+
+    shader->og_version_major = og_version_major;
+    shader->og_version_minor = og_version_minor;
 }
+
 }  // namespace
 
 void Shaders::ReloadShader(int which, ShaderType type) {
@@ -690,6 +736,16 @@ bool Shaders::DoesProgramUseTangent(int which_program) {
            shaders[programs[which_program].shader_ids[_vertex]].use_tangent;
 }
 
+void Shaders::GetProgramOvergrowthVersion(int which_program, int &vertex_version_major, int &vertex_version_minor, int &fragment_version_major, int &fragment_version_minor) {
+    const Shader &vertex_shader = shaders[programs[which_program].shader_ids[_vertex]];
+    vertex_version_major = vertex_shader.og_version_major;
+    vertex_version_minor = vertex_shader.og_version_minor;
+
+    const Shader& fragment_shader = shaders[programs[which_program].shader_ids[_fragment]];
+    fragment_version_major = fragment_shader.og_version_major;
+    fragment_version_minor = fragment_shader.og_version_minor;
+}
+
 void Shaders::createProgram(int which_program) {
     PROFILER_ZONE(g_profiler_ctx, "Shaders::createProgram");
     CHECK_GL_ERROR();

Source/Graphics/shaders.h

@@ -147,6 +147,8 @@ class Shader {
     bool particle;
     int blend_src;
     int blend_dst;
+    int og_version_major;
+    int og_version_minor;
     std::vector<std::string> definitions;
     std::vector<int64_t> include_modified;
     std::vector<std::string> include_files;
@@ -263,6 +265,7 @@ class Shaders {
     void SetUniformInt(const std::string& var_name, const int& data, ForceFlag force_flag = kNoForce);
     void SetUniformInt(GLint var_id, const int& data, ForceFlag force_flag = kNoForce);
     bool DoesProgramUseTangent(int which_program);
+    void GetProgramOvergrowthVersion(int which_program, int& vertex_version_major, int& vertex_version_minor, int& fragment_version_major, int& fragment_version_minor);
     void SetUniformMat4Array(const std::string& var_name, const std::vector<mat4>& transforms);
     void SetUniformMat4Array(GLint var_id, const std::vector<mat4>& transforms);
     GLint returnShaderAttrib(const std::string& name, int which);