input_common: Fix pro controller amiibo support

configure_graphics: Add option to enable compute pipelines for Intel proprietary

src/common/settings.cpp

@@ -232,6 +232,7 @@ void RestoreGlobalState(bool is_powered_on) {
     values.bg_red.SetGlobal(true);
     values.bg_green.SetGlobal(true);
     values.bg_blue.SetGlobal(true);
+    values.enable_compute_pipelines.SetGlobal(true);
 
     // System
     values.language_index.SetGlobal(true);

src/common/settings.h

@@ -472,6 +472,7 @@ struct Values {
     SwitchableSetting<bool> use_fast_gpu_time{true, "use_fast_gpu_time"};
     SwitchableSetting<bool> use_vulkan_driver_pipeline_cache{true,
                                                              "use_vulkan_driver_pipeline_cache"};
+    SwitchableSetting<bool> enable_compute_pipelines{false, "enable_compute_pipelines"};
 
     SwitchableSetting<u8> bg_red{0, "bg_red"};
     SwitchableSetting<u8> bg_green{0, "bg_green"};

src/core/hle/service/hid/controllers/npad.cpp

@@ -979,8 +979,8 @@ void Controller_NPad::VibrateController(
 }
 
 void Controller_NPad::VibrateControllers(
-    const std::vector<Core::HID::VibrationDeviceHandle>& vibration_device_handles,
-    const std::vector<Core::HID::VibrationValue>& vibration_values) {
+    std::span<const Core::HID::VibrationDeviceHandle> vibration_device_handles,
+    std::span<const Core::HID::VibrationValue> vibration_values) {
     if (!Settings::values.vibration_enabled.GetValue() && !permit_vibration_session_enabled) {
         return;
     }

src/core/hle/service/hid/controllers/npad.h

@@ -112,8 +112,8 @@ public:
                            const Core::HID::VibrationValue& vibration_value);
 
     void VibrateControllers(
-        const std::vector<Core::HID::VibrationDeviceHandle>& vibration_device_handles,
-        const std::vector<Core::HID::VibrationValue>& vibration_values);
+        std::span<const Core::HID::VibrationDeviceHandle> vibration_device_handles,
+        std::span<const Core::HID::VibrationValue> vibration_values);
 
     Core::HID::VibrationValue GetLastVibration(
         const Core::HID::VibrationDeviceHandle& vibration_device_handle) const;

src/core/hle/service/hid/hid.cpp

@@ -1601,16 +1601,16 @@ void Hid::SendVibrationValues(HLERequestContext& ctx) {
     IPC::RequestParser rp{ctx};
     const auto applet_resource_user_id{rp.Pop<u64>()};
 
-    const auto handles = ctx.ReadBuffer(0);
-    const auto vibrations = ctx.ReadBuffer(1);
+    const auto handle_data = ctx.ReadBuffer(0);
+    const auto handle_count = ctx.GetReadBufferNumElements<Core::HID::VibrationDeviceHandle>(0);
+    const auto vibration_data = ctx.ReadBuffer(1);
+    const auto vibration_count = ctx.GetReadBufferNumElements<Core::HID::VibrationValue>(1);
 
-    std::vector<Core::HID::VibrationDeviceHandle> vibration_device_handles(
-        handles.size() / sizeof(Core::HID::VibrationDeviceHandle));
-    std::vector<Core::HID::VibrationValue> vibration_values(vibrations.size() /
-                                                            sizeof(Core::HID::VibrationValue));
-
-    std::memcpy(vibration_device_handles.data(), handles.data(), handles.size());
-    std::memcpy(vibration_values.data(), vibrations.data(), vibrations.size());
+    auto vibration_device_handles =
+        std::span(reinterpret_cast<const Core::HID::VibrationDeviceHandle*>(handle_data.data()),
+                  handle_count);
+    auto vibration_values = std::span(
+        reinterpret_cast<const Core::HID::VibrationValue*>(vibration_data.data()), vibration_count);
 
     applet_resource->GetController<Controller_NPad>(HidController::NPad)
         .VibrateControllers(vibration_device_handles, vibration_values);

src/input_common/drivers/joycon.cpp

@@ -195,8 +195,8 @@ void Joycons::RegisterNewDevice(SDL_hid_device_info* device_info) {
                 OnMotionUpdate(port, type, id, value);
             }},
             .on_ring_data = {[this](f32 ring_data) { OnRingConUpdate(ring_data); }},
-            .on_amiibo_data = {[this, port](const std::vector<u8>& amiibo_data) {
-                OnAmiiboUpdate(port, amiibo_data);
+            .on_amiibo_data = {[this, port, type](const std::vector<u8>& amiibo_data) {
+                OnAmiiboUpdate(port, type, amiibo_data);
             }},
             .on_camera_data = {[this, port](const std::vector<u8>& camera_data,
                                             Joycon::IrsResolution format) {
@@ -398,8 +398,9 @@ void Joycons::OnRingConUpdate(f32 ring_data) {
     SetAxis(identifier, 100, ring_data);
 }
 
-void Joycons::OnAmiiboUpdate(std::size_t port, const std::vector<u8>& amiibo_data) {
-    const auto identifier = GetIdentifier(port, Joycon::ControllerType::Right);
+void Joycons::OnAmiiboUpdate(std::size_t port, Joycon::ControllerType type,
+                             const std::vector<u8>& amiibo_data) {
+    const auto identifier = GetIdentifier(port, type);
     const auto nfc_state = amiibo_data.empty() ? Common::Input::NfcState::AmiiboRemoved
                                                : Common::Input::NfcState::NewAmiibo;
     SetNfc(identifier, {nfc_state, amiibo_data});

src/input_common/drivers/joycon.h

@@ -81,7 +81,8 @@ private:
     void OnMotionUpdate(std::size_t port, Joycon::ControllerType type, int id,
                         const Joycon::MotionData& value);
     void OnRingConUpdate(f32 ring_data);
-    void OnAmiiboUpdate(std::size_t port, const std::vector<u8>& amiibo_data);
+    void OnAmiiboUpdate(std::size_t port, Joycon::ControllerType type,
+                        const std::vector<u8>& amiibo_data);
     void OnCameraUpdate(std::size_t port, const std::vector<u8>& camera_data,
                         Joycon::IrsResolution format);
 

src/input_common/helpers/joycon_protocol/common_protocol.cpp

@@ -265,7 +265,7 @@ DriverResult JoyconCommonProtocol::SendMCUData(ReportMode report_mode, MCUSubCom
 
 DriverResult JoyconCommonProtocol::WaitSetMCUMode(ReportMode report_mode, MCUMode mode) {
     MCUCommandResponse output{};
-    constexpr std::size_t MaxTries{8};
+    constexpr std::size_t MaxTries{16};
     std::size_t tries{};
 
     do {

src/input_common/helpers/joycon_protocol/joycon_types.h

@@ -394,6 +394,7 @@ enum class DriverResult {
     InvalidHandle,
     NotSupported,
     Disabled,
+    Delayed,
     Unknown,
 };
 
@@ -576,8 +577,8 @@ static_assert(sizeof(NFCPollingCommandData) == 0x05, "NFCPollingCommandData is a
 
 struct NFCRequestState {
     NFCReadCommand command_argument;
-    u8 packet_id;
     INSERT_PADDING_BYTES(0x1);
+    u8 packet_id;
     MCUPacketFlag packet_flag;
     u8 data_length;
     union {

src/input_common/helpers/joycon_protocol/nfc.cpp

@@ -64,6 +64,20 @@ DriverResult NfcProtocol::StartNFCPollingMode() {
     if (result == DriverResult::Success) {
         result = WaitUntilNfcIsReady();
     }
+    if (result == DriverResult::Success) {
+        MCUCommandResponse output{};
+        result = SendStopPollingRequest(output);
+    }
+    if (result == DriverResult::Success) {
+        result = WaitUntilNfcIsReady();
+    }
+    if (result == DriverResult::Success) {
+        MCUCommandResponse output{};
+        result = SendStartPollingRequest(output);
+    }
+    if (result == DriverResult::Success) {
+        result = WaitUntilNfcIsPolling();
+    }
     if (result == DriverResult::Success) {
         is_enabled = true;
     }
@@ -72,24 +86,26 @@ DriverResult NfcProtocol::StartNFCPollingMode() {
 }
 
 DriverResult NfcProtocol::ScanAmiibo(std::vector<u8>& data) {
-    LOG_DEBUG(Input, "Start NFC pooling Mode");
+    if (update_counter++ < AMIIBO_UPDATE_DELAY) {
+        return DriverResult::Delayed;
+    }
+    update_counter = 0;
+
+    LOG_DEBUG(Input, "Scan for amiibos");
     ScopedSetBlocking sb(this);
     DriverResult result{DriverResult::Success};
     TagFoundData tag_data{};
 
     if (result == DriverResult::Success) {
-        result = StartPolling(tag_data);
-    }
-    if (result == DriverResult::Success) {
-        result = ReadTag(tag_data);
-    }
-    if (result == DriverResult::Success) {
-        result = WaitUntilNfcIsReady();
-    }
-    if (result == DriverResult::Success) {
-        result = StartPolling(tag_data);
+        result = IsTagInRange(tag_data);
     }
+
     if (result == DriverResult::Success) {
+        std::string uuid_string;
+        for (auto& content : tag_data.uuid) {
+            uuid_string += fmt::format(" {:02x}", content);
+        }
+        LOG_INFO(Input, "Tag detected, type={}, uuid={}", tag_data.type, uuid_string);
         result = GetAmiiboData(data);
     }
 
@@ -97,12 +113,17 @@ DriverResult NfcProtocol::ScanAmiibo(std::vector<u8>& data) {
 }
 
 bool NfcProtocol::HasAmiibo() {
+    if (update_counter++ < AMIIBO_UPDATE_DELAY) {
+        return true;
+    }
+    update_counter = 0;
+
     ScopedSetBlocking sb(this);
     DriverResult result{DriverResult::Success};
     TagFoundData tag_data{};
 
     if (result == DriverResult::Success) {
-        result = StartPolling(tag_data);
+        result = IsTagInRange(tag_data, 7);
     }
 
     return result == DriverResult::Success;
@@ -114,7 +135,7 @@ DriverResult NfcProtocol::WaitUntilNfcIsReady() {
     std::size_t tries = 0;
 
     do {
-        auto result = SendStartWaitingRecieveRequest(output);
+        auto result = SendNextPackageRequest(output, {});
 
         if (result != DriverResult::Success) {
             return result;
@@ -129,14 +150,14 @@ DriverResult NfcProtocol::WaitUntilNfcIsReady() {
     return DriverResult::Success;
 }
 
-DriverResult NfcProtocol::StartPolling(TagFoundData& data) {
-    LOG_DEBUG(Input, "Start Polling for tag");
-    constexpr std::size_t timeout_limit = 7;
+DriverResult NfcProtocol::WaitUntilNfcIsPolling() {
+    constexpr std::size_t timeout_limit = 10;
     MCUCommandResponse output{};
     std::size_t tries = 0;
 
     do {
-        const auto result = SendStartPollingRequest(output);
+        auto result = SendNextPackageRequest(output, {});
+
         if (result != DriverResult::Success) {
             return result;
         }
@@ -145,7 +166,26 @@ DriverResult NfcProtocol::StartPolling(TagFoundData& data) {
         }
     } while (output.mcu_report != MCUReport::NFCState ||
              (output.mcu_data[1] << 8) + output.mcu_data[0] != 0x0500 ||
-             output.mcu_data[6] != 0x09);
+             output.mcu_data[5] != 0x31 || output.mcu_data[6] != 0x01);
+
+    return DriverResult::Success;
+}
+
+DriverResult NfcProtocol::IsTagInRange(TagFoundData& data, std::size_t timeout_limit) {
+    MCUCommandResponse output{};
+    std::size_t tries = 0;
+
+    do {
+        const auto result = SendNextPackageRequest(output, {});
+        if (result != DriverResult::Success) {
+            return result;
+        }
+        if (tries++ > timeout_limit) {
+            return DriverResult::Timeout;
+        }
+    } while (output.mcu_report != MCUReport::NFCState ||
+             (output.mcu_data[1] << 8) + output.mcu_data[0] != 0x0500 ||
+             (output.mcu_data[6] != 0x09 && output.mcu_data[6] != 0x04));
 
     data.type = output.mcu_data[12];
     data.uuid.resize(output.mcu_data[14]);
@@ -154,85 +194,22 @@ DriverResult NfcProtocol::StartPolling(TagFoundData& data) {
     return DriverResult::Success;
 }
 
-DriverResult NfcProtocol::ReadTag(const TagFoundData& data) {
-    constexpr std::size_t timeout_limit = 10;
-    MCUCommandResponse output{};
-    std::size_t tries = 0;
-
-    std::string uuid_string;
-    for (auto& content : data.uuid) {
-        uuid_string += fmt::format(" {:02x}", content);
-    }
-
-    LOG_INFO(Input, "Tag detected, type={}, uuid={}", data.type, uuid_string);
-
-    tries = 0;
-    NFCPages ntag_pages = NFCPages::Block0;
-    // Read Tag data
-    while (true) {
-        auto result = SendReadAmiiboRequest(output, ntag_pages);
-        const auto nfc_status = static_cast<NFCStatus>(output.mcu_data[6]);
-
-        if (result != DriverResult::Success) {
-            return result;
-        }
-
-        if ((output.mcu_report == MCUReport::NFCReadData ||
-             output.mcu_report == MCUReport::NFCState) &&
-            nfc_status == NFCStatus::TagLost) {
-            return DriverResult::ErrorReadingData;
-        }
-
-        if (output.mcu_report == MCUReport::NFCReadData && output.mcu_data[1] == 0x07 &&
-            output.mcu_data[2] == 0x01) {
-            if (data.type != 2) {
-                continue;
-            }
-            switch (output.mcu_data[24]) {
-            case 0:
-                ntag_pages = NFCPages::Block135;
-                break;
-            case 3:
-                ntag_pages = NFCPages::Block45;
-                break;
-            case 4:
-                ntag_pages = NFCPages::Block231;
-                break;
-            default:
-                return DriverResult::ErrorReadingData;
-            }
-            continue;
-        }
-
-        if (output.mcu_report == MCUReport::NFCState && nfc_status == NFCStatus::LastPackage) {
-            // finished
-            SendStopPollingRequest(output);
-            return DriverResult::Success;
-        }
-
-        // Ignore other state reports
-        if (output.mcu_report == MCUReport::NFCState) {
-            continue;
-        }
-
-        if (tries++ > timeout_limit) {
-            return DriverResult::Timeout;
-        }
-    }
-
-    return DriverResult::Success;
-}
-
 DriverResult NfcProtocol::GetAmiiboData(std::vector<u8>& ntag_data) {
-    constexpr std::size_t timeout_limit = 10;
+    constexpr std::size_t timeout_limit = 60;
     MCUCommandResponse output{};
     std::size_t tries = 0;
 
-    NFCPages ntag_pages = NFCPages::Block135;
+    u8 package_index = 0;
     std::size_t ntag_buffer_pos = 0;
+    auto result = SendReadAmiiboRequest(output, NFCPages::Block135);
+
+    if (result != DriverResult::Success) {
+        return result;
+    }
+
     // Read Tag data
-    while (true) {
-        auto result = SendReadAmiiboRequest(output, ntag_pages);
+    while (tries++ < timeout_limit) {
+        result = SendNextPackageRequest(output, package_index);
         const auto nfc_status = static_cast<NFCStatus>(output.mcu_data[6]);
 
         if (result != DriverResult::Success) {
@@ -255,6 +232,7 @@ DriverResult NfcProtocol::GetAmiiboData(std::vector<u8>& ntag_data) {
                 memcpy(ntag_data.data() + ntag_buffer_pos, output.mcu_data.data() + 6,
                        payload_size);
             }
+            package_index++;
             continue;
         }
 
@@ -262,18 +240,9 @@ DriverResult NfcProtocol::GetAmiiboData(std::vector<u8>& ntag_data) {
             LOG_INFO(Input, "Finished reading amiibo");
             return DriverResult::Success;
         }
-
-        // Ignore other state reports
-        if (output.mcu_report == MCUReport::NFCState) {
-            continue;
-        }
-
-        if (tries++ > timeout_limit) {
-            return DriverResult::Timeout;
-        }
     }
 
-    return DriverResult::Success;
+    return DriverResult::Timeout;
 }
 
 DriverResult NfcProtocol::SendStartPollingRequest(MCUCommandResponse& output) {
@@ -317,10 +286,10 @@ DriverResult NfcProtocol::SendStopPollingRequest(MCUCommandResponse& output) {
                        output);
 }
 
-DriverResult NfcProtocol::SendStartWaitingRecieveRequest(MCUCommandResponse& output) {
+DriverResult NfcProtocol::SendNextPackageRequest(MCUCommandResponse& output, u8 packet_id) {
     NFCRequestState request{
         .command_argument = NFCReadCommand::StartWaitingRecieve,
-        .packet_id = 0x0,
+        .packet_id = packet_id,
         .packet_flag = MCUPacketFlag::LastCommandPacket,
         .data_length = 0,
         .raw_data = {},

src/input_common/helpers/joycon_protocol/nfc.h

@@ -32,6 +32,9 @@ public:
     bool IsEnabled() const;
 
 private:
+    // Number of times the function will be delayed until it outputs valid data
+    static constexpr std::size_t AMIIBO_UPDATE_DELAY = 15;
+
     struct TagFoundData {
         u8 type;
         std::vector<u8> uuid;
@@ -39,9 +42,9 @@ private:
 
     DriverResult WaitUntilNfcIsReady();
 
-    DriverResult StartPolling(TagFoundData& data);
+    DriverResult WaitUntilNfcIsPolling();
 
-    DriverResult ReadTag(const TagFoundData& data);
+    DriverResult IsTagInRange(TagFoundData& data, std::size_t timeout_limit = 1);
 
     DriverResult GetAmiiboData(std::vector<u8>& data);
 
@@ -49,13 +52,14 @@ private:
 
     DriverResult SendStopPollingRequest(MCUCommandResponse& output);
 
-    DriverResult SendStartWaitingRecieveRequest(MCUCommandResponse& output);
+    DriverResult SendNextPackageRequest(MCUCommandResponse& output, u8 packet_id);
 
     DriverResult SendReadAmiiboRequest(MCUCommandResponse& output, NFCPages ntag_pages);
 
     NFCReadBlockCommand GetReadBlockCommand(NFCPages pages) const;
 
     bool is_enabled{};
+    std::size_t update_counter{};
 };
 
 } // namespace InputCommon::Joycon

src/shader_recompiler/backend/spirv/emit_spirv_context_get_set.cpp

@@ -339,9 +339,7 @@ Id EmitGetAttribute(EmitContext& ctx, IR::Attribute attr, Id vertex) {
         if (ctx.profile.support_vertex_instance_id) {
             return ctx.OpBitcast(ctx.F32[1], ctx.OpLoad(ctx.U32[1], ctx.vertex_id));
         } else {
-            const Id index{ctx.OpLoad(ctx.U32[1], ctx.vertex_index)};
-            const Id base{ctx.OpLoad(ctx.U32[1], ctx.base_vertex)};
-            return ctx.OpBitcast(ctx.F32[1], ctx.OpISub(ctx.U32[1], index, base));
+            return ctx.OpBitcast(ctx.F32[1], ctx.OpLoad(ctx.U32[1], ctx.vertex_index));
         }
     case IR::Attribute::BaseInstance:
         return ctx.OpBitcast(ctx.F32[1], ctx.OpLoad(ctx.U32[1], ctx.base_instance));
@@ -386,9 +384,7 @@ Id EmitGetAttributeU32(EmitContext& ctx, IR::Attribute attr, Id) {
         if (ctx.profile.support_vertex_instance_id) {
             return ctx.OpLoad(ctx.U32[1], ctx.vertex_id);
         } else {
-            const Id index{ctx.OpLoad(ctx.U32[1], ctx.vertex_index)};
-            const Id base{ctx.OpLoad(ctx.U32[1], ctx.base_vertex)};
-            return ctx.OpISub(ctx.U32[1], index, base);
+            return ctx.OpLoad(ctx.U32[1], ctx.vertex_index);
         }
     case IR::Attribute::BaseInstance:
         return ctx.OpLoad(ctx.U32[1], ctx.base_instance);

src/shader_recompiler/frontend/maxwell/translate/impl/texture_mipmap_level.cpp

@@ -102,12 +102,7 @@ void Impl(TranslatorVisitor& v, u64 insn, bool is_bindless) {
         }
         IR::F32 value{v.ir.CompositeExtract(sample, element)};
         if (element < 2) {
-            IR::U32 casted_value;
-            if (element == 0) {
-                casted_value = v.ir.ConvertFToU(32, value);
-            } else {
-                casted_value = v.ir.ConvertFToS(16, value);
-            }
+            IR::U32 casted_value = v.ir.ConvertFToU(32, value);
             v.X(dest_reg, v.ir.ShiftLeftLogical(casted_value, v.ir.Imm32(8)));
         } else {
             v.F(dest_reg, value);

src/video_core/buffer_cache/buffer_cache.h

@@ -131,33 +131,15 @@ std::optional<VideoCore::RasterizerDownloadArea> BufferCache<P>::GetFlushArea(VA
 
 template <class P>
 void BufferCache<P>::DownloadMemory(VAddr cpu_addr, u64 size) {
-    WaitOnAsyncFlushes(cpu_addr, size);
     ForEachBufferInRange(cpu_addr, size, [&](BufferId, Buffer& buffer) {
         DownloadBufferMemory(buffer, cpu_addr, size);
     });
 }
 
-template <class P>
-void BufferCache<P>::WaitOnAsyncFlushes(VAddr cpu_addr, u64 size) {
-    bool must_wait = false;
-    ForEachInOverlapCounter(async_downloads, cpu_addr, size,
-                            [&](VAddr, VAddr, int) { must_wait = true; });
-    bool must_release = false;
-    ForEachInRangeSet(pending_ranges, cpu_addr, size, [&](VAddr, VAddr) { must_release = true; });
-    if (must_release) {
-        std::function<void()> tmp([]() {});
-        rasterizer.SignalFence(std::move(tmp));
-    }
-    if (must_wait || must_release) {
-        rasterizer.ReleaseFences();
-    }
-}
-
 template <class P>
 void BufferCache<P>::ClearDownload(IntervalType subtract_interval) {
     RemoveEachInOverlapCounter(async_downloads, subtract_interval, -1024);
     uncommitted_ranges.subtract(subtract_interval);
-    pending_ranges.subtract(subtract_interval);
     for (auto& interval_set : committed_ranges) {
         interval_set.subtract(subtract_interval);
     }
@@ -177,7 +159,6 @@ bool BufferCache<P>::DMACopy(GPUVAddr src_address, GPUVAddr dest_address, u64 am
     }
 
     const IntervalType subtract_interval{*cpu_dest_address, *cpu_dest_address + amount};
-    WaitOnAsyncFlushes(*cpu_src_address, static_cast<u32>(amount));
     ClearDownload(subtract_interval);
 
     BufferId buffer_a;
@@ -205,7 +186,6 @@ bool BufferCache<P>::DMACopy(GPUVAddr src_address, GPUVAddr dest_address, u64 am
         const IntervalType add_interval{new_base_address, new_base_address + size};
         tmp_intervals.push_back(add_interval);
         uncommitted_ranges.add(add_interval);
-        pending_ranges.add(add_interval);
     };
     ForEachInRangeSet(common_ranges, *cpu_src_address, amount, mirror);
     // This subtraction in this order is important for overlapping copies.
@@ -492,7 +472,6 @@ void BufferCache<P>::CommitAsyncFlushesHigh() {
     }
     MICROPROFILE_SCOPE(GPU_DownloadMemory);
 
-    pending_ranges.clear();
     auto it = committed_ranges.begin();
     while (it != committed_ranges.end()) {
         auto& current_intervals = *it;
@@ -1232,7 +1211,6 @@ void BufferCache<P>::MarkWrittenBuffer(BufferId buffer_id, VAddr cpu_addr, u32 s
     const IntervalType base_interval{cpu_addr, cpu_addr + size};
     common_ranges.add(base_interval);
     uncommitted_ranges.add(base_interval);
-    pending_ranges.add(base_interval);
 }
 
 template <class P>
@@ -1677,14 +1655,15 @@ typename BufferCache<P>::Binding BufferCache<P>::StorageBufferBinding(GPUVAddr s
         const bool is_nvn_cbuf = cbuf_index == 0;
         // The NVN driver buffer (index 0) is known to pack the SSBO address followed by its size.
         if (is_nvn_cbuf) {
-            return gpu_memory->Read<u32>(ssbo_addr + 8);
+            const u32 ssbo_size = gpu_memory->Read<u32>(ssbo_addr + 8);
+            if (ssbo_size != 0) {
+                return ssbo_size;
+            }
         }
         // Other titles (notably Doom Eternal) may use STG/LDG on buffer addresses in custom defined
         // cbufs, which do not store the sizes adjacent to the addresses, so use the fully
         // mapped buffer size for now.
         const u32 memory_layout_size = static_cast<u32>(gpu_memory->GetMemoryLayoutSize(gpu_addr));
-        LOG_INFO(HW_GPU, "Binding storage buffer for cbuf index {}, MemoryLayoutSize 0x{:X}",
-                 cbuf_index, memory_layout_size);
         return memory_layout_size;
     }();
     const std::optional<VAddr> cpu_addr = gpu_memory->GpuToCpuAddress(gpu_addr);

src/video_core/buffer_cache/buffer_cache_base.h

@@ -381,8 +381,6 @@ private:
 
     void RunGarbageCollector();
 
-    void WaitOnAsyncFlushes(VAddr cpu_addr, u64 size);
-
     void BindHostIndexBuffer();
 
     void BindHostVertexBuffers();
@@ -547,7 +545,6 @@ private:
     IntervalSet uncommitted_ranges;
     IntervalSet common_ranges;
     IntervalSet cached_ranges;
-    IntervalSet pending_ranges;
     std::deque<IntervalSet> committed_ranges;
 
     // Async Buffers

src/video_core/host1x/codecs/h264.cpp

@@ -111,7 +111,7 @@ const std::vector<u8>& H264::ComposeFrame(const Host1x::NvdecCommon::NvdecRegist
     writer.WriteUe(0);
 
     writer.WriteBit(context.h264_parameter_set.entropy_coding_mode_flag != 0);
-    writer.WriteBit(false);
+    writer.WriteBit(context.h264_parameter_set.pic_order_present_flag != 0);
     writer.WriteUe(0);
     writer.WriteUe(context.h264_parameter_set.num_refidx_l0_default_active);
     writer.WriteUe(context.h264_parameter_set.num_refidx_l1_default_active);
@@ -129,7 +129,7 @@ const std::vector<u8>& H264::ComposeFrame(const Host1x::NvdecCommon::NvdecRegist
     writer.WriteBit(context.h264_parameter_set.redundant_pic_cnt_present_flag != 0);
     writer.WriteBit(context.h264_parameter_set.transform_8x8_mode_flag != 0);
 
-    writer.WriteBit(true);
+    writer.WriteBit(true); // pic_scaling_matrix_present_flag
 
     for (s32 index = 0; index < 6; index++) {
         writer.WriteBit(true);

src/video_core/renderer_vulkan/vk_pipeline_cache.cpp

@@ -698,7 +698,8 @@ std::unique_ptr<ComputePipeline> PipelineCache::CreateComputePipeline(
     PipelineStatistics* statistics, bool build_in_parallel) try {
     // TODO: Remove this when Intel fixes their shader compiler.
     //       https://github.com/IGCIT/Intel-GPU-Community-Issue-Tracker-IGCIT/issues/159
-    if (device.GetDriverID() == VK_DRIVER_ID_INTEL_PROPRIETARY_WINDOWS) {
+    if (device.GetDriverID() == VK_DRIVER_ID_INTEL_PROPRIETARY_WINDOWS &&
+        !Settings::values.enable_compute_pipelines.GetValue()) {
         LOG_ERROR(Render_Vulkan, "Skipping 0x{:016x}", key.Hash());
         return nullptr;
     }

src/video_core/vulkan_common/vulkan_device.cpp

@@ -1009,6 +1009,8 @@ void Device::CollectPhysicalMemoryInfo() {
         device_access_memory += mem_properties.memoryHeaps[element].size;
     }
     if (!is_integrated) {
+        const u64 reserve_memory = std::min<u64>(device_access_memory / 8, 1_GiB);
+        device_access_memory -= reserve_memory;
         return;
     }
     const s64 available_memory = static_cast<s64>(device_access_memory - device_initial_usage);

src/yuzu/configuration/config.cpp

@@ -716,6 +716,7 @@ void Config::ReadRendererValues() {
     ReadGlobalSetting(Settings::values.use_asynchronous_shaders);
     ReadGlobalSetting(Settings::values.use_fast_gpu_time);
     ReadGlobalSetting(Settings::values.use_vulkan_driver_pipeline_cache);
+    ReadGlobalSetting(Settings::values.enable_compute_pipelines);
     ReadGlobalSetting(Settings::values.bg_red);
     ReadGlobalSetting(Settings::values.bg_green);
     ReadGlobalSetting(Settings::values.bg_blue);
@@ -1366,6 +1367,7 @@ void Config::SaveRendererValues() {
     WriteGlobalSetting(Settings::values.use_asynchronous_shaders);
     WriteGlobalSetting(Settings::values.use_fast_gpu_time);
     WriteGlobalSetting(Settings::values.use_vulkan_driver_pipeline_cache);
+    WriteGlobalSetting(Settings::values.enable_compute_pipelines);
     WriteGlobalSetting(Settings::values.bg_red);
     WriteGlobalSetting(Settings::values.bg_green);
     WriteGlobalSetting(Settings::values.bg_blue);

src/yuzu/configuration/configure_dialog.cpp

@@ -36,8 +36,9 @@ ConfigureDialog::ConfigureDialog(QWidget* parent, HotkeyRegistry& registry_,
       debug_tab_tab{std::make_unique<ConfigureDebugTab>(system_, this)},
       filesystem_tab{std::make_unique<ConfigureFilesystem>(this)},
       general_tab{std::make_unique<ConfigureGeneral>(system_, this)},
-      graphics_tab{std::make_unique<ConfigureGraphics>(system_, this)},
       graphics_advanced_tab{std::make_unique<ConfigureGraphicsAdvanced>(system_, this)},
+      graphics_tab{std::make_unique<ConfigureGraphics>(
+          system_, [&]() { graphics_advanced_tab->ExposeComputeOption(); }, this)},
       hotkeys_tab{std::make_unique<ConfigureHotkeys>(system_.HIDCore(), this)},
       input_tab{std::make_unique<ConfigureInput>(system_, this)},
       network_tab{std::make_unique<ConfigureNetwork>(system_, this)},

src/yuzu/configuration/configure_dialog.h

@@ -72,8 +72,8 @@ private:
     std::unique_ptr<ConfigureDebugTab> debug_tab_tab;
     std::unique_ptr<ConfigureFilesystem> filesystem_tab;
     std::unique_ptr<ConfigureGeneral> general_tab;
-    std::unique_ptr<ConfigureGraphics> graphics_tab;
     std::unique_ptr<ConfigureGraphicsAdvanced> graphics_advanced_tab;
+    std::unique_ptr<ConfigureGraphics> graphics_tab;
     std::unique_ptr<ConfigureHotkeys> hotkeys_tab;
     std::unique_ptr<ConfigureInput> input_tab;
     std::unique_ptr<ConfigureNetwork> network_tab;

src/yuzu/configuration/configure_graphics.cpp

@@ -2,9 +2,11 @@
 // SPDX-License-Identifier: GPL-2.0-or-later
 
 // Include this early to include Vulkan headers how we want to
+#include "video_core/vulkan_common/vulkan_device.h"
 #include "video_core/vulkan_common/vulkan_wrapper.h"
 
 #include <algorithm>
+#include <functional>
 #include <iosfwd>
 #include <iterator>
 #include <string>
@@ -74,8 +76,11 @@ static constexpr Settings::VSyncMode PresentModeToSetting(VkPresentModeKHR mode)
     }
 }
 
-ConfigureGraphics::ConfigureGraphics(const Core::System& system_, QWidget* parent)
-    : QWidget(parent), ui{std::make_unique<Ui::ConfigureGraphics>()}, system{system_} {
+ConfigureGraphics::ConfigureGraphics(const Core::System& system_,
+                                     const std::function<void()>& expose_compute_option_,
+                                     QWidget* parent)
+    : QWidget(parent), ui{std::make_unique<Ui::ConfigureGraphics>()},
+      expose_compute_option{expose_compute_option_}, system{system_} {
     vulkan_device = Settings::values.vulkan_device.GetValue();
     RetrieveVulkanDevices();
 
@@ -513,8 +518,7 @@ void ConfigureGraphics::RetrieveVulkanDevices() try {
     const Common::DynamicLibrary library = OpenLibrary();
     const vk::Instance instance = CreateInstance(library, dld, VK_API_VERSION_1_1, wsi.type);
     const std::vector<VkPhysicalDevice> physical_devices = instance.EnumeratePhysicalDevices();
-    vk::SurfaceKHR surface = //< needed to view present modes for a device
-        CreateSurface(instance, wsi);
+    vk::SurfaceKHR surface = CreateSurface(instance, wsi);
 
     vulkan_devices.clear();
     vulkan_devices.reserve(physical_devices.size());
@@ -527,6 +531,17 @@ void ConfigureGraphics::RetrieveVulkanDevices() try {
             physical_device.GetSurfacePresentModesKHR(*surface);
         vulkan_devices.push_back(QString::fromStdString(name));
         device_present_modes.push_back(present_modes);
+
+        VkPhysicalDeviceDriverProperties driver_properties{};
+        driver_properties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES;
+        driver_properties.pNext = nullptr;
+        VkPhysicalDeviceProperties2 properties{};
+        properties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR;
+        properties.pNext = &driver_properties;
+        dld.vkGetPhysicalDeviceProperties2(physical_device, &properties);
+        if (driver_properties.driverID == VK_DRIVER_ID_INTEL_PROPRIETARY_WINDOWS) {
+            expose_compute_option();
+        }
     }
 } catch (const Vulkan::vk::Exception& exception) {
     LOG_ERROR(Frontend, "Failed to enumerate devices with error: {}", exception.what());

src/yuzu/configuration/configure_graphics.h

@@ -3,6 +3,7 @@
 
 #pragma once
 
+#include <functional>
 #include <memory>
 #include <vector>
 #include <QColor>
@@ -37,7 +38,9 @@ class ConfigureGraphics : public QWidget {
     Q_OBJECT
 
 public:
-    explicit ConfigureGraphics(const Core::System& system_, QWidget* parent = nullptr);
+    explicit ConfigureGraphics(const Core::System& system_,
+                               const std::function<void()>& expose_compute_option_,
+                               QWidget* parent = nullptr);
     ~ConfigureGraphics() override;
 
     void ApplyConfiguration();
@@ -81,6 +84,7 @@ private:
                                       // selection in the combobox
     u32 vulkan_device{};
     Settings::ShaderBackend shader_backend{};
+    const std::function<void()>& expose_compute_option;
 
     const Core::System& system;
 };

src/yuzu/configuration/configure_graphics_advanced.cpp

@@ -15,6 +15,8 @@ ConfigureGraphicsAdvanced::ConfigureGraphicsAdvanced(const Core::System& system_
     SetupPerGameUI();
 
     SetConfiguration();
+
+    ui->enable_compute_pipelines_checkbox->setVisible(false);
 }
 
 ConfigureGraphicsAdvanced::~ConfigureGraphicsAdvanced() = default;
@@ -27,6 +29,7 @@ void ConfigureGraphicsAdvanced::SetConfiguration() {
     ui->async_astc->setEnabled(runtime_lock);
     ui->use_asynchronous_shaders->setEnabled(runtime_lock);
     ui->anisotropic_filtering_combobox->setEnabled(runtime_lock);
+    ui->enable_compute_pipelines_checkbox->setEnabled(runtime_lock);
 
     ui->async_present->setChecked(Settings::values.async_presentation.GetValue());
     ui->renderer_force_max_clock->setChecked(Settings::values.renderer_force_max_clock.GetValue());
@@ -36,6 +39,8 @@ void ConfigureGraphicsAdvanced::SetConfiguration() {
     ui->use_fast_gpu_time->setChecked(Settings::values.use_fast_gpu_time.GetValue());
     ui->use_vulkan_driver_pipeline_cache->setChecked(
         Settings::values.use_vulkan_driver_pipeline_cache.GetValue());
+    ui->enable_compute_pipelines_checkbox->setChecked(
+        Settings::values.enable_compute_pipelines.GetValue());
 
     if (Settings::IsConfiguringGlobal()) {
         ui->gpu_accuracy->setCurrentIndex(
@@ -74,6 +79,9 @@ void ConfigureGraphicsAdvanced::ApplyConfiguration() {
     ConfigurationShared::ApplyPerGameSetting(&Settings::values.use_vulkan_driver_pipeline_cache,
                                              ui->use_vulkan_driver_pipeline_cache,
                                              use_vulkan_driver_pipeline_cache);
+    ConfigurationShared::ApplyPerGameSetting(&Settings::values.enable_compute_pipelines,
+                                             ui->enable_compute_pipelines_checkbox,
+                                             enable_compute_pipelines);
 }
 
 void ConfigureGraphicsAdvanced::changeEvent(QEvent* event) {
@@ -104,6 +112,8 @@ void ConfigureGraphicsAdvanced::SetupPerGameUI() {
             Settings::values.use_vulkan_driver_pipeline_cache.UsingGlobal());
         ui->anisotropic_filtering_combobox->setEnabled(
             Settings::values.max_anisotropy.UsingGlobal());
+        ui->enable_compute_pipelines_checkbox->setEnabled(
+            Settings::values.enable_compute_pipelines.UsingGlobal());
 
         return;
     }
@@ -125,6 +135,9 @@ void ConfigureGraphicsAdvanced::SetupPerGameUI() {
     ConfigurationShared::SetColoredTristate(ui->use_vulkan_driver_pipeline_cache,
                                             Settings::values.use_vulkan_driver_pipeline_cache,
                                             use_vulkan_driver_pipeline_cache);
+    ConfigurationShared::SetColoredTristate(ui->enable_compute_pipelines_checkbox,
+                                            Settings::values.enable_compute_pipelines,
+                                            enable_compute_pipelines);
     ConfigurationShared::SetColoredComboBox(
         ui->gpu_accuracy, ui->label_gpu_accuracy,
         static_cast<int>(Settings::values.gpu_accuracy.GetValue(true)));
@@ -132,3 +145,7 @@ void ConfigureGraphicsAdvanced::SetupPerGameUI() {
         ui->anisotropic_filtering_combobox, ui->af_label,
         static_cast<int>(Settings::values.max_anisotropy.GetValue(true)));
 }
+
+void ConfigureGraphicsAdvanced::ExposeComputeOption() {
+    ui->enable_compute_pipelines_checkbox->setVisible(true);
+}

src/yuzu/configuration/configure_graphics_advanced.h

@@ -28,6 +28,8 @@ public:
     void ApplyConfiguration();
     void SetConfiguration();
 
+    void ExposeComputeOption();
+
 private:
     void changeEvent(QEvent* event) override;
     void RetranslateUI();
@@ -44,6 +46,7 @@ private:
     ConfigurationShared::CheckState use_asynchronous_shaders;
     ConfigurationShared::CheckState use_fast_gpu_time;
     ConfigurationShared::CheckState use_vulkan_driver_pipeline_cache;
+    ConfigurationShared::CheckState enable_compute_pipelines;
 
     const Core::System& system;
 };

src/yuzu/configuration/configure_graphics_advanced.ui

@@ -136,6 +136,17 @@
           </property>
          </widget>
         </item>
+        <item>
+         <widget class="QCheckBox" name="enable_compute_pipelines_checkbox">
+          <property name="toolTip">
+           <string>Enable compute pipelines, required by some games. This setting only exists for Intel proprietary drivers, and may crash if enabled.
+Compute pipelines are always enabled on all other drivers.</string>
+          </property>
+          <property name="text">
+           <string>Enable Compute Pipelines (Intel Vulkan only)</string>
+          </property>
+         </widget>
+        </item>
         <item>
          <widget class="QWidget" name="af_layout" native="true">
           <layout class="QHBoxLayout" name="horizontalLayout_1">

src/yuzu/configuration/configure_per_game.cpp

@@ -48,8 +48,9 @@ ConfigurePerGame::ConfigurePerGame(QWidget* parent, u64 title_id_, const std::st
     audio_tab = std::make_unique<ConfigureAudio>(system_, this);
     cpu_tab = std::make_unique<ConfigureCpu>(system_, this);
     general_tab = std::make_unique<ConfigureGeneral>(system_, this);
-    graphics_tab = std::make_unique<ConfigureGraphics>(system_, this);
     graphics_advanced_tab = std::make_unique<ConfigureGraphicsAdvanced>(system_, this);
+    graphics_tab = std::make_unique<ConfigureGraphics>(
+        system_, [&]() { graphics_advanced_tab->ExposeComputeOption(); }, this);
     input_tab = std::make_unique<ConfigureInputPerGame>(system_, game_config.get(), this);
     system_tab = std::make_unique<ConfigureSystem>(system_, this);
 

src/yuzu/configuration/configure_per_game.h

@@ -75,8 +75,8 @@ private:
     std::unique_ptr<ConfigureAudio> audio_tab;
     std::unique_ptr<ConfigureCpu> cpu_tab;
     std::unique_ptr<ConfigureGeneral> general_tab;
-    std::unique_ptr<ConfigureGraphics> graphics_tab;
     std::unique_ptr<ConfigureGraphicsAdvanced> graphics_advanced_tab;
+    std::unique_ptr<ConfigureGraphics> graphics_tab;
     std::unique_ptr<ConfigureInputPerGame> input_tab;
     std::unique_ptr<ConfigureSystem> system_tab;
 };