franklinblanco
/
yuzu
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

gl_shader_cache: Remove special casing for geometry shaders 

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> {