[common] merge RenderBackend and ShaderBackend options (#3313)

first of all it makes UI a tad bit more simple and benefits the end user
second, it allows to add new backends a bit more easily
and also, there was a shader backend option in android... we don't use opengl in android
so may as well save ourselves the trouble, aye

![image](/attachments/c0195bca-da18-4907-9e4a-3b62c4292f1a)

Signed-off-by: lizzie <lizzie@eden-emu.dev>

Reviewed-on: https://git.eden-emu.dev/eden-emu/eden/pulls/3313
Reviewed-by: Maufeat <sahyno1996@gmail.com>
Reviewed-by: DraVee <dravee@eden-emu.dev>
Co-authored-by: lizzie <lizzie@eden-emu.dev>
Co-committed-by: lizzie <lizzie@eden-emu.dev>

5 files changed, 54 insertions, 66 deletions

diff --git a/src/video_core/renderer_opengl/gl_compute_pipeline.cpp b/src/video_core/renderer_opengl/gl_compute_pipeline.cpp
index 9a69ea4e06..661fbef2b0 100644
--- a/src/video_core/renderer_opengl/gl_compute_pipeline.cpp
+++ b/src/video_core/renderer_opengl/gl_compute_pipeline.cpp
@@ -8,7 +8,7 @@
 #include <bit>
 #include <numeric>
 #include "common/cityhash.h"
-#include "common/settings.h" // for enum class Settings::ShaderBackend
+#include "common/settings.h"
 #include "video_core/renderer_opengl/gl_compute_pipeline.h"
 #include "video_core/renderer_opengl/gl_shader_manager.h"
 #include "video_core/renderer_opengl/gl_shader_util.h"
@@ -37,19 +37,20 @@ ComputePipeline::ComputePipeline(const Device& device, TextureCache& texture_cac
                                  std::vector<u32> code_v, bool force_context_flush)
     : texture_cache{texture_cache_}, buffer_cache{buffer_cache_},
       program_manager{program_manager_}, info{info_} {
-    switch (device.GetShaderBackend()) {
-    case Settings::ShaderBackend::Glsl:
+    switch (::Settings::values.renderer_backend.GetValue()) {
+    case Settings::RendererBackend::OpenGL_GLSL:
         source_program = CreateProgram(code, GL_COMPUTE_SHADER);
         break;
-    case Settings::ShaderBackend::Glasm:
+    case Settings::RendererBackend::OpenGL_GLASM:
         assembly_program = CompileProgram(code, GL_COMPUTE_PROGRAM_NV);
         break;
-    case Settings::ShaderBackend::SpirV:
+    case Settings::RendererBackend::OpenGL_SPIRV:
         source_program = CreateProgram(code_v, GL_COMPUTE_SHADER);
         break;
+    default:
+        UNREACHABLE();
     }
-    std::copy_n(info.constant_buffer_used_sizes.begin(), uniform_buffer_sizes.size(),
-                uniform_buffer_sizes.begin());
+    std::copy_n(info.constant_buffer_used_sizes.begin(), uniform_buffer_sizes.size(), uniform_buffer_sizes.begin());
 
     num_texture_buffers = Shader::NumDescriptors(info.texture_buffer_descriptors);
     num_image_buffers = Shader::NumDescriptors(info.image_buffer_descriptors);
diff --git a/src/video_core/renderer_opengl/gl_device.cpp b/src/video_core/renderer_opengl/gl_device.cpp
index f5bf995d00..b49568b77d 100644
--- a/src/video_core/renderer_opengl/gl_device.cpp
+++ b/src/video_core/renderer_opengl/gl_device.cpp
@@ -233,19 +233,17 @@ Device::Device(Core::Frontend::EmuWindow& emu_window) {
     // uniform buffers as "push constants"
     has_fast_buffer_sub_data = is_nvidia && !disable_fast_buffer_sub_data;
 
-    shader_backend = Settings::values.shader_backend.GetValue();
-    use_assembly_shaders = shader_backend == Settings::ShaderBackend::Glasm &&
-                           GLAD_GL_NV_gpu_program5 && GLAD_GL_NV_compute_program5 &&
-                           GLAD_GL_NV_transform_feedback && GLAD_GL_NV_transform_feedback2;
-    if (shader_backend == Settings::ShaderBackend::Glasm && !use_assembly_shaders) {
-        LOG_ERROR(Render_OpenGL, "Assembly shaders enabled but not supported");
-        shader_backend = Settings::ShaderBackend::Glsl;
+    auto const shader_backend = Settings::values.renderer_backend.GetValue();
+    use_assembly_shaders = shader_backend == Settings::RendererBackend::OpenGL_GLASM
+        && GLAD_GL_NV_gpu_program5 && GLAD_GL_NV_compute_program5
+        && GLAD_GL_NV_transform_feedback && GLAD_GL_NV_transform_feedback2;
+    if (shader_backend == Settings::RendererBackend::OpenGL_GLASM && !use_assembly_shaders) {
+        LOG_ERROR(Render_OpenGL, "Assembly shaders enabled but not supported - expect instability!");
     }
 
-    if (shader_backend == Settings::ShaderBackend::Glsl && is_nvidia) {
+    if (shader_backend == Settings::RendererBackend::OpenGL_GLSL && is_nvidia) {
         const std::string driver_version = version.substr(13);
-        const int version_major =
-            std::atoi(driver_version.substr(0, driver_version.find(".")).data());
+        const int version_major = std::atoi(driver_version.substr(0, driver_version.find(".")).data());
         if (version_major >= 495) {
             has_cbuf_ftou_bug = true;
             has_bool_ref_bug = true;
diff --git a/src/video_core/renderer_opengl/gl_device.h b/src/video_core/renderer_opengl/gl_device.h
index a5a6bbbba7..17b5a828f2 100644
--- a/src/video_core/renderer_opengl/gl_device.h
+++ b/src/video_core/renderer_opengl/gl_device.h
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2019 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -10,10 +13,6 @@
 #include "core/frontend/emu_window.h"
 #include "shader_recompiler/stage.h"
 
-namespace Settings {
-enum class ShaderBackend : u32;
-};
-
 namespace OpenGL {
 
 class Device {
@@ -168,10 +167,6 @@ public:
         return has_bool_ref_bug;
     }
 
-    Settings::ShaderBackend GetShaderBackend() const {
-        return shader_backend;
-    }
-
     bool IsAmd() const {
         return vendor_name == "ATI Technologies Inc.";
     }
@@ -208,8 +203,6 @@ private:
     u32 max_compute_shared_memory_size{};
     u32 max_glasm_storage_buffer_blocks{};
 
-    Settings::ShaderBackend shader_backend{};
-
     bool has_warp_intrinsics{};
     bool has_shader_ballot{};
     bool has_vertex_viewport_layer{};
diff --git a/src/video_core/renderer_opengl/gl_graphics_pipeline.cpp b/src/video_core/renderer_opengl/gl_graphics_pipeline.cpp
index a5815b76d4..2abbd0de78 100644
--- a/src/video_core/renderer_opengl/gl_graphics_pipeline.cpp
+++ b/src/video_core/renderer_opengl/gl_graphics_pipeline.cpp
@@ -10,7 +10,7 @@
 #include <vector>
 #include <bit>
 #include <numeric>
-#include "common/settings.h" // for enum class Settings::ShaderBackend
+#include "common/settings.h"
 #include "common/thread_worker.h"
 #include "shader_recompiler/shader_info.h"
 #include "video_core/renderer_opengl/gl_graphics_pipeline.h"
@@ -224,8 +224,8 @@ GraphicsPipeline::GraphicsPipeline(const Device& device, TextureCache& texture_c
     ASSERT(num_textures <= MAX_TEXTURES);
     ASSERT(num_images <= MAX_IMAGES);
 
-    const auto backend = device.GetShaderBackend();
-    const bool assembly_shaders{backend == Settings::ShaderBackend::Glasm};
+    const auto backend = ::Settings::values.renderer_backend.GetValue();
+    const bool assembly_shaders = backend == Settings::RendererBackend::OpenGL_GLASM;
     use_storage_buffers =
         !assembly_shaders || num_storage_buffers <= device.GetMaxGLASMStorageBufferBlocks();
     writes_global_memory &= !use_storage_buffers;
@@ -240,21 +240,19 @@ GraphicsPipeline::GraphicsPipeline(const Device& device, TextureCache& texture_c
                force_context_flush](ShaderContext::Context*) mutable {
         for (size_t stage = 0; stage < 5; ++stage) {
             switch (backend) {
-            case Settings::ShaderBackend::Glsl:
-                if (!sources_[stage].empty()) {
+            case Settings::RendererBackend::OpenGL_GLSL:
+                if (!sources_[stage].empty())
                     source_programs[stage] = CreateProgram(sources_[stage], Stage(stage));
-                }
                 break;
-            case Settings::ShaderBackend::Glasm:
-                if (!sources_[stage].empty()) {
-                    assembly_programs[stage] =
-                        CompileProgram(sources_[stage], AssemblyStage(stage));
-                }
+            case Settings::RendererBackend::OpenGL_GLASM:
+                if (!sources_[stage].empty())
+                    assembly_programs[stage] = CompileProgram(sources_[stage], AssemblyStage(stage));
                 break;
-            case Settings::ShaderBackend::SpirV:
-                if (!sources_spirv_[stage].empty()) {
+            case Settings::RendererBackend::OpenGL_SPIRV:
+                if (!sources_spirv_[stage].empty())
                     source_programs[stage] = CreateProgram(sources_spirv_[stage], Stage(stage));
-                }
+                break;
+            default:
                 break;
             }
         }
diff --git a/src/video_core/renderer_opengl/gl_shader_cache.cpp b/src/video_core/renderer_opengl/gl_shader_cache.cpp
index 45f729698e..83ef393481 100644
--- a/src/video_core/renderer_opengl/gl_shader_cache.cpp
+++ b/src/video_core/renderer_opengl/gl_shader_cache.cpp
@@ -465,8 +465,8 @@ std::unique_ptr<GraphicsPipeline> ShaderCache::CreateGraphicsPipeline(
     Shader::IR::Program* layer_source_program{};
 
     for (size_t index = 0; index < Maxwell::MaxShaderProgram; ++index) {
-        const bool is_emulated_stage = layer_source_program != nullptr &&
-                                       index == static_cast<u32>(Maxwell::ShaderType::Geometry);
+        const bool is_emulated_stage = layer_source_program != nullptr
+            && index == u32(Maxwell::ShaderType::Geometry);
         if (key.unique_hashes[index] == 0 && is_emulated_stage) {
             auto topology = MaxwellToOutputTopology(key.gs_input_topology);
             programs[index] = GenerateGeometryPassthrough(pools.inst, pools.block, host_info,
@@ -479,7 +479,7 @@ std::unique_ptr<GraphicsPipeline> ShaderCache::CreateGraphicsPipeline(
         Shader::Environment& env{*envs[env_index]};
         ++env_index;
 
-        const u32 cfg_offset{static_cast<u32>(env.StartAddress() + sizeof(Shader::ProgramHeader))};
+        const u32 cfg_offset = u32(env.StartAddress() + sizeof(Shader::ProgramHeader));
         Shader::Maxwell::Flow::CFG cfg(env, pools.flow_block, cfg_offset, index == 0);
 
         if (Settings::values.dump_shaders) {
@@ -490,14 +490,12 @@ std::unique_ptr<GraphicsPipeline> ShaderCache::CreateGraphicsPipeline(
             // Normal path
             programs[index] = TranslateProgram(pools.inst, pools.block, env, cfg, host_info);
 
-            total_storage_buffers +=
-                Shader::NumDescriptors(programs[index].info.storage_buffers_descriptors);
+            total_storage_buffers += Shader::NumDescriptors(programs[index].info.storage_buffers_descriptors);
         } else {
             // VertexB path when VertexA is present.
             auto& program_va{programs[0]};
             auto program_vb{TranslateProgram(pools.inst, pools.block, env, cfg, host_info)};
-            total_storage_buffers +=
-                Shader::NumDescriptors(program_vb.info.storage_buffers_descriptors);
+            total_storage_buffers += Shader::NumDescriptors(program_vb.info.storage_buffers_descriptors);
             programs[index] = MergeDualVertexPrograms(program_va, program_vb, env);
         }
 
@@ -505,8 +503,8 @@ std::unique_ptr<GraphicsPipeline> ShaderCache::CreateGraphicsPipeline(
             layer_source_program = &programs[index];
         }
     }
-    const u32 glasm_storage_buffer_limit{device.GetMaxGLASMStorageBufferBlocks()};
-    const bool glasm_use_storage_buffers{total_storage_buffers <= glasm_storage_buffer_limit};
+    const u32 glasm_storage_buffer_limit = device.GetMaxGLASMStorageBufferBlocks();
+    const bool glasm_use_storage_buffers = total_storage_buffers <= glasm_storage_buffer_limit;
 
     std::array<const Shader::Info*, Maxwell::MaxShaderStage> infos{};
 
@@ -514,7 +512,7 @@ std::unique_ptr<GraphicsPipeline> ShaderCache::CreateGraphicsPipeline(
     std::array<std::vector<u32>, 5> sources_spirv;
     Shader::Backend::Bindings binding;
     Shader::IR::Program* previous_program{};
-    const bool use_glasm{device.UseAssemblyShaders()};
+    const bool use_glasm = device.UseAssemblyShaders();
     const size_t first_index = uses_vertex_a && uses_vertex_b ? 1 : 0;
     for (size_t index = first_index; index < Maxwell::MaxShaderProgram; ++index) {
         const bool is_emulated_stage = layer_source_program != nullptr &&
@@ -528,21 +526,21 @@ std::unique_ptr<GraphicsPipeline> ShaderCache::CreateGraphicsPipeline(
         const size_t stage_index{index - 1};
         infos[stage_index] = &program.info;
 
-        const auto runtime_info{
-            MakeRuntimeInfo(key, program, previous_program, glasm_use_storage_buffers, use_glasm)};
-        switch (device.GetShaderBackend()) {
-        case Settings::ShaderBackend::Glsl:
+        const auto runtime_info = MakeRuntimeInfo(key, program, previous_program, glasm_use_storage_buffers, use_glasm);
+        switch (::Settings::values.renderer_backend.GetValue()) {
+        case Settings::RendererBackend::OpenGL_GLSL:
             ConvertLegacyToGeneric(program, runtime_info);
             sources[stage_index] = EmitGLSL(profile, runtime_info, program, binding);
             break;
-        case Settings::ShaderBackend::Glasm:
+        case Settings::RendererBackend::OpenGL_GLASM:
             sources[stage_index] = EmitGLASM(profile, runtime_info, program, binding);
             break;
-        case Settings::ShaderBackend::SpirV:
+        case Settings::RendererBackend::OpenGL_SPIRV:
             ConvertLegacyToGeneric(program, runtime_info);
-            sources_spirv[stage_index] =
-                EmitSPIRV(profile, runtime_info, program, binding, this->optimize_spirv_output);
+            sources_spirv[stage_index] = EmitSPIRV(profile, runtime_info, program, binding, this->optimize_spirv_output);
             break;
+        default:
+            UNREACHABLE();
         }
         previous_program = &program;
     }
@@ -592,20 +590,20 @@ std::unique_ptr<ComputePipeline> ShaderCache::CreateComputePipeline(
 
     std::string code{};
     std::vector<u32> code_spirv;
-    switch (device.GetShaderBackend()) {
-    case Settings::ShaderBackend::Glsl:
+    switch (::Settings::values.renderer_backend.GetValue()) {
+    case Settings::RendererBackend::OpenGL_GLSL:
         code = EmitGLSL(profile, program);
         break;
-    case Settings::ShaderBackend::Glasm:
+    case Settings::RendererBackend::OpenGL_GLASM:
         code = EmitGLASM(profile, info, program);
         break;
-    case Settings::ShaderBackend::SpirV:
+    case Settings::RendererBackend::OpenGL_SPIRV:
         code_spirv = EmitSPIRV(profile, program, this->optimize_spirv_output);
         break;
+    default:
+        UNREACHABLE();
     }
-
-    return std::make_unique<ComputePipeline>(device, texture_cache, buffer_cache, program_manager,
-                                             program.info, code, code_spirv, force_context_flush);
+    return std::make_unique<ComputePipeline>(device, texture_cache, buffer_cache, program_manager, program.info, code, code_spirv, force_context_flush);
 } catch (Shader::Exception& exception) {
     LOG_ERROR(Render_OpenGL, "{}", exception.what());
     return nullptr;