Revert "shader_recompiler: Align SSBO offsets to meet host requirements"

This reverts commit 8804a4eb23.

src/common/input.h

@@ -292,6 +292,9 @@ class InputDevice {
 public:
     virtual ~InputDevice() = default;
 
+    // Request input device to update if necessary
+    virtual void SoftUpdate() {}
+
     // Force input device to update data regardless of the current state
     virtual void ForceUpdate() {}
 

src/common/settings.h

@@ -415,7 +415,7 @@ struct Values {
     // Renderer
     SwitchableSetting<RendererBackend, true> renderer_backend{
         RendererBackend::Vulkan, RendererBackend::OpenGL, RendererBackend::Null, "backend"};
-    SwitchableSetting<bool> renderer_force_max_clock{false, "force_max_clock"};
+    SwitchableSetting<bool> renderer_force_max_clock{true, "force_max_clock"};
     Setting<bool> renderer_debug{false, "debug"};
     Setting<bool> renderer_shader_feedback{false, "shader_feedback"};
     Setting<bool> enable_nsight_aftermath{false, "nsight_aftermath"};

src/core/hid/emulated_controller.cpp

@@ -1434,6 +1434,16 @@ AnalogSticks EmulatedController::GetSticks() const {
         return {};
     }
 
+    // Some drivers like stick from buttons need constant refreshing
+    for (auto& device : stick_devices) {
+        if (!device) {
+            continue;
+        }
+        lock.unlock();
+        device->SoftUpdate();
+        lock.lock();
+    }
+
     return controller.analog_stick_state;
 }
 

src/input_common/helpers/stick_from_buttons.cpp

@@ -13,11 +13,11 @@ class Stick final : public Common::Input::InputDevice {
 public:
     using Button = std::unique_ptr<Common::Input::InputDevice>;
 
-    Stick(Button up_, Button down_, Button left_, Button right_, Button modifier_, Button updater_,
+    Stick(Button up_, Button down_, Button left_, Button right_, Button modifier_,
           float modifier_scale_, float modifier_angle_)
         : up(std::move(up_)), down(std::move(down_)), left(std::move(left_)),
-          right(std::move(right_)), modifier(std::move(modifier_)), updater(std::move(updater_)),
-          modifier_scale(modifier_scale_), modifier_angle(modifier_angle_) {
+          right(std::move(right_)), modifier(std::move(modifier_)), modifier_scale(modifier_scale_),
+          modifier_angle(modifier_angle_) {
         up->SetCallback({
             .on_change =
                 [this](const Common::Input::CallbackStatus& callback_) {
@@ -48,9 +48,6 @@ public:
                     UpdateModButtonStatus(callback_);
                 },
         });
-        updater->SetCallback({
-            .on_change = [this](const Common::Input::CallbackStatus& callback_) { SoftUpdate(); },
-        });
         last_x_axis_value = 0.0f;
         last_y_axis_value = 0.0f;
     }
@@ -251,7 +248,7 @@ public:
         modifier->ForceUpdate();
     }
 
-    void SoftUpdate() {
+    void SoftUpdate() override {
         Common::Input::CallbackStatus status{
             .type = Common::Input::InputType::Stick,
             .stick_status = GetStatus(),
@@ -311,7 +308,6 @@ private:
     Button left;
     Button right;
     Button modifier;
-    Button updater;
     float modifier_scale{};
     float modifier_angle{};
     float angle{};
@@ -335,12 +331,11 @@ std::unique_ptr<Common::Input::InputDevice> StickFromButton::Create(
     auto left = Common::Input::CreateInputDeviceFromString(params.Get("left", null_engine));
     auto right = Common::Input::CreateInputDeviceFromString(params.Get("right", null_engine));
     auto modifier = Common::Input::CreateInputDeviceFromString(params.Get("modifier", null_engine));
-    auto updater = Common::Input::CreateInputDeviceFromString("engine:updater,button:0");
     auto modifier_scale = params.Get("modifier_scale", 0.5f);
     auto modifier_angle = params.Get("modifier_angle", 5.5f);
     return std::make_unique<Stick>(std::move(up), std::move(down), std::move(left),
-                                   std::move(right), std::move(modifier), std::move(updater),
-                                   modifier_scale, modifier_angle);
+                                   std::move(right), std::move(modifier), modifier_scale,
+                                   modifier_angle);
 }
 
 } // namespace InputCommon

src/input_common/main.cpp

@@ -28,28 +28,6 @@
 
 namespace InputCommon {
 
-/// Dummy engine to get periodic updates
-class UpdateEngine final : public InputEngine {
-public:
-    explicit UpdateEngine(std::string input_engine_) : InputEngine(std::move(input_engine_)) {
-        PreSetController(identifier);
-    }
-
-    void PumpEvents() {
-        SetButton(identifier, 0, last_state);
-        last_state = !last_state;
-    }
-
-private:
-    static constexpr PadIdentifier identifier = {
-        .guid = Common::UUID{},
-        .port = 0,
-        .pad = 0,
-    };
-
-    bool last_state{};
-};
-
 struct InputSubsystem::Impl {
     template <typename Engine>
     void RegisterEngine(std::string name, std::shared_ptr<Engine>& engine) {
@@ -67,7 +45,6 @@ struct InputSubsystem::Impl {
     void Initialize() {
         mapping_factory = std::make_shared<MappingFactory>();
 
-        RegisterEngine("updater", update_engine);
         RegisterEngine("keyboard", keyboard);
         RegisterEngine("mouse", mouse);
         RegisterEngine("touch", touch_screen);
@@ -97,7 +74,6 @@ struct InputSubsystem::Impl {
     }
 
     void Shutdown() {
-        UnregisterEngine(update_engine);
         UnregisterEngine(keyboard);
         UnregisterEngine(mouse);
         UnregisterEngine(touch_screen);
@@ -276,7 +252,6 @@ struct InputSubsystem::Impl {
     }
 
     void PumpEvents() const {
-        update_engine->PumpEvents();
 #ifdef HAVE_SDL2
         sdl->PumpEvents();
 #endif
@@ -288,7 +263,6 @@ struct InputSubsystem::Impl {
 
     std::shared_ptr<MappingFactory> mapping_factory;
 
-    std::shared_ptr<UpdateEngine> update_engine;
     std::shared_ptr<Keyboard> keyboard;
     std::shared_ptr<Mouse> mouse;
     std::shared_ptr<TouchScreen> touch_screen;

src/shader_recompiler/frontend/maxwell/translate_program.cpp

@@ -259,7 +259,7 @@ IR::Program TranslateProgram(ObjectPool<IR::Inst>& inst_pool, ObjectPool<IR::Blo
         program.is_geometry_passthrough = sph.common0.geometry_passthrough != 0;
         if (program.is_geometry_passthrough) {
             const auto& mask{env.GpPassthroughMask()};
-            for (size_t i = 0; i < mask.size() * 32; ++i) {
+            for (size_t i = 0; i < program.info.passthrough.mask.size(); ++i) {
                 program.info.passthrough.mask[i] = ((mask[i / 32] >> (i % 32)) & 1) == 0;
             }
 
@@ -292,7 +292,7 @@ IR::Program TranslateProgram(ObjectPool<IR::Inst>& inst_pool, ObjectPool<IR::Blo
 
     Optimization::PositionPass(env, program);
 
-    Optimization::GlobalMemoryToStorageBufferPass(program, host_info);
+    Optimization::GlobalMemoryToStorageBufferPass(program);
     Optimization::TexturePass(env, program, host_info);
 
     if (Settings::values.resolution_info.active) {

src/shader_recompiler/host_translate_info.h

@@ -15,7 +15,6 @@ struct HostTranslateInfo {
     bool needs_demote_reorder{}; ///< True when the device needs DemoteToHelperInvocation reordered
     bool support_snorm_render_buffer{};  ///< True when the device supports SNORM render buffers
     bool support_viewport_index_layer{}; ///< True when the device supports gl_Layer in VS
-    u32 min_ssbo_alignment{};            ///< Minimum alignment supported by the device for SSBOs
     bool support_geometry_shader_passthrough{}; ///< True when the device supports geometry
                                                 ///< passthrough shaders
 };

src/shader_recompiler/ir_opt/global_memory_to_storage_buffer_pass.cpp

@@ -11,7 +11,6 @@
 #include "shader_recompiler/frontend/ir/breadth_first_search.h"
 #include "shader_recompiler/frontend/ir/ir_emitter.h"
 #include "shader_recompiler/frontend/ir/value.h"
-#include "shader_recompiler/host_translate_info.h"
 #include "shader_recompiler/ir_opt/passes.h"
 
 namespace Shader::Optimization {
@@ -403,7 +402,7 @@ void CollectStorageBuffers(IR::Block& block, IR::Inst& inst, StorageInfo& info)
 }
 
 /// Returns the offset in indices (not bytes) for an equivalent storage instruction
-IR::U32 StorageOffset(IR::Block& block, IR::Inst& inst, StorageBufferAddr buffer, u32 alignment) {
+IR::U32 StorageOffset(IR::Block& block, IR::Inst& inst, StorageBufferAddr buffer) {
     IR::IREmitter ir{block, IR::Block::InstructionList::s_iterator_to(inst)};
     IR::U32 offset;
     if (const std::optional<LowAddrInfo> low_addr{TrackLowAddress(&inst)}) {
@@ -416,10 +415,7 @@ IR::U32 StorageOffset(IR::Block& block, IR::Inst& inst, StorageBufferAddr buffer
     }
     // Subtract the least significant 32 bits from the guest offset. The result is the storage
     // buffer offset in bytes.
-    IR::U32 low_cbuf{ir.GetCbuf(ir.Imm32(buffer.index), ir.Imm32(buffer.offset))};
-
-    // Align the offset base to match the host alignment requirements
-    low_cbuf = ir.BitwiseAnd(low_cbuf, ir.Imm32(~(alignment - 1U)));
+    const IR::U32 low_cbuf{ir.GetCbuf(ir.Imm32(buffer.index), ir.Imm32(buffer.offset))};
     return ir.ISub(offset, low_cbuf);
 }
 
@@ -514,7 +510,7 @@ void Replace(IR::Block& block, IR::Inst& inst, const IR::U32& storage_index,
 }
 } // Anonymous namespace
 
-void GlobalMemoryToStorageBufferPass(IR::Program& program, const HostTranslateInfo& host_info) {
+void GlobalMemoryToStorageBufferPass(IR::Program& program) {
     StorageInfo info;
     for (IR::Block* const block : program.post_order_blocks) {
         for (IR::Inst& inst : block->Instructions()) {
@@ -538,8 +534,7 @@ void GlobalMemoryToStorageBufferPass(IR::Program& program, const HostTranslateIn
         const IR::U32 index{IR::Value{static_cast<u32>(info.set.index_of(it))}};
         IR::Block* const block{storage_inst.block};
         IR::Inst* const inst{storage_inst.inst};
-        const IR::U32 offset{
-            StorageOffset(*block, *inst, storage_buffer, host_info.min_ssbo_alignment)};
+        const IR::U32 offset{StorageOffset(*block, *inst, storage_buffer)};
         Replace(*block, *inst, index, offset);
     }
 }

src/shader_recompiler/ir_opt/passes.h

@@ -15,7 +15,7 @@ namespace Shader::Optimization {
 void CollectShaderInfoPass(Environment& env, IR::Program& program);
 void ConstantPropagationPass(Environment& env, IR::Program& program);
 void DeadCodeEliminationPass(IR::Program& program);
-void GlobalMemoryToStorageBufferPass(IR::Program& program, const HostTranslateInfo& host_info);
+void GlobalMemoryToStorageBufferPass(IR::Program& program);
 void IdentityRemovalPass(IR::Program& program);
 void LowerFp16ToFp32(IR::Program& program);
 void LowerInt64ToInt32(IR::Program& program);

src/video_core/buffer_cache/buffer_cache.h

@@ -1938,21 +1938,14 @@ typename BufferCache<P>::Binding BufferCache<P>::StorageBufferBinding(GPUVAddr s
                                                                       bool is_written) const {
     const GPUVAddr gpu_addr = gpu_memory->Read<u64>(ssbo_addr);
     const u32 size = gpu_memory->Read<u32>(ssbo_addr + 8);
-    const u32 alignment = runtime.GetStorageBufferAlignment();
-
-    const GPUVAddr aligned_gpu_addr = Common::AlignDown(gpu_addr, alignment);
-    const u32 aligned_size =
-        Common::AlignUp(static_cast<u32>(gpu_addr - aligned_gpu_addr) + size, alignment);
-
-    const std::optional<VAddr> cpu_addr = gpu_memory->GpuToCpuAddress(aligned_gpu_addr);
+    const std::optional<VAddr> cpu_addr = gpu_memory->GpuToCpuAddress(gpu_addr);
     if (!cpu_addr || size == 0) {
         return NULL_BINDING;
     }
-
-    const VAddr cpu_end = Common::AlignUp(*cpu_addr + aligned_size, Core::Memory::YUZU_PAGESIZE);
+    const VAddr cpu_end = Common::AlignUp(*cpu_addr + size, Core::Memory::YUZU_PAGESIZE);
     const Binding binding{
         .cpu_addr = *cpu_addr,
-        .size = is_written ? aligned_size : static_cast<u32>(cpu_end - *cpu_addr),
+        .size = is_written ? size : static_cast<u32>(cpu_end - *cpu_addr),
         .buffer_id = BufferId{},
     };
     return binding;

src/video_core/renderer_opengl/gl_buffer_cache.h

@@ -160,10 +160,6 @@ public:
         return device.CanReportMemoryUsage();
     }
 
-    u32 GetStorageBufferAlignment() const {
-        return static_cast<u32>(device.GetShaderStorageBufferAlignment());
-    }
-
 private:
     static constexpr std::array PABO_LUT{
         GL_VERTEX_PROGRAM_PARAMETER_BUFFER_NV,          GL_TESS_CONTROL_PROGRAM_PARAMETER_BUFFER_NV,

src/video_core/renderer_opengl/gl_rasterizer.cpp

@@ -139,7 +139,6 @@ void RasterizerOpenGL::LoadDiskResources(u64 title_id, std::stop_token stop_load
 void RasterizerOpenGL::Clear(u32 layer_count) {
     MICROPROFILE_SCOPE(OpenGL_Clears);
 
-    gpu_memory->FlushCaching();
     const auto& regs = maxwell3d->regs;
     bool use_color{};
     bool use_depth{};
@@ -208,7 +207,6 @@ void RasterizerOpenGL::PrepareDraw(bool is_indexed, Func&& draw_func) {
     MICROPROFILE_SCOPE(OpenGL_Drawing);
 
     SCOPE_EXIT({ gpu.TickWork(); });
-    gpu_memory->FlushCaching();
     query_cache.UpdateCounters();
 
     GraphicsPipeline* const pipeline{shader_cache.CurrentGraphicsPipeline()};
@@ -321,7 +319,6 @@ void RasterizerOpenGL::DrawIndirect() {
 }
 
 void RasterizerOpenGL::DispatchCompute() {
-    gpu_memory->FlushCaching();
     ComputePipeline* const pipeline{shader_cache.CurrentComputePipeline()};
     if (!pipeline) {
         return;
@@ -529,7 +526,6 @@ void RasterizerOpenGL::TickFrame() {
 }
 
 bool RasterizerOpenGL::AccelerateConditionalRendering() {
-    gpu_memory->FlushCaching();
     if (Settings::IsGPULevelHigh()) {
         // Reimplement Host conditional rendering.
         return false;

src/video_core/renderer_opengl/gl_shader_cache.cpp

@@ -236,7 +236,6 @@ ShaderCache::ShaderCache(RasterizerOpenGL& rasterizer_, Core::Frontend::EmuWindo
           .needs_demote_reorder = device.IsAmd(),
           .support_snorm_render_buffer = false,
           .support_viewport_index_layer = device.HasVertexViewportLayer(),
-          .min_ssbo_alignment = static_cast<u32>(device.GetShaderStorageBufferAlignment()),
           .support_geometry_shader_passthrough = device.HasGeometryShaderPassthrough(),
       } {
     if (use_asynchronous_shaders) {

src/video_core/renderer_vulkan/renderer_vulkan.cpp

@@ -60,9 +60,22 @@ std::string GetDriverVersion(const Device& device) {
     return GetReadableVersion(version);
 }
 
-std::string BuildCommaSeparatedExtensions(
-    const std::set<std::string, std::less<>>& available_extensions) {
-    return fmt::format("{}", fmt::join(available_extensions, ","));
+std::string BuildCommaSeparatedExtensions(std::vector<std::string> available_extensions) {
+    std::sort(std::begin(available_extensions), std::end(available_extensions));
+
+    static constexpr std::size_t AverageExtensionSize = 64;
+    std::string separated_extensions;
+    separated_extensions.reserve(available_extensions.size() * AverageExtensionSize);
+
+    const auto end = std::end(available_extensions);
+    for (auto extension = std::begin(available_extensions); extension != end; ++extension) {
+        if (const bool is_last = extension + 1 == end; is_last) {
+            separated_extensions += *extension;
+        } else {
+            separated_extensions += fmt::format("{},", *extension);
+        }
+    }
+    return separated_extensions;
 }
 
 } // Anonymous namespace
@@ -99,7 +112,6 @@ RendererVulkan::RendererVulkan(Core::TelemetrySession& telemetry_session_,
                  state_tracker, scheduler) {
     if (Settings::values.renderer_force_max_clock.GetValue() && device.ShouldBoostClocks()) {
         turbo_mode.emplace(instance, dld);
-        scheduler.RegisterOnSubmit([this] { turbo_mode->QueueSubmitted(); });
     }
     Report();
 } catch (const vk::Exception& exception) {
@@ -108,7 +120,6 @@ RendererVulkan::RendererVulkan(Core::TelemetrySession& telemetry_session_,
 }
 
 RendererVulkan::~RendererVulkan() {
-    scheduler.RegisterOnSubmit([] {});
     void(device.GetLogical().WaitIdle());
 }
 

src/video_core/renderer_vulkan/vk_buffer_cache.cpp

@@ -330,10 +330,6 @@ bool BufferCacheRuntime::CanReportMemoryUsage() const {
     return device.CanReportMemoryUsage();
 }
 
-u32 BufferCacheRuntime::GetStorageBufferAlignment() const {
-    return static_cast<u32>(device.GetStorageBufferAlignment());
-}
-
 void BufferCacheRuntime::Finish() {
     scheduler.Finish();
 }

src/video_core/renderer_vulkan/vk_buffer_cache.h

@@ -73,8 +73,6 @@ public:
 
     bool CanReportMemoryUsage() const;
 
-    u32 GetStorageBufferAlignment() const;
-
     [[nodiscard]] StagingBufferRef UploadStagingBuffer(size_t size);
 
     [[nodiscard]] StagingBufferRef DownloadStagingBuffer(size_t size);

src/video_core/renderer_vulkan/vk_pipeline_cache.cpp

@@ -344,7 +344,6 @@ PipelineCache::PipelineCache(RasterizerVulkan& rasterizer_, const Device& device
             driver_id == VK_DRIVER_ID_AMD_PROPRIETARY || driver_id == VK_DRIVER_ID_AMD_OPEN_SOURCE,
         .support_snorm_render_buffer = true,
         .support_viewport_index_layer = device.IsExtShaderViewportIndexLayerSupported(),
-        .min_ssbo_alignment = static_cast<u32>(device.GetStorageBufferAlignment()),
         .support_geometry_shader_passthrough = device.IsNvGeometryShaderPassthroughSupported(),
     };
 

src/video_core/renderer_vulkan/vk_rasterizer.cpp

@@ -270,7 +270,6 @@ void RasterizerVulkan::Clear(u32 layer_count) {
     MICROPROFILE_SCOPE(Vulkan_Clearing);
 
     FlushWork();
-    gpu_memory->FlushCaching();
 
     query_cache.UpdateCounters();
 
@@ -629,7 +628,6 @@ void RasterizerVulkan::TickFrame() {
 }
 
 bool RasterizerVulkan::AccelerateConditionalRendering() {
-    gpu_memory->FlushCaching();
     if (Settings::IsGPULevelHigh()) {
         // TODO(Blinkhawk): Reimplement Host conditional rendering.
         return false;

src/video_core/renderer_vulkan/vk_scheduler.cpp

@@ -213,11 +213,6 @@ void Scheduler::SubmitExecution(VkSemaphore signal_semaphore, VkSemaphore wait_s
             .signalSemaphoreCount = num_signal_semaphores,
             .pSignalSemaphores = signal_semaphores.data(),
         };
-
-        if (on_submit) {
-            on_submit();
-        }
-
         switch (const VkResult result = device.GetGraphicsQueue().Submit(submit_info)) {
         case VK_SUCCESS:
             break;

src/video_core/renderer_vulkan/vk_scheduler.h

@@ -5,7 +5,6 @@
 
 #include <condition_variable>
 #include <cstddef>
-#include <functional>
 #include <memory>
 #include <thread>
 #include <utility>
@@ -67,11 +66,6 @@ public:
         query_cache = &query_cache_;
     }
 
-    // Registers a callback to perform on queue submission.
-    void RegisterOnSubmit(std::function<void()>&& func) {
-        on_submit = std::move(func);
-    }
-
     /// Send work to a separate thread.
     template <typename T>
     void Record(T&& command) {
@@ -222,7 +216,6 @@ private:
     vk::CommandBuffer current_cmdbuf;
 
     std::unique_ptr<CommandChunk> chunk;
-    std::function<void()> on_submit;
 
     State state;
 

src/video_core/renderer_vulkan/vk_turbo_mode.cpp

@@ -14,21 +14,11 @@ using namespace Common::Literals;
 
 TurboMode::TurboMode(const vk::Instance& instance, const vk::InstanceDispatch& dld)
     : m_device{CreateDevice(instance, dld, VK_NULL_HANDLE)}, m_allocator{m_device, false} {
-    {
-        std::scoped_lock lk{m_submission_lock};
-        m_submission_time = std::chrono::steady_clock::now();
-    }
     m_thread = std::jthread([&](auto stop_token) { Run(stop_token); });
 }
 
 TurboMode::~TurboMode() = default;
 
-void TurboMode::QueueSubmitted() {
-    std::scoped_lock lk{m_submission_lock};
-    m_submission_time = std::chrono::steady_clock::now();
-    m_submission_cv.notify_one();
-}
-
 void TurboMode::Run(std::stop_token stop_token) {
     auto& dld = m_device.GetLogical();
 
@@ -209,13 +199,6 @@ void TurboMode::Run(std::stop_token stop_token) {
 
         // Wait for completion.
         fence.Wait();
-
-        // Wait for the next graphics queue submission if necessary.
-        std::unique_lock lk{m_submission_lock};
-        Common::CondvarWait(m_submission_cv, lk, stop_token, [this] {
-            return (std::chrono::steady_clock::now() - m_submission_time) <=
-                   std::chrono::milliseconds{100};
-        });
     }
 }
 

src/video_core/renderer_vulkan/vk_turbo_mode.h

@@ -3,9 +3,6 @@
 
 #pragma once
 
-#include <chrono>
-#include <mutex>
-
 #include "common/polyfill_thread.h"
 #include "video_core/vulkan_common/vulkan_device.h"
 #include "video_core/vulkan_common/vulkan_memory_allocator.h"
@@ -18,17 +15,11 @@ public:
     explicit TurboMode(const vk::Instance& instance, const vk::InstanceDispatch& dld);
     ~TurboMode();
 
-    void QueueSubmitted();
-
 private:
     void Run(std::stop_token stop_token);
 
     Device m_device;
     MemoryAllocator m_allocator;
-    std::mutex m_submission_lock;
-    std::condition_variable_any m_submission_cv;
-    std::chrono::time_point<std::chrono::steady_clock> m_submission_time{};
-
     std::jthread m_thread;
 };
 

src/video_core/vulkan_common/vulkan_device.h

@@ -3,7 +3,6 @@
 
 #pragma once
 
-#include <set>
 #include <span>
 #include <string>
 #include <unordered_map>
@@ -12,156 +11,6 @@
 #include "common/common_types.h"
 #include "video_core/vulkan_common/vulkan_wrapper.h"
 
-// Define all features which may be used by the implementation here.
-// Vulkan version in the macro describes the minimum version required for feature availability.
-// If the Vulkan version is lower than the required version, the named extension is required.
-#define FOR_EACH_VK_FEATURE_1_1(FEATURE)                                                           \
-    FEATURE(EXT, SubgroupSizeControl, SUBGROUP_SIZE_CONTROL, subgroup_size_control)                \
-    FEATURE(KHR, 16BitStorage, 16BIT_STORAGE, bit16_storage)                                       \
-    FEATURE(KHR, ShaderAtomicInt64, SHADER_ATOMIC_INT64, shader_atomic_int64)                      \
-    FEATURE(KHR, ShaderDrawParameters, SHADER_DRAW_PARAMETERS, shader_draw_parameters)             \
-    FEATURE(KHR, ShaderFloat16Int8, SHADER_FLOAT16_INT8, shader_float16_int8)                      \
-    FEATURE(KHR, UniformBufferStandardLayout, UNIFORM_BUFFER_STANDARD_LAYOUT,                      \
-            uniform_buffer_standard_layout)                                                        \
-    FEATURE(KHR, VariablePointer, VARIABLE_POINTERS, variable_pointer)
-
-#define FOR_EACH_VK_FEATURE_1_2(FEATURE)                                                           \
-    FEATURE(EXT, HostQueryReset, HOST_QUERY_RESET, host_query_reset)                               \
-    FEATURE(KHR, 8BitStorage, 8BIT_STORAGE, bit8_storage)                                          \
-    FEATURE(KHR, TimelineSemaphore, TIMELINE_SEMAPHORE, timeline_semaphore)
-
-#define FOR_EACH_VK_FEATURE_1_3(FEATURE)                                                           \
-    FEATURE(EXT, ShaderDemoteToHelperInvocation, SHADER_DEMOTE_TO_HELPER_INVOCATION,               \
-            shader_demote_to_helper_invocation)
-
-// Define all features which may be used by the implementation and require an extension here.
-#define FOR_EACH_VK_FEATURE_EXT(FEATURE)                                                           \
-    FEATURE(EXT, CustomBorderColor, CUSTOM_BORDER_COLOR, custom_border_color)                      \
-    FEATURE(EXT, DepthClipControl, DEPTH_CLIP_CONTROL, depth_clip_control)                         \
-    FEATURE(EXT, ExtendedDynamicState, EXTENDED_DYNAMIC_STATE, extended_dynamic_state)             \
-    FEATURE(EXT, ExtendedDynamicState2, EXTENDED_DYNAMIC_STATE_2, extended_dynamic_state2)         \
-    FEATURE(EXT, ExtendedDynamicState3, EXTENDED_DYNAMIC_STATE_3, extended_dynamic_state3)         \
-    FEATURE(EXT, IndexTypeUint8, INDEX_TYPE_UINT8, index_type_uint8)                               \
-    FEATURE(EXT, LineRasterization, LINE_RASTERIZATION, line_rasterization)                        \
-    FEATURE(EXT, PrimitiveTopologyListRestart, PRIMITIVE_TOPOLOGY_LIST_RESTART,                    \
-            primitive_topology_list_restart)                                                       \
-    FEATURE(EXT, ProvokingVertex, PROVOKING_VERTEX, provoking_vertex)                              \
-    FEATURE(EXT, Robustness2, ROBUSTNESS_2, robustness2)                                           \
-    FEATURE(EXT, TransformFeedback, TRANSFORM_FEEDBACK, transform_feedback)                        \
-    FEATURE(EXT, VertexInputDynamicState, VERTEX_INPUT_DYNAMIC_STATE, vertex_input_dynamic_state)  \
-    FEATURE(KHR, PipelineExecutableProperties, PIPELINE_EXECUTABLE_PROPERTIES,                     \
-            pipeline_executable_properties)                                                        \
-    FEATURE(KHR, WorkgroupMemoryExplicitLayout, WORKGROUP_MEMORY_EXPLICIT_LAYOUT,                  \
-            workgroup_memory_explicit_layout)
-
-// Define miscellaneous extensions which may be used by the implementation here.
-#define FOR_EACH_VK_EXTENSION(EXTENSION)                                                           \
-    EXTENSION(EXT, CONSERVATIVE_RASTERIZATION, conservative_rasterization)                         \
-    EXTENSION(EXT, DEPTH_RANGE_UNRESTRICTED, depth_range_unrestricted)                             \
-    EXTENSION(EXT, MEMORY_BUDGET, memory_budget)                                                   \
-    EXTENSION(EXT, ROBUSTNESS_2, robustness_2)                                                     \
-    EXTENSION(EXT, SAMPLER_FILTER_MINMAX, sampler_filter_minmax)                                   \
-    EXTENSION(EXT, SHADER_STENCIL_EXPORT, shader_stencil_export)                                   \
-    EXTENSION(EXT, SHADER_VIEWPORT_INDEX_LAYER, shader_viewport_index_layer)                       \
-    EXTENSION(EXT, TOOLING_INFO, tooling_info)                                                     \
-    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)                                   \
-    EXTENSION(KHR, SPIRV_1_4, spirv_1_4)                                                           \
-    EXTENSION(KHR, SWAPCHAIN, swapchain)                                                           \
-    EXTENSION(KHR, SWAPCHAIN_MUTABLE_FORMAT, swapchain_mutable_format)                             \
-    EXTENSION(NV, DEVICE_DIAGNOSTICS_CONFIG, device_diagnostics_config)                            \
-    EXTENSION(NV, GEOMETRY_SHADER_PASSTHROUGH, geometry_shader_passthrough)                        \
-    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_ROBUSTNESS_2_EXTENSION_NAME)                                             \
-    EXTENSION_NAME(VK_EXT_VERTEX_ATTRIBUTE_DIVISOR_EXTENSION_NAME)                                 \
-    EXTENSION_NAME(VK_KHR_DRIVER_PROPERTIES_EXTENSION_NAME)                                        \
-    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)                               \
-    EXTENSION_NAME(VK_EXT_DEPTH_RANGE_UNRESTRICTED_EXTENSION_NAME)                                 \
-    EXTENSION_NAME(VK_EXT_EXTENDED_DYNAMIC_STATE_EXTENSION_NAME)                                   \
-    EXTENSION_NAME(VK_EXT_EXTENDED_DYNAMIC_STATE_2_EXTENSION_NAME)                                 \
-    EXTENSION_NAME(VK_EXT_EXTENDED_DYNAMIC_STATE_3_EXTENSION_NAME)                                 \
-    EXTENSION_NAME(VK_EXT_LINE_RASTERIZATION_EXTENSION_NAME)                                       \
-    EXTENSION_NAME(VK_EXT_VERTEX_INPUT_DYNAMIC_STATE_EXTENSION_NAME)                               \
-    EXTENSION_NAME(VK_NV_GEOMETRY_SHADER_PASSTHROUGH_EXTENSION_NAME)                               \
-    EXTENSION_NAME(VK_NV_VIEWPORT_ARRAY2_EXTENSION_NAME)                                           \
-    EXTENSION_NAME(VK_NV_VIEWPORT_SWIZZLE_EXTENSION_NAME)
-
-// Define features which must be supported.
-#define FOR_EACH_VK_MANDATORY_FEATURE(FEATURE_NAME)                                                \
-    FEATURE_NAME(bit16_storage, storageBuffer16BitAccess)                                          \
-    FEATURE_NAME(bit16_storage, uniformAndStorageBuffer16BitAccess)                                \
-    FEATURE_NAME(bit8_storage, storageBuffer8BitAccess)                                            \
-    FEATURE_NAME(bit8_storage, uniformAndStorageBuffer8BitAccess)                                  \
-    FEATURE_NAME(features, depthBiasClamp)                                                         \
-    FEATURE_NAME(features, depthClamp)                                                             \
-    FEATURE_NAME(features, drawIndirectFirstInstance)                                              \
-    FEATURE_NAME(features, dualSrcBlend)                                                           \
-    FEATURE_NAME(features, fillModeNonSolid)                                                       \
-    FEATURE_NAME(features, fragmentStoresAndAtomics)                                               \
-    FEATURE_NAME(features, geometryShader)                                                         \
-    FEATURE_NAME(features, imageCubeArray)                                                         \
-    FEATURE_NAME(features, independentBlend)                                                       \
-    FEATURE_NAME(features, largePoints)                                                            \
-    FEATURE_NAME(features, logicOp)                                                                \
-    FEATURE_NAME(features, multiDrawIndirect)                                                      \
-    FEATURE_NAME(features, multiViewport)                                                          \
-    FEATURE_NAME(features, occlusionQueryPrecise)                                                  \
-    FEATURE_NAME(features, robustBufferAccess)                                                     \
-    FEATURE_NAME(features, samplerAnisotropy)                                                      \
-    FEATURE_NAME(features, sampleRateShading)                                                      \
-    FEATURE_NAME(features, shaderClipDistance)                                                     \
-    FEATURE_NAME(features, shaderCullDistance)                                                     \
-    FEATURE_NAME(features, shaderImageGatherExtended)                                              \
-    FEATURE_NAME(features, shaderStorageImageWriteWithoutFormat)                                   \
-    FEATURE_NAME(features, tessellationShader)                                                     \
-    FEATURE_NAME(features, vertexPipelineStoresAndAtomics)                                         \
-    FEATURE_NAME(features, wideLines)                                                              \
-    FEATURE_NAME(host_query_reset, hostQueryReset)                                                 \
-    FEATURE_NAME(robustness2, nullDescriptor)                                                      \
-    FEATURE_NAME(robustness2, robustBufferAccess2)                                                 \
-    FEATURE_NAME(robustness2, robustImageAccess2)                                                  \
-    FEATURE_NAME(shader_demote_to_helper_invocation, shaderDemoteToHelperInvocation)               \
-    FEATURE_NAME(shader_draw_parameters, shaderDrawParameters)                                     \
-    FEATURE_NAME(timeline_semaphore, timelineSemaphore)                                            \
-    FEATURE_NAME(variable_pointer, variablePointers)                                               \
-    FEATURE_NAME(variable_pointer, variablePointersStorageBuffer)
-
-// Define features where the absence of the feature may result in a degraded experience.
-#define FOR_EACH_VK_RECOMMENDED_FEATURE(FEATURE_NAME)                                              \
-    FEATURE_NAME(custom_border_color, customBorderColors)                                          \
-    FEATURE_NAME(extended_dynamic_state, extendedDynamicState)                                     \
-    FEATURE_NAME(index_type_uint8, indexTypeUint8)                                                 \
-    FEATURE_NAME(primitive_topology_list_restart, primitiveTopologyListRestart)                    \
-    FEATURE_NAME(provoking_vertex, provokingVertexLast)                                            \
-    FEATURE_NAME(shader_float16_int8, shaderFloat16)                                               \
-    FEATURE_NAME(shader_float16_int8, shaderInt8)                                                  \
-    FEATURE_NAME(transform_feedback, transformFeedback)                                            \
-    FEATURE_NAME(uniform_buffer_standard_layout, uniformBufferStandardLayout)                      \
-    FEATURE_NAME(vertex_input_dynamic_state, vertexInputDynamicState)
-
 namespace Vulkan {
 
 class NsightAftermathTracker;
@@ -239,69 +88,69 @@ public:
 
     /// Returns the current Vulkan API version provided in Vulkan-formatted version numbers.
     u32 ApiVersion() const {
-        return properties.properties.apiVersion;
+        return properties.apiVersion;
     }
 
     /// Returns the current driver version provided in Vulkan-formatted version numbers.
     u32 GetDriverVersion() const {
-        return properties.properties.driverVersion;
+        return properties.driverVersion;
     }
 
     /// Returns the device name.
     std::string_view GetModelName() const {
-        return properties.properties.deviceName;
+        return properties.deviceName;
     }
 
     /// Returns the driver ID.
     VkDriverIdKHR GetDriverID() const {
-        return properties.driver.driverID;
+        return driver_id;
     }
 
     bool ShouldBoostClocks() const;
 
     /// Returns uniform buffer alignment requeriment.
     VkDeviceSize GetUniformBufferAlignment() const {
-        return properties.properties.limits.minUniformBufferOffsetAlignment;
+        return properties.limits.minUniformBufferOffsetAlignment;
     }
 
     /// Returns storage alignment requeriment.
     VkDeviceSize GetStorageBufferAlignment() const {
-        return properties.properties.limits.minStorageBufferOffsetAlignment;
+        return properties.limits.minStorageBufferOffsetAlignment;
     }
 
     /// Returns the maximum range for storage buffers.
     VkDeviceSize GetMaxStorageBufferRange() const {
-        return properties.properties.limits.maxStorageBufferRange;
+        return properties.limits.maxStorageBufferRange;
     }
 
     /// Returns the maximum size for push constants.
     VkDeviceSize GetMaxPushConstantsSize() const {
-        return properties.properties.limits.maxPushConstantsSize;
+        return properties.limits.maxPushConstantsSize;
     }
 
     /// Returns the maximum size for shared memory.
     u32 GetMaxComputeSharedMemorySize() const {
-        return properties.properties.limits.maxComputeSharedMemorySize;
+        return properties.limits.maxComputeSharedMemorySize;
     }
 
     /// Returns float control properties of the device.
     const VkPhysicalDeviceFloatControlsPropertiesKHR& FloatControlProperties() const {
-        return properties.float_controls;
+        return float_controls;
     }
 
     /// Returns true if ASTC is natively supported.
     bool IsOptimalAstcSupported() const {
-        return features.features.textureCompressionASTC_LDR;
+        return is_optimal_astc_supported;
     }
 
     /// Returns true if the device supports float16 natively.
     bool IsFloat16Supported() const {
-        return features.shader_float16_int8.shaderFloat16;
+        return is_float16_supported;
     }
 
     /// Returns true if the device supports int8 natively.
     bool IsInt8Supported() const {
-        return features.shader_float16_int8.shaderInt8;
+        return is_int8_supported;
     }
 
     /// Returns true if the device warp size can potentially be bigger than guest's warp size.
@@ -311,32 +160,32 @@ public:
 
     /// Returns true if the device can be forced to use the guest warp size.
     bool IsGuestWarpSizeSupported(VkShaderStageFlagBits stage) const {
-        return properties.subgroup_size_control.requiredSubgroupSizeStages & stage;
+        return guest_warp_stages & stage;
     }
 
     /// Returns the maximum number of push descriptors.
     u32 MaxPushDescriptors() const {
-        return properties.push_descriptor.maxPushDescriptors;
+        return max_push_descriptors;
     }
 
     /// Returns true if formatless image load is supported.
     bool IsFormatlessImageLoadSupported() const {
-        return features.features.shaderStorageImageReadWithoutFormat;
+        return is_formatless_image_load_supported;
     }
 
     /// Returns true if shader int64 is supported.
     bool IsShaderInt64Supported() const {
-        return features.features.shaderInt64;
+        return is_shader_int64_supported;
     }
 
     /// Returns true if shader int16 is supported.
     bool IsShaderInt16Supported() const {
-        return features.features.shaderInt16;
+        return is_shader_int16_supported;
     }
 
     // Returns true if depth bounds is supported.
     bool IsDepthBoundsSupported() const {
-        return features.features.depthBounds;
+        return is_depth_bounds_supported;
     }
 
     /// Returns true when blitting from and to depth stencil images is supported.
@@ -346,151 +195,151 @@ public:
 
     /// Returns true if the device supports VK_NV_viewport_swizzle.
     bool IsNvViewportSwizzleSupported() const {
-        return extensions.viewport_swizzle;
+        return nv_viewport_swizzle;
     }
 
     /// Returns true if the device supports VK_NV_viewport_array2.
     bool IsNvViewportArray2Supported() const {
-        return extensions.viewport_array2;
+        return nv_viewport_array2;
     }
 
     /// Returns true if the device supports VK_NV_geometry_shader_passthrough.
     bool IsNvGeometryShaderPassthroughSupported() const {
-        return extensions.geometry_shader_passthrough;
+        return nv_geometry_shader_passthrough;
     }
 
     /// Returns true if the device supports VK_KHR_uniform_buffer_standard_layout.
     bool IsKhrUniformBufferStandardLayoutSupported() const {
-        return extensions.uniform_buffer_standard_layout;
+        return khr_uniform_buffer_standard_layout;
     }
 
     /// Returns true if the device supports VK_KHR_push_descriptor.
     bool IsKhrPushDescriptorSupported() const {
-        return extensions.push_descriptor;
+        return khr_push_descriptor;
     }
 
     /// Returns true if VK_KHR_pipeline_executable_properties is enabled.
     bool IsKhrPipelineExecutablePropertiesEnabled() const {
-        return extensions.pipeline_executable_properties;
+        return khr_pipeline_executable_properties;
     }
 
     /// Returns true if VK_KHR_swapchain_mutable_format is enabled.
     bool IsKhrSwapchainMutableFormatEnabled() const {
-        return extensions.swapchain_mutable_format;
+        return khr_swapchain_mutable_format;
     }
 
     /// Returns true if the device supports VK_KHR_workgroup_memory_explicit_layout.
     bool IsKhrWorkgroupMemoryExplicitLayoutSupported() const {
-        return extensions.workgroup_memory_explicit_layout;
+        return khr_workgroup_memory_explicit_layout;
     }
 
     /// Returns true if the device supports VK_EXT_primitive_topology_list_restart.
     bool IsTopologyListPrimitiveRestartSupported() const {
-        return features.primitive_topology_list_restart.primitiveTopologyListRestart;
+        return is_topology_list_restart_supported;
     }
 
     /// Returns true if the device supports VK_EXT_primitive_topology_list_restart.
     bool IsPatchListPrimitiveRestartSupported() const {
-        return features.primitive_topology_list_restart.primitiveTopologyPatchListRestart;
+        return is_patch_list_restart_supported;
     }
 
     /// Returns true if the device supports VK_EXT_index_type_uint8.
     bool IsExtIndexTypeUint8Supported() const {
-        return extensions.index_type_uint8;
+        return ext_index_type_uint8;
     }
 
     /// Returns true if the device supports VK_EXT_sampler_filter_minmax.
     bool IsExtSamplerFilterMinmaxSupported() const {
-        return extensions.sampler_filter_minmax;
+        return ext_sampler_filter_minmax;
     }
 
     /// Returns true if the device supports VK_EXT_depth_range_unrestricted.
     bool IsExtDepthRangeUnrestrictedSupported() const {
-        return extensions.depth_range_unrestricted;
+        return ext_depth_range_unrestricted;
     }
 
     /// Returns true if the device supports VK_EXT_depth_clip_control.
     bool IsExtDepthClipControlSupported() const {
-        return extensions.depth_clip_control;
+        return ext_depth_clip_control;
     }
 
     /// Returns true if the device supports VK_EXT_shader_viewport_index_layer.
     bool IsExtShaderViewportIndexLayerSupported() const {
-        return extensions.shader_viewport_index_layer;
+        return ext_shader_viewport_index_layer;
     }
 
     /// Returns true if the device supports VK_EXT_subgroup_size_control.
     bool IsExtSubgroupSizeControlSupported() const {
-        return extensions.subgroup_size_control;
+        return ext_subgroup_size_control;
     }
 
     /// Returns true if the device supports VK_EXT_transform_feedback.
     bool IsExtTransformFeedbackSupported() const {
-        return extensions.transform_feedback;
+        return ext_transform_feedback;
     }
 
     /// Returns true if the device supports VK_EXT_custom_border_color.
     bool IsExtCustomBorderColorSupported() const {
-        return extensions.custom_border_color;
+        return ext_custom_border_color;
     }
 
     /// Returns true if the device supports VK_EXT_extended_dynamic_state.
     bool IsExtExtendedDynamicStateSupported() const {
-        return extensions.extended_dynamic_state;
+        return ext_extended_dynamic_state;
     }
 
     /// Returns true if the device supports VK_EXT_extended_dynamic_state2.
     bool IsExtExtendedDynamicState2Supported() const {
-        return extensions.extended_dynamic_state2;
+        return ext_extended_dynamic_state_2;
     }
 
     bool IsExtExtendedDynamicState2ExtrasSupported() const {
-        return features.extended_dynamic_state2.extendedDynamicState2LogicOp;
+        return ext_extended_dynamic_state_2_extra;
     }
 
     /// Returns true if the device supports VK_EXT_extended_dynamic_state3.
     bool IsExtExtendedDynamicState3Supported() const {
-        return extensions.extended_dynamic_state3;
+        return ext_extended_dynamic_state_3;
     }
 
     /// Returns true if the device supports VK_EXT_extended_dynamic_state3.
     bool IsExtExtendedDynamicState3BlendingSupported() const {
-        return dynamic_state3_blending;
+        return ext_extended_dynamic_state_3_blend;
     }
 
     /// Returns true if the device supports VK_EXT_extended_dynamic_state3.
     bool IsExtExtendedDynamicState3EnablesSupported() const {
-        return dynamic_state3_enables;
+        return ext_extended_dynamic_state_3_enables;
     }
 
     /// Returns true if the device supports VK_EXT_line_rasterization.
     bool IsExtLineRasterizationSupported() const {
-        return extensions.line_rasterization;
+        return ext_line_rasterization;
     }
 
     /// Returns true if the device supports VK_EXT_vertex_input_dynamic_state.
     bool IsExtVertexInputDynamicStateSupported() const {
-        return extensions.vertex_input_dynamic_state;
+        return ext_vertex_input_dynamic_state;
     }
 
     /// Returns true if the device supports VK_EXT_shader_stencil_export.
     bool IsExtShaderStencilExportSupported() const {
-        return extensions.shader_stencil_export;
+        return ext_shader_stencil_export;
     }
 
     /// Returns true if the device supports VK_EXT_conservative_rasterization.
     bool IsExtConservativeRasterizationSupported() const {
-        return extensions.conservative_rasterization;
+        return ext_conservative_rasterization;
     }
 
     /// Returns true if the device supports VK_EXT_provoking_vertex.
     bool IsExtProvokingVertexSupported() const {
-        return extensions.provoking_vertex;
+        return ext_provoking_vertex;
     }
 
     /// Returns true if the device supports VK_KHR_shader_atomic_int64.
     bool IsExtShaderAtomicInt64Supported() const {
-        return extensions.shader_atomic_int64;
+        return ext_shader_atomic_int64;
     }
 
     /// Returns the minimum supported version of SPIR-V.
@@ -498,7 +347,7 @@ public:
         if (instance_version >= VK_API_VERSION_1_3) {
             return 0x00010600U;
         }
-        if (extensions.spirv_1_4) {
+        if (khr_spirv_1_4) {
             return 0x00010400U;
         }
         return 0x00010000U;
@@ -516,11 +365,11 @@ public:
 
     /// Returns the vendor name reported from Vulkan.
     std::string_view GetVendorName() const {
-        return properties.driver.driverName;
+        return vendor_name;
     }
 
     /// Returns the list of available extensions.
-    const std::set<std::string, std::less<>>& GetAvailableExtensions() const {
+    const std::vector<std::string>& GetAvailableExtensions() const {
         return supported_extensions;
     }
 
@@ -529,7 +378,7 @@ public:
     }
 
     bool CanReportMemoryUsage() const {
-        return extensions.memory_budget;
+        return ext_memory_budget;
     }
 
     u64 GetDeviceMemoryUsage() const;
@@ -551,29 +400,36 @@ public:
     }
 
     bool HasNullDescriptor() const {
-        return features.robustness2.nullDescriptor;
+        return has_null_descriptor;
     }
 
     u32 GetMaxVertexInputAttributes() const {
-        return properties.properties.limits.maxVertexInputAttributes;
+        return max_vertex_input_attributes;
     }
 
     u32 GetMaxVertexInputBindings() const {
-        return properties.properties.limits.maxVertexInputBindings;
+        return max_vertex_input_bindings;
     }
 
 private:
-    /// Checks if the physical device is suitable and configures the object state
-    /// with all necessary info about its properties.
-    bool GetSuitability(bool requires_swapchain);
+    /// Checks if the physical device is suitable.
+    void CheckSuitability(bool requires_swapchain) const;
 
-    // Remove extensions which have incomplete feature support.
-    void RemoveUnsuitableExtensions();
-    void RemoveExtensionIfUnsuitable(bool is_suitable, const std::string& extension_name);
+    /// Loads extensions into a vector and stores available ones in this object.
+    std::vector<const char*> LoadExtensions(bool requires_surface);
 
     /// Sets up queue families.
     void SetupFamilies(VkSurfaceKHR surface);
 
+    /// Sets up device features.
+    void SetupFeatures();
+
+    /// Sets up device properties.
+    void SetupProperties();
+
+    /// Collects telemetry information from the device.
+    void CollectTelemetryParameters();
+
     /// Collects information about attached tools.
     void CollectToolingInfo();
 
@@ -584,93 +440,91 @@ private:
     std::vector<VkDeviceQueueCreateInfo> GetDeviceQueueCreateInfos() const;
 
     /// Returns true if ASTC textures are natively supported.
-    bool ComputeIsOptimalAstcSupported() const;
+    bool IsOptimalAstcSupported(const VkPhysicalDeviceFeatures& features) const;
 
     /// Returns true if the device natively supports blitting depth stencil images.
     bool TestDepthStencilBlits() const;
 
-private:
-    VkInstance instance;         ///< Vulkan instance.
-    vk::DeviceDispatch dld;      ///< Device function pointers.
-    vk::PhysicalDevice physical; ///< Physical device.
-    vk::Device logical;          ///< Logical device.
-    vk::Queue graphics_queue;    ///< Main graphics queue.
-    vk::Queue present_queue;     ///< Main present queue.
-    u32 instance_version{};      ///< Vulkan instance version.
-    u32 graphics_family{};       ///< Main graphics queue family index.
-    u32 present_family{};        ///< Main present queue family index.
-
-    struct Extensions {
-#define EXTENSION(prefix, macro_name, var_name) bool var_name{};
-#define FEATURE(prefix, struct_name, macro_name, var_name) bool var_name{};
-
-        FOR_EACH_VK_FEATURE_1_1(FEATURE);
-        FOR_EACH_VK_FEATURE_1_2(FEATURE);
-        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
-    };
-
-    struct Features {
-#define FEATURE_CORE(prefix, struct_name, macro_name, var_name)                                    \
-    VkPhysicalDevice##struct_name##Features var_name{};
-#define FEATURE_EXT(prefix, struct_name, macro_name, var_name)                                     \
-    VkPhysicalDevice##struct_name##Features##prefix var_name{};
-
-        FOR_EACH_VK_FEATURE_1_1(FEATURE_CORE);
-        FOR_EACH_VK_FEATURE_1_2(FEATURE_CORE);
-        FOR_EACH_VK_FEATURE_1_3(FEATURE_CORE);
-        FOR_EACH_VK_FEATURE_EXT(FEATURE_EXT);
-
-#undef FEATURE_CORE
-#undef FEATURE_EXT
-
-        VkPhysicalDeviceFeatures features{};
-    };
-
-    struct Properties {
-        VkPhysicalDeviceDriverProperties driver{};
-        VkPhysicalDeviceFloatControlsProperties float_controls{};
-        VkPhysicalDevicePushDescriptorPropertiesKHR push_descriptor{};
-        VkPhysicalDeviceSubgroupSizeControlProperties subgroup_size_control{};
-        VkPhysicalDeviceTransformFeedbackPropertiesEXT transform_feedback{};
-
-        VkPhysicalDeviceProperties properties{};
-    };
-
-    Extensions extensions{};
-    Features features{};
-    Properties properties{};
-
-    VkPhysicalDeviceFeatures2 features2{};
-    VkPhysicalDeviceProperties2 properties2{};
-
-    // Misc features
-    bool is_optimal_astc_supported{};       ///< Support for all guest ASTC formats.
-    bool is_blit_depth_stencil_supported{}; ///< Support for blitting from and to depth stencil.
-    bool is_warp_potentially_bigger{};      ///< Host warp size can be bigger than guest.
-    bool is_integrated{};                   ///< Is GPU an iGPU.
-    bool is_virtual{};                      ///< Is GPU a virtual GPU.
-    bool is_non_gpu{};                      ///< Is SoftwareRasterizer, FPGA, non-GPU device.
-    bool has_broken_cube_compatibility{};   ///< Has broken cube compatiblity bit
-    bool has_renderdoc{};                   ///< Has RenderDoc attached
-    bool has_nsight_graphics{};             ///< Has Nsight Graphics attached
-    bool supports_d24_depth{};              ///< Supports D24 depth buffers.
-    bool cant_blit_msaa{};                  ///< Does not support MSAA<->MSAA blitting.
-    bool must_emulate_bgr565{};             ///< Emulates BGR565 by swizzling RGB565 format.
-    bool dynamic_state3_blending{};         ///< Has all blending features of dynamic_state3.
-    bool dynamic_state3_enables{};          ///< Has all enables features of dynamic_state3.
-    u64 device_access_memory{};             ///< Total size of device local memory in bytes.
-    u32 sets_per_pool{};                    ///< Sets per Description Pool
+    VkInstance instance;                                         ///< Vulkan instance.
+    vk::DeviceDispatch dld;                                      ///< Device function pointers.
+    vk::PhysicalDevice physical;                                 ///< Physical device.
+    VkPhysicalDeviceProperties properties;                       ///< Device properties.
+    VkPhysicalDeviceFloatControlsPropertiesKHR float_controls{}; ///< Float control properties.
+    vk::Device logical;                                          ///< Logical device.
+    vk::Queue graphics_queue;                                    ///< Main graphics queue.
+    vk::Queue present_queue;                                     ///< Main present queue.
+    u32 instance_version{};                                      ///< Vulkan onstance version.
+    u32 graphics_family{};                      ///< Main graphics queue family index.
+    u32 present_family{};                       ///< Main present queue family index.
+    VkDriverIdKHR driver_id{};                  ///< Driver ID.
+    VkShaderStageFlags guest_warp_stages{};     ///< Stages where the guest warp size can be forced.
+    u64 device_access_memory{};                 ///< Total size of device local memory in bytes.
+    u32 max_push_descriptors{};                 ///< Maximum number of push descriptors
+    u32 sets_per_pool{};                        ///< Sets per Description Pool
+    bool is_optimal_astc_supported{};           ///< Support for native ASTC.
+    bool is_float16_supported{};                ///< Support for float16 arithmetic.
+    bool is_int8_supported{};                   ///< Support for int8 arithmetic.
+    bool is_warp_potentially_bigger{};          ///< Host warp size can be bigger than guest.
+    bool is_formatless_image_load_supported{};  ///< Support for shader image read without format.
+    bool is_depth_bounds_supported{};           ///< Support for depth bounds.
+    bool is_shader_float64_supported{};         ///< Support for float64.
+    bool is_shader_int64_supported{};           ///< Support for int64.
+    bool is_shader_int16_supported{};           ///< Support for int16.
+    bool is_shader_storage_image_multisample{}; ///< Support for image operations on MSAA images.
+    bool is_blit_depth_stencil_supported{};     ///< Support for blitting from and to depth stencil.
+    bool is_topology_list_restart_supported{};  ///< Support for primitive restart with list
+                                                ///< topologies.
+    bool is_patch_list_restart_supported{};     ///< Support for primitive restart with list patch.
+    bool is_integrated{};                       ///< Is GPU an iGPU.
+    bool is_virtual{};                          ///< Is GPU a virtual GPU.
+    bool is_non_gpu{};                          ///< Is SoftwareRasterizer, FPGA, non-GPU device.
+    bool nv_viewport_swizzle{};                 ///< Support for VK_NV_viewport_swizzle.
+    bool nv_viewport_array2{};                  ///< Support for VK_NV_viewport_array2.
+    bool nv_geometry_shader_passthrough{};      ///< Support for VK_NV_geometry_shader_passthrough.
+    bool khr_draw_indirect_count{};             ///< Support for VK_KHR_draw_indirect_count.
+    bool khr_uniform_buffer_standard_layout{};  ///< Support for scalar uniform buffer layouts.
+    bool khr_spirv_1_4{};                       ///< Support for VK_KHR_spirv_1_4.
+    bool khr_workgroup_memory_explicit_layout{}; ///< Support for explicit workgroup layouts.
+    bool khr_push_descriptor{};                  ///< Support for VK_KHR_push_descritor.
+    bool khr_pipeline_executable_properties{};   ///< Support for executable properties.
+    bool khr_swapchain_mutable_format{};         ///< Support for VK_KHR_swapchain_mutable_format.
+    bool ext_index_type_uint8{};                 ///< Support for VK_EXT_index_type_uint8.
+    bool ext_sampler_filter_minmax{};            ///< Support for VK_EXT_sampler_filter_minmax.
+    bool ext_depth_clip_control{};               ///< Support for VK_EXT_depth_clip_control
+    bool ext_depth_range_unrestricted{};         ///< Support for VK_EXT_depth_range_unrestricted.
+    bool ext_shader_viewport_index_layer{};    ///< Support for VK_EXT_shader_viewport_index_layer.
+    bool ext_tooling_info{};                   ///< Support for VK_EXT_tooling_info.
+    bool ext_subgroup_size_control{};          ///< Support for VK_EXT_subgroup_size_control.
+    bool ext_transform_feedback{};             ///< Support for VK_EXT_transform_feedback.
+    bool ext_custom_border_color{};            ///< Support for VK_EXT_custom_border_color.
+    bool ext_extended_dynamic_state{};         ///< Support for VK_EXT_extended_dynamic_state.
+    bool ext_extended_dynamic_state_2{};       ///< Support for VK_EXT_extended_dynamic_state2.
+    bool ext_extended_dynamic_state_2_extra{}; ///< Support for VK_EXT_extended_dynamic_state2.
+    bool ext_extended_dynamic_state_3{};       ///< Support for VK_EXT_extended_dynamic_state3.
+    bool ext_extended_dynamic_state_3_blend{}; ///< Support for VK_EXT_extended_dynamic_state3.
+    bool ext_extended_dynamic_state_3_enables{}; ///< Support for VK_EXT_extended_dynamic_state3.
+    bool ext_line_rasterization{};               ///< Support for VK_EXT_line_rasterization.
+    bool ext_vertex_input_dynamic_state{};       ///< Support for VK_EXT_vertex_input_dynamic_state.
+    bool ext_shader_stencil_export{};            ///< Support for VK_EXT_shader_stencil_export.
+    bool ext_shader_atomic_int64{};              ///< Support for VK_KHR_shader_atomic_int64.
+    bool ext_conservative_rasterization{};       ///< Support for VK_EXT_conservative_rasterization.
+    bool ext_provoking_vertex{};                 ///< Support for VK_EXT_provoking_vertex.
+    bool ext_memory_budget{};                    ///< Support for VK_EXT_memory_budget.
+    bool nv_device_diagnostics_config{};         ///< Support for VK_NV_device_diagnostics_config.
+    bool has_broken_cube_compatibility{};        ///< Has broken cube compatiblity bit
+    bool has_renderdoc{};                        ///< Has RenderDoc attached
+    bool has_nsight_graphics{};                  ///< Has Nsight Graphics attached
+    bool supports_d24_depth{};                   ///< Supports D24 depth buffers.
+    bool cant_blit_msaa{};                       ///< Does not support MSAA<->MSAA blitting.
+    bool must_emulate_bgr565{};                  ///< Emulates BGR565 by swizzling RGB565 format.
+    bool has_null_descriptor{};                  ///< Has support for null descriptors.
+    u32 max_vertex_input_attributes{};           ///< Max vertex input attributes in pipeline
+    u32 max_vertex_input_bindings{};             ///< Max vertex input buffers in pipeline
 
     // Telemetry parameters
-    std::set<std::string, std::less<>> supported_extensions; ///< Reported Vulkan extensions.
-    std::set<std::string, std::less<>> loaded_extensions;    ///< Loaded Vulkan extensions.
-    std::vector<size_t> valid_heap_memory;                   ///< Heaps used.
+    std::string vendor_name;                       ///< Device's driver name.
+    std::vector<std::string> supported_extensions; ///< Reported Vulkan extensions.
+    std::vector<size_t> valid_heap_memory;         ///< Heaps used.
 
     /// Format properties dictionary.
     std::unordered_map<VkFormat, VkFormatProperties> format_properties;

src/video_core/vulkan_common/vulkan_wrapper.cpp

@@ -96,8 +96,8 @@ void Load(VkDevice device, DeviceDispatch& dld) noexcept {
     X(vkCmdDrawIndexed);
     X(vkCmdDrawIndirect);
     X(vkCmdDrawIndexedIndirect);
-    X(vkCmdDrawIndirectCount);
-    X(vkCmdDrawIndexedIndirectCount);
+    X(vkCmdDrawIndirectCountKHR);
+    X(vkCmdDrawIndexedIndirectCountKHR);
     X(vkCmdEndQuery);
     X(vkCmdEndRenderPass);
     X(vkCmdEndTransformFeedbackEXT);
@@ -221,12 +221,6 @@ void Load(VkDevice device, DeviceDispatch& dld) noexcept {
     if (!dld.vkResetQueryPool) {
         Proc(dld.vkResetQueryPool, dld, "vkResetQueryPoolEXT", device);
     }
-
-    // Support for draw indirect with count is optional in Vulkan 1.2
-    if (!dld.vkCmdDrawIndirectCount) {
-        Proc(dld.vkCmdDrawIndirectCount, dld, "vkCmdDrawIndirectCountKHR", device);
-        Proc(dld.vkCmdDrawIndexedIndirectCount, dld, "vkCmdDrawIndexedIndirectCountKHR", device);
-    }
 #undef X
 }
 

src/video_core/vulkan_common/vulkan_wrapper.h

@@ -215,8 +215,8 @@ struct DeviceDispatch : InstanceDispatch {
     PFN_vkCmdDrawIndexed vkCmdDrawIndexed{};
     PFN_vkCmdDrawIndirect vkCmdDrawIndirect{};
     PFN_vkCmdDrawIndexedIndirect vkCmdDrawIndexedIndirect{};
-    PFN_vkCmdDrawIndirectCount vkCmdDrawIndirectCount{};
-    PFN_vkCmdDrawIndexedIndirectCount vkCmdDrawIndexedIndirectCount{};
+    PFN_vkCmdDrawIndirectCountKHR vkCmdDrawIndirectCountKHR{};
+    PFN_vkCmdDrawIndexedIndirectCountKHR vkCmdDrawIndexedIndirectCountKHR{};
     PFN_vkCmdEndDebugUtilsLabelEXT vkCmdEndDebugUtilsLabelEXT{};
     PFN_vkCmdEndQuery vkCmdEndQuery{};
     PFN_vkCmdEndRenderPass vkCmdEndRenderPass{};
@@ -1065,15 +1065,15 @@ public:
 
     void DrawIndirectCount(VkBuffer src_buffer, VkDeviceSize src_offset, VkBuffer count_buffer,
                            VkDeviceSize count_offset, u32 draw_count, u32 stride) const noexcept {
-        dld->vkCmdDrawIndirectCount(handle, src_buffer, src_offset, count_buffer, count_offset,
-                                    draw_count, stride);
+        dld->vkCmdDrawIndirectCountKHR(handle, src_buffer, src_offset, count_buffer, count_offset,
+                                       draw_count, stride);
     }
 
     void DrawIndexedIndirectCount(VkBuffer src_buffer, VkDeviceSize src_offset,
                                   VkBuffer count_buffer, VkDeviceSize count_offset, u32 draw_count,
                                   u32 stride) const noexcept {
-        dld->vkCmdDrawIndexedIndirectCount(handle, src_buffer, src_offset, count_buffer,
-                                           count_offset, draw_count, stride);
+        dld->vkCmdDrawIndexedIndirectCountKHR(handle, src_buffer, src_offset, count_buffer,
+                                              count_offset, draw_count, stride);
     }
 
     void ClearAttachments(Span<VkClearAttachment> attachments,

src/yuzu/Info.plist

@@ -34,8 +34,6 @@ SPDX-License-Identifier: GPL-2.0-or-later
     <string></string>
     <key>CSResourcesFileMapped</key>
     <true/>
-    <key>LSApplicationCategoryType</key>
-    <string>public.app-category.games</string>
     <key>LSRequiresCarbon</key>
     <true/>
     <key>NSHumanReadableCopyright</key>

src/yuzu/main.cpp

@@ -1839,11 +1839,9 @@ void GMainWindow::OnEmulationStopTimeExpired() {
 
 void GMainWindow::OnEmulationStopped() {
     shutdown_timer.stop();
-    if (emu_thread) {
-        emu_thread->disconnect();
-        emu_thread->wait();
-        emu_thread.reset();
-    }
+    emu_thread->disconnect();
+    emu_thread->wait();
+    emu_thread = nullptr;
 
     if (shutdown_dialog) {
         shutdown_dialog->deleteLater();
@@ -3031,8 +3029,6 @@ void GMainWindow::OnStopGame() {
 
     if (OnShutdownBegin()) {
         OnShutdownBeginDialog();
-    } else {
-        OnEmulationStopped();
     }
 }