Add shaderMode option and remove useUbershader option

src/config.cpp

@@ -6,6 +6,7 @@
 #include <string>
 
 #include "helpers.hpp"
+#include "renderer.hpp"
 #include "toml.hpp"
 
 // Largely based on https://github.com/nba-emu/NanoBoyAdvance/blob/master/src/platform/core/src/config.cpp
@@ -60,9 +61,18 @@ void EmulatorConfig::load() {
 				rendererType = RendererType::OpenGL;
 			}
 
+			auto shaderModeName = toml::find_or<std::string>(gpu, "ShaderMode", Renderer::shaderModeToString(defaultShaderMode));
+			auto configShaderMode = Renderer::shaderModeFromString(shaderModeName);
+
+			if (configShaderMode.has_value()) {
+				shaderMode = configShaderMode.value();
+			} else {
+				Helpers::warn("Invalid shader mode specified: %s\n", shaderModeName.c_str());
+				shaderMode = defaultShaderMode;
+			}
+
 			shaderJitEnabled = toml::find_or<toml::boolean>(gpu, "EnableShaderJIT", shaderJitDefault);
 			vsyncEnabled = toml::find_or<toml::boolean>(gpu, "EnableVSync", true);
-			useUbershaders = toml::find_or<toml::boolean>(gpu, "UseUbershaders", ubershaderDefault);
 			accurateShaderMul = toml::find_or<toml::boolean>(gpu, "AccurateShaderMultiplication", false);
 
 			forceShadergenForLights = toml::find_or<toml::boolean>(gpu, "ForceShadergenForLighting", true);
@@ -132,7 +142,7 @@ void EmulatorConfig::save() {
 	data["GPU"]["Renderer"] = std::string(Renderer::typeToString(rendererType));
 	data["GPU"]["EnableVSync"] = vsyncEnabled;
 	data["GPU"]["AccurateShaderMultiplication"] = accurateShaderMul;
-	data["GPU"]["UseUbershaders"] = useUbershaders;
+	data["GPU"]["ShaderMode"] = std::string(Renderer::shaderModeToString(shaderMode));
 	data["GPU"]["ForceShadergenForLighting"] = forceShadergenForLights;
 	data["GPU"]["ShadergenLightThreshold"] = lightShadergenThreshold;
 

src/core/PICA/gpu.cpp

@@ -117,7 +117,7 @@ void GPU::reset() {
 	externalRegs[Framebuffer1Config] = static_cast<u32>(PICA::ColorFmt::RGB8);
 	externalRegs[Framebuffer1Select] = 0;
 
-	renderer->setUbershaderSetting(config.useUbershaders);
+	renderer->setShaderMode(config.shaderMode);
 	renderer->reset();
 }
 

src/core/renderer_gl/renderer_gl.cpp

@@ -414,8 +414,10 @@ void RendererGL::drawVertices(PICA::PrimType primType, std::span<const Vertex> v
 		OpenGL::Triangle,
 	};
 
-	bool usingUbershader = enableUbershader;
-	if (usingUbershader) {
+	bool usingUbershader = false;
+	if (shaderMode == ShaderMode::Ubershader) {
+		usingUbershader = true;
+
 		const bool lightsEnabled = (regs[InternalRegs::LightingEnable] & 1) != 0;
 		const uint lightCount = (regs[InternalRegs::LightNumber] & 0x7) + 1;
 

src/libretro_core.cpp

@@ -5,6 +5,7 @@
 
 #include <emulator.hpp>
 #include <renderer_gl/renderer_gl.hpp>
+#include "renderer.hpp"
 
 static retro_environment_t envCallbacks;
 static retro_video_refresh_t videoCallbacks;
@@ -179,9 +180,10 @@ static void configUpdate() {
 	config.sdCardInserted = FetchVariableBool("panda3ds_use_virtual_sd", true);
 	config.sdWriteProtected = FetchVariableBool("panda3ds_write_protect_virtual_sd", false);
 	config.accurateShaderMul = FetchVariableBool("panda3ds_accurate_shader_mul", false);
-	config.useUbershaders = FetchVariableBool("panda3ds_use_ubershader", true);
 	config.forceShadergenForLights = FetchVariableBool("panda3ds_ubershader_lighting_override", true);
 	config.lightShadergenThreshold = std::clamp(std::stoi(FetchVariable("panda3ds_ubershader_lighting_override_threshold", "1")), 1, 8);
+	// TODO: be able to use hybrid mode
+	config.shaderMode = FetchVariableBool("panda3ds_use_ubershader", defaultShaderMode == ShaderMode::Ubershader) ? ShaderMode::Ubershader : ShaderMode::Specialized;
 	config.discordRpcEnabled = false;
 
 	config.save();

src/renderer.cpp

@@ -1,6 +1,7 @@
 #include "renderer.hpp"
 
 #include <algorithm>
+#include <optional>
 #include <unordered_map>
 
 Renderer::Renderer(GPU& gpu, const std::array<u32, regNum>& internalRegs, const std::array<u32, extRegNum>& externalRegs)
@@ -36,4 +37,30 @@ const char* Renderer::typeToString(RendererType rendererType) {
 		case RendererType::Software: return "software";
 		default: return "Invalid";
 	}
+}
+
+std::optional<ShaderMode> Renderer::shaderModeFromString(std::string inString) {
+	// Transform to lower-case to make the setting case-insensitive
+	std::transform(inString.begin(), inString.end(), inString.begin(), [](unsigned char c) { return std::tolower(c); });
+
+	static const std::unordered_map<std::string, ShaderMode> map = {
+		{"specialized", ShaderMode::Specialized},    {"special", ShaderMode::Specialized},
+		{"ubershader", ShaderMode::Ubershader},      {"uber", ShaderMode::Ubershader},
+		{"hybrid", ShaderMode::Hybrid},              {"threaded", ShaderMode::Hybrid},             {"i hate opengl context creation", ShaderMode::Hybrid},
+	};
+
+	if (auto search = map.find(inString); search != map.end()) {
+		return search->second;
+	}
+
+	return std::nullopt;
+}
+
+const char* Renderer::shaderModeToString(ShaderMode shaderMode) {
+	switch (shaderMode) {
+		case ShaderMode::Specialized: return "specialized";
+		case ShaderMode::Ubershader: return "ubershader";
+		case ShaderMode::Hybrid: return "hybrid";
+		default: return "Invalid";
+	}
 }