video_core/vulkan: Vulkan driver pipelines now contain cache version

So that old cache can get deleted when the cache version changes and does not grow infinitely

src/common/settings.cpp

@@ -200,6 +200,7 @@ void RestoreGlobalState(bool is_powered_on) {
     values.use_asynchronous_shaders.SetGlobal(true);
     values.use_fast_gpu_time.SetGlobal(true);
     values.use_pessimistic_flushes.SetGlobal(true);
+    values.use_vulkan_driver_pipeline_cache.SetGlobal(true);
     values.bg_red.SetGlobal(true);
     values.bg_green.SetGlobal(true);
     values.bg_blue.SetGlobal(true);

src/common/settings.h

@@ -451,6 +451,8 @@ struct Values {
     SwitchableSetting<bool> use_asynchronous_shaders{false, "use_asynchronous_shaders"};
     SwitchableSetting<bool> use_fast_gpu_time{true, "use_fast_gpu_time"};
     SwitchableSetting<bool> use_pessimistic_flushes{false, "use_pessimistic_flushes"};
+    SwitchableSetting<bool> use_vulkan_driver_pipeline_cache{true,
+                                                             "use_vulkan_driver_pipeline_cache"};
 
     SwitchableSetting<u8> bg_red{0, "bg_red"};
     SwitchableSetting<u8> bg_green{0, "bg_green"};

src/video_core/CMakeLists.txt

@@ -99,8 +99,6 @@ add_library(video_core STATIC
     renderer_null/null_rasterizer.h
     renderer_null/renderer_null.cpp
     renderer_null/renderer_null.h
-    renderer_opengl/blit_image.cpp
-    renderer_opengl/blit_image.h
     renderer_opengl/gl_buffer_cache.cpp
     renderer_opengl/gl_buffer_cache.h
     renderer_opengl/gl_compute_pipeline.cpp

src/video_core/engines/draw_manager.cpp

@@ -51,10 +51,6 @@ void DrawManager::ProcessMethodCall(u32 method, u32 argument) {
         LOG_WARNING(HW_GPU, "(STUBBED) called");
         break;
     }
-    case MAXWELL3D_REG_INDEX(draw_texture.src_y0): {
-        DrawTexture();
-        break;
-    }
     default:
         break;
     }
@@ -183,33 +179,6 @@ void DrawManager::DrawIndexSmall(u32 argument) {
     ProcessDraw(true, 1);
 }
 
-void DrawManager::DrawTexture() {
-    const auto& regs{maxwell3d->regs};
-    draw_texture_state.dst_x0 = static_cast<float>(regs.draw_texture.dst_x0) / 4096.f;
-    draw_texture_state.dst_y0 = static_cast<float>(regs.draw_texture.dst_y0) / 4096.f;
-    const auto dst_width = static_cast<float>(regs.draw_texture.dst_width) / 4096.f;
-    const auto dst_height = static_cast<float>(regs.draw_texture.dst_height) / 4096.f;
-    const bool lower_left{regs.window_origin.mode !=
-                          Maxwell3D::Regs::WindowOrigin::Mode::UpperLeft};
-    if (lower_left) {
-        draw_texture_state.dst_y0 -= dst_height;
-    }
-    draw_texture_state.dst_x1 = draw_texture_state.dst_x0 + dst_width;
-    draw_texture_state.dst_y1 = draw_texture_state.dst_y0 + dst_height;
-    draw_texture_state.src_x0 = static_cast<float>(regs.draw_texture.src_x0) / 4096.f;
-    draw_texture_state.src_y0 = static_cast<float>(regs.draw_texture.src_y0) / 4096.f;
-    draw_texture_state.src_x1 =
-        (static_cast<float>(regs.draw_texture.dx_du) / 4294967296.f) * dst_width +
-        draw_texture_state.src_x0;
-    draw_texture_state.src_y1 =
-        (static_cast<float>(regs.draw_texture.dy_dv) / 4294967296.f) * dst_height +
-        draw_texture_state.src_y0;
-    draw_texture_state.src_sampler = regs.draw_texture.src_sampler;
-    draw_texture_state.src_texture = regs.draw_texture.src_texture;
-
-    maxwell3d->rasterizer->DrawTexture();
-}
-
 void DrawManager::UpdateTopology() {
     const auto& regs{maxwell3d->regs};
     switch (regs.primitive_topology_control) {

src/video_core/engines/draw_manager.h

@@ -32,19 +32,6 @@ public:
         std::vector<u8> inline_index_draw_indexes;
     };
 
-    struct DrawTextureState {
-        f32 dst_x0;
-        f32 dst_y0;
-        f32 dst_x1;
-        f32 dst_y1;
-        f32 src_x0;
-        f32 src_y0;
-        f32 src_x1;
-        f32 src_y1;
-        u32 src_sampler;
-        u32 src_texture;
-    };
-
     struct IndirectParams {
         bool is_indexed;
         bool include_count;
@@ -77,10 +64,6 @@ public:
         return draw_state;
     }
 
-    const DrawTextureState& GetDrawTextureState() const {
-        return draw_texture_state;
-    }
-
     IndirectParams& GetIndirectParams() {
         return indirect_state;
     }
@@ -98,8 +81,6 @@ private:
 
     void DrawIndexSmall(u32 argument);
 
-    void DrawTexture();
-
     void UpdateTopology();
 
     void ProcessDraw(bool draw_indexed, u32 instance_count);
@@ -108,7 +89,6 @@ private:
 
     Maxwell3D* maxwell3d{};
     State draw_state{};
-    DrawTextureState draw_texture_state{};
     IndirectParams indirect_state{};
 };
 } // namespace Tegra::Engines

src/video_core/engines/maxwell_3d.cpp

@@ -149,7 +149,6 @@ bool Maxwell3D::IsMethodExecutable(u32 method) {
     case MAXWELL3D_REG_INDEX(inline_index_4x8.index0):
     case MAXWELL3D_REG_INDEX(vertex_array_instance_first):
     case MAXWELL3D_REG_INDEX(vertex_array_instance_subsequent):
-    case MAXWELL3D_REG_INDEX(draw_texture.src_y0):
     case MAXWELL3D_REG_INDEX(wait_for_idle):
     case MAXWELL3D_REG_INDEX(shadow_ram_control):
     case MAXWELL3D_REG_INDEX(load_mme.instruction_ptr):

src/video_core/engines/maxwell_3d.h

@@ -1599,20 +1599,6 @@ public:
         };
         static_assert(sizeof(TIRModulationCoeff) == 0x4);
 
-        struct DrawTexture {
-            s32 dst_x0;
-            s32 dst_y0;
-            s32 dst_width;
-            s32 dst_height;
-            s64 dx_du;
-            s64 dy_dv;
-            u32 src_sampler;
-            u32 src_texture;
-            s32 src_x0;
-            s32 src_y0;
-        };
-        static_assert(sizeof(DrawTexture) == 0x30);
-
         struct ReduceColorThreshold {
             union {
                 BitField<0, 8, u32> all_hit_once;
@@ -2765,7 +2751,7 @@ public:
                 u32 reserved_sw_method2;                                               ///< 0x102C
                 std::array<TIRModulationCoeff, 5> tir_modulation_coeff;                ///< 0x1030
                 std::array<u32, 15> spare_nop;                                         ///< 0x1044
-                DrawTexture draw_texture;                                              ///< 0x1080
+                INSERT_PADDING_BYTES_NOINIT(0x30);
                 std::array<u32, 7> reserved_sw_method3_to_7;                           ///< 0x10B0
                 ReduceColorThreshold reduce_color_thresholds_unorm8;                   ///< 0x10CC
                 std::array<u32, 4> reserved_sw_method10_to_13;                         ///< 0x10D0

src/video_core/host_shaders/CMakeLists.txt

@@ -11,7 +11,6 @@ set(GLSL_INCLUDES
 
 set(SHADER_FILES
     astc_decoder.comp
-    blit_color_float.frag
     block_linear_unswizzle_2d.comp
     block_linear_unswizzle_3d.comp
     convert_abgr8_to_d24s8.frag
@@ -37,6 +36,7 @@ set(SHADER_FILES
     smaa_blending_weight_calculation.frag
     smaa_neighborhood_blending.vert
     smaa_neighborhood_blending.frag
+    vulkan_blit_color_float.frag
     vulkan_blit_depth_stencil.frag
     vulkan_fidelityfx_fsr_easu_fp16.comp
     vulkan_fidelityfx_fsr_easu_fp32.comp

src/video_core/host_shaders/full_screen_triangle.vert

@@ -4,20 +4,13 @@
 #version 450
 
 #ifdef VULKAN
-#define VERTEX_ID gl_VertexIndex
 #define BEGIN_PUSH_CONSTANTS layout(push_constant) uniform PushConstants {
 #define END_PUSH_CONSTANTS };
 #define UNIFORM(n)
-#define FLIPY 1
 #else // ^^^ Vulkan ^^^ // vvv OpenGL vvv
-#define VERTEX_ID gl_VertexID
 #define BEGIN_PUSH_CONSTANTS
 #define END_PUSH_CONSTANTS
-#define FLIPY -1
 #define UNIFORM(n) layout (location = n) uniform
-out gl_PerVertex {
-    vec4 gl_Position;
-};
 #endif
 
 BEGIN_PUSH_CONSTANTS
@@ -28,8 +21,8 @@ END_PUSH_CONSTANTS
 layout(location = 0) out vec2 texcoord;
 
 void main() {
-    float x = float((VERTEX_ID & 1) << 2);
-    float y = float((VERTEX_ID & 2) << 1);
-    gl_Position = vec4(x - 1.0, FLIPY * (y - 1.0), 0.0, 1.0);
+    float x = float((gl_VertexIndex & 1) << 2);
+    float y = float((gl_VertexIndex & 2) << 1);
+    gl_Position = vec4(x - 1.0, y - 1.0, 0.0, 1.0);
     texcoord = fma(vec2(x, y) / 2.0, tex_scale, tex_offset);
 }

src/video_core/rasterizer_interface.h

@@ -46,9 +46,6 @@ public:
     /// Dispatches an indirect draw invocation
     virtual void DrawIndirect() {}
 
-    /// Dispatches an draw texture invocation
-    virtual void DrawTexture() = 0;
-
     /// Clear the current framebuffer
     virtual void Clear(u32 layer_count) = 0;
 

src/video_core/renderer_null/null_rasterizer.cpp

@@ -21,7 +21,6 @@ RasterizerNull::RasterizerNull(Core::Memory::Memory& cpu_memory_, Tegra::GPU& gp
 RasterizerNull::~RasterizerNull() = default;
 
 void RasterizerNull::Draw(bool is_indexed, u32 instance_count) {}
-void RasterizerNull::DrawTexture() {}
 void RasterizerNull::Clear(u32 layer_count) {}
 void RasterizerNull::DispatchCompute() {}
 void RasterizerNull::ResetCounter(VideoCore::QueryType type) {}

src/video_core/renderer_null/null_rasterizer.h

@@ -31,7 +31,6 @@ public:
     ~RasterizerNull() override;
 
     void Draw(bool is_indexed, u32 instance_count) override;
-    void DrawTexture() override;
     void Clear(u32 layer_count) override;
     void DispatchCompute() override;
     void ResetCounter(VideoCore::QueryType type) override;

src/video_core/renderer_opengl/blit_image.cpp

@@ -1,59 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#include <algorithm>
-
-#include "video_core/host_shaders/blit_color_float_frag.h"
-#include "video_core/host_shaders/full_screen_triangle_vert.h"
-#include "video_core/renderer_opengl/blit_image.h"
-#include "video_core/renderer_opengl/gl_shader_manager.h"
-#include "video_core/renderer_opengl/gl_shader_util.h"
-
-namespace OpenGL {
-
-BlitImageHelper::BlitImageHelper(ProgramManager& program_manager_)
-    : program_manager(program_manager_),
-      full_screen_vert(CreateProgram(HostShaders::FULL_SCREEN_TRIANGLE_VERT, GL_VERTEX_SHADER)),
-      blit_color_to_color_frag(
-          CreateProgram(HostShaders::BLIT_COLOR_FLOAT_FRAG, GL_FRAGMENT_SHADER)) {}
-
-BlitImageHelper::~BlitImageHelper() = default;
-
-void BlitImageHelper::BlitColor(GLuint dst_framebuffer, GLuint src_image_view, GLuint src_sampler,
-                                const Region2D& dst_region, const Region2D& src_region,
-                                const Extent3D& src_size) {
-    glEnable(GL_CULL_FACE);
-    glDisable(GL_COLOR_LOGIC_OP);
-    glDisable(GL_DEPTH_TEST);
-    glDisable(GL_STENCIL_TEST);
-    glDisable(GL_POLYGON_OFFSET_FILL);
-    glDisable(GL_RASTERIZER_DISCARD);
-    glDisable(GL_ALPHA_TEST);
-    glDisablei(GL_BLEND, 0);
-    glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
-    glCullFace(GL_BACK);
-    glFrontFace(GL_CW);
-    glColorMaski(0, GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
-    glDepthRangeIndexed(0, 0.0, 0.0);
-
-    program_manager.BindPresentPrograms(full_screen_vert.handle, blit_color_to_color_frag.handle);
-    glProgramUniform2f(full_screen_vert.handle, 0,
-                       static_cast<float>(src_region.end.x - src_region.start.x) /
-                           static_cast<float>(src_size.width),
-                       static_cast<float>(src_region.end.y - src_region.start.y) /
-                           static_cast<float>(src_size.height));
-    glProgramUniform2f(full_screen_vert.handle, 1,
-                       static_cast<float>(src_region.start.x) / static_cast<float>(src_size.width),
-                       static_cast<float>(src_region.start.y) /
-                           static_cast<float>(src_size.height));
-    glViewport(std::min(dst_region.start.x, dst_region.end.x),
-               std::min(dst_region.start.y, dst_region.end.y),
-               std::abs(dst_region.end.x - dst_region.start.x),
-               std::abs(dst_region.end.y - dst_region.start.y));
-    glBindFramebuffer(GL_DRAW_FRAMEBUFFER, dst_framebuffer);
-    glBindSampler(0, src_sampler);
-    glBindTextureUnit(0, src_image_view);
-    glClear(GL_COLOR_BUFFER_BIT);
-    glDrawArrays(GL_TRIANGLES, 0, 3);
-}
-} // namespace OpenGL

src/video_core/renderer_opengl/blit_image.h

@@ -1,38 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#pragma once
-
-#include <glad/glad.h>
-
-#include "video_core/engines/fermi_2d.h"
-#include "video_core/renderer_opengl/gl_resource_manager.h"
-#include "video_core/texture_cache/types.h"
-
-namespace OpenGL {
-
-using VideoCommon::Extent3D;
-using VideoCommon::Offset2D;
-using VideoCommon::Region2D;
-
-class ProgramManager;
-class Framebuffer;
-class ImageView;
-
-class BlitImageHelper {
-public:
-    explicit BlitImageHelper(ProgramManager& program_manager);
-    ~BlitImageHelper();
-
-    void BlitColor(GLuint dst_framebuffer, GLuint src_image_view, GLuint src_sampler,
-                   const Region2D& dst_region, const Region2D& src_region,
-                   const Extent3D& src_size);
-
-private:
-    ProgramManager& program_manager;
-
-    OGLProgram full_screen_vert;
-    OGLProgram blit_color_to_color_frag;
-};
-
-} // namespace OpenGL

src/video_core/renderer_opengl/gl_device.cpp

@@ -166,7 +166,6 @@ Device::Device(Core::Frontend::EmuWindow& emu_window) {
     has_shader_int64 = HasExtension(extensions, "GL_ARB_gpu_shader_int64");
     has_amd_shader_half_float = GLAD_GL_AMD_gpu_shader_half_float;
     has_sparse_texture_2 = GLAD_GL_ARB_sparse_texture2;
-    has_draw_texture = GLAD_GL_NV_draw_texture;
     warp_size_potentially_larger_than_guest = !is_nvidia && !is_intel;
     need_fastmath_off = is_nvidia;
     can_report_memory = GLAD_GL_NVX_gpu_memory_info;

src/video_core/renderer_opengl/gl_device.h

@@ -4,8 +4,6 @@
 #pragma once
 
 #include <cstddef>
-#include <string>
-
 #include "common/common_types.h"
 #include "core/frontend/emu_window.h"
 #include "shader_recompiler/stage.h"
@@ -148,10 +146,6 @@ public:
         return has_sparse_texture_2;
     }
 
-    bool HasDrawTexture() const {
-        return has_draw_texture;
-    }
-
     bool IsWarpSizePotentiallyLargerThanGuest() const {
         return warp_size_potentially_larger_than_guest;
     }
@@ -222,7 +216,6 @@ private:
     bool has_shader_int64{};
     bool has_amd_shader_half_float{};
     bool has_sparse_texture_2{};
-    bool has_draw_texture{};
     bool warp_size_potentially_larger_than_guest{};
     bool need_fastmath_off{};
     bool has_cbuf_ftou_bug{};

src/video_core/renderer_opengl/gl_rasterizer.cpp

@@ -64,8 +64,7 @@ RasterizerOpenGL::RasterizerOpenGL(Core::Frontend::EmuWindow& emu_window_, Tegra
       shader_cache(*this, emu_window_, device, texture_cache, buffer_cache, program_manager,
                    state_tracker, gpu.ShaderNotify()),
       query_cache(*this), accelerate_dma(buffer_cache),
-      fence_manager(*this, gpu, texture_cache, buffer_cache, query_cache),
-      blit_image(program_manager_) {}
+      fence_manager(*this, gpu, texture_cache, buffer_cache, query_cache) {}
 
 RasterizerOpenGL::~RasterizerOpenGL() = default;
 
@@ -319,47 +318,6 @@ void RasterizerOpenGL::DrawIndirect() {
     buffer_cache.SetDrawIndirect(nullptr);
 }
 
-void RasterizerOpenGL::DrawTexture() {
-    MICROPROFILE_SCOPE(OpenGL_Drawing);
-
-    SCOPE_EXIT({ gpu.TickWork(); });
-    query_cache.UpdateCounters();
-
-    texture_cache.SynchronizeGraphicsDescriptors();
-    texture_cache.UpdateRenderTargets(false);
-
-    SyncState();
-
-    const auto& draw_texture_state = maxwell3d->draw_manager->GetDrawTextureState();
-    const auto& sampler = texture_cache.GetGraphicsSampler(draw_texture_state.src_sampler);
-    const auto& texture = texture_cache.GetImageView(draw_texture_state.src_texture);
-
-    if (device.HasDrawTexture()) {
-        state_tracker.BindFramebuffer(texture_cache.GetFramebuffer()->Handle());
-
-        glDrawTextureNV(texture.DefaultHandle(), sampler->Handle(), draw_texture_state.dst_x0,
-                        draw_texture_state.dst_y0, draw_texture_state.dst_x1,
-                        draw_texture_state.dst_y1, 0,
-                        draw_texture_state.src_x0 / static_cast<float>(texture.size.width),
-                        draw_texture_state.src_y0 / static_cast<float>(texture.size.height),
-                        draw_texture_state.src_x1 / static_cast<float>(texture.size.width),
-                        draw_texture_state.src_y1 / static_cast<float>(texture.size.height));
-    } else {
-        Region2D dst_region = {Offset2D{.x = static_cast<s32>(draw_texture_state.dst_x0),
-                                        .y = static_cast<s32>(draw_texture_state.dst_y0)},
-                               Offset2D{.x = static_cast<s32>(draw_texture_state.dst_x1),
-                                        .y = static_cast<s32>(draw_texture_state.dst_y1)}};
-        Region2D src_region = {Offset2D{.x = static_cast<s32>(draw_texture_state.src_x0),
-                                        .y = static_cast<s32>(draw_texture_state.src_y0)},
-                               Offset2D{.x = static_cast<s32>(draw_texture_state.src_x1),
-                                        .y = static_cast<s32>(draw_texture_state.src_y1)}};
-        blit_image.BlitColor(texture_cache.GetFramebuffer()->Handle(), texture.DefaultHandle(),
-                             sampler->Handle(), dst_region, src_region, texture.size);
-    }
-
-    ++num_queued_commands;
-}
-
 void RasterizerOpenGL::DispatchCompute() {
     ComputePipeline* const pipeline{shader_cache.CurrentComputePipeline()};
     if (!pipeline) {

src/video_core/renderer_opengl/gl_rasterizer.h

@@ -16,7 +16,6 @@
 #include "video_core/engines/maxwell_dma.h"
 #include "video_core/rasterizer_accelerated.h"
 #include "video_core/rasterizer_interface.h"
-#include "video_core/renderer_opengl/blit_image.h"
 #include "video_core/renderer_opengl/gl_buffer_cache.h"
 #include "video_core/renderer_opengl/gl_device.h"
 #include "video_core/renderer_opengl/gl_fence_manager.h"
@@ -71,7 +70,6 @@ public:
 
     void Draw(bool is_indexed, u32 instance_count) override;
     void DrawIndirect() override;
-    void DrawTexture() override;
     void Clear(u32 layer_count) override;
     void DispatchCompute() override;
     void ResetCounter(VideoCore::QueryType type) override;
@@ -226,8 +224,6 @@ private:
     AccelerateDMA accelerate_dma;
     FenceManagerOpenGL fence_manager;
 
-    BlitImageHelper blit_image;
-
     boost::container::static_vector<u32, MAX_IMAGE_VIEWS> image_view_indices;
     std::array<ImageViewId, MAX_IMAGE_VIEWS> image_view_ids;
     boost::container::static_vector<GLuint, MAX_TEXTURES> sampler_handles;

src/video_core/renderer_opengl/gl_shader_manager.cpp

@@ -1,123 +1,2 @@
 // SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
-
-#include <glad/glad.h>
-
-#include "video_core/renderer_opengl/gl_shader_manager.h"
-
-namespace OpenGL {
-
-static constexpr std::array ASSEMBLY_PROGRAM_ENUMS{
-    GL_VERTEX_PROGRAM_NV,   GL_TESS_CONTROL_PROGRAM_NV, GL_TESS_EVALUATION_PROGRAM_NV,
-    GL_GEOMETRY_PROGRAM_NV, GL_FRAGMENT_PROGRAM_NV,
-};
-
-ProgramManager::ProgramManager(const Device& device) {
-    glCreateProgramPipelines(1, &pipeline.handle);
-    if (device.UseAssemblyShaders()) {
-        glEnable(GL_COMPUTE_PROGRAM_NV);
-    }
-}
-
-void ProgramManager::BindComputeProgram(GLuint program) {
-    glUseProgram(program);
-    is_compute_bound = true;
-}
-
-void ProgramManager::BindComputeAssemblyProgram(GLuint program) {
-    if (current_assembly_compute_program != program) {
-        current_assembly_compute_program = program;
-        glBindProgramARB(GL_COMPUTE_PROGRAM_NV, program);
-    }
-    UnbindPipeline();
-}
-
-void ProgramManager::BindSourcePrograms(std::span<const OGLProgram, NUM_STAGES> programs) {
-    static constexpr std::array<GLenum, 5> stage_enums{
-        GL_VERTEX_SHADER_BIT,   GL_TESS_CONTROL_SHADER_BIT, GL_TESS_EVALUATION_SHADER_BIT,
-        GL_GEOMETRY_SHADER_BIT, GL_FRAGMENT_SHADER_BIT,
-    };
-    for (size_t stage = 0; stage < NUM_STAGES; ++stage) {
-        if (current_programs[stage] != programs[stage].handle) {
-            current_programs[stage] = programs[stage].handle;
-            glUseProgramStages(pipeline.handle, stage_enums[stage], programs[stage].handle);
-        }
-    }
-    BindPipeline();
-}
-
-void ProgramManager::BindPresentPrograms(GLuint vertex, GLuint fragment) {
-    if (current_programs[0] != vertex) {
-        current_programs[0] = vertex;
-        glUseProgramStages(pipeline.handle, GL_VERTEX_SHADER_BIT, vertex);
-    }
-    if (current_programs[4] != fragment) {
-        current_programs[4] = fragment;
-        glUseProgramStages(pipeline.handle, GL_FRAGMENT_SHADER_BIT, fragment);
-    }
-    glUseProgramStages(
-        pipeline.handle,
-        GL_TESS_CONTROL_SHADER_BIT | GL_TESS_EVALUATION_SHADER_BIT | GL_GEOMETRY_SHADER_BIT, 0);
-    current_programs[1] = 0;
-    current_programs[2] = 0;
-    current_programs[3] = 0;
-
-    if (current_stage_mask != 0) {
-        current_stage_mask = 0;
-        for (const GLenum program_type : ASSEMBLY_PROGRAM_ENUMS) {
-            glDisable(program_type);
-        }
-    }
-    BindPipeline();
-}
-
-void ProgramManager::BindAssemblyPrograms(std::span<const OGLAssemblyProgram, NUM_STAGES> programs,
-                                          u32 stage_mask) {
-    const u32 changed_mask = current_stage_mask ^ stage_mask;
-    current_stage_mask = stage_mask;
-
-    if (changed_mask != 0) {
-        for (size_t stage = 0; stage < NUM_STAGES; ++stage) {
-            if (((changed_mask >> stage) & 1) != 0) {
-                if (((stage_mask >> stage) & 1) != 0) {
-                    glEnable(ASSEMBLY_PROGRAM_ENUMS[stage]);
-                } else {
-                    glDisable(ASSEMBLY_PROGRAM_ENUMS[stage]);
-                }
-            }
-        }
-    }
-    for (size_t stage = 0; stage < NUM_STAGES; ++stage) {
-        if (current_programs[stage] != programs[stage].handle) {
-            current_programs[stage] = programs[stage].handle;
-            glBindProgramARB(ASSEMBLY_PROGRAM_ENUMS[stage], programs[stage].handle);
-        }
-    }
-    UnbindPipeline();
-}
-
-void ProgramManager::RestoreGuestCompute() {}
-
-void ProgramManager::BindPipeline() {
-    if (!is_pipeline_bound) {
-        is_pipeline_bound = true;
-        glBindProgramPipeline(pipeline.handle);
-    }
-    UnbindCompute();
-}
-
-void ProgramManager::UnbindPipeline() {
-    if (is_pipeline_bound) {
-        is_pipeline_bound = false;
-        glBindProgramPipeline(0);
-    }
-    UnbindCompute();
-}
-
-void ProgramManager::UnbindCompute() {
-    if (is_compute_bound) {
-        is_compute_bound = false;
-        glUseProgram(0);
-    }
-}
-} // namespace OpenGL

src/video_core/renderer_opengl/gl_shader_manager.h

@@ -6,6 +6,8 @@
 #include <array>
 #include <span>
 
+#include <glad/glad.h>
+
 #include "video_core/renderer_opengl/gl_device.h"
 #include "video_core/renderer_opengl/gl_resource_manager.h"
 
@@ -14,28 +16,121 @@ namespace OpenGL {
 class ProgramManager {
     static constexpr size_t NUM_STAGES = 5;
 
+    static constexpr std::array ASSEMBLY_PROGRAM_ENUMS{
+        GL_VERTEX_PROGRAM_NV,   GL_TESS_CONTROL_PROGRAM_NV, GL_TESS_EVALUATION_PROGRAM_NV,
+        GL_GEOMETRY_PROGRAM_NV, GL_FRAGMENT_PROGRAM_NV,
+    };
+
 public:
-    explicit ProgramManager(const Device& device);
+    explicit ProgramManager(const Device& device) {
+        glCreateProgramPipelines(1, &pipeline.handle);
+        if (device.UseAssemblyShaders()) {
+            glEnable(GL_COMPUTE_PROGRAM_NV);
+        }
+    }
 
-    void BindComputeProgram(GLuint program);
+    void BindComputeProgram(GLuint program) {
+        glUseProgram(program);
+        is_compute_bound = true;
+    }
 
-    void BindComputeAssemblyProgram(GLuint program);
+    void BindComputeAssemblyProgram(GLuint program) {
+        if (current_assembly_compute_program != program) {
+            current_assembly_compute_program = program;
+            glBindProgramARB(GL_COMPUTE_PROGRAM_NV, program);
+        }
+        UnbindPipeline();
+    }
 
-    void BindSourcePrograms(std::span<const OGLProgram, NUM_STAGES> programs);
+    void BindSourcePrograms(std::span<const OGLProgram, NUM_STAGES> programs) {
+        static constexpr std::array<GLenum, 5> stage_enums{
+            GL_VERTEX_SHADER_BIT,   GL_TESS_CONTROL_SHADER_BIT, GL_TESS_EVALUATION_SHADER_BIT,
+            GL_GEOMETRY_SHADER_BIT, GL_FRAGMENT_SHADER_BIT,
+        };
+        for (size_t stage = 0; stage < NUM_STAGES; ++stage) {
+            if (current_programs[stage] != programs[stage].handle) {
+                current_programs[stage] = programs[stage].handle;
+                glUseProgramStages(pipeline.handle, stage_enums[stage], programs[stage].handle);
+            }
+        }
+        BindPipeline();
+    }
 
-    void BindPresentPrograms(GLuint vertex, GLuint fragment);
+    void BindPresentPrograms(GLuint vertex, GLuint fragment) {
+        if (current_programs[0] != vertex) {
+            current_programs[0] = vertex;
+            glUseProgramStages(pipeline.handle, GL_VERTEX_SHADER_BIT, vertex);
+        }
+        if (current_programs[4] != fragment) {
+            current_programs[4] = fragment;
+            glUseProgramStages(pipeline.handle, GL_FRAGMENT_SHADER_BIT, fragment);
+        }
+        glUseProgramStages(
+            pipeline.handle,
+            GL_TESS_CONTROL_SHADER_BIT | GL_TESS_EVALUATION_SHADER_BIT | GL_GEOMETRY_SHADER_BIT, 0);
+        current_programs[1] = 0;
+        current_programs[2] = 0;
+        current_programs[3] = 0;
+
+        if (current_stage_mask != 0) {
+            current_stage_mask = 0;
+            for (const GLenum program_type : ASSEMBLY_PROGRAM_ENUMS) {
+                glDisable(program_type);
+            }
+        }
+        BindPipeline();
+    }
 
     void BindAssemblyPrograms(std::span<const OGLAssemblyProgram, NUM_STAGES> programs,
-                              u32 stage_mask);
+                              u32 stage_mask) {
+        const u32 changed_mask = current_stage_mask ^ stage_mask;
+        current_stage_mask = stage_mask;
 
-    void RestoreGuestCompute();
+        if (changed_mask != 0) {
+            for (size_t stage = 0; stage < NUM_STAGES; ++stage) {
+                if (((changed_mask >> stage) & 1) != 0) {
+                    if (((stage_mask >> stage) & 1) != 0) {
+                        glEnable(ASSEMBLY_PROGRAM_ENUMS[stage]);
+                    } else {
+                        glDisable(ASSEMBLY_PROGRAM_ENUMS[stage]);
+                    }
+                }
+            }
+        }
+        for (size_t stage = 0; stage < NUM_STAGES; ++stage) {
+            if (current_programs[stage] != programs[stage].handle) {
+                current_programs[stage] = programs[stage].handle;
+                glBindProgramARB(ASSEMBLY_PROGRAM_ENUMS[stage], programs[stage].handle);
+            }
+        }
+        UnbindPipeline();
+    }
+
+    void RestoreGuestCompute() {}
 
 private:
-    void BindPipeline();
+    void BindPipeline() {
+        if (!is_pipeline_bound) {
+            is_pipeline_bound = true;
+            glBindProgramPipeline(pipeline.handle);
+        }
+        UnbindCompute();
+    }
 
-    void UnbindPipeline();
+    void UnbindPipeline() {
+        if (is_pipeline_bound) {
+            is_pipeline_bound = false;
+            glBindProgramPipeline(0);
+        }
+        UnbindCompute();
+    }
 
-    void UnbindCompute();
+    void UnbindCompute() {
+        if (is_compute_bound) {
+            is_compute_bound = false;
+            glUseProgram(0);
+        }
+    }
 
     OGLPipeline pipeline;
     bool is_pipeline_bound{};

src/video_core/renderer_vulkan/blit_image.cpp

@@ -4,13 +4,13 @@
 #include <algorithm>
 
 #include "common/settings.h"
-#include "video_core/host_shaders/blit_color_float_frag_spv.h"
 #include "video_core/host_shaders/convert_abgr8_to_d24s8_frag_spv.h"
 #include "video_core/host_shaders/convert_d24s8_to_abgr8_frag_spv.h"
 #include "video_core/host_shaders/convert_depth_to_float_frag_spv.h"
 #include "video_core/host_shaders/convert_float_to_depth_frag_spv.h"
 #include "video_core/host_shaders/convert_s8d24_to_abgr8_frag_spv.h"
 #include "video_core/host_shaders/full_screen_triangle_vert_spv.h"
+#include "video_core/host_shaders/vulkan_blit_color_float_frag_spv.h"
 #include "video_core/host_shaders/vulkan_blit_depth_stencil_frag_spv.h"
 #include "video_core/renderer_vulkan/blit_image.h"
 #include "video_core/renderer_vulkan/maxwell_to_vk.h"
@@ -303,7 +303,7 @@ void UpdateTwoTexturesDescriptorSet(const Device& device, VkDescriptorSet descri
 }
 
 void BindBlitState(vk::CommandBuffer cmdbuf, VkPipelineLayout layout, const Region2D& dst_region,
-                   const Region2D& src_region, const Extent3D& src_size = {1, 1, 1}) {
+                   const Region2D& src_region) {
     const VkOffset2D offset{
         .x = std::min(dst_region.start.x, dst_region.end.x),
         .y = std::min(dst_region.start.y, dst_region.end.y),
@@ -325,15 +325,12 @@ void BindBlitState(vk::CommandBuffer cmdbuf, VkPipelineLayout layout, const Regi
         .offset = offset,
         .extent = extent,
     };
-    const float scale_x = static_cast<float>(src_region.end.x - src_region.start.x) /
-                          static_cast<float>(src_size.width);
-    const float scale_y = static_cast<float>(src_region.end.y - src_region.start.y) /
-                          static_cast<float>(src_size.height);
+    const float scale_x = static_cast<float>(src_region.end.x - src_region.start.x);
+    const float scale_y = static_cast<float>(src_region.end.y - src_region.start.y);
     const PushConstants push_constants{
         .tex_scale = {scale_x, scale_y},
-        .tex_offset = {static_cast<float>(src_region.start.x) / static_cast<float>(src_size.width),
-                       static_cast<float>(src_region.start.y) /
-                           static_cast<float>(src_size.height)},
+        .tex_offset = {static_cast<float>(src_region.start.x),
+                       static_cast<float>(src_region.start.y)},
     };
     cmdbuf.SetViewport(0, viewport);
     cmdbuf.SetScissor(0, scissor);
@@ -350,51 +347,6 @@ VkExtent2D GetConversionExtent(const ImageView& src_image_view) {
         .height = is_rescaled ? resolution.ScaleUp(height) : height,
     };
 }
-
-void TransitionImageLayout(vk::CommandBuffer& cmdbuf, VkImage image, VkImageLayout target_layout,
-                           VkImageLayout source_layout = VK_IMAGE_LAYOUT_GENERAL) {
-    constexpr VkFlags flags{VK_ACCESS_COLOR_ATTACHMENT_READ_BIT |
-                            VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT | VK_ACCESS_SHADER_READ_BIT};
-    const VkImageMemoryBarrier barrier{
-        .sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,
-        .pNext = nullptr,
-        .srcAccessMask = flags,
-        .dstAccessMask = flags,
-        .oldLayout = source_layout,
-        .newLayout = target_layout,
-        .srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
-        .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
-        .image = image,
-        .subresourceRange{
-            .aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
-            .baseMipLevel = 0,
-            .levelCount = 1,
-            .baseArrayLayer = 0,
-            .layerCount = 1,
-        },
-    };
-    cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT,
-                           0, barrier);
-}
-
-void BeginRenderPass(vk::CommandBuffer& cmdbuf, const Framebuffer* framebuffer) {
-    const VkRenderPass render_pass = framebuffer->RenderPass();
-    const VkFramebuffer framebuffer_handle = framebuffer->Handle();
-    const VkExtent2D render_area = framebuffer->RenderArea();
-    const VkRenderPassBeginInfo renderpass_bi{
-        .sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO,
-        .pNext = nullptr,
-        .renderPass = render_pass,
-        .framebuffer = framebuffer_handle,
-        .renderArea{
-            .offset{},
-            .extent = render_area,
-        },
-        .clearValueCount = 0,
-        .pClearValues = nullptr,
-    };
-    cmdbuf.BeginRenderPass(renderpass_bi, VK_SUBPASS_CONTENTS_INLINE);
-}
 } // Anonymous namespace
 
 BlitImageHelper::BlitImageHelper(const Device& device_, Scheduler& scheduler_,
@@ -413,7 +365,7 @@ BlitImageHelper::BlitImageHelper(const Device& device_, Scheduler& scheduler_,
       two_textures_pipeline_layout(device.GetLogical().CreatePipelineLayout(
           PipelineLayoutCreateInfo(two_textures_set_layout.address()))),
       full_screen_vert(BuildShader(device, FULL_SCREEN_TRIANGLE_VERT_SPV)),
-      blit_color_to_color_frag(BuildShader(device, BLIT_COLOR_FLOAT_FRAG_SPV)),
+      blit_color_to_color_frag(BuildShader(device, VULKAN_BLIT_COLOR_FLOAT_FRAG_SPV)),
       blit_depth_stencil_frag(BuildShader(device, VULKAN_BLIT_DEPTH_STENCIL_FRAG_SPV)),
       convert_depth_to_float_frag(BuildShader(device, CONVERT_DEPTH_TO_FLOAT_FRAG_SPV)),
       convert_float_to_depth_frag(BuildShader(device, CONVERT_FLOAT_TO_DEPTH_FRAG_SPV)),
@@ -452,32 +404,6 @@ void BlitImageHelper::BlitColor(const Framebuffer* dst_framebuffer, VkImageView
     scheduler.InvalidateState();
 }
 
-void BlitImageHelper::BlitColor(const Framebuffer* dst_framebuffer, VkImageView src_image_view,
-                                VkImage src_image, VkSampler src_sampler,
-                                const Region2D& dst_region, const Region2D& src_region,
-                                const Extent3D& src_size) {
-    const BlitImagePipelineKey key{
-        .renderpass = dst_framebuffer->RenderPass(),
-        .operation = Tegra::Engines::Fermi2D::Operation::SrcCopy,
-    };
-    const VkPipelineLayout layout = *one_texture_pipeline_layout;
-    const VkPipeline pipeline = FindOrEmplaceColorPipeline(key);
-    scheduler.RequestOutsideRenderPassOperationContext();
-    scheduler.Record([this, dst_framebuffer, src_image_view, src_image, src_sampler, dst_region,
-                      src_region, src_size, pipeline, layout](vk::CommandBuffer cmdbuf) {
-        TransitionImageLayout(cmdbuf, src_image, VK_IMAGE_LAYOUT_READ_ONLY_OPTIMAL);
-        BeginRenderPass(cmdbuf, dst_framebuffer);
-        const VkDescriptorSet descriptor_set = one_texture_descriptor_allocator.Commit();
-        UpdateOneTextureDescriptorSet(device, descriptor_set, src_sampler, src_image_view);
-        cmdbuf.BindPipeline(VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline);
-        cmdbuf.BindDescriptorSets(VK_PIPELINE_BIND_POINT_GRAPHICS, layout, 0, descriptor_set,
-                                  nullptr);
-        BindBlitState(cmdbuf, layout, dst_region, src_region, src_size);
-        cmdbuf.Draw(3, 1, 0, 0);
-        cmdbuf.EndRenderPass();
-    });
-}
-
 void BlitImageHelper::BlitDepthStencil(const Framebuffer* dst_framebuffer,
                                        VkImageView src_depth_view, VkImageView src_stencil_view,
                                        const Region2D& dst_region, const Region2D& src_region,

src/video_core/renderer_vulkan/blit_image.h

@@ -10,8 +10,6 @@
 
 namespace Vulkan {
 
-using VideoCommon::Extent3D;
-using VideoCommon::Offset2D;
 using VideoCommon::Region2D;
 
 class Device;
@@ -38,10 +36,6 @@ public:
                    Tegra::Engines::Fermi2D::Filter filter,
                    Tegra::Engines::Fermi2D::Operation operation);
 
-    void BlitColor(const Framebuffer* dst_framebuffer, VkImageView src_image_view,
-                   VkImage src_image, VkSampler src_sampler, const Region2D& dst_region,
-                   const Region2D& src_region, const Extent3D& src_size);
-
     void BlitDepthStencil(const Framebuffer* dst_framebuffer, VkImageView src_depth_view,
                           VkImageView src_stencil_view, const Region2D& dst_region,
                           const Region2D& src_region, Tegra::Engines::Fermi2D::Filter filter,

src/video_core/renderer_vulkan/fixed_pipeline_state.cpp

@@ -148,7 +148,7 @@ void FixedPipelineState::Refresh(Tegra::Engines::Maxwell3D& maxwell3d, DynamicFe
         });
     }
     if (!extended_dynamic_state_2_extra) {
-        dynamic_state.Refresh2(regs, topology, extended_dynamic_state_2);
+        dynamic_state.Refresh2(regs, topology_, extended_dynamic_state_2);
     }
     if (!extended_dynamic_state_3_blend) {
         if (maxwell3d.dirty.flags[Dirty::Blending]) {

src/video_core/renderer_vulkan/vk_compute_pipeline.cpp

@@ -24,13 +24,15 @@ using Shader::ImageBufferDescriptor;
 using Shader::Backend::SPIRV::RESCALING_LAYOUT_WORDS_OFFSET;
 using Tegra::Texture::TexturePair;
 
-ComputePipeline::ComputePipeline(const Device& device_, DescriptorPool& descriptor_pool,
+ComputePipeline::ComputePipeline(const Device& device_, vk::PipelineCache& pipeline_cache_,
+                                 DescriptorPool& descriptor_pool,
                                  UpdateDescriptorQueue& update_descriptor_queue_,
                                  Common::ThreadWorker* thread_worker,
                                  PipelineStatistics* pipeline_statistics,
                                  VideoCore::ShaderNotify* shader_notify, const Shader::Info& info_,
                                  vk::ShaderModule spv_module_)
-    : device{device_}, update_descriptor_queue{update_descriptor_queue_}, info{info_},
+    : device{device_}, pipeline_cache(pipeline_cache_),
+      update_descriptor_queue{update_descriptor_queue_}, info{info_},
       spv_module(std::move(spv_module_)) {
     if (shader_notify) {
         shader_notify->MarkShaderBuilding();
@@ -56,23 +58,27 @@ ComputePipeline::ComputePipeline(const Device& device_, DescriptorPool& descript
         if (device.IsKhrPipelineExecutablePropertiesEnabled()) {
             flags |= VK_PIPELINE_CREATE_CAPTURE_STATISTICS_BIT_KHR;
         }
-        pipeline = device.GetLogical().CreateComputePipeline({
-            .sType = VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO,
-            .pNext = nullptr,
-            .flags = flags,
-            .stage{
-                .sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,
-                .pNext = device.IsExtSubgroupSizeControlSupported() ? &subgroup_size_ci : nullptr,
-                .flags = 0,
-                .stage = VK_SHADER_STAGE_COMPUTE_BIT,
-                .module = *spv_module,
-                .pName = "main",
-                .pSpecializationInfo = nullptr,
+        pipeline = device.GetLogical().CreateComputePipeline(
+            {
+                .sType = VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO,
+                .pNext = nullptr,
+                .flags = flags,
+                .stage{
+                    .sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,
+                    .pNext =
+                        device.IsExtSubgroupSizeControlSupported() ? &subgroup_size_ci : nullptr,
+                    .flags = 0,
+                    .stage = VK_SHADER_STAGE_COMPUTE_BIT,
+                    .module = *spv_module,
+                    .pName = "main",
+                    .pSpecializationInfo = nullptr,
+                },
+                .layout = *pipeline_layout,
+                .basePipelineHandle = 0,
+                .basePipelineIndex = 0,
             },
-            .layout = *pipeline_layout,
-            .basePipelineHandle = 0,
-            .basePipelineIndex = 0,
-        });
+            *pipeline_cache);
+
         if (pipeline_statistics) {
             pipeline_statistics->Collect(*pipeline);
         }

src/video_core/renderer_vulkan/vk_compute_pipeline.h

@@ -28,7 +28,8 @@ class Scheduler;
 
 class ComputePipeline {
 public:
-    explicit ComputePipeline(const Device& device, DescriptorPool& descriptor_pool,
+    explicit ComputePipeline(const Device& device, vk::PipelineCache& pipeline_cache,
+                             DescriptorPool& descriptor_pool,
                              UpdateDescriptorQueue& update_descriptor_queue,
                              Common::ThreadWorker* thread_worker,
                              PipelineStatistics* pipeline_statistics,
@@ -46,6 +47,7 @@ public:
 
 private:
     const Device& device;
+    vk::PipelineCache& pipeline_cache;
     UpdateDescriptorQueue& update_descriptor_queue;
     Shader::Info info;
 

src/video_core/renderer_vulkan/vk_graphics_pipeline.cpp

@@ -234,13 +234,14 @@ ConfigureFuncPtr ConfigureFunc(const std::array<vk::ShaderModule, NUM_STAGES>& m
 
 GraphicsPipeline::GraphicsPipeline(
     Scheduler& scheduler_, BufferCache& buffer_cache_, TextureCache& texture_cache_,
-    VideoCore::ShaderNotify* shader_notify, const Device& device_, DescriptorPool& descriptor_pool,
+    vk::PipelineCache& pipeline_cache_, VideoCore::ShaderNotify* shader_notify,
+    const Device& device_, DescriptorPool& descriptor_pool,
     UpdateDescriptorQueue& update_descriptor_queue_, Common::ThreadWorker* worker_thread,
     PipelineStatistics* pipeline_statistics, RenderPassCache& render_pass_cache,
     const GraphicsPipelineCacheKey& key_, std::array<vk::ShaderModule, NUM_STAGES> stages,
     const std::array<const Shader::Info*, NUM_STAGES>& infos)
-    : key{key_}, device{device_}, texture_cache{texture_cache_},
-      buffer_cache{buffer_cache_}, scheduler{scheduler_},
+    : key{key_}, device{device_}, texture_cache{texture_cache_}, buffer_cache{buffer_cache_},
+      pipeline_cache(pipeline_cache_), scheduler{scheduler_},
       update_descriptor_queue{update_descriptor_queue_}, spv_modules{std::move(stages)} {
     if (shader_notify) {
         shader_notify->MarkShaderBuilding();
@@ -644,12 +645,15 @@ void GraphicsPipeline::MakePipeline(VkRenderPass render_pass) {
         .pNext = nullptr,
         .flags = 0,
         .topology = input_assembly_topology,
-        .primitiveRestartEnable = dynamic.primitive_restart_enable != 0 &&
-                                  ((input_assembly_topology != VK_PRIMITIVE_TOPOLOGY_PATCH_LIST &&
-                                    device.IsTopologyListPrimitiveRestartSupported()) ||
-                                   SupportsPrimitiveRestart(input_assembly_topology) ||
-                                   (input_assembly_topology == VK_PRIMITIVE_TOPOLOGY_PATCH_LIST &&
-                                    device.IsPatchListPrimitiveRestartSupported())),
+        .primitiveRestartEnable =
+            dynamic.primitive_restart_enable != 0 &&
+                    ((input_assembly_topology != VK_PRIMITIVE_TOPOLOGY_PATCH_LIST &&
+                      device.IsTopologyListPrimitiveRestartSupported()) ||
+                     SupportsPrimitiveRestart(input_assembly_topology) ||
+                     (input_assembly_topology == VK_PRIMITIVE_TOPOLOGY_PATCH_LIST &&
+                      device.IsPatchListPrimitiveRestartSupported()))
+                ? VK_TRUE
+                : VK_FALSE,
     };
     const VkPipelineTessellationStateCreateInfo tessellation_ci{
         .sType = VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO,
@@ -699,7 +703,7 @@ void GraphicsPipeline::MakePipeline(VkRenderPass render_pass) {
         .cullMode = static_cast<VkCullModeFlags>(
             dynamic.cull_enable ? MaxwellToVK::CullFace(dynamic.CullFace()) : VK_CULL_MODE_NONE),
         .frontFace = MaxwellToVK::FrontFace(dynamic.FrontFace()),
-        .depthBiasEnable = (dynamic.depth_bias_enable == 0 ? VK_TRUE : VK_FALSE),
+        .depthBiasEnable = (dynamic.depth_bias_enable != 0 ? VK_TRUE : VK_FALSE),
         .depthBiasConstantFactor = 0.0f,
         .depthBiasClamp = 0.0f,
         .depthBiasSlopeFactor = 0.0f,
@@ -894,27 +898,29 @@ void GraphicsPipeline::MakePipeline(VkRenderPass render_pass) {
     if (device.IsKhrPipelineExecutablePropertiesEnabled()) {
         flags |= VK_PIPELINE_CREATE_CAPTURE_STATISTICS_BIT_KHR;
     }
-    pipeline = device.GetLogical().CreateGraphicsPipeline({
-        .sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO,
-        .pNext = nullptr,
-        .flags = flags,
-        .stageCount = static_cast<u32>(shader_stages.size()),
-        .pStages = shader_stages.data(),
-        .pVertexInputState = &vertex_input_ci,
-        .pInputAssemblyState = &input_assembly_ci,
-        .pTessellationState = &tessellation_ci,
-        .pViewportState = &viewport_ci,
-        .pRasterizationState = &rasterization_ci,
-        .pMultisampleState = &multisample_ci,
-        .pDepthStencilState = &depth_stencil_ci,
-        .pColorBlendState = &color_blend_ci,
-        .pDynamicState = &dynamic_state_ci,
-        .layout = *pipeline_layout,
-        .renderPass = render_pass,
-        .subpass = 0,
-        .basePipelineHandle = nullptr,
-        .basePipelineIndex = 0,
-    });
+    pipeline = device.GetLogical().CreateGraphicsPipeline(
+        {
+            .sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO,
+            .pNext = nullptr,
+            .flags = flags,
+            .stageCount = static_cast<u32>(shader_stages.size()),
+            .pStages = shader_stages.data(),
+            .pVertexInputState = &vertex_input_ci,
+            .pInputAssemblyState = &input_assembly_ci,
+            .pTessellationState = &tessellation_ci,
+            .pViewportState = &viewport_ci,
+            .pRasterizationState = &rasterization_ci,
+            .pMultisampleState = &multisample_ci,
+            .pDepthStencilState = &depth_stencil_ci,
+            .pColorBlendState = &color_blend_ci,
+            .pDynamicState = &dynamic_state_ci,
+            .layout = *pipeline_layout,
+            .renderPass = render_pass,
+            .subpass = 0,
+            .basePipelineHandle = nullptr,
+            .basePipelineIndex = 0,
+        },
+        *pipeline_cache);
 }
 
 void GraphicsPipeline::Validate() {

src/video_core/renderer_vulkan/vk_graphics_pipeline.h

@@ -70,16 +70,14 @@ class GraphicsPipeline {
     static constexpr size_t NUM_STAGES = Tegra::Engines::Maxwell3D::Regs::MaxShaderStage;
 
 public:
-    explicit GraphicsPipeline(Scheduler& scheduler, BufferCache& buffer_cache,
-                              TextureCache& texture_cache, VideoCore::ShaderNotify* shader_notify,
-                              const Device& device, DescriptorPool& descriptor_pool,
-                              UpdateDescriptorQueue& update_descriptor_queue,
-                              Common::ThreadWorker* worker_thread,
-                              PipelineStatistics* pipeline_statistics,
-                              RenderPassCache& render_pass_cache,
-                              const GraphicsPipelineCacheKey& key,
-                              std::array<vk::ShaderModule, NUM_STAGES> stages,
-                              const std::array<const Shader::Info*, NUM_STAGES>& infos);
+    explicit GraphicsPipeline(
+        Scheduler& scheduler, BufferCache& buffer_cache, TextureCache& texture_cache,
+        vk::PipelineCache& pipeline_cache, VideoCore::ShaderNotify* shader_notify,
+        const Device& device, DescriptorPool& descriptor_pool,
+        UpdateDescriptorQueue& update_descriptor_queue, Common::ThreadWorker* worker_thread,
+        PipelineStatistics* pipeline_statistics, RenderPassCache& render_pass_cache,
+        const GraphicsPipelineCacheKey& key, std::array<vk::ShaderModule, NUM_STAGES> stages,
+        const std::array<const Shader::Info*, NUM_STAGES>& infos);
 
     GraphicsPipeline& operator=(GraphicsPipeline&&) noexcept = delete;
     GraphicsPipeline(GraphicsPipeline&&) noexcept = delete;
@@ -133,6 +131,7 @@ private:
     const Device& device;
     TextureCache& texture_cache;
     BufferCache& buffer_cache;
+    vk::PipelineCache& pipeline_cache;
     Scheduler& scheduler;
     UpdateDescriptorQueue& update_descriptor_queue;
 

src/video_core/renderer_vulkan/vk_pipeline_cache.cpp

@@ -55,6 +55,7 @@ using VideoCommon::GenericEnvironment;
 using VideoCommon::GraphicsEnvironment;
 
 constexpr u32 CACHE_VERSION = 10;
+constexpr std::array<char, 8> VULKAN_CACHE_MAGIC_NUMBER{'y', 'u', 'z', 'u', 'v', 'k', 'c', 'h'};
 
 template <typename Container>
 auto MakeSpan(Container& container) {
@@ -284,6 +285,7 @@ PipelineCache::PipelineCache(RasterizerVulkan& rasterizer_, const Device& device
       render_pass_cache{render_pass_cache_}, buffer_cache{buffer_cache_},
       texture_cache{texture_cache_}, shader_notify{shader_notify_},
       use_asynchronous_shaders{Settings::values.use_asynchronous_shaders.GetValue()},
+      use_vulkan_pipeline_cache{Settings::values.use_vulkan_driver_pipeline_cache.GetValue()},
       workers(std::max(std::thread::hardware_concurrency(), 2U) - 1, "VkPipelineBuilder"),
       serialization_thread(1, "VkPipelineSerialization") {
     const auto& float_control{device.FloatControlProperties()};
@@ -362,7 +364,12 @@ PipelineCache::PipelineCache(RasterizerVulkan& rasterizer_, const Device& device
     };
 }
 
-PipelineCache::~PipelineCache() = default;
+PipelineCache::~PipelineCache() {
+    if (use_vulkan_pipeline_cache && !vulkan_pipeline_cache_filename.empty()) {
+        SerializeVulkanPipelineCache(vulkan_pipeline_cache_filename, vulkan_pipeline_cache,
+                                     CACHE_VERSION);
+    }
+}
 
 GraphicsPipeline* PipelineCache::CurrentGraphicsPipeline() {
     MICROPROFILE_SCOPE(Vulkan_PipelineCache);
@@ -418,6 +425,12 @@ void PipelineCache::LoadDiskResources(u64 title_id, std::stop_token stop_loading
     }
     pipeline_cache_filename = base_dir / "vulkan.bin";
 
+    if (use_vulkan_pipeline_cache) {
+        vulkan_pipeline_cache_filename = base_dir / "vulkan_pipelines.bin";
+        vulkan_pipeline_cache =
+            LoadVulkanPipelineCache(vulkan_pipeline_cache_filename, CACHE_VERSION);
+    }
+
     struct {
         std::mutex mutex;
         size_t total{};
@@ -496,6 +509,11 @@ void PipelineCache::LoadDiskResources(u64 title_id, std::stop_token stop_loading
 
     workers.WaitForRequests(stop_loading);
 
+    if (use_vulkan_pipeline_cache) {
+        SerializeVulkanPipelineCache(vulkan_pipeline_cache_filename, vulkan_pipeline_cache,
+                                     CACHE_VERSION);
+    }
+
     if (state.statistics) {
         state.statistics->Report();
     }
@@ -616,10 +634,10 @@ std::unique_ptr<GraphicsPipeline> PipelineCache::CreateGraphicsPipeline(
         previous_stage = &program;
     }
     Common::ThreadWorker* const thread_worker{build_in_parallel ? &workers : nullptr};
-    return std::make_unique<GraphicsPipeline>(scheduler, buffer_cache, texture_cache,
-                                              &shader_notify, device, descriptor_pool,
-                                              update_descriptor_queue, thread_worker, statistics,
-                                              render_pass_cache, key, std::move(modules), infos);
+    return std::make_unique<GraphicsPipeline>(
+        scheduler, buffer_cache, texture_cache, vulkan_pipeline_cache, &shader_notify, device,
+        descriptor_pool, update_descriptor_queue, thread_worker, statistics, render_pass_cache, key,
+        std::move(modules), infos);
 
 } catch (const Shader::Exception& exception) {
     LOG_ERROR(Render_Vulkan, "{}", exception.what());
@@ -689,13 +707,107 @@ std::unique_ptr<ComputePipeline> PipelineCache::CreateComputePipeline(
         spv_module.SetObjectNameEXT(name.c_str());
     }
     Common::ThreadWorker* const thread_worker{build_in_parallel ? &workers : nullptr};
-    return std::make_unique<ComputePipeline>(device, descriptor_pool, update_descriptor_queue,
-                                             thread_worker, statistics, &shader_notify,
-                                             program.info, std::move(spv_module));
+    return std::make_unique<ComputePipeline>(device, vulkan_pipeline_cache, descriptor_pool,
+                                             update_descriptor_queue, thread_worker, statistics,
+                                             &shader_notify, program.info, std::move(spv_module));
 
 } catch (const Shader::Exception& exception) {
     LOG_ERROR(Render_Vulkan, "{}", exception.what());
     return nullptr;
 }
 
+void PipelineCache::SerializeVulkanPipelineCache(const std::filesystem::path& filename,
+                                                 const vk::PipelineCache& pipeline_cache,
+                                                 u32 cache_version) try {
+    std::ofstream file(filename, std::ios::binary);
+    file.exceptions(std::ifstream::failbit);
+    if (!file.is_open()) {
+        LOG_ERROR(Common_Filesystem, "Failed to open Vulkan driver pipeline cache file {}",
+                  Common::FS::PathToUTF8String(filename));
+        return;
+    }
+    file.write(VULKAN_CACHE_MAGIC_NUMBER.data(), VULKAN_CACHE_MAGIC_NUMBER.size())
+        .write(reinterpret_cast<const char*>(&cache_version), sizeof(cache_version));
+
+    size_t cache_size = 0;
+    std::vector<char> cache_data;
+    if (pipeline_cache) {
+        pipeline_cache.Read(&cache_size, nullptr);
+        cache_data.resize(cache_size);
+        pipeline_cache.Read(&cache_size, cache_data.data());
+    }
+    file.write(cache_data.data(), cache_size);
+
+    LOG_INFO(Render_Vulkan, "Vulkan driver pipelines cached at: {}",
+             Common::FS::PathToUTF8String(filename));
+
+} catch (const std::ios_base::failure& e) {
+    LOG_ERROR(Common_Filesystem, "{}", e.what());
+    if (!Common::FS::RemoveFile(filename)) {
+        LOG_ERROR(Common_Filesystem, "Failed to delete Vulkan driver pipeline cache file {}",
+                  Common::FS::PathToUTF8String(filename));
+    }
+}
+
+vk::PipelineCache PipelineCache::LoadVulkanPipelineCache(const std::filesystem::path& filename,
+                                                         u32 expected_cache_version) {
+    const auto create_pipeline_cache = [this](size_t data_size, const void* data) {
+        VkPipelineCacheCreateInfo pipeline_cache_ci = {
+            .sType = VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO,
+            .pNext = nullptr,
+            .flags = 0,
+            .initialDataSize = data_size,
+            .pInitialData = data};
+        return device.GetLogical().CreatePipelineCache(pipeline_cache_ci);
+    };
+    try {
+        std::ifstream file(filename, std::ios::binary | std::ios::ate);
+        if (!file.is_open()) {
+            return create_pipeline_cache(0, nullptr);
+        }
+        file.exceptions(std::ifstream::failbit);
+        const auto end{file.tellg()};
+        file.seekg(0, std::ios::beg);
+
+        std::array<char, 8> magic_number;
+        u32 cache_version;
+        file.read(magic_number.data(), magic_number.size())
+            .read(reinterpret_cast<char*>(&cache_version), sizeof(cache_version));
+        if (magic_number != VULKAN_CACHE_MAGIC_NUMBER || cache_version != expected_cache_version) {
+            file.close();
+            if (Common::FS::RemoveFile(filename)) {
+                if (magic_number != VULKAN_CACHE_MAGIC_NUMBER) {
+                    LOG_ERROR(Common_Filesystem, "Invalid Vulkan driver pipeline cache file");
+                }
+                if (cache_version != expected_cache_version) {
+                    LOG_INFO(Common_Filesystem, "Deleting old Vulkan driver pipeline cache");
+                }
+            } else {
+                LOG_ERROR(Common_Filesystem,
+                          "Invalid Vulkan pipeline cache file and failed to delete it in \"{}\"",
+                          Common::FS::PathToUTF8String(filename));
+            }
+            return create_pipeline_cache(0, nullptr);
+        }
+
+        const size_t cache_size = static_cast<size_t>(end) - magic_number.size();
+        std::vector<char> cache_data(cache_size);
+        file.read(cache_data.data(), cache_size);
+
+        LOG_INFO(Render_Vulkan,
+                 "Loaded Vulkan driver pipeline cache: ", Common::FS::PathToUTF8String(filename));
+
+        return create_pipeline_cache(cache_size, cache_data.data());
+
+    } catch (const std::ios_base::failure& e) {
+        LOG_ERROR(Common_Filesystem, "{}", e.what());
+        if (!Common::FS::RemoveFile(filename)) {
+            LOG_ERROR(Common_Filesystem, "Failed to delete Vulkan driver pipeline cache file {}",
+                      Common::FS::PathToUTF8String(filename));
+        }
+
+        return create_pipeline_cache(0, nullptr);
+    }
+}
+
 } // namespace Vulkan

src/video_core/renderer_vulkan/vk_pipeline_cache.h

@@ -135,6 +135,12 @@ private:
                                                            PipelineStatistics* statistics,
                                                            bool build_in_parallel);
 
+    void SerializeVulkanPipelineCache(const std::filesystem::path& filename,
+                                      const vk::PipelineCache& pipeline_cache, u32 cache_version);
+
+    vk::PipelineCache LoadVulkanPipelineCache(const std::filesystem::path& filename,
+                                              u32 expected_cache_version);
+
     const Device& device;
     Scheduler& scheduler;
     DescriptorPool& descriptor_pool;
@@ -144,6 +150,7 @@ private:
     TextureCache& texture_cache;
     VideoCore::ShaderNotify& shader_notify;
     bool use_asynchronous_shaders{};
+    bool use_vulkan_pipeline_cache{};
 
     GraphicsPipelineCacheKey graphics_key{};
     GraphicsPipeline* current_pipeline{};
@@ -158,6 +165,9 @@ private:
 
     std::filesystem::path pipeline_cache_filename;
 
+    std::filesystem::path vulkan_pipeline_cache_filename;
+    vk::PipelineCache vulkan_pipeline_cache;
+
     Common::ThreadWorker workers;
     Common::ThreadWorker serialization_thread;
     DynamicFeatures dynamic_features;

src/video_core/renderer_vulkan/vk_rasterizer.cpp

@@ -265,35 +265,6 @@ void RasterizerVulkan::DrawIndirect() {
     buffer_cache.SetDrawIndirect(nullptr);
 }
 
-void RasterizerVulkan::DrawTexture() {
-    MICROPROFILE_SCOPE(Vulkan_Drawing);
-
-    SCOPE_EXIT({ gpu.TickWork(); });
-    FlushWork();
-
-    query_cache.UpdateCounters();
-
-    texture_cache.SynchronizeGraphicsDescriptors();
-    texture_cache.UpdateRenderTargets(false);
-
-    UpdateDynamicStates();
-
-    const auto& draw_texture_state = maxwell3d->draw_manager->GetDrawTextureState();
-    const auto& sampler = texture_cache.GetGraphicsSampler(draw_texture_state.src_sampler);
-    const auto& texture = texture_cache.GetImageView(draw_texture_state.src_texture);
-    Region2D dst_region = {Offset2D{.x = static_cast<s32>(draw_texture_state.dst_x0),
-                                    .y = static_cast<s32>(draw_texture_state.dst_y0)},
-                           Offset2D{.x = static_cast<s32>(draw_texture_state.dst_x1),
-                                    .y = static_cast<s32>(draw_texture_state.dst_y1)}};
-    Region2D src_region = {Offset2D{.x = static_cast<s32>(draw_texture_state.src_x0),
-                                    .y = static_cast<s32>(draw_texture_state.src_y0)},
-                           Offset2D{.x = static_cast<s32>(draw_texture_state.src_x1),
-                                    .y = static_cast<s32>(draw_texture_state.src_y1)}};
-    blit_image.BlitColor(texture_cache.GetFramebuffer(), texture.RenderTarget(),
-                         texture.ImageHandle(), sampler->Handle(), dst_region, src_region,
-                         texture.size);
-}
-
 void RasterizerVulkan::Clear(u32 layer_count) {
     MICROPROFILE_SCOPE(Vulkan_Clearing);
 

src/video_core/renderer_vulkan/vk_rasterizer.h

@@ -66,7 +66,6 @@ public:
 
     void Draw(bool is_indexed, u32 instance_count) override;
     void DrawIndirect() override;
-    void DrawTexture() override;
     void Clear(u32 layer_count) override;
     void DispatchCompute() override;
     void ResetCounter(VideoCore::QueryType type) override;

src/video_core/texture_cache/texture_cache.h

@@ -148,13 +148,6 @@ typename P::ImageView& TextureCache<P>::GetImageView(ImageViewId id) noexcept {
     return slot_image_views[id];
 }
 
-template <class P>
-typename P::ImageView& TextureCache<P>::GetImageView(u32 index) noexcept {
-    const auto image_view_id = VisitImageView(channel_state->graphics_image_table,
-                                              channel_state->graphics_image_view_ids, index);
-    return slot_image_views[image_view_id];
-}
-
 template <class P>
 void TextureCache<P>::MarkModification(ImageId id) noexcept {
     MarkModification(slot_images[id]);

src/video_core/texture_cache/texture_cache_base.h

@@ -129,9 +129,6 @@ public:
     /// Return a reference to the given image view id
     [[nodiscard]] ImageView& GetImageView(ImageViewId id) noexcept;
 
-    /// Get the imageview from the graphics descriptor table in the specified index
-    [[nodiscard]] ImageView& GetImageView(u32 index) noexcept;
-
     /// Mark an image as modified from the GPU
     void MarkModification(ImageId id) noexcept;
 

src/video_core/vulkan_common/vulkan_wrapper.cpp

@@ -152,6 +152,7 @@ void Load(VkDevice device, DeviceDispatch& dld) noexcept {
     X(vkCreateGraphicsPipelines);
     X(vkCreateImage);
     X(vkCreateImageView);
+    X(vkCreatePipelineCache);
     X(vkCreatePipelineLayout);
     X(vkCreateQueryPool);
     X(vkCreateRenderPass);
@@ -171,6 +172,7 @@ void Load(VkDevice device, DeviceDispatch& dld) noexcept {
     X(vkDestroyImage);
     X(vkDestroyImageView);
     X(vkDestroyPipeline);
+    X(vkDestroyPipelineCache);
     X(vkDestroyPipelineLayout);
     X(vkDestroyQueryPool);
     X(vkDestroyRenderPass);
@@ -188,6 +190,7 @@ void Load(VkDevice device, DeviceDispatch& dld) noexcept {
     X(vkGetEventStatus);
     X(vkGetFenceStatus);
     X(vkGetImageMemoryRequirements);
+    X(vkGetPipelineCacheData);
     X(vkGetMemoryFdKHR);
 #ifdef _WIN32
     X(vkGetMemoryWin32HandleKHR);
@@ -431,6 +434,10 @@ void Destroy(VkDevice device, VkPipeline handle, const DeviceDispatch& dld) noex
     dld.vkDestroyPipeline(device, handle, nullptr);
 }
 
+void Destroy(VkDevice device, VkPipelineCache handle, const DeviceDispatch& dld) noexcept {
+    dld.vkDestroyPipelineCache(device, handle, nullptr);
+}
+
 void Destroy(VkDevice device, VkPipelineLayout handle, const DeviceDispatch& dld) noexcept {
     dld.vkDestroyPipelineLayout(device, handle, nullptr);
 }
@@ -651,6 +658,10 @@ void ShaderModule::SetObjectNameEXT(const char* name) const {
     SetObjectName(dld, owner, handle, VK_OBJECT_TYPE_SHADER_MODULE, name);
 }
 
+void PipelineCache::SetObjectNameEXT(const char* name) const {
+    SetObjectName(dld, owner, handle, VK_OBJECT_TYPE_PIPELINE_CACHE, name);
+}
+
 void Semaphore::SetObjectNameEXT(const char* name) const {
     SetObjectName(dld, owner, handle, VK_OBJECT_TYPE_SEMAPHORE, name);
 }
@@ -746,21 +757,29 @@ DescriptorSetLayout Device::CreateDescriptorSetLayout(
     return DescriptorSetLayout(object, handle, *dld);
 }
 
+PipelineCache Device::CreatePipelineCache(const VkPipelineCacheCreateInfo& ci) const {
+    VkPipelineCache cache;
+    Check(dld->vkCreatePipelineCache(handle, &ci, nullptr, &cache));
+    return PipelineCache(cache, handle, *dld);
+}
+
 PipelineLayout Device::CreatePipelineLayout(const VkPipelineLayoutCreateInfo& ci) const {
     VkPipelineLayout object;
     Check(dld->vkCreatePipelineLayout(handle, &ci, nullptr, &object));
     return PipelineLayout(object, handle, *dld);
 }
 
-Pipeline Device::CreateGraphicsPipeline(const VkGraphicsPipelineCreateInfo& ci) const {
+Pipeline Device::CreateGraphicsPipeline(const VkGraphicsPipelineCreateInfo& ci,
+                                        VkPipelineCache cache) const {
     VkPipeline object;
-    Check(dld->vkCreateGraphicsPipelines(handle, nullptr, 1, &ci, nullptr, &object));
+    Check(dld->vkCreateGraphicsPipelines(handle, cache, 1, &ci, nullptr, &object));
     return Pipeline(object, handle, *dld);
 }
 
-Pipeline Device::CreateComputePipeline(const VkComputePipelineCreateInfo& ci) const {
+Pipeline Device::CreateComputePipeline(const VkComputePipelineCreateInfo& ci,
+                                       VkPipelineCache cache) const {
     VkPipeline object;
-    Check(dld->vkCreateComputePipelines(handle, nullptr, 1, &ci, nullptr, &object));
+    Check(dld->vkCreateComputePipelines(handle, cache, 1, &ci, nullptr, &object));
     return Pipeline(object, handle, *dld);
 }
 

src/video_core/vulkan_common/vulkan_wrapper.h

@@ -270,6 +270,7 @@ struct DeviceDispatch : InstanceDispatch {
     PFN_vkCreateGraphicsPipelines vkCreateGraphicsPipelines{};
     PFN_vkCreateImage vkCreateImage{};
     PFN_vkCreateImageView vkCreateImageView{};
+    PFN_vkCreatePipelineCache vkCreatePipelineCache{};
     PFN_vkCreatePipelineLayout vkCreatePipelineLayout{};
     PFN_vkCreateQueryPool vkCreateQueryPool{};
     PFN_vkCreateRenderPass vkCreateRenderPass{};
@@ -289,6 +290,7 @@ struct DeviceDispatch : InstanceDispatch {
     PFN_vkDestroyImage vkDestroyImage{};
     PFN_vkDestroyImageView vkDestroyImageView{};
     PFN_vkDestroyPipeline vkDestroyPipeline{};
+    PFN_vkDestroyPipelineCache vkDestroyPipelineCache{};
     PFN_vkDestroyPipelineLayout vkDestroyPipelineLayout{};
     PFN_vkDestroyQueryPool vkDestroyQueryPool{};
     PFN_vkDestroyRenderPass vkDestroyRenderPass{};
@@ -306,6 +308,7 @@ struct DeviceDispatch : InstanceDispatch {
     PFN_vkGetEventStatus vkGetEventStatus{};
     PFN_vkGetFenceStatus vkGetFenceStatus{};
     PFN_vkGetImageMemoryRequirements vkGetImageMemoryRequirements{};
+    PFN_vkGetPipelineCacheData vkGetPipelineCacheData{};
     PFN_vkGetMemoryFdKHR vkGetMemoryFdKHR{};
 #ifdef _WIN32
     PFN_vkGetMemoryWin32HandleKHR vkGetMemoryWin32HandleKHR{};
@@ -351,6 +354,7 @@ void Destroy(VkDevice, VkFramebuffer, const DeviceDispatch&) noexcept;
 void Destroy(VkDevice, VkImage, const DeviceDispatch&) noexcept;
 void Destroy(VkDevice, VkImageView, const DeviceDispatch&) noexcept;
 void Destroy(VkDevice, VkPipeline, const DeviceDispatch&) noexcept;
+void Destroy(VkDevice, VkPipelineCache, const DeviceDispatch&) noexcept;
 void Destroy(VkDevice, VkPipelineLayout, const DeviceDispatch&) noexcept;
 void Destroy(VkDevice, VkQueryPool, const DeviceDispatch&) noexcept;
 void Destroy(VkDevice, VkRenderPass, const DeviceDispatch&) noexcept;
@@ -773,6 +777,18 @@ public:
     void SetObjectNameEXT(const char* name) const;
 };
 
+class PipelineCache : public Handle<VkPipelineCache, VkDevice, DeviceDispatch> {
+    using Handle<VkPipelineCache, VkDevice, DeviceDispatch>::Handle;
+
+public:
+    /// Set object name.
+    void SetObjectNameEXT(const char* name) const;
+
+    VkResult Read(size_t* size, void* data) const noexcept {
+        return dld->vkGetPipelineCacheData(owner, handle, size, data);
+    }
+};
+
 class Semaphore : public Handle<VkSemaphore, VkDevice, DeviceDispatch> {
     using Handle<VkSemaphore, VkDevice, DeviceDispatch>::Handle;
 
@@ -844,11 +860,15 @@ public:
 
     DescriptorSetLayout CreateDescriptorSetLayout(const VkDescriptorSetLayoutCreateInfo& ci) const;
 
+    PipelineCache CreatePipelineCache(const VkPipelineCacheCreateInfo& ci) const;
+
     PipelineLayout CreatePipelineLayout(const VkPipelineLayoutCreateInfo& ci) const;
 
-    Pipeline CreateGraphicsPipeline(const VkGraphicsPipelineCreateInfo& ci) const;
+    Pipeline CreateGraphicsPipeline(const VkGraphicsPipelineCreateInfo& ci,
+                                    VkPipelineCache cache = nullptr) const;
 
-    Pipeline CreateComputePipeline(const VkComputePipelineCreateInfo& ci) const;
+    Pipeline CreateComputePipeline(const VkComputePipelineCreateInfo& ci,
+                                   VkPipelineCache cache = nullptr) const;
 
     Sampler CreateSampler(const VkSamplerCreateInfo& ci) const;
 

src/yuzu/configuration/config.cpp

@@ -709,6 +709,7 @@ void Config::ReadRendererValues() {
     ReadGlobalSetting(Settings::values.use_asynchronous_shaders);
     ReadGlobalSetting(Settings::values.use_fast_gpu_time);
     ReadGlobalSetting(Settings::values.use_pessimistic_flushes);
+    ReadGlobalSetting(Settings::values.use_vulkan_driver_pipeline_cache);
     ReadGlobalSetting(Settings::values.bg_red);
     ReadGlobalSetting(Settings::values.bg_green);
     ReadGlobalSetting(Settings::values.bg_blue);
@@ -1348,6 +1349,7 @@ void Config::SaveRendererValues() {
     WriteGlobalSetting(Settings::values.use_asynchronous_shaders);
     WriteGlobalSetting(Settings::values.use_fast_gpu_time);
     WriteGlobalSetting(Settings::values.use_pessimistic_flushes);
+    WriteGlobalSetting(Settings::values.use_vulkan_driver_pipeline_cache);
     WriteGlobalSetting(Settings::values.bg_red);
     WriteGlobalSetting(Settings::values.bg_green);
     WriteGlobalSetting(Settings::values.bg_blue);

src/yuzu/configuration/configure_graphics_advanced.cpp

@@ -29,6 +29,8 @@ void ConfigureGraphicsAdvanced::SetConfiguration() {
     ui->use_asynchronous_shaders->setChecked(Settings::values.use_asynchronous_shaders.GetValue());
     ui->use_fast_gpu_time->setChecked(Settings::values.use_fast_gpu_time.GetValue());
     ui->use_pessimistic_flushes->setChecked(Settings::values.use_pessimistic_flushes.GetValue());
+    ui->use_vulkan_driver_pipeline_cache->setChecked(
+        Settings::values.use_vulkan_driver_pipeline_cache.GetValue());
 
     if (Settings::IsConfiguringGlobal()) {
         ui->gpu_accuracy->setCurrentIndex(
@@ -58,6 +60,9 @@ void ConfigureGraphicsAdvanced::ApplyConfiguration() {
                                              ui->use_fast_gpu_time, use_fast_gpu_time);
     ConfigurationShared::ApplyPerGameSetting(&Settings::values.use_pessimistic_flushes,
                                              ui->use_pessimistic_flushes, use_pessimistic_flushes);
+    ConfigurationShared::ApplyPerGameSetting(&Settings::values.use_vulkan_driver_pipeline_cache,
+                                             ui->use_vulkan_driver_pipeline_cache,
+                                             use_vulkan_driver_pipeline_cache);
 }
 
 void ConfigureGraphicsAdvanced::changeEvent(QEvent* event) {
@@ -82,6 +87,8 @@ void ConfigureGraphicsAdvanced::SetupPerGameUI() {
         ui->use_fast_gpu_time->setEnabled(Settings::values.use_fast_gpu_time.UsingGlobal());
         ui->use_pessimistic_flushes->setEnabled(
             Settings::values.use_pessimistic_flushes.UsingGlobal());
+        ui->use_vulkan_driver_pipeline_cache->setEnabled(
+            Settings::values.use_vulkan_driver_pipeline_cache.UsingGlobal());
         ui->anisotropic_filtering_combobox->setEnabled(
             Settings::values.max_anisotropy.UsingGlobal());
 
@@ -97,6 +104,9 @@ void ConfigureGraphicsAdvanced::SetupPerGameUI() {
     ConfigurationShared::SetColoredTristate(ui->use_pessimistic_flushes,
                                             Settings::values.use_pessimistic_flushes,
                                             use_pessimistic_flushes);
+    ConfigurationShared::SetColoredTristate(ui->use_vulkan_driver_pipeline_cache,
+                                            Settings::values.use_vulkan_driver_pipeline_cache,
+                                            use_vulkan_driver_pipeline_cache);
     ConfigurationShared::SetColoredComboBox(
         ui->gpu_accuracy, ui->label_gpu_accuracy,
         static_cast<int>(Settings::values.gpu_accuracy.GetValue(true)));

src/yuzu/configuration/configure_graphics_advanced.h

@@ -40,6 +40,7 @@ private:
     ConfigurationShared::CheckState use_asynchronous_shaders;
     ConfigurationShared::CheckState use_fast_gpu_time;
     ConfigurationShared::CheckState use_pessimistic_flushes;
+    ConfigurationShared::CheckState use_vulkan_driver_pipeline_cache;
 
     const Core::System& system;
 };

src/yuzu/configuration/configure_graphics_advanced.ui

@@ -109,6 +109,16 @@
           </property>
          </widget>
         </item>
+        <item>
+         <widget class="QCheckBox" name="use_vulkan_driver_pipeline_cache">
+          <property name="toolTip">
+            <string>Enables GPU vendor-specific pipeline cache. This option can improve shader loading time significantly in cases where the Vulkan driver does not store pipeline cache files internally.</string>
+          </property>
+          <property name="text">
+           <string>Use Vulkan pipeline cache</string>
+          </property>
+         </widget>
+        </item>
         <item>
          <widget class="QWidget" name="af_layout" native="true">
           <layout class="QHBoxLayout" name="horizontalLayout_1">

src/yuzu/main.cpp

@@ -2229,8 +2229,10 @@ void GMainWindow::OnGameListRemoveFile(u64 program_id, GameListRemoveTarget targ
     }
 
     switch (target) {
-    case GameListRemoveTarget::GlShaderCache:
     case GameListRemoveTarget::VkShaderCache:
+        RemoveVulkanDriverPipelineCache(program_id);
+        [[fallthrough]];
+    case GameListRemoveTarget::GlShaderCache:
         RemoveTransferableShaderCache(program_id, target);
         break;
     case GameListRemoveTarget::AllShaderCache:
@@ -2271,6 +2273,22 @@ void GMainWindow::RemoveTransferableShaderCache(u64 program_id, GameListRemoveTa
     }
 }
 
+void GMainWindow::RemoveVulkanDriverPipelineCache(u64 program_id) {
+    static constexpr std::string_view target_file_name = "vulkan_pipelines.bin";
+
+    const auto shader_cache_dir = Common::FS::GetYuzuPath(Common::FS::YuzuPath::ShaderDir);
+    const auto shader_cache_folder_path = shader_cache_dir / fmt::format("{:016x}", program_id);
+    const auto target_file = shader_cache_folder_path / target_file_name;
+
+    if (!Common::FS::Exists(target_file)) {
+        return;
+    }
+    if (!Common::FS::RemoveFile(target_file)) {
+        QMessageBox::warning(this, tr("Error Removing Vulkan Driver Pipeline Cache"),
+                             tr("Failed to remove the driver pipeline cache."));
+    }
+}
+
 void GMainWindow::RemoveAllTransferableShaderCaches(u64 program_id) {
     const auto shader_cache_dir = Common::FS::GetYuzuPath(Common::FS::YuzuPath::ShaderDir);
     const auto program_shader_cache_dir = shader_cache_dir / fmt::format("{:016x}", program_id);

src/yuzu/main.h

@@ -347,6 +347,7 @@ private:
     void RemoveUpdateContent(u64 program_id, InstalledEntryType type);
     void RemoveAddOnContent(u64 program_id, InstalledEntryType type);
     void RemoveTransferableShaderCache(u64 program_id, GameListRemoveTarget target);
+    void RemoveVulkanDriverPipelineCache(u64 program_id);
     void RemoveAllTransferableShaderCaches(u64 program_id);
     void RemoveCustomConfiguration(u64 program_id, const std::string& game_path);
     std::optional<u64> SelectRomFSDumpTarget(const FileSys::ContentProvider&, u64 program_id);

src/yuzu_cmd/config.cpp

@@ -321,6 +321,7 @@ void Config::ReadValues() {
     ReadSetting("Renderer", Settings::values.accelerate_astc);
     ReadSetting("Renderer", Settings::values.use_fast_gpu_time);
     ReadSetting("Renderer", Settings::values.use_pessimistic_flushes);
+    ReadSetting("Renderer", Settings::values.use_vulkan_driver_pipeline_cache);
 
     ReadSetting("Renderer", Settings::values.bg_red);
     ReadSetting("Renderer", Settings::values.bg_green);