"Merge Tagged PR 1012"

CMakeLists.txt

@@ -29,7 +29,7 @@ option(ENABLE_VULKAN "Enables Vulkan backend" ON)
 
 option(USE_DISCORD_PRESENCE "Enables Discord Rich Presence" OFF)
 
-if(EXISTS ${PROJECT_SOURCE_DIR}/hooks/pre-commit AND NOT EXISTS ${PROJECT_SOURCE_DIR}/.git/hooks/pre-commit)
+if(NOT EXISTS ${PROJECT_SOURCE_DIR}/.git/hooks/pre-commit)
     message(STATUS "Copying pre-commit hook")
     file(COPY hooks/pre-commit
         DESTINATION ${PROJECT_SOURCE_DIR}/.git/hooks)
@@ -49,10 +49,7 @@ function(check_submodules_present)
         endif()
     endforeach()
 endfunction()
-
-if(EXISTS ${PROJECT_SOURCE_DIR}/.gitmodules)
-    check_submodules_present()
-endif()
+check_submodules_present()
 
 configure_file(${PROJECT_SOURCE_DIR}/dist/compatibility_list/compatibility_list.qrc
                ${PROJECT_BINARY_DIR}/dist/compatibility_list/compatibility_list.qrc

src/common/threadsafe_queue.h

@@ -46,19 +46,8 @@ public:
         ElementPtr* new_ptr = new ElementPtr();
         write_ptr->next.store(new_ptr, std::memory_order_release);
         write_ptr = new_ptr;
-
-        const size_t previous_size{size};
         ++size;
-
-        // Acquire the mutex and then immediately release it as a fence.
-        // TODO(bunnei): This can be replaced with C++20 waitable atomics when properly supported.
-        // See discussion on https://github.com/yuzu-emu/yuzu/pull/3173 for details.
-        if (previous_size == 0) {
-            std::lock_guard lock{cv_mutex};
-            cv.notify_one();
-        } else {
-            cv.notify_one();
-        }
+        cv.notify_one();
     }
 
     void Pop() {

src/core/hle/kernel/address_arbiter.cpp

@@ -11,16 +11,18 @@
 #include "core/core_cpu.h"
 #include "core/hle/kernel/address_arbiter.h"
 #include "core/hle/kernel/errors.h"
+#include "core/hle/kernel/object.h"
+#include "core/hle/kernel/process.h"
 #include "core/hle/kernel/scheduler.h"
 #include "core/hle/kernel/thread.h"
 #include "core/hle/result.h"
 #include "core/memory.h"
 
 namespace Kernel {
-
+namespace {
 // Wake up num_to_wake (or all) threads in a vector.
-void AddressArbiter::WakeThreads(const std::vector<std::shared_ptr<Thread>>& waiting_threads,
-                                 s32 num_to_wake) {
+void WakeThreads(const std::vector<std::shared_ptr<Thread>>& waiting_threads, s32 num_to_wake) {
+    auto& system = Core::System::GetInstance();
     // Only process up to 'target' threads, unless 'target' is <= 0, in which case process
     // them all.
     std::size_t last = waiting_threads.size();
@@ -32,12 +34,12 @@ void AddressArbiter::WakeThreads(const std::vector<std::shared_ptr<Thread>>& wai
     for (std::size_t i = 0; i < last; i++) {
         ASSERT(waiting_threads[i]->GetStatus() == ThreadStatus::WaitArb);
         waiting_threads[i]->SetWaitSynchronizationResult(RESULT_SUCCESS);
-        RemoveThread(waiting_threads[i]);
         waiting_threads[i]->SetArbiterWaitAddress(0);
         waiting_threads[i]->ResumeFromWait();
         system.PrepareReschedule(waiting_threads[i]->GetProcessorID());
     }
 }
+} // Anonymous namespace
 
 AddressArbiter::AddressArbiter(Core::System& system) : system{system} {}
 AddressArbiter::~AddressArbiter() = default;
@@ -184,7 +186,6 @@ ResultCode AddressArbiter::WaitForAddressIfEqual(VAddr address, s32 value, s64 t
 ResultCode AddressArbiter::WaitForAddressImpl(VAddr address, s64 timeout) {
     Thread* current_thread = system.CurrentScheduler().GetCurrentThread();
     current_thread->SetArbiterWaitAddress(address);
-    InsertThread(SharedFrom(current_thread));
     current_thread->SetStatus(ThreadStatus::WaitArb);
     current_thread->InvalidateWakeupCallback();
     current_thread->WakeAfterDelay(timeout);
@@ -193,51 +194,26 @@ ResultCode AddressArbiter::WaitForAddressImpl(VAddr address, s64 timeout) {
     return RESULT_TIMEOUT;
 }
 
-void AddressArbiter::HandleWakeupThread(std::shared_ptr<Thread> thread) {
-    ASSERT(thread->GetStatus() == ThreadStatus::WaitArb);
-    RemoveThread(thread);
-    thread->SetArbiterWaitAddress(0);
-}
+std::vector<std::shared_ptr<Thread>> AddressArbiter::GetThreadsWaitingOnAddress(
+    VAddr address) const {
 
-void AddressArbiter::InsertThread(std::shared_ptr<Thread> thread) {
-    const VAddr arb_addr = thread->GetArbiterWaitAddress();
-    std::list<std::shared_ptr<Thread>>& thread_list = arb_threads[arb_addr];
-    auto it = thread_list.begin();
-    while (it != thread_list.end()) {
-        const std::shared_ptr<Thread>& current_thread = *it;
-        if (current_thread->GetPriority() >= thread->GetPriority()) {
-            thread_list.insert(it, thread);
-            return;
+    // Retrieve all threads that are waiting for this address.
+    std::vector<std::shared_ptr<Thread>> threads;
+    const auto& scheduler = system.GlobalScheduler();
+    const auto& thread_list = scheduler.GetThreadList();
+
+    for (const auto& thread : thread_list) {
+        if (thread->GetArbiterWaitAddress() == address) {
+            threads.push_back(thread);
         }
-        ++it;
     }
-    thread_list.push_back(std::move(thread));
-}
 
-void AddressArbiter::RemoveThread(std::shared_ptr<Thread> thread) {
-    const VAddr arb_addr = thread->GetArbiterWaitAddress();
-    std::list<std::shared_ptr<Thread>>& thread_list = arb_threads[arb_addr];
-    auto it = thread_list.begin();
-    while (it != thread_list.end()) {
-        const std::shared_ptr<Thread>& current_thread = *it;
-        if (current_thread.get() == thread.get()) {
-            thread_list.erase(it);
-            return;
-        }
-        ++it;
-    }
-    UNREACHABLE();
-}
+    // Sort them by priority, such that the highest priority ones come first.
+    std::sort(threads.begin(), threads.end(),
+              [](const std::shared_ptr<Thread>& lhs, const std::shared_ptr<Thread>& rhs) {
+                  return lhs->GetPriority() < rhs->GetPriority();
+              });
 
-std::vector<std::shared_ptr<Thread>> AddressArbiter::GetThreadsWaitingOnAddress(VAddr address) {
-    std::vector<std::shared_ptr<Thread>> result;
-    std::list<std::shared_ptr<Thread>>& thread_list = arb_threads[address];
-    auto it = thread_list.begin();
-    while (it != thread_list.end()) {
-        std::shared_ptr<Thread> current_thread = *it;
-        result.push_back(std::move(current_thread));
-        ++it;
-    }
-    return result;
+    return threads;
 }
 } // namespace Kernel

src/core/hle/kernel/address_arbiter.h

@@ -4,12 +4,10 @@
 
 #pragma once
 
-#include <list>
-#include <memory>
-#include <unordered_map>
 #include <vector>
 
 #include "common/common_types.h"
+#include "core/hle/kernel/object.h"
 
 union ResultCode;
 
@@ -50,9 +48,6 @@ public:
     /// Waits on an address with a particular arbitration type.
     ResultCode WaitForAddress(VAddr address, ArbitrationType type, s32 value, s64 timeout_ns);
 
-    /// Removes a thread from the container and resets its address arbiter adress to 0
-    void HandleWakeupThread(std::shared_ptr<Thread> thread);
-
 private:
     /// Signals an address being waited on.
     ResultCode SignalToAddressOnly(VAddr address, s32 num_to_wake);
@@ -76,20 +71,8 @@ private:
     // Waits on the given address with a timeout in nanoseconds
     ResultCode WaitForAddressImpl(VAddr address, s64 timeout);
 
-    /// Wake up num_to_wake (or all) threads in a vector.
-    void WakeThreads(const std::vector<std::shared_ptr<Thread>>& waiting_threads, s32 num_to_wake);
-
-    /// Insert a thread into the address arbiter container
-    void InsertThread(std::shared_ptr<Thread> thread);
-
-    /// Removes a thread from the address arbiter container
-    void RemoveThread(std::shared_ptr<Thread> thread);
-
     // Gets the threads waiting on an address.
-    std::vector<std::shared_ptr<Thread>> GetThreadsWaitingOnAddress(VAddr address);
-
-    /// List of threads waiting for a address arbiter
-    std::unordered_map<VAddr, std::list<std::shared_ptr<Thread>>> arb_threads;
+    std::vector<std::shared_ptr<Thread>> GetThreadsWaitingOnAddress(VAddr address) const;
 
     Core::System& system;
 };

src/core/hle/kernel/client_port.cpp

@@ -8,6 +8,7 @@
 #include "core/hle/kernel/hle_ipc.h"
 #include "core/hle/kernel/object.h"
 #include "core/hle/kernel/server_port.h"
+#include "core/hle/kernel/server_session.h"
 #include "core/hle/kernel/session.h"
 
 namespace Kernel {

src/core/hle/kernel/client_port.h

@@ -4,9 +4,7 @@
 
 #pragma once
 
-#include <memory>
 #include <string>
-
 #include "common/common_types.h"
 #include "core/hle/kernel/object.h"
 #include "core/hle/result.h"

src/core/hle/kernel/handle_table.h

@@ -6,8 +6,6 @@
 
 #include <array>
 #include <cstddef>
-#include <memory>
-
 #include "common/common_types.h"
 #include "core/hle/kernel/object.h"
 #include "core/hle/result.h"

src/core/hle/kernel/kernel.cpp

@@ -13,6 +13,7 @@
 #include "core/core.h"
 #include "core/core_timing.h"
 #include "core/core_timing_util.h"
+#include "core/hle/kernel/address_arbiter.h"
 #include "core/hle/kernel/client_port.h"
 #include "core/hle/kernel/errors.h"
 #include "core/hle/kernel/handle_table.h"
@@ -78,9 +79,9 @@ static void ThreadWakeupCallback(u64 thread_handle, [[maybe_unused]] s64 cycles_
         }
     }
 
-    if (thread->GetStatus() == ThreadStatus::WaitArb) {
-        auto& address_arbiter = thread->GetOwnerProcess()->GetAddressArbiter();
-        address_arbiter.HandleWakeupThread(thread);
+    if (thread->GetArbiterWaitAddress() != 0) {
+        ASSERT(thread->GetStatus() == ThreadStatus::WaitArb);
+        thread->SetArbiterWaitAddress(0);
     }
 
     if (resume) {

src/core/hle/kernel/kernel.h

@@ -4,7 +4,6 @@
 
 #pragma once
 
-#include <memory>
 #include <string>
 #include <unordered_map>
 #include <vector>

src/core/hle/kernel/mutex.cpp

@@ -2,7 +2,6 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
-#include <memory>
 #include <utility>
 #include <vector>
 

src/core/hle/kernel/resource_limit.h

@@ -5,8 +5,6 @@
 #pragma once
 
 #include <array>
-#include <memory>
-
 #include "common/common_types.h"
 #include "core/hle/kernel/object.h"
 

src/core/hle/kernel/scheduler.h

@@ -4,12 +4,11 @@
 
 #pragma once
 
-#include <atomic>
-#include <memory>
+#include <mutex>
 #include <vector>
-
 #include "common/common_types.h"
 #include "common/multi_level_queue.h"
+#include "core/hle/kernel/object.h"
 #include "core/hle/kernel/thread.h"
 
 namespace Core {

src/core/hle/kernel/session.h

@@ -6,9 +6,9 @@
 
 #include <memory>
 #include <string>
-#include <utility>
 
 #include "core/hle/kernel/wait_object.h"
+#include "core/hle/result.h"
 
 namespace Kernel {
 

src/core/hle/kernel/shared_memory.h

@@ -6,6 +6,7 @@
 
 #include <memory>
 #include <string>
+#include <vector>
 
 #include "common/common_types.h"
 #include "core/hle/kernel/object.h"

src/core/hle/kernel/svc.cpp

@@ -1650,7 +1650,8 @@ static ResultCode WaitProcessWideKeyAtomic(Core::System& system, VAddr mutex_add
 }
 
 /// Signal process wide key
-static void SignalProcessWideKey(Core::System& system, VAddr condition_variable_addr, s32 target) {
+static ResultCode SignalProcessWideKey(Core::System& system, VAddr condition_variable_addr,
+                                       s32 target) {
     LOG_TRACE(Kernel_SVC, "called, condition_variable_addr=0x{:X}, target=0x{:08X}",
               condition_variable_addr, target);
 
@@ -1725,6 +1726,8 @@ static void SignalProcessWideKey(Core::System& system, VAddr condition_variable_
             system.PrepareReschedule(thread->GetProcessorID());
         }
     }
+
+    return RESULT_SUCCESS;
 }
 
 // Wait for an address (via Address Arbiter)
@@ -1778,17 +1781,6 @@ static ResultCode SignalToAddress(Core::System& system, VAddr address, u32 type,
     return address_arbiter.SignalToAddress(address, signal_type, value, num_to_wake);
 }
 
-static void KernelDebug([[maybe_unused]] Core::System& system,
-                        [[maybe_unused]] u32 kernel_debug_type, [[maybe_unused]] u64 param1,
-                        [[maybe_unused]] u64 param2, [[maybe_unused]] u64 param3) {
-    // Intentionally do nothing, as this does nothing in released kernel binaries.
-}
-
-static void ChangeKernelTraceState([[maybe_unused]] Core::System& system,
-                                   [[maybe_unused]] u32 trace_state) {
-    // Intentionally do nothing, as this does nothing in released kernel binaries.
-}
-
 /// This returns the total CPU ticks elapsed since the CPU was powered-on
 static u64 GetSystemTick(Core::System& system) {
     LOG_TRACE(Kernel_SVC, "called");
@@ -2426,8 +2418,8 @@ static const FunctionDef SVC_Table[] = {
     {0x39, nullptr, "Unknown"},
     {0x3A, nullptr, "Unknown"},
     {0x3B, nullptr, "Unknown"},
-    {0x3C, SvcWrap<KernelDebug>, "KernelDebug"},
-    {0x3D, SvcWrap<ChangeKernelTraceState>, "ChangeKernelTraceState"},
+    {0x3C, nullptr, "DumpInfo"},
+    {0x3D, nullptr, "DumpInfoNew"},
     {0x3E, nullptr, "Unknown"},
     {0x3F, nullptr, "Unknown"},
     {0x40, nullptr, "CreateSession"},

src/core/hle/kernel/svc_wrap.h

@@ -112,6 +112,11 @@ void SvcWrap(Core::System& system) {
     FuncReturn(system, retval);
 }
 
+template <ResultCode func(Core::System&, u64, s32)>
+void SvcWrap(Core::System& system) {
+    FuncReturn(system, func(system, Param(system, 0), static_cast<s32>(Param(system, 1))).raw);
+}
+
 template <ResultCode func(Core::System&, u64, u32)>
 void SvcWrap(Core::System& system) {
     FuncReturn(system, func(system, Param(system, 0), static_cast<u32>(Param(system, 1))).raw);
@@ -306,27 +311,11 @@ void SvcWrap(Core::System& system) {
     func(system);
 }
 
-template <void func(Core::System&, u32)>
-void SvcWrap(Core::System& system) {
-    func(system, static_cast<u32>(Param(system, 0)));
-}
-
-template <void func(Core::System&, u32, u64, u64, u64)>
-void SvcWrap(Core::System& system) {
-    func(system, static_cast<u32>(Param(system, 0)), Param(system, 1), Param(system, 2),
-         Param(system, 3));
-}
-
 template <void func(Core::System&, s64)>
 void SvcWrap(Core::System& system) {
     func(system, static_cast<s64>(Param(system, 0)));
 }
 
-template <void func(Core::System&, u64, s32)>
-void SvcWrap(Core::System& system) {
-    func(system, Param(system, 0), static_cast<s32>(Param(system, 1)));
-}
-
 template <void func(Core::System&, u64, u64)>
 void SvcWrap(Core::System& system) {
     func(system, Param(system, 0), Param(system, 1));

src/core/hle/kernel/transfer_memory.h

@@ -5,6 +5,7 @@
 #pragma once
 
 #include <memory>
+#include <vector>
 
 #include "core/hle/kernel/object.h"
 #include "core/hle/kernel/physical_memory.h"

src/core/hle/kernel/wait_object.h

@@ -4,9 +4,8 @@
 
 #pragma once
 
-#include <memory>
 #include <vector>
-
+#include <boost/smart_ptr/intrusive_ptr.hpp>
 #include "core/hle/kernel/object.h"
 
 namespace Kernel {

src/core/hle/kernel/writable_event.h

@@ -4,8 +4,6 @@
 
 #pragma once
 
-#include <memory>
-
 #include "core/hle/kernel/object.h"
 
 namespace Kernel {

src/video_core/engines/maxwell_3d.h

@@ -310,11 +310,6 @@ public:
             }
         };
 
-        enum class DepthMode : u32 {
-            MinusOneToOne = 0,
-            ZeroToOne = 1,
-        };
-
         enum class PrimitiveTopology : u32 {
             Points = 0x0,
             Lines = 0x1,
@@ -496,18 +491,6 @@ public:
             INSERT_UNION_PADDING_WORDS(1);
         };
 
-        enum class TessellationPrimitive : u32 {
-            Isolines = 0,
-            Triangles = 1,
-            Quads = 2,
-        };
-
-        enum class TessellationSpacing : u32 {
-            Equal = 0,
-            FractionalOdd = 1,
-            FractionalEven = 2,
-        };
-
         struct RenderTargetConfig {
             u32 address_high;
             u32 address_low;
@@ -645,19 +628,7 @@ public:
                     };
                 } sync_info;
 
-                INSERT_UNION_PADDING_WORDS(0x15);
-
-                union {
-                    BitField<0, 2, TessellationPrimitive> prim;
-                    BitField<4, 2, TessellationSpacing> spacing;
-                    BitField<8, 1, u32> cw;
-                    BitField<9, 1, u32> connected;
-                } tess_mode;
-
-                std::array<f32, 4> tess_level_outer;
-                std::array<f32, 2> tess_level_inner;
-
-                INSERT_UNION_PADDING_WORDS(0x102);
+                INSERT_UNION_PADDING_WORDS(0x11E);
 
                 u32 tfb_enabled;
 
@@ -676,7 +647,7 @@ public:
                     u32 count;
                 } vertex_buffer;
 
-                DepthMode depth_mode;
+                INSERT_UNION_PADDING_WORDS(1);
 
                 float clear_color[4];
                 float clear_depth;
@@ -691,9 +662,7 @@ public:
                 u32 polygon_offset_line_enable;
                 u32 polygon_offset_fill_enable;
 
-                u32 patch_vertices;
-
-                INSERT_UNION_PADDING_WORDS(0xC);
+                INSERT_UNION_PADDING_WORDS(0xD);
 
                 std::array<ScissorTest, NumViewports> scissor_test;
 
@@ -1417,22 +1386,17 @@ ASSERT_REG_POSITION(upload, 0x60);
 ASSERT_REG_POSITION(exec_upload, 0x6C);
 ASSERT_REG_POSITION(data_upload, 0x6D);
 ASSERT_REG_POSITION(sync_info, 0xB2);
-ASSERT_REG_POSITION(tess_mode, 0xC8);
-ASSERT_REG_POSITION(tess_level_outer, 0xC9);
-ASSERT_REG_POSITION(tess_level_inner, 0xCD);
 ASSERT_REG_POSITION(tfb_enabled, 0x1D1);
 ASSERT_REG_POSITION(rt, 0x200);
 ASSERT_REG_POSITION(viewport_transform, 0x280);
 ASSERT_REG_POSITION(viewports, 0x300);
 ASSERT_REG_POSITION(vertex_buffer, 0x35D);
-ASSERT_REG_POSITION(depth_mode, 0x35F);
 ASSERT_REG_POSITION(clear_color[0], 0x360);
 ASSERT_REG_POSITION(clear_depth, 0x364);
 ASSERT_REG_POSITION(clear_stencil, 0x368);
 ASSERT_REG_POSITION(polygon_offset_point_enable, 0x370);
 ASSERT_REG_POSITION(polygon_offset_line_enable, 0x371);
 ASSERT_REG_POSITION(polygon_offset_fill_enable, 0x372);
-ASSERT_REG_POSITION(patch_vertices, 0x373);
 ASSERT_REG_POSITION(scissor_test, 0x380);
 ASSERT_REG_POSITION(stencil_back_func_ref, 0x3D5);
 ASSERT_REG_POSITION(stencil_back_func_mask, 0x3D6);

src/video_core/engines/shader_bytecode.h

@@ -98,11 +98,10 @@ union Attribute {
         BitField<20, 10, u64> immediate;
         BitField<22, 2, u64> element;
         BitField<24, 6, Index> index;
-        BitField<31, 1, u64> patch;
         BitField<47, 3, AttributeSize> size;
 
         bool IsPhysical() const {
-            return patch == 0 && element == 0 && static_cast<u64>(index.Value()) == 0;
+            return element == 0 && static_cast<u64>(index.Value()) == 0;
         }
     } fmt20;
 
@@ -384,15 +383,6 @@ enum class IsberdMode : u64 {
 
 enum class IsberdShift : u64 { None = 0, U16 = 1, B32 = 2 };
 
-enum class MembarType : u64 {
-    CTA = 0,
-    GL = 1,
-    SYS = 2,
-    VC = 3,
-};
-
-enum class MembarUnknown : u64 { Default = 0, IVALLD = 1, IVALLT = 2, IVALLTD = 3 };
-
 enum class HalfType : u64 {
     H0_H1 = 0,
     F32 = 1,
@@ -809,12 +799,6 @@ union Instruction {
         BitField<40, 1, u64> invert;
     } popc;
 
-    union {
-        BitField<41, 1, u64> sh;
-        BitField<40, 1, u64> invert;
-        BitField<48, 1, u64> is_signed;
-    } flo;
-
     union {
         BitField<39, 3, u64> pred;
         BitField<42, 1, u64> neg_pred;
@@ -1455,26 +1439,6 @@ union Instruction {
         }
     } tlds;
 
-    union {
-        BitField<28, 1, u64> is_array;
-        BitField<29, 2, TextureType> texture_type;
-        BitField<35, 1, u64> aoffi_flag;
-        BitField<49, 1, u64> nodep_flag;
-
-        bool UsesMiscMode(TextureMiscMode mode) const {
-            switch (mode) {
-            case TextureMiscMode::AOFFI:
-                return aoffi_flag != 0;
-            case TextureMiscMode::NODEP:
-                return nodep_flag != 0;
-            default:
-                break;
-            }
-            return false;
-        }
-
-    } txd;
-
     union {
         BitField<24, 2, StoreCacheManagement> cache_management;
         BitField<33, 3, ImageType> image_type;
@@ -1554,11 +1518,6 @@ union Instruction {
         BitField<47, 2, IsberdShift> shift;
     } isberd;
 
-    union {
-        BitField<8, 2, MembarType> type;
-        BitField<0, 2, MembarUnknown> unknown;
-    } membar;
-
     union {
         BitField<48, 1, u64> signed_a;
         BitField<38, 1, u64> is_byte_chunk_a;
@@ -1673,8 +1632,6 @@ public:
         TLD4S,  // Texture Load 4 with scalar / non - vec4 source / destinations
         TMML_B, // Texture Mip Map Level
         TMML,   // Texture Mip Map Level
-        TXD,    // Texture Gradient/Load with Derivates
-        TXD_B,  // Texture Gradient/Load with Derivates Bindless
         SUST,   // Surface Store
         SULD,   // Surface Load
         SUATOM, // Surface Atomic Operation
@@ -1683,7 +1640,6 @@ public:
         IPA,
         OUT_R, // Emit vertex/primitive
         ISBERD,
-        MEMBAR,
         VMAD,
         VSETP,
         FFMA_IMM, // Fused Multiply and Add
@@ -1708,9 +1664,6 @@ public:
         ISCADD_C, // Scale and Add
         ISCADD_R,
         ISCADD_IMM,
-        FLO_R,
-        FLO_C,
-        FLO_IMM,
         LEA_R1,
         LEA_R2,
         LEA_RZ,
@@ -1774,10 +1727,6 @@ public:
         SHR_C,
         SHR_R,
         SHR_IMM,
-        SHF_RIGHT_R,
-        SHF_RIGHT_IMM,
-        SHF_LEFT_R,
-        SHF_LEFT_IMM,
         FMNMX_C,
         FMNMX_R,
         FMNMX_IMM,
@@ -1945,7 +1894,7 @@ private:
             INST("111000100100----", Id::BRA, Type::Flow, "BRA"),
             INST("111000100101----", Id::BRX, Type::Flow, "BRX"),
             INST("1111000011111---", Id::SYNC, Type::Flow, "SYNC"),
-            INST("111000110100----", Id::BRK, Type::Flow, "BRK"),
+            INST("111000110100---", Id::BRK, Type::Flow, "BRK"),
             INST("111000110000----", Id::EXIT, Type::Flow, "EXIT"),
             INST("1111000011110---", Id::DEPBAR, Type::Synch, "DEPBAR"),
             INST("0101000011011---", Id::VOTE, Type::Warp, "VOTE"),
@@ -1975,8 +1924,6 @@ private:
             INST("1101111100------", Id::TLD4S, Type::Texture, "TLD4S"),
             INST("110111110110----", Id::TMML_B, Type::Texture, "TMML_B"),
             INST("1101111101011---", Id::TMML, Type::Texture, "TMML"),
-            INST("11011110011110--", Id::TXD_B, Type::Texture, "TXD_B"),
-            INST("11011110001110--", Id::TXD, Type::Texture, "TXD"),
             INST("11101011001-----", Id::SUST, Type::Image, "SUST"),
             INST("11101011000-----", Id::SULD, Type::Image, "SULD"),
             INST("1110101000------", Id::SUATOM, Type::Image, "SUATOM_D"),
@@ -1984,7 +1931,6 @@ private:
             INST("11100000--------", Id::IPA, Type::Trivial, "IPA"),
             INST("1111101111100---", Id::OUT_R, Type::Trivial, "OUT_R"),
             INST("1110111111010---", Id::ISBERD, Type::Trivial, "ISBERD"),
-            INST("1110111110011---", Id::MEMBAR, Type::Trivial, "MEMBAR"),
             INST("01011111--------", Id::VMAD, Type::Video, "VMAD"),
             INST("0101000011110---", Id::VSETP, Type::Video, "VSETP"),
             INST("0011001-1-------", Id::FFMA_IMM, Type::Ffma, "FFMA_IMM"),
@@ -2019,9 +1965,6 @@ private:
             INST("010110110100----", Id::ICMP_R, Type::ArithmeticInteger, "ICMP_R"),
             INST("010010110100----", Id::ICMP_CR, Type::ArithmeticInteger, "ICMP_CR"),
             INST("0011011-0100----", Id::ICMP_IMM, Type::ArithmeticInteger, "ICMP_IMM"),
-            INST("0101110000110---", Id::FLO_R, Type::ArithmeticInteger, "FLO_R"),
-            INST("0100110000110---", Id::FLO_C, Type::ArithmeticInteger, "FLO_C"),
-            INST("0011100-00110---", Id::FLO_IMM, Type::ArithmeticInteger, "FLO_IMM"),
             INST("0101101111011---", Id::LEA_R2, Type::ArithmeticInteger, "LEA_R2"),
             INST("0101101111010---", Id::LEA_R1, Type::ArithmeticInteger, "LEA_R1"),
             INST("001101101101----", Id::LEA_IMM, Type::ArithmeticInteger, "LEA_IMM"),
@@ -2079,10 +2022,6 @@ private:
             INST("0100110000101---", Id::SHR_C, Type::Shift, "SHR_C"),
             INST("0101110000101---", Id::SHR_R, Type::Shift, "SHR_R"),
             INST("0011100-00101---", Id::SHR_IMM, Type::Shift, "SHR_IMM"),
-            INST("0101110011111---", Id::SHF_RIGHT_R, Type::Shift, "SHF_RIGHT_R"),
-            INST("0011100-11111---", Id::SHF_RIGHT_IMM, Type::Shift, "SHF_RIGHT_IMM"),
-            INST("0101101111111---", Id::SHF_LEFT_R, Type::Shift, "SHF_LEFT_R"),
-            INST("0011011-11111---", Id::SHF_LEFT_IMM, Type::Shift, "SHF_LEFT_IMM"),
             INST("0100110011100---", Id::I2I_C, Type::Conversion, "I2I_C"),
             INST("0101110011100---", Id::I2I_R, Type::Conversion, "I2I_R"),
             INST("0011101-11100---", Id::I2I_IMM, Type::Conversion, "I2I_IMM"),

src/video_core/gpu_thread.cpp

@@ -19,8 +19,7 @@ static void RunThread(VideoCore::RendererBase& renderer, Tegra::DmaPusher& dma_p
     MicroProfileOnThreadCreate("GpuThread");
 
     // Wait for first GPU command before acquiring the window context
-    while (state.queue.Empty())
-        ;
+    state.sync_event.Wait();
 
     // If emulation was stopped during disk shader loading, abort before trying to acquire context
     if (!state.is_running) {
@@ -31,22 +30,25 @@ static void RunThread(VideoCore::RendererBase& renderer, Tegra::DmaPusher& dma_p
 
     CommandDataContainer next;
     while (state.is_running) {
-        next = state.queue.PopWait();
-        if (const auto submit_list = std::get_if<SubmitListCommand>(&next.data)) {
-            dma_pusher.Push(std::move(submit_list->entries));
-            dma_pusher.DispatchCalls();
-        } else if (const auto data = std::get_if<SwapBuffersCommand>(&next.data)) {
-            renderer.SwapBuffers(data->framebuffer ? &*data->framebuffer : nullptr);
-        } else if (const auto data = std::get_if<FlushRegionCommand>(&next.data)) {
-            renderer.Rasterizer().FlushRegion(data->addr, data->size);
-        } else if (const auto data = std::get_if<InvalidateRegionCommand>(&next.data)) {
-            renderer.Rasterizer().InvalidateRegion(data->addr, data->size);
-        } else if (std::holds_alternative<EndProcessingCommand>(next.data)) {
-            return;
-        } else {
-            UNREACHABLE();
+        while (!state.queue.Empty()) {
+            state.queue.Pop(next);
+            if (const auto submit_list = std::get_if<SubmitListCommand>(&next.data)) {
+                dma_pusher.Push(std::move(submit_list->entries));
+                dma_pusher.DispatchCalls();
+            } else if (const auto data = std::get_if<SwapBuffersCommand>(&next.data)) {
+                renderer.SwapBuffers(data->framebuffer ? &*data->framebuffer : nullptr);
+            } else if (const auto data = std::get_if<FlushRegionCommand>(&next.data)) {
+                renderer.Rasterizer().FlushRegion(data->addr, data->size);
+            } else if (const auto data = std::get_if<InvalidateRegionCommand>(&next.data)) {
+                renderer.Rasterizer().InvalidateRegion(data->addr, data->size);
+            } else if (std::holds_alternative<EndProcessingCommand>(next.data)) {
+                return;
+            } else {
+                UNREACHABLE();
+            }
+            state.signaled_fence.store(next.fence);
         }
-        state.signaled_fence.store(next.fence);
+        state.sync_event.Wait();
     }
 }
 
@@ -95,6 +97,7 @@ void ThreadManager::WaitIdle() const {
 u64 ThreadManager::PushCommand(CommandData&& command_data) {
     const u64 fence{++state.last_fence};
     state.queue.Push(CommandDataContainer(std::move(command_data), fence));
+    state.sync_event.Set();
     return fence;
 }
 

src/video_core/gpu_thread.h

@@ -11,6 +11,7 @@
 #include <thread>
 #include <variant>
 
+#include "common/thread.h"
 #include "common/threadsafe_queue.h"
 #include "video_core/gpu.h"
 
@@ -90,6 +91,7 @@ struct SynchState final {
     CommandQueue queue;
     u64 last_fence{};
     std::atomic<u64> signaled_fence{};
+    Common::Event sync_event{};
 };
 
 /// Class used to manage the GPU thread

src/video_core/rasterizer_accelerated.cpp

@@ -5,7 +5,6 @@
 #include <mutex>
 
 #include <boost/icl/interval_map.hpp>
-#include <boost/range/iterator_range.hpp>
 
 #include "common/assert.h"
 #include "common/common_types.h"

src/video_core/renderer_opengl/gl_device.cpp

@@ -5,7 +5,6 @@
 #include <algorithm>
 #include <array>
 #include <cstddef>
-#include <cstring>
 #include <optional>
 #include <vector>
 
@@ -135,13 +134,11 @@ std::array<Device::BaseBindings, Tegra::Engines::MaxShaderTypes> BuildBaseBindin
 
 Device::Device() : base_bindings{BuildBaseBindings()} {
     const std::string_view vendor = reinterpret_cast<const char*>(glGetString(GL_VENDOR));
-    const auto renderer = reinterpret_cast<const char*>(glGetString(GL_RENDERER));
     const std::vector extensions = GetExtensions();
 
     const bool is_nvidia = vendor == "NVIDIA Corporation";
     const bool is_amd = vendor == "ATI Technologies Inc.";
     const bool is_intel = vendor == "Intel";
-    const bool is_intel_proprietary = is_intel && std::strstr(renderer, "Mesa") == nullptr;
 
     uniform_buffer_alignment = GetInteger<std::size_t>(GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT);
     shader_storage_alignment = GetInteger<std::size_t>(GL_SHADER_STORAGE_BUFFER_OFFSET_ALIGNMENT);
@@ -155,7 +152,7 @@ Device::Device() : base_bindings{BuildBaseBindings()} {
     has_variable_aoffi = TestVariableAoffi();
     has_component_indexing_bug = is_amd;
     has_precise_bug = TestPreciseBug();
-    has_broken_compute = is_intel_proprietary;
+    has_broken_compute = is_intel;
     has_fast_buffer_sub_data = is_nvidia;
 
     LOG_INFO(Render_OpenGL, "Renderer_VariableAOFFI: {}", has_variable_aoffi);

src/video_core/renderer_opengl/gl_rasterizer.cpp

@@ -277,14 +277,6 @@ void RasterizerOpenGL::SetupShaders(GLenum primitive_mode) {
             continue;
         }
 
-        // Currently this stages are not supported in the OpenGL backend.
-        // Todo(Blinkhawk): Port tesselation shaders from Vulkan to OpenGL
-        if (program == Maxwell::ShaderProgram::TesselationControl) {
-            continue;
-        } else if (program == Maxwell::ShaderProgram::TesselationEval) {
-            continue;
-        }
-
         Shader shader{shader_cache.GetStageProgram(program)};
 
         // Stage indices are 0 - 5
@@ -1036,10 +1028,6 @@ void RasterizerOpenGL::SyncViewport(OpenGLState& current_state) {
         flip_y = !flip_y;
     }
     state.clip_control.origin = flip_y ? GL_UPPER_LEFT : GL_LOWER_LEFT;
-    state.clip_control.depth_mode =
-        regs.depth_mode == Tegra::Engines::Maxwell3D::Regs::DepthMode::ZeroToOne
-            ? GL_ZERO_TO_ONE
-            : GL_NEGATIVE_ONE_TO_ONE;
 }
 
 void RasterizerOpenGL::SyncClipEnabled(

src/video_core/renderer_opengl/gl_shader_cache.cpp

@@ -281,11 +281,11 @@ CachedProgram BuildShader(const Device& device, u64 unique_identifier, ShaderTyp
         if (variant.shared_memory_size > 0) {
             // TODO(Rodrigo): We should divide by four here, but having a larger shared memory pool
             // avoids out of bound stores. Find out why shared memory size is being invalid.
-            source += fmt::format("shared uint smem[{}];\n", variant.shared_memory_size);
+            source += fmt::format("shared uint smem[{}];", variant.shared_memory_size);
         }
 
         if (variant.local_memory_size > 0) {
-            source += fmt::format("#define LOCAL_MEMORY_SIZE {}\n",
+            source += fmt::format("#define LOCAL_MEMORY_SIZE {}",
                                   Common::AlignUp(variant.local_memory_size, 4) / 4);
         }
     }

src/video_core/renderer_opengl/gl_shader_decompiler.cpp

@@ -49,9 +49,8 @@ class ExprDecompiler;
 enum class Type { Void, Bool, Bool2, Float, Int, Uint, HalfFloat };
 
 struct TextureAoffi {};
-struct TextureDerivates {};
 using TextureArgument = std::pair<Type, Node>;
-using TextureIR = std::variant<TextureAoffi, TextureDerivates, TextureArgument>;
+using TextureIR = std::variant<TextureAoffi, TextureArgument>;
 
 constexpr u32 MAX_CONSTBUFFER_ELEMENTS =
     static_cast<u32>(Maxwell::MaxConstBufferSize) / (4 * sizeof(float));
@@ -1113,8 +1112,6 @@ private:
                 expr += GenerateTextureArgument(*argument);
             } else if (std::holds_alternative<TextureAoffi>(variant)) {
                 expr += GenerateTextureAoffi(meta->aoffi);
-            } else if (std::holds_alternative<TextureDerivates>(variant)) {
-                expr += GenerateTextureDerivates(meta->derivates);
             } else {
                 UNREACHABLE();
             }
@@ -1184,36 +1181,6 @@ private:
         return expr;
     }
 
-    std::string GenerateTextureDerivates(const std::vector<Node>& derivates) {
-        if (derivates.empty()) {
-            return {};
-        }
-        constexpr std::array coord_constructors = {"float", "vec2", "vec3"};
-        std::string expr = ", ";
-        const std::size_t components = derivates.size() / 2;
-        std::string dx = coord_constructors.at(components - 1);
-        std::string dy = coord_constructors.at(components - 1);
-        dx += '(';
-        dy += '(';
-
-        for (std::size_t index = 0; index < components; ++index) {
-            const auto operand_x{derivates.at(index * 2)};
-            const auto operand_y{derivates.at(index * 2 + 1)};
-            dx += Visit(operand_x).AsFloat();
-            dy += Visit(operand_y).AsFloat();
-
-            if (index + 1 < components) {
-                dx += ", ";
-                dy += ", ";
-            }
-        }
-        dx += ')';
-        dy += ')';
-        expr += dx + ", " + dy;
-
-        return expr;
-    }
-
     std::string BuildIntegerCoordinates(Operation operation) {
         constexpr std::array constructors{"int(", "ivec2(", "ivec3(", "ivec4("};
         const std::size_t coords_count{operation.GetOperandsCount()};
@@ -1483,11 +1450,6 @@ private:
         return GenerateUnary(operation, "bitCount", type, type);
     }
 
-    template <Type type>
-    Expression BitMSB(Operation operation) {
-        return GenerateUnary(operation, "findMSB", type, type);
-    }
-
     Expression HNegate(Operation operation) {
         const auto GetNegate = [&](std::size_t index) {
             return VisitOperand(operation, index).AsBool() + " ? -1 : 1";
@@ -1776,14 +1738,6 @@ private:
         return {std::move(expr), Type::Float};
     }
 
-    Expression TextureGradient(Operation operation) {
-        const auto meta = std::get_if<MetaTexture>(&operation.GetMeta());
-        ASSERT(meta);
-
-        std::string expr = GenerateTexture(operation, "Grad", {TextureDerivates{}, TextureAoffi{}});
-        return {std::move(expr) + GetSwizzle(meta->element), Type::Float};
-    }
-
     Expression ImageLoad(Operation operation) {
         if (!device.HasImageLoadFormatted()) {
             LOG_ERROR(Render_OpenGL,
@@ -1915,10 +1869,6 @@ private:
         return {};
     }
 
-    Expression InvocationId(Operation operation) {
-        return {"gl_InvocationID", Type::Int};
-    }
-
     Expression YNegate(Operation operation) {
         return {"y_direction", Type::Float};
     }
@@ -1992,11 +1942,6 @@ private:
         return {fmt::format("readInvocationARB({}, {})", value, index), Type::Float};
     }
 
-    Expression MemoryBarrierGL(Operation) {
-        code.AddLine("memoryBarrier();");
-        return {};
-    }
-
     struct Func final {
         Func() = delete;
         ~Func() = delete;
@@ -2058,7 +2003,6 @@ private:
         &GLSLDecompiler::BitfieldInsert<Type::Int>,
         &GLSLDecompiler::BitfieldExtract<Type::Int>,
         &GLSLDecompiler::BitCount<Type::Int>,
-        &GLSLDecompiler::BitMSB<Type::Int>,
 
         &GLSLDecompiler::Add<Type::Uint>,
         &GLSLDecompiler::Mul<Type::Uint>,
@@ -2077,7 +2021,6 @@ private:
         &GLSLDecompiler::BitfieldInsert<Type::Uint>,
         &GLSLDecompiler::BitfieldExtract<Type::Uint>,
         &GLSLDecompiler::BitCount<Type::Uint>,
-        &GLSLDecompiler::BitMSB<Type::Uint>,
 
         &GLSLDecompiler::Add<Type::HalfFloat>,
         &GLSLDecompiler::Mul<Type::HalfFloat>,
@@ -2141,7 +2084,6 @@ private:
         &GLSLDecompiler::TextureQueryDimensions,
         &GLSLDecompiler::TextureQueryLod,
         &GLSLDecompiler::TexelFetch,
-        &GLSLDecompiler::TextureGradient,
 
         &GLSLDecompiler::ImageLoad,
         &GLSLDecompiler::ImageStore,
@@ -2162,7 +2104,6 @@ private:
         &GLSLDecompiler::EmitVertex,
         &GLSLDecompiler::EndPrimitive,
 
-        &GLSLDecompiler::InvocationId,
         &GLSLDecompiler::YNegate,
         &GLSLDecompiler::LocalInvocationId<0>,
         &GLSLDecompiler::LocalInvocationId<1>,
@@ -2178,8 +2119,6 @@ private:
 
         &GLSLDecompiler::ThreadId,
         &GLSLDecompiler::ShuffleIndexed,
-
-        &GLSLDecompiler::MemoryBarrierGL,
     };
     static_assert(operation_decompilers.size() == static_cast<std::size_t>(OperationCode::Amount));
 

src/video_core/renderer_opengl/gl_state.cpp

@@ -411,9 +411,8 @@ void OpenGLState::ApplyAlphaTest() {
 }
 
 void OpenGLState::ApplyClipControl() {
-    if (UpdateTie(std::tie(cur_state.clip_control.origin, cur_state.clip_control.depth_mode),
-                  std::tie(clip_control.origin, clip_control.depth_mode))) {
-        glClipControl(clip_control.origin, clip_control.depth_mode);
+    if (UpdateValue(cur_state.clip_control.origin, clip_control.origin)) {
+        glClipControl(clip_control.origin, GL_NEGATIVE_ONE_TO_ONE);
     }
 }
 

src/video_core/renderer_opengl/gl_state.h

@@ -150,7 +150,6 @@ public:
 
     struct {
         GLenum origin = GL_LOWER_LEFT;
-        GLenum depth_mode = GL_NEGATIVE_ONE_TO_ONE;
     } clip_control;
 
     OpenGLState();

src/video_core/renderer_vulkan/declarations.h

@@ -4,17 +4,6 @@
 
 #pragma once
 
-namespace vk {
-class DispatchLoaderDynamic;
-}
-
-namespace Vulkan {
-constexpr vk::DispatchLoaderDynamic* dont_use_me_dld = nullptr;
-}
-
-#define VULKAN_HPP_DEFAULT_DISPATCHER (*::Vulkan::dont_use_me_dld)
-#define VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL 0
-#define VULKAN_HPP_DISPATCH_LOADER_DYNAMIC 1
 #include <vulkan/vulkan.hpp>
 
 namespace Vulkan {
@@ -52,7 +41,5 @@ using UniqueSemaphore = UniqueHandle<vk::Semaphore>;
 using UniqueShaderModule = UniqueHandle<vk::ShaderModule>;
 using UniqueSwapchainKHR = UniqueHandle<vk::SwapchainKHR>;
 using UniqueValidationCacheEXT = UniqueHandle<vk::ValidationCacheEXT>;
-using UniqueDebugReportCallbackEXT = UniqueHandle<vk::DebugReportCallbackEXT>;
-using UniqueDebugUtilsMessengerEXT = UniqueHandle<vk::DebugUtilsMessengerEXT>;
 
 } // namespace Vulkan

src/video_core/renderer_vulkan/maxwell_to_vk.cpp

@@ -44,8 +44,7 @@ vk::SamplerMipmapMode MipmapMode(Tegra::Texture::TextureMipmapFilter mipmap_filt
     return {};
 }
 
-vk::SamplerAddressMode WrapMode(Tegra::Texture::WrapMode wrap_mode,
-                                Tegra::Texture::TextureFilter filter) {
+vk::SamplerAddressMode WrapMode(Tegra::Texture::WrapMode wrap_mode) {
     switch (wrap_mode) {
     case Tegra::Texture::WrapMode::Wrap:
         return vk::SamplerAddressMode::eRepeat;
@@ -56,15 +55,10 @@ vk::SamplerAddressMode WrapMode(Tegra::Texture::WrapMode wrap_mode,
     case Tegra::Texture::WrapMode::Border:
         return vk::SamplerAddressMode::eClampToBorder;
     case Tegra::Texture::WrapMode::Clamp:
-        // TODO(Rodrigo): Emulate GL_CLAMP properly
-        switch (filter) {
-        case Tegra::Texture::TextureFilter::Nearest:
-            return vk::SamplerAddressMode::eClampToEdge;
-        case Tegra::Texture::TextureFilter::Linear:
-            return vk::SamplerAddressMode::eClampToBorder;
-        }
-        UNREACHABLE();
-        return vk::SamplerAddressMode::eClampToEdge;
+        // TODO(Rodrigo): GL_CLAMP was removed as of OpenGL 3.1, to implement GL_CLAMP, we can use
+        // eClampToBorder to get the border color of the texture, and then sample the edge to
+        // manually mix them. However the shader part of this is not yet implemented.
+        return vk::SamplerAddressMode::eClampToBorder;
     case Tegra::Texture::WrapMode::MirrorOnceClampToEdge:
         return vk::SamplerAddressMode::eMirrorClampToEdge;
     case Tegra::Texture::WrapMode::MirrorOnceBorder:
@@ -102,140 +96,106 @@ vk::CompareOp DepthCompareFunction(Tegra::Texture::DepthCompareFunc depth_compar
 
 } // namespace Sampler
 
-namespace {
-
-enum : u32 { Attachable = 1, Storage = 2 };
-
 struct FormatTuple {
     vk::Format format; ///< Vulkan format
-    int usage;         ///< Describes image format usage
-} constexpr tex_format_tuples[] = {
-    {vk::Format::eA8B8G8R8UnormPack32, Attachable | Storage},    // ABGR8U
-    {vk::Format::eA8B8G8R8SnormPack32, Attachable | Storage},    // ABGR8S
-    {vk::Format::eA8B8G8R8UintPack32, Attachable | Storage},     // ABGR8UI
-    {vk::Format::eB5G6R5UnormPack16, {}},                        // B5G6R5U
-    {vk::Format::eA2B10G10R10UnormPack32, Attachable | Storage}, // A2B10G10R10U
-    {vk::Format::eA1R5G5B5UnormPack16, Attachable | Storage},    // A1B5G5R5U (flipped with swizzle)
-    {vk::Format::eR8Unorm, Attachable | Storage},                // R8U
-    {vk::Format::eR8Uint, Attachable | Storage},                 // R8UI
-    {vk::Format::eR16G16B16A16Sfloat, Attachable | Storage},     // RGBA16F
-    {vk::Format::eR16G16B16A16Unorm, Attachable | Storage},      // RGBA16U
-    {vk::Format::eR16G16B16A16Uint, Attachable | Storage},       // RGBA16UI
-    {vk::Format::eB10G11R11UfloatPack32, Attachable | Storage},  // R11FG11FB10F
-    {vk::Format::eR32G32B32A32Uint, Attachable | Storage},       // RGBA32UI
-    {vk::Format::eBc1RgbaUnormBlock, {}},                        // DXT1
-    {vk::Format::eBc2UnormBlock, {}},                            // DXT23
-    {vk::Format::eBc3UnormBlock, {}},                            // DXT45
-    {vk::Format::eBc4UnormBlock, {}},                            // DXN1
-    {vk::Format::eBc5UnormBlock, {}},                            // DXN2UNORM
-    {vk::Format::eBc5SnormBlock, {}},                            // DXN2SNORM
-    {vk::Format::eBc7UnormBlock, {}},                            // BC7U
-    {vk::Format::eBc6HUfloatBlock, {}},                          // BC6H_UF16
-    {vk::Format::eBc6HSfloatBlock, {}},                          // BC6H_SF16
-    {vk::Format::eAstc4x4UnormBlock, {}},                        // ASTC_2D_4X4
-    {vk::Format::eB8G8R8A8Unorm, {}},                            // BGRA8
-    {vk::Format::eR32G32B32A32Sfloat, Attachable | Storage},     // RGBA32F
-    {vk::Format::eR32G32Sfloat, Attachable | Storage},           // RG32F
-    {vk::Format::eR32Sfloat, Attachable | Storage},              // R32F
-    {vk::Format::eR16Sfloat, Attachable | Storage},              // R16F
-    {vk::Format::eR16Unorm, Attachable | Storage},               // R16U
-    {vk::Format::eUndefined, {}},                                // R16S
-    {vk::Format::eUndefined, {}},                                // R16UI
-    {vk::Format::eUndefined, {}},                                // R16I
-    {vk::Format::eR16G16Unorm, Attachable | Storage},            // RG16
-    {vk::Format::eR16G16Sfloat, Attachable | Storage},           // RG16F
-    {vk::Format::eUndefined, {}},                                // RG16UI
-    {vk::Format::eUndefined, {}},                                // RG16I
-    {vk::Format::eR16G16Snorm, Attachable | Storage},            // RG16S
-    {vk::Format::eUndefined, {}},                                // RGB32F
-    {vk::Format::eR8G8B8A8Srgb, Attachable},                     // RGBA8_SRGB
-    {vk::Format::eR8G8Unorm, Attachable | Storage},              // RG8U
-    {vk::Format::eR8G8Snorm, Attachable | Storage},              // RG8S
-    {vk::Format::eR32G32Uint, Attachable | Storage},             // RG32UI
-    {vk::Format::eUndefined, {}},                                // RGBX16F
-    {vk::Format::eR32Uint, Attachable | Storage},                // R32UI
-    {vk::Format::eAstc8x8UnormBlock, {}},                        // ASTC_2D_8X8
-    {vk::Format::eUndefined, {}},                                // ASTC_2D_8X5
-    {vk::Format::eUndefined, {}},                                // ASTC_2D_5X4
-    {vk::Format::eUndefined, {}},                                // BGRA8_SRGB
-    {vk::Format::eBc1RgbaSrgbBlock, {}},                         // DXT1_SRGB
-    {vk::Format::eUndefined, {}},                                // DXT23_SRGB
-    {vk::Format::eBc3SrgbBlock, {}},                             // DXT45_SRGB
-    {vk::Format::eBc7SrgbBlock, {}},                             // BC7U_SRGB
-    {vk::Format::eR4G4B4A4UnormPack16, Attachable},              // R4G4B4A4U
-    {vk::Format::eAstc4x4SrgbBlock, {}},                         // ASTC_2D_4X4_SRGB
-    {vk::Format::eAstc8x8SrgbBlock, {}},                         // ASTC_2D_8X8_SRGB
-    {vk::Format::eAstc8x5SrgbBlock, {}},                         // ASTC_2D_8X5_SRGB
-    {vk::Format::eAstc5x4SrgbBlock, {}},                         // ASTC_2D_5X4_SRGB
-    {vk::Format::eAstc5x5UnormBlock, {}},                        // ASTC_2D_5X5
-    {vk::Format::eAstc5x5SrgbBlock, {}},                         // ASTC_2D_5X5_SRGB
-    {vk::Format::eAstc10x8UnormBlock, {}},                       // ASTC_2D_10X8
-    {vk::Format::eAstc10x8SrgbBlock, {}},                        // ASTC_2D_10X8_SRGB
-    {vk::Format::eAstc6x6UnormBlock, {}},                        // ASTC_2D_6X6
-    {vk::Format::eAstc6x6SrgbBlock, {}},                         // ASTC_2D_6X6_SRGB
-    {vk::Format::eAstc10x10UnormBlock, {}},                      // ASTC_2D_10X10
-    {vk::Format::eAstc10x10SrgbBlock, {}},                       // ASTC_2D_10X10_SRGB
-    {vk::Format::eAstc12x12UnormBlock, {}},                      // ASTC_2D_12X12
-    {vk::Format::eAstc12x12SrgbBlock, {}},                       // ASTC_2D_12X12_SRGB
-    {vk::Format::eAstc8x6UnormBlock, {}},                        // ASTC_2D_8X6
-    {vk::Format::eAstc8x6SrgbBlock, {}},                         // ASTC_2D_8X6_SRGB
-    {vk::Format::eAstc6x5UnormBlock, {}},                        // ASTC_2D_6X5
-    {vk::Format::eAstc6x5SrgbBlock, {}},                         // ASTC_2D_6X5_SRGB
-    {vk::Format::eE5B9G9R9UfloatPack32, {}},                     // E5B9G9R9F
+    bool attachable;   ///< True when this format can be used as an attachment
+};
+
+static constexpr std::array<FormatTuple, VideoCore::Surface::MaxPixelFormat> tex_format_tuples = {{
+    {vk::Format::eA8B8G8R8UnormPack32, true},    // ABGR8U
+    {vk::Format::eUndefined, false},             // ABGR8S
+    {vk::Format::eUndefined, false},             // ABGR8UI
+    {vk::Format::eB5G6R5UnormPack16, false},     // B5G6R5U
+    {vk::Format::eA2B10G10R10UnormPack32, true}, // A2B10G10R10U
+    {vk::Format::eUndefined, false},             // A1B5G5R5U
+    {vk::Format::eR8Unorm, true},                // R8U
+    {vk::Format::eUndefined, false},             // R8UI
+    {vk::Format::eUndefined, false},             // RGBA16F
+    {vk::Format::eUndefined, false},             // RGBA16U
+    {vk::Format::eUndefined, false},             // RGBA16UI
+    {vk::Format::eUndefined, false},             // R11FG11FB10F
+    {vk::Format::eUndefined, false},             // RGBA32UI
+    {vk::Format::eBc1RgbaUnormBlock, false},     // DXT1
+    {vk::Format::eBc2UnormBlock, false},         // DXT23
+    {vk::Format::eBc3UnormBlock, false},         // DXT45
+    {vk::Format::eBc4UnormBlock, false},         // DXN1
+    {vk::Format::eUndefined, false},             // DXN2UNORM
+    {vk::Format::eUndefined, false},             // DXN2SNORM
+    {vk::Format::eUndefined, false},             // BC7U
+    {vk::Format::eUndefined, false},             // BC6H_UF16
+    {vk::Format::eUndefined, false},             // BC6H_SF16
+    {vk::Format::eUndefined, false},             // ASTC_2D_4X4
+    {vk::Format::eUndefined, false},             // BGRA8
+    {vk::Format::eUndefined, false},             // RGBA32F
+    {vk::Format::eUndefined, false},             // RG32F
+    {vk::Format::eUndefined, false},             // R32F
+    {vk::Format::eUndefined, false},             // R16F
+    {vk::Format::eUndefined, false},             // R16U
+    {vk::Format::eUndefined, false},             // R16S
+    {vk::Format::eUndefined, false},             // R16UI
+    {vk::Format::eUndefined, false},             // R16I
+    {vk::Format::eUndefined, false},             // RG16
+    {vk::Format::eUndefined, false},             // RG16F
+    {vk::Format::eUndefined, false},             // RG16UI
+    {vk::Format::eUndefined, false},             // RG16I
+    {vk::Format::eUndefined, false},             // RG16S
+    {vk::Format::eUndefined, false},             // RGB32F
+    {vk::Format::eA8B8G8R8SrgbPack32, true},     // RGBA8_SRGB
+    {vk::Format::eUndefined, false},             // RG8U
+    {vk::Format::eUndefined, false},             // RG8S
+    {vk::Format::eUndefined, false},             // RG32UI
+    {vk::Format::eUndefined, false},             // RGBX16F
+    {vk::Format::eUndefined, false},             // R32UI
+    {vk::Format::eUndefined, false},             // ASTC_2D_8X8
+    {vk::Format::eUndefined, false},             // ASTC_2D_8X5
+    {vk::Format::eUndefined, false},             // ASTC_2D_5X4
+
+    // Compressed sRGB formats
+    {vk::Format::eUndefined, false}, // BGRA8_SRGB
+    {vk::Format::eUndefined, false}, // DXT1_SRGB
+    {vk::Format::eUndefined, false}, // DXT23_SRGB
+    {vk::Format::eUndefined, false}, // DXT45_SRGB
+    {vk::Format::eUndefined, false}, // BC7U_SRGB
+    {vk::Format::eUndefined, false}, // ASTC_2D_4X4_SRGB
+    {vk::Format::eUndefined, false}, // ASTC_2D_8X8_SRGB
+    {vk::Format::eUndefined, false}, // ASTC_2D_8X5_SRGB
+    {vk::Format::eUndefined, false}, // ASTC_2D_5X4_SRGB
+    {vk::Format::eUndefined, false}, // ASTC_2D_5X5
+    {vk::Format::eUndefined, false}, // ASTC_2D_5X5_SRGB
+    {vk::Format::eUndefined, false}, // ASTC_2D_10X8
+    {vk::Format::eUndefined, false}, // ASTC_2D_10X8_SRGB
 
     // Depth formats
-    {vk::Format::eD32Sfloat, Attachable}, // Z32F
-    {vk::Format::eD16Unorm, Attachable},  // Z16
+    {vk::Format::eD32Sfloat, true}, // Z32F
+    {vk::Format::eD16Unorm, true},  // Z16
 
     // DepthStencil formats
-    {vk::Format::eD24UnormS8Uint, Attachable},  // Z24S8
-    {vk::Format::eD24UnormS8Uint, Attachable},  // S8Z24 (emulated)
-    {vk::Format::eD32SfloatS8Uint, Attachable}, // Z32FS8
-};
-static_assert(std::size(tex_format_tuples) == VideoCore::Surface::MaxPixelFormat);
+    {vk::Format::eD24UnormS8Uint, true}, // Z24S8
+    {vk::Format::eD24UnormS8Uint, true}, // S8Z24 (emulated)
+    {vk::Format::eUndefined, false},     // Z32FS8
+}};
 
-constexpr bool IsZetaFormat(PixelFormat pixel_format) {
+static constexpr bool IsZetaFormat(PixelFormat pixel_format) {
     return pixel_format >= PixelFormat::MaxColorFormat &&
            pixel_format < PixelFormat::MaxDepthStencilFormat;
 }
 
-} // Anonymous namespace
+std::pair<vk::Format, bool> SurfaceFormat(const VKDevice& device, FormatType format_type,
+                                          PixelFormat pixel_format) {
+    ASSERT(static_cast<std::size_t>(pixel_format) < tex_format_tuples.size());
 
-FormatInfo SurfaceFormat(const VKDevice& device, FormatType format_type, PixelFormat pixel_format) {
-    ASSERT(static_cast<std::size_t>(pixel_format) < std::size(tex_format_tuples));
+    const auto tuple = tex_format_tuples[static_cast<u32>(pixel_format)];
+    UNIMPLEMENTED_IF_MSG(tuple.format == vk::Format::eUndefined,
+                         "Unimplemented texture format with pixel format={}",
+                         static_cast<u32>(pixel_format));
 
-    auto tuple = tex_format_tuples[static_cast<std::size_t>(pixel_format)];
-    if (tuple.format == vk::Format::eUndefined) {
-        UNIMPLEMENTED_MSG("Unimplemented texture format with pixel format={}",
-                          static_cast<u32>(pixel_format));
-        return {vk::Format::eA8B8G8R8UnormPack32, true, true};
+    auto usage = vk::FormatFeatureFlagBits::eSampledImage |
+                 vk::FormatFeatureFlagBits::eTransferDst | vk::FormatFeatureFlagBits::eTransferSrc;
+    if (tuple.attachable) {
+        usage |= IsZetaFormat(pixel_format) ? vk::FormatFeatureFlagBits::eDepthStencilAttachment
+                                            : vk::FormatFeatureFlagBits::eColorAttachment;
     }
-
-    // Use ABGR8 on hardware that doesn't support ASTC natively
-    if (!device.IsOptimalAstcSupported() && VideoCore::Surface::IsPixelFormatASTC(pixel_format)) {
-        tuple.format = VideoCore::Surface::IsPixelFormatSRGB(pixel_format)
-                           ? vk::Format::eA8B8G8R8SrgbPack32
-                           : vk::Format::eA8B8G8R8UnormPack32;
-    }
-    const bool attachable = tuple.usage & Attachable;
-    const bool storage = tuple.usage & Storage;
-
-    vk::FormatFeatureFlags usage;
-    if (format_type == FormatType::Buffer) {
-        usage = vk::FormatFeatureFlagBits::eStorageTexelBuffer |
-                vk::FormatFeatureFlagBits::eUniformTexelBuffer;
-    } else {
-        usage = vk::FormatFeatureFlagBits::eSampledImage | vk::FormatFeatureFlagBits::eTransferDst |
-                vk::FormatFeatureFlagBits::eTransferSrc;
-        if (attachable) {
-            usage |= IsZetaFormat(pixel_format) ? vk::FormatFeatureFlagBits::eDepthStencilAttachment
-                                                : vk::FormatFeatureFlagBits::eColorAttachment;
-        }
-        if (storage) {
-            usage |= vk::FormatFeatureFlagBits::eStorageImage;
-        }
-    }
-    return {device.GetSupportedFormat(tuple.format, usage, format_type), attachable, storage};
+    return {device.GetSupportedFormat(tuple.format, usage, format_type), tuple.attachable};
 }
 
 vk::ShaderStageFlagBits ShaderStage(Tegra::Engines::ShaderType stage) {
@@ -255,8 +215,7 @@ vk::ShaderStageFlagBits ShaderStage(Tegra::Engines::ShaderType stage) {
     return {};
 }
 
-vk::PrimitiveTopology PrimitiveTopology([[maybe_unused]] const VKDevice& device,
-                                        Maxwell::PrimitiveTopology topology) {
+vk::PrimitiveTopology PrimitiveTopology(Maxwell::PrimitiveTopology topology) {
     switch (topology) {
     case Maxwell::PrimitiveTopology::Points:
         return vk::PrimitiveTopology::ePointList;
@@ -268,13 +227,6 @@ vk::PrimitiveTopology PrimitiveTopology([[maybe_unused]] const VKDevice& device,
         return vk::PrimitiveTopology::eTriangleList;
     case Maxwell::PrimitiveTopology::TriangleStrip:
         return vk::PrimitiveTopology::eTriangleStrip;
-    case Maxwell::PrimitiveTopology::TriangleFan:
-        return vk::PrimitiveTopology::eTriangleFan;
-    case Maxwell::PrimitiveTopology::Quads:
-        // TODO(Rodrigo): Use VK_PRIMITIVE_TOPOLOGY_QUAD_LIST_EXT whenever it releases
-        return vk::PrimitiveTopology::eTriangleList;
-    case Maxwell::PrimitiveTopology::Patches:
-        return vk::PrimitiveTopology::ePatchList;
     default:
         UNIMPLEMENTED_MSG("Unimplemented topology={}", static_cast<u32>(topology));
         return {};
@@ -284,111 +236,37 @@ vk::PrimitiveTopology PrimitiveTopology([[maybe_unused]] const VKDevice& device,
 vk::Format VertexFormat(Maxwell::VertexAttribute::Type type, Maxwell::VertexAttribute::Size size) {
     switch (type) {
     case Maxwell::VertexAttribute::Type::SignedNorm:
-        switch (size) {
-        case Maxwell::VertexAttribute::Size::Size_8:
-            return vk::Format::eR8Snorm;
-        case Maxwell::VertexAttribute::Size::Size_8_8:
-            return vk::Format::eR8G8Snorm;
-        case Maxwell::VertexAttribute::Size::Size_8_8_8:
-            return vk::Format::eR8G8B8Snorm;
-        case Maxwell::VertexAttribute::Size::Size_8_8_8_8:
-            return vk::Format::eR8G8B8A8Snorm;
-        case Maxwell::VertexAttribute::Size::Size_16:
-            return vk::Format::eR16Snorm;
-        case Maxwell::VertexAttribute::Size::Size_16_16:
-            return vk::Format::eR16G16Snorm;
-        case Maxwell::VertexAttribute::Size::Size_16_16_16:
-            return vk::Format::eR16G16B16Snorm;
-        case Maxwell::VertexAttribute::Size::Size_16_16_16_16:
-            return vk::Format::eR16G16B16A16Snorm;
-        case Maxwell::VertexAttribute::Size::Size_10_10_10_2:
-            return vk::Format::eA2B10G10R10SnormPack32;
-        default:
-            break;
-        }
         break;
     case Maxwell::VertexAttribute::Type::UnsignedNorm:
         switch (size) {
-        case Maxwell::VertexAttribute::Size::Size_8:
-            return vk::Format::eR8Unorm;
-        case Maxwell::VertexAttribute::Size::Size_8_8:
-            return vk::Format::eR8G8Unorm;
-        case Maxwell::VertexAttribute::Size::Size_8_8_8:
-            return vk::Format::eR8G8B8Unorm;
         case Maxwell::VertexAttribute::Size::Size_8_8_8_8:
             return vk::Format::eR8G8B8A8Unorm;
-        case Maxwell::VertexAttribute::Size::Size_16:
-            return vk::Format::eR16Unorm;
-        case Maxwell::VertexAttribute::Size::Size_16_16:
-            return vk::Format::eR16G16Unorm;
-        case Maxwell::VertexAttribute::Size::Size_16_16_16:
-            return vk::Format::eR16G16B16Unorm;
-        case Maxwell::VertexAttribute::Size::Size_16_16_16_16:
-            return vk::Format::eR16G16B16A16Unorm;
         default:
             break;
         }
         break;
     case Maxwell::VertexAttribute::Type::SignedInt:
-        switch (size) {
-        case Maxwell::VertexAttribute::Size::Size_16_16_16_16:
-            return vk::Format::eR16G16B16A16Sint;
-        case Maxwell::VertexAttribute::Size::Size_8:
-            return vk::Format::eR8Sint;
-        case Maxwell::VertexAttribute::Size::Size_8_8:
-            return vk::Format::eR8G8Sint;
-        case Maxwell::VertexAttribute::Size::Size_8_8_8:
-            return vk::Format::eR8G8B8Sint;
-        case Maxwell::VertexAttribute::Size::Size_8_8_8_8:
-            return vk::Format::eR8G8B8A8Sint;
-        case Maxwell::VertexAttribute::Size::Size_32:
-            return vk::Format::eR32Sint;
-        default:
-            break;
-        }
+        break;
     case Maxwell::VertexAttribute::Type::UnsignedInt:
         switch (size) {
-        case Maxwell::VertexAttribute::Size::Size_8:
-            return vk::Format::eR8Uint;
-        case Maxwell::VertexAttribute::Size::Size_8_8:
-            return vk::Format::eR8G8Uint;
-        case Maxwell::VertexAttribute::Size::Size_8_8_8:
-            return vk::Format::eR8G8B8Uint;
-        case Maxwell::VertexAttribute::Size::Size_8_8_8_8:
-            return vk::Format::eR8G8B8A8Uint;
         case Maxwell::VertexAttribute::Size::Size_32:
             return vk::Format::eR32Uint;
         default:
             break;
         }
     case Maxwell::VertexAttribute::Type::UnsignedScaled:
-        switch (size) {
-        case Maxwell::VertexAttribute::Size::Size_8_8:
-            return vk::Format::eR8G8Uscaled;
-        default:
-            break;
-        }
-        break;
     case Maxwell::VertexAttribute::Type::SignedScaled:
         break;
     case Maxwell::VertexAttribute::Type::Float:
         switch (size) {
-        case Maxwell::VertexAttribute::Size::Size_32:
-            return vk::Format::eR32Sfloat;
-        case Maxwell::VertexAttribute::Size::Size_32_32:
-            return vk::Format::eR32G32Sfloat;
-        case Maxwell::VertexAttribute::Size::Size_32_32_32:
-            return vk::Format::eR32G32B32Sfloat;
         case Maxwell::VertexAttribute::Size::Size_32_32_32_32:
             return vk::Format::eR32G32B32A32Sfloat;
-        case Maxwell::VertexAttribute::Size::Size_16:
-            return vk::Format::eR16Sfloat;
-        case Maxwell::VertexAttribute::Size::Size_16_16:
-            return vk::Format::eR16G16Sfloat;
-        case Maxwell::VertexAttribute::Size::Size_16_16_16:
-            return vk::Format::eR16G16B16Sfloat;
-        case Maxwell::VertexAttribute::Size::Size_16_16_16_16:
-            return vk::Format::eR16G16B16A16Sfloat;
+        case Maxwell::VertexAttribute::Size::Size_32_32_32:
+            return vk::Format::eR32G32B32Sfloat;
+        case Maxwell::VertexAttribute::Size::Size_32_32:
+            return vk::Format::eR32G32Sfloat;
+        case Maxwell::VertexAttribute::Size::Size_32:
+            return vk::Format::eR32Sfloat;
         default:
             break;
         }
@@ -430,14 +308,11 @@ vk::CompareOp ComparisonOp(Maxwell::ComparisonOp comparison) {
     return {};
 }
 
-vk::IndexType IndexFormat(const VKDevice& device, Maxwell::IndexFormat index_format) {
+vk::IndexType IndexFormat(Maxwell::IndexFormat index_format) {
     switch (index_format) {
     case Maxwell::IndexFormat::UnsignedByte:
-        if (!device.IsExtIndexTypeUint8Supported()) {
-            UNIMPLEMENTED_MSG("Native uint8 indices are not supported on this device");
-            return vk::IndexType::eUint16;
-        }
-        return vk::IndexType::eUint8EXT;
+        UNIMPLEMENTED_MSG("Vulkan does not support native u8 index format");
+        return vk::IndexType::eUint16;
     case Maxwell::IndexFormat::UnsignedShort:
         return vk::IndexType::eUint16;
     case Maxwell::IndexFormat::UnsignedInt:

src/video_core/renderer_vulkan/maxwell_to_vk.h

@@ -4,6 +4,7 @@
 
 #pragma once
 
+#include <utility>
 #include "common/common_types.h"
 #include "video_core/engines/maxwell_3d.h"
 #include "video_core/renderer_vulkan/declarations.h"
@@ -22,31 +23,24 @@ vk::Filter Filter(Tegra::Texture::TextureFilter filter);
 
 vk::SamplerMipmapMode MipmapMode(Tegra::Texture::TextureMipmapFilter mipmap_filter);
 
-vk::SamplerAddressMode WrapMode(Tegra::Texture::WrapMode wrap_mode,
-                                Tegra::Texture::TextureFilter filter);
+vk::SamplerAddressMode WrapMode(Tegra::Texture::WrapMode wrap_mode);
 
 vk::CompareOp DepthCompareFunction(Tegra::Texture::DepthCompareFunc depth_compare_func);
 
 } // namespace Sampler
 
-struct FormatInfo {
-    vk::Format format;
-    bool attachable;
-    bool storage;
-};
-
-FormatInfo SurfaceFormat(const VKDevice& device, FormatType format_type, PixelFormat pixel_format);
+std::pair<vk::Format, bool> SurfaceFormat(const VKDevice& device, FormatType format_type,
+                                          PixelFormat pixel_format);
 
 vk::ShaderStageFlagBits ShaderStage(Tegra::Engines::ShaderType stage);
 
-vk::PrimitiveTopology PrimitiveTopology(const VKDevice& device,
-                                        Maxwell::PrimitiveTopology topology);
+vk::PrimitiveTopology PrimitiveTopology(Maxwell::PrimitiveTopology topology);
 
 vk::Format VertexFormat(Maxwell::VertexAttribute::Type type, Maxwell::VertexAttribute::Size size);
 
 vk::CompareOp ComparisonOp(Maxwell::ComparisonOp comparison);
 
-vk::IndexType IndexFormat(const VKDevice& device, Maxwell::IndexFormat index_format);
+vk::IndexType IndexFormat(Maxwell::IndexFormat index_format);
 
 vk::StencilOp StencilOp(Maxwell::StencilOp stencil_op);
 

src/video_core/renderer_vulkan/vk_device.cpp

@@ -3,7 +3,6 @@
 // Refer to the license.txt file included.
 
 #include <bitset>
-#include <cstdlib>
 #include <optional>
 #include <set>
 #include <string_view>
@@ -16,15 +15,6 @@ namespace Vulkan {
 
 namespace {
 
-namespace Alternatives {
-
-constexpr std::array Depth24UnormS8Uint = {vk::Format::eD32SfloatS8Uint,
-                                           vk::Format::eD16UnormS8Uint, vk::Format{}};
-constexpr std::array Depth16UnormS8Uint = {vk::Format::eD24UnormS8Uint,
-                                           vk::Format::eD32SfloatS8Uint, vk::Format{}};
-
-} // namespace Alternatives
-
 template <typename T>
 void SetNext(void**& next, T& data) {
     *next = &data;
@@ -32,7 +22,7 @@ void SetNext(void**& next, T& data) {
 }
 
 template <typename T>
-T GetFeatures(vk::PhysicalDevice physical, const vk::DispatchLoaderDynamic& dldi) {
+T GetFeatures(vk::PhysicalDevice physical, vk::DispatchLoaderDynamic dldi) {
     vk::PhysicalDeviceFeatures2 features;
     T extension_features;
     features.pNext = &extension_features;
@@ -40,14 +30,17 @@ T GetFeatures(vk::PhysicalDevice physical, const vk::DispatchLoaderDynamic& dldi
     return extension_features;
 }
 
-template <typename T>
-T GetProperties(vk::PhysicalDevice physical, const vk::DispatchLoaderDynamic& dldi) {
-    vk::PhysicalDeviceProperties2 properties;
-    T extension_properties;
-    properties.pNext = &extension_properties;
-    physical.getProperties2(&properties, dldi);
-    return extension_properties;
-}
+} // Anonymous namespace
+
+namespace Alternatives {
+
+constexpr std::array Depth24UnormS8Uint = {vk::Format::eD32SfloatS8Uint,
+                                           vk::Format::eD16UnormS8Uint, vk::Format{}};
+constexpr std::array Depth16UnormS8Uint = {vk::Format::eD24UnormS8Uint,
+                                           vk::Format::eD32SfloatS8Uint, vk::Format{}};
+constexpr std::array Astc = {vk::Format::eA8B8G8R8UnormPack32, vk::Format{}};
+
+} // namespace Alternatives
 
 constexpr const vk::Format* GetFormatAlternatives(vk::Format format) {
     switch (format) {
@@ -60,7 +53,8 @@ constexpr const vk::Format* GetFormatAlternatives(vk::Format format) {
     }
 }
 
-vk::FormatFeatureFlags GetFormatFeatures(vk::FormatProperties properties, FormatType format_type) {
+constexpr vk::FormatFeatureFlags GetFormatFeatures(vk::FormatProperties properties,
+                                                   FormatType format_type) {
     switch (format_type) {
     case FormatType::Linear:
         return properties.linearTilingFeatures;
@@ -73,13 +67,11 @@ vk::FormatFeatureFlags GetFormatFeatures(vk::FormatProperties properties, Format
     }
 }
 
-} // Anonymous namespace
-
 VKDevice::VKDevice(const vk::DispatchLoaderDynamic& dldi, vk::PhysicalDevice physical,
                    vk::SurfaceKHR surface)
-    : physical{physical}, properties{physical.getProperties(dldi)},
-      format_properties{GetFormatProperties(dldi, physical)} {
+    : physical{physical}, format_properties{GetFormatProperties(dldi, physical)} {
     SetupFamilies(dldi, surface);
+    SetupProperties(dldi);
     SetupFeatures(dldi);
 }
 
@@ -97,22 +89,12 @@ bool VKDevice::Create(const vk::DispatchLoaderDynamic& dldi, vk::Instance instan
     features.depthClamp = true;
     features.samplerAnisotropy = true;
     features.largePoints = true;
-    features.multiViewport = true;
-    features.depthBiasClamp = true;
-    features.geometryShader = true;
-    features.tessellationShader = true;
-    features.fragmentStoresAndAtomics = true;
-    features.shaderImageGatherExtended = true;
-    features.shaderStorageImageWriteWithoutFormat = true;
     features.textureCompressionASTC_LDR = is_optimal_astc_supported;
 
-    vk::PhysicalDevice16BitStorageFeaturesKHR bit16_storage;
-    bit16_storage.uniformAndStorageBuffer16BitAccess = true;
-    SetNext(next, bit16_storage);
-
-    vk::PhysicalDevice8BitStorageFeaturesKHR bit8_storage;
-    bit8_storage.uniformAndStorageBuffer8BitAccess = true;
-    SetNext(next, bit8_storage);
+    vk::PhysicalDeviceVertexAttributeDivisorFeaturesEXT vertex_divisor;
+    vertex_divisor.vertexAttributeInstanceRateDivisor = true;
+    vertex_divisor.vertexAttributeInstanceRateZeroDivisor = true;
+    SetNext(next, vertex_divisor);
 
     vk::PhysicalDeviceFloat16Int8FeaturesKHR float16_int8;
     if (is_float16_supported) {
@@ -138,10 +120,6 @@ bool VKDevice::Create(const vk::DispatchLoaderDynamic& dldi, vk::Instance instan
         LOG_INFO(Render_Vulkan, "Device doesn't support uint8 indexes");
     }
 
-    if (!ext_depth_range_unrestricted) {
-        LOG_INFO(Render_Vulkan, "Device doesn't support depth range unrestricted");
-    }
-
     vk::DeviceCreateInfo device_ci({}, static_cast<u32>(queue_cis.size()), queue_cis.data(), 0,
                                    nullptr, static_cast<u32>(extensions.size()), extensions.data(),
                                    nullptr);
@@ -157,7 +135,16 @@ bool VKDevice::Create(const vk::DispatchLoaderDynamic& dldi, vk::Instance instan
     logical = UniqueDevice(
         dummy_logical, vk::ObjectDestroy<vk::NoParent, vk::DispatchLoaderDynamic>(nullptr, dld));
 
-    CollectTelemetryParameters();
+    if (khr_driver_properties) {
+        vk::PhysicalDeviceDriverPropertiesKHR driver;
+        vk::PhysicalDeviceProperties2 properties;
+        properties.pNext = &driver;
+        physical.getProperties2(&properties, dld);
+        driver_id = driver.driverID;
+        LOG_INFO(Render_Vulkan, "Driver: {} {}", driver.driverName, driver.driverInfo);
+    } else {
+        LOG_INFO(Render_Vulkan, "Driver: Unknown");
+    }
 
     graphics_queue = logical->getQueue(graphics_family, 0, dld);
     present_queue = logical->getQueue(present_family, 0, dld);
@@ -203,18 +190,6 @@ vk::Format VKDevice::GetSupportedFormat(vk::Format wanted_format,
 
 bool VKDevice::IsOptimalAstcSupported(const vk::PhysicalDeviceFeatures& features,
                                       const vk::DispatchLoaderDynamic& dldi) const {
-    // Disable for now to avoid converting ASTC twice.
-    return false;
-    static constexpr std::array astc_formats = {
-        vk::Format::eAstc4x4SrgbBlock,    vk::Format::eAstc8x8SrgbBlock,
-        vk::Format::eAstc8x5SrgbBlock,    vk::Format::eAstc5x4SrgbBlock,
-        vk::Format::eAstc5x5UnormBlock,   vk::Format::eAstc5x5SrgbBlock,
-        vk::Format::eAstc10x8UnormBlock,  vk::Format::eAstc10x8SrgbBlock,
-        vk::Format::eAstc6x6UnormBlock,   vk::Format::eAstc6x6SrgbBlock,
-        vk::Format::eAstc10x10UnormBlock, vk::Format::eAstc10x10SrgbBlock,
-        vk::Format::eAstc12x12UnormBlock, vk::Format::eAstc12x12SrgbBlock,
-        vk::Format::eAstc8x6UnormBlock,   vk::Format::eAstc8x6SrgbBlock,
-        vk::Format::eAstc6x5UnormBlock,   vk::Format::eAstc6x5SrgbBlock};
     if (!features.textureCompressionASTC_LDR) {
         return false;
     }
@@ -222,6 +197,12 @@ bool VKDevice::IsOptimalAstcSupported(const vk::PhysicalDeviceFeatures& features
         vk::FormatFeatureFlagBits::eSampledImage | vk::FormatFeatureFlagBits::eBlitSrc |
         vk::FormatFeatureFlagBits::eBlitDst | vk::FormatFeatureFlagBits::eTransferSrc |
         vk::FormatFeatureFlagBits::eTransferDst};
+    constexpr std::array astc_formats = {
+        vk::Format::eAstc4x4UnormBlock, vk::Format::eAstc4x4SrgbBlock,
+        vk::Format::eAstc8x8SrgbBlock,  vk::Format::eAstc8x6SrgbBlock,
+        vk::Format::eAstc5x4SrgbBlock,  vk::Format::eAstc5x5UnormBlock,
+        vk::Format::eAstc5x5SrgbBlock,  vk::Format::eAstc10x8UnormBlock,
+        vk::Format::eAstc10x8SrgbBlock};
     for (const auto format : astc_formats) {
         const auto format_properties{physical.getFormatProperties(format, dldi)};
         if (!(format_properties.optimalTilingFeatures & format_feature_usage)) {
@@ -244,17 +225,11 @@ bool VKDevice::IsFormatSupported(vk::Format wanted_format, vk::FormatFeatureFlag
 
 bool VKDevice::IsSuitable(const vk::DispatchLoaderDynamic& dldi, vk::PhysicalDevice physical,
                           vk::SurfaceKHR surface) {
+    LOG_INFO(Render_Vulkan, "{}", physical.getProperties(dldi).deviceName);
     bool is_suitable = true;
 
-    constexpr std::array required_extensions = {
-        VK_KHR_SWAPCHAIN_EXTENSION_NAME,
-        VK_KHR_16BIT_STORAGE_EXTENSION_NAME,
-        VK_KHR_8BIT_STORAGE_EXTENSION_NAME,
-        VK_KHR_DRIVER_PROPERTIES_EXTENSION_NAME,
-        VK_EXT_VERTEX_ATTRIBUTE_DIVISOR_EXTENSION_NAME,
-        VK_EXT_SHADER_SUBGROUP_BALLOT_EXTENSION_NAME,
-        VK_EXT_SHADER_SUBGROUP_VOTE_EXTENSION_NAME,
-    };
+    constexpr std::array required_extensions = {VK_KHR_SWAPCHAIN_EXTENSION_NAME,
+                                                VK_EXT_VERTEX_ATTRIBUTE_DIVISOR_EXTENSION_NAME};
     std::bitset<required_extensions.size()> available_extensions{};
 
     for (const auto& prop : physical.enumerateDeviceExtensionProperties(nullptr, dldi)) {
@@ -271,7 +246,7 @@ bool VKDevice::IsSuitable(const vk::DispatchLoaderDynamic& dldi, vk::PhysicalDev
             if (available_extensions[i]) {
                 continue;
             }
-            LOG_ERROR(Render_Vulkan, "Missing required extension: {}", required_extensions[i]);
+            LOG_INFO(Render_Vulkan, "Missing required extension: {}", required_extensions[i]);
             is_suitable = false;
         }
     }
@@ -288,7 +263,7 @@ bool VKDevice::IsSuitable(const vk::DispatchLoaderDynamic& dldi, vk::PhysicalDev
         has_present |= physical.getSurfaceSupportKHR(i, surface, dldi) != 0;
     }
     if (!has_graphics || !has_present) {
-        LOG_ERROR(Render_Vulkan, "Device lacks a graphics and present queue");
+        LOG_INFO(Render_Vulkan, "Device lacks a graphics and present queue");
         is_suitable = false;
     }
 
@@ -298,15 +273,8 @@ bool VKDevice::IsSuitable(const vk::DispatchLoaderDynamic& dldi, vk::PhysicalDev
 
     constexpr u32 required_ubo_size = 65536;
     if (limits.maxUniformBufferRange < required_ubo_size) {
-        LOG_ERROR(Render_Vulkan, "Device UBO size {} is too small, {} is required",
-                  limits.maxUniformBufferRange, required_ubo_size);
-        is_suitable = false;
-    }
-
-    constexpr u32 required_num_viewports = 16;
-    if (limits.maxViewports < required_num_viewports) {
-        LOG_INFO(Render_Vulkan, "Device number of viewports {} is too small, {} is required",
-                 limits.maxViewports, required_num_viewports);
+        LOG_INFO(Render_Vulkan, "Device UBO size {} is too small, {} is required)",
+                 limits.maxUniformBufferRange, required_ubo_size);
         is_suitable = false;
     }
 
@@ -317,32 +285,24 @@ bool VKDevice::IsSuitable(const vk::DispatchLoaderDynamic& dldi, vk::PhysicalDev
         std::make_pair(features.depthClamp, "depthClamp"),
         std::make_pair(features.samplerAnisotropy, "samplerAnisotropy"),
         std::make_pair(features.largePoints, "largePoints"),
-        std::make_pair(features.multiViewport, "multiViewport"),
-        std::make_pair(features.depthBiasClamp, "depthBiasClamp"),
-        std::make_pair(features.geometryShader, "geometryShader"),
-        std::make_pair(features.tessellationShader, "tessellationShader"),
-        std::make_pair(features.fragmentStoresAndAtomics, "fragmentStoresAndAtomics"),
-        std::make_pair(features.shaderImageGatherExtended, "shaderImageGatherExtended"),
-        std::make_pair(features.shaderStorageImageWriteWithoutFormat,
-                       "shaderStorageImageWriteWithoutFormat"),
     };
     for (const auto& [supported, name] : feature_report) {
         if (supported) {
             continue;
         }
-        LOG_ERROR(Render_Vulkan, "Missing required feature: {}", name);
+        LOG_INFO(Render_Vulkan, "Missing required feature: {}", name);
         is_suitable = false;
     }
 
-    if (!is_suitable) {
-        LOG_ERROR(Render_Vulkan, "{} is not suitable", properties.deviceName);
-    }
-
     return is_suitable;
 }
 
 std::vector<const char*> VKDevice::LoadExtensions(const vk::DispatchLoaderDynamic& dldi) {
     std::vector<const char*> extensions;
+    extensions.reserve(7);
+    extensions.push_back(VK_KHR_SWAPCHAIN_EXTENSION_NAME);
+    extensions.push_back(VK_EXT_VERTEX_ATTRIBUTE_DIVISOR_EXTENSION_NAME);
+
     const auto Test = [&](const vk::ExtensionProperties& extension,
                           std::optional<std::reference_wrapper<bool>> status, const char* name,
                           bool push) {
@@ -357,30 +317,13 @@ std::vector<const char*> VKDevice::LoadExtensions(const vk::DispatchLoaderDynami
         }
     };
 
-    extensions.reserve(13);
-    extensions.push_back(VK_KHR_SWAPCHAIN_EXTENSION_NAME);
-    extensions.push_back(VK_KHR_16BIT_STORAGE_EXTENSION_NAME);
-    extensions.push_back(VK_KHR_8BIT_STORAGE_EXTENSION_NAME);
-    extensions.push_back(VK_KHR_DRIVER_PROPERTIES_EXTENSION_NAME);
-    extensions.push_back(VK_EXT_VERTEX_ATTRIBUTE_DIVISOR_EXTENSION_NAME);
-    extensions.push_back(VK_EXT_SHADER_SUBGROUP_BALLOT_EXTENSION_NAME);
-    extensions.push_back(VK_EXT_SHADER_SUBGROUP_VOTE_EXTENSION_NAME);
-
-    [[maybe_unused]] const bool nsight =
-        std::getenv("NVTX_INJECTION64_PATH") || std::getenv("NSIGHT_LAUNCHED");
     bool khr_shader_float16_int8{};
-    bool ext_subgroup_size_control{};
     for (const auto& extension : physical.enumerateDeviceExtensionProperties(nullptr, dldi)) {
         Test(extension, khr_uniform_buffer_standard_layout,
              VK_KHR_UNIFORM_BUFFER_STANDARD_LAYOUT_EXTENSION_NAME, true);
-        Test(extension, khr_shader_float16_int8, VK_KHR_SHADER_FLOAT16_INT8_EXTENSION_NAME, false);
-        Test(extension, ext_depth_range_unrestricted,
-             VK_EXT_DEPTH_RANGE_UNRESTRICTED_EXTENSION_NAME, true);
         Test(extension, ext_index_type_uint8, VK_EXT_INDEX_TYPE_UINT8_EXTENSION_NAME, true);
-        Test(extension, ext_shader_viewport_index_layer,
-             VK_EXT_SHADER_VIEWPORT_INDEX_LAYER_EXTENSION_NAME, true);
-        Test(extension, ext_subgroup_size_control, VK_EXT_SUBGROUP_SIZE_CONTROL_EXTENSION_NAME,
-             false);
+        Test(extension, khr_driver_properties, VK_KHR_DRIVER_PROPERTIES_EXTENSION_NAME, true);
+        Test(extension, khr_shader_float16_int8, VK_KHR_SHADER_FLOAT16_INT8_EXTENSION_NAME, false);
     }
 
     if (khr_shader_float16_int8) {
@@ -389,23 +332,6 @@ std::vector<const char*> VKDevice::LoadExtensions(const vk::DispatchLoaderDynami
         extensions.push_back(VK_KHR_SHADER_FLOAT16_INT8_EXTENSION_NAME);
     }
 
-    if (ext_subgroup_size_control) {
-        const auto features =
-            GetFeatures<vk::PhysicalDeviceSubgroupSizeControlFeaturesEXT>(physical, dldi);
-        const auto properties =
-            GetProperties<vk::PhysicalDeviceSubgroupSizeControlPropertiesEXT>(physical, dldi);
-
-        is_warp_potentially_bigger = properties.maxSubgroupSize > GuestWarpSize;
-
-        if (features.subgroupSizeControl && properties.minSubgroupSize <= GuestWarpSize &&
-            properties.maxSubgroupSize >= GuestWarpSize) {
-            extensions.push_back(VK_EXT_SUBGROUP_SIZE_CONTROL_EXTENSION_NAME);
-            guest_warp_stages = properties.requiredSubgroupSizeStages;
-        }
-    } else {
-        is_warp_potentially_bigger = true;
-    }
-
     return extensions;
 }
 
@@ -432,23 +358,19 @@ void VKDevice::SetupFamilies(const vk::DispatchLoaderDynamic& dldi, vk::SurfaceK
     present_family = *present_family_;
 }
 
+void VKDevice::SetupProperties(const vk::DispatchLoaderDynamic& dldi) {
+    const auto props = physical.getProperties(dldi);
+    device_type = props.deviceType;
+    uniform_buffer_alignment = static_cast<u64>(props.limits.minUniformBufferOffsetAlignment);
+    storage_buffer_alignment = static_cast<u64>(props.limits.minStorageBufferOffsetAlignment);
+    max_storage_buffer_range = static_cast<u64>(props.limits.maxStorageBufferRange);
+}
+
 void VKDevice::SetupFeatures(const vk::DispatchLoaderDynamic& dldi) {
     const auto supported_features{physical.getFeatures(dldi)};
     is_optimal_astc_supported = IsOptimalAstcSupported(supported_features, dldi);
 }
 
-void VKDevice::CollectTelemetryParameters() {
-    const auto driver = GetProperties<vk::PhysicalDeviceDriverPropertiesKHR>(physical, dld);
-    driver_id = driver.driverID;
-    vendor_name = driver.driverName;
-
-    const auto extensions = physical.enumerateDeviceExtensionProperties(nullptr, dld);
-    reported_extensions.reserve(std::size(extensions));
-    for (const auto& extension : extensions) {
-        reported_extensions.push_back(extension.extensionName);
-    }
-}
-
 std::vector<vk::DeviceQueueCreateInfo> VKDevice::GetDeviceQueueCreateInfos() const {
     static const float QUEUE_PRIORITY = 1.0f;
 
@@ -463,70 +385,50 @@ std::vector<vk::DeviceQueueCreateInfo> VKDevice::GetDeviceQueueCreateInfos() con
 
 std::unordered_map<vk::Format, vk::FormatProperties> VKDevice::GetFormatProperties(
     const vk::DispatchLoaderDynamic& dldi, vk::PhysicalDevice physical) {
-    static constexpr std::array formats{vk::Format::eA8B8G8R8UnormPack32,
-                                        vk::Format::eA8B8G8R8SnormPack32,
-                                        vk::Format::eA8B8G8R8SrgbPack32,
-                                        vk::Format::eB5G6R5UnormPack16,
-                                        vk::Format::eA2B10G10R10UnormPack32,
-                                        vk::Format::eA1R5G5B5UnormPack16,
-                                        vk::Format::eR32G32B32A32Sfloat,
-                                        vk::Format::eR32G32B32A32Uint,
-                                        vk::Format::eR32G32Sfloat,
-                                        vk::Format::eR32G32Uint,
-                                        vk::Format::eR16G16B16A16Uint,
-                                        vk::Format::eR16G16B16A16Unorm,
-                                        vk::Format::eR16G16Unorm,
-                                        vk::Format::eR16G16Snorm,
-                                        vk::Format::eR16G16Sfloat,
-                                        vk::Format::eR16Unorm,
-                                        vk::Format::eR8G8B8A8Srgb,
-                                        vk::Format::eR8G8Unorm,
-                                        vk::Format::eR8G8Snorm,
-                                        vk::Format::eR8Unorm,
-                                        vk::Format::eR8Uint,
-                                        vk::Format::eB10G11R11UfloatPack32,
-                                        vk::Format::eR32Sfloat,
-                                        vk::Format::eR32Uint,
-                                        vk::Format::eR16Sfloat,
-                                        vk::Format::eR16G16B16A16Sfloat,
-                                        vk::Format::eB8G8R8A8Unorm,
-                                        vk::Format::eR4G4B4A4UnormPack16,
-                                        vk::Format::eD32Sfloat,
-                                        vk::Format::eD16Unorm,
-                                        vk::Format::eD16UnormS8Uint,
-                                        vk::Format::eD24UnormS8Uint,
-                                        vk::Format::eD32SfloatS8Uint,
-                                        vk::Format::eBc1RgbaUnormBlock,
-                                        vk::Format::eBc2UnormBlock,
-                                        vk::Format::eBc3UnormBlock,
-                                        vk::Format::eBc4UnormBlock,
-                                        vk::Format::eBc5UnormBlock,
-                                        vk::Format::eBc5SnormBlock,
-                                        vk::Format::eBc7UnormBlock,
-                                        vk::Format::eBc6HUfloatBlock,
-                                        vk::Format::eBc6HSfloatBlock,
-                                        vk::Format::eBc1RgbaSrgbBlock,
-                                        vk::Format::eBc3SrgbBlock,
-                                        vk::Format::eBc7SrgbBlock,
-                                        vk::Format::eAstc4x4SrgbBlock,
-                                        vk::Format::eAstc8x8SrgbBlock,
-                                        vk::Format::eAstc8x5SrgbBlock,
-                                        vk::Format::eAstc5x4SrgbBlock,
-                                        vk::Format::eAstc5x5UnormBlock,
-                                        vk::Format::eAstc5x5SrgbBlock,
-                                        vk::Format::eAstc10x8UnormBlock,
-                                        vk::Format::eAstc10x8SrgbBlock,
-                                        vk::Format::eAstc6x6UnormBlock,
-                                        vk::Format::eAstc6x6SrgbBlock,
-                                        vk::Format::eAstc10x10UnormBlock,
-                                        vk::Format::eAstc10x10SrgbBlock,
-                                        vk::Format::eAstc12x12UnormBlock,
-                                        vk::Format::eAstc12x12SrgbBlock,
-                                        vk::Format::eAstc8x6UnormBlock,
-                                        vk::Format::eAstc8x6SrgbBlock,
-                                        vk::Format::eAstc6x5UnormBlock,
-                                        vk::Format::eAstc6x5SrgbBlock,
-                                        vk::Format::eE5B9G9R9UfloatPack32};
+    constexpr std::array formats{vk::Format::eA8B8G8R8UnormPack32,
+                                 vk::Format::eA8B8G8R8SnormPack32,
+                                 vk::Format::eA8B8G8R8SrgbPack32,
+                                 vk::Format::eB5G6R5UnormPack16,
+                                 vk::Format::eA2B10G10R10UnormPack32,
+                                 vk::Format::eR32G32B32A32Sfloat,
+                                 vk::Format::eR16G16B16A16Uint,
+                                 vk::Format::eR16G16Unorm,
+                                 vk::Format::eR16G16Snorm,
+                                 vk::Format::eR16G16Sfloat,
+                                 vk::Format::eR16Unorm,
+                                 vk::Format::eR8G8B8A8Srgb,
+                                 vk::Format::eR8G8Unorm,
+                                 vk::Format::eR8G8Snorm,
+                                 vk::Format::eR8Unorm,
+                                 vk::Format::eB10G11R11UfloatPack32,
+                                 vk::Format::eR32Sfloat,
+                                 vk::Format::eR16Sfloat,
+                                 vk::Format::eR16G16B16A16Sfloat,
+                                 vk::Format::eB8G8R8A8Unorm,
+                                 vk::Format::eD32Sfloat,
+                                 vk::Format::eD16Unorm,
+                                 vk::Format::eD16UnormS8Uint,
+                                 vk::Format::eD24UnormS8Uint,
+                                 vk::Format::eD32SfloatS8Uint,
+                                 vk::Format::eBc1RgbaUnormBlock,
+                                 vk::Format::eBc2UnormBlock,
+                                 vk::Format::eBc3UnormBlock,
+                                 vk::Format::eBc4UnormBlock,
+                                 vk::Format::eBc5UnormBlock,
+                                 vk::Format::eBc5SnormBlock,
+                                 vk::Format::eBc7UnormBlock,
+                                 vk::Format::eBc1RgbaSrgbBlock,
+                                 vk::Format::eBc3SrgbBlock,
+                                 vk::Format::eBc7SrgbBlock,
+                                 vk::Format::eAstc4x4UnormBlock,
+                                 vk::Format::eAstc4x4SrgbBlock,
+                                 vk::Format::eAstc8x8SrgbBlock,
+                                 vk::Format::eAstc8x6SrgbBlock,
+                                 vk::Format::eAstc5x4SrgbBlock,
+                                 vk::Format::eAstc5x5UnormBlock,
+                                 vk::Format::eAstc5x5SrgbBlock,
+                                 vk::Format::eAstc10x8UnormBlock,
+                                 vk::Format::eAstc10x8SrgbBlock};
     std::unordered_map<vk::Format, vk::FormatProperties> format_properties;
     for (const auto format : formats) {
         format_properties.emplace(format, physical.getFormatProperties(format, dldi));

src/video_core/renderer_vulkan/vk_device.h

@@ -4,8 +4,6 @@
 
 #pragma once
 
-#include <string>
-#include <string_view>
 #include <unordered_map>
 #include <vector>
 #include "common/common_types.h"
@@ -16,9 +14,6 @@ namespace Vulkan {
 /// Format usage descriptor.
 enum class FormatType { Linear, Optimal, Buffer };
 
-/// Subgroup size of the guest emulated hardware (Nvidia has 32 threads per subgroup).
-const u32 GuestWarpSize = 32;
-
 /// Handles data specific to a physical device.
 class VKDevice final {
 public:
@@ -76,22 +71,7 @@ public:
 
     /// Returns true if the device is integrated with the host CPU.
     bool IsIntegrated() const {
-        return properties.deviceType == vk::PhysicalDeviceType::eIntegratedGpu;
-    }
-
-    /// Returns the current Vulkan API version provided in Vulkan-formatted version numbers.
-    u32 GetApiVersion() const {
-        return properties.apiVersion;
-    }
-
-    /// Returns the current driver version provided in Vulkan-formatted version numbers.
-    u32 GetDriverVersion() const {
-        return properties.driverVersion;
-    }
-
-    /// Returns the device name.
-    std::string_view GetModelName() const {
-        return properties.deviceName;
+        return device_type == vk::PhysicalDeviceType::eIntegratedGpu;
     }
 
     /// Returns the driver ID.
@@ -100,23 +80,18 @@ public:
     }
 
     /// Returns uniform buffer alignment requeriment.
-    vk::DeviceSize GetUniformBufferAlignment() const {
-        return properties.limits.minUniformBufferOffsetAlignment;
+    u64 GetUniformBufferAlignment() const {
+        return uniform_buffer_alignment;
     }
 
     /// Returns storage alignment requeriment.
-    vk::DeviceSize GetStorageBufferAlignment() const {
-        return properties.limits.minStorageBufferOffsetAlignment;
+    u64 GetStorageBufferAlignment() const {
+        return storage_buffer_alignment;
     }
 
     /// Returns the maximum range for storage buffers.
-    vk::DeviceSize GetMaxStorageBufferRange() const {
-        return properties.limits.maxStorageBufferRange;
-    }
-
-    /// Returns the maximum size for push constants.
-    vk::DeviceSize GetMaxPushConstantsSize() const {
-        return properties.limits.maxPushConstantsSize;
+    u64 GetMaxStorageBufferRange() const {
+        return max_storage_buffer_range;
     }
 
     /// Returns true if ASTC is natively supported.
@@ -129,16 +104,6 @@ public:
         return is_float16_supported;
     }
 
-    /// Returns true if the device warp size can potentially be bigger than guest's warp size.
-    bool IsWarpSizePotentiallyBiggerThanGuest() const {
-        return is_warp_potentially_bigger;
-    }
-
-    /// Returns true if the device can be forced to use the guest warp size.
-    bool IsGuestWarpSizeSupported(vk::ShaderStageFlagBits stage) const {
-        return (guest_warp_stages & stage) != vk::ShaderStageFlags{};
-    }
-
     /// Returns true if the device supports VK_EXT_scalar_block_layout.
     bool IsKhrUniformBufferStandardLayoutSupported() const {
         return khr_uniform_buffer_standard_layout;
@@ -149,26 +114,6 @@ public:
         return ext_index_type_uint8;
     }
 
-    /// Returns true if the device supports VK_EXT_depth_range_unrestricted.
-    bool IsExtDepthRangeUnrestrictedSupported() const {
-        return ext_depth_range_unrestricted;
-    }
-
-    /// Returns true if the device supports VK_EXT_shader_viewport_index_layer.
-    bool IsExtShaderViewportIndexLayerSupported() const {
-        return ext_shader_viewport_index_layer;
-    }
-
-    /// Returns the vendor name reported from Vulkan.
-    std::string_view GetVendorName() const {
-        return vendor_name;
-    }
-
-    /// Returns the list of available extensions.
-    const std::vector<std::string>& GetAvailableExtensions() const {
-        return reported_extensions;
-    }
-
     /// Checks if the physical device is suitable.
     static bool IsSuitable(const vk::DispatchLoaderDynamic& dldi, vk::PhysicalDevice physical,
                            vk::SurfaceKHR surface);
@@ -180,12 +125,12 @@ private:
     /// Sets up queue families.
     void SetupFamilies(const vk::DispatchLoaderDynamic& dldi, vk::SurfaceKHR surface);
 
+    /// Sets up device properties.
+    void SetupProperties(const vk::DispatchLoaderDynamic& dldi);
+
     /// Sets up device features.
     void SetupFeatures(const vk::DispatchLoaderDynamic& dldi);
 
-    /// Collects telemetry information from the device.
-    void CollectTelemetryParameters();
-
     /// Returns a list of queue initialization descriptors.
     std::vector<vk::DeviceQueueCreateInfo> GetDeviceQueueCreateInfos() const;
 
@@ -203,28 +148,23 @@ private:
 
     const vk::PhysicalDevice physical;         ///< Physical device.
     vk::DispatchLoaderDynamic dld;             ///< Device function pointers.
-    vk::PhysicalDeviceProperties properties;   ///< Device properties.
     UniqueDevice logical;                      ///< Logical device.
     vk::Queue graphics_queue;                  ///< Main graphics queue.
     vk::Queue present_queue;                   ///< Main present queue.
     u32 graphics_family{};                     ///< Main graphics queue family index.
     u32 present_family{};                      ///< Main present queue family index.
+    vk::PhysicalDeviceType device_type;        ///< Physical device type.
     vk::DriverIdKHR driver_id{};               ///< Driver ID.
-    vk::ShaderStageFlags guest_warp_stages{};  ///< Stages where the guest warp size can be forced.
+    u64 uniform_buffer_alignment{};            ///< Uniform buffer alignment requeriment.
+    u64 storage_buffer_alignment{};            ///< Storage buffer alignment requeriment.
+    u64 max_storage_buffer_range{};            ///< Max storage buffer size.
     bool is_optimal_astc_supported{};          ///< Support for native ASTC.
     bool is_float16_supported{};               ///< Support for float16 arithmetics.
-    bool is_warp_potentially_bigger{};         ///< Host warp size can be bigger than guest.
     bool khr_uniform_buffer_standard_layout{}; ///< Support for std430 on UBOs.
     bool ext_index_type_uint8{};               ///< Support for VK_EXT_index_type_uint8.
-    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.
-
-    // Telemetry parameters
-    std::string vendor_name;                      ///< Device's driver name.
-    std::vector<std::string> reported_extensions; ///< Reported Vulkan extensions.
-
-    /// Format properties dictionary.
-    std::unordered_map<vk::Format, vk::FormatProperties> format_properties;
+    bool khr_driver_properties{};              ///< Support for VK_KHR_driver_properties.
+    std::unordered_map<vk::Format, vk::FormatProperties>
+        format_properties; ///< Format properties dictionary.
 };
 
 } // namespace Vulkan

src/video_core/renderer_vulkan/vk_sampler_cache.cpp

@@ -46,10 +46,9 @@ UniqueSampler VKSamplerCache::CreateSampler(const Tegra::Texture::TSCEntry& tsc)
         {}, MaxwellToVK::Sampler::Filter(tsc.mag_filter),
         MaxwellToVK::Sampler::Filter(tsc.min_filter),
         MaxwellToVK::Sampler::MipmapMode(tsc.mipmap_filter),
-        MaxwellToVK::Sampler::WrapMode(tsc.wrap_u, tsc.mag_filter),
-        MaxwellToVK::Sampler::WrapMode(tsc.wrap_v, tsc.mag_filter),
-        MaxwellToVK::Sampler::WrapMode(tsc.wrap_p, tsc.mag_filter), tsc.GetLodBias(),
-        has_anisotropy, max_anisotropy, tsc.depth_compare_enabled,
+        MaxwellToVK::Sampler::WrapMode(tsc.wrap_u), MaxwellToVK::Sampler::WrapMode(tsc.wrap_v),
+        MaxwellToVK::Sampler::WrapMode(tsc.wrap_p), tsc.GetLodBias(), has_anisotropy,
+        max_anisotropy, tsc.depth_compare_enabled,
         MaxwellToVK::Sampler::DepthCompareFunction(tsc.depth_compare_func), tsc.GetMinLod(),
         tsc.GetMaxLod(), vk_border_color.value_or(vk::BorderColor::eFloatTransparentBlack),
         unnormalized_coords);

src/video_core/renderer_vulkan/vk_shader_decompiler.h

@@ -5,28 +5,29 @@
 #pragma once
 
 #include <array>
-#include <bitset>
 #include <memory>
 #include <set>
-#include <type_traits>
 #include <utility>
 #include <vector>
 
+#include <sirit/sirit.h>
+
 #include "common/common_types.h"
 #include "video_core/engines/maxwell_3d.h"
-#include "video_core/engines/shader_type.h"
 #include "video_core/shader/shader_ir.h"
 
+namespace VideoCommon::Shader {
+class ShaderIR;
+}
+
 namespace Vulkan {
 class VKDevice;
 }
 
-namespace Vulkan {
+namespace Vulkan::VKShader {
 
 using Maxwell = Tegra::Engines::Maxwell3D::Regs;
-using TexelBufferEntry = VideoCommon::Shader::Sampler;
 using SamplerEntry = VideoCommon::Shader::Sampler;
-using ImageEntry = VideoCommon::Shader::Image;
 
 constexpr u32 DESCRIPTOR_SET = 0;
 
@@ -45,74 +46,39 @@ private:
 
 class GlobalBufferEntry {
 public:
-    constexpr explicit GlobalBufferEntry(u32 cbuf_index, u32 cbuf_offset, bool is_written)
-        : cbuf_index{cbuf_index}, cbuf_offset{cbuf_offset}, is_written{is_written} {}
+    explicit GlobalBufferEntry(u32 cbuf_index, u32 cbuf_offset)
+        : cbuf_index{cbuf_index}, cbuf_offset{cbuf_offset} {}
 
-    constexpr u32 GetCbufIndex() const {
+    u32 GetCbufIndex() const {
         return cbuf_index;
     }
 
-    constexpr u32 GetCbufOffset() const {
+    u32 GetCbufOffset() const {
         return cbuf_offset;
     }
 
-    constexpr bool IsWritten() const {
-        return is_written;
-    }
-
 private:
     u32 cbuf_index{};
     u32 cbuf_offset{};
-    bool is_written{};
 };
 
 struct ShaderEntries {
-    u32 NumBindings() const {
-        return static_cast<u32>(const_buffers.size() + global_buffers.size() +
-                                texel_buffers.size() + samplers.size() + images.size());
-    }
-
+    u32 const_buffers_base_binding{};
+    u32 global_buffers_base_binding{};
+    u32 samplers_base_binding{};
     std::vector<ConstBufferEntry> const_buffers;
     std::vector<GlobalBufferEntry> global_buffers;
-    std::vector<TexelBufferEntry> texel_buffers;
     std::vector<SamplerEntry> samplers;
-    std::vector<ImageEntry> images;
     std::set<u32> attributes;
     std::array<bool, Maxwell::NumClipDistances> clip_distances{};
     std::size_t shader_length{};
-    bool uses_warps{};
+    Sirit::Id entry_function{};
+    std::vector<Sirit::Id> interfaces;
 };
 
-struct Specialization final {
-    u32 base_binding{};
+using DecompilerResult = std::pair<std::unique_ptr<Sirit::Module>, ShaderEntries>;
 
-    // Compute specific
-    std::array<u32, 3> workgroup_size{};
-    u32 shared_memory_size{};
+DecompilerResult Decompile(const VKDevice& device, const VideoCommon::Shader::ShaderIR& ir,
+                           Tegra::Engines::ShaderType stage);
 
-    // Graphics specific
-    Maxwell::PrimitiveTopology primitive_topology{};
-    std::optional<float> point_size{};
-    std::array<Maxwell::VertexAttribute::Type, Maxwell::NumVertexAttributes> attribute_types{};
-
-    // Tessellation specific
-    struct {
-        Maxwell::TessellationPrimitive primitive{};
-        Maxwell::TessellationSpacing spacing{};
-        bool clockwise{};
-    } tessellation;
-};
-// Old gcc versions don't consider this trivially copyable.
-// static_assert(std::is_trivially_copyable_v<Specialization>);
-
-struct SPIRVShader {
-    std::vector<u32> code;
-    ShaderEntries entries;
-};
-
-ShaderEntries GenerateShaderEntries(const VideoCommon::Shader::ShaderIR& ir);
-
-std::vector<u32> Decompile(const VKDevice& device, const VideoCommon::Shader::ShaderIR& ir,
-                           Tegra::Engines::ShaderType stage, const Specialization& specialization);
-
-} // namespace Vulkan
+} // namespace Vulkan::VKShader

src/video_core/renderer_vulkan/vk_swapchain.cpp

@@ -19,18 +19,12 @@
 namespace Vulkan {
 
 namespace {
-
-vk::SurfaceFormatKHR ChooseSwapSurfaceFormat(const std::vector<vk::SurfaceFormatKHR>& formats,
-                                             bool srgb) {
+vk::SurfaceFormatKHR ChooseSwapSurfaceFormat(const std::vector<vk::SurfaceFormatKHR>& formats) {
     if (formats.size() == 1 && formats[0].format == vk::Format::eUndefined) {
-        vk::SurfaceFormatKHR format;
-        format.format = vk::Format::eB8G8R8A8Unorm;
-        format.colorSpace = vk::ColorSpaceKHR::eSrgbNonlinear;
-        return format;
+        return {vk::Format::eB8G8R8A8Unorm, vk::ColorSpaceKHR::eSrgbNonlinear};
     }
-    const auto& found = std::find_if(formats.begin(), formats.end(), [srgb](const auto& format) {
-        const auto request_format = srgb ? vk::Format::eB8G8R8A8Srgb : vk::Format::eB8G8R8A8Unorm;
-        return format.format == request_format &&
+    const auto& found = std::find_if(formats.begin(), formats.end(), [](const auto& format) {
+        return format.format == vk::Format::eB8G8R8A8Unorm &&
                format.colorSpace == vk::ColorSpaceKHR::eSrgbNonlinear;
     });
     return found != formats.end() ? *found : formats[0];
@@ -57,26 +51,28 @@ vk::Extent2D ChooseSwapExtent(const vk::SurfaceCapabilitiesKHR& capabilities, u3
                              std::min(capabilities.maxImageExtent.height, extent.height));
     return extent;
 }
-
-} // Anonymous namespace
+} // namespace
 
 VKSwapchain::VKSwapchain(vk::SurfaceKHR surface, const VKDevice& device)
     : surface{surface}, device{device} {}
 
 VKSwapchain::~VKSwapchain() = default;
 
-void VKSwapchain::Create(u32 width, u32 height, bool srgb) {
+void VKSwapchain::Create(u32 width, u32 height) {
+    const auto dev = device.GetLogical();
     const auto& dld = device.GetDispatchLoader();
     const auto physical_device = device.GetPhysical();
-    const auto capabilities{physical_device.getSurfaceCapabilitiesKHR(surface, dld)};
+
+    const vk::SurfaceCapabilitiesKHR capabilities{
+        physical_device.getSurfaceCapabilitiesKHR(surface, dld)};
     if (capabilities.maxImageExtent.width == 0 || capabilities.maxImageExtent.height == 0) {
         return;
     }
 
-    device.GetLogical().waitIdle(dld);
+    dev.waitIdle(dld);
     Destroy();
 
-    CreateSwapchain(capabilities, width, height, srgb);
+    CreateSwapchain(capabilities, width, height);
     CreateSemaphores();
     CreateImageViews();
 
@@ -111,7 +107,7 @@ bool VKSwapchain::Present(vk::Semaphore render_semaphore, VKFence& fence) {
         break;
     case vk::Result::eErrorOutOfDateKHR:
         if (current_width > 0 && current_height > 0) {
-            Create(current_width, current_height, current_srgb);
+            Create(current_width, current_height);
             recreated = true;
         }
         break;
@@ -133,19 +129,23 @@ bool VKSwapchain::HasFramebufferChanged(const Layout::FramebufferLayout& framebu
 }
 
 void VKSwapchain::CreateSwapchain(const vk::SurfaceCapabilitiesKHR& capabilities, u32 width,
-                                  u32 height, bool srgb) {
+                                  u32 height) {
+    const auto dev{device.GetLogical()};
     const auto& dld{device.GetDispatchLoader()};
     const auto physical_device{device.GetPhysical()};
-    const auto formats{physical_device.getSurfaceFormatsKHR(surface, dld)};
-    const auto present_modes{physical_device.getSurfacePresentModesKHR(surface, dld)};
 
-    const vk::SurfaceFormatKHR surface_format{ChooseSwapSurfaceFormat(formats, srgb)};
+    const std::vector<vk::SurfaceFormatKHR> formats{
+        physical_device.getSurfaceFormatsKHR(surface, dld)};
+
+    const std::vector<vk::PresentModeKHR> present_modes{
+        physical_device.getSurfacePresentModesKHR(surface, dld)};
+
+    const vk::SurfaceFormatKHR surface_format{ChooseSwapSurfaceFormat(formats)};
     const vk::PresentModeKHR present_mode{ChooseSwapPresentMode(present_modes)};
     extent = ChooseSwapExtent(capabilities, width, height);
 
     current_width = extent.width;
     current_height = extent.height;
-    current_srgb = srgb;
 
     u32 requested_image_count{capabilities.minImageCount + 1};
     if (capabilities.maxImageCount > 0 && requested_image_count > capabilities.maxImageCount) {
@@ -169,7 +169,6 @@ void VKSwapchain::CreateSwapchain(const vk::SurfaceCapabilitiesKHR& capabilities
         swapchain_ci.imageSharingMode = vk::SharingMode::eExclusive;
     }
 
-    const auto dev{device.GetLogical()};
     swapchain = dev.createSwapchainKHRUnique(swapchain_ci, nullptr, dld);
 
     images = dev.getSwapchainImagesKHR(*swapchain, dld);

src/video_core/renderer_vulkan/vk_swapchain.h

@@ -24,7 +24,7 @@ public:
     ~VKSwapchain();
 
     /// Creates (or recreates) the swapchain with a given size.
-    void Create(u32 width, u32 height, bool srgb);
+    void Create(u32 width, u32 height);
 
     /// Acquires the next image in the swapchain, waits as needed.
     void AcquireNextImage();
@@ -60,13 +60,8 @@ public:
         return image_format;
     }
 
-    bool GetSrgbState() const {
-        return current_srgb;
-    }
-
 private:
-    void CreateSwapchain(const vk::SurfaceCapabilitiesKHR& capabilities, u32 width, u32 height,
-                         bool srgb);
+    void CreateSwapchain(const vk::SurfaceCapabilitiesKHR& capabilities, u32 width, u32 height);
     void CreateSemaphores();
     void CreateImageViews();
 
@@ -92,7 +87,6 @@ private:
 
     u32 current_width{};
     u32 current_height{};
-    bool current_srgb{};
 };
 
 } // namespace Vulkan

src/video_core/shader/decode/arithmetic_integer.cpp

@@ -130,25 +130,6 @@ u32 ShaderIR::DecodeArithmeticInteger(NodeBlock& bb, u32 pc) {
         SetRegister(bb, instr.gpr0, value);
         break;
     }
-    case OpCode::Id::FLO_R:
-    case OpCode::Id::FLO_C:
-    case OpCode::Id::FLO_IMM: {
-        Node value;
-        if (instr.flo.invert) {
-            op_b = Operation(OperationCode::IBitwiseNot, NO_PRECISE, std::move(op_b));
-        }
-        if (instr.flo.is_signed) {
-            value = Operation(OperationCode::IBitMSB, NO_PRECISE, std::move(op_b));
-        } else {
-            value = Operation(OperationCode::UBitMSB, NO_PRECISE, std::move(op_b));
-        }
-        if (instr.flo.sh) {
-            value =
-                Operation(OperationCode::UBitwiseXor, NO_PRECISE, std::move(value), Immediate(31));
-        }
-        SetRegister(bb, instr.gpr0, std::move(value));
-        break;
-    }
     case OpCode::Id::SEL_C:
     case OpCode::Id::SEL_R:
     case OpCode::Id::SEL_IMM: {

src/video_core/shader/decode/memory.cpp

@@ -21,7 +21,6 @@ using Tegra::Shader::OpCode;
 using Tegra::Shader::Register;
 
 namespace {
-
 u32 GetUniformTypeElementsCount(Tegra::Shader::UniformType uniform_type) {
     switch (uniform_type) {
     case Tegra::Shader::UniformType::Single:
@@ -36,7 +35,6 @@ u32 GetUniformTypeElementsCount(Tegra::Shader::UniformType uniform_type) {
         return 1;
     }
 }
-
 } // Anonymous namespace
 
 u32 ShaderIR::DecodeMemory(NodeBlock& bb, u32 pc) {
@@ -198,28 +196,28 @@ u32 ShaderIR::DecodeMemory(NodeBlock& bb, u32 pc) {
         UNIMPLEMENTED_IF_MSG((instr.attribute.fmt20.immediate.Value() % sizeof(u32)) != 0,
                              "Unaligned attribute loads are not supported");
 
-        u64 element = instr.attribute.fmt20.element;
-        auto index = static_cast<u64>(instr.attribute.fmt20.index.Value());
+        u64 next_element = instr.attribute.fmt20.element;
+        auto next_index = static_cast<u64>(instr.attribute.fmt20.index.Value());
 
-        const u32 num_words = static_cast<u32>(instr.attribute.fmt20.size.Value()) + 1;
-        for (u32 reg_offset = 0; reg_offset < num_words; ++reg_offset) {
-            Node dest;
-            if (instr.attribute.fmt20.patch) {
-                const u32 offset = static_cast<u32>(index) * 4 + static_cast<u32>(element);
-                dest = MakeNode<PatchNode>(offset);
-            } else {
-                dest = GetOutputAttribute(static_cast<Attribute::Index>(index), element,
-                                          GetRegister(instr.gpr39));
-            }
+        const auto StoreNextElement = [&](u32 reg_offset) {
+            const auto dest = GetOutputAttribute(static_cast<Attribute::Index>(next_index),
+                                                 next_element, GetRegister(instr.gpr39));
             const auto src = GetRegister(instr.gpr0.Value() + reg_offset);
 
             bb.push_back(Operation(OperationCode::Assign, dest, src));
 
-            // Load the next attribute element into the following register. If the element to load
-            // goes beyond the vec4 size, load the first element of the next attribute.
-            element = (element + 1) % 4;
-            index = index + (element == 0 ? 1 : 0);
+            // Load the next attribute element into the following register. If the element
+            // to load goes beyond the vec4 size, load the first element of the next
+            // attribute.
+            next_element = (next_element + 1) % 4;
+            next_index = next_index + (next_element == 0 ? 1 : 0);
+        };
+
+        const u32 num_words = static_cast<u32>(instr.attribute.fmt20.size.Value()) + 1;
+        for (u32 reg_offset = 0; reg_offset < num_words; ++reg_offset) {
+            StoreNextElement(reg_offset);
         }
+
         break;
     }
     case OpCode::Id::ST_L:

src/video_core/shader/decode/other.cpp

@@ -69,8 +69,6 @@ u32 ShaderIR::DecodeOther(NodeBlock& bb, u32 pc) {
     case OpCode::Id::MOV_SYS: {
         const Node value = [this, instr] {
             switch (instr.sys20) {
-            case SystemVariable::InvocationId:
-                return Operation(OperationCode::InvocationId);
             case SystemVariable::Ydirection:
                 return Operation(OperationCode::YNegate);
             case SystemVariable::InvocationInfo:
@@ -257,12 +255,6 @@ u32 ShaderIR::DecodeOther(NodeBlock& bb, u32 pc) {
         SetRegister(bb, instr.gpr0, GetRegister(instr.gpr8));
         break;
     }
-    case OpCode::Id::MEMBAR: {
-        UNIMPLEMENTED_IF(instr.membar.type != Tegra::Shader::MembarType::GL);
-        UNIMPLEMENTED_IF(instr.membar.unknown != Tegra::Shader::MembarUnknown::Default);
-        bb.push_back(Operation(OperationCode::MemoryBarrierGL));
-        break;
-    }
     case OpCode::Id::DEPBAR: {
         LOG_DEBUG(HW_GPU, "DEPBAR instruction is stubbed");
         break;

src/video_core/shader/decode/texture.cpp

@@ -134,52 +134,13 @@ u32 ShaderIR::DecodeTexture(NodeBlock& bb, u32 pc) {
         Node4 values;
         for (u32 element = 0; element < values.size(); ++element) {
             auto coords_copy = coords;
-            MetaTexture meta{sampler, {}, {}, {}, {}, {}, {}, component, element};
+            MetaTexture meta{sampler, {}, {}, {}, {}, {}, component, element};
             values[element] = Operation(OperationCode::TextureGather, meta, std::move(coords_copy));
         }
 
         WriteTexsInstructionFloat(bb, instr, values, true);
         break;
     }
-    case OpCode::Id::TXD_B:
-        is_bindless = true;
-        [[fallthrough]];
-    case OpCode::Id::TXD: {
-        UNIMPLEMENTED_IF_MSG(instr.txd.UsesMiscMode(TextureMiscMode::AOFFI),
-                             "AOFFI is not implemented");
-        UNIMPLEMENTED_IF_MSG(instr.txd.is_array != 0, "TXD Array is not implemented");
-
-        u64 base_reg = instr.gpr8.Value();
-        const auto derivate_reg = instr.gpr20.Value();
-        const auto texture_type = instr.txd.texture_type.Value();
-        const auto coord_count = GetCoordCount(texture_type);
-
-        const auto& sampler = is_bindless
-                                  ? GetBindlessSampler(base_reg, {{texture_type, false, false}})
-                                  : GetSampler(instr.sampler, {{texture_type, false, false}});
-        if (is_bindless) {
-            base_reg++;
-        }
-
-        std::vector<Node> coords;
-        std::vector<Node> derivates;
-        for (std::size_t i = 0; i < coord_count; ++i) {
-            coords.push_back(GetRegister(base_reg + i));
-            const std::size_t derivate = i * 2;
-            derivates.push_back(GetRegister(derivate_reg + derivate));
-            derivates.push_back(GetRegister(derivate_reg + derivate + 1));
-        }
-
-        Node4 values;
-        for (u32 element = 0; element < values.size(); ++element) {
-            MetaTexture meta{sampler, {}, {}, {}, derivates, {}, {}, {}, element};
-            values[element] = Operation(OperationCode::TextureGradient, std::move(meta), coords);
-        }
-
-        WriteTexInstructionFloat(bb, instr, values);
-
-        break;
-    }
     case OpCode::Id::TXQ_B:
         is_bindless = true;
         [[fallthrough]];
@@ -197,7 +158,7 @@ u32 ShaderIR::DecodeTexture(NodeBlock& bb, u32 pc) {
                 if (!instr.txq.IsComponentEnabled(element)) {
                     continue;
                 }
-                MetaTexture meta{sampler, {}, {}, {}, {}, {}, {}, {}, element};
+                MetaTexture meta{sampler, {}, {}, {}, {}, {}, {}, element};
                 const Node value =
                     Operation(OperationCode::TextureQueryDimensions, meta,
                               GetRegister(instr.gpr8.Value() + (is_bindless ? 1 : 0)));
@@ -251,7 +212,7 @@ u32 ShaderIR::DecodeTexture(NodeBlock& bb, u32 pc) {
                 continue;
             }
             auto params = coords;
-            MetaTexture meta{sampler, {}, {}, {}, {}, {}, {}, {}, element};
+            MetaTexture meta{sampler, {}, {}, {}, {}, {}, {}, element};
             const Node value = Operation(OperationCode::TextureQueryLod, meta, std::move(params));
             SetTemporary(bb, indexer++, value);
         }
@@ -481,7 +442,7 @@ Node4 ShaderIR::GetTextureCode(Instruction instr, TextureType texture_type,
     Node4 values;
     for (u32 element = 0; element < values.size(); ++element) {
         auto copy_coords = coords;
-        MetaTexture meta{sampler, array, depth_compare, aoffi, {}, bias, lod, {}, element};
+        MetaTexture meta{sampler, array, depth_compare, aoffi, bias, lod, {}, element};
         values[element] = Operation(read_method, meta, std::move(copy_coords));
     }
 
@@ -613,7 +574,7 @@ Node4 ShaderIR::GetTld4Code(Instruction instr, TextureType texture_type, bool de
     Node4 values;
     for (u32 element = 0; element < values.size(); ++element) {
         auto coords_copy = coords;
-        MetaTexture meta{sampler, GetRegister(array_register), dc, aoffi, {}, {}, {}, component,
+        MetaTexture meta{sampler, GetRegister(array_register), dc, aoffi, {}, {}, component,
                          element};
         values[element] = Operation(OperationCode::TextureGather, meta, std::move(coords_copy));
     }
@@ -647,7 +608,7 @@ Node4 ShaderIR::GetTldCode(Tegra::Shader::Instruction instr) {
     Node4 values;
     for (u32 element = 0; element < values.size(); ++element) {
         auto coords_copy = coords;
-        MetaTexture meta{sampler, array_register, {}, {}, {}, {}, lod, {}, element};
+        MetaTexture meta{sampler, array_register, {}, {}, {}, lod, {}, element};
         values[element] = Operation(OperationCode::TexelFetch, meta, std::move(coords_copy));
     }
 
@@ -692,7 +653,7 @@ Node4 ShaderIR::GetTldsCode(Instruction instr, TextureType texture_type, bool is
     Node4 values;
     for (u32 element = 0; element < values.size(); ++element) {
         auto coords_copy = coords;
-        MetaTexture meta{sampler, array, {}, {}, {}, {}, lod, {}, element};
+        MetaTexture meta{sampler, array, {}, {}, {}, lod, {}, element};
         values[element] = Operation(OperationCode::TexelFetch, meta, std::move(coords_copy));
     }
     return values;

src/video_core/shader/decode/warp.cpp

@@ -38,9 +38,6 @@ u32 ShaderIR::DecodeWarp(NodeBlock& bb, u32 pc) {
     const Instruction instr = {program_code[pc]};
     const auto opcode = OpCode::Decode(instr);
 
-    // Signal the backend that this shader uses warp instructions.
-    uses_warps = true;
-
     switch (opcode->get().GetId()) {
     case OpCode::Id::VOTE: {
         const Node value = GetPredicate(instr.vote.value, instr.vote.negate_value != 0);

src/video_core/shader/node.h

@@ -68,7 +68,6 @@ enum class OperationCode {
     IBitfieldInsert,       /// (MetaArithmetic, int base, int insert, int offset, int bits) -> int
     IBitfieldExtract,      /// (MetaArithmetic, int value, int offset, int offset) -> int
     IBitCount,             /// (MetaArithmetic, int) -> int
-    IBitMSB,               /// (MetaArithmetic, int) -> int
 
     UAdd,                  /// (MetaArithmetic, uint a, uint b) -> uint
     UMul,                  /// (MetaArithmetic, uint a, uint b) -> uint
@@ -87,7 +86,6 @@ enum class OperationCode {
     UBitfieldInsert,  /// (MetaArithmetic, uint base, uint insert, int offset, int bits) -> uint
     UBitfieldExtract, /// (MetaArithmetic, uint value, int offset, int offset) -> uint
     UBitCount,        /// (MetaArithmetic, uint) -> uint
-    UBitMSB,          /// (MetaArithmetic, uint) -> uint
 
     HAdd,       /// (MetaArithmetic, f16vec2 a, f16vec2 b) -> f16vec2
     HMul,       /// (MetaArithmetic, f16vec2 a, f16vec2 b) -> f16vec2
@@ -151,7 +149,6 @@ enum class OperationCode {
     TextureQueryDimensions, /// (MetaTexture, float a) -> float4
     TextureQueryLod,        /// (MetaTexture, float[N] coords) -> float4
     TexelFetch,             /// (MetaTexture, int[N], int) -> float4
-    TextureGradient,        /// (MetaTexture, float[N] coords, float[N*2] derivates) -> float4
 
     ImageLoad,  /// (MetaImage, int[N] coords) -> void
     ImageStore, /// (MetaImage, int[N] coords) -> void
@@ -172,7 +169,6 @@ enum class OperationCode {
     EmitVertex,   /// () -> void
     EndPrimitive, /// () -> void
 
-    InvocationId,       /// () -> int
     YNegate,            /// () -> float
     LocalInvocationIdX, /// () -> uint
     LocalInvocationIdY, /// () -> uint
@@ -189,8 +185,6 @@ enum class OperationCode {
     ThreadId,       /// () -> uint
     ShuffleIndexed, /// (uint value, uint index) -> uint
 
-    MemoryBarrierGL, /// () -> void
-
     Amount,
 };
 
@@ -216,14 +210,13 @@ class PredicateNode;
 class AbufNode;
 class CbufNode;
 class LmemNode;
-class PatchNode;
 class SmemNode;
 class GmemNode;
 class CommentNode;
 
-using NodeData = std::variant<OperationNode, ConditionalNode, GprNode, ImmediateNode,
-                              InternalFlagNode, PredicateNode, AbufNode, PatchNode, CbufNode,
-                              LmemNode, SmemNode, GmemNode, CommentNode>;
+using NodeData =
+    std::variant<OperationNode, ConditionalNode, GprNode, ImmediateNode, InternalFlagNode,
+                 PredicateNode, AbufNode, CbufNode, LmemNode, SmemNode, GmemNode, CommentNode>;
 using Node = std::shared_ptr<NodeData>;
 using Node4 = std::array<Node, 4>;
 using NodeBlock = std::vector<Node>;
@@ -374,7 +367,6 @@ struct MetaTexture {
     Node array;
     Node depth_compare;
     std::vector<Node> aoffi;
-    std::vector<Node> derivates;
     Node bias;
     Node lod;
     Node component{};
@@ -546,19 +538,6 @@ private:
     u32 element{};
 };
 
-/// Patch memory (used to communicate tessellation stages).
-class PatchNode final {
-public:
-    explicit PatchNode(u32 offset) : offset{offset} {}
-
-    u32 GetOffset() const {
-        return offset;
-    }
-
-private:
-    u32 offset{};
-};
-
 /// Constant buffer node, usually mapped to uniform buffers in GLSL
 class CbufNode final {
 public:

src/video_core/shader/shader_ir.h

@@ -137,10 +137,6 @@ public:
         return uses_vertex_id;
     }
 
-    bool UsesWarps() const {
-        return uses_warps;
-    }
-
     bool HasPhysicalAttributes() const {
         return uses_physical_attributes;
     }
@@ -419,7 +415,6 @@ private:
     bool uses_physical_attributes{}; // Shader uses AL2P or physical attribute read/writes
     bool uses_instance_id{};
     bool uses_vertex_id{};
-    bool uses_warps{};
 
     Tegra::Shader::Header header;
 };

src/video_core/shader/track.cpp

@@ -7,7 +7,6 @@
 #include <variant>
 
 #include "common/common_types.h"
-#include "video_core/shader/node.h"
 #include "video_core/shader/shader_ir.h"
 
 namespace VideoCommon::Shader {