Impaczus/rpcs3
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

vk: Interpreter bringup to restore previous functionality

Browse Source 
- Get basics working again along with some prep-work for enhancements
This commit is contained in:
kd-11
2026-04-12 21:08:22 +03:00
committed by kd-11
parent f3d0c3ba28
commit a6c3ef350a
2 changed files with 44 additions and 45 deletions
Download Patch File Download Diff File Expand all files Collapse all files
rpcs3/Emu/RSX/VK/VKShaderInterpreter.cpp
+34 -35
View File
@@ -14,7 +14,7 @@
namespace vk namespace vk
{ {
u32 shader_interpreter::init(VKVertexProgram* vk_prog, u64 compiler_options) const u32 shader_interpreter::init(std::shared_ptr<VKVertexProgram>& vk_prog, u64 compiler_options) const
{ {
std::memset(&vk_prog->binding_table, 0xff, sizeof(vk_prog->binding_table)); std::memset(&vk_prog->binding_table, 0xff, sizeof(vk_prog->binding_table));
@@ -48,7 +48,7 @@ namespace vk
return location; return location;
} }
u32 shader_interpreter::init(VKFragmentProgram* vk_prog, u64 /*compiler_opt*/) const u32 shader_interpreter::init(std::shared_ptr<VKFragmentProgram>& vk_prog, u64 /*compiler_opt*/) const
{ {
std::memset(&vk_prog->binding_table, 0xff, sizeof(vk_prog->binding_table)); std::memset(&vk_prog->binding_table, 0xff, sizeof(vk_prog->binding_table));
@@ -60,7 +60,7 @@ namespace vk
return 3; return 3;
} }
VKVertexProgram* shader_interpreter::build_vs(u64 compiler_options) std::shared_ptr<VKVertexProgram> shader_interpreter::build_vs(u64 compiler_options)
{ {
::glsl::shader_properties properties{}; ::glsl::shader_properties properties{};
properties.domain = ::glsl::program_domain::glsl_vertex_program; properties.domain = ::glsl::program_domain::glsl_vertex_program;
@@ -72,8 +72,8 @@ namespace vk
ParamArray arr; ParamArray arr;
// Initialize binding layout // Initialize binding layout
auto vk_prog = std::make_unique<VKVertexProgram>(); auto vk_prog = std::make_shared<VKVertexProgram>();
const u32 vertex_instruction_start = init(vk_prog.get(), compiler_options); const u32 vertex_instruction_start = init(vk_prog, compiler_options);
null_prog.ctrl = (compiler_options & program_common::interpreter::COMPILER_OPT_ENABLE_INSTANCING) null_prog.ctrl = (compiler_options & program_common::interpreter::COMPILER_OPT_ENABLE_INSTANCING)
? RSX_SHADER_CONTROL_INSTANCED_CONSTANTS ? RSX_SHADER_CONTROL_INSTANCED_CONSTANTS
@@ -153,12 +153,11 @@ namespace vk
vk_prog->SetInputs(vs_inputs); vk_prog->SetInputs(vs_inputs);
auto ret = vk_prog.get(); m_shader_cache[compiler_options].m_vs = vk_prog;
m_shader_cache[compiler_options].m_vs = std::move(vk_prog); return vk_prog;
return ret;
} }
VKFragmentProgram* shader_interpreter::build_fs(u64 compiler_options) std::shared_ptr<VKFragmentProgram> shader_interpreter::build_fs(u64 compiler_options)
{ {
[[maybe_unused]] ::glsl::shader_properties properties{}; [[maybe_unused]] ::glsl::shader_properties properties{};
properties.domain = ::glsl::program_domain::glsl_fragment_program; properties.domain = ::glsl::program_domain::glsl_fragment_program;
@@ -172,8 +171,8 @@ namespace vk
frag.ctrl |= RSX_SHADER_CONTROL_INTERPRETER_MODEL; frag.ctrl |= RSX_SHADER_CONTROL_INTERPRETER_MODEL;
auto vk_prog = std::make_unique<VKFragmentProgram>(); auto vk_prog = std::make_shared<VKFragmentProgram>();
const u32 fragment_instruction_start = init(vk_prog.get(), compiler_options); const u32 fragment_instruction_start = init(vk_prog, compiler_options);
const u32 fragment_textures_start = fragment_instruction_start + 1; const u32 fragment_textures_start = fragment_instruction_start + 1;
VKFragmentDecompilerThread comp(shader_str, arr, frag, len, *vk_prog); VKFragmentDecompilerThread comp(shader_str, arr, frag, len, *vk_prog);
@@ -323,9 +322,8 @@ namespace vk
vk_prog->SetInputs(inputs); vk_prog->SetInputs(inputs);
auto ret = vk_prog.get(); m_shader_cache[compiler_options].m_fs = vk_prog;
m_shader_cache[compiler_options].m_fs = std::move(vk_prog); return vk_prog;
return ret;
} }
void shader_interpreter::init(const vk::render_device& dev) void shader_interpreter::init(const vk::render_device& dev)
@@ -335,19 +333,20 @@ namespace vk
void shader_interpreter::destroy() void shader_interpreter::destroy()
{ {
m_current_interpreter.reset();
m_program_cache.clear(); m_program_cache.clear();
m_shader_cache.clear(); m_shader_cache.clear();
} }
glsl::program* shader_interpreter::link(const vk::pipeline_props& properties, u64 compiler_opt) std::shared_ptr<glsl::program> shader_interpreter::link(const vk::pipeline_props& properties, u64 compiler_opt)
{ {
VKVertexProgram* vs; std::shared_ptr<VKVertexProgram> vs;
VKFragmentProgram* fs; std::shared_ptr<VKFragmentProgram> fs;
if (auto found = m_shader_cache.find(compiler_opt); found != m_shader_cache.end()) if (auto found = m_shader_cache.find(compiler_opt); found != m_shader_cache.end())
{ {
fs = found->second.m_fs.get(); fs = found->second.m_fs;
vs = found->second.m_vs.get(); vs = found->second.m_vs;
} }
else else
{ {
@@ -436,7 +435,7 @@ namespace vk
vs->uniforms, vs->uniforms,
fs->uniforms); fs->uniforms);
return program.release(); return program;
} }
void shader_interpreter::update_fragment_textures(const std::array<VkDescriptorImageInfoEx, 68>& sampled_images) void shader_interpreter::update_fragment_textures(const std::array<VkDescriptorImageInfoEx, 68>& sampled_images)
@@ -507,7 +506,7 @@ namespace vk
if (m_current_key == key) [[likely]] if (m_current_key == key) [[likely]]
{ {
return m_current_interpreter; return m_current_interpreter.get();
} }
else else
{ {
@@ -518,18 +517,18 @@ namespace vk
auto found = m_program_cache.find(key); auto found = m_program_cache.find(key);
if (found != m_program_cache.end()) [[likely]] if (found != m_program_cache.end()) [[likely]]
{ {
m_current_interpreter = found->second.get(); m_current_interpreter = found->second;
return m_current_interpreter; return m_current_interpreter.get();
} }
m_current_interpreter = link(properties, key.compiler_opt); m_current_interpreter = link(properties, key.compiler_opt);
m_program_cache[key].reset(m_current_interpreter); m_program_cache[key] = m_current_interpreter;
return m_current_interpreter; return m_current_interpreter.get();
} }
bool shader_interpreter::is_interpreter(const glsl::program* prog) const bool shader_interpreter::is_interpreter(const glsl::program* prog) const
{ {
return prog == m_current_interpreter; return prog == m_current_interpreter.get();
} }
u32 shader_interpreter::get_vertex_instruction_location() const u32 shader_interpreter::get_vertex_instruction_location() const
@@ -542,16 +541,16 @@ namespace vk
return m_current_pipeline_info_ex.fragment_instruction_location; return m_current_pipeline_info_ex.fragment_instruction_location;
} }
std::pair<VKVertexProgram*, VKFragmentProgram*> shader_interpreter::get_shaders() const std::pair<std::shared_ptr<VKVertexProgram>, std::shared_ptr<VKFragmentProgram>> shader_interpreter::get_shaders() const
{ {
if (auto found = m_shader_cache.find(m_current_key.compiler_opt); found != m_shader_cache.end()) if (auto found = m_shader_cache.find(m_current_key.compiler_opt); found != m_shader_cache.end())
{ {
auto fs = found->second.m_fs.get(); auto fs = found->second.m_fs;
auto vs = found->second.m_vs.get(); auto vs = found->second.m_vs;
return { vs, fs }; return { vs, fs };
} }
return { nullptr, nullptr }; return {};
} }
const shader_interpreter::pipeline_info_ex_t* shader_interpreter::get_pipeline_info_ex(u64 compiler_opt) const shader_interpreter::pipeline_info_ex_t* shader_interpreter::get_pipeline_info_ex(u64 compiler_opt)
@@ -561,10 +560,10 @@ namespace vk
return &found->second; return &found->second;
} }
VKVertexProgram vs_stub{}; auto vs_stub = std::make_shared<VKVertexProgram>();
VKFragmentProgram fs_stub{}; auto fs_stub = std::make_shared<VKFragmentProgram>();
const auto vi_location = init(&vs_stub, compiler_opt); const auto vi_location = init(vs_stub, compiler_opt);
const auto fi_location = init(&fs_stub, compiler_opt); const auto fi_location = init(fs_stub, compiler_opt);
pipeline_info_ex_t result pipeline_info_ex_t result
{ {
@@ -579,9 +578,9 @@ namespace vk
void shader_interpreter::preload(rsx::shader_loading_dialog* dlg) void shader_interpreter::preload(rsx::shader_loading_dialog* dlg)
{ {
#if 0
dlg->create("Precompiling interpreter variants.\nPlease wait...", "Shader Compilation"); dlg->create("Precompiling interpreter variants.\nPlease wait...", "Shader Compilation");
#if 0
const auto variants = program_common::interpreter::get_interpreter_variants(); const auto variants = program_common::interpreter::get_interpreter_variants();
const u32 limit = ::size32(variants); const u32 limit = ::size32(variants);
dlg->set_limit(0, limit); dlg->set_limit(0, limit);
rpcs3/Emu/RSX/VK/VKShaderInterpreter.h
+10 -10
View File
@@ -21,7 +21,6 @@ namespace vk
class shader_interpreter class shader_interpreter
{ {
VkDevice m_device = VK_NULL_HANDLE; VkDevice m_device = VK_NULL_HANDLE;
glsl::program* m_current_interpreter = nullptr;
struct pipeline_key struct pipeline_key
{ {
@@ -44,8 +43,8 @@ namespace vk
struct shader_cache_entry_t struct shader_cache_entry_t
{ {
std::unique_ptr<VKFragmentProgram> m_fs; std::shared_ptr<VKFragmentProgram> m_fs;
std::unique_ptr<VKVertexProgram> m_vs; std::shared_ptr<VKVertexProgram> m_vs;
}; };
struct pipeline_info_ex_t struct pipeline_info_ex_t
@@ -55,19 +54,20 @@ namespace vk
u32 fragment_textures_location = 0; u32 fragment_textures_location = 0;
}; };
std::unordered_map<pipeline_key, std::unique_ptr<glsl::program>, key_hasher> m_program_cache; std::unordered_map<pipeline_key, std::shared_ptr<glsl::program>, key_hasher> m_program_cache;
std::unordered_map<u64, shader_cache_entry_t> m_shader_cache; std::unordered_map<u64, shader_cache_entry_t> m_shader_cache;
std::unordered_map<u64, pipeline_info_ex_t> m_pipeline_info_cache; std::unordered_map<u64, pipeline_info_ex_t> m_pipeline_info_cache;
pipeline_key m_current_key{}; pipeline_key m_current_key{};
pipeline_info_ex_t m_current_pipeline_info_ex{}; pipeline_info_ex_t m_current_pipeline_info_ex{};
std::shared_ptr<glsl::program> m_current_interpreter;
VKVertexProgram* build_vs(u64 compiler_opt); std::shared_ptr<VKVertexProgram> build_vs(u64 compiler_opt);
VKFragmentProgram* build_fs(u64 compiler_opt); std::shared_ptr<VKFragmentProgram> build_fs(u64 compiler_opt);
glsl::program* link(const vk::pipeline_props& properties, u64 compiler_opt); std::shared_ptr<glsl::program> link(const vk::pipeline_props& properties, u64 compiler_opt);
u32 init(VKVertexProgram* vk_prog, u64 compiler_opt) const; u32 init(std::shared_ptr<VKVertexProgram>& vk_prog, u64 compiler_opt) const;
u32 init(VKFragmentProgram* vk_prog, u64 compiler_opt) const; u32 init(std::shared_ptr<VKFragmentProgram>& vk_prog, u64 compiler_opt) const;
const pipeline_info_ex_t* get_pipeline_info_ex(u64 compiler_opt); const pipeline_info_ex_t* get_pipeline_info_ex(u64 compiler_opt);
@@ -85,7 +85,7 @@ namespace vk
u32 fp_ctrl); u32 fp_ctrl);
// Retrieve the shader components that make up the current interpreter // Retrieve the shader components that make up the current interpreter
std::pair<VKVertexProgram*, VKFragmentProgram*> get_shaders() const; std::pair<std::shared_ptr<VKVertexProgram>, std::shared_ptr<VKFragmentProgram>> get_shaders() const;
bool is_interpreter(const glsl::program* prog) const; bool is_interpreter(const glsl::program* prog) const;