resolve merge conflicts

include/renderer_gl/gl_state.hpp

@@ -40,9 +40,13 @@ struct GLStateManager {
 	GLuint boundVAO;
 	GLuint boundVBO;
 	GLuint currentProgram;
+	GLuint boundUBO;
 
 	GLenum depthFunc;
 	GLenum logicOp;
+	GLenum blendEquationRGB, blendEquationAlpha;
+	GLenum blendFuncSourceRGB, blendFuncSourceAlpha;
+	GLenum blendFuncDestRGB, blendFuncDestAlpha;
 
 	void reset();
 	void resetBlend();
@@ -51,7 +55,7 @@ struct GLStateManager {
 	void resetColourMask();
 	void resetDepth();
 	void resetVAO();
-	void resetVBO();
+	void resetBuffers();
 	void resetProgram();
 	void resetScissor();
 	void resetStencil();
@@ -183,6 +187,13 @@ struct GLStateManager {
 		}
 	}
 
+	void bindUBO(GLuint handle) {
+		if (boundUBO != handle) {
+			boundUBO = handle;
+			glBindBuffer(GL_UNIFORM_BUFFER, boundUBO);
+		}
+	}
+
 	void bindVAO(const OpenGL::VertexArray& vao) { bindVAO(vao.handle()); }
 	void bindVBO(const OpenGL::VertexBuffer& vbo) { bindVBO(vbo.handle()); }
 	void useProgram(const OpenGL::Program& program) { useProgram(program.handle()); }
@@ -224,6 +235,41 @@ struct GLStateManager {
 	}
 
 	void setDepthFunc(OpenGL::DepthFunc func) { setDepthFunc(static_cast<GLenum>(func)); }
+
+	// Counterpart to glBlendEquationSeparate
+	void setBlendEquation(GLenum modeRGB, GLenum modeAlpha) {
+		if (blendEquationRGB != modeRGB || blendEquationAlpha != modeAlpha) {
+			blendEquationRGB = modeRGB;
+			blendEquationAlpha = modeAlpha;
+
+			glBlendEquationSeparate(modeRGB, modeAlpha);
+		}
+	}
+
+	// Counterpart to glBlendFuncSeparate
+	void setBlendFunc(GLenum sourceRGB, GLenum destRGB, GLenum sourceAlpha, GLenum destAlpha) {
+		if (blendFuncSourceRGB != sourceRGB || blendFuncDestRGB != destRGB || blendFuncSourceAlpha != sourceAlpha ||
+			blendFuncDestAlpha != destAlpha) {
+
+			blendFuncSourceRGB = sourceRGB;
+			blendFuncDestRGB = destRGB;
+			blendFuncSourceAlpha = sourceAlpha;
+			blendFuncDestAlpha = destAlpha;
+
+			glBlendFuncSeparate(sourceRGB, destRGB,sourceAlpha, destAlpha);
+		}
+	}
+
+	// Counterpart to regular glBlendEquation
+	void setBlendEquation(GLenum mode) { setBlendEquation(mode, mode); }
+
+	void setBlendEquation(OpenGL::BlendEquation modeRGB, OpenGL::BlendEquation modeAlpha) {
+		setBlendEquation(static_cast<GLenum>(modeRGB), static_cast<GLenum>(modeAlpha));
+	}
+
+	void setBlendEquation(OpenGL::BlendEquation mode) {
+		setBlendEquation(static_cast<GLenum>(mode));
+	}
 };
 
 static_assert(std::is_trivially_constructible<GLStateManager>(), "OpenGL State Manager class is not trivially constructible!");

include/renderer_gl/renderer_gl.hpp

@@ -1,11 +1,17 @@
 #pragma once
 
 #include <array>
+#include <cstring>
+#include <functional>
 #include <span>
+#include <unordered_map>
 
 #include "PICA/float_types.hpp"
+#include "PICA/pica_frag_config.hpp"
+#include "PICA/pica_hash.hpp"
 #include "PICA/pica_vertex.hpp"
 #include "PICA/regs.hpp"
+#include "PICA/shader_gen.hpp"
 #include "gl_state.hpp"
 #include "helpers.hpp"
 #include "logger.hpp"
@@ -24,21 +30,25 @@ class RendererGL final : public Renderer {
 
 	OpenGL::VertexArray vao;
 	OpenGL::VertexBuffer vbo;
+	bool enableUbershader = true;
 
-	// TEV configuration uniform locations
-	GLint textureEnvSourceLoc = -1;
-	GLint textureEnvOperandLoc = -1;
-	GLint textureEnvCombinerLoc = -1;
-	GLint textureEnvColorLoc = -1;
-	GLint textureEnvScaleLoc = -1;
+	// Data 
+	struct {
+		// TEV configuration uniform locations
+		GLint textureEnvSourceLoc = -1;
+		GLint textureEnvOperandLoc = -1;
+		GLint textureEnvCombinerLoc = -1;
+		GLint textureEnvColorLoc = -1;
+		GLint textureEnvScaleLoc = -1;
 
-	// Uniform of PICA registers
-	GLint picaRegLoc = -1;
+		// Uniform of PICA registers
+		GLint picaRegLoc = -1;
 
-	// Depth configuration uniform locations
-	GLint depthOffsetLoc = -1;
-	GLint depthScaleLoc = -1;
-	GLint depthmapEnableLoc = -1;
+		// Depth configuration uniform locations
+		GLint depthOffsetLoc = -1;
+		GLint depthScaleLoc = -1;
+		GLint depthmapEnableLoc = -1;
+	} ubershaderData;
 
 	float oldDepthScale = -1.0;
 	float oldDepthOffset = 0.0;
@@ -53,25 +63,39 @@ class RendererGL final : public Renderer {
 	OpenGL::VertexBuffer dummyVBO;
 
 	OpenGL::Texture screenTexture;
-	GLuint lightLUTTextureArray;
+	OpenGL::Texture LUTTexture;
 	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 {
+		OpenGL::Program program;
+		uint uboBinding;
+	};
+	std::unordered_map<PICA::FragmentConfig, CachedProgram> shaderCache;
 
 	OpenGL::Framebuffer getColourFBO();
 	OpenGL::Texture getTexture(Texture& tex);
+	OpenGL::Program& getSpecializedShader();
+
+	PICA::ShaderGen::FragmentGenerator fragShaderGen;
 
 	MAKE_LOG_FUNCTION(log, rendererLogger)
 	void setupBlending();
 	void setupStencilTest(bool stencilEnable);
 	void bindDepthBuffer();
-	void setupTextureEnvState();
+	void setupUbershaderTexEnv();
 	void bindTexturesToSlots();
 	void updateLightingLUT();
+	void updateFogLUT();
 	void initGraphicsContextInternal();
 
   public:
 	RendererGL(GPU& gpu, const std::array<u32, regNum>& internalRegs, const std::array<u32, extRegNum>& externalRegs)
-		: Renderer(gpu, internalRegs, externalRegs) {}
+		: Renderer(gpu, internalRegs, externalRegs), fragShaderGen(PICA::ShaderGen::API::GL, PICA::ShaderGen::Language::GLSL) {}
 	~RendererGL() override;
 
 	void reset() override;
@@ -82,12 +106,20 @@ class RendererGL final : public Renderer {
 	void textureCopy(u32 inputAddr, u32 outputAddr, u32 totalBytes, u32 inputSize, u32 outputSize, u32 flags) override;
 	void drawVertices(PICA::PrimType primType, std::span<const PICA::Vertex> vertices) override;             // Draw the given vertices
 	void deinitGraphicsContext() override;
+
+	virtual bool supportsShaderReload() override { return true; }
+	virtual std::string getUbershader() override;
+	virtual void setUbershader(const std::string& shader) override;
+
+	virtual void setUbershaderSetting(bool value) override { enableUbershader = value; }
 	
 	std::optional<ColourBuffer> getColourBuffer(u32 addr, PICA::ColorFmt format, u32 width, u32 height, bool createIfnotFound = true);
 
 	// Note: The caller is responsible for deleting the currently bound FBO before calling this
 	void setFBO(uint handle) { screenFramebuffer.m_handle = handle; }
 	void resetStateManager() { gl.reset(); }
+	void clearShaderCache();
+	void initUbershader(OpenGL::Program& program);
 
 #ifdef PANDA3DS_FRONTEND_QT
 	virtual void initGraphicsContext([[maybe_unused]] GL::Context* context) override { initGraphicsContextInternal(); }
@@ -95,4 +127,4 @@ class RendererGL final : public Renderer {
 
 	// Take a screenshot of the screen and store it in a file
 	void screenshot(const std::string& name) override;
-};
+};