Merge pull request #2804 from ReinUsesLisp/remove-gs-special

gl_shader_cache: Remove special casing for geometry shaders

src/video_core/renderer_opengl/gl_rasterizer.cpp

@@ -537,8 +537,7 @@ std::pair<bool, bool> RasterizerOpenGL::ConfigureFramebuffers(
         texture_cache.MarkDepthBufferInUse();
 
         fbkey.zeta = depth_surface;
-        fbkey.stencil_enable = regs.stencil_enable &&
-                               depth_surface->GetSurfaceParams().type == SurfaceType::DepthStencil;
+        fbkey.stencil_enable = depth_surface->GetSurfaceParams().type == SurfaceType::DepthStencil;
     }
 
     texture_cache.GuardRenderTargets(false);
@@ -577,16 +576,15 @@ void RasterizerOpenGL::ConfigureClearFramebuffer(OpenGLState& current_state, boo
     if (depth_surface) {
         const auto& params = depth_surface->GetSurfaceParams();
         switch (params.type) {
-        case VideoCore::Surface::SurfaceType::Depth: {
+        case VideoCore::Surface::SurfaceType::Depth:
             depth_surface->Attach(GL_DEPTH_ATTACHMENT, GL_DRAW_FRAMEBUFFER);
             glFramebufferTexture2D(GL_DRAW_FRAMEBUFFER, GL_STENCIL_ATTACHMENT, GL_TEXTURE_2D, 0, 0);
             break;
-        }
-        case VideoCore::Surface::SurfaceType::DepthStencil: {
-            depth_surface->Attach(GL_DEPTH_ATTACHMENT, GL_DRAW_FRAMEBUFFER);
+        case VideoCore::Surface::SurfaceType::DepthStencil:
+            depth_surface->Attach(GL_DEPTH_STENCIL_ATTACHMENT, GL_DRAW_FRAMEBUFFER);
             break;
-        }
-        default: { UNIMPLEMENTED(); }
+        default:
+            UNIMPLEMENTED();
         }
     } else {
         glFramebufferTexture2D(GL_DRAW_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT, GL_TEXTURE_2D, 0,
@@ -639,6 +637,7 @@ void RasterizerOpenGL::Clear() {
         ASSERT_MSG(regs.zeta_enable != 0, "Tried to clear stencil but buffer is not enabled!");
         use_stencil = true;
         clear_state.stencil.test_enabled = true;
+
         if (regs.clear_flags.stencil) {
             // Stencil affects the clear so fill it with the used masks
             clear_state.stencil.front.test_func = GL_ALWAYS;
@@ -1119,9 +1118,12 @@ void RasterizerOpenGL::SyncStencilTestState() {
     if (!maxwell3d.dirty.stencil_test) {
         return;
     }
-    const auto& regs = maxwell3d.regs;
+    maxwell3d.dirty.stencil_test = false;
 
+    const auto& regs = maxwell3d.regs;
     state.stencil.test_enabled = regs.stencil_enable != 0;
+    state.MarkDirtyStencilState();
+
     if (!regs.stencil_enable) {
         return;
     }
@@ -1150,8 +1152,6 @@ void RasterizerOpenGL::SyncStencilTestState() {
         state.stencil.back.action_depth_fail = GL_KEEP;
         state.stencil.back.action_depth_pass = GL_KEEP;
     }
-    state.MarkDirtyStencilState();
-    maxwell3d.dirty.stencil_test = false;
 }
 
 void RasterizerOpenGL::SyncColorMask() {

src/video_core/renderer_opengl/gl_shader_cache.cpp

@@ -348,23 +348,16 @@ Shader CachedShader::CreateKernelFromCache(const ShaderParameters& params,
 }
 
 std::tuple<GLuint, BaseBindings> CachedShader::GetProgramHandle(const ProgramVariant& variant) {
-    GLuint handle{};
-    if (program_type == ProgramType::Geometry) {
-        handle = GetGeometryShader(variant);
-    } else {
-        const auto [entry, is_cache_miss] = programs.try_emplace(variant);
-        auto& program = entry->second;
-        if (is_cache_miss) {
-            program = TryLoadProgram(variant);
-            if (!program) {
-                program = SpecializeShader(code, entries, program_type, variant);
-                disk_cache.SaveUsage(GetUsage(variant));
-            }
-
-            LabelGLObject(GL_PROGRAM, program->handle, cpu_addr);
+    const auto [entry, is_cache_miss] = programs.try_emplace(variant);
+    auto& program = entry->second;
+    if (is_cache_miss) {
+        program = TryLoadProgram(variant);
+        if (!program) {
+            program = SpecializeShader(code, entries, program_type, variant);
+            disk_cache.SaveUsage(GetUsage(variant));
         }
 
-        handle = program->handle;
+        LabelGLObject(GL_PROGRAM, program->handle, cpu_addr);
     }
 
     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.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 {
     const auto found = precompiled_programs.find(GetUsage(variant));
     if (found == precompiled_programs.end()) {

src/video_core/renderer_opengl/gl_shader_cache.h

@@ -86,22 +86,6 @@ private:
     explicit CachedShader(const ShaderParameters& params, ProgramType program_type,
                           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;
 
     ShaderDiskCacheUsage GetUsage(const ProgramVariant& variant) const;
@@ -117,11 +101,6 @@ private:
     std::size_t shader_length{};
 
     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> {