Plexi09/eden-miror
1
0
Fork 0
mirror of https://git.eden-emu.dev/eden-emu/eden synced 2026-04-24 09:48:57 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

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

Browse source 
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>
This commit is contained in:
lizzie 2026-01-18 12:33:00 +01:00 • committed by crueter
parent ed0276582e
commit 291b5febec
No known key found for this signature in database
GPG key ID: 425ACD2D4830EBC6
45 changed files with 133 additions and 351 deletions
Download patch file Download diff file Expand all files Collapse all files

15
src/video_core/renderer_opengl/gl_compute_pipeline.cpp
View file

@ -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);

18
src/video_core/renderer_opengl/gl_device.cpp
View file

@ -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;

13
src/video_core/renderer_opengl/gl_device.h
View file

@ -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{};

26
src/video_core/renderer_opengl/gl_graphics_pipeline.cpp
View file

@ -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;
}
}

48
src/video_core/renderer_opengl/gl_shader_cache.cpp
View file

@ -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;

13
src/video_core/video_core.cpp
View file

@ -1,3 +1,6 @@
// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
// SPDX-License-Identifier: GPL-3.0-or-later
// SPDX-FileCopyrightText: 2014 Citra Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
@ -22,12 +25,12 @@ std::unique_ptr<VideoCore::RendererBase> CreateRenderer(
auto& device_memory = system.Host1x().MemoryManager();
switch (Settings::values.renderer_backend.GetValue()) {
case Settings::RendererBackend::OpenGL:
return std::make_unique<OpenGL::RendererOpenGL>(emu_window, device_memory, gpu,
std::move(context));
case Settings::RendererBackend::OpenGL_GLSL:
case Settings::RendererBackend::OpenGL_GLASM:
case Settings::RendererBackend::OpenGL_SPIRV:
return std::make_unique<OpenGL::RendererOpenGL>(emu_window, device_memory, gpu, std::move(context));
case Settings::RendererBackend::Vulkan:
return std::make_unique<Vulkan::RendererVulkan>(emu_window, device_memory, gpu,
std::move(context));
return std::make_unique<Vulkan::RendererVulkan>(emu_window, device_memory, gpu, std::move(context));
case Settings::RendererBackend::Null:
return std::make_unique<Null::RendererNull>(emu_window, gpu, std::move(context));
default: