video_core: add samples check when find render target

.gitmodules

@@ -52,6 +52,3 @@
 [submodule "libadrenotools"]
 	path = externals/libadrenotools
 	url = https://github.com/bylaws/libadrenotools
-[submodule "tzdb_to_nx"]
-	path = externals/nx_tzdb/tzdb_to_nx
-	url = https://github.com/lat9nq/tzdb_to_nx.git

CMakeLists.txt

@@ -59,8 +59,6 @@ option(YUZU_CHECK_SUBMODULES "Check if submodules are present" ON)
 
 option(YUZU_ENABLE_LTO "Enable link-time optimization" OFF)
 
-option(YUZU_DOWNLOAD_TIME_ZONE_DATA "Always download time zone binaries" OFF)
-
 CMAKE_DEPENDENT_OPTION(YUZU_USE_FASTER_LD "Check if a faster linker is available" ON "NOT WIN32" OFF)
 
 # On Android, fetch and compile libcxx before doing anything else

externals/nx_tzdb/CMakeLists.txt

@@ -1,60 +1,24 @@
 # SPDX-FileCopyrightText: 2023 yuzu Emulator Project
 # SPDX-License-Identifier: GPL-2.0-or-later
 
+set(NX_TZDB_VERSION "220816")
+set(NX_TZDB_DOWNLOAD_URL "https://github.com/lat9nq/tzdb_to_nx/releases/download/${NX_TZDB_VERSION}/${NX_TZDB_VERSION}.zip")
+
+set(NX_TZDB_ARCHIVE "${CMAKE_CURRENT_BINARY_DIR}/${NX_TZDB_VERSION}.zip")
+set(NX_TZDB_DIR "${CMAKE_CURRENT_BINARY_DIR}/nx_tzdb")
+
 set(NX_TZDB_INCLUDE_DIR "${CMAKE_CURRENT_BINARY_DIR}/include")
 
-add_library(nx_tzdb INTERFACE)
-
-find_program(GIT git)
-find_program(GNU_MAKE make)
-find_program(DATE_PROG date)
-
-set(CAN_BUILD_NX_TZDB true)
-
-if (NOT GIT)
-    set(CAN_BUILD_NX_TZDB false)
-endif()
-if (NOT GNU_MAKE)
-    set(CAN_BUILD_NX_TZDB false)
-endif()
-if (NOT DATE_PROG)
-    set(CAN_BUILD_NX_TZDB false)
-endif()
-if (CMAKE_SYSTEM_NAME STREQUAL "Windows" OR ANDROID)
-    # tzdb_to_nx currently requires a posix-compliant host
-    # MinGW and Android are handled here due to the executable format being different from the host system
-    # TODO (lat9nq): cross-compiling support
-    set(CAN_BUILD_NX_TZDB false)
-endif()
-
-set(NX_TZDB_VERSION "220816")
-set(NX_TZDB_ARCHIVE "${CMAKE_CURRENT_BINARY_DIR}/${NX_TZDB_VERSION}.zip")
-
-set(NX_TZDB_ROMFS_DIR "${CMAKE_CURRENT_BINARY_DIR}/nx_tzdb")
-
-if ((NOT CAN_BUILD_NX_TZDB OR YUZU_DOWNLOAD_TIME_ZONE_DATA) AND NOT EXISTS ${NX_TZDB_ARCHIVE})
-    set(NX_TZDB_DOWNLOAD_URL "https://github.com/lat9nq/tzdb_to_nx/releases/download/${NX_TZDB_VERSION}/${NX_TZDB_VERSION}.zip")
-
-    message(STATUS "Downloading time zone data from ${NX_TZDB_DOWNLOAD_URL}...")
-    file(DOWNLOAD ${NX_TZDB_DOWNLOAD_URL} ${NX_TZDB_ARCHIVE}
-        STATUS NX_TZDB_DOWNLOAD_STATUS)
-    list(GET NX_TZDB_DOWNLOAD_STATUS 0 NX_TZDB_DOWNLOAD_STATUS_CODE)
-    if (NOT NX_TZDB_DOWNLOAD_STATUS_CODE EQUAL 0)
-        message(FATAL_ERROR "Time zone data download failed (status code ${NX_TZDB_DOWNLOAD_STATUS_CODE})")
-    endif()
-
+if (NOT EXISTS ${NX_TZDB_ARCHIVE})
+    file(DOWNLOAD ${NX_TZDB_DOWNLOAD_URL} ${NX_TZDB_ARCHIVE})
     file(ARCHIVE_EXTRACT
         INPUT
             ${NX_TZDB_ARCHIVE}
         DESTINATION
-            ${NX_TZDB_ROMFS_DIR})
-elseif (CAN_BUILD_NX_TZDB AND NOT YUZU_DOWNLOAD_TIME_ZONE_DATA)
-    add_subdirectory(tzdb_to_nx)
-    add_dependencies(nx_tzdb x80e)
-
-    set(NX_TZDB_ROMFS_DIR "${NX_TZDB_DIR}")
+            ${NX_TZDB_DIR})
 endif()
 
+add_library(nx_tzdb INTERFACE)
 target_include_directories(nx_tzdb
     INTERFACE ${CMAKE_CURRENT_SOURCE_DIR}/include
     INTERFACE ${NX_TZDB_INCLUDE_DIR})
@@ -77,25 +41,25 @@ function(CreateHeader ZONE_PATH HEADER_NAME)
     target_sources(nx_tzdb PRIVATE ${HEADER_PATH})
 endfunction()
 
-CreateHeader(${NX_TZDB_ROMFS_DIR} base)
-CreateHeader(${NX_TZDB_ROMFS_DIR}/zoneinfo zoneinfo)
-CreateHeader(${NX_TZDB_ROMFS_DIR}/zoneinfo/Africa africa)
-CreateHeader(${NX_TZDB_ROMFS_DIR}/zoneinfo/America america)
-CreateHeader(${NX_TZDB_ROMFS_DIR}/zoneinfo/America/Argentina america_argentina)
-CreateHeader(${NX_TZDB_ROMFS_DIR}/zoneinfo/America/Indiana america_indiana)
-CreateHeader(${NX_TZDB_ROMFS_DIR}/zoneinfo/America/Kentucky america_kentucky)
-CreateHeader(${NX_TZDB_ROMFS_DIR}/zoneinfo/America/North_Dakota america_north_dakota)
-CreateHeader(${NX_TZDB_ROMFS_DIR}/zoneinfo/Antarctica antarctica)
-CreateHeader(${NX_TZDB_ROMFS_DIR}/zoneinfo/Arctic arctic)
-CreateHeader(${NX_TZDB_ROMFS_DIR}/zoneinfo/Asia asia)
-CreateHeader(${NX_TZDB_ROMFS_DIR}/zoneinfo/Atlantic atlantic)
-CreateHeader(${NX_TZDB_ROMFS_DIR}/zoneinfo/Australia australia)
-CreateHeader(${NX_TZDB_ROMFS_DIR}/zoneinfo/Brazil brazil)
-CreateHeader(${NX_TZDB_ROMFS_DIR}/zoneinfo/Canada canada)
-CreateHeader(${NX_TZDB_ROMFS_DIR}/zoneinfo/Chile chile)
-CreateHeader(${NX_TZDB_ROMFS_DIR}/zoneinfo/Etc etc)
-CreateHeader(${NX_TZDB_ROMFS_DIR}/zoneinfo/Europe europe)
-CreateHeader(${NX_TZDB_ROMFS_DIR}/zoneinfo/Indian indian)
-CreateHeader(${NX_TZDB_ROMFS_DIR}/zoneinfo/Mexico mexico)
-CreateHeader(${NX_TZDB_ROMFS_DIR}/zoneinfo/Pacific pacific)
-CreateHeader(${NX_TZDB_ROMFS_DIR}/zoneinfo/US us)
+CreateHeader(${NX_TZDB_DIR} base)
+CreateHeader(${NX_TZDB_DIR}/zoneinfo zoneinfo)
+CreateHeader(${NX_TZDB_DIR}/zoneinfo/Africa africa)
+CreateHeader(${NX_TZDB_DIR}/zoneinfo/America america)
+CreateHeader(${NX_TZDB_DIR}/zoneinfo/America/Argentina america_argentina)
+CreateHeader(${NX_TZDB_DIR}/zoneinfo/America/Indiana america_indiana)
+CreateHeader(${NX_TZDB_DIR}/zoneinfo/America/Kentucky america_kentucky)
+CreateHeader(${NX_TZDB_DIR}/zoneinfo/America/North_Dakota america_north_dakota)
+CreateHeader(${NX_TZDB_DIR}/zoneinfo/Antartica antartica)
+CreateHeader(${NX_TZDB_DIR}/zoneinfo/Arctic arctic)
+CreateHeader(${NX_TZDB_DIR}/zoneinfo/Asia asia)
+CreateHeader(${NX_TZDB_DIR}/zoneinfo/Atlantic atlantic)
+CreateHeader(${NX_TZDB_DIR}/zoneinfo/Australia australia)
+CreateHeader(${NX_TZDB_DIR}/zoneinfo/Brazil brazil)
+CreateHeader(${NX_TZDB_DIR}/zoneinfo/Canada canada)
+CreateHeader(${NX_TZDB_DIR}/zoneinfo/Chile chile)
+CreateHeader(${NX_TZDB_DIR}/zoneinfo/Etc etc)
+CreateHeader(${NX_TZDB_DIR}/zoneinfo/Europe europe)
+CreateHeader(${NX_TZDB_DIR}/zoneinfo/Indian indian)
+CreateHeader(${NX_TZDB_DIR}/zoneinfo/Mexico mexico)
+CreateHeader(${NX_TZDB_DIR}/zoneinfo/Pacific pacific)
+CreateHeader(${NX_TZDB_DIR}/zoneinfo/US us)

externals/nx_tzdb/NxTzdbCreateHeader.cmake

@@ -15,7 +15,7 @@ set(DIRECTORY_NAME ${HEADER_NAME})
 
 set(FILE_DATA "")
 foreach(ZONE_FILE ${FILE_LIST})
-    if (ZONE_FILE STREQUAL "\n")
+    if ("${ZONE_FILE}" STREQUAL "\n")
         continue()
     endif()
 
@@ -26,13 +26,13 @@ foreach(ZONE_FILE ${FILE_LIST})
     foreach(I RANGE 0 ${ZONE_DATA_LEN} 2)
         math(EXPR BREAK_LINE "(${I} + 2) % 38")
 
-        string(SUBSTRING "${ZONE_DATA}" "${I}" 2 HEX_DATA)
-        if (NOT HEX_DATA)
+        string(SUBSTRING "${ZONE_DATA}" "${I}" "2" HEX_DATA)
+        if ("${HEX_DATA}" STREQUAL "")
             break()
         endif()
 
         string(APPEND FILE_DATA "0x${HEX_DATA},")
-        if (BREAK_LINE EQUAL 0)
+        if ("${BREAK_LINE}" STREQUAL "0")
             string(APPEND FILE_DATA "\n")
         else()
             string(APPEND FILE_DATA " ")

externals/nx_tzdb/include/nx_tzdb.h

@@ -9,7 +9,7 @@
 #include "nx_tzdb/america_indiana.h"
 #include "nx_tzdb/america_kentucky.h"
 #include "nx_tzdb/america_north_dakota.h"
-#include "nx_tzdb/antarctica.h"
+#include "nx_tzdb/antartica.h"
 #include "nx_tzdb/arctic.h"
 #include "nx_tzdb/asia.h"
 #include "nx_tzdb/atlantic.h"

src/core/file_sys/system_archive/time_zone_binary.cpp

@@ -15,7 +15,7 @@ namespace FileSys::SystemArchive {
 const static std::map<std::string, const std::map<const char*, const std::vector<u8>>&>
     tzdb_zoneinfo_dirs = {{"Africa", NxTzdb::africa},
                           {"America", NxTzdb::america},
-                          {"Antarctica", NxTzdb::antarctica},
+                          {"Antartica", NxTzdb::antartica},
                           {"Arctic", NxTzdb::arctic},
                           {"Asia", NxTzdb::asia},
                           {"Atlantic", NxTzdb::atlantic},

src/core/hle/kernel/k_thread.cpp

@@ -4,8 +4,6 @@
 #include <algorithm>
 #include <atomic>
 #include <cinttypes>
-#include <condition_variable>
-#include <mutex>
 #include <optional>
 #include <vector>
 
@@ -1315,8 +1313,7 @@ void KThread::RequestDummyThreadWait() {
     ASSERT(this->IsDummyThread());
 
     // We will block when the scheduler lock is released.
-    std::scoped_lock lock{m_dummy_thread_mutex};
-    m_dummy_thread_runnable = false;
+    m_dummy_thread_runnable.store(false);
 }
 
 void KThread::DummyThreadBeginWait() {
@@ -1326,8 +1323,7 @@ void KThread::DummyThreadBeginWait() {
     }
 
     // Block until runnable is no longer false.
-    std::unique_lock lock{m_dummy_thread_mutex};
-    m_dummy_thread_cv.wait(lock, [this] { return m_dummy_thread_runnable; });
+    m_dummy_thread_runnable.wait(false);
 }
 
 void KThread::DummyThreadEndWait() {
@@ -1335,11 +1331,8 @@ void KThread::DummyThreadEndWait() {
     ASSERT(this->IsDummyThread());
 
     // Wake up the waiting thread.
-    {
-        std::scoped_lock lock{m_dummy_thread_mutex};
-        m_dummy_thread_runnable = true;
-    }
-    m_dummy_thread_cv.notify_one();
+    m_dummy_thread_runnable.store(true);
+    m_dummy_thread_runnable.notify_one();
 }
 
 void KThread::BeginWait(KThreadQueue* queue) {

src/core/hle/kernel/k_thread.h

@@ -892,9 +892,7 @@ private:
     std::shared_ptr<Common::Fiber> m_host_context{};
     ThreadType m_thread_type{};
     StepState m_step_state{};
-    bool m_dummy_thread_runnable{true};
-    std::mutex m_dummy_thread_mutex{};
-    std::condition_variable m_dummy_thread_cv{};
+    std::atomic<bool> m_dummy_thread_runnable{true};
 
     // For debugging
     std::vector<KSynchronizationObject*> m_wait_objects_for_debugging{};

src/core/hle/service/time/time_zone_manager.cpp

@@ -849,9 +849,8 @@ static Result CreateCalendarTime(s64 time, int gmt_offset, CalendarTimeInternal&
 static Result ToCalendarTimeInternal(const TimeZoneRule& rules, s64 time,
                                      CalendarTimeInternal& calendar_time,
                                      CalendarAdditionalInfo& calendar_additional_info) {
-    ASSERT(rules.go_ahead ? rules.time_count > 0 : true);
-    if ((rules.go_back && time < rules.ats[0]) ||
-        (rules.go_ahead && time > rules.ats[rules.time_count - 1])) {
+    if ((rules.go_ahead && time < rules.ats[0]) ||
+        (rules.go_back && time > rules.ats[rules.time_count - 1])) {
         s64 seconds{};
         if (time < rules.ats[0]) {
             seconds = rules.ats[0] - time;

src/core/hle/service/time/time_zone_service.cpp

@@ -112,14 +112,20 @@ void ITimeZoneService::LoadTimeZoneRule(HLERequestContext& ctx) {
     LOG_DEBUG(Service_Time, "called, location_name={}", location_name);
 
     TimeZone::TimeZoneRule time_zone_rule{};
-    const Result result{time_zone_content_manager.LoadTimeZoneRule(time_zone_rule, location_name)};
+    if (const Result result{
+            time_zone_content_manager.LoadTimeZoneRule(time_zone_rule, location_name)};
+        result != ResultSuccess) {
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(result);
+        return;
+    }
 
     std::vector<u8> time_zone_rule_outbuffer(sizeof(TimeZone::TimeZoneRule));
     std::memcpy(time_zone_rule_outbuffer.data(), &time_zone_rule, sizeof(TimeZone::TimeZoneRule));
     ctx.WriteBuffer(time_zone_rule_outbuffer);
 
     IPC::ResponseBuilder rb{ctx, 2};
-    rb.Push(result);
+    rb.Push(ResultSuccess);
 }
 
 void ITimeZoneService::ToCalendarTime(HLERequestContext& ctx) {

src/video_core/buffer_cache/buffer_cache.h

@@ -719,15 +719,9 @@ void BufferCache<P>::BindHostVertexBuffers() {
     bool any_valid{false};
     auto& flags = maxwell3d->dirty.flags;
     for (u32 index = 0; index < NUM_VERTEX_BUFFERS; ++index) {
-        const Binding& binding = channel_state->vertex_buffers[index];
-        Buffer& buffer = slot_buffers[binding.buffer_id];
-        TouchBuffer(buffer, binding.buffer_id);
-        SynchronizeBuffer(buffer, binding.cpu_addr, binding.size);
         if (!flags[Dirty::VertexBuffer0 + index]) {
             continue;
         }
-        flags[Dirty::VertexBuffer0 + index] = false;
-
         host_bindings.min_index = std::min(host_bindings.min_index, index);
         host_bindings.max_index = std::max(host_bindings.max_index, index);
         any_valid = true;
@@ -741,6 +735,9 @@ void BufferCache<P>::BindHostVertexBuffers() {
             const Binding& binding = channel_state->vertex_buffers[index];
             Buffer& buffer = slot_buffers[binding.buffer_id];
 
+            TouchBuffer(buffer, binding.buffer_id);
+            SynchronizeBuffer(buffer, binding.cpu_addr, binding.size);
+
             const u32 stride = maxwell3d->regs.vertex_streams[index].stride;
             const u32 offset = buffer.Offset(binding.cpu_addr);
 

src/video_core/engines/draw_manager.cpp

@@ -1,7 +1,6 @@
 // SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
-#include "common/settings.h"
 #include "video_core/dirty_flags.h"
 #include "video_core/engines/draw_manager.h"
 #include "video_core/rasterizer_interface.h"
@@ -196,12 +195,8 @@ void DrawManager::DrawTexture() {
     if (lower_left) {
         draw_texture_state.dst_y0 -= dst_height;
     }
-    draw_texture_state.dst_x1 =
-        draw_texture_state.dst_x0 +
-        static_cast<f32>(Settings::values.resolution_info.ScaleUp(static_cast<u32>(dst_width)));
-    draw_texture_state.dst_y1 =
-        draw_texture_state.dst_y0 +
-        static_cast<f32>(Settings::values.resolution_info.ScaleUp(static_cast<u32>(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 =
@@ -212,6 +207,7 @@ void DrawManager::DrawTexture() {
         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();
 }
 

src/video_core/renderer_opengl/gl_compute_pipeline.cpp

@@ -87,8 +87,7 @@ void ComputePipeline::Configure() {
     texture_cache.SynchronizeComputeDescriptors();
 
     boost::container::static_vector<VideoCommon::ImageViewInOut, MAX_TEXTURES + MAX_IMAGES> views;
-    boost::container::static_vector<VideoCommon::SamplerId, MAX_TEXTURES> samplers;
-    std::array<GLuint, MAX_TEXTURES> gl_samplers;
+    std::array<GLuint, MAX_TEXTURES> samplers;
     std::array<GLuint, MAX_TEXTURES> textures;
     std::array<GLuint, MAX_IMAGES> images;
     GLsizei sampler_binding{};
@@ -132,6 +131,7 @@ void ComputePipeline::Configure() {
         for (u32 index = 0; index < desc.count; ++index) {
             const auto handle{read_handle(desc, index)};
             views.push_back({handle.first});
+            samplers[sampler_binding++] = 0;
         }
     }
     for (const auto& desc : info.image_buffer_descriptors) {
@@ -142,8 +142,8 @@ void ComputePipeline::Configure() {
             const auto handle{read_handle(desc, index)};
             views.push_back({handle.first});
 
-            VideoCommon::SamplerId sampler = texture_cache.GetComputeSamplerId(handle.second);
-            samplers.push_back(sampler);
+            Sampler* const sampler = texture_cache.GetComputeSampler(handle.second);
+            samplers[sampler_binding++] = sampler->Handle();
         }
     }
     for (const auto& desc : info.image_descriptors) {
@@ -186,17 +186,10 @@ void ComputePipeline::Configure() {
 
     const VideoCommon::ImageViewInOut* views_it{views.data() + num_texture_buffers +
                                                 num_image_buffers};
-    const VideoCommon::SamplerId* samplers_it{samplers.data()};
     texture_binding += num_texture_buffers;
     image_binding += num_image_buffers;
 
     u32 texture_scaling_mask{};
-
-    for (const auto& desc : info.texture_buffer_descriptors) {
-        for (u32 index = 0; index < desc.count; ++index) {
-            gl_samplers[sampler_binding++] = 0;
-        }
-    }
     for (const auto& desc : info.texture_descriptors) {
         for (u32 index = 0; index < desc.count; ++index) {
             ImageView& image_view{texture_cache.GetImageView((views_it++)->id)};
@@ -205,12 +198,6 @@ void ComputePipeline::Configure() {
                 texture_scaling_mask |= 1u << texture_binding;
             }
             ++texture_binding;
-
-            const Sampler& sampler{texture_cache.GetSampler(*(samplers_it++))};
-            const bool use_fallback_sampler{sampler.HasAddedAnisotropy() &&
-                                            !image_view.SupportsAnisotropy()};
-            gl_samplers[sampler_binding++] =
-                use_fallback_sampler ? sampler.HandleWithDefaultAnisotropy() : sampler.Handle();
         }
     }
     u32 image_scaling_mask{};
@@ -241,7 +228,7 @@ void ComputePipeline::Configure() {
     if (texture_binding != 0) {
         ASSERT(texture_binding == sampler_binding);
         glBindTextures(0, texture_binding, textures.data());
-        glBindSamplers(0, sampler_binding, gl_samplers.data());
+        glBindSamplers(0, sampler_binding, samplers.data());
     }
     if (image_binding != 0) {
         glBindImageTextures(0, image_binding, images.data());

src/video_core/renderer_opengl/gl_graphics_pipeline.cpp

@@ -275,9 +275,9 @@ GraphicsPipeline::GraphicsPipeline(const Device& device, TextureCache& texture_c
 template <typename Spec>
 void GraphicsPipeline::ConfigureImpl(bool is_indexed) {
     std::array<VideoCommon::ImageViewInOut, MAX_TEXTURES + MAX_IMAGES> views;
-    std::array<VideoCommon::SamplerId, MAX_TEXTURES> samplers;
+    std::array<GLuint, MAX_TEXTURES> samplers;
     size_t views_index{};
-    size_t samplers_index{};
+    GLsizei sampler_binding{};
 
     texture_cache.SynchronizeGraphicsDescriptors();
 
@@ -337,6 +337,7 @@ void GraphicsPipeline::ConfigureImpl(bool is_indexed) {
                 for (u32 index = 0; index < desc.count; ++index) {
                     const auto handle{read_handle(desc, index)};
                     views[views_index++] = {handle.first};
+                    samplers[sampler_binding++] = 0;
                 }
             }
         }
@@ -350,8 +351,8 @@ void GraphicsPipeline::ConfigureImpl(bool is_indexed) {
                 const auto handle{read_handle(desc, index)};
                 views[views_index++] = {handle.first};
 
-                VideoCommon::SamplerId sampler{texture_cache.GetGraphicsSamplerId(handle.second)};
-                samplers[samplers_index++] = sampler;
+                Sampler* const sampler{texture_cache.GetGraphicsSampler(handle.second)};
+                samplers[sampler_binding++] = sampler->Handle();
             }
         }
         if constexpr (Spec::has_images) {
@@ -444,13 +445,10 @@ void GraphicsPipeline::ConfigureImpl(bool is_indexed) {
         program_manager.BindSourcePrograms(source_programs);
     }
     const VideoCommon::ImageViewInOut* views_it{views.data()};
-    const VideoCommon::SamplerId* samplers_it{samplers.data()};
     GLsizei texture_binding = 0;
     GLsizei image_binding = 0;
-    GLsizei sampler_binding{};
     std::array<GLuint, MAX_TEXTURES> textures;
     std::array<GLuint, MAX_IMAGES> images;
-    std::array<GLuint, MAX_TEXTURES> gl_samplers;
     const auto prepare_stage{[&](size_t stage) {
         buffer_cache.runtime.SetImagePointers(&textures[texture_binding], &images[image_binding]);
         buffer_cache.BindHostStageBuffers(stage);
@@ -467,13 +465,6 @@ void GraphicsPipeline::ConfigureImpl(bool is_indexed) {
         u32 stage_image_binding{};
 
         const auto& info{stage_infos[stage]};
-        if constexpr (Spec::has_texture_buffers) {
-            for (const auto& desc : info.texture_buffer_descriptors) {
-                for (u32 index = 0; index < desc.count; ++index) {
-                    gl_samplers[sampler_binding++] = 0;
-                }
-            }
-        }
         for (const auto& desc : info.texture_descriptors) {
             for (u32 index = 0; index < desc.count; ++index) {
                 ImageView& image_view{texture_cache.GetImageView((views_it++)->id)};
@@ -483,12 +474,6 @@ void GraphicsPipeline::ConfigureImpl(bool is_indexed) {
                 }
                 ++texture_binding;
                 ++stage_texture_binding;
-
-                const Sampler& sampler{texture_cache.GetSampler(*(samplers_it++))};
-                const bool use_fallback_sampler{sampler.HasAddedAnisotropy() &&
-                                                !image_view.SupportsAnisotropy()};
-                gl_samplers[sampler_binding++] =
-                    use_fallback_sampler ? sampler.HandleWithDefaultAnisotropy() : sampler.Handle();
             }
         }
         for (const auto& desc : info.image_descriptors) {
@@ -549,7 +534,7 @@ void GraphicsPipeline::ConfigureImpl(bool is_indexed) {
     if (texture_binding != 0) {
         ASSERT(texture_binding == sampler_binding);
         glBindTextures(0, texture_binding, textures.data());
-        glBindSamplers(0, sampler_binding, gl_samplers.data());
+        glBindSamplers(0, sampler_binding, samplers.data());
     }
     if (image_binding != 0) {
         glBindImageTextures(0, image_binding, images.data());

src/video_core/renderer_opengl/gl_texture_cache.cpp

@@ -1268,48 +1268,36 @@ Sampler::Sampler(TextureCacheRuntime& runtime, const TSCEntry& config) {
 
     UNIMPLEMENTED_IF(config.cubemap_anisotropy != 1);
 
-    const f32 max_anisotropy = std::clamp(config.MaxAnisotropy(), 1.0f, 16.0f);
+    sampler.Create();
+    const GLuint handle = sampler.handle;
+    glSamplerParameteri(handle, GL_TEXTURE_WRAP_S, MaxwellToGL::WrapMode(config.wrap_u));
+    glSamplerParameteri(handle, GL_TEXTURE_WRAP_T, MaxwellToGL::WrapMode(config.wrap_v));
+    glSamplerParameteri(handle, GL_TEXTURE_WRAP_R, MaxwellToGL::WrapMode(config.wrap_p));
+    glSamplerParameteri(handle, GL_TEXTURE_COMPARE_MODE, compare_mode);
+    glSamplerParameteri(handle, GL_TEXTURE_COMPARE_FUNC, compare_func);
+    glSamplerParameteri(handle, GL_TEXTURE_MAG_FILTER, mag);
+    glSamplerParameteri(handle, GL_TEXTURE_MIN_FILTER, min);
+    glSamplerParameterf(handle, GL_TEXTURE_LOD_BIAS, config.LodBias());
+    glSamplerParameterf(handle, GL_TEXTURE_MIN_LOD, config.MinLod());
+    glSamplerParameterf(handle, GL_TEXTURE_MAX_LOD, config.MaxLod());
+    glSamplerParameterfv(handle, GL_TEXTURE_BORDER_COLOR, config.BorderColor().data());
 
-    const auto create_sampler = [&](const f32 anisotropy) {
-        OGLSampler new_sampler;
-        new_sampler.Create();
-        const GLuint handle = new_sampler.handle;
-        glSamplerParameteri(handle, GL_TEXTURE_WRAP_S, MaxwellToGL::WrapMode(config.wrap_u));
-        glSamplerParameteri(handle, GL_TEXTURE_WRAP_T, MaxwellToGL::WrapMode(config.wrap_v));
-        glSamplerParameteri(handle, GL_TEXTURE_WRAP_R, MaxwellToGL::WrapMode(config.wrap_p));
-        glSamplerParameteri(handle, GL_TEXTURE_COMPARE_MODE, compare_mode);
-        glSamplerParameteri(handle, GL_TEXTURE_COMPARE_FUNC, compare_func);
-        glSamplerParameteri(handle, GL_TEXTURE_MAG_FILTER, mag);
-        glSamplerParameteri(handle, GL_TEXTURE_MIN_FILTER, min);
-        glSamplerParameterf(handle, GL_TEXTURE_LOD_BIAS, config.LodBias());
-        glSamplerParameterf(handle, GL_TEXTURE_MIN_LOD, config.MinLod());
-        glSamplerParameterf(handle, GL_TEXTURE_MAX_LOD, config.MaxLod());
-        glSamplerParameterfv(handle, GL_TEXTURE_BORDER_COLOR, config.BorderColor().data());
-
-        if (GLAD_GL_ARB_texture_filter_anisotropic || GLAD_GL_EXT_texture_filter_anisotropic) {
-            glSamplerParameterf(handle, GL_TEXTURE_MAX_ANISOTROPY, anisotropy);
-        } else {
-            LOG_WARNING(Render_OpenGL, "GL_ARB_texture_filter_anisotropic is required");
-        }
-        if (GLAD_GL_ARB_texture_filter_minmax || GLAD_GL_EXT_texture_filter_minmax) {
-            glSamplerParameteri(handle, GL_TEXTURE_REDUCTION_MODE_ARB, reduction_filter);
-        } else if (reduction_filter != GL_WEIGHTED_AVERAGE_ARB) {
-            LOG_WARNING(Render_OpenGL, "GL_ARB_texture_filter_minmax is required");
-        }
-        if (GLAD_GL_ARB_seamless_cubemap_per_texture || GLAD_GL_AMD_seamless_cubemap_per_texture) {
-            glSamplerParameteri(handle, GL_TEXTURE_CUBE_MAP_SEAMLESS, seamless);
-        } else if (seamless == GL_FALSE) {
-            // We default to false because it's more common
-            LOG_WARNING(Render_OpenGL, "GL_ARB_seamless_cubemap_per_texture is required");
-        }
-        return new_sampler;
-    };
-
-    sampler = create_sampler(max_anisotropy);
-
-    const f32 max_anisotropy_default = static_cast<f32>(1U << config.max_anisotropy);
-    if (max_anisotropy > max_anisotropy_default) {
-        sampler_default_anisotropy = create_sampler(max_anisotropy_default);
+    if (GLAD_GL_ARB_texture_filter_anisotropic || GLAD_GL_EXT_texture_filter_anisotropic) {
+        const f32 max_anisotropy = std::clamp(config.MaxAnisotropy(), 1.0f, 16.0f);
+        glSamplerParameterf(handle, GL_TEXTURE_MAX_ANISOTROPY, max_anisotropy);
+    } else {
+        LOG_WARNING(Render_OpenGL, "GL_ARB_texture_filter_anisotropic is required");
+    }
+    if (GLAD_GL_ARB_texture_filter_minmax || GLAD_GL_EXT_texture_filter_minmax) {
+        glSamplerParameteri(handle, GL_TEXTURE_REDUCTION_MODE_ARB, reduction_filter);
+    } else if (reduction_filter != GL_WEIGHTED_AVERAGE_ARB) {
+        LOG_WARNING(Render_OpenGL, "GL_ARB_texture_filter_minmax is required");
+    }
+    if (GLAD_GL_ARB_seamless_cubemap_per_texture || GLAD_GL_AMD_seamless_cubemap_per_texture) {
+        glSamplerParameteri(handle, GL_TEXTURE_CUBE_MAP_SEAMLESS, seamless);
+    } else if (seamless == GL_FALSE) {
+        // We default to false because it's more common
+        LOG_WARNING(Render_OpenGL, "GL_ARB_seamless_cubemap_per_texture is required");
     }
 }
 

src/video_core/renderer_opengl/gl_texture_cache.h

@@ -309,21 +309,12 @@ class Sampler {
 public:
     explicit Sampler(TextureCacheRuntime&, const Tegra::Texture::TSCEntry&);
 
-    [[nodiscard]] GLuint Handle() const noexcept {
+    GLuint Handle() const noexcept {
         return sampler.handle;
     }
 
-    [[nodiscard]] GLuint HandleWithDefaultAnisotropy() const noexcept {
-        return sampler_default_anisotropy.handle;
-    }
-
-    [[nodiscard]] bool HasAddedAnisotropy() const noexcept {
-        return static_cast<bool>(sampler_default_anisotropy.handle);
-    }
-
 private:
     OGLSampler sampler;
-    OGLSampler sampler_default_anisotropy;
 };
 
 class Framebuffer {

src/video_core/renderer_vulkan/pipeline_helper.h

@@ -178,7 +178,7 @@ public:
 inline void PushImageDescriptors(TextureCache& texture_cache,
                                  GuestDescriptorQueue& guest_descriptor_queue,
                                  const Shader::Info& info, RescalingPushConstant& rescaling,
-                                 const VideoCommon::SamplerId*& samplers,
+                                 const VkSampler*& samplers,
                                  const VideoCommon::ImageViewInOut*& views) {
     const u32 num_texture_buffers = Shader::NumDescriptors(info.texture_buffer_descriptors);
     const u32 num_image_buffers = Shader::NumDescriptors(info.image_buffer_descriptors);
@@ -187,15 +187,10 @@ inline void PushImageDescriptors(TextureCache& texture_cache,
     for (const auto& desc : info.texture_descriptors) {
         for (u32 index = 0; index < desc.count; ++index) {
             const VideoCommon::ImageViewId image_view_id{(views++)->id};
-            const VideoCommon::SamplerId sampler_id{*(samplers++)};
+            const VkSampler sampler{*(samplers++)};
             ImageView& image_view{texture_cache.GetImageView(image_view_id)};
             const VkImageView vk_image_view{image_view.Handle(desc.type)};
-            const Sampler& sampler{texture_cache.GetSampler(sampler_id)};
-            const bool use_fallback_sampler{sampler.HasAddedAnisotropy() &&
-                                            !image_view.SupportsAnisotropy()};
-            const VkSampler vk_sampler{use_fallback_sampler ? sampler.HandleWithDefaultAnisotropy()
-                                                            : sampler.Handle()};
-            guest_descriptor_queue.AddSampledImage(vk_image_view, vk_sampler);
+            guest_descriptor_queue.AddSampledImage(vk_image_view, sampler);
             rescaling.PushTexture(texture_cache.IsRescaling(image_view));
         }
     }

src/video_core/renderer_vulkan/vk_buffer_cache.cpp

@@ -516,15 +516,15 @@ void BufferCacheRuntime::BindVertexBuffers(VideoCommon::HostBindings<Buffer>& bi
         buffer_handles.push_back(handle);
     }
     if (device.IsExtExtendedDynamicStateSupported()) {
-        scheduler.Record([bindings = std::move(bindings),
-                          buffer_handles = std::move(buffer_handles)](vk::CommandBuffer cmdbuf) {
+        scheduler.Record([bindings = bindings,
+                          buffer_handles = buffer_handles](vk::CommandBuffer cmdbuf) {
             cmdbuf.BindVertexBuffers2EXT(
                 bindings.min_index, bindings.max_index - bindings.min_index, buffer_handles.data(),
                 bindings.offsets.data(), bindings.sizes.data(), bindings.strides.data());
         });
     } else {
-        scheduler.Record([bindings = std::move(bindings),
-                          buffer_handles = std::move(buffer_handles)](vk::CommandBuffer cmdbuf) {
+        scheduler.Record([bindings = bindings,
+                          buffer_handles = buffer_handles](vk::CommandBuffer cmdbuf) {
             cmdbuf.BindVertexBuffers(bindings.min_index, bindings.max_index - bindings.min_index,
                                      buffer_handles.data(), bindings.offsets.data());
         });
@@ -561,12 +561,12 @@ void BufferCacheRuntime::BindTransformFeedbackBuffers(VideoCommon::HostBindings<
     for (u32 index = 0; index < bindings.buffers.size(); ++index) {
         buffer_handles.push_back(bindings.buffers[index]->Handle());
     }
-    scheduler.Record([bindings = std::move(bindings),
-                      buffer_handles = std::move(buffer_handles)](vk::CommandBuffer cmdbuf) {
-        cmdbuf.BindTransformFeedbackBuffersEXT(0, static_cast<u32>(buffer_handles.size()),
-                                               buffer_handles.data(), bindings.offsets.data(),
-                                               bindings.sizes.data());
-    });
+    scheduler.Record(
+        [bindings = bindings, buffer_handles = buffer_handles](vk::CommandBuffer cmdbuf) {
+            cmdbuf.BindTransformFeedbackBuffersEXT(0, static_cast<u32>(buffer_handles.size()),
+                                                   buffer_handles.data(), bindings.offsets.data(),
+                                                   bindings.sizes.data());
+        });
 }
 
 void BufferCacheRuntime::ReserveNullBuffer() {

src/video_core/renderer_vulkan/vk_compute_pipeline.cpp

@@ -115,7 +115,7 @@ void ComputePipeline::Configure(Tegra::Engines::KeplerCompute& kepler_compute,
 
     static constexpr size_t max_elements = 64;
     boost::container::static_vector<VideoCommon::ImageViewInOut, max_elements> views;
-    boost::container::static_vector<VideoCommon::SamplerId, max_elements> samplers;
+    boost::container::static_vector<VkSampler, max_elements> samplers;
 
     const auto& qmd{kepler_compute.launch_description};
     const auto& cbufs{qmd.const_buffer_config};
@@ -160,8 +160,8 @@ void ComputePipeline::Configure(Tegra::Engines::KeplerCompute& kepler_compute,
             const auto handle{read_handle(desc, index)};
             views.push_back({handle.first});
 
-            VideoCommon::SamplerId sampler = texture_cache.GetComputeSamplerId(handle.second);
-            samplers.push_back(sampler);
+            Sampler* const sampler = texture_cache.GetComputeSampler(handle.second);
+            samplers.push_back(sampler->Handle());
         }
     }
     for (const auto& desc : info.image_descriptors) {
@@ -192,7 +192,7 @@ void ComputePipeline::Configure(Tegra::Engines::KeplerCompute& kepler_compute,
     buffer_cache.BindHostComputeBuffers();
 
     RescalingPushConstant rescaling;
-    const VideoCommon::SamplerId* samplers_it{samplers.data()};
+    const VkSampler* samplers_it{samplers.data()};
     const VideoCommon::ImageViewInOut* views_it{views.data()};
     PushImageDescriptors(texture_cache, guest_descriptor_queue, info, rescaling, samplers_it,
                          views_it);

src/video_core/renderer_vulkan/vk_graphics_pipeline.cpp

@@ -298,7 +298,7 @@ void GraphicsPipeline::AddTransition(GraphicsPipeline* transition) {
 template <typename Spec>
 void GraphicsPipeline::ConfigureImpl(bool is_indexed) {
     std::array<VideoCommon::ImageViewInOut, MAX_IMAGE_ELEMENTS> views;
-    std::array<VideoCommon::SamplerId, MAX_IMAGE_ELEMENTS> samplers;
+    std::array<VkSampler, MAX_IMAGE_ELEMENTS> samplers;
     size_t sampler_index{};
     size_t view_index{};
 
@@ -367,8 +367,8 @@ void GraphicsPipeline::ConfigureImpl(bool is_indexed) {
                 const auto handle{read_handle(desc, index)};
                 views[view_index++] = {handle.first};
 
-                VideoCommon::SamplerId sampler{texture_cache.GetGraphicsSamplerId(handle.second)};
-                samplers[sampler_index++] = sampler;
+                Sampler* const sampler{texture_cache.GetGraphicsSampler(handle.second)};
+                samplers[sampler_index++] = sampler->Handle();
             }
         }
         if constexpr (Spec::has_images) {
@@ -453,7 +453,7 @@ void GraphicsPipeline::ConfigureImpl(bool is_indexed) {
 
     RescalingPushConstant rescaling;
     RenderAreaPushConstant render_area;
-    const VideoCommon::SamplerId* samplers_it{samplers.data()};
+    const VkSampler* samplers_it{samplers.data()};
     const VideoCommon::ImageViewInOut* views_it{views.data()};
     const auto prepare_stage{[&](size_t stage) LAMBDA_FORCEINLINE {
         buffer_cache.BindHostStageBuffers(stage);

src/video_core/renderer_vulkan/vk_master_semaphore.cpp

@@ -3,7 +3,6 @@
 
 #include <thread>
 
-#include "common/polyfill_ranges.h"
 #include "common/settings.h"
 #include "video_core/renderer_vulkan/vk_master_semaphore.h"
 #include "video_core/vulkan_common/vulkan_device.h"

src/video_core/renderer_vulkan/vk_texture_cache.cpp

@@ -1802,36 +1802,27 @@ Sampler::Sampler(TextureCacheRuntime& runtime, const Tegra::Texture::TSCEntry& t
     // Some games have samplers with garbage. Sanitize them here.
     const f32 max_anisotropy = std::clamp(tsc.MaxAnisotropy(), 1.0f, 16.0f);
 
-    const auto create_sampler = [&](const f32 anisotropy) {
-        return device.GetLogical().CreateSampler(VkSamplerCreateInfo{
-            .sType = VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO,
-            .pNext = pnext,
-            .flags = 0,
-            .magFilter = MaxwellToVK::Sampler::Filter(tsc.mag_filter),
-            .minFilter = MaxwellToVK::Sampler::Filter(tsc.min_filter),
-            .mipmapMode = MaxwellToVK::Sampler::MipmapMode(tsc.mipmap_filter),
-            .addressModeU = MaxwellToVK::Sampler::WrapMode(device, tsc.wrap_u, tsc.mag_filter),
-            .addressModeV = MaxwellToVK::Sampler::WrapMode(device, tsc.wrap_v, tsc.mag_filter),
-            .addressModeW = MaxwellToVK::Sampler::WrapMode(device, tsc.wrap_p, tsc.mag_filter),
-            .mipLodBias = tsc.LodBias(),
-            .anisotropyEnable = static_cast<VkBool32>(anisotropy > 1.0f ? VK_TRUE : VK_FALSE),
-            .maxAnisotropy = anisotropy,
-            .compareEnable = tsc.depth_compare_enabled,
-            .compareOp = MaxwellToVK::Sampler::DepthCompareFunction(tsc.depth_compare_func),
-            .minLod = tsc.mipmap_filter == TextureMipmapFilter::None ? 0.0f : tsc.MinLod(),
-            .maxLod = tsc.mipmap_filter == TextureMipmapFilter::None ? 0.25f : tsc.MaxLod(),
-            .borderColor =
-                arbitrary_borders ? VK_BORDER_COLOR_FLOAT_CUSTOM_EXT : ConvertBorderColor(color),
-            .unnormalizedCoordinates = VK_FALSE,
-        });
-    };
-
-    sampler = create_sampler(max_anisotropy);
-
-    const f32 max_anisotropy_default = static_cast<f32>(1U << tsc.max_anisotropy);
-    if (max_anisotropy > max_anisotropy_default) {
-        sampler_default_anisotropy = create_sampler(max_anisotropy_default);
-    }
+    sampler = device.GetLogical().CreateSampler(VkSamplerCreateInfo{
+        .sType = VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO,
+        .pNext = pnext,
+        .flags = 0,
+        .magFilter = MaxwellToVK::Sampler::Filter(tsc.mag_filter),
+        .minFilter = MaxwellToVK::Sampler::Filter(tsc.min_filter),
+        .mipmapMode = MaxwellToVK::Sampler::MipmapMode(tsc.mipmap_filter),
+        .addressModeU = MaxwellToVK::Sampler::WrapMode(device, tsc.wrap_u, tsc.mag_filter),
+        .addressModeV = MaxwellToVK::Sampler::WrapMode(device, tsc.wrap_v, tsc.mag_filter),
+        .addressModeW = MaxwellToVK::Sampler::WrapMode(device, tsc.wrap_p, tsc.mag_filter),
+        .mipLodBias = tsc.LodBias(),
+        .anisotropyEnable = static_cast<VkBool32>(max_anisotropy > 1.0f ? VK_TRUE : VK_FALSE),
+        .maxAnisotropy = max_anisotropy,
+        .compareEnable = tsc.depth_compare_enabled,
+        .compareOp = MaxwellToVK::Sampler::DepthCompareFunction(tsc.depth_compare_func),
+        .minLod = tsc.mipmap_filter == TextureMipmapFilter::None ? 0.0f : tsc.MinLod(),
+        .maxLod = tsc.mipmap_filter == TextureMipmapFilter::None ? 0.25f : tsc.MaxLod(),
+        .borderColor =
+            arbitrary_borders ? VK_BORDER_COLOR_FLOAT_CUSTOM_EXT : ConvertBorderColor(color),
+        .unnormalizedCoordinates = VK_FALSE,
+    });
 }
 
 Framebuffer::Framebuffer(TextureCacheRuntime& runtime, std::span<ImageView*, NUM_RT> color_buffers,

src/video_core/renderer_vulkan/vk_texture_cache.h

@@ -279,17 +279,8 @@ public:
         return *sampler;
     }
 
-    [[nodiscard]] VkSampler HandleWithDefaultAnisotropy() const noexcept {
-        return *sampler_default_anisotropy;
-    }
-
-    [[nodiscard]] bool HasAddedAnisotropy() const noexcept {
-        return static_cast<bool>(sampler_default_anisotropy);
-    }
-
 private:
     vk::Sampler sampler;
-    vk::Sampler sampler_default_anisotropy;
 };
 
 class Framebuffer {

src/video_core/texture_cache/image_view_base.cpp

@@ -45,56 +45,4 @@ ImageViewBase::ImageViewBase(const ImageInfo& info, const ImageViewInfo& view_in
 
 ImageViewBase::ImageViewBase(const NullImageViewParams&) : image_id{NULL_IMAGE_ID} {}
 
-bool ImageViewBase::SupportsAnisotropy() const noexcept {
-    const bool has_mips = range.extent.levels > 1;
-    const bool is_2d = type == ImageViewType::e2D || type == ImageViewType::e2DArray;
-    if (!has_mips || !is_2d) {
-        return false;
-    }
-
-    switch (format) {
-    case PixelFormat::R8_UNORM:
-    case PixelFormat::R8_SNORM:
-    case PixelFormat::R8_SINT:
-    case PixelFormat::R8_UINT:
-    case PixelFormat::BC4_UNORM:
-    case PixelFormat::BC4_SNORM:
-    case PixelFormat::BC5_UNORM:
-    case PixelFormat::BC5_SNORM:
-    case PixelFormat::R32G32_FLOAT:
-    case PixelFormat::R32G32_SINT:
-    case PixelFormat::R32_FLOAT:
-    case PixelFormat::R16_FLOAT:
-    case PixelFormat::R16_UNORM:
-    case PixelFormat::R16_SNORM:
-    case PixelFormat::R16_UINT:
-    case PixelFormat::R16_SINT:
-    case PixelFormat::R16G16_UNORM:
-    case PixelFormat::R16G16_FLOAT:
-    case PixelFormat::R16G16_UINT:
-    case PixelFormat::R16G16_SINT:
-    case PixelFormat::R16G16_SNORM:
-    case PixelFormat::R8G8_UNORM:
-    case PixelFormat::R8G8_SNORM:
-    case PixelFormat::R8G8_SINT:
-    case PixelFormat::R8G8_UINT:
-    case PixelFormat::R32G32_UINT:
-    case PixelFormat::R32_UINT:
-    case PixelFormat::R32_SINT:
-    case PixelFormat::G4R4_UNORM:
-    // Depth formats
-    case PixelFormat::D32_FLOAT:
-    case PixelFormat::D16_UNORM:
-    // Stencil formats
-    case PixelFormat::S8_UINT:
-    // DepthStencil formats
-    case PixelFormat::D24_UNORM_S8_UINT:
-    case PixelFormat::S8_UINT_D24_UNORM:
-    case PixelFormat::D32_FLOAT_S8_UINT:
-        return false;
-    default:
-        return true;
-    }
-}
-
 } // namespace VideoCommon

src/video_core/texture_cache/image_view_base.h

@@ -33,8 +33,6 @@ struct ImageViewBase {
         return type == ImageViewType::Buffer;
     }
 
-    [[nodiscard]] bool SupportsAnisotropy() const noexcept;
-
     ImageId image_id{};
     GPUVAddr gpu_addr = 0;
     PixelFormat format{};

src/video_core/texture_cache/texture_cache.h

@@ -222,50 +222,30 @@ void TextureCache<P>::CheckFeedbackLoop(std::span<const ImageViewInOut> views) {
 
 template <class P>
 typename P::Sampler* TextureCache<P>::GetGraphicsSampler(u32 index) {
-    return &slot_samplers[GetGraphicsSamplerId(index)];
-}
-
-template <class P>
-typename P::Sampler* TextureCache<P>::GetComputeSampler(u32 index) {
-    return &slot_samplers[GetComputeSamplerId(index)];
-}
-
-template <class P>
-SamplerId TextureCache<P>::GetGraphicsSamplerId(u32 index) {
     if (index > channel_state->graphics_sampler_table.Limit()) {
         LOG_DEBUG(HW_GPU, "Invalid sampler index={}", index);
-        return NULL_SAMPLER_ID;
+        return &slot_samplers[NULL_SAMPLER_ID];
     }
     const auto [descriptor, is_new] = channel_state->graphics_sampler_table.Read(index);
     SamplerId& id = channel_state->graphics_sampler_ids[index];
     if (is_new) {
         id = FindSampler(descriptor);
     }
-    return id;
+    return &slot_samplers[id];
 }
 
 template <class P>
-SamplerId TextureCache<P>::GetComputeSamplerId(u32 index) {
+typename P::Sampler* TextureCache<P>::GetComputeSampler(u32 index) {
     if (index > channel_state->compute_sampler_table.Limit()) {
         LOG_DEBUG(HW_GPU, "Invalid sampler index={}", index);
-        return NULL_SAMPLER_ID;
+        return &slot_samplers[NULL_SAMPLER_ID];
     }
     const auto [descriptor, is_new] = channel_state->compute_sampler_table.Read(index);
     SamplerId& id = channel_state->compute_sampler_ids[index];
     if (is_new) {
         id = FindSampler(descriptor);
     }
-    return id;
-}
-
-template <class P>
-const typename P::Sampler& TextureCache<P>::GetSampler(SamplerId id) const noexcept {
-    return slot_samplers[id];
-}
-
-template <class P>
-typename P::Sampler& TextureCache<P>::GetSampler(SamplerId id) noexcept {
-    return slot_samplers[id];
+    return &slot_samplers[id];
 }
 
 template <class P>
@@ -300,7 +280,7 @@ void TextureCache<P>::SynchronizeComputeDescriptors() {
 }
 
 template <class P>
-bool TextureCache<P>::RescaleRenderTargets(bool is_clear) {
+bool TextureCache<P>::RescaleRenderTargets() {
     auto& flags = maxwell3d->dirty.flags;
     u32 scale_rating = 0;
     bool rescaled = false;
@@ -338,13 +318,13 @@ bool TextureCache<P>::RescaleRenderTargets(bool is_clear) {
             ImageViewId& color_buffer_id = render_targets.color_buffer_ids[index];
             if (flags[Dirty::ColorBuffer0 + index] || force) {
                 flags[Dirty::ColorBuffer0 + index] = false;
-                BindRenderTarget(&color_buffer_id, FindColorBuffer(index, is_clear));
+                BindRenderTarget(&color_buffer_id, FindColorBuffer(index));
             }
             check_rescale(color_buffer_id, tmp_color_images[index]);
         }
         if (flags[Dirty::ZetaBuffer] || force) {
             flags[Dirty::ZetaBuffer] = false;
-            BindRenderTarget(&render_targets.depth_buffer_id, FindDepthBuffer(is_clear));
+            BindRenderTarget(&render_targets.depth_buffer_id, FindDepthBuffer());
         }
         check_rescale(render_targets.depth_buffer_id, tmp_depth_image);
 
@@ -409,7 +389,7 @@ void TextureCache<P>::UpdateRenderTargets(bool is_clear) {
         return;
     }
 
-    const bool rescaled = RescaleRenderTargets(is_clear);
+    const bool rescaled = RescaleRenderTargets();
     if (is_rescaling != rescaled) {
         flags[Dirty::RescaleViewports] = true;
         flags[Dirty::RescaleScissors] = true;
@@ -1678,7 +1658,7 @@ SamplerId TextureCache<P>::FindSampler(const TSCEntry& config) {
 }
 
 template <class P>
-ImageViewId TextureCache<P>::FindColorBuffer(size_t index, bool is_clear) {
+ImageViewId TextureCache<P>::FindColorBuffer(size_t index) {
     const auto& regs = maxwell3d->regs;
     if (index >= regs.rt_control.count) {
         return ImageViewId{};
@@ -1692,11 +1672,11 @@ ImageViewId TextureCache<P>::FindColorBuffer(size_t index, bool is_clear) {
         return ImageViewId{};
     }
     const ImageInfo info(regs.rt[index], regs.anti_alias_samples_mode);
-    return FindRenderTargetView(info, gpu_addr, is_clear);
+    return FindRenderTargetView(info, gpu_addr);
 }
 
 template <class P>
-ImageViewId TextureCache<P>::FindDepthBuffer(bool is_clear) {
+ImageViewId TextureCache<P>::FindDepthBuffer() {
     const auto& regs = maxwell3d->regs;
     if (!regs.zeta_enable) {
         return ImageViewId{};
@@ -1706,18 +1686,16 @@ ImageViewId TextureCache<P>::FindDepthBuffer(bool is_clear) {
         return ImageViewId{};
     }
     const ImageInfo info(regs.zeta, regs.zeta_size, regs.anti_alias_samples_mode);
-    return FindRenderTargetView(info, gpu_addr, is_clear);
+    return FindRenderTargetView(info, gpu_addr);
 }
 
 template <class P>
-ImageViewId TextureCache<P>::FindRenderTargetView(const ImageInfo& info, GPUVAddr gpu_addr,
-                                                  bool is_clear) {
-    const auto options = is_clear ? RelaxedOptions::Samples : RelaxedOptions{};
+ImageViewId TextureCache<P>::FindRenderTargetView(const ImageInfo& info, GPUVAddr gpu_addr) {
     ImageId image_id{};
     bool delete_state = has_deleted_images;
     do {
         has_deleted_images = false;
-        image_id = FindOrInsertImage(info, gpu_addr, options);
+        image_id = FindOrInsertImage(info, gpu_addr);
         delete_state |= has_deleted_images;
     } while (has_deleted_images);
     has_deleted_images = delete_state;

src/video_core/texture_cache/texture_cache_base.h

@@ -159,18 +159,6 @@ public:
     /// Get the sampler from the compute descriptor table in the specified index
     Sampler* GetComputeSampler(u32 index);
 
-    /// Get the sampler id from the graphics descriptor table in the specified index
-    SamplerId GetGraphicsSamplerId(u32 index);
-
-    /// Get the sampler id from the compute descriptor table in the specified index
-    SamplerId GetComputeSamplerId(u32 index);
-
-    /// Return a constant reference to the given sampler id
-    [[nodiscard]] const Sampler& GetSampler(SamplerId id) const noexcept;
-
-    /// Return a reference to the given sampler id
-    [[nodiscard]] Sampler& GetSampler(SamplerId id) noexcept;
-
     /// Refresh the state for graphics image view and sampler descriptors
     void SynchronizeGraphicsDescriptors();
 
@@ -178,9 +166,8 @@ public:
     void SynchronizeComputeDescriptors();
 
     /// Updates the Render Targets if they can be rescaled
-    /// @param is_clear True when the render targets are being used for clears
     /// @retval True if the Render Targets have been rescaled.
-    bool RescaleRenderTargets(bool is_clear);
+    bool RescaleRenderTargets();
 
     /// Update bound render targets and upload memory if necessary
     /// @param is_clear True when the render targets are being used for clears
@@ -336,14 +323,13 @@ private:
     [[nodiscard]] SamplerId FindSampler(const TSCEntry& config);
 
     /// Find or create an image view for the given color buffer index
-    [[nodiscard]] ImageViewId FindColorBuffer(size_t index, bool is_clear);
+    [[nodiscard]] ImageViewId FindColorBuffer(size_t index);
 
     /// Find or create an image view for the depth buffer
-    [[nodiscard]] ImageViewId FindDepthBuffer(bool is_clear);
+    [[nodiscard]] ImageViewId FindDepthBuffer();
 
     /// Find or create a view for a render target with the given image parameters
-    [[nodiscard]] ImageViewId FindRenderTargetView(const ImageInfo& info, GPUVAddr gpu_addr,
-                                                   bool is_clear);
+    [[nodiscard]] ImageViewId FindRenderTargetView(const ImageInfo& info, GPUVAddr gpu_addr);
 
     /// Iterates over all the images in a region calling func
     template <typename Func>

src/video_core/textures/texture.cpp

@@ -62,12 +62,7 @@ std::array<float, 4> TSCEntry::BorderColor() const noexcept {
 }
 
 float TSCEntry::MaxAnisotropy() const noexcept {
-    const bool is_suitable_mipmap_filter = mipmap_filter != TextureMipmapFilter::None;
-    const bool has_regular_lods = min_lod_clamp == 0 && max_lod_clamp >= 256;
-    const bool is_bilinear_filter = min_filter == TextureFilter::Linear &&
-                                    reduction_filter == SamplerReduction::WeightedAverage;
-    if (max_anisotropy == 0 && (!is_suitable_mipmap_filter || !has_regular_lods ||
-                                !is_bilinear_filter || depth_compare_enabled)) {
+    if (max_anisotropy == 0 && mipmap_filter != TextureMipmapFilter::Linear) {
         return 1.0f;
     }
     const auto anisotropic_settings = Settings::values.max_anisotropy.GetValue();

src/video_core/vulkan_common/vulkan_device.cpp

@@ -783,6 +783,9 @@ bool Device::GetSuitability(bool requires_swapchain) {
 
     FOR_EACH_VK_FEATURE_EXT(FEATURE_EXTENSION);
     FOR_EACH_VK_EXTENSION(EXTENSION);
+#ifdef _WIN32
+    FOR_EACH_VK_EXTENSION_WIN32(EXTENSION);
+#endif
 
 #undef FEATURE_EXTENSION
 #undef EXTENSION
@@ -801,6 +804,11 @@ bool Device::GetSuitability(bool requires_swapchain) {
 
     FOR_EACH_VK_RECOMMENDED_EXTENSION(LOG_EXTENSION);
     FOR_EACH_VK_MANDATORY_EXTENSION(CHECK_EXTENSION);
+#ifdef _WIN32
+    FOR_EACH_VK_MANDATORY_EXTENSION_WIN32(CHECK_EXTENSION);
+#else
+    FOR_EACH_VK_MANDATORY_EXTENSION_GENERIC(CHECK_EXTENSION);
+#endif
 
     if (requires_swapchain) {
         CHECK_EXTENSION(VK_KHR_SWAPCHAIN_EXTENSION_NAME);

src/video_core/vulkan_common/vulkan_device.h

@@ -68,6 +68,7 @@
     EXTENSION(EXT, VERTEX_ATTRIBUTE_DIVISOR, vertex_attribute_divisor)                             \
     EXTENSION(KHR, DRAW_INDIRECT_COUNT, draw_indirect_count)                                       \
     EXTENSION(KHR, DRIVER_PROPERTIES, driver_properties)                                           \
+    EXTENSION(KHR, EXTERNAL_MEMORY_FD, external_memory_fd)                                         \
     EXTENSION(KHR, PUSH_DESCRIPTOR, push_descriptor)                                               \
     EXTENSION(KHR, SAMPLER_MIRROR_CLAMP_TO_EDGE, sampler_mirror_clamp_to_edge)                     \
     EXTENSION(KHR, SHADER_FLOAT_CONTROLS, shader_float_controls)                                   \
@@ -79,6 +80,9 @@
     EXTENSION(NV, VIEWPORT_ARRAY2, viewport_array2)                                                \
     EXTENSION(NV, VIEWPORT_SWIZZLE, viewport_swizzle)
 
+#define FOR_EACH_VK_EXTENSION_WIN32(EXTENSION)                                                     \
+    EXTENSION(KHR, EXTERNAL_MEMORY_WIN32, external_memory_win32)
+
 // Define extensions which must be supported.
 #define FOR_EACH_VK_MANDATORY_EXTENSION(EXTENSION_NAME)                                            \
     EXTENSION_NAME(VK_EXT_VERTEX_ATTRIBUTE_DIVISOR_EXTENSION_NAME)                                 \
@@ -86,6 +90,12 @@
     EXTENSION_NAME(VK_KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE_EXTENSION_NAME)                             \
     EXTENSION_NAME(VK_KHR_SHADER_FLOAT_CONTROLS_EXTENSION_NAME)
 
+#define FOR_EACH_VK_MANDATORY_EXTENSION_GENERIC(EXTENSION_NAME)                                    \
+    EXTENSION_NAME(VK_KHR_EXTERNAL_MEMORY_FD_EXTENSION_NAME)
+
+#define FOR_EACH_VK_MANDATORY_EXTENSION_WIN32(EXTENSION_NAME)                                      \
+    EXTENSION_NAME(VK_KHR_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME)
+
 // Define extensions where the absence of the extension may result in a degraded experience.
 #define FOR_EACH_VK_RECOMMENDED_EXTENSION(EXTENSION_NAME)                                          \
     EXTENSION_NAME(VK_EXT_CONSERVATIVE_RASTERIZATION_EXTENSION_NAME)                               \
@@ -626,6 +636,7 @@ private:
         FOR_EACH_VK_FEATURE_1_3(FEATURE);
         FOR_EACH_VK_FEATURE_EXT(FEATURE);
         FOR_EACH_VK_EXTENSION(EXTENSION);
+        FOR_EACH_VK_EXTENSION_WIN32(EXTENSION);
 
 #undef EXTENSION
 #undef FEATURE

src/yuzu/CMakeLists.txt

@@ -210,8 +210,6 @@ add_executable(yuzu
     util/url_request_interceptor.h
     util/util.cpp
     util/util.h
-    vk_device_info.cpp
-    vk_device_info.h
     compatdb.cpp
     compatdb.h
     yuzu.qrc

src/yuzu/configuration/configure_dialog.cpp

@@ -6,7 +6,6 @@
 #include "common/settings.h"
 #include "core/core.h"
 #include "ui_configure.h"
-#include "vk_device_info.h"
 #include "yuzu/configuration/config.h"
 #include "yuzu/configuration/configure_audio.h"
 #include "yuzu/configuration/configure_cpu.h"
@@ -29,7 +28,6 @@
 
 ConfigureDialog::ConfigureDialog(QWidget* parent, HotkeyRegistry& registry_,
                                  InputCommon::InputSubsystem* input_subsystem,
-                                 std::vector<VkDeviceInfo::Record>& vk_device_records,
                                  Core::System& system_, bool enable_web_config)
     : QDialog(parent), ui{std::make_unique<Ui::ConfigureDialog>()},
       registry(registry_), system{system_}, audio_tab{std::make_unique<ConfigureAudio>(system_,
@@ -40,8 +38,7 @@ ConfigureDialog::ConfigureDialog(QWidget* parent, HotkeyRegistry& registry_,
       general_tab{std::make_unique<ConfigureGeneral>(system_, this)},
       graphics_advanced_tab{std::make_unique<ConfigureGraphicsAdvanced>(system_, this)},
       graphics_tab{std::make_unique<ConfigureGraphics>(
-          system_, vk_device_records, [&]() { graphics_advanced_tab->ExposeComputeOption(); },
-          this)},
+          system_, [&]() { graphics_advanced_tab->ExposeComputeOption(); }, this)},
       hotkeys_tab{std::make_unique<ConfigureHotkeys>(system_.HIDCore(), this)},
       input_tab{std::make_unique<ConfigureInput>(system_, this)},
       network_tab{std::make_unique<ConfigureNetwork>(system_, this)},

src/yuzu/configuration/configure_dialog.h

@@ -4,9 +4,7 @@
 #pragma once
 
 #include <memory>
-#include <vector>
 #include <QDialog>
-#include "yuzu/vk_device_info.h"
 
 namespace Core {
 class System;
@@ -42,9 +40,8 @@ class ConfigureDialog : public QDialog {
 
 public:
     explicit ConfigureDialog(QWidget* parent, HotkeyRegistry& registry_,
-                             InputCommon::InputSubsystem* input_subsystem,
-                             std::vector<VkDeviceInfo::Record>& vk_device_records,
-                             Core::System& system_, bool enable_web_config = true);
+                             InputCommon::InputSubsystem* input_subsystem, Core::System& system_,
+                             bool enable_web_config = true);
     ~ConfigureDialog() override;
 
     void ApplyConfiguration();

src/yuzu/configuration/configure_graphics.cpp

@@ -1,6 +1,10 @@
 // SPDX-FileCopyrightText: 2016 Citra Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
+// Include this early to include Vulkan headers how we want to
+#include "video_core/vulkan_common/vulkan_device.h"
+#include "video_core/vulkan_common/vulkan_wrapper.h"
+
 #include <algorithm>
 #include <functional>
 #include <iosfwd>
@@ -30,11 +34,13 @@
 #include "common/settings.h"
 #include "core/core.h"
 #include "ui_configure_graphics.h"
+#include "video_core/vulkan_common/vulkan_instance.h"
+#include "video_core/vulkan_common/vulkan_library.h"
+#include "video_core/vulkan_common/vulkan_surface.h"
 #include "yuzu/configuration/configuration_shared.h"
 #include "yuzu/configuration/configure_graphics.h"
 #include "yuzu/qt_common.h"
 #include "yuzu/uisettings.h"
-#include "yuzu/vk_device_info.h"
 
 static const std::vector<VkPresentModeKHR> default_present_modes{VK_PRESENT_MODE_IMMEDIATE_KHR,
                                                                  VK_PRESENT_MODE_FIFO_KHR};
@@ -71,10 +77,9 @@ static constexpr Settings::VSyncMode PresentModeToSetting(VkPresentModeKHR mode)
 }
 
 ConfigureGraphics::ConfigureGraphics(const Core::System& system_,
-                                     std::vector<VkDeviceInfo::Record>& records_,
                                      const std::function<void()>& expose_compute_option_,
                                      QWidget* parent)
-    : QWidget(parent), ui{std::make_unique<Ui::ConfigureGraphics>()}, records{records_},
+    : QWidget(parent), ui{std::make_unique<Ui::ConfigureGraphics>()},
       expose_compute_option{expose_compute_option_}, system{system_} {
     vulkan_device = Settings::values.vulkan_device.GetValue();
     RetrieveVulkanDevices();
@@ -499,19 +504,47 @@ void ConfigureGraphics::UpdateAPILayout() {
     }
 }
 
-void ConfigureGraphics::RetrieveVulkanDevices() {
-    vulkan_devices.clear();
-    vulkan_devices.reserve(records.size());
-    device_present_modes.clear();
-    device_present_modes.reserve(records.size());
-    for (const auto& record : records) {
-        vulkan_devices.push_back(QString::fromStdString(record.name));
-        device_present_modes.push_back(record.vsync_support);
+void ConfigureGraphics::RetrieveVulkanDevices() try {
+    if (UISettings::values.has_broken_vulkan) {
+        return;
+    }
 
-        if (record.is_intel_proprietary) {
+    using namespace Vulkan;
+
+    auto* window = this->window()->windowHandle();
+    auto wsi = QtCommon::GetWindowSystemInfo(window);
+
+    vk::InstanceDispatch dld;
+    const auto library = OpenLibrary();
+    const vk::Instance instance = CreateInstance(*library, dld, VK_API_VERSION_1_1, wsi.type);
+    const std::vector<VkPhysicalDevice> physical_devices = instance.EnumeratePhysicalDevices();
+    vk::SurfaceKHR surface = CreateSurface(instance, wsi);
+
+    vulkan_devices.clear();
+    vulkan_devices.reserve(physical_devices.size());
+    device_present_modes.clear();
+    device_present_modes.reserve(physical_devices.size());
+    for (const VkPhysicalDevice device : physical_devices) {
+        const auto physical_device = vk::PhysicalDevice(device, dld);
+        const std::string name = physical_device.GetProperties().deviceName;
+        const std::vector<VkPresentModeKHR> present_modes =
+            physical_device.GetSurfacePresentModesKHR(*surface);
+        vulkan_devices.push_back(QString::fromStdString(name));
+        device_present_modes.push_back(present_modes);
+
+        VkPhysicalDeviceDriverProperties driver_properties{};
+        driver_properties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES;
+        driver_properties.pNext = nullptr;
+        VkPhysicalDeviceProperties2 properties{};
+        properties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR;
+        properties.pNext = &driver_properties;
+        dld.vkGetPhysicalDeviceProperties2(physical_device, &properties);
+        if (driver_properties.driverID == VK_DRIVER_ID_INTEL_PROPRIETARY_WINDOWS) {
             expose_compute_option();
         }
     }
+} catch (const Vulkan::vk::Exception& exception) {
+    LOG_ERROR(Frontend, "Failed to enumerate devices with error: {}", exception.what());
 }
 
 Settings::RendererBackend ConfigureGraphics::GetCurrentGraphicsBackend() const {

src/yuzu/configuration/configure_graphics.h

@@ -12,7 +12,6 @@
 #include <qobjectdefs.h>
 #include <vulkan/vulkan_core.h>
 #include "common/common_types.h"
-#include "vk_device_info.h"
 
 class QEvent;
 class QObject;
@@ -40,7 +39,6 @@ class ConfigureGraphics : public QWidget {
 
 public:
     explicit ConfigureGraphics(const Core::System& system_,
-                               std::vector<VkDeviceInfo::Record>& records,
                                const std::function<void()>& expose_compute_option_,
                                QWidget* parent = nullptr);
     ~ConfigureGraphics() override;
@@ -79,7 +77,6 @@ private:
     ConfigurationShared::CheckState use_disk_shader_cache;
     ConfigurationShared::CheckState use_asynchronous_gpu_emulation;
 
-    std::vector<VkDeviceInfo::Record>& records;
     std::vector<QString> vulkan_devices;
     std::vector<std::vector<VkPresentModeKHR>> device_present_modes;
     std::vector<VkPresentModeKHR>

src/yuzu/configuration/configure_per_game.cpp

@@ -6,7 +6,6 @@
 #include <memory>
 #include <string>
 #include <utility>
-#include <vector>
 
 #include <fmt/format.h>
 
@@ -35,10 +34,8 @@
 #include "yuzu/configuration/configure_system.h"
 #include "yuzu/uisettings.h"
 #include "yuzu/util/util.h"
-#include "yuzu/vk_device_info.h"
 
 ConfigurePerGame::ConfigurePerGame(QWidget* parent, u64 title_id_, const std::string& file_name,
-                                   std::vector<VkDeviceInfo::Record>& vk_device_records,
                                    Core::System& system_)
     : QDialog(parent),
       ui(std::make_unique<Ui::ConfigurePerGame>()), title_id{title_id_}, system{system_} {
@@ -53,7 +50,7 @@ ConfigurePerGame::ConfigurePerGame(QWidget* parent, u64 title_id_, const std::st
     general_tab = std::make_unique<ConfigureGeneral>(system_, this);
     graphics_advanced_tab = std::make_unique<ConfigureGraphicsAdvanced>(system_, this);
     graphics_tab = std::make_unique<ConfigureGraphics>(
-        system_, vk_device_records, [&]() { graphics_advanced_tab->ExposeComputeOption(); }, this);
+        system_, [&]() { graphics_advanced_tab->ExposeComputeOption(); }, this);
     input_tab = std::make_unique<ConfigureInputPerGame>(system_, game_config.get(), this);
     system_tab = std::make_unique<ConfigureSystem>(system_, this);
 

src/yuzu/configuration/configure_per_game.h

@@ -5,13 +5,11 @@
 
 #include <memory>
 #include <string>
-#include <vector>
 
 #include <QDialog>
 #include <QList>
 
 #include "core/file_sys/vfs_types.h"
-#include "vk_device_info.h"
 #include "yuzu/configuration/config.h"
 
 namespace Core {
@@ -47,7 +45,6 @@ class ConfigurePerGame : public QDialog {
 public:
     // Cannot use std::filesystem::path due to https://bugreports.qt.io/browse/QTBUG-73263
     explicit ConfigurePerGame(QWidget* parent, u64 title_id_, const std::string& file_name,
-                              std::vector<VkDeviceInfo::Record>& vk_device_records,
                               Core::System& system_);
     ~ConfigurePerGame() override;
 

src/yuzu/main.cpp

@@ -147,7 +147,6 @@ static FileSys::VirtualFile VfsDirectoryCreateFileWrapper(const FileSys::Virtual
 #include "yuzu/startup_checks.h"
 #include "yuzu/uisettings.h"
 #include "yuzu/util/clickable_label.h"
-#include "yuzu/vk_device_info.h"
 
 #ifdef YUZU_DBGHELP
 #include "yuzu/mini_dump.h"
@@ -441,8 +440,6 @@ GMainWindow::GMainWindow(std::unique_ptr<Config> config_, bool has_broken_vulkan
 
         renderer_status_button->setDisabled(true);
         renderer_status_button->setChecked(false);
-    } else {
-        VkDeviceInfo::PopulateRecords(vk_device_records, this->window()->windowHandle());
     }
 
 #if defined(HAVE_SDL2) && !defined(_WIN32)
@@ -3497,8 +3494,7 @@ void GMainWindow::OnConfigure() {
     const auto old_language_index = Settings::values.language_index.GetValue();
 
     Settings::SetConfiguringGlobal(true);
-    ConfigureDialog configure_dialog(this, hotkey_registry, input_subsystem.get(),
-                                     vk_device_records, *system,
+    ConfigureDialog configure_dialog(this, hotkey_registry, input_subsystem.get(), *system,
                                      !multiplayer_state->IsHostingPublicRoom());
     connect(&configure_dialog, &ConfigureDialog::LanguageChanged, this,
             &GMainWindow::OnLanguageChanged);
@@ -3769,7 +3765,7 @@ void GMainWindow::OpenPerGameConfiguration(u64 title_id, const std::string& file
     const auto v_file = Core::GetGameFileFromPath(vfs, file_name);
 
     Settings::SetConfiguringGlobal(false);
-    ConfigurePerGame dialog(this, title_id, file_name, vk_device_records, *system);
+    ConfigurePerGame dialog(this, title_id, file_name, *system);
     dialog.LoadFromFile(v_file);
     const auto result = dialog.exec();
 

src/yuzu/main.h

@@ -118,10 +118,6 @@ enum class ReinitializeKeyBehavior {
     Warning,
 };
 
-namespace VkDeviceInfo {
-class Record;
-}
-
 class GMainWindow : public QMainWindow {
     Q_OBJECT
 
@@ -422,8 +418,6 @@ private:
 
     GameListPlaceholder* game_list_placeholder;
 
-    std::vector<VkDeviceInfo::Record> vk_device_records;
-
     // Status bar elements
     QLabel* message_label = nullptr;
     QLabel* shader_building_label = nullptr;

src/yuzu/vk_device_info.cpp

@@ -1,58 +0,0 @@
-// SPDX-FileCopyrightText: 2023 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#include <utility>
-#include <vector>
-#include "common/dynamic_library.h"
-#include "common/logging/log.h"
-#include "video_core/vulkan_common/vulkan_instance.h"
-#include "video_core/vulkan_common/vulkan_library.h"
-#include "video_core/vulkan_common/vulkan_surface.h"
-#include "video_core/vulkan_common/vulkan_wrapper.h"
-#include "yuzu/qt_common.h"
-#include "yuzu/vk_device_info.h"
-
-class QWindow;
-
-namespace VkDeviceInfo {
-Record::Record(std::string_view name_, const std::vector<VkPresentModeKHR>& vsync_modes_,
-               bool is_intel_proprietary_)
-    : name{name_}, vsync_support{vsync_modes_}, is_intel_proprietary{is_intel_proprietary_} {}
-
-Record::~Record() = default;
-
-void PopulateRecords(std::vector<Record>& records, QWindow* window) try {
-    using namespace Vulkan;
-
-    auto wsi = QtCommon::GetWindowSystemInfo(window);
-
-    vk::InstanceDispatch dld;
-    const auto library = OpenLibrary();
-    const vk::Instance instance = CreateInstance(*library, dld, VK_API_VERSION_1_1, wsi.type);
-    const std::vector<VkPhysicalDevice> physical_devices = instance.EnumeratePhysicalDevices();
-    vk::SurfaceKHR surface = CreateSurface(instance, wsi);
-
-    records.clear();
-    records.reserve(physical_devices.size());
-    for (const VkPhysicalDevice device : physical_devices) {
-        const auto physical_device = vk::PhysicalDevice(device, dld);
-        const std::string name = physical_device.GetProperties().deviceName;
-        const std::vector<VkPresentModeKHR> present_modes =
-            physical_device.GetSurfacePresentModesKHR(*surface);
-
-        VkPhysicalDeviceDriverProperties driver_properties{};
-        driver_properties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES;
-        driver_properties.pNext = nullptr;
-        VkPhysicalDeviceProperties2 properties{};
-        properties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR;
-        properties.pNext = &driver_properties;
-        dld.vkGetPhysicalDeviceProperties2(physical_device, &properties);
-
-        records.push_back(VkDeviceInfo::Record(name, present_modes,
-                                               driver_properties.driverID ==
-                                                   VK_DRIVER_ID_INTEL_PROPRIETARY_WINDOWS));
-    }
-} catch (const Vulkan::vk::Exception& exception) {
-    LOG_ERROR(Frontend, "Failed to enumerate devices with error: {}", exception.what());
-}
-} // namespace VkDeviceInfo

src/yuzu/vk_device_info.h

@@ -1,36 +0,0 @@
-// SPDX-FileCopyrightText: 2023 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#pragma once
-
-#include <algorithm>
-#include <iterator>
-#include <memory>
-#include <string>
-#include <string_view>
-#include <vector>
-#include "common/common_types.h"
-#include "vulkan/vulkan_core.h"
-
-class QWindow;
-
-namespace Settings {
-enum class VSyncMode : u32;
-}
-// #include "common/settings.h"
-
-namespace VkDeviceInfo {
-// Short class to record Vulkan driver information for configuration purposes
-class Record {
-public:
-    explicit Record(std::string_view name, const std::vector<VkPresentModeKHR>& vsync_modes,
-                    bool is_intel_proprietary);
-    ~Record();
-
-    const std::string name;
-    const std::vector<VkPresentModeKHR> vsync_support;
-    const bool is_intel_proprietary;
-};
-
-void PopulateRecords(std::vector<Record>& records, QWindow* window);
-} // namespace VkDeviceInfo

vcpkg.json

@@ -1,7 +1,7 @@
 {
     "$schema": "https://raw.githubusercontent.com/microsoft/vcpkg-tool/main/docs/vcpkg.schema.json",
     "name": "yuzu",
-    "builtin-baseline": "cbf56573a987527b39272e88cbdd11389b78c6e4",
+    "builtin-baseline": "a487471068f4cb1cbb4eeb340763cdcc0a75fd68",
     "version": "1.0",
     "dependencies": [
         "boost-algorithm",