Temp

Author: raphaelthegreat

Diff for: externals/cryptopp-cmake

@@ -0,0 +1 @@
+Subproject commit 01db7cdd00aabcce559a8dddce8798dabb71949b

Diff for: externals/cubeb

@@ -127,7 +127,7 @@ void RendererVulkan::PrepareRendertarget() {
 
 void RendererVulkan::PrepareDraw(Frame* frame, const Layout::FramebufferLayout& layout) {
     const auto sampler = present_samplers[!Settings::values.filter_mode.GetValue()];
-    const auto present_set = present_heap.Commit();
+    const auto [present_set, _] = present_heap.Commit();
     for (u32 index = 0; index < screen_infos.size(); index++) {
         update_queue.AddImageSampler(present_set, 0, index, screen_infos[index].image_view,
                                      sampler);

Diff for: externals/dynarmic

@@ -284,7 +284,7 @@ bool BlitHelper::BlitDepthStencil(Surface& source, Surface& dest,
         .extent = {dest.GetScaledWidth(), dest.GetScaledHeight()},
     };
 
-    const auto descriptor_set = two_textures_provider.Commit();
+    const auto [descriptor_set, _] = two_textures_provider.Commit();
     update_queue.AddImageSampler(descriptor_set, 0, 0, source.DepthView(), nearest_sampler);
     update_queue.AddImageSampler(descriptor_set, 1, 0, source.StencilView(), nearest_sampler);
 
@@ -309,7 +309,7 @@ bool BlitHelper::BlitDepthStencil(Surface& source, Surface& dest,
 
 bool BlitHelper::ConvertDS24S8ToRGBA8(Surface& source, Surface& dest,
                                       const VideoCore::TextureCopy& copy) {
-    const auto descriptor_set = compute_provider.Commit();
+    const auto [descriptor_set, _] = compute_provider.Commit();
     update_queue.AddImageSampler(descriptor_set, 0, 0, source.DepthView(), VK_NULL_HANDLE,
                                  vk::ImageLayout::eDepthStencilReadOnlyOptimal);
     update_queue.AddImageSampler(descriptor_set, 1, 0, source.StencilView(), VK_NULL_HANDLE,
@@ -420,7 +420,7 @@ bool BlitHelper::ConvertDS24S8ToRGBA8(Surface& source, Surface& dest,
 
 bool BlitHelper::DepthToBuffer(Surface& source, vk::Buffer buffer,
                                const VideoCore::BufferTextureCopy& copy) {
-    const auto descriptor_set = compute_buffer_provider.Commit();
+    const auto [descriptor_set, _] = compute_buffer_provider.Commit();
     update_queue.AddImageSampler(descriptor_set, 0, 0, source.DepthView(), nearest_sampler,
                                  vk::ImageLayout::eDepthStencilReadOnlyOptimal);
     update_queue.AddImageSampler(descriptor_set, 1, 0, source.StencilView(), nearest_sampler,

Diff for: externals/oaknut

@@ -45,11 +45,11 @@ class PipelineCache {
     ~PipelineCache();
 
     /// Acquires and binds a free descriptor set from the appropriate heap.
-    vk::DescriptorSet Acquire(DescriptorHeapType type) {
+    vk::DescriptorSet Acquire(DescriptorHeapType type, std::size_t hash = 0) {
         const u32 index = static_cast<u32>(type);
-        const auto descriptor_set = descriptor_heaps[index].Commit();
+        const auto [descriptor_set, requires_update] = descriptor_heaps[index].Commit(hash);
         bound_descriptor_sets[index] = descriptor_set;
-        return descriptor_set;
+        return requires_update ? descriptor_set : VK_NULL_HANDLE;
     }
 
     /// Sets the dynamic offset for the uniform buffer at binding

Diff for: externals/teakra

@@ -559,20 +559,17 @@ void RasterizerVulkan::SyncTextureUnits(const Framebuffer* framebuffer) {
     using TextureType = Pica::TexturingRegs::TextureConfig::TextureType;
 
     const auto pica_textures = regs.texturing.GetTextures();
-    const bool use_cube_heap =
-        pica_textures[0].enabled && pica_textures[0].config.type == TextureType::ShadowCube;
-    const auto texture_set = pipeline_cache.Acquire(use_cube_heap ? DescriptorHeapType::Texture
-                                                                  : DescriptorHeapType::Texture);
-
     for (u32 texture_index = 0; texture_index < pica_textures.size(); ++texture_index) {
         const auto& texture = pica_textures[texture_index];
 
         // If the texture unit is disabled bind a null surface to it
         if (!texture.enabled) {
             const Surface& null_surface = res_cache.GetSurface(VideoCore::NULL_SURFACE_ID);
             const Sampler& null_sampler = res_cache.GetSampler(VideoCore::NULL_SAMPLER_ID);
-            update_queue.AddImageSampler(texture_set, texture_index, 0, null_surface.ImageView(),
-                                         null_sampler.Handle());
+            images[texture_index] = {
+                .sampler = null_sampler.Handle(),
+                .imageView = null_surface.ImageView(),
+            };
             continue;
         }
 
@@ -583,16 +580,18 @@ void RasterizerVulkan::SyncTextureUnits(const Framebuffer* framebuffer) {
                 Surface& surface = res_cache.GetTextureSurface(texture);
                 Sampler& sampler = res_cache.GetSampler(texture.config);
                 surface.flags |= VideoCore::SurfaceFlagBits::ShadowMap;
-                update_queue.AddImageSampler(texture_set, texture_index, 0, surface.StorageView(),
-                                             sampler.Handle());
+                images[texture_index] = {
+                    .sampler = sampler.Handle(),
+                    .imageView = surface.StorageView(),
+                };
                 continue;
             }
             case TextureType::ShadowCube: {
-                BindShadowCube(texture, texture_set);
+                BindShadowCube(texture);
                 continue;
             }
             case TextureType::TextureCube: {
-                BindTextureCube(texture, texture_set);
+                BindTextureCube(texture);
                 continue;
             }
             default:
@@ -607,7 +606,21 @@ void RasterizerVulkan::SyncTextureUnits(const Framebuffer* framebuffer) {
         const bool is_feedback_loop = color_view == surface.ImageView();
         const vk::ImageView texture_view =
             is_feedback_loop ? surface.CopyImageView() : surface.ImageView();
-        update_queue.AddImageSampler(texture_set, texture_index, 0, texture_view, sampler.Handle());
+        images[texture_index] = {
+            .sampler = sampler.Handle(),
+            .imageView = texture_view,
+        };
+    }
+
+    const std::size_t hash = Common::ComputeStructHash64(images);
+    const auto texture_set = pipeline_cache.Acquire(DescriptorHeapType::Texture, hash);
+    if (!texture_set) {
+        return;
+    }
+
+    for (u32 texture_index = 0; texture_index < pica_textures.size(); texture_index++) {
+        update_queue.AddImageSampler(texture_set, texture_index, 0,
+                                     images[texture_index].imageView, images[texture_index].sampler);
     }
 }
 
@@ -621,16 +634,15 @@ void RasterizerVulkan::SyncUtilityTextures(const Framebuffer* framebuffer) {
     update_queue.AddStorageImage(utility_set, 0, framebuffer->ImageView(SurfaceType::Color));
 }
 
-void RasterizerVulkan::BindShadowCube(const Pica::TexturingRegs::FullTextureConfig& texture,
-                                      vk::DescriptorSet texture_set) {
-    using CubeFace = Pica::TexturingRegs::CubeFace;
-    auto info = Pica::Texture::TextureInfo::FromPicaRegister(texture.config, texture.format);
-    constexpr std::array faces = {
-        CubeFace::PositiveX, CubeFace::NegativeX, CubeFace::PositiveY,
-        CubeFace::NegativeY, CubeFace::PositiveZ, CubeFace::NegativeZ,
-    };
+void RasterizerVulkan::BindShadowCube(const Pica::TexturingRegs::FullTextureConfig& texture) {
+    //using CubeFace = Pica::TexturingRegs::CubeFace;
+    //auto info = Pica::Texture::TextureInfo::FromPicaRegister(texture.config, texture.format);
+    //constexpr std::array faces = {
+    //    CubeFace::PositiveX, CubeFace::NegativeX, CubeFace::PositiveY,
+    //    CubeFace::NegativeY, CubeFace::PositiveZ, CubeFace::NegativeZ,
+    //};
 
-    Sampler& sampler = res_cache.GetSampler(texture.config);
+    /*Sampler& sampler = res_cache.GetSampler(texture.config);
 
     for (CubeFace face : faces) {
         const u32 binding = static_cast<u32>(face);
@@ -639,13 +651,12 @@ void RasterizerVulkan::BindShadowCube(const Pica::TexturingRegs::FullTextureConf
         const VideoCore::SurfaceId surface_id = res_cache.GetTextureSurface(info);
         Surface& surface = res_cache.GetSurface(surface_id);
         surface.flags |= VideoCore::SurfaceFlagBits::ShadowMap;
-        update_queue.AddImageSampler(texture_set, 0, binding, surface.StorageView(),
-                                     sampler.Handle());
-    }
+        //update_queue.AddImageSampler(texture_set, 0, binding, surface.StorageView(),
+        //                             sampler.Handle());
+    }*/
 }
 
-void RasterizerVulkan::BindTextureCube(const Pica::TexturingRegs::FullTextureConfig& texture,
-                                       vk::DescriptorSet texture_set) {
+void RasterizerVulkan::BindTextureCube(const Pica::TexturingRegs::FullTextureConfig& texture) {
     using CubeFace = Pica::TexturingRegs::CubeFace;
     const VideoCore::TextureCubeConfig config = {
         .px = regs.texturing.GetCubePhysicalAddress(CubeFace::PositiveX),
@@ -661,7 +672,10 @@ void RasterizerVulkan::BindTextureCube(const Pica::TexturingRegs::FullTextureCon
 
     Surface& surface = res_cache.GetTextureCube(config);
     Sampler& sampler = res_cache.GetSampler(texture.config);
-    update_queue.AddImageSampler(texture_set, 0, 0, surface.ImageView(), sampler.Handle());
+    images[0] = {
+        .sampler = sampler.Handle(),
+        .imageView = surface.ImageView(),
+    };
 }
 
 void RasterizerVulkan::NotifyFixedFunctionPicaRegisterChanged(u32 id) {

Diff for: externals/teakra_interp

@@ -107,12 +107,10 @@ class RasterizerVulkan : public VideoCore::RasterizerAccelerated {
     void SyncUtilityTextures(const Framebuffer* framebuffer);
 
     /// Binds the PICA shadow cube required for shadow mapping
-    void BindShadowCube(const Pica::TexturingRegs::FullTextureConfig& texture,
-                        vk::DescriptorSet texture_set);
+    void BindShadowCube(const Pica::TexturingRegs::FullTextureConfig& texture);
 
     /// Binds a texture cube to texture unit 0
-    void BindTextureCube(const Pica::TexturingRegs::FullTextureConfig& texture,
-                         vk::DescriptorSet texture_set);
+    void BindTextureCube(const Pica::TexturingRegs::FullTextureConfig& texture);
 
     /// Upload the uniform blocks to the uniform buffer object
     void UploadUniforms(bool accelerate_draw);
@@ -154,6 +152,7 @@ class RasterizerVulkan : public VideoCore::RasterizerAccelerated {
     std::array<u32, 16> binding_offsets{};
     std::array<bool, 16> enable_attributes{};
     std::array<vk::Buffer, 16> vertex_buffers;
+    std::array<vk::DescriptorImageInfo, 3> images{};
     VertexArrayInfo vertex_info;
     PipelineInfo pipeline_info{};
 

Diff for: src/video_core/renderer_vulkan/renderer_vulkan.cpp

@@ -140,6 +140,7 @@ DescriptorHeap::~DescriptorHeap() = default;
 void DescriptorHeap::Allocate(std::size_t begin, std::size_t end) {
     ASSERT(end - begin == DESCRIPTOR_SET_BATCH);
     descriptor_sets.resize(end);
+    hashes.resize(end);
 
     std::array<vk::DescriptorSetLayout, DESCRIPTOR_SET_BATCH> layouts;
     layouts.fill(*descriptor_set_layout);
@@ -170,9 +171,27 @@ void DescriptorHeap::Allocate(std::size_t begin, std::size_t end) {
     }
 }
 
-vk::DescriptorSet DescriptorHeap::Commit() {
+std::pair<vk::DescriptorSet, bool> DescriptorHeap::Commit(std::size_t hash) {
+    if (hash == 0) {
+        const std::size_t index = CommitResource();
+        return {descriptor_sets[index], true};
+    }
+
+    // Try to recycle an existing descriptor set that matches the content hash.
+    const auto it = descriptor_content_map.find(hash);
+    if (it != descriptor_content_map.end()) {
+        ticks[it->second] = master_semaphore->CurrentTick();
+        return {descriptor_sets[it->second], false};
+    }
+
+    // No descriptor set found, provide a fresh one
     const std::size_t index = CommitResource();
-    return descriptor_sets[index];
+    if (hashes[index] != 0) {
+        descriptor_content_map.erase(hashes[index]);
+    }
+    descriptor_content_map[hash] = index;
+    hashes[index] = hash;
+    return {descriptor_sets[index], true};
 }
 
 void DescriptorHeap::AppendDescriptorPool() {

Diff for: src/video_core/renderer_vulkan/vk_blit_helper.cpp

@@ -5,6 +5,8 @@
 #pragma once
 
 #include <vector>
+#include <tsl/robin_map.h>
+
 #include "common/common_types.h"
 #include "video_core/renderer_vulkan/vk_common.h"
 
@@ -74,7 +76,7 @@ class DescriptorHeap final : public ResourcePool {
 
     void Allocate(std::size_t begin, std::size_t end) override;
 
-    vk::DescriptorSet Commit();
+    std::pair<vk::DescriptorSet, bool> Commit(std::size_t hash = 0);
 
 private:
     void AppendDescriptorPool();
@@ -86,6 +88,8 @@ class DescriptorHeap final : public ResourcePool {
     std::vector<vk::DescriptorPoolSize> pool_sizes;
     std::vector<vk::UniqueDescriptorPool> pools;
     std::vector<vk::DescriptorSet> descriptor_sets;
+    std::vector<std::size_t> hashes;
+    tsl::robin_map<std::size_t, std::size_t> descriptor_content_map;
 };
 
 } // namespace Vulkan