NvFlinger: Split Buffer Wait from VSync on Async VSync.

This commit splits presentation from waiting. Now buffers will be waited for in a different thread and presented on a sepprate thread.
2020-07-02 20:23:58 -04:00
144 changed files with 1867 additions and 5068 deletions
--- a/.github/ISSUE_TEMPLATE/bug-report-feature-request.md
+++ b/.github/ISSUE_TEMPLATE/bug-report-feature-request.md
@@ -1,13 +1,4 @@
---
-name: Bug Report / Feature Request
-about: Tech support does not belong here. You should only file an issue here if you think you have experienced an actual bug with yuzu or you are requesting a feature you believe would make yuzu better.
-title: ''
-labels: ''
-assignees: ''
-
---
-
-<!---
+<!--
 Please keep in mind yuzu is EXPERIMENTAL SOFTWARE.

 Please read the FAQ:
--- a/.github/ISSUE_TEMPLATE/config.yml
+++ b/.github/ISSUE_TEMPLATE/config.yml
@@ -1,8 +0,0 @@
-blank_issues_enabled: false
-contact_links:
-  - name: yuzu Discord
-    url: https://discord.com/invite/u77vRWY
-    about: If you are experiencing an issue with yuzu, and you need tech support, or if you have a general question, try asking in the official yuzu Discord linked here. Piracy is not allowed.
-  - name: Community forums
-    url: https://community.citra-emu.org
-    about: This is an alternative place for tech support, however helpers there are not as active.
--- a/.gitmodules
+++ b/.gitmodules
@@ -34,9 +34,3 @@
 [submodule "xbyak"]
    path = externals/xbyak
    url = https://github.com/herumi/xbyak.git
-[submodule "externals/libusb"]
-	path = externals/libusb
-	url = https://github.com/ameerj/libusb
-[submodule "opus"]
-	path = externals/opus/opus
-	url = https://github.com/xiph/opus.git
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -118,17 +118,8 @@ message(STATUS "Target architecture: ${ARCHITECTURE}")
 # Configure C++ standard
 # ===========================

-if (MSVC)
-    add_compile_options(/std:c++latest)
-
-    # cubeb and boost still make use of deprecated result_of.
-    add_definitions(-D_HAS_DEPRECATED_RESULT_OF)
-    # boost asio's concept usage doesn't play nicely with MSVC yet.
-    add_definitions(-DBOOST_ASIO_DISABLE_CONCEPTS)
-else()
-    set(CMAKE_CXX_STANDARD 17)
-    set(CMAKE_CXX_STANDARD_REQUIRED ON)
-endif()
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)

 # Output binaries to bin/
 set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${PROJECT_BINARY_DIR}/bin)
@@ -160,11 +151,13 @@ macro(yuzu_find_packages)
    #    Cmake Pkg Prefix  Version     Conan Pkg
        "Boost             1.71        boost/1.72.0"
        "Catch2            2.11        catch2/2.11.0"
-        "fmt               7.0         fmt/7.0.1"
+        "fmt               6.2         fmt/6.2.0"
    # can't use until https://github.com/bincrafters/community/issues/1173
        #"libzip            1.5         libzip/1.5.2@bincrafters/stable"
        "lz4               1.8         lz4/1.9.2"
        "nlohmann_json     3.7         nlohmann_json/3.7.3"
+    # we need to be careful as the version check might be broken https://github.com/xiph/opus/issues/110
+        "opus              1.3         opus/1.3.1"
        "ZLIB              1.2         zlib/1.2.11"
        "zstd              1.4         zstd/1.4.4"
    )
@@ -220,7 +213,7 @@ if(ENABLE_QT)

        set(QT_PREFIX_HINT HINTS "${QT_PREFIX}")
    endif()
-    find_package(Qt5 5.9 COMPONENTS Widgets ${QT_PREFIX_HINT})
+    find_package(Qt5 5.9 COMPONENTS Widgets OpenGL ${QT_PREFIX_HINT})
    if (YUZU_USE_QT_WEB_ENGINE)
        find_package(Qt5 COMPONENTS WebEngineCore WebEngineWidgets)
    endif()
@@ -296,7 +289,7 @@ if (CONAN_REQUIRED_LIBS)
    if(ENABLE_QT)
        list(APPEND CMAKE_MODULE_PATH "${CONAN_QT_ROOT_RELEASE}")
        list(APPEND CMAKE_PREFIX_PATH "${CONAN_QT_ROOT_RELEASE}")
-        find_package(Qt5 5.9 REQUIRED COMPONENTS Widgets)
+        find_package(Qt5 5.9 REQUIRED COMPONENTS Widgets OpenGL)
        if (YUZU_USE_QT_WEB_ENGINE)
            find_package(Qt5 REQUIRED COMPONENTS WebEngineCore WebEngineWidgets)
        endif()
@@ -338,16 +331,6 @@ elseif(SDL2_FOUND)
    target_link_libraries(SDL2 INTERFACE "${SDL2_LIBRARIES}")
 endif()

-# Ensure libusb is properly configured (based on dolphin libusb include)
-if(NOT APPLE)
-    include(FindPkgConfig)
-    find_package(LibUSB)
-endif()
-if (NOT LIBUSB_FOUND)
-    add_subdirectory(externals/libusb)
-    set(LIBUSB_LIBRARIES usb)
-endif()
-
 # Prefer the -pthread flag on Linux.
 set(THREADS_PREFER_PTHREAD_FLAG ON)
 find_package(Threads REQUIRED)
--- a/CMakeModules/CopyYuzuQt5Deps.cmake
+++ b/CMakeModules/CopyYuzuQt5Deps.cmake
@@ -15,6 +15,7 @@ function(copy_yuzu_Qt5_deps target_dir)
        icuuc*.dll
        Qt5Core$<$<CONFIG:Debug>:d>.*
        Qt5Gui$<$<CONFIG:Debug>:d>.*
+        Qt5OpenGL$<$<CONFIG:Debug>:d>.*
        Qt5Widgets$<$<CONFIG:Debug>:d>.*
    )

