Mirrors/yuzu-fork
1
0
Fork 0
mirror of https://github.com/yuzu-mirror/yuzu.git synced 2024-11-09 11:49:58 +00:00
Code Issues Projects Releases Packages Wiki Activity

gl_shader_cache: Remove special casing for geometry shaders

Browse source 
Now that ProgramVariants holds the primitive topology we no longer need
to keep track of individual geometry shaders topologies.
This commit is contained in:
ReinUsesLisp 2019-08-25 01:28:26 -03:00
parent 922c7f4e51
commit 42e1bb6d46
2 changed files with 9 additions and 80 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

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

@ -348,23 +348,16 @@ Shader CachedShader::CreateKernelFromCache(const ShaderParameters& params,
} }
std::tuple<GLuint, BaseBindings> CachedShader::GetProgramHandle(const ProgramVariant& variant) { std::tuple<GLuint, BaseBindings> CachedShader::GetProgramHandle(const ProgramVariant& variant) {
GLuint handle{}; const auto [entry, is_cache_miss] = programs.try_emplace(variant);
if (program_type == ProgramType::Geometry) { auto& program = entry->second;
handle = GetGeometryShader(variant); if (is_cache_miss) {
} else { program = TryLoadProgram(variant);
const auto [entry, is_cache_miss] = programs.try_emplace(variant); if (!program) {
auto& program = entry->second; program = SpecializeShader(code, entries, program_type, variant);
if (is_cache_miss) { disk_cache.SaveUsage(GetUsage(variant));
program = TryLoadProgram(variant);
if (!program) {
program = SpecializeShader(code, entries, program_type, variant);
disk_cache.SaveUsage(GetUsage(variant));
}
LabelGLObject(GL_PROGRAM, program->handle, cpu_addr);
} }
handle = program->handle; LabelGLObject(GL_PROGRAM, program->handle, cpu_addr);
} }
auto base_bindings = variant.base_bindings; auto base_bindings = variant.base_bindings;
@ -375,52 +368,9 @@ std::tuple<GLuint, BaseBindings> CachedShader::GetProgramHandle(const ProgramVar
base_bindings.gmem += static_cast<u32>(entries.global_memory_entries.size()); base_bindings.gmem += static_cast<u32>(entries.global_memory_entries.size());
base_bindings.sampler += static_cast<u32>(entries.samplers.size()); base_bindings.sampler += static_cast<u32>(entries.samplers.size());
return {handle, base_bindings}; return {program->handle, base_bindings};
} }
GLuint CachedShader::GetGeometryShader(const ProgramVariant& variant) {
const auto [entry, is_cache_miss] = geometry_programs.try_emplace(variant);
auto& programs = entry->second;
switch (variant.primitive_mode) {
case GL_POINTS:
return LazyGeometryProgram(programs.points, variant);
case GL_LINES:
case GL_LINE_STRIP:
return LazyGeometryProgram(programs.lines, variant);
case GL_LINES_ADJACENCY:
case GL_LINE_STRIP_ADJACENCY:
return LazyGeometryProgram(programs.lines_adjacency, variant);
case GL_TRIANGLES:
case GL_TRIANGLE_STRIP:
case GL_TRIANGLE_FAN:
return LazyGeometryProgram(programs.triangles, variant);
case GL_TRIANGLES_ADJACENCY:
case GL_TRIANGLE_STRIP_ADJACENCY:
return LazyGeometryProgram(programs.triangles_adjacency, variant);
default:
UNREACHABLE_MSG("Unknown primitive mode.");
return LazyGeometryProgram(programs.points, variant);
}
}
GLuint CachedShader::LazyGeometryProgram(CachedProgram& target_program,
const ProgramVariant& variant) {
if (target_program) {
return target_program->handle;
}
const auto [glsl_name, debug_name, vertices] = GetPrimitiveDescription(variant.primitive_mode);
target_program = TryLoadProgram(variant);
if (!target_program) {
target_program = SpecializeShader(code, entries, program_type, variant);
disk_cache.SaveUsage(GetUsage(variant));
}
LabelGLObject(GL_PROGRAM, target_program->handle, cpu_addr, debug_name);
return target_program->handle;
};
CachedProgram CachedShader::TryLoadProgram(const ProgramVariant& variant) const { CachedProgram CachedShader::TryLoadProgram(const ProgramVariant& variant) const {
const auto found = precompiled_programs.find(GetUsage(variant)); const auto found = precompiled_programs.find(GetUsage(variant));
if (found == precompiled_programs.end()) { if (found == precompiled_programs.end()) {

21
src/video_core/renderer_opengl/gl_shader_cache.h
View file

@ -86,22 +86,6 @@ private:
explicit CachedShader(const ShaderParameters& params, ProgramType program_type, explicit CachedShader(const ShaderParameters& params, ProgramType program_type,
GLShader::ProgramResult result); GLShader::ProgramResult result);
// Geometry programs. These are needed because GLSL needs an input topology but it's not
// declared by the hardware. Workaround this issue by generating a different shader per input
// topology class.
struct GeometryPrograms {
CachedProgram points;
CachedProgram lines;
CachedProgram lines_adjacency;
CachedProgram triangles;
CachedProgram triangles_adjacency;
};
GLuint GetGeometryShader(const ProgramVariant& variant);
/// Generates a geometry shader or returns one that already exists.
GLuint LazyGeometryProgram(CachedProgram& target_program, const ProgramVariant& variant);
CachedProgram TryLoadProgram(const ProgramVariant& variant) const; CachedProgram TryLoadProgram(const ProgramVariant& variant) const;
ShaderDiskCacheUsage GetUsage(const ProgramVariant& variant) const; ShaderDiskCacheUsage GetUsage(const ProgramVariant& variant) const;
@ -117,11 +101,6 @@ private:
std::size_t shader_length{}; std::size_t shader_length{};
std::unordered_map<ProgramVariant, CachedProgram> programs; std::unordered_map<ProgramVariant, CachedProgram> programs;
std::unordered_map<ProgramVariant, GeometryPrograms> geometry_programs;
std::unordered_map<u32, GLuint> cbuf_resource_cache;
std::unordered_map<u32, GLuint> gmem_resource_cache;
std::unordered_map<u32, GLint> uniform_cache;
}; };
class ShaderCacheOpenGL final : public RasterizerCache<Shader> { class ShaderCacheOpenGL final : public RasterizerCache<Shader> {