Shadergen: Minimize shader compilation time by caching the default VS

include/PICA/shader_gen.hpp

@@ -35,7 +35,7 @@ namespace PICA::ShaderGen {
 	  public:
 		FragmentGenerator(API api, Language language) : api(api), language(language) {}
 		std::string generate(const PICARegs& regs, const PICA::FragmentConfig& config);
-		std::string getVertexShader(const PICARegs& regs);
+		std::string getDefaultVertexShader();
 
 		void setTarget(API api, Language language) {
 			this->api = api;

include/renderer_gl/renderer_gl.hpp

@@ -66,6 +66,9 @@ class RendererGL final : public Renderer {
 	OpenGL::Texture lightLUTTexture;
 	OpenGL::Framebuffer screenFramebuffer;
 	OpenGL::Texture blankTexture;
+	// The "default" vertex shader to use when using specialized shaders but not PICA vertex shader -> GLSL recompilation
+	// We can compile this once and then link it with all other generated fragment shaders
+	OpenGL::Shader defaultShadergenVs;
 
 	// Cached recompiled fragment shader
 	struct CachedProgram {

src/core/PICA/shader_gen_glsl.cpp

@@ -34,7 +34,7 @@ static constexpr const char* uniformDefinition = R"(
 // This is particularly intuitive in several places, such as checking if a LUT is enabled
 static constexpr int spotlightLutIndex = 2;
 
-std::string FragmentGenerator::getVertexShader(const PICARegs& regs) {
+std::string FragmentGenerator::getDefaultVertexShader() {
 	std::string ret = "";
 
 	switch (api) {

src/core/renderer_gl/renderer_gl.cpp

@@ -162,6 +162,10 @@ void RendererGL::initGraphicsContextInternal() {
 	OpenGL::setViewport(oldViewport[0], oldViewport[1], oldViewport[2], oldViewport[3]);
 
 	reset();
+
+	// Initialize the default vertex shader used with shadergen
+	std::string defaultShadergenVSSource = fragShaderGen.getDefaultVertexShader();
+	defaultShadergenVs.create({defaultShadergenVSSource.c_str(), defaultShadergenVSSource.size()}, OpenGL::Vertex);
 }
 
 // The OpenGL renderer doesn't need to do anything with the GL context (For Qt frontend) or the SDL window (For SDL frontend)
@@ -810,12 +814,10 @@ OpenGL::Program& RendererGL::getSpecializedShader() {
 	OpenGL::Program& program = programEntry.program;
 
 	if (!program.exists()) {
-		std::string vs = fragShaderGen.getVertexShader(regs);
 		std::string fs = fragShaderGen.generate(regs, fsConfig);
 
-		OpenGL::Shader vertShader({vs.c_str(), vs.size()}, OpenGL::Vertex);
 		OpenGL::Shader fragShader({fs.c_str(), fs.size()}, OpenGL::Fragment);
-		program.create({vertShader, fragShader});
+		program.create({defaultShadergenVs, fragShader});
 		gl.useProgram(program);
 
 		// Init sampler objects. Texture 0 goes in texture unit 0, texture 1 in TU 1, texture 2 in TU 2, and the light maps go in TU 3

third_party/opengl/opengl.hpp

@@ -355,46 +355,57 @@ namespace OpenGL {
         }
     };
 
-    enum ShaderType {
+	enum ShaderType {
-        Fragment = GL_FRAGMENT_SHADER,
+		Fragment = GL_FRAGMENT_SHADER,
-        Vertex = GL_VERTEX_SHADER,
+		Vertex = GL_VERTEX_SHADER,
-        Geometry = GL_GEOMETRY_SHADER,
+		Geometry = GL_GEOMETRY_SHADER,
-        Compute = GL_COMPUTE_SHADER,
+		Compute = GL_COMPUTE_SHADER,
-        TessControl = GL_TESS_CONTROL_SHADER,
+		TessControl = GL_TESS_CONTROL_SHADER,
-        TessEvaluation = GL_TESS_EVALUATION_SHADER
+		TessEvaluation = GL_TESS_EVALUATION_SHADER
-    };
+	};
 
-    struct Shader {
+	struct Shader {
-        GLuint m_handle = 0;
+		GLuint m_handle = 0;
 
-        Shader() {}
+		Shader() {}
-        Shader(const std::string_view source, ShaderType type) { create(source, static_cast<GLenum>(type)); }
+		Shader(const std::string_view source, ShaderType type) { create(source, static_cast<GLenum>(type)); }
 
-        // Returns whether compilation failed or not
+		// Returns whether compilation failed or not
-        bool create(const std::string_view source, GLenum type) {
+		bool create(const std::string_view source, GLenum type) {
-            m_handle = glCreateShader(type);
+			m_handle = glCreateShader(type);
-            const GLchar* const sources[1] = { source.data() };
+			const GLchar* const sources[1] = {source.data()};
 
-            glShaderSource(m_handle, 1, sources, nullptr);
+			glShaderSource(m_handle, 1, sources, nullptr);
-            glCompileShader(m_handle);
+			glCompileShader(m_handle);
 
-            GLint success;
+			GLint success;
-            glGetShaderiv(m_handle, GL_COMPILE_STATUS, &success);
+			glGetShaderiv(m_handle, GL_COMPILE_STATUS, &success);
-            if (success == GL_FALSE) {
+			if (success == GL_FALSE) {
-                char buf[4096];
+				char buf[4096];
-                glGetShaderInfoLog(m_handle, 4096, nullptr, buf);
+				glGetShaderInfoLog(m_handle, 4096, nullptr, buf);
-                fprintf(stderr, "Failed to compile shader\nError: %s\n", buf);
+				fprintf(stderr, "Failed to compile shader\nError: %s\n", buf);
-                glDeleteShader(m_handle);
+				glDeleteShader(m_handle);
 
-                m_handle = 0;
+				m_handle = 0;
-            }
+			}
 
-            return m_handle != 0;
+			return m_handle != 0;
-        }
+		}
 
-        GLuint handle() const { return m_handle; }
+		GLuint handle() const { return m_handle; }
-        bool exists() const { return m_handle != 0; }
+		bool exists() const { return m_handle != 0; }
-    };
+
+		void free() {
+			if (exists()) {
+				glDeleteShader(m_handle);
+				m_handle = 0;
+			}
+		}
+
+#ifdef OPENGL_DESTRUCTORS
+		~Shader() { free(); }
+#endif
+	};
 
     struct Program {
 		GLuint m_handle = 0;
@@ -431,6 +442,10 @@ namespace OpenGL {
 				m_handle = 0;
 			}
 		}
+
+#ifdef OPENGL_DESTRUCTORS
+		~Program() { free(); }
+#endif
 	};
 
     static void dispatchCompute(GLuint groupsX = 1, GLuint groupsY = 1, GLuint groupsZ = 1) {