Android #167

externals: update Vulkan-Headers to v1.3.274

CMakeLists.txt

@@ -142,6 +142,9 @@ if (YUZU_USE_BUNDLED_VCPKG)
     if (ENABLE_WEB_SERVICE)
         list(APPEND VCPKG_MANIFEST_FEATURES "web-service")
     endif()
+    if (ANDROID)
+        list(APPEND VCPKG_MANIFEST_FEATURES "android")
+    endif()
 
     include(${CMAKE_SOURCE_DIR}/externals/vcpkg/scripts/buildsystems/vcpkg.cmake)
 elseif(NOT "$ENV{VCPKG_TOOLCHAIN_FILE}" STREQUAL "")
@@ -302,7 +305,7 @@ find_package(ZLIB 1.2 REQUIRED)
 find_package(zstd 1.5 REQUIRED)
 
 if (NOT YUZU_USE_EXTERNAL_VULKAN_HEADERS)
-    find_package(Vulkan 1.3.256 REQUIRED)
+    find_package(Vulkan 1.3.274 REQUIRED)
 endif()
 
 if (ENABLE_LIBUSB)

README.md

@@ -1,3 +1,13 @@
+| Pull Request | Commit | Title | Author | Merged? |
+|----|----|----|----|----|
+| [12407](https://github.com/yuzu-emu/yuzu//pull/12407) | [`6e2cbd474`](https://github.com/yuzu-emu/yuzu//pull/12407/files) | shader_recompiler: patch small float image writes on broken drivers | [liamwhite](https://github.com/liamwhite/) | Yes |
+| [12410](https://github.com/yuzu-emu/yuzu//pull/12410) | [`d0a75580d`](https://github.com/yuzu-emu/yuzu//pull/12410/files) | renderer_vulkan: don't pass null view when nullDescriptor is not supported | [liamwhite](https://github.com/liamwhite/) | Yes |
+
+
+End of merge log. You can find the original README.md below the break.
+
+-----
+
 <!--
 SPDX-FileCopyrightText: 2018 yuzu Emulator Project
 SPDX-License-Identifier: GPL-2.0-or-later

src/android/app/src/main/res/values/arrays.xml

@@ -256,11 +256,13 @@
 
     <string-array name="outputEngineEntries">
         <item>@string/auto</item>
+        <item>@string/oboe</item>
         <item>@string/cubeb</item>
         <item>@string/string_null</item>
     </string-array>
     <integer-array name="outputEngineValues">
         <item>0</item>
+        <item>4</item>
         <item>1</item>
         <item>3</item>
     </integer-array>

src/android/app/src/main/res/values/strings.xml

@@ -503,6 +503,7 @@
     <string name="theme_mode_dark">Dark</string>
 
     <!-- Audio output engines -->
+    <string name="oboe">oboe</string>
     <string name="cubeb">cubeb</string>
 
     <!-- Black backgrounds theme -->

src/audio_core/CMakeLists.txt

@@ -253,6 +253,17 @@ if (ENABLE_SDL2)
     target_compile_definitions(audio_core PRIVATE HAVE_SDL2)
 endif()
 
+if (ANDROID)
+    target_sources(audio_core PRIVATE
+        sink/oboe_sink.cpp
+        sink/oboe_sink.h
+    )
+
+    # FIXME: this port seems broken, it cannot be imported with find_package(oboe REQUIRED)
+    target_link_libraries(audio_core PRIVATE "${VCPKG_INSTALLED_DIR}/${VCPKG_TARGET_TRIPLET}/lib/liboboe.a")
+    target_compile_definitions(audio_core PRIVATE HAVE_OBOE)
+endif()
+
 if (YUZU_USE_PRECOMPILED_HEADERS)
     target_precompile_headers(audio_core PRIVATE precompiled_headers.h)
 endif()

src/audio_core/sink/cubeb_sink.cpp

@@ -253,8 +253,9 @@ CubebSink::~CubebSink() {
 #endif
 }
 
-SinkStream* CubebSink::AcquireSinkStream(Core::System& system, u32 system_channels,
+SinkStream* CubebSink::AcquireSinkStream(Core::System& system, u32 system_channels_,
                                          const std::string& name, StreamType type) {
+    system_channels = system_channels_;
     SinkStreamPtr& stream = sink_streams.emplace_back(std::make_unique<CubebSinkStream>(
         ctx, device_channels, system_channels, output_device, input_device, name, type, system));
 

src/audio_core/sink/oboe_sink.cpp

@@ -0,0 +1,223 @@
+// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include <span>
+#include <vector>
+
+#include <oboe/Oboe.h>
+
+#include "audio_core/common/common.h"
+#include "audio_core/sink/oboe_sink.h"
+#include "audio_core/sink/sink_stream.h"
+#include "common/logging/log.h"
+#include "common/scope_exit.h"
+#include "core/core.h"
+
+namespace AudioCore::Sink {
+
+class OboeSinkStream final : public SinkStream,
+                             public oboe::AudioStreamDataCallback,
+                             public oboe::AudioStreamErrorCallback {
+public:
+    explicit OboeSinkStream(Core::System& system_, StreamType type_, const std::string& name_,
+                            u32 system_channels_)
+        : SinkStream(system_, type_) {
+        name = name_;
+        system_channels = system_channels_;
+
+        this->OpenStream();
+    }
+
+    ~OboeSinkStream() override {
+        LOG_INFO(Audio_Sink, "Destroyed Oboe stream");
+    }
+
+    void Finalize() override {
+        this->Stop();
+        m_stream.reset();
+    }
+
+    void Start(bool resume = false) override {
+        if (!m_stream || !paused) {
+            return;
+        }
+
+        paused = false;
+
+        if (m_stream->start() != oboe::Result::OK) {
+            LOG_CRITICAL(Audio_Sink, "Error starting Oboe stream");
+        }
+    }
+
+    void Stop() override {
+        if (!m_stream || paused) {
+            return;
+        }
+
+        this->SignalPause();
+
+        if (m_stream->stop() != oboe::Result::OK) {
+            LOG_CRITICAL(Audio_Sink, "Error stopping Oboe stream");
+        }
+    }
+
+public:
+    static s32 QueryChannelCount(oboe::Direction direction) {
+        std::shared_ptr<oboe::AudioStream> temp_stream;
+        oboe::AudioStreamBuilder builder;
+
+        const auto result = ConfigureBuilder(builder, direction)->openStream(temp_stream);
+        ASSERT(result == oboe::Result::OK);
+
+        return temp_stream->getChannelCount() >= 6 ? 6 : 2;
+    }
+
+protected:
+    oboe::DataCallbackResult onAudioReady(oboe::AudioStream*, void* audio_data,
+                                          s32 num_buffer_frames) override {
+        const size_t num_channels = this->GetDeviceChannels();
+        const size_t frame_size = num_channels;
+        const size_t num_frames = static_cast<size_t>(num_buffer_frames);
+
+        if (type == StreamType::In) {
+            std::span<const s16> input_buffer{reinterpret_cast<const s16*>(audio_data),
+                                              num_frames * frame_size};
+            this->ProcessAudioIn(input_buffer, num_frames);
+        } else {
+            std::span<s16> output_buffer{reinterpret_cast<s16*>(audio_data),
+                                         num_frames * frame_size};
+            this->ProcessAudioOutAndRender(output_buffer, num_frames);
+        }
+
+        return oboe::DataCallbackResult::Continue;
+    }
+
+    void onErrorAfterClose(oboe::AudioStream*, oboe::Result) override {
+        LOG_INFO(Audio_Sink, "Audio stream closed, reinitializing");
+
+        if (this->OpenStream()) {
+            m_stream->start();
+        }
+    }
+
+private:
+    static oboe::AudioStreamBuilder* ConfigureBuilder(oboe::AudioStreamBuilder& builder,
+                                                      oboe::Direction direction) {
+        // TODO: investigate callback delay issues when using AAudio
+        return builder.setPerformanceMode(oboe::PerformanceMode::LowLatency)
+            ->setAudioApi(oboe::AudioApi::OpenSLES)
+            ->setDirection(direction)
+            ->setSampleRate(TargetSampleRate)
+            ->setSampleRateConversionQuality(oboe::SampleRateConversionQuality::High)
+            ->setFormat(oboe::AudioFormat::I16)
+            ->setFormatConversionAllowed(true)
+            ->setUsage(oboe::Usage::Game)
+            ->setBufferCapacityInFrames(TargetSampleCount * 2);
+    }
+
+    bool OpenStream() {
+        const auto direction = [&]() {
+            switch (type) {
+            case StreamType::In:
+                return oboe::Direction::Input;
+            case StreamType::Out:
+            case StreamType::Render:
+                return oboe::Direction::Output;
+            default:
+                ASSERT(false);
+                return oboe::Direction::Output;
+            }
+        }();
+
+        const auto expected_channels = QueryChannelCount(direction);
+        const auto expected_mask = [&]() {
+            switch (expected_channels) {
+            case 1:
+                return oboe::ChannelMask::Mono;
+            case 2:
+                return oboe::ChannelMask::Stereo;
+            case 6:
+                return oboe::ChannelMask::CM5Point1;
+            default:
+                ASSERT(false);
+                return oboe::ChannelMask::Unspecified;
+            }
+        }();
+
+        oboe::AudioStreamBuilder builder;
+        const auto result = ConfigureBuilder(builder, direction)
+                                ->setChannelCount(expected_channels)
+                                ->setChannelMask(expected_mask)
+                                ->setChannelConversionAllowed(true)
+                                ->setDataCallback(this)
+                                ->setErrorCallback(this)
+                                ->openStream(m_stream);
+        ASSERT(result == oboe::Result::OK);
+        return result == oboe::Result::OK && this->SetStreamProperties();
+    }
+
+    bool SetStreamProperties() {
+        ASSERT(m_stream);
+
+        m_stream->setBufferSizeInFrames(TargetSampleCount * 2);
+        device_channels = m_stream->getChannelCount();
+
+        const auto sample_rate = m_stream->getSampleRate();
+        const auto buffer_capacity = m_stream->getBufferCapacityInFrames();
+        const auto stream_backend =
+            m_stream->getAudioApi() == oboe::AudioApi::AAudio ? "AAudio" : "OpenSLES";
+
+        LOG_INFO(Audio_Sink, "Opened Oboe {} stream with {} channels sample rate {} capacity {}",
+                 stream_backend, device_channels, sample_rate, buffer_capacity);
+
+        return true;
+    }
+
+    std::shared_ptr<oboe::AudioStream> m_stream{};
+};
+
+OboeSink::OboeSink() {
+    // TODO: This is not generally knowable
+    // The channel count is distinct based on direction and can change
+    device_channels = OboeSinkStream::QueryChannelCount(oboe::Direction::Output);
+}
+
+OboeSink::~OboeSink() = default;
+
+SinkStream* OboeSink::AcquireSinkStream(Core::System& system, u32 system_channels,
+                                        const std::string& name, StreamType type) {
+    SinkStreamPtr& stream = sink_streams.emplace_back(
+        std::make_unique<OboeSinkStream>(system, type, name, system_channels));
+
+    return stream.get();
+}
+
+void OboeSink::CloseStream(SinkStream* to_remove) {
+    sink_streams.remove_if([&](auto& stream) { return stream.get() == to_remove; });
+}
+
+void OboeSink::CloseStreams() {
+    sink_streams.clear();
+}
+
+f32 OboeSink::GetDeviceVolume() const {
+    if (sink_streams.empty()) {
+        return 1.0f;
+    }
+
+    return sink_streams.front()->GetDeviceVolume();
+}
+
+void OboeSink::SetDeviceVolume(f32 volume) {
+    for (auto& stream : sink_streams) {
+        stream->SetDeviceVolume(volume);
+    }
+}
+
+void OboeSink::SetSystemVolume(f32 volume) {
+    for (auto& stream : sink_streams) {
+        stream->SetSystemVolume(volume);
+    }
+}
+
+} // namespace AudioCore::Sink

src/audio_core/sink/oboe_sink.h

@@ -0,0 +1,75 @@
+// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include <list>
+#include <string>
+
+#include "audio_core/sink/sink.h"
+
+namespace Core {
+class System;
+}
+
+namespace AudioCore::Sink {
+class SinkStream;
+
+class OboeSink final : public Sink {
+public:
+    explicit OboeSink();
+    ~OboeSink() override;
+
+    /**
+     * Create a new sink stream.
+     *
+     * @param system          - Core system.
+     * @param system_channels - Number of channels the audio system expects.
+     *                          May differ from the device's channel count.
+     * @param name            - Name of this stream.
+     * @param type            - Type of this stream, render/in/out.
+     *
+     * @return A pointer to the created SinkStream
+     */
+    SinkStream* AcquireSinkStream(Core::System& system, u32 system_channels,
+                                  const std::string& name, StreamType type) override;
+
+    /**
+     * Close a given stream.
+     *
+     * @param stream - The stream to close.
+     */
+    void CloseStream(SinkStream* stream) override;
+
+    /**
+     * Close all streams.
+     */
+    void CloseStreams() override;
+
+    /**
+     * Get the device volume. Set from calls to the IAudioDevice service.
+     *
+     * @return Volume of the device.
+     */
+    f32 GetDeviceVolume() const override;
+
+    /**
+     * Set the device volume. Set from calls to the IAudioDevice service.
+     *
+     * @param volume - New volume of the device.
+     */
+    void SetDeviceVolume(f32 volume) override;
+
+    /**
+     * Set the system volume. Comes from the audio system using this stream.
+     *
+     * @param volume - New volume of the system.
+     */
+    void SetSystemVolume(f32 volume) override;
+
+private:
+    /// List of streams managed by this sink
+    std::list<SinkStreamPtr> sink_streams{};
+};
+
+} // namespace AudioCore::Sink

src/audio_core/sink/sdl2_sink.cpp

@@ -168,8 +168,9 @@ SDLSink::SDLSink(std::string_view target_device_name) {
 
 SDLSink::~SDLSink() = default;
 
-SinkStream* SDLSink::AcquireSinkStream(Core::System& system, u32 system_channels,
+SinkStream* SDLSink::AcquireSinkStream(Core::System& system, u32 system_channels_,
                                        const std::string&, StreamType type) {
+    system_channels = system_channels_;
     SinkStreamPtr& stream = sink_streams.emplace_back(std::make_unique<SDLSinkStream>(
         device_channels, system_channels, output_device, input_device, type, system));
     return stream.get();

src/audio_core/sink/sink.h

@@ -85,9 +85,21 @@ public:
      */
     virtual void SetSystemVolume(f32 volume) = 0;
 
+    /**
+     * Get the number of channels the game has set, can be different to the host hardware's support.
+     * Either 2 or 6.
+     *
+     * @return Number of device channels.
+     */
+    u32 GetSystemChannels() const {
+        return system_channels;
+    }
+
 protected:
     /// Number of device channels supported by the hardware
     u32 device_channels{2};
+    /// Number of channels the game is sending
+    u32 system_channels{2};
 };
 
 using SinkPtr = std::unique_ptr<Sink>;

src/audio_core/sink/sink_details.cpp

@@ -7,6 +7,9 @@
 #include <vector>
 
 #include "audio_core/sink/sink_details.h"
+#ifdef HAVE_OBOE
+#include "audio_core/sink/oboe_sink.h"
+#endif
 #ifdef HAVE_CUBEB
 #include "audio_core/sink/cubeb_sink.h"
 #endif
@@ -36,6 +39,16 @@ struct SinkDetails {
 
 // sink_details is ordered in terms of desirability, with the best choice at the top.
 constexpr SinkDetails sink_details[] = {
+#ifdef HAVE_OBOE
+    SinkDetails{
+        Settings::AudioEngine::Oboe,
+        [](std::string_view device_id) -> std::unique_ptr<Sink> {
+            return std::make_unique<OboeSink>();
+        },
+        [](bool capture) { return std::vector<std::string>{"Default"}; },
+        []() { return true; },
+    },
+#endif
 #ifdef HAVE_CUBEB
     SinkDetails{
         Settings::AudioEngine::Cubeb,

src/audio_core/sink/sink_stream.cpp

@@ -40,29 +40,36 @@ void SinkStream::AppendBuffer(SinkBuffer& buffer, std::span<s16> samples) {
 
     if (system_channels == 6 && device_channels == 2) {
         // We're given 6 channels, but our device only outputs 2, so downmix.
-        static constexpr std::array<f32, 4> down_mix_coeff{1.0f, 0.707f, 0.251f, 0.707f};
+        // Front = 1.0
+        // Center = 0.596
+        // LFE = 0.354
+        // Back = 0.707
+        static constexpr std::array<f32, 4> down_mix_coeff{1.0, 0.596f, 0.354f, 0.707f};
 
         for (u32 read_index = 0, write_index = 0; read_index < samples.size();
              read_index += system_channels, write_index += device_channels) {
+            const auto fl =
+                static_cast<f32>(samples[read_index + static_cast<u32>(Channels::FrontLeft)]);
+            const auto fr =
+                static_cast<f32>(samples[read_index + static_cast<u32>(Channels::FrontRight)]);
+            const auto c =
+                static_cast<f32>(samples[read_index + static_cast<u32>(Channels::Center)]);
+            const auto lfe =
+                static_cast<f32>(samples[read_index + static_cast<u32>(Channels::LFE)]);
+            const auto bl =
+                static_cast<f32>(samples[read_index + static_cast<u32>(Channels::BackLeft)]);
+            const auto br =
+                static_cast<f32>(samples[read_index + static_cast<u32>(Channels::BackRight)]);
+
             const auto left_sample{
-                ((Common::FixedPoint<49, 15>(
+                static_cast<s32>((fl * down_mix_coeff[0] + c * down_mix_coeff[1] +
-                      samples[read_index + static_cast<u32>(Channels::FrontLeft)]) *
+                                  lfe * down_mix_coeff[2] + bl * down_mix_coeff[3]) *
-                      down_mix_coeff[0] +
+                                 volume)};
-                  samples[read_index + static_cast<u32>(Channels::Center)] * down_mix_coeff[1] +
-                  samples[read_index + static_cast<u32>(Channels::LFE)] * down_mix_coeff[2] +
-                  samples[read_index + static_cast<u32>(Channels::BackLeft)] * down_mix_coeff[3]) *
-                 volume)
-                    .to_int()};
 
             const auto right_sample{
-                ((Common::FixedPoint<49, 15>(
+                static_cast<s32>((fr * down_mix_coeff[0] + c * down_mix_coeff[1] +
-                      samples[read_index + static_cast<u32>(Channels::FrontRight)]) *
+                                  lfe * down_mix_coeff[2] + br * down_mix_coeff[3]) *
-                      down_mix_coeff[0] +
+                                 volume)};
-                  samples[read_index + static_cast<u32>(Channels::Center)] * down_mix_coeff[1] +
-                  samples[read_index + static_cast<u32>(Channels::LFE)] * down_mix_coeff[2] +
-                  samples[read_index + static_cast<u32>(Channels::BackRight)] * down_mix_coeff[3]) *
-                 volume)
-                    .to_int()};
 
             samples[write_index + static_cast<u32>(Channels::FrontLeft)] =
                 static_cast<s16>(std::clamp(left_sample, min, max));

src/common/settings_enums.h

@@ -82,16 +82,15 @@ enum class AudioEngine : u32 {
     Cubeb,
     Sdl2,
     Null,
+    Oboe,
 };
 
 template <>
 inline std::vector<std::pair<std::string, AudioEngine>>
 EnumMetadata<AudioEngine>::Canonicalizations() {
     return {
-        {"auto", AudioEngine::Auto},
+        {"auto", AudioEngine::Auto}, {"cubeb", AudioEngine::Cubeb}, {"sdl2", AudioEngine::Sdl2},
-        {"cubeb", AudioEngine::Cubeb},
+        {"null", AudioEngine::Null}, {"oboe", AudioEngine::Oboe},
-        {"sdl2", AudioEngine::Sdl2},
-        {"null", AudioEngine::Null},
     };
 }
 

src/core/arm/nce/arm_nce.cpp

@@ -39,7 +39,7 @@ fpsimd_context* GetFloatingPointState(mcontext_t& host_ctx) {
 }
 
 using namespace Common::Literals;
-constexpr u32 StackSize = 32_KiB;
+constexpr u32 StackSize = 128_KiB;
 
 } // namespace
 

src/core/arm/nce/interpreter_visitor.cpp

@@ -5,8 +5,6 @@
 #include "common/bit_cast.h"
 #include "core/arm/nce/interpreter_visitor.h"
 
-#include <dynarmic/frontend/A64/decoder/a64.h>
-
 namespace Core {
 
 template <u32 BitSize>
@@ -249,6 +247,7 @@ bool InterpreterVisitor::LDR_lit_fpsimd(Imm<2> opc, Imm<19> imm19, Vec Vt) {
         return false;
     }
 
+    // Size in bytes
     const u64 size = 4 << opc.ZeroExtend();
     const u64 offset = imm19.SignExtend<u64>() << 2;
     const u64 address = this->GetPc() + offset;
@@ -530,7 +529,7 @@ bool InterpreterVisitor::SIMDImmediate(bool wback, bool postindex, size_t scale,
     }
     case MemOp::Load: {
         u128 data{};
-        m_memory.ReadBlock(address, &data, datasize);
+        m_memory.ReadBlock(address, &data, datasize / 8);
         this->SetVec(Vt, data);
         break;
     }

src/core/arm/nce/visitor_base.h

@@ -4,9 +4,15 @@
 
 #pragma once
 
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wshadow"
+
 #include <dynarmic/frontend/A64/a64_types.h>
+#include <dynarmic/frontend/A64/decoder/a64.h>
 #include <dynarmic/frontend/imm.h>
 
+#pragma GCC diagnostic pop
+
 namespace Core {
 
 class VisitorBase {

src/core/hle/service/audio/audren_u.cpp

@@ -359,7 +359,7 @@ private:
 
     void GetActiveChannelCount(HLERequestContext& ctx) {
         const auto& sink{system.AudioCore().GetOutputSink()};
-        u32 channel_count{sink.GetDeviceChannels()};
+        u32 channel_count{sink.GetSystemChannels()};
 
         LOG_DEBUG(Service_Audio, "(STUBBED) called. Channels={}", channel_count);
 

src/core/hle/service/filesystem/filesystem.h

@@ -54,6 +54,13 @@ enum class ImageDirectoryId : u32 {
     SdCard,
 };
 
+enum class OpenDirectoryMode : u64 {
+    Directory = (1 << 0),
+    File = (1 << 1),
+    All = Directory | File
+};
+DECLARE_ENUM_FLAG_OPERATORS(OpenDirectoryMode);
+
 class FileSystemController {
 public:
     explicit FileSystemController(Core::System& system_);

src/core/hle/service/filesystem/fsp_srv.cpp

@@ -259,7 +259,7 @@ static void BuildEntryIndex(std::vector<FileSys::Entry>& entries, const std::vec
 
 class IDirectory final : public ServiceFramework<IDirectory> {
 public:
-    explicit IDirectory(Core::System& system_, FileSys::VirtualDir backend_)
+    explicit IDirectory(Core::System& system_, FileSys::VirtualDir backend_, OpenDirectoryMode mode)
         : ServiceFramework{system_, "IDirectory"}, backend(std::move(backend_)) {
         static const FunctionInfo functions[] = {
             {0, &IDirectory::Read, "Read"},
@@ -269,8 +269,12 @@ public:
 
         // TODO(DarkLordZach): Verify that this is the correct behavior.
         // Build entry index now to save time later.
-        BuildEntryIndex(entries, backend->GetFiles(), FileSys::EntryType::File);
+        if (True(mode & OpenDirectoryMode::Directory)) {
-        BuildEntryIndex(entries, backend->GetSubdirectories(), FileSys::EntryType::Directory);
+            BuildEntryIndex(entries, backend->GetSubdirectories(), FileSys::EntryType::Directory);
+        }
+        if (True(mode & OpenDirectoryMode::File)) {
+            BuildEntryIndex(entries, backend->GetFiles(), FileSys::EntryType::File);
+        }
     }
 
 private:
@@ -446,11 +450,9 @@ public:
 
         const auto file_buffer = ctx.ReadBuffer();
         const std::string name = Common::StringFromBuffer(file_buffer);
+        const auto mode = rp.PopRaw<OpenDirectoryMode>();
 
-        // TODO(Subv): Implement this filter.
+        LOG_DEBUG(Service_FS, "called. directory={}, mode={}", name, mode);
-        const u32 filter_flags = rp.Pop<u32>();
-
-        LOG_DEBUG(Service_FS, "called. directory={}, filter={}", name, filter_flags);
 
         FileSys::VirtualDir vfs_dir{};
         auto result = backend.OpenDirectory(&vfs_dir, name);
@@ -460,7 +462,7 @@ public:
             return;
         }
 
-        auto directory = std::make_shared<IDirectory>(system, vfs_dir);
+        auto directory = std::make_shared<IDirectory>(system, vfs_dir, mode);
 
         IPC::ResponseBuilder rb{ctx, 2, 0, 1};
         rb.Push(ResultSuccess);

src/core/hle/service/nvnflinger/buffer_queue_consumer.cpp

@@ -90,6 +90,18 @@ Status BufferQueueConsumer::AcquireBuffer(BufferItem* out_buffer,
 
     LOG_DEBUG(Service_Nvnflinger, "acquiring slot={}", slot);
 
+    // If the front buffer is still being tracked, update its slot state
+    if (core->StillTracking(*front)) {
+        slots[slot].acquire_called = true;
+        slots[slot].needs_cleanup_on_release = false;
+        slots[slot].buffer_state = BufferState::Acquired;
+
+        // TODO: for now, avoid resetting the fence, so that when we next return this
+        // slot to the producer, it will wait for the fence to pass. We should fix this
+        // by properly waiting for the fence in the BufferItemConsumer.
+        // slots[slot].fence = Fence::NoFence();
+    }
+
     // If the buffer has previously been acquired by the consumer, set graphic_buffer to nullptr to
     // avoid unnecessarily remapping this buffer on the consumer side.
     if (out_buffer->acquire_called) {
@@ -132,11 +144,28 @@ Status BufferQueueConsumer::ReleaseBuffer(s32 slot, u64 frame_number, const Fenc
             ++current;
         }
 
-        slots[slot].buffer_state = BufferState::Free;
+        if (slots[slot].buffer_state == BufferState::Acquired) {
+            // TODO: for now, avoid resetting the fence, so that when we next return this
+            // slot to the producer, it can wait for its own fence to pass. We should fix this
+            // by properly waiting for the fence in the BufferItemConsumer.
+            // slots[slot].fence = release_fence;
+            slots[slot].buffer_state = BufferState::Free;
 
-        listener = core->connected_producer_listener;
+            listener = core->connected_producer_listener;
 
-        LOG_DEBUG(Service_Nvnflinger, "releasing slot {}", slot);
+            LOG_DEBUG(Service_Nvnflinger, "releasing slot {}", slot);
+        } else if (slots[slot].needs_cleanup_on_release) {
+            LOG_DEBUG(Service_Nvnflinger, "releasing a stale buffer slot {} (state = {})", slot,
+                      slots[slot].buffer_state);
+            slots[slot].needs_cleanup_on_release = false;
+            return Status::StaleBufferSlot;
+        } else {
+            LOG_ERROR(Service_Nvnflinger,
+                      "attempted to release buffer slot {} but its state was {}", slot,
+                      slots[slot].buffer_state);
+
+            return Status::BadValue;
+        }
 
         core->SignalDequeueCondition();
     }

src/core/hle/service/nvnflinger/buffer_queue_core.cpp

@@ -74,6 +74,10 @@ void BufferQueueCore::FreeBufferLocked(s32 slot) {
 
     slots[slot].graphic_buffer.reset();
 
+    if (slots[slot].buffer_state == BufferState::Acquired) {
+        slots[slot].needs_cleanup_on_release = true;
+    }
+
     slots[slot].buffer_state = BufferState::Free;
     slots[slot].frame_number = UINT32_MAX;
     slots[slot].acquire_called = false;

src/core/hle/service/nvnflinger/buffer_slot.h

@@ -31,6 +31,7 @@ struct BufferSlot final {
     u64 frame_number{};
     Fence fence;
     bool acquire_called{};
+    bool needs_cleanup_on_release{};
     bool attached_by_consumer{};
     bool is_preallocated{};
 };

src/shader_recompiler/backend/spirv/emit_spirv_context_get_set.cpp

@@ -74,6 +74,11 @@ std::optional<OutAttr> OutputAttrPointer(EmitContext& ctx, IR::Attribute attr) {
     case IR::Attribute::ClipDistance7: {
         const u32 base{static_cast<u32>(IR::Attribute::ClipDistance0)};
         const u32 index{static_cast<u32>(attr) - base};
+        if (index >= ctx.profile.max_user_clip_distances) {
+            LOG_WARNING(Shader, "Ignoring clip distance store {} >= {} supported", index,
+                        ctx.profile.max_user_clip_distances);
+            return std::nullopt;
+        }
         const Id clip_num{ctx.Const(index)};
         return OutputAccessChain(ctx, ctx.output_f32, ctx.clip_distances, clip_num);
     }

src/shader_recompiler/backend/spirv/spirv_emit_context.cpp

@@ -74,9 +74,17 @@ spv::ImageFormat GetImageFormat(ImageFormat format) {
     throw InvalidArgument("Invalid image format {}", format);
 }
 
+Id GetImageSampledType(EmitContext& ctx, const ImageDescriptor& desc) {
+    if (desc.is_float) {
+        return ctx.F32[1];
+    } else {
+        return ctx.U32[1];
+    }
+}
+
 Id ImageType(EmitContext& ctx, const ImageDescriptor& desc) {
     const spv::ImageFormat format{GetImageFormat(desc.format)};
-    const Id type{ctx.U32[1]};
+    const Id type{GetImageSampledType(ctx, desc)};
     switch (desc.type) {
     case TextureType::Color1D:
         return ctx.TypeImage(type, spv::Dim::Dim1D, false, false, false, 2, format);
@@ -1528,7 +1536,8 @@ void EmitContext::DefineOutputs(const IR::Program& program) {
         if (stage == Stage::Fragment) {
             throw NotImplementedException("Storing ClipDistance in fragment stage");
         }
-        const Id type{TypeArray(F32[1], Const(8U))};
+        const Id type{TypeArray(
+            F32[1], Const(std::min(info.used_clip_distances, profile.max_user_clip_distances)))};
         clip_distances = DefineOutput(*this, type, invocations, spv::BuiltIn::ClipDistance);
     }
     if (info.stores[IR::Attribute::Layer] &&

src/shader_recompiler/frontend/ir/opcodes.inc

@@ -512,7 +512,7 @@ OPCODE(ImageQueryDimensions,                                U32x4,          Opaq
 OPCODE(ImageQueryLod,                                       F32x4,          Opaque,         Opaque,                                                         )
 OPCODE(ImageGradient,                                       F32x4,          Opaque,         Opaque,         Opaque,         Opaque,         Opaque,         )
 OPCODE(ImageRead,                                           U32x4,          Opaque,         Opaque,                                                         )
-OPCODE(ImageWrite,                                          Void,           Opaque,         Opaque,         U32x4,                                          )
+OPCODE(ImageWrite,                                          Void,           Opaque,         Opaque,         Opaque,                                         )
 
 OPCODE(IsTextureScaled,                                     U1,             U32,                                                                            )
 OPCODE(IsImageScaled,                                       U1,             U32,                                                                            )

src/shader_recompiler/host_translate_info.h

@@ -19,8 +19,10 @@ struct HostTranslateInfo {
     u32 min_ssbo_alignment{};            ///< Minimum alignment supported by the device for SSBOs
     bool support_geometry_shader_passthrough{}; ///< True when the device supports geometry
                                                 ///< passthrough shaders
-    bool support_conditional_barrier{}; ///< True when the device supports barriers in conditional
+    bool support_conditional_barrier{};  ///< True when the device supports barriers in conditional
-                                        ///< control flow
+                                         ///< control flow
+    bool support_ufloat_write_as_uint{}; ///< True when the device supports writing float images
+                                         ///< as bitcasts to uint
 };
 
 } // namespace Shader

src/shader_recompiler/ir_opt/collect_shader_info_pass.cpp

@@ -913,7 +913,11 @@ void GatherInfoFromHeader(Environment& env, Info& info) {
         }
         for (size_t index = 0; index < 8; ++index) {
             const u16 mask{header.vtg.omap_systemc.clip_distances};
-            info.stores.Set(IR::Attribute::ClipDistance0 + index, ((mask >> index) & 1) != 0);
+            const bool used{((mask >> index) & 1) != 0};
+            info.stores.Set(IR::Attribute::ClipDistance0 + index, used);
+            if (used) {
+                info.used_clip_distances = static_cast<u32>(index) + 1;
+            }
         }
         info.stores.Set(IR::Attribute::PrimitiveId,
                         header.vtg.omap_systemb.primitive_array_id != 0);

src/shader_recompiler/ir_opt/texture_pass.cpp

@@ -372,6 +372,10 @@ TexturePixelFormat ReadTexturePixelFormat(Environment& env, const ConstBufferAdd
     return env.ReadTexturePixelFormat(GetTextureHandle(env, cbuf));
 }
 
+bool TexturePixelFormatIsFloat(Environment& env, const ConstBufferAddr& cbuf) {
+    return ReadTexturePixelFormat(env, cbuf) == TexturePixelFormat::B10G11R11_FLOAT;
+}
+
 class Descriptors {
 public:
     explicit Descriptors(TextureBufferDescriptors& texture_buffer_descriptors_,
@@ -428,8 +432,9 @@ public:
             return desc.type == existing.type && desc.format == existing.format &&
                    desc.cbuf_index == existing.cbuf_index &&
                    desc.cbuf_offset == existing.cbuf_offset && desc.count == existing.count &&
-                   desc.size_shift == existing.size_shift;
+                   desc.size_shift == existing.size_shift && desc.is_float == existing.is_float;
         })};
+        // TODO: handle is_float?
         image_descriptors[index].is_written |= desc.is_written;
         image_descriptors[index].is_read |= desc.is_read;
         return index;
@@ -500,6 +505,19 @@ void PatchTexelFetch(IR::Block& block, IR::Inst& inst, TexturePixelFormat pixel_
                               ir.FPMul(ir.ConvertSToF(32, 32, ir.BitCast<IR::U32>(w)), max_value));
     inst.ReplaceUsesWith(converted);
 }
+
+void PatchSmallFloatImageWrite(IR::Block& block, IR::Inst& inst) {
+    IR::IREmitter ir{block, IR::Block::InstructionList::s_iterator_to(inst)};
+
+    const IR::Value old_value{inst.Arg(2)};
+    const IR::F32 x(ir.BitCast<IR::F32>(IR::U32(ir.CompositeExtract(old_value, 0))));
+    const IR::F32 y(ir.BitCast<IR::F32>(IR::U32(ir.CompositeExtract(old_value, 1))));
+    const IR::F32 z(ir.BitCast<IR::F32>(IR::U32(ir.CompositeExtract(old_value, 2))));
+    const IR::F32 w(ir.BitCast<IR::F32>(IR::U32(ir.CompositeExtract(old_value, 3))));
+    const IR::Value converted = ir.CompositeConstruct(x, y, z, w);
+    inst.SetArg(2, converted);
+}
+
 } // Anonymous namespace
 
 void TexturePass(Environment& env, IR::Program& program, const HostTranslateInfo& host_info) {
@@ -531,6 +549,9 @@ void TexturePass(Environment& env, IR::Program& program, const HostTranslateInfo
         inst->ReplaceOpcode(IndexedInstruction(*inst));
 
         const auto& cbuf{texture_inst.cbuf};
+        const bool is_float_write{!host_info.support_ufloat_write_as_uint &&
+                                  inst->GetOpcode() == IR::Opcode::ImageWrite &&
+                                  TexturePixelFormatIsFloat(env, cbuf)};
         auto flags{inst->Flags<IR::TextureInstInfo>()};
         bool is_multisample{false};
         switch (inst->GetOpcode()) {
@@ -603,6 +624,7 @@ void TexturePass(Environment& env, IR::Program& program, const HostTranslateInfo
                     .format = flags.image_format,
                     .is_written = is_written,
                     .is_read = is_read,
+                    .is_float = is_float_write,
                     .cbuf_index = cbuf.index,
                     .cbuf_offset = cbuf.offset,
                     .count = cbuf.count,
@@ -662,6 +684,10 @@ void TexturePass(Environment& env, IR::Program& program, const HostTranslateInfo
                 PatchTexelFetch(*texture_inst.block, *texture_inst.inst, pixel_format);
             }
         }
+
+        if (is_float_write) {
+            PatchSmallFloatImageWrite(*texture_inst.block, *inst);
+        }
     }
 }
 

src/shader_recompiler/profile.h

@@ -87,6 +87,8 @@ struct Profile {
     bool has_broken_robust{};
 
     u64 min_ssbo_alignment{};
+
+    u32 max_user_clip_distances{};
 };
 
 } // namespace Shader

src/shader_recompiler/shader_info.h

@@ -42,6 +42,7 @@ enum class TexturePixelFormat : u32 {
     R16G16B16A16_SNORM,
     R16G16_SNORM,
     R16_SNORM,
+    B10G11R11_FLOAT,
     OTHER
 };
 
@@ -129,6 +130,7 @@ struct ImageDescriptor {
     ImageFormat format;
     bool is_written;
     bool is_read;
+    bool is_float;
     u32 cbuf_index;
     u32 cbuf_offset;
     u32 count;
@@ -227,6 +229,8 @@ struct Info {
     bool requires_layer_emulation{};
     IR::Attribute emulated_layer{};
 
+    u32 used_clip_distances{};
+
     boost::container::static_vector<ConstantBufferDescriptor, MAX_CBUFS>
         constant_buffer_descriptors;
     boost::container::static_vector<StorageBufferDescriptor, MAX_SSBOS> storage_buffers_descriptors;

src/tests/video_core/memory_tracker.cpp

@@ -23,13 +23,13 @@ constexpr VAddr c = 16 * HIGH_PAGE_SIZE;
 
 class RasterizerInterface {
 public:
-    void UpdatePagesCachedCount(VAddr addr, u64 size, bool cache) {
+    void UpdatePagesCachedCount(VAddr addr, u64 size, int delta) {
         const u64 page_start{addr >> Core::Memory::YUZU_PAGEBITS};
         const u64 page_end{(addr + size + Core::Memory::YUZU_PAGESIZE - 1) >>
                            Core::Memory::YUZU_PAGEBITS};
         for (u64 page = page_start; page < page_end; ++page) {
             int& value = page_table[page];
-            value += (cache ? 1 : -1);
+            value += delta;
             if (value < 0) {
                 throw std::logic_error{"negative page"};
             }
@@ -546,4 +546,4 @@ TEST_CASE("MemoryTracker: Cached write downloads") {
     REQUIRE(!memory_track->IsRegionGpuModified(c + PAGE, PAGE));
     memory_track->MarkRegionAsCpuModified(c, WORD);
     REQUIRE(rasterizer.Count() == 0);
-}
+}

src/video_core/buffer_cache/word_manager.h

@@ -473,7 +473,7 @@ private:
         VAddr addr = cpu_addr + word_index * BYTES_PER_WORD;
         IteratePages(changed_bits, [&](size_t offset, size_t size) {
             rasterizer->UpdatePagesCachedCount(addr + offset * BYTES_PER_PAGE,
-                                               size * BYTES_PER_PAGE, add_to_rasterizer);
+                                               size * BYTES_PER_PAGE, add_to_rasterizer ? 1 : -1);
         });
     }
 

src/video_core/fence_manager.h

@@ -270,7 +270,7 @@ private:
 
     std::jthread fence_thread;
 
-    DelayedDestructionRing<TFence, 6> delayed_destruction_ring;
+    DelayedDestructionRing<TFence, 8> delayed_destruction_ring;
 };
 
 } // namespace VideoCommon

src/video_core/rasterizer_accelerated.cpp

@@ -3,7 +3,6 @@
 
 #include <atomic>
 
-#include "common/alignment.h"
 #include "common/assert.h"
 #include "common/common_types.h"
 #include "common/div_ceil.h"
@@ -12,65 +11,61 @@
 
 namespace VideoCore {
 
-static constexpr u16 IdentityValue = 1;
-
 using namespace Core::Memory;
 
-RasterizerAccelerated::RasterizerAccelerated(Memory& cpu_memory_) : map{}, cpu_memory{cpu_memory_} {
+RasterizerAccelerated::RasterizerAccelerated(Memory& cpu_memory_)
-    // We are tracking CPU memory, which cannot map more than 39 bits.
+    : cached_pages(std::make_unique<CachedPages>()), cpu_memory{cpu_memory_} {}
-    const VAddr start_address = 0;
-    const VAddr end_address = (1ULL << 39);
-    const IntervalType address_space_interval(start_address, end_address);
-    const auto value = std::make_pair(address_space_interval, IdentityValue);
-
-    map.add(value);
-}
 
 RasterizerAccelerated::~RasterizerAccelerated() = default;
 
-void RasterizerAccelerated::UpdatePagesCachedCount(VAddr addr, u64 size, bool cache) {
+void RasterizerAccelerated::UpdatePagesCachedCount(VAddr addr, u64 size, int delta) {
-    std::scoped_lock lk{map_lock};
+    u64 uncache_begin = 0;
+    u64 cache_begin = 0;
+    u64 uncache_bytes = 0;
+    u64 cache_bytes = 0;
 
-    // Align sizes.
+    std::atomic_thread_fence(std::memory_order_acquire);
-    addr = Common::AlignDown(addr, YUZU_PAGESIZE);
+    const u64 page_end = Common::DivCeil(addr + size, YUZU_PAGESIZE);
-    size = Common::AlignUp(size, YUZU_PAGESIZE);
+    for (u64 page = addr >> YUZU_PAGEBITS; page != page_end; ++page) {
+        std::atomic_uint16_t& count = cached_pages->at(page >> 2).Count(page);
 
-    // Declare the overall interval we are going to operate on.
+        if (delta > 0) {
-    const VAddr start_address = addr;
+            ASSERT_MSG(count.load(std::memory_order::relaxed) < UINT16_MAX, "Count may overflow!");
-    const VAddr end_address = addr + size;
+        } else if (delta < 0) {
-    const IntervalType modification_range(start_address, end_address);
+            ASSERT_MSG(count.load(std::memory_order::relaxed) > 0, "Count may underflow!");
+        } else {
+            ASSERT_MSG(false, "Delta must be non-zero!");
+        }
 
-    // Find the boundaries of where to iterate.
+        // Adds or subtracts 1, as count is a unsigned 8-bit value
-    const auto lower = map.lower_bound(modification_range);
+        count.fetch_add(static_cast<u16>(delta), std::memory_order_release);
-    const auto upper = map.upper_bound(modification_range);
 
-    // Iterate over the contained intervals.
+        // Assume delta is either -1 or 1
-    for (auto it = lower; it != upper; it++) {
+        if (count.load(std::memory_order::relaxed) == 0) {
-        // Intersect interval range with modification range.
+            if (uncache_bytes == 0) {
-        const auto current_range = modification_range & it->first;
+                uncache_begin = page;
-
+            }
-        // Calculate the address and size to operate over.
+            uncache_bytes += YUZU_PAGESIZE;
-        const auto current_addr = current_range.lower();
+        } else if (uncache_bytes > 0) {
-        const auto current_size = current_range.upper() - current_addr;
+            cpu_memory.RasterizerMarkRegionCached(uncache_begin << YUZU_PAGEBITS, uncache_bytes,
-
+                                                  false);
-        // Get the current value of the range.
+            uncache_bytes = 0;
-        const auto value = it->second;
+        }
-
+        if (count.load(std::memory_order::relaxed) == 1 && delta > 0) {
-        if (cache && value == IdentityValue) {
+            if (cache_bytes == 0) {
-            // If we are going to cache, and the value is not yet referenced, then cache this range.
+                cache_begin = page;
-            cpu_memory.RasterizerMarkRegionCached(current_addr, current_size, true);
+            }
-        } else if (!cache && value == IdentityValue + 1) {
+            cache_bytes += YUZU_PAGESIZE;
-            // If we are going to uncache, and this is the last reference, then uncache this range.
+        } else if (cache_bytes > 0) {
-            cpu_memory.RasterizerMarkRegionCached(current_addr, current_size, false);
+            cpu_memory.RasterizerMarkRegionCached(cache_begin << YUZU_PAGEBITS, cache_bytes, true);
+            cache_bytes = 0;
         }
     }
-
+    if (uncache_bytes > 0) {
-    // Update the set.
+        cpu_memory.RasterizerMarkRegionCached(uncache_begin << YUZU_PAGEBITS, uncache_bytes, false);
-    const auto value = std::make_pair(modification_range, IdentityValue);
+    }
-    if (cache) {
+    if (cache_bytes > 0) {
-        map.add(value);
+        cpu_memory.RasterizerMarkRegionCached(cache_begin << YUZU_PAGEBITS, cache_bytes, true);
-    } else {
-        map.subtract(value);
     }
 }
 

src/video_core/rasterizer_accelerated.h

@@ -3,8 +3,8 @@
 
 #pragma once
 
-#include <mutex>
+#include <array>
-#include <boost/icl/interval_map.hpp>
+#include <atomic>
 
 #include "common/common_types.h"
 #include "video_core/rasterizer_interface.h"
@@ -21,17 +21,28 @@ public:
     explicit RasterizerAccelerated(Core::Memory::Memory& cpu_memory_);
     ~RasterizerAccelerated() override;
 
-    void UpdatePagesCachedCount(VAddr addr, u64 size, bool cache) override;
+    void UpdatePagesCachedCount(VAddr addr, u64 size, int delta) override;
 
 private:
-    using PageIndex = VAddr;
+    class CacheEntry final {
-    using PageReferenceCount = u16;
+    public:
+        CacheEntry() = default;
 
-    using IntervalMap = boost::icl::interval_map<PageIndex, PageReferenceCount>;
+        std::atomic_uint16_t& Count(std::size_t page) {
-    using IntervalType = IntervalMap::interval_type;
+            return values[page & 3];
+        }
 
-    IntervalMap map;
+        const std::atomic_uint16_t& Count(std::size_t page) const {
-    std::mutex map_lock;
+            return values[page & 3];
+        }
+
+    private:
+        std::array<std::atomic_uint16_t, 4> values{};
+    };
+    static_assert(sizeof(CacheEntry) == 8, "CacheEntry should be 8 bytes!");
+
+    using CachedPages = std::array<CacheEntry, 0x2000000>;
+    std::unique_ptr<CachedPages> cached_pages;
     Core::Memory::Memory& cpu_memory;
 };
 

src/video_core/rasterizer_interface.h

@@ -162,7 +162,7 @@ public:
     }
 
     /// Increase/decrease the number of object in pages touching the specified region
-    virtual void UpdatePagesCachedCount(VAddr addr, u64 size, bool cache) {}
+    virtual void UpdatePagesCachedCount(VAddr addr, u64 size, int delta) {}
 
     /// Initialize disk cached resources for the game being emulated
     virtual void LoadDiskResources(u64 title_id, std::stop_token stop_loading,

src/video_core/renderer_opengl/gl_buffer_cache.cpp

@@ -58,6 +58,9 @@ Buffer::Buffer(BufferCacheRuntime& runtime, VideoCore::RasterizerInterface& rast
         glObjectLabel(GL_BUFFER, buffer.handle, static_cast<GLsizei>(name.size()), name.data());
     }
     glNamedBufferData(buffer.handle, SizeBytes(), nullptr, GL_DYNAMIC_DRAW);
+    if (runtime.has_unified_vertex_buffers) {
+        glGetNamedBufferParameterui64vNV(buffer.handle, GL_BUFFER_GPU_ADDRESS_NV, &address);
+    }
 }
 
 void Buffer::ImmediateUpload(size_t offset, std::span<const u8> data) noexcept {
@@ -109,6 +112,7 @@ BufferCacheRuntime::BufferCacheRuntime(const Device& device_,
     : device{device_}, staging_buffer_pool{staging_buffer_pool_},
       has_fast_buffer_sub_data{device.HasFastBufferSubData()},
       use_assembly_shaders{device.UseAssemblyShaders()},
+      has_unified_vertex_buffers{device.HasVertexBufferUnifiedMemory()},
       stream_buffer{has_fast_buffer_sub_data ? std::nullopt : std::make_optional<StreamBuffer>()} {
     GLint gl_max_attributes;
     glGetIntegerv(GL_MAX_VERTEX_ATTRIBS, &gl_max_attributes);
@@ -210,8 +214,14 @@ void BufferCacheRuntime::ClearBuffer(Buffer& dest_buffer, u32 offset, size_t siz
 }
 
 void BufferCacheRuntime::BindIndexBuffer(Buffer& buffer, u32 offset, u32 size) {
-    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, buffer.Handle());
+    if (has_unified_vertex_buffers) {
-    index_buffer_offset = offset;
+        buffer.MakeResident(GL_READ_ONLY);
+        glBufferAddressRangeNV(GL_ELEMENT_ARRAY_ADDRESS_NV, 0, buffer.HostGpuAddr() + offset,
+                               static_cast<GLsizeiptr>(Common::AlignUp(size, 4)));
+    } else {
+        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, buffer.Handle());
+        index_buffer_offset = offset;
+    }
 }
 
 void BufferCacheRuntime::BindVertexBuffer(u32 index, Buffer& buffer, u32 offset, u32 size,
@@ -219,8 +229,15 @@ void BufferCacheRuntime::BindVertexBuffer(u32 index, Buffer& buffer, u32 offset,
     if (index >= max_attributes) {
         return;
     }
-    glBindVertexBuffer(index, buffer.Handle(), static_cast<GLintptr>(offset),
+    if (has_unified_vertex_buffers) {
-                       static_cast<GLsizei>(stride));
+        buffer.MakeResident(GL_READ_ONLY);
+        glBindVertexBuffer(index, 0, 0, static_cast<GLsizei>(stride));
+        glBufferAddressRangeNV(GL_VERTEX_ATTRIB_ARRAY_ADDRESS_NV, index,
+                               buffer.HostGpuAddr() + offset, static_cast<GLsizeiptr>(size));
+    } else {
+        glBindVertexBuffer(index, buffer.Handle(), static_cast<GLintptr>(offset),
+                           static_cast<GLsizei>(stride));
+    }
 }
 
 void BufferCacheRuntime::BindVertexBuffers(VideoCommon::HostBindings<Buffer>& bindings) {
@@ -233,9 +250,23 @@ void BufferCacheRuntime::BindVertexBuffers(VideoCommon::HostBindings<Buffer>& bi
                            [](u64 stride) { return static_cast<GLsizei>(stride); });
     const u32 count =
         std::min(static_cast<u32>(bindings.buffers.size()), max_attributes - bindings.min_index);
-    glBindVertexBuffers(bindings.min_index, static_cast<GLsizei>(count), buffer_handles.data(),
+    if (has_unified_vertex_buffers) {
-                        reinterpret_cast<const GLintptr*>(bindings.offsets.data()),
+        for (u32 index = 0; index < count; ++index) {
-                        buffer_strides.data());
+            Buffer& buffer = *bindings.buffers[index];
+            buffer.MakeResident(GL_READ_ONLY);
+            glBufferAddressRangeNV(GL_VERTEX_ATTRIB_ARRAY_ADDRESS_NV, bindings.min_index + index,
+                                   buffer.HostGpuAddr() + bindings.offsets[index],
+                                   static_cast<GLsizeiptr>(bindings.sizes[index]));
+        }
+        static constexpr std::array<size_t, 32> ZEROS{};
+        glBindVertexBuffers(bindings.min_index, static_cast<GLsizei>(count),
+                            reinterpret_cast<const GLuint*>(ZEROS.data()),
+                            reinterpret_cast<const GLintptr*>(ZEROS.data()), buffer_strides.data());
+    } else {
+        glBindVertexBuffers(bindings.min_index, static_cast<GLsizei>(count), buffer_handles.data(),
+                            reinterpret_cast<const GLintptr*>(bindings.offsets.data()),
+                            buffer_strides.data());
+    }
 }
 
 void BufferCacheRuntime::BindUniformBuffer(size_t stage, u32 binding_index, Buffer& buffer,

src/video_core/renderer_opengl/gl_buffer_cache.h

@@ -209,6 +209,7 @@ private:
 
     bool has_fast_buffer_sub_data = false;
     bool use_assembly_shaders = false;
+    bool has_unified_vertex_buffers = false;
 
     bool use_storage_buffers = false;
 

src/video_core/renderer_opengl/gl_device.cpp

@@ -200,6 +200,7 @@ Device::Device(Core::Frontend::EmuWindow& emu_window) {
     has_broken_texture_view_formats = is_amd || (!is_linux && is_intel);
     has_nv_viewport_array2 = GLAD_GL_NV_viewport_array2;
     has_derivative_control = GLAD_GL_ARB_derivative_control;
+    has_vertex_buffer_unified_memory = GLAD_GL_NV_vertex_buffer_unified_memory;
     has_debugging_tool_attached = IsDebugToolAttached(extensions);
     has_depth_buffer_float = HasExtension(extensions, "GL_NV_depth_buffer_float");
     has_geometry_shader_passthrough = GLAD_GL_NV_geometry_shader_passthrough;

src/video_core/renderer_opengl/gl_device.h

@@ -72,6 +72,10 @@ public:
         return has_texture_shadow_lod;
     }
 
+    bool HasVertexBufferUnifiedMemory() const {
+        return has_vertex_buffer_unified_memory;
+    }
+
     bool HasASTC() const {
         return has_astc;
     }
@@ -211,6 +215,7 @@ private:
     bool has_vertex_viewport_layer{};
     bool has_image_load_formatted{};
     bool has_texture_shadow_lod{};
+    bool has_vertex_buffer_unified_memory{};
     bool has_astc{};
     bool has_variable_aoffi{};
     bool has_component_indexing_bug{};

src/video_core/renderer_opengl/gl_rasterizer.cpp

@@ -162,14 +162,18 @@ void RasterizerOpenGL::Clear(u32 layer_count) {
         SyncFramebufferSRGB();
     }
     if (regs.clear_surface.Z) {
-        ASSERT_MSG(regs.zeta_enable != 0, "Tried to clear Z but buffer is not enabled!");
+        if (regs.zeta_enable != 0) {
+            LOG_DEBUG(Render_OpenGL, "Tried to clear Z but buffer is not enabled!");
+        }
         use_depth = true;
 
         state_tracker.NotifyDepthMask();
         glDepthMask(GL_TRUE);
     }
     if (regs.clear_surface.S) {
-        ASSERT_MSG(regs.zeta_enable, "Tried to clear stencil but buffer is not enabled!");
+        if (regs.zeta_enable) {
+            LOG_DEBUG(Render_OpenGL, "Tried to clear stencil but buffer is not enabled!");
+        }
         use_stencil = true;
     }
 
@@ -1294,15 +1298,13 @@ void RasterizerOpenGL::BeginTransformFeedback(GraphicsPipeline* program, GLenum
     program->ConfigureTransformFeedback();
 
     UNIMPLEMENTED_IF(regs.IsShaderConfigEnabled(Maxwell::ShaderType::TessellationInit) ||
-                     regs.IsShaderConfigEnabled(Maxwell::ShaderType::Tessellation) ||
+                     regs.IsShaderConfigEnabled(Maxwell::ShaderType::Tessellation));
-                     regs.IsShaderConfigEnabled(Maxwell::ShaderType::Geometry));
-    UNIMPLEMENTED_IF(primitive_mode != GL_POINTS);
 
     // We may have to call BeginTransformFeedbackNV here since they seem to call different
     // implementations on Nvidia's driver (the pointer is different) but we are using
     // ARB_transform_feedback3 features with NV_transform_feedback interactions and the ARB
     // extension doesn't define BeginTransformFeedback (without NV) interactions. It just works.
-    glBeginTransformFeedback(GL_POINTS);
+    glBeginTransformFeedback(primitive_mode);
 }
 
 void RasterizerOpenGL::EndTransformFeedback() {

src/video_core/renderer_opengl/gl_shader_cache.cpp

@@ -233,6 +233,7 @@ ShaderCache::ShaderCache(RasterizerOpenGL& rasterizer_, Core::Frontend::EmuWindo
           .ignore_nan_fp_comparisons = true,
           .gl_max_compute_smem_size = device.GetMaxComputeSharedMemorySize(),
           .min_ssbo_alignment = device.GetShaderStorageBufferAlignment(),
+          .max_user_clip_distances = 8,
       },
       host_info{
           .support_float64 = true,
@@ -244,6 +245,7 @@ ShaderCache::ShaderCache(RasterizerOpenGL& rasterizer_, Core::Frontend::EmuWindo
           .min_ssbo_alignment = static_cast<u32>(device.GetShaderStorageBufferAlignment()),
           .support_geometry_shader_passthrough = device.HasGeometryShaderPassthrough(),
           .support_conditional_barrier = device.SupportsConditionalBarriers(),
+          .support_ufloat_write_as_uint = true,
       } {
     if (use_asynchronous_shaders) {
         workers = CreateWorkers();

src/video_core/renderer_opengl/renderer_opengl.cpp

@@ -168,6 +168,14 @@ RendererOpenGL::RendererOpenGL(Core::TelemetrySession& telemetry_session_,
     if (!GLAD_GL_ARB_seamless_cubemap_per_texture && !GLAD_GL_AMD_seamless_cubemap_per_texture) {
         glEnable(GL_TEXTURE_CUBE_MAP_SEAMLESS);
     }
+    // Enable unified vertex attributes and query vertex buffer address when the driver supports it
+    if (device.HasVertexBufferUnifiedMemory()) {
+        glEnableClientState(GL_VERTEX_ATTRIB_ARRAY_UNIFIED_NV);
+        glEnableClientState(GL_ELEMENT_ARRAY_UNIFIED_NV);
+        glMakeNamedBufferResidentNV(vertex_buffer.handle, GL_READ_ONLY);
+        glGetNamedBufferParameterui64vNV(vertex_buffer.handle, GL_BUFFER_GPU_ADDRESS_NV,
+                                         &vertex_buffer_address);
+    }
 }
 
 RendererOpenGL::~RendererOpenGL() = default;
@@ -667,7 +675,13 @@ void RendererOpenGL::DrawScreen(const Layout::FramebufferLayout& layout) {
                          offsetof(ScreenRectVertex, tex_coord));
     glVertexAttribBinding(PositionLocation, 0);
     glVertexAttribBinding(TexCoordLocation, 0);
-    glBindVertexBuffer(0, vertex_buffer.handle, 0, sizeof(ScreenRectVertex));
+    if (device.HasVertexBufferUnifiedMemory()) {
+        glBindVertexBuffer(0, 0, 0, sizeof(ScreenRectVertex));
+        glBufferAddressRangeNV(GL_VERTEX_ATTRIB_ARRAY_ADDRESS_NV, 0, vertex_buffer_address,
+                               sizeof(vertices));
+    } else {
+        glBindVertexBuffer(0, vertex_buffer.handle, 0, sizeof(ScreenRectVertex));
+    }
 
     if (Settings::values.scaling_filter.GetValue() != Settings::ScalingFilter::NearestNeighbor) {
         glBindSampler(0, present_sampler.handle);

src/video_core/renderer_vulkan/vk_buffer_cache.cpp

@@ -78,8 +78,15 @@ vk::Buffer CreateBuffer(const Device& device, const MemoryAllocator& memory_allo
 }
 } // Anonymous namespace
 
-Buffer::Buffer(BufferCacheRuntime&, VideoCommon::NullBufferParams null_params)
+Buffer::Buffer(BufferCacheRuntime& runtime, VideoCommon::NullBufferParams null_params)
-    : VideoCommon::BufferBase<VideoCore::RasterizerInterface>(null_params), tracker{4096} {}
+    : VideoCommon::BufferBase<VideoCore::RasterizerInterface>(null_params), tracker{4096} {
+    if (runtime.device.HasNullDescriptor()) {
+        return;
+    }
+    device = &runtime.device;
+    buffer = runtime.CreateNullBuffer();
+    is_null = true;
+}
 
 Buffer::Buffer(BufferCacheRuntime& runtime, VideoCore::RasterizerInterface& rasterizer_,
                VAddr cpu_addr_, u64 size_bytes_)
@@ -93,8 +100,12 @@ Buffer::Buffer(BufferCacheRuntime& runtime, VideoCore::RasterizerInterface& rast
 
 VkBufferView Buffer::View(u32 offset, u32 size, VideoCore::Surface::PixelFormat format) {
     if (!device) {
-        // Null buffer, return a null descriptor
+        // Null buffer supported, return a null descriptor
         return VK_NULL_HANDLE;
+    } else if (is_null) {
+        // Null buffer not supported, adjust offset and size
+        offset = 0;
+        size = 0;
     }
     const auto it{std::ranges::find_if(views, [offset, size, format](const BufferView& view) {
         return offset == view.offset && size == view.size && format == view.format;
@@ -563,22 +574,27 @@ void BufferCacheRuntime::BindVertexBuffers(VideoCommon::HostBindings<Buffer>& bi
         }
         buffer_handles.push_back(handle);
     }
+    const u32 device_max = device.GetMaxVertexInputBindings();
+    const u32 min_binding = std::min(bindings.min_index, device_max);
+    const u32 max_binding = std::min(bindings.max_index, device_max);
+    const u32 binding_count = max_binding - min_binding;
+    if (binding_count == 0) {
+        return;
+    }
     if (device.IsExtExtendedDynamicStateSupported()) {
-        scheduler.Record([this, bindings_ = std::move(bindings),
+        scheduler.Record([bindings_ = std::move(bindings),
-                          buffer_handles_ = std::move(buffer_handles)](vk::CommandBuffer cmdbuf) {
+                          buffer_handles_ = std::move(buffer_handles),
-            cmdbuf.BindVertexBuffers2EXT(bindings_.min_index,
+                          binding_count](vk::CommandBuffer cmdbuf) {
-                                         std::min(bindings_.max_index - bindings_.min_index,
+            cmdbuf.BindVertexBuffers2EXT(bindings_.min_index, binding_count, buffer_handles_.data(),
-                                                  device.GetMaxVertexInputBindings()),
+                                         bindings_.offsets.data(), bindings_.sizes.data(),
-                                         buffer_handles_.data(), bindings_.offsets.data(),
+                                         bindings_.strides.data());
-                                         bindings_.sizes.data(), bindings_.strides.data());
         });
     } else {
-        scheduler.Record([this, bindings_ = std::move(bindings),
+        scheduler.Record([bindings_ = std::move(bindings),
-                          buffer_handles_ = std::move(buffer_handles)](vk::CommandBuffer cmdbuf) {
+                          buffer_handles_ = std::move(buffer_handles),
-            cmdbuf.BindVertexBuffers(bindings_.min_index,
+                          binding_count](vk::CommandBuffer cmdbuf) {
-                                     std::min(bindings_.max_index - bindings_.min_index,
+            cmdbuf.BindVertexBuffers(bindings_.min_index, binding_count, buffer_handles_.data(),
-                                              device.GetMaxVertexInputBindings()),
+                                     bindings_.offsets.data());
-                                     buffer_handles_.data(), bindings_.offsets.data());
         });
     }
 }
@@ -622,9 +638,12 @@ void BufferCacheRuntime::BindTransformFeedbackBuffers(VideoCommon::HostBindings<
 }
 
 void BufferCacheRuntime::ReserveNullBuffer() {
-    if (null_buffer) {
+    if (!null_buffer) {
-        return;
+        null_buffer = CreateNullBuffer();
     }
+}
+
+vk::Buffer BufferCacheRuntime::CreateNullBuffer() {
     VkBufferCreateInfo create_info{
         .sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,
         .pNext = nullptr,
@@ -639,15 +658,17 @@ void BufferCacheRuntime::ReserveNullBuffer() {
     if (device.IsExtTransformFeedbackSupported()) {
         create_info.usage |= VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_BUFFER_BIT_EXT;
     }
-    null_buffer = memory_allocator.CreateBuffer(create_info, MemoryUsage::DeviceLocal);
+    vk::Buffer ret = memory_allocator.CreateBuffer(create_info, MemoryUsage::DeviceLocal);
     if (device.HasDebuggingToolAttached()) {
-        null_buffer.SetObjectNameEXT("Null buffer");
+        ret.SetObjectNameEXT("Null buffer");
     }
 
     scheduler.RequestOutsideRenderPassOperationContext();
-    scheduler.Record([buffer = *null_buffer](vk::CommandBuffer cmdbuf) {
+    scheduler.Record([buffer = *ret](vk::CommandBuffer cmdbuf) {
         cmdbuf.FillBuffer(buffer, 0, VK_WHOLE_SIZE, 0);
     });
+
+    return ret;
 }
 
 } // namespace Vulkan

src/video_core/renderer_vulkan/vk_buffer_cache.h

@@ -63,6 +63,7 @@ private:
     vk::Buffer buffer;
     std::vector<BufferView> views;
     VideoCommon::UsageTracker tracker;
+    bool is_null{};
 };
 
 class QuadArrayIndexBuffer;
@@ -151,6 +152,7 @@ private:
     }
 
     void ReserveNullBuffer();
+    vk::Buffer CreateNullBuffer();
 
     const Device& device;
     MemoryAllocator& memory_allocator;

src/video_core/renderer_vulkan/vk_pipeline_cache.cpp

@@ -374,6 +374,7 @@ PipelineCache::PipelineCache(RasterizerVulkan& rasterizer_, const Device& device
         .has_broken_robust =
             device.IsNvidia() && device.GetNvidiaArch() <= NvidiaArchitecture::Arch_Pascal,
         .min_ssbo_alignment = device.GetStorageBufferAlignment(),
+        .max_user_clip_distances = device.GetMaxUserClipDistances(),
     };
 
     host_info = Shader::HostTranslateInfo{
@@ -387,6 +388,9 @@ PipelineCache::PipelineCache(RasterizerVulkan& rasterizer_, const Device& device
         .min_ssbo_alignment = static_cast<u32>(device.GetStorageBufferAlignment()),
         .support_geometry_shader_passthrough = device.IsNvGeometryShaderPassthroughSupported(),
         .support_conditional_barrier = device.SupportsConditionalBarriers(),
+        .support_ufloat_write_as_uint = driver_id != VK_DRIVER_ID_QUALCOMM_PROPRIETARY &&
+                                        driver_id != VK_DRIVER_ID_MESA_TURNIP &&
+                                        driver_id != VK_DRIVER_ID_ARM_PROPRIETARY,
     };
 
     if (device.GetMaxVertexInputAttributes() < Maxwell::NumVertexAttributes) {

src/video_core/renderer_vulkan/vk_present_manager.cpp

@@ -293,10 +293,10 @@ void PresentManager::RecreateSwapchain(Frame* frame) {
 }
 
 void PresentManager::SetImageCount() {
-    // We cannot have more than 5 images in flight at any given time.
+    // We cannot have more than 7 images in flight at any given time.
-    // FRAMES_IN_FLIGHT is 7, and the cache TICKS_TO_DESTROY is 6.
+    // FRAMES_IN_FLIGHT is 8, and the cache TICKS_TO_DESTROY is 8.
     // Mali drivers will give us 6.
-    image_count = std::min<size_t>(swapchain.GetImageCount(), 5);
+    image_count = std::min<size_t>(swapchain.GetImageCount(), 7);
 }
 
 void PresentManager::CopyToSwapchain(Frame* frame) {

src/video_core/renderer_vulkan/vk_query_cache.cpp

@@ -289,12 +289,15 @@ public:
         }
 
         if (has_multi_queries) {
-            size_t intermediary_buffer_index = ObtainBuffer<false>(num_slots_used);
+            const size_t min_accumulation_limit =
+                std::min(first_accumulation_checkpoint, num_slots_used);
+            const size_t max_accumulation_limit =
+                std::max(last_accumulation_checkpoint, num_slots_used);
+            const size_t intermediary_buffer_index = ObtainBuffer<false>(num_slots_used);
             resolve_buffers.push_back(intermediary_buffer_index);
             queries_prefix_scan_pass->Run(*accumulation_buffer, *buffers[intermediary_buffer_index],
                                           *buffers[resolve_buffer_index], num_slots_used,
-                                          std::min(first_accumulation_checkpoint, num_slots_used),
+                                          min_accumulation_limit, max_accumulation_limit);
-                                          last_accumulation_checkpoint);
 
         } else {
             scheduler.RequestOutsideRenderPassOperationContext();

src/video_core/renderer_vulkan/vk_update_descriptor.h

@@ -31,7 +31,7 @@ struct DescriptorUpdateEntry {
 class UpdateDescriptorQueue final {
     // This should be plenty for the vast majority of cases. Most desktop platforms only
     // provide up to 3 swapchain images.
-    static constexpr size_t FRAMES_IN_FLIGHT = 7;
+    static constexpr size_t FRAMES_IN_FLIGHT = 8;
     static constexpr size_t FRAME_PAYLOAD_SIZE = 0x20000;
     static constexpr size_t PAYLOAD_SIZE = FRAME_PAYLOAD_SIZE * FRAMES_IN_FLIGHT;
 

src/video_core/shader_cache.cpp

@@ -132,7 +132,7 @@ void ShaderCache::Register(std::unique_ptr<ShaderInfo> data, VAddr addr, size_t
 
     storage.push_back(std::move(data));
 
-    rasterizer.UpdatePagesCachedCount(addr, size, true);
+    rasterizer.UpdatePagesCachedCount(addr, size, 1);
 }
 
 void ShaderCache::InvalidatePagesInRegion(VAddr addr, size_t size) {
@@ -209,7 +209,7 @@ void ShaderCache::UnmarkMemory(Entry* entry) {
 
     const VAddr addr = entry->addr_start;
     const size_t size = entry->addr_end - addr;
-    rasterizer.UpdatePagesCachedCount(addr, size, false);
+    rasterizer.UpdatePagesCachedCount(addr, size, -1);
 }
 
 void ShaderCache::RemoveShadersFromStorage(std::span<ShaderInfo*> removed_shaders) {

src/video_core/shader_environment.cpp

@@ -76,6 +76,8 @@ static Shader::TexturePixelFormat ConvertTexturePixelFormat(const Tegra::Texture
         return Shader::TexturePixelFormat::R16G16_SNORM;
     case VideoCore::Surface::PixelFormat::R16_SNORM:
         return Shader::TexturePixelFormat::R16_SNORM;
+    case VideoCore::Surface::PixelFormat::B10G11R11_FLOAT:
+        return Shader::TexturePixelFormat::B10G11R11_FLOAT;
     default:
         return Shader::TexturePixelFormat::OTHER;
     }

src/video_core/texture_cache/texture_cache.h

@@ -2080,7 +2080,7 @@ void TextureCache<P>::TrackImage(ImageBase& image, ImageId image_id) {
     ASSERT(False(image.flags & ImageFlagBits::Tracked));
     image.flags |= ImageFlagBits::Tracked;
     if (False(image.flags & ImageFlagBits::Sparse)) {
-        rasterizer.UpdatePagesCachedCount(image.cpu_addr, image.guest_size_bytes, true);
+        rasterizer.UpdatePagesCachedCount(image.cpu_addr, image.guest_size_bytes, 1);
         return;
     }
     if (True(image.flags & ImageFlagBits::Registered)) {
@@ -2091,13 +2091,13 @@ void TextureCache<P>::TrackImage(ImageBase& image, ImageId image_id) {
             const auto& map = slot_map_views[map_view_id];
             const VAddr cpu_addr = map.cpu_addr;
             const std::size_t size = map.size;
-            rasterizer.UpdatePagesCachedCount(cpu_addr, size, true);
+            rasterizer.UpdatePagesCachedCount(cpu_addr, size, 1);
         }
         return;
     }
     ForEachSparseSegment(image,
                          [this]([[maybe_unused]] GPUVAddr gpu_addr, VAddr cpu_addr, size_t size) {
-                             rasterizer.UpdatePagesCachedCount(cpu_addr, size, true);
+                             rasterizer.UpdatePagesCachedCount(cpu_addr, size, 1);
                          });
 }
 
@@ -2106,7 +2106,7 @@ void TextureCache<P>::UntrackImage(ImageBase& image, ImageId image_id) {
     ASSERT(True(image.flags & ImageFlagBits::Tracked));
     image.flags &= ~ImageFlagBits::Tracked;
     if (False(image.flags & ImageFlagBits::Sparse)) {
-        rasterizer.UpdatePagesCachedCount(image.cpu_addr, image.guest_size_bytes, false);
+        rasterizer.UpdatePagesCachedCount(image.cpu_addr, image.guest_size_bytes, -1);
         return;
     }
     ASSERT(True(image.flags & ImageFlagBits::Registered));
@@ -2117,7 +2117,7 @@ void TextureCache<P>::UntrackImage(ImageBase& image, ImageId image_id) {
         const auto& map = slot_map_views[map_view_id];
         const VAddr cpu_addr = map.cpu_addr;
         const std::size_t size = map.size;
-        rasterizer.UpdatePagesCachedCount(cpu_addr, size, false);
+        rasterizer.UpdatePagesCachedCount(cpu_addr, size, -1);
     }
 }
 

src/video_core/texture_cache/texture_cache_base.h

@@ -474,7 +474,7 @@ private:
     };
     Common::LeastRecentlyUsedCache<LRUItemParams> lru_cache;
 
-    static constexpr size_t TICKS_TO_DESTROY = 6;
+    static constexpr size_t TICKS_TO_DESTROY = 8;
     DelayedDestructionRing<Image, TICKS_TO_DESTROY> sentenced_images;
     DelayedDestructionRing<ImageView, TICKS_TO_DESTROY> sentenced_image_view;
     DelayedDestructionRing<Framebuffer, TICKS_TO_DESTROY> sentenced_framebuffers;

src/video_core/vulkan_common/vulkan_device.cpp

@@ -695,6 +695,11 @@ Device::Device(VkInstance instance_, vk::PhysicalDevice physical_, VkSurfaceKHR
             std::min(properties.properties.limits.maxVertexInputBindings, 16U);
     }
 
+    if (is_turnip) {
+        LOG_WARNING(Render_Vulkan, "Turnip requires higher-than-reported binding limits");
+        properties.properties.limits.maxVertexInputBindings = 32;
+    }
+
     if (!extensions.extended_dynamic_state && extensions.extended_dynamic_state2) {
         LOG_INFO(Render_Vulkan,
                  "Removing extendedDynamicState2 due to missing extendedDynamicState");

src/video_core/vulkan_common/vulkan_device.h

@@ -665,6 +665,10 @@ public:
         return properties.properties.limits.maxViewports;
     }
 
+    u32 GetMaxUserClipDistances() const {
+        return properties.properties.limits.maxClipDistances;
+    }
+
     bool SupportsConditionalBarriers() const {
         return supports_conditional_barriers;
     }

src/video_core/vulkan_common/vulkan_wrapper.cpp

@@ -377,6 +377,8 @@ const char* ToString(VkResult result) noexcept {
         return "VK_OPERATION_DEFERRED_KHR";
     case VkResult::VK_OPERATION_NOT_DEFERRED_KHR:
         return "VK_OPERATION_NOT_DEFERRED_KHR";
+    case VkResult::VK_ERROR_INVALID_VIDEO_STD_PARAMETERS_KHR:
+        return "VK_ERROR_INVALID_VIDEO_STD_PARAMETERS_KHR";
     case VkResult::VK_PIPELINE_COMPILE_REQUIRED_EXT:
         return "VK_PIPELINE_COMPILE_REQUIRED_EXT";
     case VkResult::VK_RESULT_MAX_ENUM:

src/yuzu/configuration/configure_ui.cpp

@@ -193,8 +193,8 @@ void ConfigureUi::RequestGameListUpdate() {
 void ConfigureUi::SetConfiguration() {
     ui->theme_combobox->setCurrentIndex(
         ui->theme_combobox->findData(QString::fromStdString(UISettings::values.theme)));
-    ui->language_combobox->setCurrentIndex(
+    ui->language_combobox->setCurrentIndex(ui->language_combobox->findData(
-        ui->language_combobox->findData(QString::fromStdString(UISettings::values.language)));
+        QString::fromStdString(UISettings::values.language.GetValue())));
     ui->show_add_ons->setChecked(UISettings::values.show_add_ons.GetValue());
     ui->show_compat->setChecked(UISettings::values.show_compat.GetValue());
     ui->show_size->setChecked(UISettings::values.show_size.GetValue());

src/yuzu/configuration/qt_config.cpp

@@ -187,7 +187,6 @@ void QtConfig::ReadPathValues() {
     BeginGroup(Settings::TranslateCategory(Settings::Category::Paths));
 
     UISettings::values.roms_path = ReadStringSetting(std::string("romsPath"));
-    UISettings::values.symbols_path = ReadStringSetting(std::string("symbolsPath"));
     UISettings::values.game_dir_deprecated =
         ReadStringSetting(std::string("gameListRootDir"), std::string("."));
     UISettings::values.game_dir_deprecated_deepscan =
@@ -225,8 +224,8 @@ void QtConfig::ReadPathValues() {
     UISettings::values.recent_files =
         QString::fromStdString(ReadStringSetting(std::string("recentFiles")))
             .split(QStringLiteral(", "), Qt::SkipEmptyParts, Qt::CaseSensitive);
-    UISettings::values.language =
+
-        ReadStringSetting(std::string("language"), std::make_optional(std::string("")));
+    ReadCategory(Settings::Category::Paths);
 
     EndGroup();
 }
@@ -408,8 +407,9 @@ void QtConfig::SaveQtControlValues() {
 void QtConfig::SavePathValues() {
     BeginGroup(Settings::TranslateCategory(Settings::Category::Paths));
 
+    WriteCategory(Settings::Category::Paths);
+
     WriteSetting(std::string("romsPath"), UISettings::values.roms_path);
-    WriteSetting(std::string("symbolsPath"), UISettings::values.symbols_path);
     BeginArray(std::string("gamedirs"));
     for (int i = 0; i < UISettings::values.game_dirs.size(); ++i) {
         SetArrayIndex(i);
@@ -422,7 +422,6 @@ void QtConfig::SavePathValues() {
 
     WriteSetting(std::string("recentFiles"),
                  UISettings::values.recent_files.join(QStringLiteral(", ")).toStdString());
-    WriteSetting(std::string("language"), UISettings::values.language);
 
     EndGroup();
 }

src/yuzu/main.cpp

@@ -5147,12 +5147,12 @@ void GMainWindow::UpdateUITheme() {
 void GMainWindow::LoadTranslation() {
     bool loaded;
 
-    if (UISettings::values.language.empty()) {
+    if (UISettings::values.language.GetValue().empty()) {
         // If the selected language is empty, use system locale
         loaded = translator.load(QLocale(), {}, {}, QStringLiteral(":/languages/"));
     } else {
         // Otherwise load from the specified file
-        loaded = translator.load(QString::fromStdString(UISettings::values.language),
+        loaded = translator.load(QString::fromStdString(UISettings::values.language.GetValue()),
                                  QStringLiteral(":/languages/"));
     }
 
@@ -5164,7 +5164,7 @@ void GMainWindow::LoadTranslation() {
 }
 
 void GMainWindow::OnLanguageChanged(const QString& locale) {
-    if (UISettings::values.language != std::string("en")) {
+    if (UISettings::values.language.GetValue() != std::string("en")) {
         qApp->removeTranslator(&translator);
     }
 

src/yuzu/uisettings.h

@@ -154,12 +154,11 @@ struct Values {
     Setting<u32> screenshot_height{linkage, 0, "screenshot_height", Category::Screenshots};
 
     std::string roms_path;
-    std::string symbols_path;
     std::string game_dir_deprecated;
     bool game_dir_deprecated_deepscan;
     QVector<GameDir> game_dirs;
     QStringList recent_files;
-    std::string language;
+    Setting<std::string> language{linkage, {}, "language", Category::Paths};
 
     std::string theme;
 

vcpkg.json

@@ -41,6 +41,15 @@
                     "platform": "windows"
                 }
             ]
+        },
+        "android": {
+            "description": "Enable Android dependencies",
+            "dependencies": [
+                {
+                    "name": "oboe",
+                    "platform": "android"
+                }
+            ]
         }
     },
     "overrides": [