--- a/README.md
+++ b/README.md
@@ -2,7 +2,7 @@ yuzu emulator
 =============
 [![Travis CI Build Status](https://travis-ci.com/yuzu-emu/yuzu.svg?branch=master)](https://travis-ci.com/yuzu-emu/yuzu)
 [![Azure Mainline CI Build Status](https://dev.azure.com/yuzu-emu/yuzu/_apis/build/status/yuzu%20mainline?branchName=master)](https://dev.azure.com/yuzu-emu/yuzu/)
-[![Discord](https://img.shields.io/discord/398318088170242053?color=%237289DA&label=yuzu&logo=discord&logoColor=white)](https://discord.com/invite/u77vRWY)
+[![Discord](https://img.shields.io/discord/398318088170242053?color=%237289DA&label=yuzu&logo=discord&logoColor=white)](https://discord.gg/XQV6dn9)

 yuzu is an experimental open-source emulator for the Nintendo Switch from the creators of [Citra](https://citra-emu.org/).

@@ -16,7 +16,7 @@ yuzu is licensed under the GPLv2 (or any later version). Refer to the license.tx

 Check out our [website](https://yuzu-emu.org/)!

-For development discussion, please join us on [Discord](https://discord.com/invite/u77vRWY).
+For development discussion, please join us on [Discord](https://discord.gg/XQV6dn9).

 ### Development

--- a/externals/CMakeLists.txt
+++ b/externals/CMakeLists.txt
@@ -91,6 +91,3 @@ if (ENABLE_WEB_SERVICE)
    target_compile_definitions(httplib INTERFACE -DCPPHTTPLIB_OPENSSL_SUPPORT)
    target_link_libraries(httplib INTERFACE ${OPENSSL_LIBRARIES})
 endif()
-
-# Opus
-add_subdirectory(opus)
--- a/externals/Vulkan-Headers
+++ b/externals/Vulkan-Headers
--- a/externals/find-modules/FindLibUSB.cmake
+++ b/externals/find-modules/FindLibUSB.cmake
@@ -1,43 +0,0 @@
-# - Find libusb-1.0 library
-# This module defines
-#  LIBUSB_INCLUDE_DIR, where to find bluetooth.h
-#  LIBUSB_LIBRARIES, the libraries needed to use libusb-1.0.
-#  LIBUSB_FOUND, If false, do not try to use libusb-1.0.
-#
-# Copyright (c) 2009, Michal Cihar, <michal@cihar.com>
-#
-# vim: expandtab sw=4 ts=4 sts=4:
-
-if(ANDROID)
-       set(LIBUSB_FOUND FALSE CACHE INTERNAL "libusb-1.0 found")
-       message(STATUS "libusb-1.0 not found.")
-elseif (NOT LIBUSB_FOUND)
-    pkg_check_modules (LIBUSB_PKG libusb-1.0)
-
-    find_path(LIBUSB_INCLUDE_DIR NAMES libusb.h
-       PATHS
-       ${LIBUSB_PKG_INCLUDE_DIRS}
-       /usr/include/libusb-1.0
-       /usr/include
-       /usr/local/include/libusb-1.0
-       /usr/local/include
-    )
-
-    find_library(LIBUSB_LIBRARIES NAMES usb-1.0 usb
-       PATHS
-       ${LIBUSB_PKG_LIBRARY_DIRS}
-       /usr/lib
-       /usr/local/lib
-    )
-
-    if(LIBUSB_INCLUDE_DIR AND LIBUSB_LIBRARIES)
-       set(LIBUSB_FOUND TRUE CACHE INTERNAL "libusb-1.0 found")
-       message(STATUS "Found libusb-1.0: ${LIBUSB_INCLUDE_DIR}, ${LIBUSB_LIBRARIES}")
-    else(LIBUSB_INCLUDE_DIR AND LIBUSB_LIBRARIES)
-       set(LIBUSB_FOUND FALSE CACHE INTERNAL "libusb-1.0 found")
-       message(STATUS "libusb-1.0 not found.")
-    endif(LIBUSB_INCLUDE_DIR AND LIBUSB_LIBRARIES)
-
-    mark_as_advanced(LIBUSB_INCLUDE_DIR LIBUSB_LIBRARIES)
-endif ()
-
--- a/externals/libusb
+++ b/externals/libusb
--- a/externals/opus/CMakeLists.txt
+++ b/externals/opus/CMakeLists.txt
@@ -1,254 +0,0 @@
-cmake_minimum_required(VERSION 3.8)
-
-project(opus)
-
-option(OPUS_STACK_PROTECTOR "Use stack protection" OFF)
-option(OPUS_USE_ALLOCA "Use alloca for stack arrays (on non-C99 compilers)" OFF)
-option(OPUS_CUSTOM_MODES "Enable non-Opus modes, e.g. 44.1 kHz & 2^n frames" OFF)
-option(OPUS_FIXED_POINT "Compile as fixed-point (for machines without a fast enough FPU)" OFF)
-option(OPUS_ENABLE_FLOAT_API "Compile with the floating point API (for machines with float library" ON)
-
-include(opus/opus_functions.cmake)
-
-if(OPUS_STACK_PROTECTOR)
-    if(NOT MSVC) # GC on by default on MSVC
-        check_and_set_flag(STACK_PROTECTION_STRONG -fstack-protector-strong)
-    endif()
-else()
-    if(MSVC)
-        check_and_set_flag(BUFFER_SECURITY_CHECK /GS-)
-    endif()
-endif()
-
-add_library(opus STATIC
-    # CELT sources
-    opus/celt/bands.c
-    opus/celt/celt.c
-    opus/celt/celt_decoder.c
-    opus/celt/celt_encoder.c
-    opus/celt/celt_lpc.c
-    opus/celt/cwrs.c
-    opus/celt/entcode.c
-    opus/celt/entdec.c
-    opus/celt/entenc.c
-    opus/celt/kiss_fft.c
-    opus/celt/laplace.c
-    opus/celt/mathops.c
-    opus/celt/mdct.c
-    opus/celt/modes.c
-    opus/celt/pitch.c
-    opus/celt/quant_bands.c
-    opus/celt/rate.c
-    opus/celt/vq.c
-
-    # SILK sources
-    opus/silk/A2NLSF.c
-    opus/silk/CNG.c
-    opus/silk/HP_variable_cutoff.c
-    opus/silk/LPC_analysis_filter.c
-    opus/silk/LPC_fit.c
-    opus/silk/LPC_inv_pred_gain.c
-    opus/silk/LP_variable_cutoff.c
-    opus/silk/NLSF2A.c
-    opus/silk/NLSF_VQ.c
-    opus/silk/NLSF_VQ_weights_laroia.c
-    opus/silk/NLSF_decode.c
-    opus/silk/NLSF_del_dec_quant.c
-    opus/silk/NLSF_encode.c
-    opus/silk/NLSF_stabilize.c
-    opus/silk/NLSF_unpack.c
-    opus/silk/NSQ.c
-    opus/silk/NSQ_del_dec.c
-    opus/silk/PLC.c
-    opus/silk/VAD.c
-    opus/silk/VQ_WMat_EC.c
-    opus/silk/ana_filt_bank_1.c
-    opus/silk/biquad_alt.c
-    opus/silk/bwexpander.c
-    opus/silk/bwexpander_32.c
-    opus/silk/check_control_input.c
-    opus/silk/code_signs.c
-    opus/silk/control_SNR.c
-    opus/silk/control_audio_bandwidth.c
-    opus/silk/control_codec.c
-    opus/silk/dec_API.c
-    opus/silk/decode_core.c
-    opus/silk/decode_frame.c
-    opus/silk/decode_indices.c
-    opus/silk/decode_parameters.c
-    opus/silk/decode_pitch.c
-    opus/silk/decode_pulses.c
-    opus/silk/decoder_set_fs.c
-    opus/silk/enc_API.c
-    opus/silk/encode_indices.c
-    opus/silk/encode_pulses.c
-    opus/silk/gain_quant.c
-    opus/silk/init_decoder.c
-    opus/silk/init_encoder.c
-    opus/silk/inner_prod_aligned.c
-    opus/silk/interpolate.c
-    opus/silk/lin2log.c
-    opus/silk/log2lin.c
-    opus/silk/pitch_est_tables.c
-    opus/silk/process_NLSFs.c
-    opus/silk/quant_LTP_gains.c
-    opus/silk/resampler.c
-    opus/silk/resampler_down2.c
-    opus/silk/resampler_down2_3.c
-    opus/silk/resampler_private_AR2.c
-    opus/silk/resampler_private_IIR_FIR.c
-    opus/silk/resampler_private_down_FIR.c
-    opus/silk/resampler_private_up2_HQ.c
-    opus/silk/resampler_rom.c
-    opus/silk/shell_coder.c
-    opus/silk/sigm_Q15.c
-    opus/silk/sort.c
-    opus/silk/stereo_LR_to_MS.c
-    opus/silk/stereo_MS_to_LR.c
-    opus/silk/stereo_decode_pred.c
-    opus/silk/stereo_encode_pred.c
-    opus/silk/stereo_find_predictor.c
-    opus/silk/stereo_quant_pred.c
-    opus/silk/sum_sqr_shift.c
-    opus/silk/table_LSF_cos.c
-    opus/silk/tables_LTP.c
-    opus/silk/tables_NLSF_CB_NB_MB.c
-    opus/silk/tables_NLSF_CB_WB.c
-    opus/silk/tables_gain.c
-    opus/silk/tables_other.c
-    opus/silk/tables_pitch_lag.c
-    opus/silk/tables_pulses_per_block.c
-
-    # Opus sources
-    opus/src/analysis.c
-    opus/src/mapping_matrix.c
-    opus/src/mlp.c
-    opus/src/mlp_data.c
-    opus/src/opus.c
-    opus/src/opus_decoder.c
-    opus/src/opus_encoder.c
-    opus/src/opus_multistream.c
-    opus/src/opus_multistream_decoder.c
-    opus/src/opus_multistream_encoder.c
-    opus/src/opus_projection_decoder.c
-    opus/src/opus_projection_encoder.c
-    opus/src/repacketizer.c
-)
-
-if (DEBUG)
-    target_sources(opus PRIVATE opus/silk/debug.c)
-endif()
-
-if (OPUS_FIXED_POINT)
-    target_sources(opus PRIVATE
-        opus/silk/fixed/LTP_analysis_filter_FIX.c
-        opus/silk/fixed/LTP_scale_ctrl_FIX.c
-        opus/silk/fixed/apply_sine_window_FIX.c
-        opus/silk/fixed/autocorr_FIX.c
-        opus/silk/fixed/burg_modified_FIX.c
-        opus/silk/fixed/corrMatrix_FIX.c
-        opus/silk/fixed/encode_frame_FIX.c
-        opus/silk/fixed/find_LPC_FIX.c
-        opus/silk/fixed/find_LTP_FIX.c
-        opus/silk/fixed/find_pitch_lags_FIX.c
-        opus/silk/fixed/find_pred_coefs_FIX.c
-        opus/silk/fixed/k2a_FIX.c
-        opus/silk/fixed/k2a_Q16_FIX.c
-        opus/silk/fixed/noise_shape_analysis_FIX.c
-        opus/silk/fixed/pitch_analysis_core_FIX.c
-        opus/silk/fixed/prefilter_FIX.c
-        opus/silk/fixed/process_gains_FIX.c
-        opus/silk/fixed/regularize_correlations_FIX.c
-        opus/silk/fixed/residual_energy16_FIX.c
-        opus/silk/fixed/residual_energy_FIX.c
-        opus/silk/fixed/schur64_FIX.c
-        opus/silk/fixed/schur_FIX.c
-        opus/silk/fixed/solve_LS_FIX.c
-        opus/silk/fixed/vector_ops_FIX.c
-        opus/silk/fixed/warped_autocorrelation_FIX.c
-    )
-else()
-    target_sources(opus PRIVATE
-        opus/silk/float/LPC_analysis_filter_FLP.c
-        opus/silk/float/LPC_inv_pred_gain_FLP.c
-        opus/silk/float/LTP_analysis_filter_FLP.c
-        opus/silk/float/LTP_scale_ctrl_FLP.c
-        opus/silk/float/apply_sine_window_FLP.c
-        opus/silk/float/autocorrelation_FLP.c
-        opus/silk/float/burg_modified_FLP.c
-        opus/silk/float/bwexpander_FLP.c
-        opus/silk/float/corrMatrix_FLP.c
-        opus/silk/float/encode_frame_FLP.c
-        opus/silk/float/energy_FLP.c
-        opus/silk/float/find_LPC_FLP.c
-        opus/silk/float/find_LTP_FLP.c
-        opus/silk/float/find_pitch_lags_FLP.c
-        opus/silk/float/find_pred_coefs_FLP.c
-        opus/silk/float/inner_product_FLP.c
-        opus/silk/float/k2a_FLP.c
-        opus/silk/float/noise_shape_analysis_FLP.c
-        opus/silk/float/pitch_analysis_core_FLP.c
-        opus/silk/float/process_gains_FLP.c
-        opus/silk/float/regularize_correlations_FLP.c
-        opus/silk/float/residual_energy_FLP.c
-        opus/silk/float/scale_copy_vector_FLP.c
-        opus/silk/float/scale_vector_FLP.c
-        opus/silk/float/schur_FLP.c
-        opus/silk/float/sort_FLP.c
-        opus/silk/float/warped_autocorrelation_FLP.c
-        opus/silk/float/wrappers_FLP.c
-    )
-endif()
-
-target_compile_definitions(opus PRIVATE OPUS_BUILD ENABLE_HARDENING)
-
-if(NOT MSVC)
-    if(MINGW)
-        target_compile_definitions(opus PRIVATE _FORTIFY_SOURCE=0)
-    else()
-        target_compile_definitions(opus PRIVATE _FORTIFY_SOURCE=2)
-    endif()
-endif()
-
-# It is strongly recommended to uncomment one of these VAR_ARRAYS: Use C99
-# variable-length arrays for stack allocation USE_ALLOCA: Use alloca() for stack
-# allocation If none is defined, then the fallback is a non-threadsafe global
-# array
-if(OPUS_USE_ALLOCA OR MSVC)
-    target_compile_definitions(opus PRIVATE USE_ALLOCA)
-else()
-    target_compile_definitions(opus PRIVATE VAR_ARRAYS)
-endif()
-
-if(OPUS_CUSTOM_MODES)
-    target_compile_definitions(opus PRIVATE CUSTOM_MODES)
-endif()
-
-if(NOT OPUS_ENABLE_FLOAT_API)
-    target_compile_definitions(opus PRIVATE DISABLE_FLOAT_API)
-endif()
-
-target_compile_definitions(opus
-PUBLIC
-    -DOPUS_VERSION="\\"1.3.1\\""
-
-PRIVATE
-    # Use C99 intrinsics to speed up float-to-int conversion
-    HAVE_LRINTF
-)
-
-if (FIXED_POINT)
-    target_compile_definitions(opus PRIVATE -DFIXED_POINT=1 -DDISABLE_FLOAT_API)
-endif()
-
-target_include_directories(opus
-PUBLIC
-    opus/include
-
-PRIVATE
-    opus/celt
-    opus/silk
-    opus/silk/fixed
-    opus/silk/float
-    opus/src
-)
--- a/externals/opus/opus
+++ b/externals/opus/opus
--- a/src/audio_core/cubeb_sink.cpp
+++ b/src/audio_core/cubeb_sink.cpp
@@ -193,7 +193,7 @@ long CubebSinkStream::DataCallback(cubeb_stream* stream, void* user_data, const
    const std::size_t samples_to_write = num_channels * num_frames;
    std::size_t samples_written;

-    if (Settings::values.enable_audio_stretching.GetValue()) {
+    if (Settings::values.enable_audio_stretching) {
        const std::vector<s16> in{impl->queue.Pop()};
        const std::size_t num_in{in.size() / num_channels};
        s16* const out{reinterpret_cast<s16*>(buffer)};
--- a/src/audio_core/stream.cpp
+++ b/src/audio_core/stream.cpp
@@ -38,7 +38,7 @@ Stream::Stream(Core::Timing::CoreTiming& core_timing, u32 sample_rate, Format fo
      sink_stream{sink_stream}, core_timing{core_timing}, name{std::move(name_)} {

    release_event = Core::Timing::CreateEvent(
-        name, [this](u64 userdata, s64 cycles_late) { ReleaseActiveBuffer(cycles_late); });
+        name, [this](u64 userdata, s64 cycles_late) { ReleaseActiveBuffer(); });
 }

 void Stream::Play() {
@@ -66,6 +66,15 @@ s64 Stream::GetBufferReleaseNS(const Buffer& buffer) const {
    return ns.count();
 }

+s64 Stream::GetBufferReleaseNSHostTiming(const Buffer& buffer) const {
+    const std::size_t num_samples{buffer.GetSamples().size() / GetNumChannels()};
+    /// DSP signals before playing the last sample, in HLE we emulate this in this way
+    s64 base_samples = std::max<s64>(static_cast<s64>(num_samples) - 1, 0);
+    const auto ns =
+        std::chrono::nanoseconds((static_cast<u64>(base_samples) * 1000000000ULL) / sample_rate);
+    return ns.count();
+}
+
 static void VolumeAdjustSamples(std::vector<s16>& samples, float game_volume) {
    const float volume{std::clamp(Settings::Volume() - (1.0f - game_volume), 0.0f, 1.0f)};

@@ -80,7 +89,7 @@ static void VolumeAdjustSamples(std::vector<s16>& samples, float game_volume) {
    }
 }

-void Stream::PlayNextBuffer(s64 cycles_late) {
+void Stream::PlayNextBuffer() {
    if (!IsPlaying()) {
        // Ensure we are in playing state before playing the next buffer
        sink_stream.Flush();
@@ -105,17 +114,18 @@ void Stream::PlayNextBuffer(s64 cycles_late) {

    sink_stream.EnqueueSamples(GetNumChannels(), active_buffer->GetSamples());

-    core_timing.ScheduleEvent(
-        GetBufferReleaseNS(*active_buffer) -
-            (Settings::values.enable_audio_stretching.GetValue() ? 0 : cycles_late),
-        release_event, {});
+    if (core_timing.IsHostTiming()) {
+        core_timing.ScheduleEvent(GetBufferReleaseNSHostTiming(*active_buffer), release_event, {});
+    } else {
+        core_timing.ScheduleEvent(GetBufferReleaseNS(*active_buffer), release_event, {});
+    }
 }

-void Stream::ReleaseActiveBuffer(s64 cycles_late) {
+void Stream::ReleaseActiveBuffer() {
    ASSERT(active_buffer);
    released_buffers.push(std::move(active_buffer));
    release_callback();
-    PlayNextBuffer(cycles_late);
+    PlayNextBuffer();
 }

 bool Stream::QueueBuffer(BufferPtr&& buffer) {
--- a/src/audio_core/stream.h
+++ b/src/audio_core/stream.h
@@ -90,10 +90,10 @@ public:

 private:
    /// Plays the next queued buffer in the audio stream, starting playback if necessary
-    void PlayNextBuffer(s64 cycles_late = 0);
+    void PlayNextBuffer();

    /// Releases the actively playing buffer, signalling that it has been completed
-    void ReleaseActiveBuffer(s64 cycles_late = 0);
+    void ReleaseActiveBuffer();

    /// Gets the number of core cycles when the specified buffer will be released
    s64 GetBufferReleaseNS(const Buffer& buffer) const;
--- a/src/common/alignment.h
+++ b/src/common/alignment.h
@@ -11,9 +11,7 @@ namespace Common {
 template <typename T>
 constexpr T AlignUp(T value, std::size_t size) {
    static_assert(std::is_unsigned_v<T>, "T must be an unsigned value.");
-    auto mod{static_cast<T>(value % size)};
-    value -= mod;
-    return static_cast<T>(mod == T{0} ? value : value + size);
+    return static_cast<T>(value + (size - value % size) % size);
 }

 template <typename T>
--- a/src/core/CMakeLists.txt
+++ b/src/core/CMakeLists.txt
@@ -614,7 +614,7 @@ endif()
 create_target_directory_groups(core)

 target_link_libraries(core PUBLIC common PRIVATE audio_core video_core)
-target_link_libraries(core PUBLIC Boost::boost PRIVATE fmt::fmt nlohmann_json::nlohmann_json mbedtls opus unicorn zip)
+target_link_libraries(core PUBLIC Boost::boost PRIVATE fmt::fmt nlohmann_json::nlohmann_json mbedtls Opus::Opus unicorn zip)

 if (YUZU_ENABLE_BOXCAT)
    target_compile_definitions(core PRIVATE -DYUZU_ENABLE_BOXCAT)
--- a/src/core/arm/cpu_interrupt_handler.cpp
+++ b/src/core/arm/cpu_interrupt_handler.cpp
@@ -2,6 +2,8 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.

+#pragma once
+
 #include "common/thread.h"
 #include "core/arm/cpu_interrupt_handler.h"

--- a/src/core/core.cpp
+++ b/src/core/core.cpp
@@ -147,8 +147,8 @@ struct System::Impl {

        device_memory = std::make_unique<Core::DeviceMemory>(system);

-        is_multicore = Settings::values.use_multi_core.GetValue();
-        is_async_gpu = is_multicore || Settings::values.use_asynchronous_gpu_emulation.GetValue();
+        is_multicore = Settings::values.use_multi_core;
+        is_async_gpu = is_multicore || Settings::values.use_asynchronous_gpu_emulation;

        kernel.SetMulticore(is_multicore);
        cpu_manager.SetMulticore(is_multicore);
@@ -162,7 +162,7 @@ struct System::Impl {
        const auto current_time = std::chrono::duration_cast<std::chrono::seconds>(
            std::chrono::system_clock::now().time_since_epoch());
        Settings::values.custom_rtc_differential =
-            Settings::values.custom_rtc.GetValue().value_or(current_time) - current_time;
+            Settings::values.custom_rtc.value_or(current_time) - current_time;

        // Create a default fs if one doesn't already exist.
        if (virtual_filesystem == nullptr)
--- a/src/core/core_timing.cpp
+++ b/src/core/core_timing.cpp
@@ -172,7 +172,7 @@ void CoreTiming::ClearPendingEvents() {
 }

 void CoreTiming::RemoveEvent(const std::shared_ptr<EventType>& event_type) {
-    std::scoped_lock lock{basic_lock};
+    basic_lock.lock();

    const auto itr = std::remove_if(event_queue.begin(), event_queue.end(), [&](const Event& e) {
        return e.type.lock().get() == event_type.get();
@@ -183,10 +183,12 @@ void CoreTiming::RemoveEvent(const std::shared_ptr<EventType>& event_type) {
        event_queue.erase(itr, event_queue.end());
        std::make_heap(event_queue.begin(), event_queue.end(), std::greater<>());
    }
+    basic_lock.unlock();
 }

 std::optional<s64> CoreTiming::Advance() {
-    std::scoped_lock lock{advance_lock, basic_lock};
+    std::scoped_lock advance_scope{advance_lock};
+    std::scoped_lock basic_scope{basic_lock};
    global_timer = GetGlobalTimeNs().count();

    while (!event_queue.empty() && event_queue.front().time <= global_timer) {
--- a/src/core/crypto/key_manager.cpp
+++ b/src/core/crypto/key_manager.cpp
@@ -695,9 +695,8 @@ void KeyManager::WriteKeyToFile(KeyCategory category, std::string_view keyname,
 }

 void KeyManager::SetKey(S128KeyType id, Key128 key, u64 field1, u64 field2) {
-    if (s128_keys.find({id, field1, field2}) != s128_keys.end() || key == Key128{}) {
+    if (s128_keys.find({id, field1, field2}) != s128_keys.end())
        return;
-    }
    if (id == S128KeyType::Titlekey) {
        Key128 rights_id;
        std::memcpy(rights_id.data(), &field2, sizeof(u64));
@@ -717,9 +716,8 @@ void KeyManager::SetKey(S128KeyType id, Key128 key, u64 field1, u64 field2) {
            return std::tie(elem.second.type, elem.second.field1, elem.second.field2) ==
                   std::tie(id, field1, field2);
        });
-    if (iter2 != s128_file_id.end()) {
+    if (iter2 != s128_file_id.end())
        WriteKeyToFile(category, iter2->first, key);
-    }

    // Variable cases
    if (id == S128KeyType::KeyArea) {
@@ -747,18 +745,16 @@ void KeyManager::SetKey(S128KeyType id, Key128 key, u64 field1, u64 field2) {
 }

 void KeyManager::SetKey(S256KeyType id, Key256 key, u64 field1, u64 field2) {
-    if (s256_keys.find({id, field1, field2}) != s256_keys.end() || key == Key256{}) {
+    if (s256_keys.find({id, field1, field2}) != s256_keys.end())
        return;
-    }
    const auto iter = std::find_if(
        s256_file_id.begin(), s256_file_id.end(),
        [&id, &field1, &field2](const std::pair<std::string, KeyIndex<S256KeyType>> elem) {
            return std::tie(elem.second.type, elem.second.field1, elem.second.field2) ==
                   std::tie(id, field1, field2);
        });
-    if (iter != s256_file_id.end()) {
+    if (iter != s256_file_id.end())
        WriteKeyToFile(KeyCategory::Standard, iter->first, key);
-    }
    s256_keys[{id, field1, field2}] = key;
 }

--- a/src/core/file_sys/vfs_real.cpp
+++ b/src/core/file_sys/vfs_real.cpp
@@ -112,26 +112,19 @@ VirtualFile RealVfsFilesystem::MoveFile(std::string_view old_path_, std::string_
    const auto new_path =
        FileUtil::SanitizePath(new_path_, FileUtil::DirectorySeparator::PlatformDefault);

-    if (cache.find(old_path) != cache.end()) {
-        auto file = cache[old_path].lock();
-
-        if (!cache[old_path].expired()) {
-            file->Close();
-        }
-
-        if (!FileUtil::Exists(old_path) || FileUtil::Exists(new_path) ||
-            FileUtil::IsDirectory(old_path) || !FileUtil::Rename(old_path, new_path)) {
-            return nullptr;
-        }
-
-        cache.erase(old_path);
-        file->Open(new_path, "r+b");
-        cache[new_path] = file;
-    } else {
-        UNREACHABLE();
+    if (!FileUtil::Exists(old_path) || FileUtil::Exists(new_path) ||
+        FileUtil::IsDirectory(old_path) || !FileUtil::Rename(old_path, new_path))
        return nullptr;
-    }

+    if (cache.find(old_path) != cache.end()) {
+        auto cached = cache[old_path];
+        if (!cached.expired()) {
+            auto file = cached.lock();
+            file->Open(new_path, "r+b");
+            cache.erase(old_path);
+            cache[new_path] = file;
+        }
+    }
    return OpenFile(new_path, Mode::ReadWrite);
 }

--- a/src/core/frontend/framebuffer_layout.cpp
+++ b/src/core/frontend/framebuffer_layout.cpp
@@ -29,7 +29,7 @@ FramebufferLayout DefaultFrameLayout(u32 width, u32 height) {

    const float window_aspect_ratio = static_cast<float>(height) / width;
    const float emulation_aspect_ratio = EmulationAspectRatio(
-        static_cast<AspectRatio>(Settings::values.aspect_ratio.GetValue()), window_aspect_ratio);
+        static_cast<AspectRatio>(Settings::values.aspect_ratio), window_aspect_ratio);

    const Common::Rectangle<u32> screen_window_area{0, 0, width, height};
    Common::Rectangle<u32> screen = MaxRectangle(screen_window_area, emulation_aspect_ratio);
--- a/src/core/hle/kernel/process.cpp
+++ b/src/core/hle/kernel/process.cpp
@@ -123,7 +123,7 @@ std::shared_ptr<Process> Process::Create(Core::System& system, std::string name,
                                                              : kernel.CreateNewUserProcessID();
    process->capabilities.InitializeForMetadatalessProcess();

-    std::mt19937 rng(Settings::values.rng_seed.GetValue().value_or(0));
+    std::mt19937 rng(Settings::values.rng_seed.value_or(0));
    std::uniform_int_distribution<u64> distribution;
    std::generate(process->random_entropy.begin(), process->random_entropy.end(),
                  [&] { return distribution(rng); });
--- a/src/core/hle/kernel/scheduler.cpp
+++ b/src/core/hle/kernel/scheduler.cpp
@@ -6,7 +6,6 @@
 // licensed under GPLv2 or later under exception provided by the author.

 #include <algorithm>
-#include <mutex>
 #include <set>
 #include <unordered_set>
 #include <utility>
@@ -32,20 +31,22 @@ GlobalScheduler::GlobalScheduler(KernelCore& kernel) : kernel{kernel} {}
 GlobalScheduler::~GlobalScheduler() = default;

 void GlobalScheduler::AddThread(std::shared_ptr<Thread> thread) {
-    std::scoped_lock lock{global_list_guard};
+    global_list_guard.lock();
    thread_list.push_back(std::move(thread));
+    global_list_guard.unlock();
 }

 void GlobalScheduler::RemoveThread(std::shared_ptr<Thread> thread) {
-    std::scoped_lock lock{global_list_guard};
+    global_list_guard.lock();
    thread_list.erase(std::remove(thread_list.begin(), thread_list.end(), thread),
                      thread_list.end());
+    global_list_guard.unlock();
 }

 u32 GlobalScheduler::SelectThreads() {
    ASSERT(is_locked);
    const auto update_thread = [](Thread* thread, Scheduler& sched) {
-        std::scoped_lock lock{sched.guard};
+        sched.guard.lock();
        if (thread != sched.selected_thread_set.get()) {
            if (thread == nullptr) {
                ++sched.idle_selection_count;
@@ -56,6 +57,7 @@ u32 GlobalScheduler::SelectThreads() {
            sched.is_context_switch_pending || (sched.selected_thread_set != sched.current_thread);
        sched.is_context_switch_pending = reschedule_pending;
        std::atomic_thread_fence(std::memory_order_seq_cst);
+        sched.guard.unlock();
        return reschedule_pending;
    };
    if (!is_reselection_pending.load()) {
@@ -755,12 +757,11 @@ void Scheduler::OnSwitch(void* this_scheduler) {

 void Scheduler::SwitchToCurrent() {
    while (true) {
-        {
-            std::scoped_lock lock{guard};
-            selected_thread = selected_thread_set;
-            current_thread = selected_thread;
-            is_context_switch_pending = false;
-        }
+        guard.lock();
+        selected_thread = selected_thread_set;
+        current_thread = selected_thread;
+        is_context_switch_pending = false;
+        guard.unlock();
        while (!is_context_switch_pending) {
            if (current_thread != nullptr && !current_thread->IsHLEThread()) {
                current_thread->context_guard.lock();
--- a/src/core/hle/service/acc/acc.cpp
+++ b/src/core/hle/service/acc/acc.cpp
@@ -776,15 +776,6 @@ void Module::Interface::ListQualifiedUsers(Kernel::HLERequestContext& ctx) {
    rb.Push(RESULT_SUCCESS);
 }

-void Module::Interface::ListOpenContextStoredUsers(Kernel::HLERequestContext& ctx) {
-    LOG_WARNING(Service_ACC, "(STUBBED) called");
-
-    // TODO(ogniK): Handle open contexts
-    ctx.WriteBuffer(profile_manager->GetOpenUsers());
-    IPC::ResponseBuilder rb{ctx, 2};
-    rb.Push(RESULT_SUCCESS);
-}
-
 void Module::Interface::TrySelectUserWithoutInteraction(Kernel::HLERequestContext& ctx) {
    LOG_DEBUG(Service_ACC, "called");
    // A u8 is passed into this function which we can safely ignore. It's to determine if we have
--- a/src/core/hle/service/acc/acc.h
+++ b/src/core/hle/service/acc/acc.h
@@ -34,7 +34,6 @@ public:
        void IsUserAccountSwitchLocked(Kernel::HLERequestContext& ctx);
        void GetProfileEditor(Kernel::HLERequestContext& ctx);
        void ListQualifiedUsers(Kernel::HLERequestContext& ctx);
-        void ListOpenContextStoredUsers(Kernel::HLERequestContext& ctx);

    private:
        ResultCode InitializeApplicationInfoBase();
--- a/src/core/hle/service/acc/acc_su.cpp
+++ b/src/core/hle/service/acc/acc_su.cpp
@@ -20,7 +20,7 @@ ACC_SU::ACC_SU(std::shared_ptr<Module> module, std::shared_ptr<ProfileManager> p
        {6, nullptr, "GetProfileDigest"}, // 3.0.0+
        {50, &ACC_SU::IsUserRegistrationRequestPermitted, "IsUserRegistrationRequestPermitted"},
        {51, &ACC_SU::TrySelectUserWithoutInteraction, "TrySelectUserWithoutInteraction"},
-        {60, &ACC_SU::ListOpenContextStoredUsers, "ListOpenContextStoredUsers"}, // 5.0.0 - 5.1.0
+        {60, nullptr, "ListOpenContextStoredUsers"}, // 5.0.0 - 5.1.0
        {99, nullptr, "DebugActivateOpenContextRetention"}, // 6.0.0+
        {100, nullptr, "GetUserRegistrationNotifier"},
        {101, nullptr, "GetUserStateChangeNotifier"},
--- a/src/core/hle/service/acc/acc_u0.cpp
+++ b/src/core/hle/service/acc/acc_u0.cpp
@@ -20,7 +20,7 @@ ACC_U0::ACC_U0(std::shared_ptr<Module> module, std::shared_ptr<ProfileManager> p
        {6, nullptr, "GetProfileDigest"}, // 3.0.0+
        {50, &ACC_U0::IsUserRegistrationRequestPermitted, "IsUserRegistrationRequestPermitted"},
        {51, &ACC_U0::TrySelectUserWithoutInteraction, "TrySelectUserWithoutInteraction"},
-        {60, &ACC_U0::ListOpenContextStoredUsers, "ListOpenContextStoredUsers"}, // 5.0.0 - 5.1.0
+        {60, nullptr, "ListOpenContextStoredUsers"}, // 5.0.0 - 5.1.0
        {99, nullptr, "DebugActivateOpenContextRetention"}, // 6.0.0+
        {100, &ACC_U0::InitializeApplicationInfo, "InitializeApplicationInfo"},
        {101, &ACC_U0::GetBaasAccountManagerForApplication, "GetBaasAccountManagerForApplication"},
@@ -30,7 +30,7 @@ ACC_U0::ACC_U0(std::shared_ptr<Module> module, std::shared_ptr<ProfileManager> p
        {111, nullptr, "ClearSaveDataThumbnail"},
        {120, nullptr, "CreateGuestLoginRequest"},
        {130, nullptr, "LoadOpenContext"}, // 5.0.0+
-        {131, &ACC_U0::ListOpenContextStoredUsers, "ListOpenContextStoredUsers"}, // 6.0.0+
+        {131, nullptr, "ListOpenContextStoredUsers"}, // 6.0.0+
        {140, &ACC_U0::InitializeApplicationInfoRestricted, "InitializeApplicationInfoRestricted"}, // 6.0.0+
        {141, &ACC_U0::ListQualifiedUsers, "ListQualifiedUsers"}, // 6.0.0+
        {150, &ACC_U0::IsUserAccountSwitchLocked, "IsUserAccountSwitchLocked"}, // 6.0.0+
--- a/src/core/hle/service/acc/acc_u1.cpp
+++ b/src/core/hle/service/acc/acc_u1.cpp
@@ -20,7 +20,7 @@ ACC_U1::ACC_U1(std::shared_ptr<Module> module, std::shared_ptr<ProfileManager> p
        {6, nullptr, "GetProfileDigest"}, // 3.0.0+
        {50, &ACC_U1::IsUserRegistrationRequestPermitted, "IsUserRegistrationRequestPermitted"},
        {51, &ACC_U1::TrySelectUserWithoutInteraction, "TrySelectUserWithoutInteraction"},
-        {60, &ACC_U1::ListOpenContextStoredUsers, "ListOpenContextStoredUsers"}, // 5.0.0 - 5.1.0
+        {60, nullptr, "ListOpenContextStoredUsers"}, // 5.0.0 - 5.1.0
        {99, nullptr, "DebugActivateOpenContextRetention"}, // 6.0.0+
        {100, nullptr, "GetUserRegistrationNotifier"},
        {101, nullptr, "GetUserStateChangeNotifier"},
--- a/src/core/hle/service/am/am.cpp
+++ b/src/core/hle/service/am/am.cpp
@@ -10,7 +10,6 @@
 #include "core/core.h"
 #include "core/file_sys/control_metadata.h"
 #include "core/file_sys/patch_manager.h"
-#include "core/file_sys/registered_cache.h"
 #include "core/file_sys/savedata_factory.h"
 #include "core/hle/ipc_helpers.h"
 #include "core/hle/kernel/kernel.h"
@@ -272,7 +271,7 @@ ISelfController::ISelfController(Core::System& system,
        {41, nullptr, "IsSystemBufferSharingEnabled"},
        {42, nullptr, "GetSystemSharedLayerHandle"},
        {43, nullptr, "GetSystemSharedBufferHandle"},
-        {44, &ISelfController::CreateManagedDisplaySeparableLayer, "CreateManagedDisplaySeparableLayer"},
+        {44, nullptr, "CreateManagedDisplaySeparableLayer"},
        {45, nullptr, "SetManagedDisplayLayerSeparationMode"},
        {50, &ISelfController::SetHandlesRequestToDisplay, "SetHandlesRequestToDisplay"},
        {51, nullptr, "ApproveToDisplay"},
@@ -462,24 +461,6 @@ void ISelfController::CreateManagedDisplayLayer(Kernel::HLERequestContext& ctx)
    rb.Push(*layer_id);
 }

-void ISelfController::CreateManagedDisplaySeparableLayer(Kernel::HLERequestContext& ctx) {
-    LOG_WARNING(Service_AM, "(STUBBED) called");
-
-    // TODO(Subv): Find out how AM determines the display to use, for now just
-    // create the layer in the Default display.
-    // This calls nn::vi::CreateRecordingLayer() which creates another layer.
-    // Currently we do not support more than 1 layer per display, output 1 layer id for now.
-    // Outputting 1 layer id instead of the expected 2 has not been observed to cause any adverse
-    // side effects.
-    // TODO: Support multiple layers
-    const auto display_id = nvflinger->OpenDisplay("Default");
-    const auto layer_id = nvflinger->CreateLayer(*display_id);
-
-    IPC::ResponseBuilder rb{ctx, 4};
-    rb.Push(RESULT_SUCCESS);
-    rb.Push(*layer_id);
-}
-
 void ISelfController::SetHandlesRequestToDisplay(Kernel::HLERequestContext& ctx) {
    LOG_WARNING(Service_AM, "(STUBBED) called");

@@ -749,14 +730,14 @@ void ICommonStateGetter::GetDefaultDisplayResolution(Kernel::HLERequestContext&

    if (Settings::values.use_docked_mode) {
        rb.Push(static_cast<u32>(Service::VI::DisplayResolution::DockedWidth) *
-                static_cast<u32>(Settings::values.resolution_factor.GetValue()));
+                static_cast<u32>(Settings::values.resolution_factor));
        rb.Push(static_cast<u32>(Service::VI::DisplayResolution::DockedHeight) *
-                static_cast<u32>(Settings::values.resolution_factor.GetValue()));
+                static_cast<u32>(Settings::values.resolution_factor));
    } else {
        rb.Push(static_cast<u32>(Service::VI::DisplayResolution::UndockedWidth) *
-                static_cast<u32>(Settings::values.resolution_factor.GetValue()));
+                static_cast<u32>(Settings::values.resolution_factor));
        rb.Push(static_cast<u32>(Service::VI::DisplayResolution::UndockedHeight) *
-                static_cast<u32>(Settings::values.resolution_factor.GetValue()));
+                static_cast<u32>(Settings::values.resolution_factor));
    }
 }

@@ -860,7 +841,7 @@ public:
            {110, nullptr, "NeedsToExitProcess"},
            {120, nullptr, "GetLibraryAppletInfo"},
            {150, nullptr, "RequestForAppletToGetForeground"},
-            {160, &ILibraryAppletAccessor::GetIndirectLayerConsumerHandle, "GetIndirectLayerConsumerHandle"},
+            {160, nullptr, "GetIndirectLayerConsumerHandle"},
        };
        // clang-format on

@@ -979,18 +960,6 @@ private:
        rb.PushCopyObjects(applet->GetBroker().GetInteractiveDataEvent());
    }

-    void GetIndirectLayerConsumerHandle(Kernel::HLERequestContext& ctx) {
-        LOG_WARNING(Service_AM, "(STUBBED) called");
-
-        // We require a non-zero handle to be valid. Using 0xdeadbeef allows us to trace if this is
-        // actually used anywhere
-        constexpr u64 handle = 0xdeadbeef;
-
-        IPC::ResponseBuilder rb{ctx, 4};
-        rb.Push(RESULT_SUCCESS);
-        rb.Push(handle);
-    }
-
    std::shared_ptr<Applets::Applet> applet;
 };

@@ -1372,25 +1341,14 @@ void IApplicationFunctions::GetDisplayVersion(Kernel::HLERequestContext& ctx) {

    std::array<u8, 0x10> version_string{};

-    const auto res = [this] {
-        const auto title_id = system.CurrentProcess()->GetTitleID();
-
-        FileSys::PatchManager pm{title_id};
-        auto res = pm.GetControlMetadata();
-        if (res.first != nullptr) {
-            return res;
-        }
-
-        FileSys::PatchManager pm_update{FileSys::GetUpdateTitleID(title_id)};
-        return pm_update.GetControlMetadata();
-    }();
-
+    FileSys::PatchManager pm{system.CurrentProcess()->GetTitleID()};
+    const auto res = pm.GetControlMetadata();
    if (res.first != nullptr) {
        const auto& version = res.first->GetVersionString();
        std::copy(version.begin(), version.end(), version_string.begin());
    } else {
-        constexpr char default_version[]{"1.0.0"};
-        std::memcpy(version_string.data(), default_version, sizeof(default_version));
+        constexpr u128 default_version = {1, 0};
+        std::memcpy(version_string.data(), default_version.data(), sizeof(u128));
    }

    IPC::ResponseBuilder rb{ctx, 6};
@@ -1407,19 +1365,7 @@ void IApplicationFunctions::GetDesiredLanguage(Kernel::HLERequestContext& ctx) {
    u32 supported_languages = 0;
    FileSys::PatchManager pm{system.CurrentProcess()->GetTitleID()};

-    const auto res = [this] {
-        const auto title_id = system.CurrentProcess()->GetTitleID();
-
-        FileSys::PatchManager pm{title_id};
-        auto res = pm.GetControlMetadata();
-        if (res.first != nullptr) {
-            return res;
-        }
-
-        FileSys::PatchManager pm_update{FileSys::GetUpdateTitleID(title_id)};
-        return pm_update.GetControlMetadata();
-    }();
-
+    const auto res = pm.GetControlMetadata();
    if (res.first != nullptr) {
        supported_languages = res.first->GetSupportedLanguages();
    }
--- a/src/core/hle/service/am/am.h
+++ b/src/core/hle/service/am/am.h
@@ -140,7 +140,6 @@ private:
    void SetOutOfFocusSuspendingEnabled(Kernel::HLERequestContext& ctx);
    void SetAlbumImageOrientation(Kernel::HLERequestContext& ctx);
    void CreateManagedDisplayLayer(Kernel::HLERequestContext& ctx);
-    void CreateManagedDisplaySeparableLayer(Kernel::HLERequestContext& ctx);
    void SetHandlesRequestToDisplay(Kernel::HLERequestContext& ctx);
    void SetIdleTimeDetectionExtension(Kernel::HLERequestContext& ctx);
    void GetIdleTimeDetectionExtension(Kernel::HLERequestContext& ctx);
--- a/src/core/hle/service/nim/nim.cpp
+++ b/src/core/hle/service/nim/nim.cpp
@@ -121,83 +121,11 @@ public:
            {39, nullptr, "PrepareShutdown"},
            {40, nullptr, "ListApplyDeltaTask"},
            {41, nullptr, "ClearNotEnoughSpaceStateOfApplyDeltaTask"},
-            {42, nullptr, "Unknown42"},
-            {43, nullptr, "Unknown43"},
-            {44, nullptr, "Unknown44"},
-            {45, nullptr, "Unknown45"},
-            {46, nullptr, "Unknown46"},
-            {47, nullptr, "Unknown47"},
-            {48, nullptr, "Unknown48"},
-            {49, nullptr, "Unknown49"},
-            {50, nullptr, "Unknown50"},
-            {51, nullptr, "Unknown51"},
-            {52, nullptr, "Unknown52"},
-            {53, nullptr, "Unknown53"},
-            {54, nullptr, "Unknown54"},
-            {55, nullptr, "Unknown55"},
-            {56, nullptr, "Unknown56"},
-            {57, nullptr, "Unknown57"},
-            {58, nullptr, "Unknown58"},
-            {59, nullptr, "Unknown59"},
-            {60, nullptr, "Unknown60"},
-            {61, nullptr, "Unknown61"},
-            {62, nullptr, "Unknown62"},
-            {63, nullptr, "Unknown63"},
-            {64, nullptr, "Unknown64"},
-            {65, nullptr, "Unknown65"},
-            {66, nullptr, "Unknown66"},
-            {67, nullptr, "Unknown67"},
-            {68, nullptr, "Unknown68"},
-            {69, nullptr, "Unknown69"},
-            {70, nullptr, "Unknown70"},
-            {71, nullptr, "Unknown71"},
-            {72, nullptr, "Unknown72"},
-            {73, nullptr, "Unknown73"},
-            {74, nullptr, "Unknown74"},
-            {75, nullptr, "Unknown75"},
-            {76, nullptr, "Unknown76"},
-            {77, nullptr, "Unknown77"},
-            {78, nullptr, "Unknown78"},
-            {79, nullptr, "Unknown79"},
-            {80, nullptr, "Unknown80"},
-            {81, nullptr, "Unknown81"},
-            {82, nullptr, "Unknown82"},
-            {83, nullptr, "Unknown83"},
-            {84, nullptr, "Unknown84"},
-            {85, nullptr, "Unknown85"},
-            {86, nullptr, "Unknown86"},
-            {87, nullptr, "Unknown87"},
-            {88, nullptr, "Unknown88"},
-            {89, nullptr, "Unknown89"},
-            {90, nullptr, "Unknown90"},
-            {91, nullptr, "Unknown91"},
-            {92, nullptr, "Unknown92"},
-            {93, nullptr, "Unknown93"},
-            {94, nullptr, "Unknown94"},
-            {95, nullptr, "Unknown95"},
-            {96, nullptr, "Unknown96"},
-            {97, nullptr, "Unknown97"},
-            {98, nullptr, "Unknown98"},
-            {99, nullptr, "Unknown99"},
-            {100, nullptr, "Unknown100"},
-            {101, nullptr, "Unknown101"},
-            {102, nullptr, "Unknown102"},
-            {103, nullptr, "Unknown103"},
-            {104, nullptr, "Unknown104"},
-            {105, nullptr, "Unknown105"},
-            {106, nullptr, "Unknown106"},
-            {107, nullptr, "Unknown107"},
-            {108, nullptr, "Unknown108"},
-            {109, nullptr, "Unknown109"},
-            {110, nullptr, "Unknown110"},
-            {111, nullptr, "Unknown111"},
-            {112, nullptr, "Unknown112"},
-            {113, nullptr, "Unknown113"},
-            {114, nullptr, "Unknown114"},
-            {115, nullptr, "Unknown115"},
-            {116, nullptr, "Unknown116"},
-            {117, nullptr, "Unknown117"},
-            {118, nullptr, "Unknown118"},
+            {42, nullptr, "Unknown1"},
+            {43, nullptr, "Unknown2"},
+            {44, nullptr, "Unknown3"},
+            {45, nullptr, "Unknown4"},
+            {46, nullptr, "Unknown5"},
        };
        // clang-format on

@@ -214,7 +142,6 @@ public:
            {1, nullptr, "RefreshDebugAvailability"},
            {2, nullptr, "ClearDebugResponse"},
            {3, nullptr, "RegisterDebugResponse"},
-            {4, nullptr, "IsLargeResourceAvailable"},
        };
        // clang-format on

@@ -237,8 +164,6 @@ public:
        static const FunctionInfo functions[] = {
            {0, nullptr, "RequestDeviceAuthenticationToken"},
            {1, nullptr, "RequestCachedDeviceAuthenticationToken"},
-            {2, nullptr, "RequestEdgeToken"},
-            {3, nullptr, "RequestCachedEdgeToken"},
            {100, nullptr, "RequestRegisterDeviceAccount"},
            {101, nullptr, "RequestUnregisterDeviceAccount"},
            {102, nullptr, "RequestDeviceAccountStatus"},
@@ -256,8 +181,7 @@ public:
            {305, nullptr, "RequestCreateVirtualAccount"},
            {306, nullptr, "RequestDeviceLinkStatus"},
            {400, nullptr, "GetAccountByVirtualAccount"},
-            {401, nullptr, "GetVirtualAccount"},
-            {500, nullptr, "RequestSyncTicketLegacy"},
+            {500, nullptr, "RequestSyncTicket"},
            {501, nullptr, "RequestDownloadTicket"},
            {502, nullptr, "RequestDownloadTicketForPrepurchasedContents"},
            {503, nullptr, "RequestSyncTicket"},
--- a/src/core/hle/service/npns/npns.cpp
+++ b/src/core/hle/service/npns/npns.cpp
@@ -30,7 +30,6 @@ public:
            {23, nullptr, "DestroyToken"},
            {24, nullptr, "DestroyTokenWithApplicationId"},
            {25, nullptr, "QueryIsTokenValid"},
-            {26, nullptr, "ListenToMyApplicationId"},
            {31, nullptr, "UploadTokenToBaaS"},
            {32, nullptr, "DestroyTokenForBaaS"},
            {33, nullptr, "CreateTokenForBaaS"},
--- a/src/core/hle/service/ns/ns.cpp
+++ b/src/core/hle/service/ns/ns.cpp
@@ -104,7 +104,7 @@ IApplicationManagerInterface::IApplicationManagerInterface()
        {94, nullptr, "LaunchApplication"},
        {95, nullptr, "GetApplicationLaunchInfo"},
        {96, nullptr, "AcquireApplicationLaunchInfo"},
-        {97, nullptr, "GetMainApplicationProgramIndexByApplicationLaunchInfo"},
+        {97, nullptr, "GetMainApplicationProgramIndex2"},
        {98, nullptr, "EnableApplicationAllThreadDumpOnCrash"},
        {99, nullptr, "LaunchDevMenu"},
        {100, nullptr, "ResetToFactorySettings"},
@@ -254,7 +254,7 @@ IApplicationManagerInterface::IApplicationManagerInterface()
        {2170, nullptr, "GetRightsEnvironmentStatus"},
        {2171, nullptr, "GetRightsEnvironmentStatusChangedEvent"},
        {2180, nullptr, "RequestExtendRightsInRightsEnvironment"},
-        {2181, nullptr, "GetResultOfExtendRightsInRightsEnvironment"},
+        {2181, nullptr, "GetLastResultOfExtendRightsInRightsEnvironment"},
        {2182, nullptr, "SetActiveRightsContextUsingStateToRightsEnvironment"},
        {2190, nullptr, "GetRightsEnvironmentHandleForApplication"},
        {2199, nullptr, "GetRightsEnvironmentCountForDebug"},
@@ -366,8 +366,7 @@ ResultVal<u8> IApplicationManagerInterface::GetApplicationDesiredLanguage(
    LOG_DEBUG(Service_NS, "called with supported_languages={:08X}", supported_languages);

    // Get language code from settings
-    const auto language_code =
-        Set::GetLanguageCodeFromIndex(Settings::values.language_index.GetValue());
+    const auto language_code = Set::GetLanguageCodeFromIndex(Settings::values.language_index);

    // Convert to application language, get priority list
    const auto application_language = ConvertToApplicationLanguage(language_code);
@@ -446,8 +445,8 @@ IApplicationVersionInterface::IApplicationVersionInterface()

 IApplicationVersionInterface::~IApplicationVersionInterface() = default;

-IContentManagementInterface::IContentManagementInterface()
-    : ServiceFramework{"IContentManagementInterface"} {
+IContentManagerInterface::IContentManagerInterface()
+    : ServiceFramework{"IContentManagerInterface"} {
    // clang-format off
    static const FunctionInfo functions[] = {
        {11, nullptr, "CalculateApplicationOccupiedSize"},
@@ -464,7 +463,7 @@ IContentManagementInterface::IContentManagementInterface()
    RegisterHandlers(functions);
 }

-IContentManagementInterface::~IContentManagementInterface() = default;
+IContentManagerInterface::~IContentManagerInterface() = default;

 IDocumentInterface::IDocumentInterface() : ServiceFramework{"IDocumentInterface"} {
    // clang-format off
@@ -546,7 +545,7 @@ NS::NS(const char* name) : ServiceFramework{name} {
        {7995, &NS::PushInterface<IAccountProxyInterface>, "GetAccountProxyInterface"},
        {7996, &NS::PushInterface<IApplicationManagerInterface>, "GetApplicationManagerInterface"},
        {7997, &NS::PushInterface<IDownloadTaskInterface>, "GetDownloadTaskInterface"},
-        {7998, &NS::PushInterface<IContentManagementInterface>, "GetContentManagementInterface"},
+        {7998, &NS::PushInterface<IContentManagerInterface>, "GetContentManagementInterface"},
        {7999, &NS::PushInterface<IDocumentInterface>, "GetDocumentInterface"},
    };
    // clang-format on
@@ -573,9 +572,9 @@ public:
            {6, nullptr, "TerminateApplication"},
            {7, nullptr, "PrepareLaunchProgramFromHost"},
            {8, nullptr, "LaunchApplication"},
-            {9, nullptr, "LaunchApplicationWithStorageIdForDevelop"},
-            {10, nullptr, "IsSystemMemoryResourceLimitBoosted"},
-            {11, nullptr, "GetRunningApplicationProcessIdForDevelop"},
+            {9, nullptr, "LaunchApplicationWithStorageId"},
+            {10, nullptr, "TerminateApplication2"},
+            {11, nullptr, "GetRunningApplicationProcessId"},
            {12, nullptr, "SetCurrentApplicationRightsEnvironmentCanBeActive"},
            {13, nullptr, "CreateApplicationResourceForDevelop"},
            {14, nullptr, "IsPreomiaForDevelop"},
@@ -637,10 +636,6 @@ public:
            {9, nullptr, "GetSystemUpdateNotificationEventForContentDelivery"},
            {10, nullptr, "NotifySystemUpdateForContentDelivery"},
            {11, nullptr, "PrepareShutdown"},
-            {12, nullptr, "Unknown12"},
-            {13, nullptr, "Unknown13"},
-            {14, nullptr, "Unknown14"},
-            {15, nullptr, "Unknown15"},
            {16, nullptr, "DestroySystemUpdateTask"},
            {17, nullptr, "RequestSendSystemUpdate"},
            {18, nullptr, "GetSendSystemUpdateProgress"},
--- a/src/core/hle/service/ns/ns.h
+++ b/src/core/hle/service/ns/ns.h
@@ -40,10 +40,10 @@ public:
    ~IApplicationVersionInterface() override;
 };

-class IContentManagementInterface final : public ServiceFramework<IContentManagementInterface> {
+class IContentManagerInterface final : public ServiceFramework<IContentManagerInterface> {
 public:
-    explicit IContentManagementInterface();
-    ~IContentManagementInterface() override;
+    explicit IContentManagerInterface();
+    ~IContentManagerInterface() override;
 };

 class IDocumentInterface final : public ServiceFramework<IDocumentInterface> {
--- a/src/core/hle/service/ns/pl_u.cpp
+++ b/src/core/hle/service/ns/pl_u.cpp
@@ -163,7 +163,7 @@ PL_U::PL_U(Core::System& system)
        {5, &PL_U::GetSharedFontInOrderOfPriority, "GetSharedFontInOrderOfPriority"},
        {6, nullptr, "GetSharedFontInOrderOfPriorityForSystem"},
        {100, nullptr, "RequestApplicationFunctionAuthorization"},
-        {101, nullptr, "RequestApplicationFunctionAuthorizationByProcessId"},
+        {101, nullptr, "RequestApplicationFunctionAuthorizationForSystem"},
        {102, nullptr, "RequestApplicationFunctionAuthorizationByApplicationId"},
        {1000, nullptr, "LoadNgWordDataForPlatformRegionChina"},
        {1001, nullptr, "GetNgWordDataSizeForPlatformRegionChina"},
--- a/src/core/hle/service/nvdrv/interface.cpp
+++ b/src/core/hle/service/nvdrv/interface.cpp
@@ -144,7 +144,7 @@ void NVDRV::QueryEvent(Kernel::HLERequestContext& ctx) {
    }
 }

-void NVDRV::SetAruid(Kernel::HLERequestContext& ctx) {
+void NVDRV::SetClientPID(Kernel::HLERequestContext& ctx) {
    IPC::RequestParser rp{ctx};
    pid = rp.Pop<u64>();
    LOG_WARNING(Service_NVDRV, "(STUBBED) called, pid=0x{:X}", pid);
@@ -154,7 +154,7 @@ void NVDRV::SetAruid(Kernel::HLERequestContext& ctx) {
    rb.Push<u32>(0);
 }

-void NVDRV::SetGraphicsFirmwareMemoryMarginEnabled(Kernel::HLERequestContext& ctx) {
+void NVDRV::FinishInitialize(Kernel::HLERequestContext& ctx) {
    LOG_WARNING(Service_NVDRV, "(STUBBED) called");

    IPC::ResponseBuilder rb{ctx, 2};
@@ -187,14 +187,13 @@ NVDRV::NVDRV(std::shared_ptr<Module> nvdrv, const char* name)
        {4, &NVDRV::QueryEvent, "QueryEvent"},
        {5, nullptr, "MapSharedMem"},
        {6, &NVDRV::GetStatus, "GetStatus"},
-        {7, nullptr, "SetAruidForTest"},
-        {8, &NVDRV::SetAruid, "SetAruid"},
+        {7, nullptr, "ForceSetClientPID"},
+        {8, &NVDRV::SetClientPID, "SetClientPID"},
        {9, &NVDRV::DumpGraphicsMemoryInfo, "DumpGraphicsMemoryInfo"},
        {10, nullptr, "InitializeDevtools"},
        {11, &NVDRV::Ioctl2, "Ioctl2"},
        {12, &NVDRV::Ioctl3, "Ioctl3"},
-        {13, &NVDRV::SetGraphicsFirmwareMemoryMarginEnabled,
-         "SetGraphicsFirmwareMemoryMarginEnabled"},
+        {13, &NVDRV::FinishInitialize, "FinishInitialize"},
    };
    RegisterHandlers(functions);
 }
--- a/src/core/hle/service/nvdrv/interface.h
+++ b/src/core/hle/service/nvdrv/interface.h
@@ -29,8 +29,8 @@ private:
    void Close(Kernel::HLERequestContext& ctx);
    void Initialize(Kernel::HLERequestContext& ctx);
    void QueryEvent(Kernel::HLERequestContext& ctx);
-    void SetAruid(Kernel::HLERequestContext& ctx);
-    void SetGraphicsFirmwareMemoryMarginEnabled(Kernel::HLERequestContext& ctx);
+    void SetClientPID(Kernel::HLERequestContext& ctx);
+    void FinishInitialize(Kernel::HLERequestContext& ctx);
    void GetStatus(Kernel::HLERequestContext& ctx);
    void DumpGraphicsMemoryInfo(Kernel::HLERequestContext& ctx);
    void IoctlBase(Kernel::HLERequestContext& ctx, IoctlVersion version);
--- a/src/core/hle/service/nvdrv/nvmemp.cpp
+++ b/src/core/hle/service/nvdrv/nvmemp.cpp
@@ -10,19 +10,19 @@ namespace Service::Nvidia {

 NVMEMP::NVMEMP() : ServiceFramework("nvmemp") {
    static const FunctionInfo functions[] = {
-        {0, &NVMEMP::Open, "Open"},
-        {1, &NVMEMP::GetAruid, "GetAruid"},
+        {0, &NVMEMP::Cmd0, "Cmd0"},
+        {1, &NVMEMP::Cmd1, "Cmd1"},
    };
    RegisterHandlers(functions);
 }

 NVMEMP::~NVMEMP() = default;

-void NVMEMP::Open(Kernel::HLERequestContext& ctx) {
+void NVMEMP::Cmd0(Kernel::HLERequestContext& ctx) {
    UNIMPLEMENTED();
 }

-void NVMEMP::GetAruid(Kernel::HLERequestContext& ctx) {
+void NVMEMP::Cmd1(Kernel::HLERequestContext& ctx) {
    UNIMPLEMENTED();
 }

--- a/src/core/hle/service/nvdrv/nvmemp.h
+++ b/src/core/hle/service/nvdrv/nvmemp.h
@@ -14,8 +14,8 @@ public:
    ~NVMEMP() override;

 private:
-    void Open(Kernel::HLERequestContext& ctx);
-    void GetAruid(Kernel::HLERequestContext& ctx);
+    void Cmd0(Kernel::HLERequestContext& ctx);
+    void Cmd1(Kernel::HLERequestContext& ctx);
 };

 } // namespace Service::Nvidia
--- a/src/core/hle/service/nvflinger/buffer_queue.cpp
+++ b/src/core/hle/service/nvflinger/buffer_queue.cpp
@@ -115,11 +115,36 @@ std::optional<std::reference_wrapper<const BufferQueue::Buffer>> BufferQueue::Ac
    return *itr;
 }

-void BufferQueue::ReleaseBuffer(u32 slot) {
+std::optional<std::reference_wrapper<const BufferQueue::Buffer>>
+BufferQueue::ObtainPresentBuffer() {
+    auto itr = queue.end();
+    // Iterate to find a queued buffer matching the requested slot.
+    while (itr == queue.end() && !presenting_sequence.empty()) {
+        u32 slot = presenting_sequence.front();
+        itr = std::find_if(queue.begin(), queue.end(), [&slot](const Buffer& buffer) {
+            return buffer.status == Buffer::Status::Presenting && buffer.slot == slot;
+        });
+        presenting_sequence.pop_front();
+    }
+    if (itr == queue.end())
+        return {};
+    return *itr;
+}
+
+void BufferQueue::SetToPresentBuffer(u32 slot) {
    auto itr = std::find_if(queue.begin(), queue.end(),
                            [&](const Buffer& buffer) { return buffer.slot == slot; });
    ASSERT(itr != queue.end());
    ASSERT(itr->status == Buffer::Status::Acquired);
+    itr->status = Buffer::Status::Presenting;
+    presenting_sequence.push_back(slot);
+}
+
+void BufferQueue::ReleaseBuffer(u32 slot) {
+    auto itr = std::find_if(queue.begin(), queue.end(),
+                            [&](const Buffer& buffer) { return buffer.slot == slot; });
+    ASSERT(itr != queue.end());
+    ASSERT(itr->status == Buffer::Status::Presenting || itr->status == Buffer::Status::Acquired);
    itr->status = Buffer::Status::Free;
    free_buffers.push_back(slot);

--- a/src/core/hle/service/nvflinger/buffer_queue.h
+++ b/src/core/hle/service/nvflinger/buffer_queue.h
@@ -77,7 +77,7 @@ public:
    };

    struct Buffer {
-        enum class Status { Free = 0, Queued = 1, Dequeued = 2, Acquired = 3 };
+        enum class Status { Free = 0, Queued = 1, Dequeued = 2, Acquired = 3, Presenting = 4 };

        u32 slot;
        Status status = Status::Free;
@@ -96,6 +96,8 @@ public:
                     const Common::Rectangle<int>& crop_rect, u32 swap_interval,
                     Service::Nvidia::MultiFence& multi_fence);
    std::optional<std::reference_wrapper<const Buffer>> AcquireBuffer();
+    std::optional<std::reference_wrapper<const Buffer>> ObtainPresentBuffer();
+    void SetToPresentBuffer(u32 slot);
    void ReleaseBuffer(u32 slot);
    void Disconnect();
    u32 Query(QueryType type);
@@ -115,6 +117,7 @@ private:
    std::list<u32> free_buffers;
    std::vector<Buffer> queue;
    std::list<u32> queue_sequence;
+    std::list<u32> presenting_sequence;
    Kernel::EventPair buffer_wait_event;
 };

--- a/src/core/hle/service/nvflinger/nvflinger.cpp
+++ b/src/core/hle/service/nvflinger/nvflinger.cpp
@@ -35,6 +35,10 @@ void NVFlinger::VSyncThread(NVFlinger& nv_flinger) {
    nv_flinger.SplitVSync();
 }

+void NVFlinger::WaitForBuffersThread(NVFlinger& nv_flinger) {
+    nv_flinger.WaitForBuffers();
+}
+
 void NVFlinger::SplitVSync() {
    system.RegisterHostThread();
    std::string name = "yuzu:VSyncThread";
@@ -43,14 +47,37 @@ void NVFlinger::SplitVSync() {
    Common::SetCurrentThreadPriority(Common::ThreadPriority::High);
    s64 delay = 0;
    while (is_running) {
-        guard->lock();
        const s64 time_start = system.CoreTiming().GetGlobalTimeNs().count();
-        Compose();
+        for (auto& display : displays) {
+            // Trigger vsync for this display at the end of drawing
+            SCOPE_EXIT({ display.SignalVSyncEvent(); });
+
+            // Don't do anything for displays without layers.
+            if (!display.HasLayers())
+                continue;
+
+            // TODO(Subv): Support more than 1 layer.
+            VI::Layer& layer = display.GetLayer(0);
+            auto& buffer_queue = layer.GetBufferQueue();
+
+            guard->lock();
+            // Search for a queued buffer and acquire it
+            auto buffer = buffer_queue.ObtainPresentBuffer();
+            guard->unlock();
+
+            if (!buffer) {
+                continue;
+            }
+
+            MicroProfileFlip();
+
+            swap_interval = buffer->get().swap_interval;
+            buffer_queue.ReleaseBuffer(buffer->get().slot);
+        }
        const auto ticks = GetNextTicks();
        const s64 time_end = system.CoreTiming().GetGlobalTimeNs().count();
        const s64 time_passed = time_end - time_start;
        const s64 next_time = std::max<s64>(0, ticks - time_passed - delay);
-        guard->unlock();
        if (next_time > 0) {
            wait_event->WaitFor(std::chrono::nanoseconds{next_time});
        }
@@ -58,6 +85,63 @@ void NVFlinger::SplitVSync() {
    }
 }

+void NVFlinger::WaitForBuffers() {
+    system.RegisterHostThread();
+    std::string name = "yuzu:WaitBufferQueueThread";
+    MicroProfileOnThreadCreate(name.c_str());
+    Common::SetCurrentThreadName(name.c_str());
+    Common::SetCurrentThreadPriority(Common::ThreadPriority::High);
+    s64 delay = 0;
+    while (is_running) {
+        for (auto& display : displays) {
+            // Don't do anything for displays without layers.
+            if (!display.HasLayers())
+                continue;
+
+            // TODO(Subv): Support more than 1 layer.
+            VI::Layer& layer = display.GetLayer(0);
+            auto& buffer_queue = layer.GetBufferQueue();
+
+            guard->lock();
+
+            // Search for a queued buffer and acquire it
+            auto buffer = buffer_queue.AcquireBuffer();
+
+            guard->unlock();
+            if (!buffer) {
+
+                continue;
+            }
+
+            const auto& igbp_buffer = buffer->get().igbp_buffer;
+            // Now send the buffer to the GPU for drawing.
+            // TODO(Subv): Support more than just disp0. The display device selection is probably
+            // based on which display we're drawing (Default, Internal, External, etc)
+            auto nvdisp = nvdrv->GetDevice<Nvidia::Devices::nvdisp_disp0>("/dev/nvdisp_disp0");
+            ASSERT(nvdisp);
+
+            nvdisp->flip(igbp_buffer.gpu_buffer_id, igbp_buffer.offset, igbp_buffer.format,
+                         igbp_buffer.width, igbp_buffer.height, igbp_buffer.stride,
+                         buffer->get().transform, buffer->get().crop_rect);
+
+            auto& gpu = system.GPU();
+            const auto& multi_fence = buffer->get().multi_fence;
+
+            for (u32 fence_id = 0; fence_id < multi_fence.num_fences; fence_id++) {
+                const auto& fence = multi_fence.fences[fence_id];
+                gpu.WaitFence(fence.id, fence.value);
+            }
+
+            buffer_queue.SetToPresentBuffer(buffer->get().slot);
+        }
+        queue_event->Wait();
+    }
+}
+
+void NVFlinger::NotifyQueue() {
+    queue_event->Set();
+}
+
 NVFlinger::NVFlinger(Core::System& system) : system(system) {
    displays.emplace_back(0, "Default", system);
    displays.emplace_back(1, "External", system);
@@ -78,7 +162,9 @@ NVFlinger::NVFlinger(Core::System& system) : system(system) {
    if (system.IsMulticore()) {
        is_running = true;
        wait_event = std::make_unique<Common::Event>();
+        queue_event = std::make_unique<Common::Event>();
        vsync_thread = std::make_unique<std::thread>(VSyncThread, std::ref(*this));
+        buffer_thread = std::make_unique<std::thread>(WaitForBuffersThread, std::ref(*this));
    } else {
        system.CoreTiming().ScheduleEvent(frame_ticks, composition_event);
    }
@@ -88,9 +174,13 @@ NVFlinger::~NVFlinger() {
    if (system.IsMulticore()) {
        is_running = false;
        wait_event->Set();
+        queue_event->Set();
        vsync_thread->join();
+        buffer_thread->join();
        vsync_thread.reset();
+        buffer_thread.reset();
        wait_event.reset();
+        queue_event.reset();
    } else {
        system.CoreTiming().UnscheduleEvent(composition_event, 0);
    }
--- a/src/core/hle/service/nvflinger/nvflinger.h
+++ b/src/core/hle/service/nvflinger/nvflinger.h
@@ -80,6 +80,9 @@ public:
    /// Obtains a buffer queue identified by the ID.
    const BufferQueue& FindBufferQueue(u32 id) const;

+    /// On queueing buffer for rendering
+    void NotifyQueue();
+
    /// Performs a composition request to the emulated nvidia GPU and triggers the vsync events when
    /// finished.
    void Compose();
@@ -104,8 +107,10 @@ private:
    const VI::Layer* FindLayer(u64 display_id, u64 layer_id) const;

    static void VSyncThread(NVFlinger& nv_flinger);
+    static void WaitForBuffersThread(NVFlinger& nv_flinger);

    void SplitVSync();
+    void WaitForBuffers();

    std::shared_ptr<Nvidia::Module> nvdrv;

@@ -128,7 +133,9 @@ private:
    Core::System& system;

    std::unique_ptr<std::thread> vsync_thread;
+    std::unique_ptr<std::thread> buffer_thread;
    std::unique_ptr<Common::Event> wait_event;
+    std::unique_ptr<Common::Event> queue_event;
    std::atomic<bool> is_running{};
 };

--- a/src/core/hle/service/pcie/pcie.cpp
+++ b/src/core/hle/service/pcie/pcie.cpp
@@ -36,9 +36,6 @@ public:
            {18, nullptr, "ReleaseIrq"},
            {19, nullptr, "SetIrqEnable"},
            {20, nullptr, "SetAspmEnable"},
-            {21, nullptr, "SetResetUponResumeEnable"},
-            {22, nullptr, "Unknown22"},
-            {23, nullptr, "Unknown23"},
        };
        // clang-format on

--- a/src/core/hle/service/pcv/pcv.cpp
+++ b/src/core/hle/service/pcv/pcv.cpp
@@ -42,9 +42,6 @@ public:
            {24, nullptr, "GetModuleStateTable"},
            {25, nullptr, "GetPowerDomainStateTable"},
            {26, nullptr, "GetFuseInfo"},
-            {27, nullptr, "GetDramId"},
-            {28, nullptr, "IsPoweredOn"},
-            {29, nullptr, "GetVoltage"},
        };
        // clang-format on

--- a/src/core/hle/service/pm/pm.cpp
+++ b/src/core/hle/service/pm/pm.cpp
@@ -78,13 +78,13 @@ public:
        : ServiceFramework{"pm:dmnt"}, kernel(kernel) {
        // clang-format off
        static const FunctionInfo functions[] = {
-            {0, nullptr, "GetJitDebugProcessIdList"},
-            {1, nullptr, "StartProcess"},
-            {2, &DebugMonitor::GetProcessId, "GetProcessId"},
-            {3, nullptr, "HookToCreateProcess"},
-            {4, &DebugMonitor::GetApplicationProcessId, "GetApplicationProcessId"},
-            {5, nullptr, "HookToCreateApplicationProgress"},
-            {6, nullptr, "ClearHook"},
+            {0, nullptr, "GetDebugProcesses"},
+            {1, nullptr, "StartDebugProcess"},
+            {2, &DebugMonitor::GetTitlePid, "GetTitlePid"},
+            {3, nullptr, "EnableDebugForTitleId"},
+            {4, &DebugMonitor::GetApplicationPid, "GetApplicationPid"},
+            {5, nullptr, "EnableDebugForApplication"},
+            {6, nullptr, "DisableDebug"},
        };
        // clang-format on

@@ -92,7 +92,7 @@ public:
    }

 private:
-    void GetProcessId(Kernel::HLERequestContext& ctx) {
+    void GetTitlePid(Kernel::HLERequestContext& ctx) {
        IPC::RequestParser rp{ctx};
        const auto title_id = rp.PopRaw<u64>();

@@ -114,7 +114,7 @@ private:
        rb.Push((*process)->GetProcessID());
    }

-    void GetApplicationProcessId(Kernel::HLERequestContext& ctx) {
+    void GetApplicationPid(Kernel::HLERequestContext& ctx) {
        LOG_DEBUG(Service_PM, "called");
        GetApplicationPidGeneric(ctx, kernel.GetProcessList());
    }
@@ -163,15 +163,15 @@ public:
        : ServiceFramework{"pm:shell"}, kernel(kernel) {
        // clang-format off
        static const FunctionInfo functions[] = {
-            {0, nullptr, "LaunchProgram"},
-            {1, nullptr, "TerminateProcess"},
-            {2, nullptr, "TerminateProgram"},
-            {3, nullptr, "GetProcessEventHandle"},
-            {4, nullptr, "GetProcessEventInfo"},
+            {0, nullptr, "LaunchProcess"},
+            {1, nullptr, "TerminateProcessByPid"},
+            {2, nullptr, "TerminateProcessByTitleId"},
+            {3, nullptr, "GetProcessEventWaiter"},
+            {4, nullptr, "GetProcessEventType"},
            {5, nullptr, "NotifyBootFinished"},
-            {6, &Shell::GetApplicationProcessIdForShell, "GetApplicationProcessIdForShell"},
+            {6, &Shell::GetApplicationPid, "GetApplicationPid"},
            {7, nullptr, "BoostSystemMemoryResourceLimit"},
-            {8, nullptr, "BoostApplicationThreadResourceLimit"},
+            {8, nullptr, "EnableAdditionalSystemThreads"},
            {9, nullptr, "GetBootFinishedEventHandle"},
        };
        // clang-format on
@@ -180,7 +180,7 @@ public:
    }

 private:
-    void GetApplicationProcessIdForShell(Kernel::HLERequestContext& ctx) {
+    void GetApplicationPid(Kernel::HLERequestContext& ctx) {
        LOG_DEBUG(Service_PM, "called");
        GetApplicationPidGeneric(ctx, kernel.GetProcessList());
    }
--- a/src/core/hle/service/prepo/prepo.cpp
+++ b/src/core/hle/service/prepo/prepo.cpp
@@ -42,11 +42,6 @@ public:
            {40101, nullptr, "SetUserAgreementCheckEnabled"},
            {50100, nullptr, "ReadAllApplicationReportFiles"},
            {90100, nullptr, "ReadAllReportFiles"},
-            {90101, nullptr, "Unknown90101"},
-            {90102, nullptr, "Unknown90102"},
-            {90200, nullptr, "GetStatistics"},
-            {90201, nullptr, "GetThroughputHistory"},
-            {90300, nullptr, "GetLastUploadError"},
        };
        // clang-format on

--- a/src/core/hle/service/psc/psc.cpp
+++ b/src/core/hle/service/psc/psc.cpp
@@ -24,8 +24,6 @@ public:
            {4, nullptr, "Cancel"},
            {5, nullptr, "PrintModuleInformation"},
            {6, nullptr, "GetModuleInformation"},
-            {10, nullptr, "Unknown10"},
-            {11, nullptr, "Unknown11"},
        };
        // clang-format on

--- a/src/core/hle/service/ptm/psm.cpp
+++ b/src/core/hle/service/ptm/psm.cpp
@@ -35,7 +35,6 @@ public:
            {15, nullptr, "GetBatteryAgePercentage"},
            {16, nullptr, "GetBatteryChargeInfoEvent"},
            {17, nullptr, "GetBatteryChargeInfoFields"},
-            {18, nullptr, "GetBatteryChargeCalibratedEvent"},
        };
        // clang-format on

--- a/src/core/hle/service/set/set.cpp
+++ b/src/core/hle/service/set/set.cpp
@@ -3,7 +3,6 @@
 // Refer to the license.txt file included.

 #include <algorithm>
-#include <array>
 #include <chrono>
 #include "common/logging/log.h"
 #include "core/hle/ipc_helpers.h"
@@ -32,44 +31,6 @@ constexpr std::array<LanguageCode, 17> available_language_codes = {{
    LanguageCode::ZH_HANT,
 }};

-enum class KeyboardLayout : u64 {
-    Japanese = 0,
-    EnglishUs = 1,
-    EnglishUsInternational = 2,
-    EnglishUk = 3,
-    French = 4,
-    FrenchCa = 5,
-    Spanish = 6,
-    SpanishLatin = 7,
-    German = 8,
-    Italian = 9,
-    Portuguese = 10,
-    Russian = 11,
-    Korean = 12,
-    ChineseSimplified = 13,
-    ChineseTraditional = 14,
-};
-
-constexpr std::array<std::pair<LanguageCode, KeyboardLayout>, 17> language_to_layout{{
-    {LanguageCode::JA, KeyboardLayout::Japanese},
-    {LanguageCode::EN_US, KeyboardLayout::EnglishUs},
-    {LanguageCode::FR, KeyboardLayout::French},
-    {LanguageCode::DE, KeyboardLayout::German},
-    {LanguageCode::IT, KeyboardLayout::Italian},
-    {LanguageCode::ES, KeyboardLayout::Spanish},
-    {LanguageCode::ZH_CN, KeyboardLayout::ChineseSimplified},
-    {LanguageCode::KO, KeyboardLayout::Korean},
-    {LanguageCode::NL, KeyboardLayout::EnglishUsInternational},
-    {LanguageCode::PT, KeyboardLayout::Portuguese},
-    {LanguageCode::RU, KeyboardLayout::Russian},
-    {LanguageCode::ZH_TW, KeyboardLayout::ChineseTraditional},
-    {LanguageCode::EN_GB, KeyboardLayout::EnglishUk},
-    {LanguageCode::FR_CA, KeyboardLayout::FrenchCa},
-    {LanguageCode::ES_419, KeyboardLayout::SpanishLatin},
-    {LanguageCode::ZH_HANS, KeyboardLayout::ChineseSimplified},
-    {LanguageCode::ZH_HANT, KeyboardLayout::ChineseTraditional},
-}};
-
 constexpr std::size_t pre4_0_0_max_entries = 15;
 constexpr std::size_t post4_0_0_max_entries = 17;

@@ -89,25 +50,6 @@ void GetAvailableLanguageCodesImpl(Kernel::HLERequestContext& ctx, std::size_t m
    ctx.WriteBuffer(available_language_codes.data(), copy_size);
    PushResponseLanguageCode(ctx, copy_amount);
 }
-
-void GetKeyCodeMapImpl(Kernel::HLERequestContext& ctx) {
-    const auto language_code = available_language_codes[Settings::values.language_index.GetValue()];
-    const auto key_code =
-        std::find_if(language_to_layout.cbegin(), language_to_layout.cend(),
-                     [=](const auto& element) { return element.first == language_code; });
-    KeyboardLayout layout = KeyboardLayout::EnglishUs;
-    if (key_code == language_to_layout.cend()) {
-        LOG_ERROR(Service_SET,
-                  "Could not find keyboard layout for language index {}, defaulting to English us",
-                  Settings::values.language_index.GetValue());
-    } else {
-        layout = key_code->second;
-    }
-
-    IPC::ResponseBuilder rb{ctx, 2};
-    rb.Push(RESULT_SUCCESS);
-    ctx.WriteBuffer(&layout, sizeof(KeyboardLayout));
-}
 } // Anonymous namespace

 LanguageCode GetLanguageCodeFromIndex(std::size_t index) {
@@ -163,11 +105,11 @@ void SET::GetQuestFlag(Kernel::HLERequestContext& ctx) {
 }

 void SET::GetLanguageCode(Kernel::HLERequestContext& ctx) {
-    LOG_DEBUG(Service_SET, "called {}", Settings::values.language_index.GetValue());
+    LOG_DEBUG(Service_SET, "called {}", Settings::values.language_index);

    IPC::ResponseBuilder rb{ctx, 4};
    rb.Push(RESULT_SUCCESS);
-    rb.PushEnum(available_language_codes[Settings::values.language_index.GetValue()]);
+    rb.PushEnum(available_language_codes[Settings::values.language_index]);
 }

 void SET::GetRegionCode(Kernel::HLERequestContext& ctx) {
@@ -175,17 +117,7 @@ void SET::GetRegionCode(Kernel::HLERequestContext& ctx) {

    IPC::ResponseBuilder rb{ctx, 3};
    rb.Push(RESULT_SUCCESS);
-    rb.Push(Settings::values.region_index.GetValue());
-}
-
-void SET::GetKeyCodeMap(Kernel::HLERequestContext& ctx) {
-    LOG_DEBUG(Service_SET, "Called {}", ctx.Description());
-    GetKeyCodeMapImpl(ctx);
-}
-
-void SET::GetKeyCodeMap2(Kernel::HLERequestContext& ctx) {
-    LOG_DEBUG(Service_SET, "Called {}", ctx.Description());
-    GetKeyCodeMapImpl(ctx);
+    rb.Push(Settings::values.region_index);
 }

 SET::SET() : ServiceFramework("set") {
@@ -198,9 +130,9 @@ SET::SET() : ServiceFramework("set") {
        {4, &SET::GetRegionCode, "GetRegionCode"},
        {5, &SET::GetAvailableLanguageCodes2, "GetAvailableLanguageCodes2"},
        {6, &SET::GetAvailableLanguageCodeCount2, "GetAvailableLanguageCodeCount2"},
-        {7, &SET::GetKeyCodeMap, "GetKeyCodeMap"},
+        {7, nullptr, "GetKeyCodeMap"},
        {8, &SET::GetQuestFlag, "GetQuestFlag"},
-        {9, &SET::GetKeyCodeMap2, "GetKeyCodeMap2"},
+        {9, nullptr, "GetKeyCodeMap2"},
        {10, nullptr, "GetFirmwareVersionForDebug"},
    };
    // clang-format on
--- a/src/core/hle/service/set/set.h
+++ b/src/core/hle/service/set/set.h
@@ -44,8 +44,6 @@ private:
    void GetAvailableLanguageCodeCount2(Kernel::HLERequestContext& ctx);
    void GetQuestFlag(Kernel::HLERequestContext& ctx);
    void GetRegionCode(Kernel::HLERequestContext& ctx);
-    void GetKeyCodeMap(Kernel::HLERequestContext& ctx);
-    void GetKeyCodeMap2(Kernel::HLERequestContext& ctx);
 };

 } // namespace Service::Set
--- a/src/core/hle/service/sm/controller.cpp
+++ b/src/core/hle/service/sm/controller.cpp
@@ -12,7 +12,7 @@

 namespace Service::SM {

-void Controller::ConvertCurrentObjectToDomain(Kernel::HLERequestContext& ctx) {
+void Controller::ConvertSessionToDomain(Kernel::HLERequestContext& ctx) {
    ASSERT_MSG(ctx.Session()->IsSession(), "Session is already a domain");
    LOG_DEBUG(Service, "called, server_session={}", ctx.Session()->GetObjectId());
    ctx.Session()->ConvertToDomain();
@@ -22,7 +22,7 @@ void Controller::ConvertCurrentObjectToDomain(Kernel::HLERequestContext& ctx) {
    rb.Push<u32>(1); // Converted sessions start with 1 request handler
 }

-void Controller::CloneCurrentObject(Kernel::HLERequestContext& ctx) {
+void Controller::DuplicateSession(Kernel::HLERequestContext& ctx) {
    // TODO(bunnei): This is just creating a new handle to the same Session. I assume this is wrong
    // and that we probably want to actually make an entirely new Session, but we still need to
    // verify this on hardware.
@@ -33,10 +33,10 @@ void Controller::CloneCurrentObject(Kernel::HLERequestContext& ctx) {
    rb.PushMoveObjects(ctx.Session()->GetParent()->Client());
 }

-void Controller::CloneCurrentObjectEx(Kernel::HLERequestContext& ctx) {
-    LOG_WARNING(Service, "(STUBBED) called, using CloneCurrentObject");
+void Controller::DuplicateSessionEx(Kernel::HLERequestContext& ctx) {
+    LOG_WARNING(Service, "(STUBBED) called, using DuplicateSession");

-    CloneCurrentObject(ctx);
+    DuplicateSession(ctx);
 }

 void Controller::QueryPointerBufferSize(Kernel::HLERequestContext& ctx) {
@@ -47,14 +47,13 @@ void Controller::QueryPointerBufferSize(Kernel::HLERequestContext& ctx) {
    rb.Push<u16>(0x1000);
 }

-// https://switchbrew.org/wiki/IPC_Marshalling
 Controller::Controller() : ServiceFramework("IpcController") {
    static const FunctionInfo functions[] = {
-        {0, &Controller::ConvertCurrentObjectToDomain, "ConvertCurrentObjectToDomain"},
-        {1, nullptr, "CopyFromCurrentDomain"},
-        {2, &Controller::CloneCurrentObject, "CloneCurrentObject"},
-        {3, &Controller::QueryPointerBufferSize, "QueryPointerBufferSize"},
-        {4, &Controller::CloneCurrentObjectEx, "CloneCurrentObjectEx"},
+        {0x00000000, &Controller::ConvertSessionToDomain, "ConvertSessionToDomain"},
+        {0x00000001, nullptr, "ConvertDomainToSession"},
+        {0x00000002, &Controller::DuplicateSession, "DuplicateSession"},
+        {0x00000003, &Controller::QueryPointerBufferSize, "QueryPointerBufferSize"},
+        {0x00000004, &Controller::DuplicateSessionEx, "DuplicateSessionEx"},
    };
    RegisterHandlers(functions);
 }
--- a/src/core/hle/service/sm/controller.h
+++ b/src/core/hle/service/sm/controller.h
@@ -14,9 +14,9 @@ public:
    ~Controller() override;

 private:
-    void ConvertCurrentObjectToDomain(Kernel::HLERequestContext& ctx);
-    void CloneCurrentObject(Kernel::HLERequestContext& ctx);
-    void CloneCurrentObjectEx(Kernel::HLERequestContext& ctx);
+    void ConvertSessionToDomain(Kernel::HLERequestContext& ctx);
+    void DuplicateSession(Kernel::HLERequestContext& ctx);
+    void DuplicateSessionEx(Kernel::HLERequestContext& ctx);
    void QueryPointerBufferSize(Kernel::HLERequestContext& ctx);
 };

--- a/src/core/hle/service/sockets/nsd.cpp
+++ b/src/core/hle/service/sockets/nsd.cpp
@@ -14,7 +14,6 @@ NSD::NSD(const char* name) : ServiceFramework(name) {
        {12, nullptr, "GetDeviceId"},
        {13, nullptr, "DeleteSettings"},
        {14, nullptr, "ImportSettings"},
-        {15, nullptr, "SetChangeEnvironmentIdentifierDisabled"},
        {20, nullptr, "Resolve"},
        {21, nullptr, "ResolveEx"},
        {30, nullptr, "GetNasServiceSetting"},
@@ -29,11 +28,6 @@ NSD::NSD(const char* name) : ServiceFramework(name) {
        {60, nullptr, "ReadSaveDataFromFsForTest"},
        {61, nullptr, "WriteSaveDataToFsForTest"},
        {62, nullptr, "DeleteSaveDataOfFsForTest"},
-        {63, nullptr, "IsChangeEnvironmentIdentifierDisabled"},
-        {64, nullptr, "SetWithoutDomainExchangeFqdns"},
-        {100, nullptr, "GetApplicationServerEnvironmentType"},
-        {101, nullptr, "SetApplicationServerEnvironmentType"},
-        {102, nullptr, "DeleteApplicationServerEnvironmentType"},
    };
    // clang-format on

--- a/src/core/hle/service/sockets/sfdnsres.cpp
+++ b/src/core/hle/service/sockets/sfdnsres.cpp
@@ -7,7 +7,7 @@

 namespace Service::Sockets {

-void SFDNSRES::GetAddrInfoRequest(Kernel::HLERequestContext& ctx) {
+void SFDNSRES::GetAddrInfo(Kernel::HLERequestContext& ctx) {
    struct Parameters {
        u8 use_nsd_resolve;
        u32 unknown;
@@ -29,20 +29,15 @@ SFDNSRES::SFDNSRES() : ServiceFramework("sfdnsres") {
    static const FunctionInfo functions[] = {
        {0, nullptr, "SetDnsAddressesPrivate"},
        {1, nullptr, "GetDnsAddressPrivate"},
-        {2, nullptr, "GetHostByNameRequest"},
-        {3, nullptr, "GetHostByAddrRequest"},
-        {4, nullptr, "GetHostStringErrorRequest"},
-        {5, nullptr, "GetGaiStringErrorRequest"},
-        {6, &SFDNSRES::GetAddrInfoRequest, "GetAddrInfoRequest"},
-        {7, nullptr, "GetNameInfoRequest"},
-        {8, nullptr, "RequestCancelHandleRequest"},
-        {9, nullptr, "CancelRequest"},
-        {10, nullptr, "GetHostByNameRequestWithOptions"},
-        {11, nullptr, "GetHostByAddrRequestWithOptions"},
-        {12, nullptr, "GetAddrInfoRequestWithOptions"},
-        {13, nullptr, "GetNameInfoRequestWithOptions"},
-        {14, nullptr, "ResolverSetOptionRequest"},
-        {15, nullptr, "ResolverGetOptionRequest"},
+        {2, nullptr, "GetHostByName"},
+        {3, nullptr, "GetHostByAddr"},
+        {4, nullptr, "GetHostStringError"},
+        {5, nullptr, "GetGaiStringError"},
+        {6, &SFDNSRES::GetAddrInfo, "GetAddrInfo"},
+        {7, nullptr, "GetNameInfo"},
+        {8, nullptr, "RequestCancelHandle"},
+        {9, nullptr, "CancelSocketCall"},
+        {11, nullptr, "ClearDnsIpServerAddressArray"},
    };
    RegisterHandlers(functions);
 }
--- a/src/core/hle/service/sockets/sfdnsres.h
+++ b/src/core/hle/service/sockets/sfdnsres.h
@@ -15,7 +15,7 @@ public:
    ~SFDNSRES() override;

 private:
-    void GetAddrInfoRequest(Kernel::HLERequestContext& ctx);
+    void GetAddrInfo(Kernel::HLERequestContext& ctx);
 };

 } // namespace Service::Sockets
--- a/src/core/hle/service/spl/module.cpp
+++ b/src/core/hle/service/spl/module.cpp
@@ -19,7 +19,7 @@ namespace Service::SPL {

 Module::Interface::Interface(std::shared_ptr<Module> module, const char* name)
    : ServiceFramework(name), module(std::move(module)),
-      rng(Settings::values.rng_seed.GetValue().value_or(std::time(nullptr))) {}
+      rng(Settings::values.rng_seed.value_or(std::time(nullptr))) {}

 Module::Interface::~Interface() = default;

--- a/src/core/hle/service/spl/spl.cpp
+++ b/src/core/hle/service/spl/spl.cpp
@@ -9,36 +9,35 @@ namespace Service::SPL {
 SPL::SPL(std::shared_ptr<Module> module) : Module::Interface(std::move(module), "spl:") {
    static const FunctionInfo functions[] = {
        {0, nullptr, "GetConfig"},
-        {1, nullptr, "ModularExponentiate"},
+        {1, nullptr, "UserExpMod"},
        {2, nullptr, "GenerateAesKek"},
        {3, nullptr, "LoadAesKey"},
        {4, nullptr, "GenerateAesKey"},
        {5, nullptr, "SetConfig"},
        {7, &SPL::GetRandomBytes, "GetRandomBytes"},
-        {9, nullptr, "ImportLotusKey"},
-        {10, nullptr, "DecryptLotusMessage"},
+        {9, nullptr, "LoadSecureExpModKey"},
+        {10, nullptr, "SecureExpMod"},
        {11, nullptr, "IsDevelopment"},
        {12, nullptr, "GenerateSpecificAesKey"},
-        {13, nullptr, "DecryptDeviceUniqueData"},
+        {13, nullptr, "DecryptPrivk"},
        {14, nullptr, "DecryptAesKey"},
-        {15, nullptr, "CryptAesCtr"},
+        {15, nullptr, "DecryptAesCtr"},
        {16, nullptr, "ComputeCmac"},
-        {17, nullptr, "ImportEsKey"},
-        {18, nullptr, "UnwrapTitleKey"},
+        {17, nullptr, "LoadRsaOaepKey"},
+        {18, nullptr, "UnwrapRsaOaepWrappedTitleKey"},
        {19, nullptr, "LoadTitleKey"},
-        {20, nullptr, "PrepareEsCommonKey"},
-        {21, nullptr, "AllocateAesKeyslot"},
-        {22, nullptr, "DeallocateAesKeySlot"},
-        {23, nullptr, "GetAesKeyslotAvailableEvent"},
-        {24, nullptr, "SetBootReason"},
-        {25, nullptr, "GetBootReason"},
-        {26, nullptr, "DecryptAndStoreSslClientCertKey"},
-        {27, nullptr, "ModularExponentiateWithSslClientCertKey"},
-        {28, nullptr, "DecryptAndStoreDrmDeviceCertKey"},
-        {29, nullptr, "ModularExponentiateWithDrmDeviceCertKey"},
-        {30, nullptr, "ReencryptDeviceUniqueData "},
-        {31, nullptr, "PrepareEsArchiveKey"}, // This is also GetPackage2Hash?
-        {32, nullptr, "LoadPreparedAesKey"},
+        {20, nullptr, "UnwrapAesWrappedTitleKey"},
+        {21, nullptr, "LockAesEngine"},
+        {22, nullptr, "UnlockAesEngine"},
+        {23, nullptr, "GetSplWaitEvent"},
+        {24, nullptr, "SetSharedData"},
+        {25, nullptr, "GetSharedData"},
+        {26, nullptr, "ImportSslRsaKey"},
+        {27, nullptr, "SecureExpModWithSslKey"},
+        {28, nullptr, "ImportEsRsaKey"},
+        {29, nullptr, "SecureExpModWithEsKey"},
+        {30, nullptr, "EncryptManuRsaKeyForImport"},
+        {31, nullptr, "GetPackage2Hash"},
    };
    RegisterHandlers(functions);
 }
--- a/src/core/hle/service/time/time.cpp
+++ b/src/core/hle/service/time/time.cpp
@@ -90,13 +90,6 @@ public:
        : ServiceFramework("ISteadyClock"), clock_core{clock_core}, system{system} {
        static const FunctionInfo functions[] = {
            {0, &ISteadyClock::GetCurrentTimePoint, "GetCurrentTimePoint"},
-            {2, nullptr, "GetTestOffset"},
-            {3, nullptr, "SetTestOffset"},
-            {100, nullptr, "GetRtcValue"},
-            {101, nullptr, "IsRtcResetDetected"},
-            {102, nullptr, "GetSetupResultValue"},
-            {200, nullptr, "GetInternalOffset"},
-            {201, nullptr, "SetInternalOffset"},
        };
        RegisterHandlers(functions);
    }
--- a/src/core/hle/service/usb/usb.cpp
+++ b/src/core/hle/service/usb/usb.cpp
@@ -20,7 +20,7 @@ public:
        static const FunctionInfo functions[] = {
            {0, nullptr, "GetDsEndpoint"},
            {1, nullptr, "GetSetupEvent"},
-            {2, nullptr, "Unknown2"},
+            {2, nullptr, "Unknown"},
            {3, nullptr, "EnableInterface"},
            {4, nullptr, "DisableInterface"},
            {5, nullptr, "CtrlInPostBufferAsync"},
@@ -55,7 +55,6 @@ public:
            {9, nullptr, "SetBinaryObjectStore"},
            {10, nullptr, "Enable"},
            {11, nullptr, "Disable"},
-            {12, nullptr, "Unknown12"},
        };
        // clang-format on

@@ -70,13 +69,13 @@ public:
        static const FunctionInfo functions[] = {
            {0, nullptr, "Open"},
            {1, nullptr, "Close"},
-            {2, nullptr, "Unknown2"},
+            {2, nullptr, "Unknown1"},
            {3, nullptr, "Populate"},
            {4, nullptr, "PostBufferAsync"},
            {5, nullptr, "GetXferReport"},
            {6, nullptr, "PostBufferMultiAsync"},
-            {7, nullptr, "Unknown7"},
-            {8, nullptr, "Unknown8"},
+            {7, nullptr, "Unknown3"},
+            {8, nullptr, "Unknown4"},
        };
        // clang-format on

@@ -89,13 +88,13 @@ public:
    explicit IClientIfSession() : ServiceFramework{"IClientIfSession"} {
        // clang-format off
        static const FunctionInfo functions[] = {
-            {0, nullptr, "Unknown0"},
+            {0, nullptr, "Unknown1"},
            {1, nullptr, "SetInterface"},
            {2, nullptr, "GetInterface"},
            {3, nullptr, "GetAlternateInterface"},
            {4, nullptr, "GetCurrentFrame"},
            {5, nullptr, "CtrlXferAsync"},
-            {6, nullptr, "Unknown6"},
+            {6, nullptr, "Unknown2"},
            {7, nullptr, "GetCtrlXferReport"},
            {8, nullptr, "ResetDevice"},
            {9, nullptr, "OpenUsbEp"},
@@ -119,7 +118,7 @@ public:
            {5, nullptr, "DestroyInterfaceAvailableEvent"},
            {6, nullptr, "GetInterfaceStateChangeEvent"},
            {7, nullptr, "AcquireUsbIf"},
-            {8, nullptr, "Unknown8"},
+            {8, nullptr, "Unknown1"},
        };
        // clang-format on

@@ -180,8 +179,8 @@ public:
            {4, nullptr, "GetFwRevision"},
            {5, nullptr, "GetManufacturerId"},
            {6, nullptr, "GetDeviceId"},
-            {7, nullptr, "Unknown7"},
-            {8, nullptr, "Unknown8"},
+            {7, nullptr, "Unknown1"},
+            {8, nullptr, "Unknown2"},
        };
        // clang-format on

@@ -216,12 +215,12 @@ public:
    explicit USB_PM() : ServiceFramework{"usb:pm"} {
        // clang-format off
        static const FunctionInfo functions[] = {
-            {0, nullptr, "Unknown0"},
-            {1, nullptr, "Unknown1"},
-            {2, nullptr, "Unknown2"},
-            {3, nullptr, "Unknown3"},
-            {4, nullptr, "Unknown4"},
-            {5, nullptr, "Unknown5"},
+            {0, nullptr, "Unknown1"},
+            {1, nullptr, "Unknown2"},
+            {2, nullptr, "Unknown3"},
+            {3, nullptr, "Unknown4"},
+            {4, nullptr, "Unknown5"},
+            {5, nullptr, "Unknown6"},
        };
        // clang-format on

--- a/src/core/hle/service/vi/vi.cpp
+++ b/src/core/hle/service/vi/vi.cpp
@@ -519,9 +519,9 @@ private:
            IGBPConnectRequestParcel request{ctx.ReadBuffer()};
            IGBPConnectResponseParcel response{
                static_cast<u32>(static_cast<u32>(DisplayResolution::UndockedWidth) *
-                                 Settings::values.resolution_factor.GetValue()),
+                                 Settings::values.resolution_factor),
                static_cast<u32>(static_cast<u32>(DisplayResolution::UndockedHeight) *
-                                 Settings::values.resolution_factor.GetValue())};
+                                 Settings::values.resolution_factor)};
            ctx.WriteBuffer(response.Serialize());
            break;
        }
@@ -580,6 +580,7 @@ private:
            buffer_queue.QueueBuffer(request.data.slot, request.data.transform,
                                     request.data.GetCropRect(), request.data.swap_interval,
                                     request.data.multi_fence);
+            nv_flinger->NotifyQueue();

            IGBPQueueBufferResponseParcel response{1280, 720};
            ctx.WriteBuffer(response.Serialize());
@@ -700,7 +701,6 @@ public:
            {3215, nullptr, "SetDisplayGamma"},
            {3216, nullptr, "GetDisplayCmuLuma"},
            {3217, nullptr, "SetDisplayCmuLuma"},
-            {6013, nullptr, "GetLayerPresentationSubmissionTimestamps"},
            {8225, nullptr, "GetSharedBufferMemoryHandleId"},
            {8250, nullptr, "OpenSharedLayer"},
            {8251, nullptr, "CloseSharedLayer"},
@@ -749,14 +749,14 @@ private:

        if (Settings::values.use_docked_mode) {
            rb.Push(static_cast<u32>(Service::VI::DisplayResolution::DockedWidth) *
-                    static_cast<u32>(Settings::values.resolution_factor.GetValue()));
+                    static_cast<u32>(Settings::values.resolution_factor));
            rb.Push(static_cast<u32>(Service::VI::DisplayResolution::DockedHeight) *
-                    static_cast<u32>(Settings::values.resolution_factor.GetValue()));
+                    static_cast<u32>(Settings::values.resolution_factor));
        } else {
            rb.Push(static_cast<u32>(Service::VI::DisplayResolution::UndockedWidth) *
-                    static_cast<u32>(Settings::values.resolution_factor.GetValue()));
+                    static_cast<u32>(Settings::values.resolution_factor));
            rb.Push(static_cast<u32>(Service::VI::DisplayResolution::UndockedHeight) *
-                    static_cast<u32>(Settings::values.resolution_factor.GetValue()));
+                    static_cast<u32>(Settings::values.resolution_factor));
        }

        rb.PushRaw<float>(60.0f); // This wouldn't seem to be correct for 30 fps games.
@@ -786,7 +786,6 @@ public:
            {2300, nullptr, "AcquireLayerTexturePresentingEvent"},
            {2301, nullptr, "ReleaseLayerTexturePresentingEvent"},
            {2302, nullptr, "GetDisplayHotplugEvent"},
-            {2303, nullptr, "GetDisplayModeChangedEvent"},
            {2402, nullptr, "GetDisplayHotplugState"},
            {2501, nullptr, "GetCompositorErrorInfo"},
            {2601, nullptr, "GetDisplayErrorEvent"},
@@ -1031,9 +1030,9 @@ private:
        // between docked and undocked dimensions. We take the liberty of applying
        // the resolution scaling factor here.
        rb.Push(static_cast<u64>(DisplayResolution::UndockedWidth) *
-                static_cast<u32>(Settings::values.resolution_factor.GetValue()));
+                static_cast<u32>(Settings::values.resolution_factor));
        rb.Push(static_cast<u64>(DisplayResolution::UndockedHeight) *
-                static_cast<u32>(Settings::values.resolution_factor.GetValue()));
+                static_cast<u32>(Settings::values.resolution_factor));
    }

    void SetLayerScalingMode(Kernel::HLERequestContext& ctx) {
@@ -1066,8 +1065,8 @@ private:
        LOG_WARNING(Service_VI, "(STUBBED) called");

        DisplayInfo display_info;
-        display_info.width *= static_cast<u64>(Settings::values.resolution_factor.GetValue());
-        display_info.height *= static_cast<u64>(Settings::values.resolution_factor.GetValue());
+        display_info.width *= static_cast<u64>(Settings::values.resolution_factor);
+        display_info.height *= static_cast<u64>(Settings::values.resolution_factor);
        ctx.WriteBuffer(&display_info, sizeof(DisplayInfo));
        IPC::ResponseBuilder rb{ctx, 4};
        rb.Push(RESULT_SUCCESS);
--- a/src/core/hle/service/vi/vi_u.cpp
+++ b/src/core/hle/service/vi/vi_u.cpp
@@ -12,7 +12,6 @@ VI_U::VI_U(std::shared_ptr<NVFlinger::NVFlinger> nv_flinger)
    : ServiceFramework{"vi:u"}, nv_flinger{std::move(nv_flinger)} {
    static const FunctionInfo functions[] = {
        {0, &VI_U::GetDisplayService, "GetDisplayService"},
-        {1, nullptr, "GetDisplayServiceWithProxyNameExchange"},
    };
    RegisterHandlers(functions);
 }
--- a/src/core/hle/service/wlan/wlan.cpp
+++ b/src/core/hle/service/wlan/wlan.cpp
@@ -15,37 +15,34 @@ public:
    explicit WLANInfra() : ServiceFramework{"wlan:inf"} {
        // clang-format off
        static const FunctionInfo functions[] = {
-            {0, nullptr, "OpenMode"},
-            {1, nullptr, "CloseMode"},
+            {0, nullptr, "Unknown1"},
+            {1, nullptr, "Unknown2"},
            {2, nullptr, "GetMacAddress"},
            {3, nullptr, "StartScan"},
            {4, nullptr, "StopScan"},
            {5, nullptr, "Connect"},
            {6, nullptr, "CancelConnect"},
            {7, nullptr, "Disconnect"},
-            {8, nullptr, "GetConnectionEvent"},
-            {9, nullptr, "GetConnectionStatus"},
+            {8, nullptr, "Unknown3"},
+            {9, nullptr, "Unknown4"},
            {10, nullptr, "GetState"},
            {11, nullptr, "GetScanResult"},
            {12, nullptr, "GetRssi"},
            {13, nullptr, "ChangeRxAntenna"},
-            {14, nullptr, "GetFwVersion"},
-            {15, nullptr, "RequestSleep"},
+            {14, nullptr, "Unknown5"},
+            {15, nullptr, "Unknown6"},
            {16, nullptr, "RequestWakeUp"},
            {17, nullptr, "RequestIfUpDown"},
-            {18, nullptr, "Unknown18"},
-            {19, nullptr, "Unknown19"},
-            {20, nullptr, "Unknown20"},
-            {21, nullptr, "Unknown21"},
-            {22, nullptr, "Unknown22"},
-            {23, nullptr, "Unknown23"},
-            {24, nullptr, "Unknown24"},
-            {25, nullptr, "Unknown25"},
-            {26, nullptr, "Unknown26"},
-            {27, nullptr, "Unknown27"},
-            {28, nullptr, "Unknown28"},
-            {29, nullptr, "Unknown29"},
-            {30, nullptr, "Unknown30"},
+            {18, nullptr, "Unknown7"},
+            {19, nullptr, "Unknown8"},
+            {20, nullptr, "Unknown9"},
+            {21, nullptr, "Unknown10"},
+            {22, nullptr, "Unknown11"},
+            {23, nullptr, "Unknown12"},
+            {24, nullptr, "Unknown13"},
+            {25, nullptr, "Unknown14"},
+            {26, nullptr, "Unknown15"},
+            {27, nullptr, "Unknown16"},
        };
        // clang-format on

@@ -58,12 +55,12 @@ public:
    explicit WLANLocal() : ServiceFramework{"wlan:lcl"} {
        // clang-format off
        static const FunctionInfo functions[] = {
-            {0, nullptr, "Unknown0"},
-            {1, nullptr, "Unknown1"},
-            {2, nullptr, "Unknown2"},
-            {3, nullptr, "Unknown3"},
-            {4, nullptr, "Unknown4"},
-            {5, nullptr, "Unknown5"},
+            {0, nullptr, "Unknown1"},
+            {1, nullptr, "Unknown2"},
+            {2, nullptr, "Unknown3"},
+            {3, nullptr, "Unknown4"},
+            {4, nullptr, "Unknown5"},
+            {5, nullptr, "Unknown6"},
            {6, nullptr, "GetMacAddress"},
            {7, nullptr, "CreateBss"},
            {8, nullptr, "DestroyBss"},
@@ -75,42 +72,38 @@ public:
            {14, nullptr, "CancelJoin"},
            {15, nullptr, "Disconnect"},
            {16, nullptr, "SetBeaconLostCount"},
-            {17, nullptr, "Unknown17"},
-            {18, nullptr, "Unknown18"},
-            {19, nullptr, "Unknown19"},
+            {17, nullptr, "Unknown7"},
+            {18, nullptr, "Unknown8"},
+            {19, nullptr, "Unknown9"},
            {20, nullptr, "GetBssIndicationEvent"},
            {21, nullptr, "GetBssIndicationInfo"},
            {22, nullptr, "GetState"},
            {23, nullptr, "GetAllowedChannels"},
            {24, nullptr, "AddIe"},
            {25, nullptr, "DeleteIe"},
-            {26, nullptr, "Unknown26"},
-            {27, nullptr, "Unknown27"},
+            {26, nullptr, "Unknown10"},
+            {27, nullptr, "Unknown11"},
            {28, nullptr, "CreateRxEntry"},
            {29, nullptr, "DeleteRxEntry"},
-            {30, nullptr, "Unknown30"},
-            {31, nullptr, "Unknown31"},
+            {30, nullptr, "Unknown12"},
+            {31, nullptr, "Unknown13"},
            {32, nullptr, "AddMatchingDataToRxEntry"},
            {33, nullptr, "RemoveMatchingDataFromRxEntry"},
            {34, nullptr, "GetScanResult"},
-            {35, nullptr, "Unknown35"},
+            {35, nullptr, "Unknown14"},
            {36, nullptr, "SetActionFrameWithBeacon"},
            {37, nullptr, "CancelActionFrameWithBeacon"},
            {38, nullptr, "CreateRxEntryForActionFrame"},
            {39, nullptr, "DeleteRxEntryForActionFrame"},
-            {40, nullptr, "Unknown40"},
-            {41, nullptr, "Unknown41"},
+            {40, nullptr, "Unknown15"},
+            {41, nullptr, "Unknown16"},
            {42, nullptr, "CancelGetActionFrame"},
            {43, nullptr, "GetRssi"},
-            {44, nullptr, "Unknown44"},
-            {45, nullptr, "Unknown45"},
-            {46, nullptr, "Unknown46"},
-            {47, nullptr, "Unknown47"},
-            {48, nullptr, "Unknown48"},
-            {49, nullptr, "Unknown49"},
-            {50, nullptr, "Unknown50"},
-            {51, nullptr, "Unknown51"},
-            {52, nullptr, "Unknown52"},
+            {44, nullptr, "Unknown17"},
+            {45, nullptr, "Unknown18"},
+            {46, nullptr, "Unknown19"},
+            {47, nullptr, "Unknown20"},
+            {48, nullptr, "Unknown21"},
        };
        // clang-format on

@@ -149,19 +142,18 @@ public:
    explicit WLANSocketManager() : ServiceFramework{"wlan:soc"} {
        // clang-format off
        static const FunctionInfo functions[] = {
-            {0, nullptr, "Unknown0"},
-            {1, nullptr, "Unknown1"},
-            {2, nullptr, "Unknown2"},
-            {3, nullptr, "Unknown3"},
-            {4, nullptr, "Unknown4"},
-            {5, nullptr, "Unknown5"},
+            {0, nullptr, "Unknown1"},
+            {1, nullptr, "Unknown2"},
+            {2, nullptr, "Unknown3"},
+            {3, nullptr, "Unknown4"},
+            {4, nullptr, "Unknown5"},
+            {5, nullptr, "Unknown6"},
            {6, nullptr, "GetMacAddress"},
            {7, nullptr, "SwitchTsfTimerFunction"},
-            {8, nullptr, "Unknown8"},
-            {9, nullptr, "Unknown9"},
-            {10, nullptr, "Unknown10"},
-            {11, nullptr, "Unknown11"},
-            {12, nullptr, "Unknown12"},
+            {8, nullptr, "Unknown7"},
+            {9, nullptr, "Unknown8"},
+            {10, nullptr, "Unknown9"},
+            {11, nullptr, "Unknown10"},
        };
        // clang-format on

--- a/src/core/memory.cpp
+++ b/src/core/memory.cpp
@@ -548,9 +548,9 @@ struct Memory::Impl {
                        // longer exist, and we should just leave the pagetable entry blank.
                        page_type = Common::PageType::Unmapped;
                    } else {
+                        page_type = Common::PageType::Memory;
                        current_page_table->pointers[vaddr >> PAGE_BITS] =
                            pointer - (vaddr & ~PAGE_MASK);
-                        page_type = Common::PageType::Memory;
                    }
                    break;
                }
@@ -591,12 +591,9 @@ struct Memory::Impl {
                   base + page_table.pointers.size());

        if (!target) {
-            ASSERT_MSG(type != Common::PageType::Memory,
-                       "Mapping memory page without a pointer @ {:016x}", base * PAGE_SIZE);
-
            while (base != end) {
-                page_table.attributes[base] = type;
                page_table.pointers[base] = nullptr;
+                page_table.attributes[base] = type;
                page_table.backing_addr[base] = 0;

                base += 1;
--- a/src/core/perf_stats.cpp
+++ b/src/core/perf_stats.cpp
@@ -119,14 +119,13 @@ double PerfStats::GetLastFrameTimeScale() {
 }

 void FrameLimiter::DoFrameLimiting(microseconds current_system_time_us) {
-    if (!Settings::values.use_frame_limit.GetValue() ||
-        Settings::values.use_multi_core.GetValue()) {
+    if (!Settings::values.use_frame_limit || Settings::values.use_multi_core) {
        return;
    }

    auto now = Clock::now();

-    const double sleep_scale = Settings::values.frame_limit.GetValue() / 100.0;
+    const double sleep_scale = Settings::values.frame_limit / 100.0;

    // Max lag caused by slow frames. Shouldn't be more than the length of a frame at the current
    // speed percent or it will clamp too much and prevent this from properly limiting to that
--- a/src/core/settings.cpp
+++ b/src/core/settings.cpp
@@ -62,7 +62,6 @@ const std::array<const char*, NumMouseButtons> mapping = {{
 }

 Values values = {};
-bool configuring_global = true;

 std::string GetTimeZoneString() {
    static constexpr std::array<const char*, 46> timezones{{
@@ -74,9 +73,9 @@ std::string GetTimeZoneString() {
        "UCT",       "Universal", "UTC", "W-SU",    "WET",     "Zulu",
    }};

-    ASSERT(Settings::values.time_zone_index.GetValue() < timezones.size());
+    ASSERT(Settings::values.time_zone_index < timezones.size());

-    return timezones[Settings::values.time_zone_index.GetValue()];
+    return timezones[Settings::values.time_zone_index];
 }

 void Apply() {
@@ -98,25 +97,25 @@ void LogSetting(const std::string& name, const T& value) {

 void LogSettings() {
    LOG_INFO(Config, "yuzu Configuration:");
-    LogSetting("Controls_UseDockedMode", Settings::values.use_docked_mode);
-    LogSetting("System_RngSeed", Settings::values.rng_seed.GetValue().value_or(0));
+    LogSetting("System_UseDockedMode", Settings::values.use_docked_mode);
+    LogSetting("System_RngSeed", Settings::values.rng_seed.value_or(0));
    LogSetting("System_CurrentUser", Settings::values.current_user);
-    LogSetting("System_LanguageIndex", Settings::values.language_index.GetValue());
-    LogSetting("System_RegionIndex", Settings::values.region_index.GetValue());
-    LogSetting("System_TimeZoneIndex", Settings::values.time_zone_index.GetValue());
-    LogSetting("Core_UseMultiCore", Settings::values.use_multi_core.GetValue());
-    LogSetting("Renderer_UseResolutionFactor", Settings::values.resolution_factor.GetValue());
-    LogSetting("Renderer_UseFrameLimit", Settings::values.use_frame_limit.GetValue());
-    LogSetting("Renderer_FrameLimit", Settings::values.frame_limit.GetValue());
-    LogSetting("Renderer_UseDiskShaderCache", Settings::values.use_disk_shader_cache.GetValue());
-    LogSetting("Renderer_GPUAccuracyLevel", Settings::values.gpu_accuracy.GetValue());
+    LogSetting("System_LanguageIndex", Settings::values.language_index);
+    LogSetting("System_RegionIndex", Settings::values.region_index);
+    LogSetting("System_TimeZoneIndex", Settings::values.time_zone_index);
+    LogSetting("Core_UseMultiCore", Settings::values.use_multi_core);
+    LogSetting("Renderer_UseResolutionFactor", Settings::values.resolution_factor);
+    LogSetting("Renderer_UseFrameLimit", Settings::values.use_frame_limit);
+    LogSetting("Renderer_FrameLimit", Settings::values.frame_limit);
+    LogSetting("Renderer_UseDiskShaderCache", Settings::values.use_disk_shader_cache);
+    LogSetting("Renderer_GPUAccuracyLevel", Settings::values.gpu_accuracy);
    LogSetting("Renderer_UseAsynchronousGpuEmulation",
-               Settings::values.use_asynchronous_gpu_emulation.GetValue());
-    LogSetting("Renderer_UseVsync", Settings::values.use_vsync.GetValue());
-    LogSetting("Renderer_UseAssemblyShaders", Settings::values.use_assembly_shaders.GetValue());
-    LogSetting("Renderer_AnisotropicFilteringLevel", Settings::values.max_anisotropy.GetValue());
+               Settings::values.use_asynchronous_gpu_emulation);
+    LogSetting("Renderer_UseVsync", Settings::values.use_vsync);
+    LogSetting("Renderer_UseAssemblyShaders", Settings::values.use_assembly_shaders);
+    LogSetting("Renderer_AnisotropicFilteringLevel", Settings::values.max_anisotropy);
    LogSetting("Audio_OutputEngine", Settings::values.sink_id);
-    LogSetting("Audio_EnableAudioStretching", Settings::values.enable_audio_stretching.GetValue());
+    LogSetting("Audio_EnableAudioStretching", Settings::values.enable_audio_stretching);
    LogSetting("Audio_OutputDevice", Settings::values.audio_device_id);
    LogSetting("DataStorage_UseVirtualSd", Settings::values.use_virtual_sd);
    LogSetting("DataStorage_NandDir", FileUtil::GetUserPath(FileUtil::UserPath::NANDDir));
@@ -132,56 +131,15 @@ float Volume() {
    if (values.audio_muted) {
        return 0.0f;
    }
-    return values.volume.GetValue();
+    return values.volume;
 }

 bool IsGPULevelExtreme() {
-    return values.gpu_accuracy.GetValue() == GPUAccuracy::Extreme;
+    return values.gpu_accuracy == GPUAccuracy::Extreme;
 }

 bool IsGPULevelHigh() {
-    return values.gpu_accuracy.GetValue() == GPUAccuracy::Extreme ||
-           values.gpu_accuracy.GetValue() == GPUAccuracy::High;
-}
-
-void RestoreGlobalState() {
-    // If a game is running, DO NOT restore the global settings state
-    if (Core::System::GetInstance().IsPoweredOn()) {
-        return;
-    }
-
-    // Audio
-    values.enable_audio_stretching.SetGlobal(true);
-    values.volume.SetGlobal(true);
-
-    // Core
-    values.use_multi_core.SetGlobal(true);
-
-    // Renderer
-    values.renderer_backend.SetGlobal(true);
-    values.vulkan_device.SetGlobal(true);
-    values.aspect_ratio.SetGlobal(true);
-    values.max_anisotropy.SetGlobal(true);
-    values.use_frame_limit.SetGlobal(true);
-    values.frame_limit.SetGlobal(true);
-    values.use_disk_shader_cache.SetGlobal(true);
-    values.gpu_accuracy.SetGlobal(true);
-    values.use_asynchronous_gpu_emulation.SetGlobal(true);
-    values.use_vsync.SetGlobal(true);
-    values.use_assembly_shaders.SetGlobal(true);
-    values.use_fast_gpu_time.SetGlobal(true);
-    values.force_30fps_mode.SetGlobal(true);
-    values.bg_red.SetGlobal(true);
-    values.bg_green.SetGlobal(true);
-    values.bg_blue.SetGlobal(true);
-
-    // System
-    values.language_index.SetGlobal(true);
-    values.region_index.SetGlobal(true);
-    values.time_zone_index.SetGlobal(true);
-    values.rng_seed.SetGlobal(true);
-    values.custom_rtc.SetGlobal(true);
-    values.sound_index.SetGlobal(true);
+    return values.gpu_accuracy == GPUAccuracy::Extreme || values.gpu_accuracy == GPUAccuracy::High;
 }

 } // namespace Settings
--- a/src/core/settings.h
+++ b/src/core/settings.h
@@ -382,85 +382,20 @@ enum class GPUAccuracy : u32 {
    Extreme = 2,
 };

-extern bool configuring_global;
-
-template <typename Type>
-class Setting final {
-public:
-    Setting() = default;
-    explicit Setting(Type val) : global{val} {}
-    ~Setting() = default;
-    void SetGlobal(bool to_global) {
-        use_global = to_global;
-    }
-    bool UsingGlobal() const {
-        return use_global;
-    }
-    Type GetValue(bool need_global = false) const {
-        if (use_global || need_global) {
-            return global;
-        }
-        return local;
-    }
-    void SetValue(const Type& value) {
-        if (use_global) {
-            global = value;
-        } else {
-            local = value;
-        }
-    }
-
-private:
-    bool use_global = true;
-    Type global{};
-    Type local{};
-};
-
 struct Values {
-    // Audio
-    std::string audio_device_id;
-    std::string sink_id;
-    bool audio_muted;
-    Setting<bool> enable_audio_stretching;
-    Setting<float> volume;
-
-    // Core
-    Setting<bool> use_multi_core;
-
-    // Renderer
-    Setting<RendererBackend> renderer_backend;
-    bool renderer_debug;
-    Setting<int> vulkan_device;
-
-    Setting<u16> resolution_factor = Setting(static_cast<u16>(1));
-    Setting<int> aspect_ratio;
-    Setting<int> max_anisotropy;
-    Setting<bool> use_frame_limit;
-    Setting<u16> frame_limit;
-    Setting<bool> use_disk_shader_cache;
-    Setting<GPUAccuracy> gpu_accuracy;
-    Setting<bool> use_asynchronous_gpu_emulation;
-    Setting<bool> use_vsync;
-    Setting<bool> use_assembly_shaders;
-    Setting<bool> force_30fps_mode;
-    Setting<bool> use_fast_gpu_time;
-
-    Setting<float> bg_red;
-    Setting<float> bg_green;
-    Setting<float> bg_blue;
-
    // System
-    Setting<std::optional<u32>> rng_seed;
+    bool use_docked_mode;
+    std::optional<u32> rng_seed;
    // Measured in seconds since epoch
-    Setting<std::optional<std::chrono::seconds>> custom_rtc;
+    std::optional<std::chrono::seconds> custom_rtc;
    // Set on game boot, reset on stop. Seconds difference between current time and `custom_rtc`
    std::chrono::seconds custom_rtc_differential;

    s32 current_user;
-    Setting<s32> language_index;
-    Setting<s32> region_index;
-    Setting<s32> time_zone_index;
-    Setting<s32> sound_index;
+    s32 language_index;
+    s32 region_index;
+    s32 time_zone_index;
+    s32 sound_index;

    // Controls
    std::array<PlayerInput, 10> players;
@@ -484,7 +419,8 @@ struct Values {
    u16 udp_input_port;
    u8 udp_pad_index;

-    bool use_docked_mode;
+    // Core
+    bool use_multi_core;

    // Data Storage
    bool use_virtual_sd;
@@ -496,6 +432,39 @@ struct Values {
    NANDUserSize nand_user_size;
    SDMCSize sdmc_size;

+    // Renderer
+    RendererBackend renderer_backend;
+    bool renderer_debug;
+    int vulkan_device;
+
+    u16 resolution_factor{1};
+    int aspect_ratio;
+    int max_anisotropy;
+    bool use_frame_limit;
+    u16 frame_limit;
+    bool use_disk_shader_cache;
+    GPUAccuracy gpu_accuracy;
+    bool use_asynchronous_gpu_emulation;
+    bool use_vsync;
+    bool use_assembly_shaders;
+    bool force_30fps_mode;
+    bool use_fast_gpu_time;
+
+    float bg_red;
+    float bg_green;
+    float bg_blue;
+
+    std::string log_filter;
+
+    bool use_dev_keys;
+
+    // Audio
+    bool audio_muted;
+    std::string sink_id;
+    bool enable_audio_stretching;
+    std::string audio_device_id;
+    float volume;
+
    // Debugging
    bool record_frame_times;
    bool use_gdbstub;
@@ -508,11 +477,7 @@ struct Values {
    bool disable_cpu_opt;
    bool disable_macro_jit;

-    // Misceallaneous
-    std::string log_filter;
-    bool use_dev_keys;
-
-    // Services
+    // BCAT
    std::string bcat_backend;
    bool bcat_boxcat_local;

@@ -536,7 +501,4 @@ std::string GetTimeZoneString();
 void Apply();
 void LogSettings();

-// Restore the global state of all applicable settings in the Values struct
-void RestoreGlobalState();
-
 } // namespace Settings
--- a/src/core/telemetry_session.cpp
+++ b/src/core/telemetry_session.cpp
@@ -189,24 +189,19 @@ void TelemetrySession::AddInitialInfo(Loader::AppLoader& app_loader) {
    // Log user configuration information
    constexpr auto field_type = Telemetry::FieldType::UserConfig;
    AddField(field_type, "Audio_SinkId", Settings::values.sink_id);
-    AddField(field_type, "Audio_EnableAudioStretching",
-             Settings::values.enable_audio_stretching.GetValue());
-    AddField(field_type, "Core_UseMultiCore", Settings::values.use_multi_core.GetValue());
-    AddField(field_type, "Renderer_Backend",
-             TranslateRenderer(Settings::values.renderer_backend.GetValue()));
-    AddField(field_type, "Renderer_ResolutionFactor",
-             Settings::values.resolution_factor.GetValue());
-    AddField(field_type, "Renderer_UseFrameLimit", Settings::values.use_frame_limit.GetValue());
-    AddField(field_type, "Renderer_FrameLimit", Settings::values.frame_limit.GetValue());
-    AddField(field_type, "Renderer_UseDiskShaderCache",
-             Settings::values.use_disk_shader_cache.GetValue());
+    AddField(field_type, "Audio_EnableAudioStretching", Settings::values.enable_audio_stretching);
+    AddField(field_type, "Core_UseMultiCore", Settings::values.use_multi_core);
+    AddField(field_type, "Renderer_Backend", TranslateRenderer(Settings::values.renderer_backend));
+    AddField(field_type, "Renderer_ResolutionFactor", Settings::values.resolution_factor);
+    AddField(field_type, "Renderer_UseFrameLimit", Settings::values.use_frame_limit);
+    AddField(field_type, "Renderer_FrameLimit", Settings::values.frame_limit);
+    AddField(field_type, "Renderer_UseDiskShaderCache", Settings::values.use_disk_shader_cache);
    AddField(field_type, "Renderer_GPUAccuracyLevel",
-             TranslateGPUAccuracyLevel(Settings::values.gpu_accuracy.GetValue()));
+             TranslateGPUAccuracyLevel(Settings::values.gpu_accuracy));
    AddField(field_type, "Renderer_UseAsynchronousGpuEmulation",
-             Settings::values.use_asynchronous_gpu_emulation.GetValue());
-    AddField(field_type, "Renderer_UseVsync", Settings::values.use_vsync.GetValue());
-    AddField(field_type, "Renderer_UseAssemblyShaders",
-             Settings::values.use_assembly_shaders.GetValue());
+             Settings::values.use_asynchronous_gpu_emulation);
+    AddField(field_type, "Renderer_UseVsync", Settings::values.use_vsync);
+    AddField(field_type, "Renderer_UseAssemblyShaders", Settings::values.use_assembly_shaders);
    AddField(field_type, "System_UseDockedMode", Settings::values.use_docked_mode);
 }

--- a/src/input_common/CMakeLists.txt
+++ b/src/input_common/CMakeLists.txt
@@ -7,10 +7,6 @@ add_library(input_common STATIC
    main.h
    motion_emu.cpp
    motion_emu.h
-    gcadapter/gc_adapter.cpp
-    gcadapter/gc_adapter.h
-    gcadapter/gc_poller.cpp
-    gcadapter/gc_poller.h
    sdl/sdl.cpp
    sdl/sdl.h
    udp/client.cpp
@@ -30,7 +26,5 @@ if(SDL2_FOUND)
    target_compile_definitions(input_common PRIVATE HAVE_SDL2)
 endif()

-target_link_libraries(input_common PUBLIC ${LIBUSB_LIBRARIES})
-
 create_target_directory_groups(input_common)
 target_link_libraries(input_common PUBLIC core PRIVATE common Boost::boost)
--- a/src/input_common/gcadapter/gc_adapter.cpp
+++ b/src/input_common/gcadapter/gc_adapter.cpp
@@ -1,398 +0,0 @@
-// Copyright 2014 Dolphin Emulator Project
-// Licensed under GPLv2+
-// Refer to the license.txt file included.
-
-#include <chrono>
-#include <thread>
-#include "common/logging/log.h"
-#include "input_common/gcadapter/gc_adapter.h"
-
-namespace GCAdapter {
-
-/// Used to loop through and assign button in poller
-constexpr std::array<PadButton, 12> PadButtonArray{
-    PadButton::PAD_BUTTON_LEFT, PadButton::PAD_BUTTON_RIGHT, PadButton::PAD_BUTTON_DOWN,
-    PadButton::PAD_BUTTON_UP,   PadButton::PAD_TRIGGER_Z,    PadButton::PAD_TRIGGER_R,
-    PadButton::PAD_TRIGGER_L,   PadButton::PAD_BUTTON_A,     PadButton::PAD_BUTTON_B,
-    PadButton::PAD_BUTTON_X,    PadButton::PAD_BUTTON_Y,     PadButton::PAD_BUTTON_START,
-};
-
-Adapter::Adapter() {
-    if (usb_adapter_handle != nullptr) {
-        return;
-    }
-    LOG_INFO(Input, "GC Adapter Initialization started");
-
-    current_status = NO_ADAPTER_DETECTED;
-
-    const int init_res = libusb_init(&libusb_ctx);
-    if (init_res == LIBUSB_SUCCESS) {
-        StartScanThread();
-    } else {
-        LOG_ERROR(Input, "libusb could not be initialized. failed with error = {}", init_res);
-    }
-}
-
-GCPadStatus Adapter::GetPadStatus(int port, const std::array<u8, 37>& adapter_payload) {
-    GCPadStatus pad = {};
-    bool get_origin = false;
-
-    ControllerTypes type = ControllerTypes(adapter_payload[1 + (9 * port)] >> 4);
-    if (type != ControllerTypes::None) {
-        get_origin = true;
-    }
-
-    adapter_controllers_status[port] = type;
-
-    static constexpr std::array<PadButton, 8> b1_buttons{
-        PadButton::PAD_BUTTON_A,    PadButton::PAD_BUTTON_B,    PadButton::PAD_BUTTON_X,
-        PadButton::PAD_BUTTON_Y,    PadButton::PAD_BUTTON_LEFT, PadButton::PAD_BUTTON_RIGHT,
-        PadButton::PAD_BUTTON_DOWN, PadButton::PAD_BUTTON_UP,
-    };
-
-    static constexpr std::array<PadButton, 4> b2_buttons{
-        PadButton::PAD_BUTTON_START,
-        PadButton::PAD_TRIGGER_Z,
-        PadButton::PAD_TRIGGER_R,
-        PadButton::PAD_TRIGGER_L,
-    };
-
-    if (adapter_controllers_status[port] != ControllerTypes::None) {
-        const u8 b1 = adapter_payload[1 + (9 * port) + 1];
-        const u8 b2 = adapter_payload[1 + (9 * port) + 2];
-
-        for (std::size_t i = 0; i < b1_buttons.size(); ++i) {
-            if ((b1 & (1U << i)) != 0) {
-                pad.button |= static_cast<u16>(b1_buttons[i]);
-            }
-        }
-
-        for (std::size_t j = 0; j < b2_buttons.size(); ++j) {
-            if ((b2 & (1U << j)) != 0) {
-                pad.button |= static_cast<u16>(b2_buttons[j]);
-            }
-        }
-
-        if (get_origin) {
-            pad.button |= PAD_GET_ORIGIN;
-        }
-
-        pad.stick_x = adapter_payload[1 + (9 * port) + 3];
-        pad.stick_y = adapter_payload[1 + (9 * port) + 4];
-        pad.substick_x = adapter_payload[1 + (9 * port) + 5];
-        pad.substick_y = adapter_payload[1 + (9 * port) + 6];
-        pad.trigger_left = adapter_payload[1 + (9 * port) + 7];
-        pad.trigger_right = adapter_payload[1 + (9 * port) + 8];
-    }
-    return pad;
-}
-
-void Adapter::PadToState(const GCPadStatus& pad, GCState& state) {
-    for (const auto& button : PadButtonArray) {
-        const u16 button_value = static_cast<u16>(button);
-        state.buttons.insert_or_assign(button_value, pad.button & button_value);
-    }
-
-    state.axes.insert_or_assign(static_cast<u8>(PadAxes::StickX), pad.stick_x);
-    state.axes.insert_or_assign(static_cast<u8>(PadAxes::StickY), pad.stick_y);
-    state.axes.insert_or_assign(static_cast<u8>(PadAxes::SubstickX), pad.substick_x);
-    state.axes.insert_or_assign(static_cast<u8>(PadAxes::SubstickY), pad.substick_y);
-    state.axes.insert_or_assign(static_cast<u8>(PadAxes::TriggerLeft), pad.trigger_left);
-    state.axes.insert_or_assign(static_cast<u8>(PadAxes::TriggerRight), pad.trigger_right);
-}
-
-void Adapter::Read() {
-    LOG_DEBUG(Input, "GC Adapter Read() thread started");
-
-    int payload_size_in, payload_size_copy;
-    std::array<u8, 37> adapter_payload;
-    std::array<u8, 37> adapter_payload_copy;
-    std::array<GCPadStatus, 4> pads;
-
-    while (adapter_thread_running) {
-        libusb_interrupt_transfer(usb_adapter_handle, input_endpoint, adapter_payload.data(),
-                                  sizeof(adapter_payload), &payload_size_in, 16);
-        payload_size_copy = 0;
-        // this mutex might be redundant?
-        {
-            std::lock_guard<std::mutex> lk(s_mutex);
-            std::copy(std::begin(adapter_payload), std::end(adapter_payload),
-                      std::begin(adapter_payload_copy));
-            payload_size_copy = payload_size_in;
-        }
-
-        if (payload_size_copy != sizeof(adapter_payload_copy) ||
-            adapter_payload_copy[0] != LIBUSB_DT_HID) {
-            LOG_ERROR(Input, "error reading payload (size: {}, type: {:02x})", payload_size_copy,
-                      adapter_payload_copy[0]);
-            adapter_thread_running = false; // error reading from adapter, stop reading.
-            break;
-        }
-        for (std::size_t port = 0; port < pads.size(); ++port) {
-            pads[port] = GetPadStatus(port, adapter_payload_copy);
-            if (DeviceConnected(port) && configuring) {
-                if (pads[port].button != PAD_GET_ORIGIN) {
-                    pad_queue[port].Push(pads[port]);
-                }
-
-                // Accounting for a threshold here because of some controller variance
-                if (pads[port].stick_x > pads[port].MAIN_STICK_CENTER_X + pads[port].THRESHOLD ||
-                    pads[port].stick_x < pads[port].MAIN_STICK_CENTER_X - pads[port].THRESHOLD) {
-                    pads[port].axis = GCAdapter::PadAxes::StickX;
-                    pads[port].axis_value = pads[port].stick_x;
-                    pad_queue[port].Push(pads[port]);
-                }
-                if (pads[port].stick_y > pads[port].MAIN_STICK_CENTER_Y + pads[port].THRESHOLD ||
-                    pads[port].stick_y < pads[port].MAIN_STICK_CENTER_Y - pads[port].THRESHOLD) {
-                    pads[port].axis = GCAdapter::PadAxes::StickY;
-                    pads[port].axis_value = pads[port].stick_y;
-                    pad_queue[port].Push(pads[port]);
-                }
-                if (pads[port].substick_x > pads[port].C_STICK_CENTER_X + pads[port].THRESHOLD ||
-                    pads[port].substick_x < pads[port].C_STICK_CENTER_X - pads[port].THRESHOLD) {
-                    pads[port].axis = GCAdapter::PadAxes::SubstickX;
-                    pads[port].axis_value = pads[port].substick_x;
-                    pad_queue[port].Push(pads[port]);
-                }
-                if (pads[port].substick_y > pads[port].C_STICK_CENTER_Y + pads[port].THRESHOLD ||
-                    pads[port].substick_y < pads[port].C_STICK_CENTER_Y - pads[port].THRESHOLD) {
-                    pads[port].axis = GCAdapter::PadAxes::SubstickY;
-                    pads[port].axis_value = pads[port].substick_y;
-                    pad_queue[port].Push(pads[port]);
-                }
-                if (pads[port].trigger_left > pads[port].TRIGGER_THRESHOLD) {
-                    pads[port].axis = GCAdapter::PadAxes::TriggerLeft;
-                    pads[port].axis_value = pads[port].trigger_left;
-                    pad_queue[port].Push(pads[port]);
-                }
-                if (pads[port].trigger_right > pads[port].TRIGGER_THRESHOLD) {
-                    pads[port].axis = GCAdapter::PadAxes::TriggerRight;
-                    pads[port].axis_value = pads[port].trigger_right;
-                    pad_queue[port].Push(pads[port]);
-                }
-            }
-            PadToState(pads[port], state[port]);
-        }
-        std::this_thread::yield();
-    }
-}
-
-void Adapter::ScanThreadFunc() {
-    LOG_INFO(Input, "GC Adapter scanning thread started");
-
-    while (detect_thread_running) {
-        if (usb_adapter_handle == nullptr) {
-            std::lock_guard<std::mutex> lk(initialization_mutex);
-            Setup();
-        }
-        std::this_thread::sleep_for(std::chrono::milliseconds(500));
-    }
-}
-
-void Adapter::StartScanThread() {
-    if (detect_thread_running) {
-        return;
-    }
-    if (!libusb_ctx) {
-        return;
-    }
-
-    detect_thread_running = true;
-    detect_thread = std::thread([=] { ScanThreadFunc(); });
-}
-
-void Adapter::StopScanThread() {
-    detect_thread_running = false;
-    detect_thread.join();
-}
-
-void Adapter::Setup() {
-    // Reset the error status in case the adapter gets unplugged
-    if (current_status < 0) {
-        current_status = NO_ADAPTER_DETECTED;
-    }
-
-    adapter_controllers_status.fill(ControllerTypes::None);
-
-    // pointer to list of connected usb devices
-    libusb_device** devices{};
-
-    // populate the list of devices, get the count
-    const ssize_t device_count = libusb_get_device_list(libusb_ctx, &devices);
-    if (device_count < 0) {
-        LOG_ERROR(Input, "libusb_get_device_list failed with error: {}", device_count);
-        detect_thread_running = false; // Stop the loop constantly checking for gc adapter
-        // TODO: For hotplug+gc adapter checkbox implementation, revert this.
-        return;
-    }
-
-    if (devices != nullptr) {
-        for (std::size_t index = 0; index < device_count; ++index) {
-            if (CheckDeviceAccess(devices[index])) {
-                // GC Adapter found and accessible, registering it
-                GetGCEndpoint(devices[index]);
-                break;
-            }
-        }
-        libusb_free_device_list(devices, 1);
-    }
-}
-
-bool Adapter::CheckDeviceAccess(libusb_device* device) {
-    libusb_device_descriptor desc;
-    const int get_descriptor_error = libusb_get_device_descriptor(device, &desc);
-    if (get_descriptor_error) {
-        // could not acquire the descriptor, no point in trying to use it.
-        LOG_ERROR(Input, "libusb_get_device_descriptor failed with error: {}",
-                  get_descriptor_error);
-        return false;
-    }
-
-    if (desc.idVendor != 0x057e || desc.idProduct != 0x0337) {
-        // This isn't the device we are looking for.
-        return false;
-    }
-    const int open_error = libusb_open(device, &usb_adapter_handle);
-
-    if (open_error == LIBUSB_ERROR_ACCESS) {
-        LOG_ERROR(Input, "Yuzu can not gain access to this device: ID {:04X}:{:04X}.",
-                  desc.idVendor, desc.idProduct);
-        return false;
-    }
-    if (open_error) {
-        LOG_ERROR(Input, "libusb_open failed to open device with error = {}", open_error);
-        return false;
-    }
-
-    int kernel_driver_error = libusb_kernel_driver_active(usb_adapter_handle, 0);
-    if (kernel_driver_error == 1) {
-        kernel_driver_error = libusb_detach_kernel_driver(usb_adapter_handle, 0);
-        if (kernel_driver_error != 0 && kernel_driver_error != LIBUSB_ERROR_NOT_SUPPORTED) {
-            LOG_ERROR(Input, "libusb_detach_kernel_driver failed with error = {}",
-                      kernel_driver_error);
-        }
-    }
-
-    if (kernel_driver_error && kernel_driver_error != LIBUSB_ERROR_NOT_SUPPORTED) {
-        libusb_close(usb_adapter_handle);
-        usb_adapter_handle = nullptr;
-        return false;
-    }
-
-    const int interface_claim_error = libusb_claim_interface(usb_adapter_handle, 0);
-    if (interface_claim_error) {
-        LOG_ERROR(Input, "libusb_claim_interface failed with error = {}", interface_claim_error);
-        libusb_close(usb_adapter_handle);
-        usb_adapter_handle = nullptr;
-        return false;
-    }
-
-    return true;
-}
-
-void Adapter::GetGCEndpoint(libusb_device* device) {
-    libusb_config_descriptor* config = nullptr;
-    const int config_descriptor_return = libusb_get_config_descriptor(device, 0, &config);
-    if (config_descriptor_return != LIBUSB_SUCCESS) {
-        LOG_ERROR(Input, "libusb_get_config_descriptor failed with error = {}",
-                  config_descriptor_return);
-        return;
-    }
-
-    for (u8 ic = 0; ic < config->bNumInterfaces; ic++) {
-        const libusb_interface* interfaceContainer = &config->interface[ic];
-        for (int i = 0; i < interfaceContainer->num_altsetting; i++) {
-            const libusb_interface_descriptor* interface = &interfaceContainer->altsetting[i];
-            for (u8 e = 0; e < interface->bNumEndpoints; e++) {
-                const libusb_endpoint_descriptor* endpoint = &interface->endpoint[e];
-                if (endpoint->bEndpointAddress & LIBUSB_ENDPOINT_IN) {
-                    input_endpoint = endpoint->bEndpointAddress;
-                } else {
-                    output_endpoint = endpoint->bEndpointAddress;
-                }
-            }
-        }
-    }
-    // This transfer seems to be responsible for clearing the state of the adapter
-    // Used to clear the "busy" state of when the device is unexpectedly unplugged
-    unsigned char clear_payload = 0x13;
-    libusb_interrupt_transfer(usb_adapter_handle, output_endpoint, &clear_payload,
-                              sizeof(clear_payload), nullptr, 16);
-
-    adapter_thread_running = true;
-    current_status = ADAPTER_DETECTED;
-    adapter_input_thread = std::thread([=] { Read(); }); // Read input
-}
-
-Adapter::~Adapter() {
-    StopScanThread();
-    Reset();
-}
-
-void Adapter::Reset() {
-    std::unique_lock<std::mutex> lock(initialization_mutex, std::defer_lock);
-    if (!lock.try_lock()) {
-        return;
-    }
-    if (current_status != ADAPTER_DETECTED) {
-        return;
-    }
-
-    if (adapter_thread_running) {
-        adapter_thread_running = false;
-    }
-    adapter_input_thread.join();
-
-    adapter_controllers_status.fill(ControllerTypes::None);
-    current_status = NO_ADAPTER_DETECTED;
-
-    if (usb_adapter_handle) {
-        libusb_release_interface(usb_adapter_handle, 1);
-        libusb_close(usb_adapter_handle);
-        usb_adapter_handle = nullptr;
-    }
-
-    if (libusb_ctx) {
-        libusb_exit(libusb_ctx);
-    }
-}
-
-bool Adapter::DeviceConnected(int port) {
-    return adapter_controllers_status[port] != ControllerTypes::None;
-}
-
-void Adapter::ResetDeviceType(int port) {
-    adapter_controllers_status[port] = ControllerTypes::None;
-}
-
-void Adapter::BeginConfiguration() {
-    for (auto& pq : pad_queue) {
-        pq.Clear();
-    }
-    configuring = true;
-}
-
-void Adapter::EndConfiguration() {
-    for (auto& pq : pad_queue) {
-        pq.Clear();
-    }
-    configuring = false;
-}
-
-std::array<Common::SPSCQueue<GCPadStatus>, 4>& Adapter::GetPadQueue() {
-    return pad_queue;
-}
-
-const std::array<Common::SPSCQueue<GCPadStatus>, 4>& Adapter::GetPadQueue() const {
-    return pad_queue;
-}
-
-std::array<GCState, 4>& Adapter::GetPadState() {
-    return state;
-}
-
-const std::array<GCState, 4>& Adapter::GetPadState() const {
-    return state;
-}
-
-} // namespace GCAdapter
--- a/src/input_common/gcadapter/gc_adapter.h
+++ b/src/input_common/gcadapter/gc_adapter.h
@@ -1,161 +0,0 @@
-// Copyright 2014 Dolphin Emulator Project
-// Licensed under GPLv2+
-// Refer to the license.txt file included.
-
-#pragma once
-#include <algorithm>
-#include <functional>
-#include <mutex>
-#include <thread>
-#include <unordered_map>
-#include <libusb.h>
-#include "common/common_types.h"
-#include "common/threadsafe_queue.h"
-
-namespace GCAdapter {
-
-enum {
-    PAD_USE_ORIGIN = 0x0080,
-    PAD_GET_ORIGIN = 0x2000,
-    PAD_ERR_STATUS = 0x8000,
-};
-
-enum class PadButton {
-    PAD_BUTTON_LEFT = 0x0001,
-    PAD_BUTTON_RIGHT = 0x0002,
-    PAD_BUTTON_DOWN = 0x0004,
-    PAD_BUTTON_UP = 0x0008,
-    PAD_TRIGGER_Z = 0x0010,
-    PAD_TRIGGER_R = 0x0020,
-    PAD_TRIGGER_L = 0x0040,
-    PAD_BUTTON_A = 0x0100,
-    PAD_BUTTON_B = 0x0200,
-    PAD_BUTTON_X = 0x0400,
-    PAD_BUTTON_Y = 0x0800,
-    PAD_BUTTON_START = 0x1000,
-    // Below is for compatibility with "AxisButton" type
-    PAD_STICK = 0x2000,
-};
-
-extern const std::array<PadButton, 12> PadButtonArray;
-
-enum class PadAxes : u8 {
-    StickX,
-    StickY,
-    SubstickX,
-    SubstickY,
-    TriggerLeft,
-    TriggerRight,
-    Undefined,
-};
-
-struct GCPadStatus {
-    u16 button{};       // Or-ed PAD_BUTTON_* and PAD_TRIGGER_* bits
-    u8 stick_x{};       // 0 <= stick_x       <= 255
-    u8 stick_y{};       // 0 <= stick_y       <= 255
-    u8 substick_x{};    // 0 <= substick_x    <= 255
-    u8 substick_y{};    // 0 <= substick_y    <= 255
-    u8 trigger_left{};  // 0 <= trigger_left  <= 255
-    u8 trigger_right{}; // 0 <= trigger_right <= 255
-
-    static constexpr u8 MAIN_STICK_CENTER_X = 0x80;
-    static constexpr u8 MAIN_STICK_CENTER_Y = 0x80;
-    static constexpr u8 MAIN_STICK_RADIUS = 0x7f;
-    static constexpr u8 C_STICK_CENTER_X = 0x80;
-    static constexpr u8 C_STICK_CENTER_Y = 0x80;
-    static constexpr u8 C_STICK_RADIUS = 0x7f;
-    static constexpr u8 THRESHOLD = 10;
-
-    // 256/4, at least a quarter press to count as a press. For polling mostly
-    static constexpr u8 TRIGGER_THRESHOLD = 64;
-
-    u8 port{};
-    PadAxes axis{PadAxes::Undefined};
-    u8 axis_value{255};
-};
-
-struct GCState {
-    std::unordered_map<int, bool> buttons;
-    std::unordered_map<int, u16> axes;
-};
-
-enum class ControllerTypes { None, Wired, Wireless };
-
-enum {
-    NO_ADAPTER_DETECTED = 0,
-    ADAPTER_DETECTED = 1,
-};
-
-class Adapter {
-public:
-    /// Initialize the GC Adapter capture and read sequence
-    Adapter();
-
-    /// Close the adapter read thread and release the adapter
-    ~Adapter();
-    /// Used for polling
-    void BeginConfiguration();
-    void EndConfiguration();
-
-    std::array<Common::SPSCQueue<GCPadStatus>, 4>& GetPadQueue();
-    const std::array<Common::SPSCQueue<GCPadStatus>, 4>& GetPadQueue() const;
-
-    std::array<GCState, 4>& GetPadState();
-    const std::array<GCState, 4>& GetPadState() const;
-
-private:
-    GCPadStatus GetPadStatus(int port, const std::array<u8, 37>& adapter_payload);
-
-    void PadToState(const GCPadStatus& pad, GCState& state);
-
-    void Read();
-    void ScanThreadFunc();
-    /// Begin scanning for the GC Adapter.
-    void StartScanThread();
-
-    /// Stop scanning for the adapter
-    void StopScanThread();
-
-    /// Returns true if there is a device connected to port
-    bool DeviceConnected(int port);
-
-    /// Resets status of device connected to port
-    void ResetDeviceType(int port);
-
-    /// Returns true if we successfully gain access to GC Adapter
-    bool CheckDeviceAccess(libusb_device* device);
-
-    /// Captures GC Adapter endpoint address,
-    void GetGCEndpoint(libusb_device* device);
-
-    /// For shutting down, clear all data, join all threads, release usb
-    void Reset();
-
-    /// For use in initialization, querying devices to find the adapter
-    void Setup();
-
-    int current_status = NO_ADAPTER_DETECTED;
-    libusb_device_handle* usb_adapter_handle = nullptr;
-    std::array<ControllerTypes, 4> adapter_controllers_status{};
-
-    std::mutex s_mutex;
-
-    std::thread adapter_input_thread;
-    bool adapter_thread_running;
-
-    std::mutex initialization_mutex;
-    std::thread detect_thread;
-    bool detect_thread_running = false;
-
-    libusb_context* libusb_ctx;
-
-    u8 input_endpoint = 0;
-    u8 output_endpoint = 0;
-
-    bool configuring = false;
-
-    std::array<Common::SPSCQueue<GCPadStatus>, 4> pad_queue;
-    std::array<GCState, 4> state;
-};
-
-} // namespace GCAdapter
--- a/src/input_common/gcadapter/gc_poller.cpp
+++ b/src/input_common/gcadapter/gc_poller.cpp
@@ -1,272 +0,0 @@
-// Copyright 2020 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include <atomic>
-#include <list>
-#include <mutex>
-#include <utility>
-#include "common/threadsafe_queue.h"
-#include "input_common/gcadapter/gc_adapter.h"
-#include "input_common/gcadapter/gc_poller.h"
-
-namespace InputCommon {
-
-class GCButton final : public Input::ButtonDevice {
-public:
-    explicit GCButton(int port_, int button_, GCAdapter::Adapter* adapter)
-        : port(port_), button(button_), gcadapter(adapter) {}
-
-    ~GCButton() override;
-
-    bool GetStatus() const override {
-        return gcadapter->GetPadState()[port].buttons.at(button);
-    }
-
-private:
-    const int port;
-    const int button;
-    GCAdapter::Adapter* gcadapter;
-};
-
-class GCAxisButton final : public Input::ButtonDevice {
-public:
-    explicit GCAxisButton(int port_, int axis_, float threshold_, bool trigger_if_greater_,
-                          GCAdapter::Adapter* adapter)
-        : port(port_), axis(axis_), threshold(threshold_), trigger_if_greater(trigger_if_greater_),
-          gcadapter(adapter) {
-        // L/R triggers range is only in positive direction beginning near 0
-        // 0.0 threshold equates to near half trigger press, but threshold accounts for variability.
-        if (axis > 3) {
-            threshold *= -0.5;
-        }
-    }
-
-    bool GetStatus() const override {
-        const float axis_value = (gcadapter->GetPadState()[port].axes.at(axis) - 128.0f) / 128.0f;
-        if (trigger_if_greater) {
-            // TODO: Might be worthwile to set a slider for the trigger threshold. It is currently
-            // always set to 0.5 in configure_input_player.cpp ZL/ZR HandleClick
-            return axis_value > threshold;
-        }
-        return axis_value < -threshold;
-    }
-
-private:
-    const int port;
-    const int axis;
-    float threshold;
-    bool trigger_if_greater;
-    GCAdapter::Adapter* gcadapter;
-};
-
-GCButtonFactory::GCButtonFactory(std::shared_ptr<GCAdapter::Adapter> adapter_)
-    : adapter(std::move(adapter_)) {}
-
-GCButton::~GCButton() = default;
-
-std::unique_ptr<Input::ButtonDevice> GCButtonFactory::Create(const Common::ParamPackage& params) {
-    const int button_id = params.Get("button", 0);
-    const int port = params.Get("port", 0);
-
-    constexpr int PAD_STICK_ID = static_cast<u16>(GCAdapter::PadButton::PAD_STICK);
-
-    // button is not an axis/stick button
-    if (button_id != PAD_STICK_ID) {
-        auto button = std::make_unique<GCButton>(port, button_id, adapter.get());
-        return std::move(button);
-    }
-
-    // For Axis buttons, used by the binary sticks.
-    if (button_id == PAD_STICK_ID) {
-        const int axis = params.Get("axis", 0);
-        const float threshold = params.Get("threshold", 0.25f);
-        const std::string direction_name = params.Get("direction", "");
-        bool trigger_if_greater;
-        if (direction_name == "+") {
-            trigger_if_greater = true;
-        } else if (direction_name == "-") {
-            trigger_if_greater = false;
-        } else {
-            trigger_if_greater = true;
-            LOG_ERROR(Input, "Unknown direction {}", direction_name);
-        }
-        return std::make_unique<GCAxisButton>(port, axis, threshold, trigger_if_greater,
-                                              adapter.get());
-    }
-}
-
-Common::ParamPackage GCButtonFactory::GetNextInput() {
-    Common::ParamPackage params;
-    GCAdapter::GCPadStatus pad;
-    auto& queue = adapter->GetPadQueue();
-    for (std::size_t port = 0; port < queue.size(); ++port) {
-        while (queue[port].Pop(pad)) {
-            // This while loop will break on the earliest detected button
-            params.Set("engine", "gcpad");
-            params.Set("port", static_cast<int>(port));
-            for (const auto& button : GCAdapter::PadButtonArray) {
-                const u16 button_value = static_cast<u16>(button);
-                if (pad.button & button_value) {
-                    params.Set("button", button_value);
-                    break;
-                }
-            }
-
-            // For Axis button implementation
-            if (pad.axis != GCAdapter::PadAxes::Undefined) {
-                params.Set("axis", static_cast<u8>(pad.axis));
-                params.Set("button", static_cast<u16>(GCAdapter::PadButton::PAD_STICK));
-                if (pad.axis_value > 128) {
-                    params.Set("direction", "+");
-                    params.Set("threshold", "0.25");
-                } else {
-                    params.Set("direction", "-");
-                    params.Set("threshold", "-0.25");
-                }
-                break;
-            }
-        }
-    }
-    return params;
-}
-
-void GCButtonFactory::BeginConfiguration() {
-    polling = true;
-    adapter->BeginConfiguration();
-}
-
-void GCButtonFactory::EndConfiguration() {
-    polling = false;
-    adapter->EndConfiguration();
-}
-
-class GCAnalog final : public Input::AnalogDevice {
-public:
-    GCAnalog(int port_, int axis_x_, int axis_y_, float deadzone_, GCAdapter::Adapter* adapter)
-        : port(port_), axis_x(axis_x_), axis_y(axis_y_), deadzone(deadzone_), gcadapter(adapter) {}
-
-    float GetAxis(int axis) const {
-        std::lock_guard lock{mutex};
-        // division is not by a perfect 128 to account for some variance in center location
-        // e.g. my device idled at 131 in X, 120 in Y, and full range of motion was in range
-        // [20-230]
-        return (gcadapter->GetPadState()[port].axes.at(axis) - 128.0f) / 95.0f;
-    }
-
-    std::pair<float, float> GetAnalog(int axis_x, int axis_y) const {
-        float x = GetAxis(axis_x);
-        float y = GetAxis(axis_y);
-
-        // Make sure the coordinates are in the unit circle,
-        // otherwise normalize it.
-        float r = x * x + y * y;
-        if (r > 1.0f) {
-            r = std::sqrt(r);
-            x /= r;
-            y /= r;
-        }
-
-        return {x, y};
-    }
-
-    std::tuple<float, float> GetStatus() const override {
-        const auto [x, y] = GetAnalog(axis_x, axis_y);
-        const float r = std::sqrt((x * x) + (y * y));
-        if (r > deadzone) {
-            return {x / r * (r - deadzone) / (1 - deadzone),
-                    y / r * (r - deadzone) / (1 - deadzone)};
-        }
-        return {0.0f, 0.0f};
-    }
-
-    bool GetAnalogDirectionStatus(Input::AnalogDirection direction) const override {
-        const auto [x, y] = GetStatus();
-        const float directional_deadzone = 0.4f;
-        switch (direction) {
-        case Input::AnalogDirection::RIGHT:
-            return x > directional_deadzone;
-        case Input::AnalogDirection::LEFT:
-            return x < -directional_deadzone;
-        case Input::AnalogDirection::UP:
-            return y > directional_deadzone;
-        case Input::AnalogDirection::DOWN:
-            return y < -directional_deadzone;
-        }
-        return false;
-    }
-
-private:
-    const int port;
-    const int axis_x;
-    const int axis_y;
-    const float deadzone;
-    mutable std::mutex mutex;
-    GCAdapter::Adapter* gcadapter;
-};
-
-/// An analog device factory that creates analog devices from GC Adapter
-GCAnalogFactory::GCAnalogFactory(std::shared_ptr<GCAdapter::Adapter> adapter_)
-    : adapter(std::move(adapter_)) {}
-
-/**
- * Creates analog device from joystick axes
- * @param params contains parameters for creating the device:
- *     - "port": the nth gcpad on the adapter
- *     - "axis_x": the index of the axis to be bind as x-axis
- *     - "axis_y": the index of the axis to be bind as y-axis
- */
-std::unique_ptr<Input::AnalogDevice> GCAnalogFactory::Create(const Common::ParamPackage& params) {
-    const int port = params.Get("port", 0);
-    const int axis_x = params.Get("axis_x", 0);
-    const int axis_y = params.Get("axis_y", 1);
-    const float deadzone = std::clamp(params.Get("deadzone", 0.0f), 0.0f, .99f);
-
-    return std::make_unique<GCAnalog>(port, axis_x, axis_y, deadzone, adapter.get());
-}
-
-void GCAnalogFactory::BeginConfiguration() {
-    polling = true;
-    adapter->BeginConfiguration();
-}
-
-void GCAnalogFactory::EndConfiguration() {
-    polling = false;
-    adapter->EndConfiguration();
-}
-
-Common::ParamPackage GCAnalogFactory::GetNextInput() {
-    GCAdapter::GCPadStatus pad;
-    auto& queue = adapter->GetPadQueue();
-    for (std::size_t port = 0; port < queue.size(); ++port) {
-        while (queue[port].Pop(pad)) {
-            if (pad.axis == GCAdapter::PadAxes::Undefined ||
-                std::abs((pad.axis_value - 128.0f) / 128.0f) < 0.1) {
-                continue;
-            }
-            // An analog device needs two axes, so we need to store the axis for later and wait for
-            // a second input event. The axes also must be from the same joystick.
-            const u8 axis = static_cast<u8>(pad.axis);
-            if (analog_x_axis == -1) {
-                analog_x_axis = axis;
-                controller_number = port;
-            } else if (analog_y_axis == -1 && analog_x_axis != axis && controller_number == port) {
-                analog_y_axis = axis;
-            }
-        }
-    }
-    Common::ParamPackage params;
-    if (analog_x_axis != -1 && analog_y_axis != -1) {
-        params.Set("engine", "gcpad");
-        params.Set("port", controller_number);
-        params.Set("axis_x", analog_x_axis);
-        params.Set("axis_y", analog_y_axis);
-        analog_x_axis = -1;
-        analog_y_axis = -1;
-        controller_number = -1;
-        return params;
-    }
-    return params;
-}
-
-} // namespace InputCommon
--- a/src/input_common/gcadapter/gc_poller.h
+++ b/src/input_common/gcadapter/gc_poller.h
@@ -1,67 +0,0 @@
-// Copyright 2020 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <memory>
-#include "core/frontend/input.h"
-#include "input_common/gcadapter/gc_adapter.h"
-
-namespace InputCommon {
-
-/**
- * A button device factory representing a gcpad. It receives gcpad events and forward them
- * to all button devices it created.
- */
-class GCButtonFactory final : public Input::Factory<Input::ButtonDevice> {
-public:
-    explicit GCButtonFactory(std::shared_ptr<GCAdapter::Adapter> adapter_);
-
-    /**
-     * Creates a button device from a button press
-     * @param params contains parameters for creating the device:
-     *     - "code": the code of the key to bind with the button
-     */
-    std::unique_ptr<Input::ButtonDevice> Create(const Common::ParamPackage& params) override;
-
-    Common::ParamPackage GetNextInput();
-
-    /// For device input configuration/polling
-    void BeginConfiguration();
-    void EndConfiguration();
-
-    bool IsPolling() const {
-        return polling;
-    }
-
-private:
-    std::shared_ptr<GCAdapter::Adapter> adapter;
-    bool polling = false;
-};
-
-/// An analog device factory that creates analog devices from GC Adapter
-class GCAnalogFactory final : public Input::Factory<Input::AnalogDevice> {
-public:
-    explicit GCAnalogFactory(std::shared_ptr<GCAdapter::Adapter> adapter_);
-
-    std::unique_ptr<Input::AnalogDevice> Create(const Common::ParamPackage& params) override;
-    Common::ParamPackage GetNextInput();
-
-    /// For device input configuration/polling
-    void BeginConfiguration();
-    void EndConfiguration();
-
-    bool IsPolling() const {
-        return polling;
-    }
-
-private:
-    std::shared_ptr<GCAdapter::Adapter> adapter;
-    int analog_x_axis = -1;
-    int analog_y_axis = -1;
-    int controller_number = -1;
-    bool polling = false;
-};
-
-} // namespace InputCommon
--- a/src/input_common/main.cpp
+++ b/src/input_common/main.cpp
@@ -4,11 +4,8 @@

 #include <memory>
 #include <thread>
-#include <libusb.h>
 #include "common/param_package.h"
 #include "input_common/analog_from_button.h"
-#include "input_common/gcadapter/gc_adapter.h"
-#include "input_common/gcadapter/gc_poller.h"
 #include "input_common/keyboard.h"
 #include "input_common/main.h"
 #include "input_common/motion_emu.h"
@@ -25,16 +22,8 @@ static std::shared_ptr<MotionEmu> motion_emu;
 static std::unique_ptr<SDL::State> sdl;
 #endif
 static std::unique_ptr<CemuhookUDP::State> udp;
-static std::shared_ptr<GCButtonFactory> gcbuttons;
-static std::shared_ptr<GCAnalogFactory> gcanalog;

 void Init() {
-    auto gcadapter = std::make_shared<GCAdapter::Adapter>();
-    gcbuttons = std::make_shared<GCButtonFactory>(gcadapter);
-    Input::RegisterFactory<Input::ButtonDevice>("gcpad", gcbuttons);
-    gcanalog = std::make_shared<GCAnalogFactory>(gcadapter);
-    Input::RegisterFactory<Input::AnalogDevice>("gcpad", gcanalog);
-
    keyboard = std::make_shared<Keyboard>();
    Input::RegisterFactory<Input::ButtonDevice>("keyboard", keyboard);
    Input::RegisterFactory<Input::AnalogDevice>("analog_from_button",
@@ -59,11 +48,6 @@ void Shutdown() {
    sdl.reset();
 #endif
    udp.reset();
-    Input::UnregisterFactory<Input::ButtonDevice>("gcpad");
-    Input::UnregisterFactory<Input::AnalogDevice>("gcpad");
-
-    gcbuttons.reset();
-    gcanalog.reset();
 }

 Keyboard* GetKeyboard() {
@@ -74,14 +58,6 @@ MotionEmu* GetMotionEmu() {
    return motion_emu.get();
 }

-GCButtonFactory* GetGCButtons() {
-    return gcbuttons.get();
-}
-
-GCAnalogFactory* GetGCAnalogs() {
-    return gcanalog.get();
-}
-
 std::string GenerateKeyboardParam(int key_code) {
    Common::ParamPackage param{
        {"engine", "keyboard"},
--- a/src/input_common/main.h
+++ b/src/input_common/main.h
@@ -7,7 +7,6 @@
 #include <memory>
 #include <string>
 #include <vector>
-#include "input_common/gcadapter/gc_poller.h"

 namespace Common {
 class ParamPackage;
@@ -31,10 +30,6 @@ class MotionEmu;
 /// Gets the motion emulation factory.
 MotionEmu* GetMotionEmu();

-GCButtonFactory* GetGCButtons();
-
-GCAnalogFactory* GetGCAnalogs();
-
 /// Generates a serialized param package for creating a keyboard button device
 std::string GenerateKeyboardParam(int key_code);

--- a/src/video_core/buffer_cache/buffer_cache.h
+++ b/src/video_core/buffer_cache/buffer_cache.h
@@ -96,8 +96,7 @@ public:
        }
        if (is_written) {
            map->MarkAsModified(true, GetModifiedTicks());
-            if (Settings::IsGPULevelHigh() &&
-                Settings::values.use_asynchronous_gpu_emulation.GetValue()) {
+            if (Settings::IsGPULevelHigh() && Settings::values.use_asynchronous_gpu_emulation) {
                MarkForAsyncFlush(map);
            }
            if (!map->is_written) {
@@ -323,7 +322,8 @@ protected:
    }

 private:
-    MapInterval* MapAddress(Buffer* block, GPUVAddr gpu_addr, VAddr cpu_addr, std::size_t size) {
+    MapInterval* MapAddress(const Buffer* block, GPUVAddr gpu_addr, VAddr cpu_addr,
+                            std::size_t size) {
        const VectorMapInterval overlaps = GetMapsInRange(cpu_addr, size);
        if (overlaps.empty()) {
            auto& memory_manager = system.GPU().MemoryManager();
@@ -370,15 +370,15 @@ private:
        }
        if (modified_inheritance) {
            map->MarkAsModified(true, GetModifiedTicks());
-            if (Settings::IsGPULevelHigh() &&
-                Settings::values.use_asynchronous_gpu_emulation.GetValue()) {
+            if (Settings::IsGPULevelHigh() && Settings::values.use_asynchronous_gpu_emulation) {
                MarkForAsyncFlush(map);
            }
        }
        return map;
    }

-    void UpdateBlock(Buffer* block, VAddr start, VAddr end, const VectorMapInterval& overlaps) {
+    void UpdateBlock(const Buffer* block, VAddr start, VAddr end,
+                     const VectorMapInterval& overlaps) {
        const IntervalType base_interval{start, end};
        IntervalSet interval_set{};
        interval_set.add(base_interval);
--- a/src/video_core/gpu.cpp
+++ b/src/video_core/gpu.cpp
@@ -157,7 +157,7 @@ u64 GPU::GetTicks() const {
    constexpr u64 gpu_ticks_den = 625;

    u64 nanoseconds = system.CoreTiming().GetGlobalTimeNs().count();
-    if (Settings::values.use_fast_gpu_time.GetValue()) {
+    if (Settings::values.use_fast_gpu_time) {
        nanoseconds /= 256;
    }
    const u64 nanoseconds_num = nanoseconds / gpu_ticks_den;
--- a/src/video_core/query_cache.h
+++ b/src/video_core/query_cache.h
@@ -132,7 +132,7 @@ public:
        }

        query->BindCounter(Stream(type).Current(), timestamp);
-        if (Settings::values.use_asynchronous_gpu_emulation.GetValue()) {
+        if (Settings::values.use_asynchronous_gpu_emulation) {
            AsyncFlushQuery(cpu_addr);
        }
    }
--- a/src/video_core/renderer_base.cpp
+++ b/src/video_core/renderer_base.cpp
@@ -18,7 +18,7 @@ RendererBase::~RendererBase() = default;
 void RendererBase::RefreshBaseSettings() {
    UpdateCurrentFramebufferLayout();

-    renderer_settings.use_framelimiter = Settings::values.use_frame_limit.GetValue();
+    renderer_settings.use_framelimiter = Settings::values.use_frame_limit;
    renderer_settings.set_background_color = true;
 }

--- a/src/video_core/renderer_opengl/gl_buffer_cache.cpp
+++ b/src/video_core/renderer_opengl/gl_buffer_cache.cpp
@@ -34,27 +34,20 @@ Buffer::Buffer(const Device& device, VAddr cpu_addr, std::size_t size)

 Buffer::~Buffer() = default;

-void Buffer::Upload(std::size_t offset, std::size_t size, const u8* data) {
+void Buffer::Upload(std::size_t offset, std::size_t size, const u8* data) const {
    glNamedBufferSubData(Handle(), static_cast<GLintptr>(offset), static_cast<GLsizeiptr>(size),
                         data);
 }

-void Buffer::Download(std::size_t offset, std::size_t size, u8* data) {
+void Buffer::Download(std::size_t offset, std::size_t size, u8* data) const {
    MICROPROFILE_SCOPE(OpenGL_Buffer_Download);
-    const GLsizeiptr gl_size = static_cast<GLsizeiptr>(size);
-    const GLintptr gl_offset = static_cast<GLintptr>(offset);
-    if (read_buffer.handle == 0) {
-        read_buffer.Create();
-        glNamedBufferData(read_buffer.handle, static_cast<GLsizeiptr>(Size()), nullptr,
-                          GL_STREAM_READ);
-    }
    glMemoryBarrier(GL_BUFFER_UPDATE_BARRIER_BIT);
-    glCopyNamedBufferSubData(gl_buffer.handle, read_buffer.handle, gl_offset, gl_offset, gl_size);
-    glGetNamedBufferSubData(read_buffer.handle, gl_offset, gl_size, data);
+    glGetNamedBufferSubData(Handle(), static_cast<GLintptr>(offset), static_cast<GLsizeiptr>(size),
+                            data);
 }

 void Buffer::CopyFrom(const Buffer& src, std::size_t src_offset, std::size_t dst_offset,
-                      std::size_t size) {
+                      std::size_t size) const {
    glCopyNamedBufferSubData(src.Handle(), Handle(), static_cast<GLintptr>(src_offset),
                             static_cast<GLintptr>(dst_offset), static_cast<GLsizeiptr>(size));
 }
--- a/src/video_core/renderer_opengl/gl_buffer_cache.h
+++ b/src/video_core/renderer_opengl/gl_buffer_cache.h
@@ -28,12 +28,12 @@ public:
    explicit Buffer(const Device& device, VAddr cpu_addr, std::size_t size);
    ~Buffer();

-    void Upload(std::size_t offset, std::size_t size, const u8* data);
+    void Upload(std::size_t offset, std::size_t size, const u8* data) const;

-    void Download(std::size_t offset, std::size_t size, u8* data);
+    void Download(std::size_t offset, std::size_t size, u8* data) const;

    void CopyFrom(const Buffer& src, std::size_t src_offset, std::size_t dst_offset,
-                  std::size_t size);
+                  std::size_t size) const;

    GLuint Handle() const noexcept {
        return gl_buffer.handle;
@@ -45,7 +45,6 @@ public:

 private:
    OGLBuffer gl_buffer;
-    OGLBuffer read_buffer;
    u64 gpu_address = 0;
 };

--- a/src/video_core/renderer_opengl/gl_device.cpp
+++ b/src/video_core/renderer_opengl/gl_device.cpp
@@ -229,15 +229,15 @@ Device::Device()
    // uniform buffers as "push constants"
    has_fast_buffer_sub_data = is_nvidia && !disable_fast_buffer_sub_data;

-    use_assembly_shaders = Settings::values.use_assembly_shaders.GetValue() &&
-                           GLAD_GL_NV_gpu_program5 && GLAD_GL_NV_compute_program5 &&
-                           GLAD_GL_NV_transform_feedback && GLAD_GL_NV_transform_feedback2;
+    use_assembly_shaders = Settings::values.use_assembly_shaders && GLAD_GL_NV_gpu_program5 &&
+                           GLAD_GL_NV_compute_program5 && GLAD_GL_NV_transform_feedback &&
+                           GLAD_GL_NV_transform_feedback2;

    LOG_INFO(Render_OpenGL, "Renderer_VariableAOFFI: {}", has_variable_aoffi);
    LOG_INFO(Render_OpenGL, "Renderer_ComponentIndexingBug: {}", has_component_indexing_bug);
    LOG_INFO(Render_OpenGL, "Renderer_PreciseBug: {}", has_precise_bug);

-    if (Settings::values.use_assembly_shaders.GetValue() && !use_assembly_shaders) {
+    if (Settings::values.use_assembly_shaders && !use_assembly_shaders) {
        LOG_ERROR(Render_OpenGL, "Assembly shaders enabled but not supported");
    }
 }
--- a/src/video_core/renderer_opengl/gl_shader_disk_cache.cpp
+++ b/src/video_core/renderer_opengl/gl_shader_disk_cache.cpp
@@ -213,7 +213,7 @@ ShaderDiskCacheOpenGL::~ShaderDiskCacheOpenGL() = default;
 std::optional<std::vector<ShaderDiskCacheEntry>> ShaderDiskCacheOpenGL::LoadTransferable() {
    // Skip games without title id
    const bool has_title_id = system.CurrentProcess()->GetTitleID() != 0;
-    if (!Settings::values.use_disk_shader_cache.GetValue() || !has_title_id) {
+    if (!Settings::values.use_disk_shader_cache || !has_title_id) {
        return {};
    }

--- a/src/video_core/renderer_opengl/renderer_opengl.cpp
+++ b/src/video_core/renderer_opengl/renderer_opengl.cpp
@@ -455,8 +455,8 @@ void RendererOpenGL::LoadColorToActiveGLTexture(u8 color_r, u8 color_g, u8 color
 void RendererOpenGL::InitOpenGLObjects() {
    frame_mailbox = std::make_unique<FrameMailbox>();

-    glClearColor(Settings::values.bg_red.GetValue(), Settings::values.bg_green.GetValue(),
-                 Settings::values.bg_blue.GetValue(), 0.0f);
+    glClearColor(Settings::values.bg_red, Settings::values.bg_green, Settings::values.bg_blue,
+                 0.0f);

    // Create shader programs
    OGLShader vertex_shader;
@@ -561,8 +561,8 @@ void RendererOpenGL::ConfigureFramebufferTexture(TextureInfo& texture,
 void RendererOpenGL::DrawScreen(const Layout::FramebufferLayout& layout) {
    if (renderer_settings.set_background_color) {
        // Update background color before drawing
-        glClearColor(Settings::values.bg_red.GetValue(), Settings::values.bg_green.GetValue(),
-                     Settings::values.bg_blue.GetValue(), 0.0f);
+        glClearColor(Settings::values.bg_red, Settings::values.bg_green, Settings::values.bg_blue,
+                     0.0f);
    }

    // Set projection matrix
--- a/src/video_core/renderer_vulkan/fixed_pipeline_state.cpp
+++ b/src/video_core/renderer_vulkan/fixed_pipeline_state.cpp
@@ -39,18 +39,52 @@ constexpr std::array POLYGON_OFFSET_ENABLE_LUT = {

 } // Anonymous namespace

-void FixedPipelineState::Fill(const Maxwell& regs, bool has_extended_dynamic_state) {
+void FixedPipelineState::DepthStencil::Fill(const Maxwell& regs) noexcept {
+    raw = 0;
+    front.action_stencil_fail.Assign(PackStencilOp(regs.stencil_front_op_fail));
+    front.action_depth_fail.Assign(PackStencilOp(regs.stencil_front_op_zfail));
+    front.action_depth_pass.Assign(PackStencilOp(regs.stencil_front_op_zpass));
+    front.test_func.Assign(PackComparisonOp(regs.stencil_front_func_func));
+    if (regs.stencil_two_side_enable) {
+        back.action_stencil_fail.Assign(PackStencilOp(regs.stencil_back_op_fail));
+        back.action_depth_fail.Assign(PackStencilOp(regs.stencil_back_op_zfail));
+        back.action_depth_pass.Assign(PackStencilOp(regs.stencil_back_op_zpass));
+        back.test_func.Assign(PackComparisonOp(regs.stencil_back_func_func));
+    } else {
+        back.action_stencil_fail.Assign(front.action_stencil_fail);
+        back.action_depth_fail.Assign(front.action_depth_fail);
+        back.action_depth_pass.Assign(front.action_depth_pass);
+        back.test_func.Assign(front.test_func);
+    }
+    depth_test_enable.Assign(regs.depth_test_enable);
+    depth_write_enable.Assign(regs.depth_write_enabled);
+    depth_bounds_enable.Assign(regs.depth_bounds_enable);
+    stencil_enable.Assign(regs.stencil_enable);
+    depth_test_func.Assign(PackComparisonOp(regs.depth_test_func));
+}
+
+void FixedPipelineState::Rasterizer::Fill(const Maxwell& regs) noexcept {
    const auto& clip = regs.view_volume_clip_control;
    const std::array enabled_lut = {regs.polygon_offset_point_enable,
                                    regs.polygon_offset_line_enable,
                                    regs.polygon_offset_fill_enable};
    const u32 topology_index = static_cast<u32>(regs.draw.topology.Value());

+    u32 packed_front_face = PackFrontFace(regs.front_face);
+    if (regs.screen_y_control.triangle_rast_flip != 0) {
+        // Flip front face
+        packed_front_face = 1 - packed_front_face;
+    }
+
    raw = 0;
+    topology.Assign(topology_index);
    primitive_restart_enable.Assign(regs.primitive_restart.enabled != 0 ? 1 : 0);
+    cull_enable.Assign(regs.cull_test_enabled != 0 ? 1 : 0);
    depth_bias_enable.Assign(enabled_lut[POLYGON_OFFSET_ENABLE_LUT[topology_index]] != 0 ? 1 : 0);
    depth_clamp_disabled.Assign(regs.view_volume_clip_control.depth_clamp_disabled.Value());
    ndc_minus_one_to_one.Assign(regs.depth_mode == Maxwell::DepthMode::MinusOneToOne ? 1 : 0);
+    cull_face.Assign(PackCullFace(regs.cull_face));
+    front_face.Assign(packed_front_face);
    polygon_mode.Assign(PackPolygonMode(regs.polygon_mode_front));
    patch_control_points_minus_one.Assign(regs.patch_vertices - 1);
    tessellation_primitive.Assign(static_cast<u32>(regs.tess_mode.prim.Value()));
@@ -59,37 +93,19 @@ void FixedPipelineState::Fill(const Maxwell& regs, bool has_extended_dynamic_sta
    logic_op_enable.Assign(regs.logic_op.enable != 0 ? 1 : 0);
    logic_op.Assign(PackLogicOp(regs.logic_op.operation));
    rasterize_enable.Assign(regs.rasterize_enable != 0 ? 1 : 0);
-
    std::memcpy(&point_size, &regs.point_size, sizeof(point_size)); // TODO: C++20 std::bit_cast
+}

-    for (std::size_t index = 0; index < Maxwell::NumVertexArrays; ++index) {
-        binding_divisors[index] =
-            regs.instanced_arrays.IsInstancingEnabled(index) ? regs.vertex_array[index].divisor : 0;
-    }
-
-    for (std::size_t index = 0; index < Maxwell::NumVertexAttributes; ++index) {
-        const auto& input = regs.vertex_attrib_format[index];
-        auto& attribute = attributes[index];
-        attribute.raw = 0;
-        attribute.enabled.Assign(input.IsConstant() ? 0 : 1);
-        attribute.buffer.Assign(input.buffer);
-        attribute.offset.Assign(input.offset);
-        attribute.type.Assign(static_cast<u32>(input.type.Value()));
-        attribute.size.Assign(static_cast<u32>(input.size.Value()));
-    }
-
+void FixedPipelineState::ColorBlending::Fill(const Maxwell& regs) noexcept {
    for (std::size_t index = 0; index < std::size(attachments); ++index) {
        attachments[index].Fill(regs, index);
    }
+}

+void FixedPipelineState::ViewportSwizzles::Fill(const Maxwell& regs) noexcept {
    const auto& transform = regs.viewport_transform;
-    std::transform(transform.begin(), transform.end(), viewport_swizzles.begin(),
+    std::transform(transform.begin(), transform.end(), swizzles.begin(),
                   [](const auto& viewport) { return static_cast<u16>(viewport.swizzle.raw); });
-
-    if (!has_extended_dynamic_state) {
-        no_extended_dynamic_state.Assign(1);
-        dynamic_state.Fill(regs);
-    }
 }

 void FixedPipelineState::BlendingAttachment::Fill(const Maxwell& regs, std::size_t index) {
@@ -131,57 +147,20 @@ void FixedPipelineState::BlendingAttachment::Fill(const Maxwell& regs, std::size
    enable.Assign(1);
 }

-void FixedPipelineState::DynamicState::Fill(const Maxwell& regs) {
-    const u32 topology_index = static_cast<u32>(regs.draw.topology.Value());
-    u32 packed_front_face = PackFrontFace(regs.front_face);
-    if (regs.screen_y_control.triangle_rast_flip != 0) {
-        // Flip front face
-        packed_front_face = 1 - packed_front_face;
-    }
-
-    raw1 = 0;
-    raw2 = 0;
-    front.action_stencil_fail.Assign(PackStencilOp(regs.stencil_front_op_fail));
-    front.action_depth_fail.Assign(PackStencilOp(regs.stencil_front_op_zfail));
-    front.action_depth_pass.Assign(PackStencilOp(regs.stencil_front_op_zpass));
-    front.test_func.Assign(PackComparisonOp(regs.stencil_front_func_func));
-    if (regs.stencil_two_side_enable) {
-        back.action_stencil_fail.Assign(PackStencilOp(regs.stencil_back_op_fail));
-        back.action_depth_fail.Assign(PackStencilOp(regs.stencil_back_op_zfail));
-        back.action_depth_pass.Assign(PackStencilOp(regs.stencil_back_op_zpass));
-        back.test_func.Assign(PackComparisonOp(regs.stencil_back_func_func));
-    } else {
-        back.action_stencil_fail.Assign(front.action_stencil_fail);
-        back.action_depth_fail.Assign(front.action_depth_fail);
-        back.action_depth_pass.Assign(front.action_depth_pass);
-        back.test_func.Assign(front.test_func);
-    }
-    stencil_enable.Assign(regs.stencil_enable);
-    depth_write_enable.Assign(regs.depth_write_enabled);
-    depth_bounds_enable.Assign(regs.depth_bounds_enable);
-    depth_test_enable.Assign(regs.depth_test_enable);
-    front_face.Assign(packed_front_face);
-    depth_test_func.Assign(PackComparisonOp(regs.depth_test_func));
-    topology.Assign(topology_index);
-    cull_face.Assign(PackCullFace(regs.cull_face));
-    cull_enable.Assign(regs.cull_test_enabled != 0 ? 1 : 0);
-
-    for (std::size_t index = 0; index < Maxwell::NumVertexArrays; ++index) {
-        const auto& input = regs.vertex_array[index];
-        VertexBinding& binding = vertex_bindings[index];
-        binding.raw = 0;
-        binding.enabled.Assign(input.IsEnabled() ? 1 : 0);
-        binding.stride.Assign(static_cast<u16>(input.stride.Value()));
-    }
+void FixedPipelineState::Fill(const Maxwell& regs) {
+    rasterizer.Fill(regs);
+    depth_stencil.Fill(regs);
+    color_blending.Fill(regs);
+    viewport_swizzles.Fill(regs);
 }

 std::size_t FixedPipelineState::Hash() const noexcept {
-    const u64 hash = Common::CityHash64(reinterpret_cast<const char*>(this), Size());
+    const u64 hash = Common::CityHash64(reinterpret_cast<const char*>(this), sizeof *this);
    return static_cast<std::size_t>(hash);
 }

 bool FixedPipelineState::operator==(const FixedPipelineState& rhs) const noexcept {
-    return std::memcmp(this, &rhs, Size()) == 0;
+    return std::memcmp(this, &rhs, sizeof *this) == 0;
 }

 u32 FixedPipelineState::PackComparisonOp(Maxwell::ComparisonOp op) noexcept {
--- a/src/video_core/renderer_vulkan/fixed_pipeline_state.h
+++ b/src/video_core/renderer_vulkan/fixed_pipeline_state.h
@@ -60,6 +60,14 @@ struct FixedPipelineState {

        void Fill(const Maxwell& regs, std::size_t index);

+        std::size_t Hash() const noexcept;
+
+        bool operator==(const BlendingAttachment& rhs) const noexcept;
+
+        bool operator!=(const BlendingAttachment& rhs) const noexcept {
+            return !operator==(rhs);
+        }
+
        constexpr std::array<bool, 4> Mask() const noexcept {
            return {mask_r != 0, mask_g != 0, mask_b != 0, mask_a != 0};
        }
@@ -89,77 +97,83 @@ struct FixedPipelineState {
        }
    };

-    union VertexAttribute {
-        u32 raw;
-        BitField<0, 1, u32> enabled;
-        BitField<1, 5, u32> buffer;
-        BitField<6, 14, u32> offset;
-        BitField<20, 3, u32> type;
-        BitField<23, 6, u32> size;
-
-        constexpr Maxwell::VertexAttribute::Type Type() const noexcept {
-            return static_cast<Maxwell::VertexAttribute::Type>(type.Value());
-        }
-
-        constexpr Maxwell::VertexAttribute::Size Size() const noexcept {
-            return static_cast<Maxwell::VertexAttribute::Size>(size.Value());
-        }
-    };
-
-    template <std::size_t Position>
-    union StencilFace {
-        BitField<Position + 0, 3, u32> action_stencil_fail;
-        BitField<Position + 3, 3, u32> action_depth_fail;
-        BitField<Position + 6, 3, u32> action_depth_pass;
-        BitField<Position + 9, 3, u32> test_func;
-
-        Maxwell::StencilOp ActionStencilFail() const noexcept {
-            return UnpackStencilOp(action_stencil_fail);
-        }
-
-        Maxwell::StencilOp ActionDepthFail() const noexcept {
-            return UnpackStencilOp(action_depth_fail);
-        }
-
-        Maxwell::StencilOp ActionDepthPass() const noexcept {
-            return UnpackStencilOp(action_depth_pass);
-        }
-
-        Maxwell::ComparisonOp TestFunc() const noexcept {
-            return UnpackComparisonOp(test_func);
-        }
-    };
-
-    union VertexBinding {
-        u16 raw;
-        BitField<0, 12, u16> stride;
-        BitField<12, 1, u16> enabled;
-    };
-
-    struct DynamicState {
-        union {
-            u32 raw1;
-            StencilFace<0> front;
-            StencilFace<12> back;
-            BitField<24, 1, u32> stencil_enable;
-            BitField<25, 1, u32> depth_write_enable;
-            BitField<26, 1, u32> depth_bounds_enable;
-            BitField<27, 1, u32> depth_test_enable;
-            BitField<28, 1, u32> front_face;
-            BitField<29, 3, u32> depth_test_func;
+    struct VertexInput {
+        union Binding {
+            u16 raw;
+            BitField<0, 1, u16> enabled;
+            BitField<1, 12, u16> stride;
        };
+
+        union Attribute {
+            u32 raw;
+            BitField<0, 1, u32> enabled;
+            BitField<1, 5, u32> buffer;
+            BitField<6, 14, u32> offset;
+            BitField<20, 3, u32> type;
+            BitField<23, 6, u32> size;
+
+            constexpr Maxwell::VertexAttribute::Type Type() const noexcept {
+                return static_cast<Maxwell::VertexAttribute::Type>(type.Value());
+            }
+
+            constexpr Maxwell::VertexAttribute::Size Size() const noexcept {
+                return static_cast<Maxwell::VertexAttribute::Size>(size.Value());
+            }
+        };
+
+        std::array<Binding, Maxwell::NumVertexArrays> bindings;
+        std::array<u32, Maxwell::NumVertexArrays> binding_divisors;
+        std::array<Attribute, Maxwell::NumVertexAttributes> attributes;
+
+        void SetBinding(std::size_t index, bool enabled, u32 stride, u32 divisor) noexcept {
+            auto& binding = bindings[index];
+            binding.raw = 0;
+            binding.enabled.Assign(enabled ? 1 : 0);
+            binding.stride.Assign(static_cast<u16>(stride));
+            binding_divisors[index] = divisor;
+        }
+
+        void SetAttribute(std::size_t index, bool enabled, u32 buffer, u32 offset,
+                          Maxwell::VertexAttribute::Type type,
+                          Maxwell::VertexAttribute::Size size) noexcept {
+            auto& attribute = attributes[index];
+            attribute.raw = 0;
+            attribute.enabled.Assign(enabled ? 1 : 0);
+            attribute.buffer.Assign(buffer);
+            attribute.offset.Assign(offset);
+            attribute.type.Assign(static_cast<u32>(type));
+            attribute.size.Assign(static_cast<u32>(size));
+        }
+    };
+
+    struct Rasterizer {
        union {
-            u32 raw2;
+            u32 raw;
            BitField<0, 4, u32> topology;
-            BitField<4, 2, u32> cull_face;
-            BitField<6, 1, u32> cull_enable;
+            BitField<4, 1, u32> primitive_restart_enable;
+            BitField<5, 1, u32> cull_enable;
+            BitField<6, 1, u32> depth_bias_enable;
+            BitField<7, 1, u32> depth_clamp_disabled;
+            BitField<8, 1, u32> ndc_minus_one_to_one;
+            BitField<9, 2, u32> cull_face;
+            BitField<11, 1, u32> front_face;
+            BitField<12, 2, u32> polygon_mode;
+            BitField<14, 5, u32> patch_control_points_minus_one;
+            BitField<19, 2, u32> tessellation_primitive;
+            BitField<21, 2, u32> tessellation_spacing;
+            BitField<23, 1, u32> tessellation_clockwise;
+            BitField<24, 1, u32> logic_op_enable;
+            BitField<25, 4, u32> logic_op;
+            BitField<29, 1, u32> rasterize_enable;
        };
-        std::array<VertexBinding, Maxwell::NumVertexArrays> vertex_bindings;

-        void Fill(const Maxwell& regs);
+        // TODO(Rodrigo): Move this to push constants
+        u32 point_size;

-        Maxwell::ComparisonOp DepthTestFunc() const noexcept {
-            return UnpackComparisonOp(depth_test_func);
+        void Fill(const Maxwell& regs) noexcept;
+
+        constexpr Maxwell::PrimitiveTopology Topology() const noexcept {
+            return static_cast<Maxwell::PrimitiveTopology>(topology.Value());
        }

        Maxwell::CullFace CullFace() const noexcept {
@@ -169,36 +183,70 @@ struct FixedPipelineState {
        Maxwell::FrontFace FrontFace() const noexcept {
            return UnpackFrontFace(front_face.Value());
        }
+    };

-        constexpr Maxwell::PrimitiveTopology Topology() const noexcept {
-            return static_cast<Maxwell::PrimitiveTopology>(topology.Value());
+    struct DepthStencil {
+        template <std::size_t Position>
+        union StencilFace {
+            BitField<Position + 0, 3, u32> action_stencil_fail;
+            BitField<Position + 3, 3, u32> action_depth_fail;
+            BitField<Position + 6, 3, u32> action_depth_pass;
+            BitField<Position + 9, 3, u32> test_func;
+
+            Maxwell::StencilOp ActionStencilFail() const noexcept {
+                return UnpackStencilOp(action_stencil_fail);
+            }
+
+            Maxwell::StencilOp ActionDepthFail() const noexcept {
+                return UnpackStencilOp(action_depth_fail);
+            }
+
+            Maxwell::StencilOp ActionDepthPass() const noexcept {
+                return UnpackStencilOp(action_depth_pass);
+            }
+
+            Maxwell::ComparisonOp TestFunc() const noexcept {
+                return UnpackComparisonOp(test_func);
+            }
+        };
+
+        union {
+            u32 raw;
+            StencilFace<0> front;
+            StencilFace<12> back;
+            BitField<24, 1, u32> depth_test_enable;
+            BitField<25, 1, u32> depth_write_enable;
+            BitField<26, 1, u32> depth_bounds_enable;
+            BitField<27, 1, u32> stencil_enable;
+            BitField<28, 3, u32> depth_test_func;
+        };
+
+        void Fill(const Maxwell& regs) noexcept;
+
+        Maxwell::ComparisonOp DepthTestFunc() const noexcept {
+            return UnpackComparisonOp(depth_test_func);
        }
    };

-    union {
-        u32 raw;
-        BitField<0, 1, u32> no_extended_dynamic_state;
-        BitField<2, 1, u32> primitive_restart_enable;
-        BitField<3, 1, u32> depth_bias_enable;
-        BitField<4, 1, u32> depth_clamp_disabled;
-        BitField<5, 1, u32> ndc_minus_one_to_one;
-        BitField<6, 2, u32> polygon_mode;
-        BitField<8, 5, u32> patch_control_points_minus_one;
-        BitField<13, 2, u32> tessellation_primitive;
-        BitField<15, 2, u32> tessellation_spacing;
-        BitField<17, 1, u32> tessellation_clockwise;
-        BitField<18, 1, u32> logic_op_enable;
-        BitField<19, 4, u32> logic_op;
-        BitField<23, 1, u32> rasterize_enable;
-    };
-    u32 point_size;
-    std::array<u32, Maxwell::NumVertexArrays> binding_divisors;
-    std::array<VertexAttribute, Maxwell::NumVertexAttributes> attributes;
-    std::array<BlendingAttachment, Maxwell::NumRenderTargets> attachments;
-    std::array<u16, Maxwell::NumViewports> viewport_swizzles;
-    DynamicState dynamic_state;
+    struct ColorBlending {
+        std::array<BlendingAttachment, Maxwell::NumRenderTargets> attachments;

-    void Fill(const Maxwell& regs, bool has_extended_dynamic_state);
+        void Fill(const Maxwell& regs) noexcept;
+    };
+
+    struct ViewportSwizzles {
+        std::array<u16, Maxwell::NumViewports> swizzles;
+
+        void Fill(const Maxwell& regs) noexcept;
+    };
+
+    VertexInput vertex_input;
+    Rasterizer rasterizer;
+    DepthStencil depth_stencil;
+    ColorBlending color_blending;
+    ViewportSwizzles viewport_swizzles;
+
+    void Fill(const Maxwell& regs);

    std::size_t Hash() const noexcept;

@@ -207,11 +255,6 @@ struct FixedPipelineState {
    bool operator!=(const FixedPipelineState& rhs) const noexcept {
        return !operator==(rhs);
    }
-
-    std::size_t Size() const noexcept {
-        const std::size_t total_size = sizeof *this;
-        return total_size - (no_extended_dynamic_state != 0 ? 0 : sizeof(DynamicState));
-    }
 };
 static_assert(std::has_unique_object_representations_v<FixedPipelineState>);
 static_assert(std::is_trivially_copyable_v<FixedPipelineState>);
--- a/src/video_core/renderer_vulkan/renderer_vulkan.cpp
+++ b/src/video_core/renderer_vulkan/renderer_vulkan.cpp
@@ -409,7 +409,7 @@ bool RendererVulkan::PickDevices() {
        return false;
    }

-    const s32 device_index = Settings::values.vulkan_device.GetValue();
+    const s32 device_index = Settings::values.vulkan_device;
    if (device_index < 0 || device_index >= static_cast<s32>(devices->size())) {
        LOG_ERROR(Render_Vulkan, "Invalid device index {}!", device_index);
        return false;
--- a/src/video_core/renderer_vulkan/vk_buffer_cache.cpp
+++ b/src/video_core/renderer_vulkan/vk_buffer_cache.cpp
@@ -56,7 +56,7 @@ Buffer::Buffer(const VKDevice& device, VKMemoryManager& memory_manager, VKSchedu

 Buffer::~Buffer() = default;

-void Buffer::Upload(std::size_t offset, std::size_t size, const u8* data) {
+void Buffer::Upload(std::size_t offset, std::size_t size, const u8* data) const {
    const auto& staging = staging_pool.GetUnusedBuffer(size, true);
    std::memcpy(staging.commit->Map(size), data, size);

@@ -81,7 +81,7 @@ void Buffer::Upload(std::size_t offset, std::size_t size, const u8* data) {
    });
 }

-void Buffer::Download(std::size_t offset, std::size_t size, u8* data) {
+void Buffer::Download(std::size_t offset, std::size_t size, u8* data) const {
    const auto& staging = staging_pool.GetUnusedBuffer(size, true);
    scheduler.RequestOutsideRenderPassOperationContext();

@@ -110,7 +110,7 @@ void Buffer::Download(std::size_t offset, std::size_t size, u8* data) {
 }

 void Buffer::CopyFrom(const Buffer& src, std::size_t src_offset, std::size_t dst_offset,
-                      std::size_t size) {
+                      std::size_t size) const {
    scheduler.RequestOutsideRenderPassOperationContext();

    const VkBuffer dst_buffer = Handle();
--- a/src/video_core/renderer_vulkan/vk_buffer_cache.h
+++ b/src/video_core/renderer_vulkan/vk_buffer_cache.h
@@ -29,12 +29,12 @@ public:
                    VKStagingBufferPool& staging_pool, VAddr cpu_addr, std::size_t size);
    ~Buffer();

-    void Upload(std::size_t offset, std::size_t size, const u8* data);
+    void Upload(std::size_t offset, std::size_t size, const u8* data) const;

-    void Download(std::size_t offset, std::size_t size, u8* data);
+    void Download(std::size_t offset, std::size_t size, u8* data) const;

    void CopyFrom(const Buffer& src, std::size_t src_offset, std::size_t dst_offset,
-                  std::size_t size);
+                  std::size_t size) const;

    VkBuffer Handle() const {
        return *buffer.handle;
--- a/src/video_core/renderer_vulkan/vk_device.cpp
+++ b/src/video_core/renderer_vulkan/vk_device.cpp
@@ -313,16 +313,6 @@ bool VKDevice::Create() {
        LOG_INFO(Render_Vulkan, "Device doesn't support custom border colors");
    }

-    VkPhysicalDeviceExtendedDynamicStateFeaturesEXT dynamic_state;
-    if (ext_extended_dynamic_state) {
-        dynamic_state.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT;
-        dynamic_state.pNext = nullptr;
-        dynamic_state.extendedDynamicState = VK_TRUE;
-        SetNext(next, dynamic_state);
-    } else {
-        LOG_INFO(Render_Vulkan, "Device doesn't support extended dynamic state");
-    }
-
    if (!ext_depth_range_unrestricted) {
        LOG_INFO(Render_Vulkan, "Device doesn't support depth range unrestricted");
    }
@@ -551,7 +541,6 @@ std::vector<const char*> VKDevice::LoadExtensions() {
    bool has_ext_subgroup_size_control{};
    bool has_ext_transform_feedback{};
    bool has_ext_custom_border_color{};
-    bool has_ext_extended_dynamic_state{};
    for (const auto& extension : physical.EnumerateDeviceExtensionProperties()) {
        Test(extension, nv_viewport_swizzle, VK_NV_VIEWPORT_SWIZZLE_EXTENSION_NAME, true);
        Test(extension, khr_uniform_buffer_standard_layout,
@@ -569,8 +558,6 @@ std::vector<const char*> VKDevice::LoadExtensions() {
             false);
        Test(extension, has_ext_custom_border_color, VK_EXT_CUSTOM_BORDER_COLOR_EXTENSION_NAME,
             false);
-        Test(extension, has_ext_extended_dynamic_state,
-             VK_EXT_EXTENDED_DYNAMIC_STATE_EXTENSION_NAME, false);
        if (Settings::values.renderer_debug) {
            Test(extension, nv_device_diagnostics_config,
                 VK_NV_DEVICE_DIAGNOSTICS_CONFIG_EXTENSION_NAME, true);
@@ -656,19 +643,6 @@ std::vector<const char*> VKDevice::LoadExtensions() {
        }
    }

-    if (has_ext_extended_dynamic_state) {
-        VkPhysicalDeviceExtendedDynamicStateFeaturesEXT dynamic_state;
-        dynamic_state.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT;
-        dynamic_state.pNext = nullptr;
-        features.pNext = &dynamic_state;
-        physical.GetFeatures2KHR(features);
-
-        if (dynamic_state.extendedDynamicState) {
-            extensions.push_back(VK_EXT_EXTENDED_DYNAMIC_STATE_EXTENSION_NAME);
-            ext_extended_dynamic_state = true;
-        }
-    }
-
    return extensions;
 }

--- a/src/video_core/renderer_vulkan/vk_device.h
+++ b/src/video_core/renderer_vulkan/vk_device.h
@@ -182,11 +182,6 @@ public:
        return ext_custom_border_color;
    }

-    /// Returns true if the device supports VK_EXT_extended_dynamic_state.
-    bool IsExtExtendedDynamicStateSupported() const {
-        return ext_extended_dynamic_state;
-    }
-
    /// Returns the vendor name reported from Vulkan.
    std::string_view GetVendorName() const {
        return vendor_name;
@@ -244,7 +239,6 @@ private:
    bool ext_shader_viewport_index_layer{};    ///< Support for VK_EXT_shader_viewport_index_layer.
    bool ext_transform_feedback{};             ///< Support for VK_EXT_transform_feedback.
    bool ext_custom_border_color{};            ///< Support for VK_EXT_custom_border_color.
-    bool ext_extended_dynamic_state{};         ///< Support for VK_EXT_extended_dynamic_state.
    bool nv_device_diagnostics_config{};       ///< Support for VK_NV_device_diagnostics_config.

    // Telemetry parameters
--- a/src/video_core/renderer_vulkan/vk_graphics_pipeline.cpp
+++ b/src/video_core/renderer_vulkan/vk_graphics_pipeline.cpp
@@ -28,15 +28,15 @@ namespace {

 template <class StencilFace>
 VkStencilOpState GetStencilFaceState(const StencilFace& face) {
-    return {
-        .failOp = MaxwellToVK::StencilOp(face.ActionStencilFail()),
-        .passOp = MaxwellToVK::StencilOp(face.ActionDepthPass()),
-        .depthFailOp = MaxwellToVK::StencilOp(face.ActionDepthFail()),
-        .compareOp = MaxwellToVK::ComparisonOp(face.TestFunc()),
-        .compareMask = 0,
-        .writeMask = 0,
-        .reference = 0,
-    };
+    VkStencilOpState state;
+    state.failOp = MaxwellToVK::StencilOp(face.ActionStencilFail());
+    state.passOp = MaxwellToVK::StencilOp(face.ActionDepthPass());
+    state.depthFailOp = MaxwellToVK::StencilOp(face.ActionDepthFail());
+    state.compareOp = MaxwellToVK::ComparisonOp(face.TestFunc());
+    state.compareMask = 0;
+    state.writeMask = 0;
+    state.reference = 0;
+    return state;
 }

 bool SupportsPrimitiveRestart(VkPrimitiveTopology topology) {
@@ -52,21 +52,20 @@ bool SupportsPrimitiveRestart(VkPrimitiveTopology topology) {
 }

 VkViewportSwizzleNV UnpackViewportSwizzle(u16 swizzle) {
-    union Swizzle {
+    union {
        u32 raw;
        BitField<0, 3, Maxwell::ViewportSwizzle> x;
        BitField<4, 3, Maxwell::ViewportSwizzle> y;
        BitField<8, 3, Maxwell::ViewportSwizzle> z;
        BitField<12, 3, Maxwell::ViewportSwizzle> w;
-    };
-    const Swizzle unpacked{swizzle};
+    } const unpacked{swizzle};

-    return {
-        .x = MaxwellToVK::ViewportSwizzle(unpacked.x),
-        .y = MaxwellToVK::ViewportSwizzle(unpacked.y),
-        .z = MaxwellToVK::ViewportSwizzle(unpacked.z),
-        .w = MaxwellToVK::ViewportSwizzle(unpacked.w),
-    };
+    VkViewportSwizzleNV result;
+    result.x = MaxwellToVK::ViewportSwizzle(unpacked.x);
+    result.y = MaxwellToVK::ViewportSwizzle(unpacked.y);
+    result.z = MaxwellToVK::ViewportSwizzle(unpacked.z);
+    result.w = MaxwellToVK::ViewportSwizzle(unpacked.w);
+    return result;
 }

 } // Anonymous namespace
@@ -101,26 +100,24 @@ VkDescriptorSet VKGraphicsPipeline::CommitDescriptorSet() {

 vk::DescriptorSetLayout VKGraphicsPipeline::CreateDescriptorSetLayout(
    vk::Span<VkDescriptorSetLayoutBinding> bindings) const {
-    const VkDescriptorSetLayoutCreateInfo ci{
-        .sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO,
-        .pNext = nullptr,
-        .flags = 0,
-        .bindingCount = bindings.size(),
-        .pBindings = bindings.data(),
-    };
+    VkDescriptorSetLayoutCreateInfo ci;
+    ci.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO;
+    ci.pNext = nullptr;
+    ci.flags = 0;
+    ci.bindingCount = bindings.size();
+    ci.pBindings = bindings.data();
    return device.GetLogical().CreateDescriptorSetLayout(ci);
 }

 vk::PipelineLayout VKGraphicsPipeline::CreatePipelineLayout() const {
-    const VkPipelineLayoutCreateInfo ci{
-        .sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO,
-        .pNext = nullptr,
-        .flags = 0,
-        .setLayoutCount = 1,
-        .pSetLayouts = descriptor_set_layout.address(),
-        .pushConstantRangeCount = 0,
-        .pPushConstantRanges = nullptr,
-    };
+    VkPipelineLayoutCreateInfo ci;
+    ci.sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO;
+    ci.pNext = nullptr;
+    ci.flags = 0;
+    ci.setLayoutCount = 1;
+    ci.pSetLayouts = descriptor_set_layout.address();
+    ci.pushConstantRangeCount = 0;
+    ci.pPushConstantRanges = nullptr;
    return device.GetLogical().CreatePipelineLayout(ci);
 }

@@ -139,28 +136,26 @@ vk::DescriptorUpdateTemplateKHR VKGraphicsPipeline::CreateDescriptorUpdateTempla
        return {};
    }

-    const VkDescriptorUpdateTemplateCreateInfoKHR ci{
-        .sType = VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO_KHR,
-        .pNext = nullptr,
-        .flags = 0,
-        .descriptorUpdateEntryCount = static_cast<u32>(template_entries.size()),
-        .pDescriptorUpdateEntries = template_entries.data(),
-        .templateType = VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET_KHR,
-        .descriptorSetLayout = *descriptor_set_layout,
-        .pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS,
-        .pipelineLayout = *layout,
-        .set = DESCRIPTOR_SET,
-    };
+    VkDescriptorUpdateTemplateCreateInfoKHR ci;
+    ci.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO_KHR;
+    ci.pNext = nullptr;
+    ci.flags = 0;
+    ci.descriptorUpdateEntryCount = static_cast<u32>(template_entries.size());
+    ci.pDescriptorUpdateEntries = template_entries.data();
+    ci.templateType = VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET_KHR;
+    ci.descriptorSetLayout = *descriptor_set_layout;
+    ci.pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS;
+    ci.pipelineLayout = *layout;
+    ci.set = DESCRIPTOR_SET;
    return device.GetLogical().CreateDescriptorUpdateTemplateKHR(ci);
 }

 std::vector<vk::ShaderModule> VKGraphicsPipeline::CreateShaderModules(
    const SPIRVProgram& program) const {
-    VkShaderModuleCreateInfo ci{
-        .sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO,
-        .pNext = nullptr,
-        .flags = 0,
-    };
+    VkShaderModuleCreateInfo ci;
+    ci.sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO;
+    ci.pNext = nullptr;
+    ci.flags = 0;

    std::vector<vk::ShaderModule> modules;
    modules.reserve(Maxwell::MaxShaderStage);
@@ -181,52 +176,38 @@ std::vector<vk::ShaderModule> VKGraphicsPipeline::CreateShaderModules(

 vk::Pipeline VKGraphicsPipeline::CreatePipeline(const RenderPassParams& renderpass_params,
                                                const SPIRVProgram& program) const {
-    const auto& state = fixed_state;
-    const auto& viewport_swizzles = state.viewport_swizzles;
-
-    FixedPipelineState::DynamicState dynamic;
-    if (device.IsExtExtendedDynamicStateSupported()) {
-        // Insert dummy values, as long as they are valid they don't matter as extended dynamic
-        // state is ignored
-        dynamic.raw1 = 0;
-        dynamic.raw2 = 0;
-        for (FixedPipelineState::VertexBinding& binding : dynamic.vertex_bindings) {
-            // Enable all vertex bindings
-            binding.raw = 0;
-            binding.enabled.Assign(1);
-        }
-    } else {
-        dynamic = state.dynamic_state;
-    }
+    const auto& vi = fixed_state.vertex_input;
+    const auto& ds = fixed_state.depth_stencil;
+    const auto& cd = fixed_state.color_blending;
+    const auto& rs = fixed_state.rasterizer;
+    const auto& viewport_swizzles = fixed_state.viewport_swizzles.swizzles;

    std::vector<VkVertexInputBindingDescription> vertex_bindings;
    std::vector<VkVertexInputBindingDivisorDescriptionEXT> vertex_binding_divisors;
-    for (std::size_t index = 0; index < Maxwell::NumVertexArrays; ++index) {
-        const auto& binding = dynamic.vertex_bindings[index];
+    for (std::size_t index = 0; index < std::size(vi.bindings); ++index) {
+        const auto& binding = vi.bindings[index];
        if (!binding.enabled) {
            continue;
        }
-        const bool instanced = state.binding_divisors[index] != 0;
+        const bool instanced = vi.binding_divisors[index] != 0;
        const auto rate = instanced ? VK_VERTEX_INPUT_RATE_INSTANCE : VK_VERTEX_INPUT_RATE_VERTEX;

-        vertex_bindings.push_back({
-            .binding = static_cast<u32>(index),
-            .stride = binding.stride,
-            .inputRate = rate,
-        });
+        auto& vertex_binding = vertex_bindings.emplace_back();
+        vertex_binding.binding = static_cast<u32>(index);
+        vertex_binding.stride = binding.stride;
+        vertex_binding.inputRate = rate;

        if (instanced) {
-            vertex_binding_divisors.push_back({
-                .binding = static_cast<u32>(index),
-                .divisor = state.binding_divisors[index],
-            });
+            auto& binding_divisor = vertex_binding_divisors.emplace_back();
+            binding_divisor.binding = static_cast<u32>(index);
+            binding_divisor.divisor = vi.binding_divisors[index];
        }
    }

    std::vector<VkVertexInputAttributeDescription> vertex_attributes;
    const auto& input_attributes = program[0]->entries.attributes;
-    for (std::size_t index = 0; index < state.attributes.size(); ++index) {
-        const auto& attribute = state.attributes[index];
+    for (std::size_t index = 0; index < std::size(vi.attributes); ++index) {
+        const auto& attribute = vi.attributes[index];
        if (!attribute.enabled) {
            continue;
        }
@@ -234,131 +215,116 @@ vk::Pipeline VKGraphicsPipeline::CreatePipeline(const RenderPassParams& renderpa
            // Skip attributes not used by the vertex shaders.
            continue;
        }
-        vertex_attributes.push_back({
-            .location = static_cast<u32>(index),
-            .binding = attribute.buffer,
-            .format = MaxwellToVK::VertexFormat(attribute.Type(), attribute.Size()),
-            .offset = attribute.offset,
-        });
+        auto& vertex_attribute = vertex_attributes.emplace_back();
+        vertex_attribute.location = static_cast<u32>(index);
+        vertex_attribute.binding = attribute.buffer;
+        vertex_attribute.format = MaxwellToVK::VertexFormat(attribute.Type(), attribute.Size());
+        vertex_attribute.offset = attribute.offset;
    }

-    VkPipelineVertexInputStateCreateInfo vertex_input_ci{
-        .sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO,
-        .pNext = nullptr,
-        .flags = 0,
-        .vertexBindingDescriptionCount = static_cast<u32>(vertex_bindings.size()),
-        .pVertexBindingDescriptions = vertex_bindings.data(),
-        .vertexAttributeDescriptionCount = static_cast<u32>(vertex_attributes.size()),
-        .pVertexAttributeDescriptions = vertex_attributes.data(),
-    };
+    VkPipelineVertexInputStateCreateInfo vertex_input_ci;
+    vertex_input_ci.sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO;
+    vertex_input_ci.pNext = nullptr;
+    vertex_input_ci.flags = 0;
+    vertex_input_ci.vertexBindingDescriptionCount = static_cast<u32>(vertex_bindings.size());
+    vertex_input_ci.pVertexBindingDescriptions = vertex_bindings.data();
+    vertex_input_ci.vertexAttributeDescriptionCount = static_cast<u32>(vertex_attributes.size());
+    vertex_input_ci.pVertexAttributeDescriptions = vertex_attributes.data();

-    const VkPipelineVertexInputDivisorStateCreateInfoEXT input_divisor_ci{
-        .sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT,
-        .pNext = nullptr,
-        .vertexBindingDivisorCount = static_cast<u32>(vertex_binding_divisors.size()),
-        .pVertexBindingDivisors = vertex_binding_divisors.data(),
-    };
+    VkPipelineVertexInputDivisorStateCreateInfoEXT input_divisor_ci;
+    input_divisor_ci.sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT;
+    input_divisor_ci.pNext = nullptr;
+    input_divisor_ci.vertexBindingDivisorCount = static_cast<u32>(vertex_binding_divisors.size());
+    input_divisor_ci.pVertexBindingDivisors = vertex_binding_divisors.data();
    if (!vertex_binding_divisors.empty()) {
        vertex_input_ci.pNext = &input_divisor_ci;
    }

-    const auto input_assembly_topology = MaxwellToVK::PrimitiveTopology(device, dynamic.Topology());
-    const VkPipelineInputAssemblyStateCreateInfo input_assembly_ci{
-        .sType = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO,
-        .pNext = nullptr,
-        .flags = 0,
-        .topology = MaxwellToVK::PrimitiveTopology(device, dynamic.Topology()),
-        .primitiveRestartEnable = state.primitive_restart_enable != 0 &&
-                                  SupportsPrimitiveRestart(input_assembly_topology),
-    };
+    VkPipelineInputAssemblyStateCreateInfo input_assembly_ci;
+    input_assembly_ci.sType = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO;
+    input_assembly_ci.pNext = nullptr;
+    input_assembly_ci.flags = 0;
+    input_assembly_ci.topology = MaxwellToVK::PrimitiveTopology(device, rs.Topology());
+    input_assembly_ci.primitiveRestartEnable =
+        rs.primitive_restart_enable != 0 && SupportsPrimitiveRestart(input_assembly_ci.topology);

-    const VkPipelineTessellationStateCreateInfo tessellation_ci{
-        .sType = VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO,
-        .pNext = nullptr,
-        .flags = 0,
-        .patchControlPoints = state.patch_control_points_minus_one.Value() + 1,
-    };
+    VkPipelineTessellationStateCreateInfo tessellation_ci;
+    tessellation_ci.sType = VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO;
+    tessellation_ci.pNext = nullptr;
+    tessellation_ci.flags = 0;
+    tessellation_ci.patchControlPoints = rs.patch_control_points_minus_one.Value() + 1;

-    VkPipelineViewportStateCreateInfo viewport_ci{
-        .sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO,
-        .pNext = nullptr,
-        .flags = 0,
-        .viewportCount = Maxwell::NumViewports,
-        .pViewports = nullptr,
-        .scissorCount = Maxwell::NumViewports,
-        .pScissors = nullptr,
-    };
+    VkPipelineViewportStateCreateInfo viewport_ci;
+    viewport_ci.sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO;
+    viewport_ci.pNext = nullptr;
+    viewport_ci.flags = 0;
+    viewport_ci.viewportCount = Maxwell::NumViewports;
+    viewport_ci.pViewports = nullptr;
+    viewport_ci.scissorCount = Maxwell::NumViewports;
+    viewport_ci.pScissors = nullptr;

    std::array<VkViewportSwizzleNV, Maxwell::NumViewports> swizzles;
    std::transform(viewport_swizzles.begin(), viewport_swizzles.end(), swizzles.begin(),
                   UnpackViewportSwizzle);
-    VkPipelineViewportSwizzleStateCreateInfoNV swizzle_ci{
-        .sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV,
-        .pNext = nullptr,
-        .flags = 0,
-        .viewportCount = Maxwell::NumViewports,
-        .pViewportSwizzles = swizzles.data(),
-    };
+    VkPipelineViewportSwizzleStateCreateInfoNV swizzle_ci;
+    swizzle_ci.sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV;
+    swizzle_ci.pNext = nullptr;
+    swizzle_ci.flags = 0;
+    swizzle_ci.viewportCount = Maxwell::NumViewports;
+    swizzle_ci.pViewportSwizzles = swizzles.data();
    if (device.IsNvViewportSwizzleSupported()) {
        viewport_ci.pNext = &swizzle_ci;
    }

-    const VkPipelineRasterizationStateCreateInfo rasterization_ci{
-        .sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO,
-        .pNext = nullptr,
-        .flags = 0,
-        .depthClampEnable = state.depth_clamp_disabled == 0 ? VK_TRUE : VK_FALSE,
-        .rasterizerDiscardEnable = state.rasterize_enable == 0 ? VK_TRUE : VK_FALSE,
-        .polygonMode = VK_POLYGON_MODE_FILL,
-        .cullMode =
-            dynamic.cull_enable ? MaxwellToVK::CullFace(dynamic.CullFace()) : VK_CULL_MODE_NONE,
-        .frontFace = MaxwellToVK::FrontFace(dynamic.FrontFace()),
-        .depthBiasEnable = state.depth_bias_enable,
-        .depthBiasConstantFactor = 0.0f,
-        .depthBiasClamp = 0.0f,
-        .depthBiasSlopeFactor = 0.0f,
-        .lineWidth = 1.0f,
-    };
+    VkPipelineRasterizationStateCreateInfo rasterization_ci;
+    rasterization_ci.sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO;
+    rasterization_ci.pNext = nullptr;
+    rasterization_ci.flags = 0;
+    rasterization_ci.depthClampEnable = rs.depth_clamp_disabled == 0 ? VK_TRUE : VK_FALSE;
+    rasterization_ci.rasterizerDiscardEnable = rs.rasterize_enable == 0 ? VK_TRUE : VK_FALSE;
+    rasterization_ci.polygonMode = VK_POLYGON_MODE_FILL;
+    rasterization_ci.cullMode =
+        rs.cull_enable ? MaxwellToVK::CullFace(rs.CullFace()) : VK_CULL_MODE_NONE;
+    rasterization_ci.frontFace = MaxwellToVK::FrontFace(rs.FrontFace());
+    rasterization_ci.depthBiasEnable = rs.depth_bias_enable;
+    rasterization_ci.depthBiasConstantFactor = 0.0f;
+    rasterization_ci.depthBiasClamp = 0.0f;
+    rasterization_ci.depthBiasSlopeFactor = 0.0f;
+    rasterization_ci.lineWidth = 1.0f;

-    const VkPipelineMultisampleStateCreateInfo multisample_ci{
-        .sType = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO,
-        .pNext = nullptr,
-        .flags = 0,
-        .rasterizationSamples = VK_SAMPLE_COUNT_1_BIT,
-        .sampleShadingEnable = VK_FALSE,
-        .minSampleShading = 0.0f,
-        .pSampleMask = nullptr,
-        .alphaToCoverageEnable = VK_FALSE,
-        .alphaToOneEnable = VK_FALSE,
-    };
+    VkPipelineMultisampleStateCreateInfo multisample_ci;
+    multisample_ci.sType = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO;
+    multisample_ci.pNext = nullptr;
+    multisample_ci.flags = 0;
+    multisample_ci.rasterizationSamples = VK_SAMPLE_COUNT_1_BIT;
+    multisample_ci.sampleShadingEnable = VK_FALSE;
+    multisample_ci.minSampleShading = 0.0f;
+    multisample_ci.pSampleMask = nullptr;
+    multisample_ci.alphaToCoverageEnable = VK_FALSE;
+    multisample_ci.alphaToOneEnable = VK_FALSE;

-    const VkPipelineDepthStencilStateCreateInfo depth_stencil_ci{
-        .sType = VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO,
-        .pNext = nullptr,
-        .flags = 0,
-        .depthTestEnable = dynamic.depth_test_enable,
-        .depthWriteEnable = dynamic.depth_write_enable,
-        .depthCompareOp = dynamic.depth_test_enable
-                              ? MaxwellToVK::ComparisonOp(dynamic.DepthTestFunc())
-                              : VK_COMPARE_OP_ALWAYS,
-        .depthBoundsTestEnable = dynamic.depth_bounds_enable,
-        .stencilTestEnable = dynamic.stencil_enable,
-        .front = GetStencilFaceState(dynamic.front),
-        .back = GetStencilFaceState(dynamic.back),
-        .minDepthBounds = 0.0f,
-        .maxDepthBounds = 0.0f,
-    };
+    VkPipelineDepthStencilStateCreateInfo depth_stencil_ci;
+    depth_stencil_ci.sType = VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO;
+    depth_stencil_ci.pNext = nullptr;
+    depth_stencil_ci.flags = 0;
+    depth_stencil_ci.depthTestEnable = ds.depth_test_enable;
+    depth_stencil_ci.depthWriteEnable = ds.depth_write_enable;
+    depth_stencil_ci.depthCompareOp =
+        ds.depth_test_enable ? MaxwellToVK::ComparisonOp(ds.DepthTestFunc()) : VK_COMPARE_OP_ALWAYS;
+    depth_stencil_ci.depthBoundsTestEnable = ds.depth_bounds_enable;
+    depth_stencil_ci.stencilTestEnable = ds.stencil_enable;
+    depth_stencil_ci.front = GetStencilFaceState(ds.front);
+    depth_stencil_ci.back = GetStencilFaceState(ds.back);
+    depth_stencil_ci.minDepthBounds = 0.0f;
+    depth_stencil_ci.maxDepthBounds = 0.0f;

    std::array<VkPipelineColorBlendAttachmentState, Maxwell::NumRenderTargets> cb_attachments;
    const auto num_attachments = static_cast<std::size_t>(renderpass_params.num_color_attachments);
    for (std::size_t index = 0; index < num_attachments; ++index) {
-        static constexpr std::array COMPONENT_TABLE{
-            VK_COLOR_COMPONENT_R_BIT,
-            VK_COLOR_COMPONENT_G_BIT,
-            VK_COLOR_COMPONENT_B_BIT,
-            VK_COLOR_COMPONENT_A_BIT,
-        };
-        const auto& blend = state.attachments[index];
+        static constexpr std::array COMPONENT_TABLE = {
+            VK_COLOR_COMPONENT_R_BIT, VK_COLOR_COMPONENT_G_BIT, VK_COLOR_COMPONENT_B_BIT,
+            VK_COLOR_COMPONENT_A_BIT};
+        const auto& blend = cd.attachments[index];

        VkColorComponentFlags color_components = 0;
        for (std::size_t i = 0; i < COMPONENT_TABLE.size(); ++i) {
@@ -367,63 +333,45 @@ vk::Pipeline VKGraphicsPipeline::CreatePipeline(const RenderPassParams& renderpa
            }
        }

-        cb_attachments[index] = {
-            .blendEnable = blend.enable != 0,
-            .srcColorBlendFactor = MaxwellToVK::BlendFactor(blend.SourceRGBFactor()),
-            .dstColorBlendFactor = MaxwellToVK::BlendFactor(blend.DestRGBFactor()),
-            .colorBlendOp = MaxwellToVK::BlendEquation(blend.EquationRGB()),
-            .srcAlphaBlendFactor = MaxwellToVK::BlendFactor(blend.SourceAlphaFactor()),
-            .dstAlphaBlendFactor = MaxwellToVK::BlendFactor(blend.DestAlphaFactor()),
-            .alphaBlendOp = MaxwellToVK::BlendEquation(blend.EquationAlpha()),
-            .colorWriteMask = color_components,
-        };
+        VkPipelineColorBlendAttachmentState& attachment = cb_attachments[index];
+        attachment.blendEnable = blend.enable != 0;
+        attachment.srcColorBlendFactor = MaxwellToVK::BlendFactor(blend.SourceRGBFactor());
+        attachment.dstColorBlendFactor = MaxwellToVK::BlendFactor(blend.DestRGBFactor());
+        attachment.colorBlendOp = MaxwellToVK::BlendEquation(blend.EquationRGB());
+        attachment.srcAlphaBlendFactor = MaxwellToVK::BlendFactor(blend.SourceAlphaFactor());
+        attachment.dstAlphaBlendFactor = MaxwellToVK::BlendFactor(blend.DestAlphaFactor());
+        attachment.alphaBlendOp = MaxwellToVK::BlendEquation(blend.EquationAlpha());
+        attachment.colorWriteMask = color_components;
    }

-    const VkPipelineColorBlendStateCreateInfo color_blend_ci{
-        .sType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO,
-        .pNext = nullptr,
-        .flags = 0,
-        .logicOpEnable = VK_FALSE,
-        .logicOp = VK_LOGIC_OP_COPY,
-        .attachmentCount = static_cast<u32>(num_attachments),
-        .pAttachments = cb_attachments.data(),
-    };
+    VkPipelineColorBlendStateCreateInfo color_blend_ci;
+    color_blend_ci.sType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO;
+    color_blend_ci.pNext = nullptr;
+    color_blend_ci.flags = 0;
+    color_blend_ci.logicOpEnable = VK_FALSE;
+    color_blend_ci.logicOp = VK_LOGIC_OP_COPY;
+    color_blend_ci.attachmentCount = static_cast<u32>(num_attachments);
+    color_blend_ci.pAttachments = cb_attachments.data();
+    std::memset(color_blend_ci.blendConstants, 0, sizeof(color_blend_ci.blendConstants));

-    std::vector dynamic_states{
+    static constexpr std::array dynamic_states = {
        VK_DYNAMIC_STATE_VIEWPORT,           VK_DYNAMIC_STATE_SCISSOR,
        VK_DYNAMIC_STATE_DEPTH_BIAS,         VK_DYNAMIC_STATE_BLEND_CONSTANTS,
        VK_DYNAMIC_STATE_DEPTH_BOUNDS,       VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK,
-        VK_DYNAMIC_STATE_STENCIL_WRITE_MASK, VK_DYNAMIC_STATE_STENCIL_REFERENCE,
-    };
-    if (device.IsExtExtendedDynamicStateSupported()) {
-        static constexpr std::array extended{
-            VK_DYNAMIC_STATE_CULL_MODE_EXT,
-            VK_DYNAMIC_STATE_FRONT_FACE_EXT,
-            VK_DYNAMIC_STATE_PRIMITIVE_TOPOLOGY_EXT,
-            VK_DYNAMIC_STATE_VERTEX_INPUT_BINDING_STRIDE_EXT,
-            VK_DYNAMIC_STATE_DEPTH_TEST_ENABLE_EXT,
-            VK_DYNAMIC_STATE_DEPTH_WRITE_ENABLE_EXT,
-            VK_DYNAMIC_STATE_DEPTH_COMPARE_OP_EXT,
-            VK_DYNAMIC_STATE_DEPTH_BOUNDS_TEST_ENABLE_EXT,
-            VK_DYNAMIC_STATE_STENCIL_TEST_ENABLE_EXT,
-            VK_DYNAMIC_STATE_STENCIL_OP_EXT,
-        };
-        dynamic_states.insert(dynamic_states.end(), extended.begin(), extended.end());
-    }
+        VK_DYNAMIC_STATE_STENCIL_WRITE_MASK, VK_DYNAMIC_STATE_STENCIL_REFERENCE};

-    const VkPipelineDynamicStateCreateInfo dynamic_state_ci{
-        .sType = VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO,
-        .pNext = nullptr,
-        .flags = 0,
-        .dynamicStateCount = static_cast<u32>(dynamic_states.size()),
-        .pDynamicStates = dynamic_states.data(),
-    };
+    VkPipelineDynamicStateCreateInfo dynamic_state_ci;
+    dynamic_state_ci.sType = VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO;
+    dynamic_state_ci.pNext = nullptr;
+    dynamic_state_ci.flags = 0;
+    dynamic_state_ci.dynamicStateCount = static_cast<u32>(dynamic_states.size());
+    dynamic_state_ci.pDynamicStates = dynamic_states.data();

-    const VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT subgroup_size_ci{
-        .sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO_EXT,
-        .pNext = nullptr,
-        .requiredSubgroupSize = GuestWarpSize,
-    };
+    VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT subgroup_size_ci;
+    subgroup_size_ci.sType =
+        VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO_EXT;
+    subgroup_size_ci.pNext = nullptr;
+    subgroup_size_ci.requiredSubgroupSize = GuestWarpSize;

    std::vector<VkPipelineShaderStageCreateInfo> shader_stages;
    std::size_t module_index = 0;
@@ -431,7 +379,6 @@ vk::Pipeline VKGraphicsPipeline::CreatePipeline(const RenderPassParams& renderpa
        if (!program[stage]) {
            continue;
        }
-
        VkPipelineShaderStageCreateInfo& stage_ci = shader_stages.emplace_back();
        stage_ci.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
        stage_ci.pNext = nullptr;
@@ -446,27 +393,26 @@ vk::Pipeline VKGraphicsPipeline::CreatePipeline(const RenderPassParams& renderpa
        }
    }

-    const VkGraphicsPipelineCreateInfo ci{
-        .sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO,
-        .pNext = nullptr,
-        .flags = 0,
-        .stageCount = static_cast<u32>(shader_stages.size()),
-        .pStages = shader_stages.data(),
-        .pVertexInputState = &vertex_input_ci,
-        .pInputAssemblyState = &input_assembly_ci,
-        .pTessellationState = &tessellation_ci,
-        .pViewportState = &viewport_ci,
-        .pRasterizationState = &rasterization_ci,
-        .pMultisampleState = &multisample_ci,
-        .pDepthStencilState = &depth_stencil_ci,
-        .pColorBlendState = &color_blend_ci,
-        .pDynamicState = &dynamic_state_ci,
-        .layout = *layout,
-        .renderPass = renderpass,
-        .subpass = 0,
-        .basePipelineHandle = nullptr,
-        .basePipelineIndex = 0,
-    };
+    VkGraphicsPipelineCreateInfo ci;
+    ci.sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO;
+    ci.pNext = nullptr;
+    ci.flags = 0;
+    ci.stageCount = static_cast<u32>(shader_stages.size());
+    ci.pStages = shader_stages.data();
+    ci.pVertexInputState = &vertex_input_ci;
+    ci.pInputAssemblyState = &input_assembly_ci;
+    ci.pTessellationState = &tessellation_ci;
+    ci.pViewportState = &viewport_ci;
+    ci.pRasterizationState = &rasterization_ci;
+    ci.pMultisampleState = &multisample_ci;
+    ci.pDepthStencilState = &depth_stencil_ci;
+    ci.pColorBlendState = &color_blend_ci;
+    ci.pDynamicState = &dynamic_state_ci;
+    ci.layout = *layout;
+    ci.renderPass = renderpass;
+    ci.subpass = 0;
+    ci.basePipelineHandle = nullptr;
+    ci.basePipelineIndex = 0;
    return device.GetLogical().CreateGraphicsPipeline(ci);
 }

--- a/src/video_core/renderer_vulkan/vk_pipeline_cache.cpp
+++ b/src/video_core/renderer_vulkan/vk_pipeline_cache.cpp
@@ -116,12 +116,12 @@ u32 FillDescriptorLayout(const ShaderEntries& entries,
 } // Anonymous namespace

 std::size_t GraphicsPipelineCacheKey::Hash() const noexcept {
-    const u64 hash = Common::CityHash64(reinterpret_cast<const char*>(this), Size());
+    const u64 hash = Common::CityHash64(reinterpret_cast<const char*>(this), sizeof *this);
    return static_cast<std::size_t>(hash);
 }

 bool GraphicsPipelineCacheKey::operator==(const GraphicsPipelineCacheKey& rhs) const noexcept {
-    return std::memcmp(&rhs, this, Size()) == 0;
+    return std::memcmp(&rhs, this, sizeof *this) == 0;
 }

 std::size_t ComputePipelineCacheKey::Hash() const noexcept {
@@ -312,19 +312,18 @@ VKPipelineCache::DecompileShaders(const GraphicsPipelineCacheKey& key) {
    const auto& gpu = system.GPU().Maxwell3D();

    Specialization specialization;
-    if (fixed_state.dynamic_state.Topology() == Maxwell::PrimitiveTopology::Points ||
-        device.IsExtExtendedDynamicStateSupported()) {
+    if (fixed_state.rasterizer.Topology() == Maxwell::PrimitiveTopology::Points) {
        float point_size;
-        std::memcpy(&point_size, &fixed_state.point_size, sizeof(float));
+        std::memcpy(&point_size, &fixed_state.rasterizer.point_size, sizeof(float));
        specialization.point_size = point_size;
        ASSERT(point_size != 0.0f);
    }
    for (std::size_t i = 0; i < Maxwell::NumVertexAttributes; ++i) {
-        const auto& attribute = fixed_state.attributes[i];
+        const auto& attribute = fixed_state.vertex_input.attributes[i];
        specialization.enabled_attributes[i] = attribute.enabled.Value() != 0;
        specialization.attribute_types[i] = attribute.Type();
    }
-    specialization.ndc_minus_one_to_one = fixed_state.ndc_minus_one_to_one;
+    specialization.ndc_minus_one_to_one = fixed_state.rasterizer.ndc_minus_one_to_one;

    SPIRVProgram program;
    std::vector<VkDescriptorSetLayoutBinding> bindings;
--- a/src/video_core/renderer_vulkan/vk_pipeline_cache.h
+++ b/src/video_core/renderer_vulkan/vk_pipeline_cache.h
@@ -44,10 +44,10 @@ class VKUpdateDescriptorQueue;
 using Maxwell = Tegra::Engines::Maxwell3D::Regs;

 struct GraphicsPipelineCacheKey {
-    RenderPassParams renderpass_params;
-    u32 padding;
-    std::array<GPUVAddr, Maxwell::MaxShaderProgram> shaders;
    FixedPipelineState fixed_state;
+    RenderPassParams renderpass_params;
+    std::array<GPUVAddr, Maxwell::MaxShaderProgram> shaders;
+    u64 padding; // This is necessary for unique object representations

    std::size_t Hash() const noexcept;

@@ -56,10 +56,6 @@ struct GraphicsPipelineCacheKey {
    bool operator!=(const GraphicsPipelineCacheKey& rhs) const noexcept {
        return !operator==(rhs);
    }
-
-    std::size_t Size() const noexcept {
-        return sizeof(renderpass_params) + sizeof(padding) + sizeof(shaders) + fixed_state.Size();
-    }
 };
 static_assert(std::has_unique_object_representations_v<GraphicsPipelineCacheKey>);
 static_assert(std::is_trivially_copyable_v<GraphicsPipelineCacheKey>);
--- a/src/video_core/renderer_vulkan/vk_rasterizer.cpp
+++ b/src/video_core/renderer_vulkan/vk_rasterizer.cpp
@@ -186,22 +186,13 @@ bool HasToPreserveDepthContents(bool is_clear, const Maxwell& regs) {
           scissor.max_y < regs.zeta_height;
 }

-template <std::size_t N>
-std::array<VkDeviceSize, N> ExpandStrides(const std::array<u16, N>& strides) {
-    std::array<VkDeviceSize, N> expanded;
-    std::copy(strides.begin(), strides.end(), expanded.begin());
-    return expanded;
-}
-
 } // Anonymous namespace

 class BufferBindings final {
 public:
-    void AddVertexBinding(VkBuffer buffer, VkDeviceSize offset, VkDeviceSize size, u32 stride) {
+    void AddVertexBinding(VkBuffer buffer, VkDeviceSize offset) {
        vertex.buffers[vertex.num_buffers] = buffer;
        vertex.offsets[vertex.num_buffers] = offset;
-        vertex.sizes[vertex.num_buffers] = size;
-        vertex.strides[vertex.num_buffers] = static_cast<u16>(stride);
        ++vertex.num_buffers;
    }

@@ -211,76 +202,76 @@ public:
        index.type = type;
    }

-    void Bind(const VKDevice& device, VKScheduler& scheduler) const {
+    void Bind(VKScheduler& scheduler) const {
        // Use this large switch case to avoid dispatching more memory in the record lambda than
        // what we need. It looks horrible, but it's the best we can do on standard C++.
        switch (vertex.num_buffers) {
        case 0:
-            return BindStatic<0>(device, scheduler);
+            return BindStatic<0>(scheduler);
        case 1:
-            return BindStatic<1>(device, scheduler);
+            return BindStatic<1>(scheduler);
        case 2:
-            return BindStatic<2>(device, scheduler);
+            return BindStatic<2>(scheduler);
        case 3:
-            return BindStatic<3>(device, scheduler);
+            return BindStatic<3>(scheduler);
        case 4:
-            return BindStatic<4>(device, scheduler);
+            return BindStatic<4>(scheduler);
        case 5:
-            return BindStatic<5>(device, scheduler);
+            return BindStatic<5>(scheduler);
        case 6:
-            return BindStatic<6>(device, scheduler);
+            return BindStatic<6>(scheduler);
        case 7:
-            return BindStatic<7>(device, scheduler);
+            return BindStatic<7>(scheduler);
        case 8:
-            return BindStatic<8>(device, scheduler);
+            return BindStatic<8>(scheduler);
        case 9:
-            return BindStatic<9>(device, scheduler);
+            return BindStatic<9>(scheduler);
        case 10:
-            return BindStatic<10>(device, scheduler);
+            return BindStatic<10>(scheduler);
        case 11:
-            return BindStatic<11>(device, scheduler);
+            return BindStatic<11>(scheduler);
        case 12:
-            return BindStatic<12>(device, scheduler);
+            return BindStatic<12>(scheduler);
        case 13:
-            return BindStatic<13>(device, scheduler);
+            return BindStatic<13>(scheduler);
        case 14:
-            return BindStatic<14>(device, scheduler);
+            return BindStatic<14>(scheduler);
        case 15:
-            return BindStatic<15>(device, scheduler);
+            return BindStatic<15>(scheduler);
        case 16:
-            return BindStatic<16>(device, scheduler);
+            return BindStatic<16>(scheduler);
        case 17:
-            return BindStatic<17>(device, scheduler);
+            return BindStatic<17>(scheduler);
        case 18:
-            return BindStatic<18>(device, scheduler);
+            return BindStatic<18>(scheduler);
        case 19:
-            return BindStatic<19>(device, scheduler);
+            return BindStatic<19>(scheduler);
        case 20:
-            return BindStatic<20>(device, scheduler);
+            return BindStatic<20>(scheduler);
        case 21:
-            return BindStatic<21>(device, scheduler);
+            return BindStatic<21>(scheduler);
        case 22:
-            return BindStatic<22>(device, scheduler);
+            return BindStatic<22>(scheduler);
        case 23:
-            return BindStatic<23>(device, scheduler);
+            return BindStatic<23>(scheduler);
        case 24:
-            return BindStatic<24>(device, scheduler);
+            return BindStatic<24>(scheduler);
        case 25:
-            return BindStatic<25>(device, scheduler);
+            return BindStatic<25>(scheduler);
        case 26:
-            return BindStatic<26>(device, scheduler);
+            return BindStatic<26>(scheduler);
        case 27:
-            return BindStatic<27>(device, scheduler);
+            return BindStatic<27>(scheduler);
        case 28:
-            return BindStatic<28>(device, scheduler);
+            return BindStatic<28>(scheduler);
        case 29:
-            return BindStatic<29>(device, scheduler);
+            return BindStatic<29>(scheduler);
        case 30:
-            return BindStatic<30>(device, scheduler);
+            return BindStatic<30>(scheduler);
        case 31:
-            return BindStatic<31>(device, scheduler);
+            return BindStatic<31>(scheduler);
        case 32:
-            return BindStatic<32>(device, scheduler);
+            return BindStatic<32>(scheduler);
        }
        UNREACHABLE();
    }
@@ -291,8 +282,6 @@ private:
        std::size_t num_buffers = 0;
        std::array<VkBuffer, Maxwell::NumVertexArrays> buffers;
        std::array<VkDeviceSize, Maxwell::NumVertexArrays> offsets;
-        std::array<VkDeviceSize, Maxwell::NumVertexArrays> sizes;
-        std::array<u16, Maxwell::NumVertexArrays> strides;
    } vertex;

    struct {
@@ -302,23 +291,15 @@ private:
    } index;

    template <std::size_t N>
-    void BindStatic(const VKDevice& device, VKScheduler& scheduler) const {
-        if (device.IsExtExtendedDynamicStateSupported()) {
-            if (index.buffer) {
-                BindStatic<N, true, true>(scheduler);
-            } else {
-                BindStatic<N, false, true>(scheduler);
-            }
+    void BindStatic(VKScheduler& scheduler) const {
+        if (index.buffer) {
+            BindStatic<N, true>(scheduler);
        } else {
-            if (index.buffer) {
-                BindStatic<N, true, false>(scheduler);
-            } else {
-                BindStatic<N, false, false>(scheduler);
-            }
+            BindStatic<N, false>(scheduler);
        }
    }

-    template <std::size_t N, bool is_indexed, bool has_extended_dynamic_state>
+    template <std::size_t N, bool is_indexed>
    void BindStatic(VKScheduler& scheduler) const {
        static_assert(N <= Maxwell::NumVertexArrays);
        if constexpr (N == 0) {
@@ -330,31 +311,6 @@ private:
        std::copy(vertex.buffers.begin(), vertex.buffers.begin() + N, buffers.begin());
        std::copy(vertex.offsets.begin(), vertex.offsets.begin() + N, offsets.begin());

-        if constexpr (has_extended_dynamic_state) {
-            // With extended dynamic states we can specify the length and stride of a vertex buffer
-            std::array<VkDeviceSize, N> sizes;
-            std::array<u16, N> strides;
-            std::copy(vertex.sizes.begin(), vertex.sizes.begin() + N, sizes.begin());
-            std::copy(vertex.strides.begin(), vertex.strides.begin() + N, strides.begin());
-
-            if constexpr (is_indexed) {
-                scheduler.Record(
-                    [buffers, offsets, sizes, strides, index = index](vk::CommandBuffer cmdbuf) {
-                        cmdbuf.BindIndexBuffer(index.buffer, index.offset, index.type);
-                        cmdbuf.BindVertexBuffers2EXT(0, static_cast<u32>(N), buffers.data(),
-                                                     offsets.data(), sizes.data(),
-                                                     ExpandStrides(strides).data());
-                    });
-            } else {
-                scheduler.Record([buffers, offsets, sizes, strides](vk::CommandBuffer cmdbuf) {
-                    cmdbuf.BindVertexBuffers2EXT(0, static_cast<u32>(N), buffers.data(),
-                                                 offsets.data(), sizes.data(),
-                                                 ExpandStrides(strides).data());
-                });
-            }
-            return;
-        }
-
        if constexpr (is_indexed) {
            // Indexed draw
            scheduler.Record([buffers, offsets, index = index](vk::CommandBuffer cmdbuf) {
@@ -413,7 +369,7 @@ void RasterizerVulkan::Draw(bool is_indexed, bool is_instanced) {

    const auto& gpu = system.GPU().Maxwell3D();
    GraphicsPipelineCacheKey key;
-    key.fixed_state.Fill(gpu.regs, device.IsExtExtendedDynamicStateSupported());
+    key.fixed_state.Fill(gpu.regs);

    buffer_cache.Map(CalculateGraphicsStreamBufferSize(is_indexed));

@@ -446,7 +402,7 @@ void RasterizerVulkan::Draw(bool is_indexed, bool is_instanced) {

    UpdateDynamicStates();

-    buffer_bindings.Bind(device, scheduler);
+    buffer_bindings.Bind(scheduler);

    BeginTransformFeedback();

@@ -866,7 +822,7 @@ RasterizerVulkan::DrawParameters RasterizerVulkan::SetupGeometry(FixedPipelineSt
    const auto& gpu = system.GPU().Maxwell3D();
    const auto& regs = gpu.regs;

-    SetupVertexArrays(buffer_bindings);
+    SetupVertexArrays(fixed_state.vertex_input, buffer_bindings);

    const u32 base_instance = regs.vb_base_instance;
    const u32 num_instances = is_instanced ? gpu.mme_draw.instance_count : 1;
@@ -937,17 +893,6 @@ void RasterizerVulkan::UpdateDynamicStates() {
    UpdateBlendConstants(regs);
    UpdateDepthBounds(regs);
    UpdateStencilFaces(regs);
-    if (device.IsExtExtendedDynamicStateSupported()) {
-        UpdateCullMode(regs);
-        UpdateDepthBoundsTestEnable(regs);
-        UpdateDepthTestEnable(regs);
-        UpdateDepthWriteEnable(regs);
-        UpdateDepthCompareOp(regs);
-        UpdateFrontFace(regs);
-        UpdatePrimitiveTopology(regs);
-        UpdateStencilOp(regs);
-        UpdateStencilTestEnable(regs);
-    }
 }

 void RasterizerVulkan::BeginTransformFeedback() {
@@ -995,25 +940,41 @@ void RasterizerVulkan::EndTransformFeedback() {
        [](vk::CommandBuffer cmdbuf) { cmdbuf.EndTransformFeedbackEXT(0, 0, nullptr, nullptr); });
 }

-void RasterizerVulkan::SetupVertexArrays(BufferBindings& buffer_bindings) {
+void RasterizerVulkan::SetupVertexArrays(FixedPipelineState::VertexInput& vertex_input,
+                                         BufferBindings& buffer_bindings) {
    const auto& regs = system.GPU().Maxwell3D().regs;

+    for (std::size_t index = 0; index < Maxwell::NumVertexAttributes; ++index) {
+        const auto& attrib = regs.vertex_attrib_format[index];
+        if (attrib.IsConstant()) {
+            vertex_input.SetAttribute(index, false, 0, 0, {}, {});
+            continue;
+        }
+        vertex_input.SetAttribute(index, true, attrib.buffer, attrib.offset, attrib.type.Value(),
+                                  attrib.size.Value());
+    }
+
    for (std::size_t index = 0; index < Maxwell::NumVertexArrays; ++index) {
        const auto& vertex_array = regs.vertex_array[index];
        if (!vertex_array.IsEnabled()) {
+            vertex_input.SetBinding(index, false, 0, 0);
            continue;
        }
+        vertex_input.SetBinding(
+            index, true, vertex_array.stride,
+            regs.instanced_arrays.IsInstancingEnabled(index) ? vertex_array.divisor : 0);
+
        const GPUVAddr start{vertex_array.StartAddress()};
        const GPUVAddr end{regs.vertex_array_limit[index].LimitAddress()};

        ASSERT(end >= start);
-        const std::size_t size = end - start;
+        const std::size_t size{end - start};
        if (size == 0) {
-            buffer_bindings.AddVertexBinding(DefaultBuffer(), 0, DEFAULT_BUFFER_SIZE, 0);
+            buffer_bindings.AddVertexBinding(DefaultBuffer(), 0);
            continue;
        }
        const auto info = buffer_cache.UploadMemory(start, size);
-        buffer_bindings.AddVertexBinding(info.handle, info.offset, size, vertex_array.stride);
+        buffer_bindings.AddVertexBinding(info.handle, info.offset);
    }
 }

@@ -1365,117 +1326,6 @@ void RasterizerVulkan::UpdateStencilFaces(Tegra::Engines::Maxwell3D::Regs& regs)
    }
 }

-void RasterizerVulkan::UpdateCullMode(Tegra::Engines::Maxwell3D::Regs& regs) {
-    if (!state_tracker.TouchCullMode()) {
-        return;
-    }
-    scheduler.Record(
-        [enabled = regs.cull_test_enabled, cull_face = regs.cull_face](vk::CommandBuffer cmdbuf) {
-            cmdbuf.SetCullModeEXT(enabled ? MaxwellToVK::CullFace(cull_face) : VK_CULL_MODE_NONE);
-        });
-}
-
-void RasterizerVulkan::UpdateDepthBoundsTestEnable(Tegra::Engines::Maxwell3D::Regs& regs) {
-    if (!state_tracker.TouchDepthBoundsTestEnable()) {
-        return;
-    }
-    scheduler.Record([enable = regs.depth_bounds_enable](vk::CommandBuffer cmdbuf) {
-        cmdbuf.SetDepthBoundsTestEnableEXT(enable);
-    });
-}
-
-void RasterizerVulkan::UpdateDepthTestEnable(Tegra::Engines::Maxwell3D::Regs& regs) {
-    if (!state_tracker.TouchDepthTestEnable()) {
-        return;
-    }
-    scheduler.Record([enable = regs.depth_test_enable](vk::CommandBuffer cmdbuf) {
-        cmdbuf.SetDepthTestEnableEXT(enable);
-    });
-}
-
-void RasterizerVulkan::UpdateDepthWriteEnable(Tegra::Engines::Maxwell3D::Regs& regs) {
-    if (!state_tracker.TouchDepthWriteEnable()) {
-        return;
-    }
-    scheduler.Record([enable = regs.depth_write_enabled](vk::CommandBuffer cmdbuf) {
-        cmdbuf.SetDepthWriteEnableEXT(enable);
-    });
-}
-
-void RasterizerVulkan::UpdateDepthCompareOp(Tegra::Engines::Maxwell3D::Regs& regs) {
-    if (!state_tracker.TouchDepthCompareOp()) {
-        return;
-    }
-    scheduler.Record([func = regs.depth_test_func](vk::CommandBuffer cmdbuf) {
-        cmdbuf.SetDepthCompareOpEXT(MaxwellToVK::ComparisonOp(func));
-    });
-}
-
-void RasterizerVulkan::UpdateFrontFace(Tegra::Engines::Maxwell3D::Regs& regs) {
-    if (!state_tracker.TouchFrontFace()) {
-        return;
-    }
-
-    VkFrontFace front_face = MaxwellToVK::FrontFace(regs.front_face);
-    if (regs.screen_y_control.triangle_rast_flip != 0) {
-        front_face = front_face == VK_FRONT_FACE_CLOCKWISE ? VK_FRONT_FACE_COUNTER_CLOCKWISE
-                                                           : VK_FRONT_FACE_CLOCKWISE;
-    }
-    scheduler.Record(
-        [front_face](vk::CommandBuffer cmdbuf) { cmdbuf.SetFrontFaceEXT(front_face); });
-}
-
-void RasterizerVulkan::UpdatePrimitiveTopology(Tegra::Engines::Maxwell3D::Regs& regs) {
-    if (!state_tracker.TouchPrimitiveTopology()) {
-        return;
-    }
-    const Maxwell::PrimitiveTopology primitive_topology = regs.draw.topology.Value();
-    scheduler.Record([this, primitive_topology](vk::CommandBuffer cmdbuf) {
-        cmdbuf.SetPrimitiveTopologyEXT(MaxwellToVK::PrimitiveTopology(device, primitive_topology));
-    });
-}
-
-void RasterizerVulkan::UpdateStencilOp(Tegra::Engines::Maxwell3D::Regs& regs) {
-    if (!state_tracker.TouchStencilOp()) {
-        return;
-    }
-    const Maxwell::StencilOp fail = regs.stencil_front_op_fail;
-    const Maxwell::StencilOp zfail = regs.stencil_front_op_zfail;
-    const Maxwell::StencilOp zpass = regs.stencil_front_op_zpass;
-    const Maxwell::ComparisonOp compare = regs.stencil_front_func_func;
-    if (regs.stencil_two_side_enable) {
-        scheduler.Record([fail, zfail, zpass, compare](vk::CommandBuffer cmdbuf) {
-            cmdbuf.SetStencilOpEXT(VK_STENCIL_FACE_FRONT_AND_BACK, MaxwellToVK::StencilOp(fail),
-                                   MaxwellToVK::StencilOp(zpass), MaxwellToVK::StencilOp(zfail),
-                                   MaxwellToVK::ComparisonOp(compare));
-        });
-    } else {
-        const Maxwell::StencilOp back_fail = regs.stencil_back_op_fail;
-        const Maxwell::StencilOp back_zfail = regs.stencil_back_op_zfail;
-        const Maxwell::StencilOp back_zpass = regs.stencil_back_op_zpass;
-        const Maxwell::ComparisonOp back_compare = regs.stencil_back_func_func;
-        scheduler.Record([fail, zfail, zpass, compare, back_fail, back_zfail, back_zpass,
-                          back_compare](vk::CommandBuffer cmdbuf) {
-            cmdbuf.SetStencilOpEXT(VK_STENCIL_FACE_FRONT_BIT, MaxwellToVK::StencilOp(fail),
-                                   MaxwellToVK::StencilOp(zpass), MaxwellToVK::StencilOp(zfail),
-                                   MaxwellToVK::ComparisonOp(compare));
-            cmdbuf.SetStencilOpEXT(VK_STENCIL_FACE_BACK_BIT, MaxwellToVK::StencilOp(back_fail),
-                                   MaxwellToVK::StencilOp(back_zpass),
-                                   MaxwellToVK::StencilOp(back_zfail),
-                                   MaxwellToVK::ComparisonOp(back_compare));
-        });
-    }
-}
-
-void RasterizerVulkan::UpdateStencilTestEnable(Tegra::Engines::Maxwell3D::Regs& regs) {
-    if (!state_tracker.TouchStencilTestEnable()) {
-        return;
-    }
-    scheduler.Record([enable = regs.stencil_enable](vk::CommandBuffer cmdbuf) {
-        cmdbuf.SetStencilTestEnableEXT(enable);
-    });
-}
-
 std::size_t RasterizerVulkan::CalculateGraphicsStreamBufferSize(bool is_indexed) const {
    std::size_t size = CalculateVertexArraysSize();
    if (is_indexed) {
--- a/src/video_core/renderer_vulkan/vk_rasterizer.h
+++ b/src/video_core/renderer_vulkan/vk_rasterizer.h
@@ -185,7 +185,8 @@ private:

    bool WalkAttachmentOverlaps(const CachedSurfaceView& attachment);

-    void SetupVertexArrays(BufferBindings& buffer_bindings);
+    void SetupVertexArrays(FixedPipelineState::VertexInput& vertex_input,
+                           BufferBindings& buffer_bindings);

    void SetupIndexBuffer(BufferBindings& buffer_bindings, DrawParameters& params, bool is_indexed);

@@ -245,16 +246,6 @@ private:
    void UpdateDepthBounds(Tegra::Engines::Maxwell3D::Regs& regs);
    void UpdateStencilFaces(Tegra::Engines::Maxwell3D::Regs& regs);

-    void UpdateCullMode(Tegra::Engines::Maxwell3D::Regs& regs);
-    void UpdateDepthBoundsTestEnable(Tegra::Engines::Maxwell3D::Regs& regs);
-    void UpdateDepthTestEnable(Tegra::Engines::Maxwell3D::Regs& regs);
-    void UpdateDepthWriteEnable(Tegra::Engines::Maxwell3D::Regs& regs);
-    void UpdateDepthCompareOp(Tegra::Engines::Maxwell3D::Regs& regs);
-    void UpdateFrontFace(Tegra::Engines::Maxwell3D::Regs& regs);
-    void UpdatePrimitiveTopology(Tegra::Engines::Maxwell3D::Regs& regs);
-    void UpdateStencilOp(Tegra::Engines::Maxwell3D::Regs& regs);
-    void UpdateStencilTestEnable(Tegra::Engines::Maxwell3D::Regs& regs);
-
    std::size_t CalculateGraphicsStreamBufferSize(bool is_indexed) const;

    std::size_t CalculateComputeStreamBufferSize() const;
--- a/src/video_core/renderer_vulkan/vk_state_tracker.cpp
+++ b/src/video_core/renderer_vulkan/vk_state_tracker.cpp
@@ -36,15 +36,6 @@ Flags MakeInvalidationFlags() {
    flags[BlendConstants] = true;
    flags[DepthBounds] = true;
    flags[StencilProperties] = true;
-    flags[CullMode] = true;
-    flags[DepthBoundsEnable] = true;
-    flags[DepthTestEnable] = true;
-    flags[DepthWriteEnable] = true;
-    flags[DepthCompareOp] = true;
-    flags[FrontFace] = true;
-    flags[PrimitiveTopology] = true;
-    flags[StencilOp] = true;
-    flags[StencilTestEnable] = true;
    return flags;
 }

@@ -84,57 +75,6 @@ void SetupDirtyStencilProperties(Tables& tables) {
    table[OFF(stencil_back_func_mask)] = StencilProperties;
 }

-void SetupDirtyCullMode(Tables& tables) {
-    auto& table = tables[0];
-    table[OFF(cull_face)] = CullMode;
-    table[OFF(cull_test_enabled)] = CullMode;
-}
-
-void SetupDirtyDepthBoundsEnable(Tables& tables) {
-    tables[0][OFF(depth_bounds_enable)] = DepthBoundsEnable;
-}
-
-void SetupDirtyDepthTestEnable(Tables& tables) {
-    tables[0][OFF(depth_test_enable)] = DepthTestEnable;
-}
-
-void SetupDirtyDepthWriteEnable(Tables& tables) {
-    tables[0][OFF(depth_write_enabled)] = DepthWriteEnable;
-}
-
-void SetupDirtyDepthCompareOp(Tables& tables) {
-    tables[0][OFF(depth_test_func)] = DepthCompareOp;
-}
-
-void SetupDirtyFrontFace(Tables& tables) {
-    auto& table = tables[0];
-    table[OFF(front_face)] = FrontFace;
-    table[OFF(screen_y_control)] = FrontFace;
-}
-
-void SetupDirtyPrimitiveTopology(Tables& tables) {
-    tables[0][OFF(draw.topology)] = PrimitiveTopology;
-}
-
-void SetupDirtyStencilOp(Tables& tables) {
-    auto& table = tables[0];
-    table[OFF(stencil_front_op_fail)] = StencilOp;
-    table[OFF(stencil_front_op_zfail)] = StencilOp;
-    table[OFF(stencil_front_op_zpass)] = StencilOp;
-    table[OFF(stencil_front_func_func)] = StencilOp;
-    table[OFF(stencil_back_op_fail)] = StencilOp;
-    table[OFF(stencil_back_op_zfail)] = StencilOp;
-    table[OFF(stencil_back_op_zpass)] = StencilOp;
-    table[OFF(stencil_back_func_func)] = StencilOp;
-
-    // Table 0 is used by StencilProperties
-    tables[1][OFF(stencil_two_side_enable)] = StencilOp;
-}
-
-void SetupDirtyStencilTestEnable(Tables& tables) {
-    tables[0][OFF(stencil_enable)] = StencilTestEnable;
-}
-
 } // Anonymous namespace

 StateTracker::StateTracker(Core::System& system)
@@ -150,14 +90,6 @@ void StateTracker::Initialize() {
    SetupDirtyBlendConstants(tables);
    SetupDirtyDepthBounds(tables);
    SetupDirtyStencilProperties(tables);
-    SetupDirtyCullMode(tables);
-    SetupDirtyDepthBoundsEnable(tables);
-    SetupDirtyDepthTestEnable(tables);
-    SetupDirtyDepthWriteEnable(tables);
-    SetupDirtyDepthCompareOp(tables);
-    SetupDirtyFrontFace(tables);
-    SetupDirtyPrimitiveTopology(tables);
-    SetupDirtyStencilOp(tables);
 }

 void StateTracker::InvalidateCommandBufferState() {
--- a/src/video_core/renderer_vulkan/vk_state_tracker.h
+++ b/src/video_core/renderer_vulkan/vk_state_tracker.h
@@ -26,16 +26,6 @@ enum : u8 {
    DepthBounds,
    StencilProperties,

-    CullMode,
-    DepthBoundsEnable,
-    DepthTestEnable,
-    DepthWriteEnable,
-    DepthCompareOp,
-    FrontFace,
-    PrimitiveTopology,
-    StencilOp,
-    StencilTestEnable,
-
    Last
 };
 static_assert(Last <= std::numeric_limits<u8>::max());
@@ -74,46 +64,6 @@ public:
        return Exchange(Dirty::StencilProperties, false);
    }

-    bool TouchCullMode() {
-        return Exchange(Dirty::CullMode, false);
-    }
-
-    bool TouchDepthBoundsTestEnable() {
-        return Exchange(Dirty::DepthBoundsEnable, false);
-    }
-
-    bool TouchDepthTestEnable() {
-        return Exchange(Dirty::DepthTestEnable, false);
-    }
-
-    bool TouchDepthBoundsEnable() {
-        return Exchange(Dirty::DepthBoundsEnable, false);
-    }
-
-    bool TouchDepthWriteEnable() {
-        return Exchange(Dirty::DepthWriteEnable, false);
-    }
-
-    bool TouchDepthCompareOp() {
-        return Exchange(Dirty::DepthCompareOp, false);
-    }
-
-    bool TouchFrontFace() {
-        return Exchange(Dirty::FrontFace, false);
-    }
-
-    bool TouchPrimitiveTopology() {
-        return Exchange(Dirty::PrimitiveTopology, false);
-    }
-
-    bool TouchStencilOp() {
-        return Exchange(Dirty::StencilOp, false);
-    }
-
-    bool TouchStencilTestEnable() {
-        return Exchange(Dirty::StencilTestEnable, false);
-    }
-
 private:
    bool Exchange(std::size_t id, bool new_value) const noexcept {
        auto& flags = system.GPU().Maxwell3D().dirty.flags;
--- a/Show More
+++ b/Show More