"Merge Tagged PR 1012"

"Merge Tagged PR 1340"
"Merge Tagged PR 1703"
2020-05-04 12:01:20 +00:00 · 2020-05-04 12:01:19 +00:00 · 2020-05-04 12:01:19 +00:00 · 2020-05-04 12:01:17 +00:00 · 2020-05-04 12:01:16 +00:00 · 2020-05-04 12:01:16 +00:00
133 changed files with 18285 additions and 1808 deletions
@@ -1,7 +1,4 @@
 #!/bin/bash -ex

 chmod a+x ./.ci/scripts/format/docker.sh
-# the UID for the container yuzu user is 1027
-sudo chown -R 1027 ./
 docker run -v $(pwd):/yuzu yuzuemu/build-environments:linux-clang-format /bin/bash -ex /yuzu/.ci/scripts/format/docker.sh
-sudo chown -R $UID ./
@@ -2,7 +2,4 @@

 mkdir -p "ccache"  || true
 chmod a+x ./.ci/scripts/linux/docker.sh
-# the UID for the container yuzu user is 1027
-sudo chown -R 1027 ./
 docker run -e ENABLE_COMPATIBILITY_REPORTING -e CCACHE_DIR=/yuzu/ccache -v $(pwd):/yuzu yuzuemu/build-environments:linux-fresh /bin/bash /yuzu/.ci/scripts/linux/docker.sh $1
-sudo chown -R $UID ./
@@ -4,10 +4,22 @@ cd /yuzu

 ccache -s

+# Dirty hack to trick unicorn makefile into believing we are in a MINGW system
+mv /bin/uname /bin/uname1 && echo -e '#!/bin/sh\necho MINGW64' >> /bin/uname
+chmod +x /bin/uname
+
+# Dirty hack to trick unicorn makefile into believing we have cmd
+echo '' >> /bin/cmd
+chmod +x /bin/cmd
+
 mkdir build || true && cd build
 cmake .. -G Ninja -DDISPLAY_VERSION=$1 -DCMAKE_TOOLCHAIN_FILE="$(pwd)/../CMakeModules/MinGWCross.cmake" -DUSE_CCACHE=ON -DYUZU_USE_BUNDLED_UNICORN=ON -DENABLE_COMPATIBILITY_LIST_DOWNLOAD=ON -DCMAKE_BUILD_TYPE=Release
 ninja

+# Clean up the dirty hacks
+rm /bin/uname && mv /bin/uname1 /bin/uname
+rm /bin/cmd
+
 ccache -s

 echo "Tests skipped"
@@ -2,7 +2,4 @@

 mkdir -p "ccache" || true
 chmod a+x ./.ci/scripts/windows/docker.sh
-# the UID for the container yuzu user is 1027
-sudo chown -R 1027 ./
 docker run -e CCACHE_DIR=/yuzu/ccache -v $(pwd):/yuzu yuzuemu/build-environments:linux-mingw /bin/bash -ex /yuzu/.ci/scripts/windows/docker.sh $1
-sudo chown -R $UID ./
@@ -4,9 +4,7 @@ parameters:
  version: ''

 steps:
- script: python -m pip install --upgrade pip conan
-  displayName: 'Install conan'
- script: mkdir build && cd build && cmake -G "Visual Studio 16 2019" -A x64 --config Release -DYUZU_USE_BUNDLED_QT=1 -DYUZU_USE_BUNDLED_UNICORN=1 -DYUZU_USE_QT_WEB_ENGINE=ON -DENABLE_COMPATIBILITY_LIST_DOWNLOAD=ON -DYUZU_ENABLE_COMPATIBILITY_REPORTING=${COMPAT} -DUSE_DISCORD_PRESENCE=ON -DDISPLAY_VERSION=${{ parameters['version'] }} .. && cd ..
+- script: mkdir build && cd build && cmake -G "Visual Studio 16 2019" -A x64 --config Release -DYUZU_USE_BUNDLED_QT=1 -DYUZU_USE_BUNDLED_SDL2=1 -DYUZU_USE_BUNDLED_UNICORN=1 -DYUZU_USE_QT_WEB_ENGINE=ON -DENABLE_COMPATIBILITY_LIST_DOWNLOAD=ON -DYUZU_ENABLE_COMPATIBILITY_REPORTING=${COMPAT} -DUSE_DISCORD_PRESENCE=ON -DDISPLAY_VERSION=${{ parameters['version'] }} .. && cd ..
  displayName: 'Configure CMake'
 - task: MSBuild@1
  displayName: 'Build'
@@ -5,7 +5,18 @@ variables:
  DisplayVersion: $[counter(variables['DisplayPrefix'], 1)]

 stages:
+- stage: format
+  displayName: 'format'
+  jobs:
+  - job: format
+    displayName: 'clang'
+    continueOnError: true
+    pool:
+      vmImage: ubuntu-latest
+    steps:
+    - template: ./templates/format-check.yml
 - stage: build
+  dependsOn: format
  displayName: 'build'
  jobs:
  - job: build
@@ -1,30 +1,54 @@
 [submodule "inih"]
    path = externals/inih/inih
    url = https://github.com/svn2github/inih
+[submodule "boost"]
+    path = externals/boost
+    url = https://github.com/yuzu-emu/ext-boost.git
+[submodule "catch"]
+    path = externals/catch
+    url = https://github.com/philsquared/Catch.git
 [submodule "cubeb"]
    path = externals/cubeb
    url = https://github.com/kinetiknz/cubeb.git
 [submodule "dynarmic"]
    path = externals/dynarmic
    url = https://github.com/MerryMage/dynarmic.git
+[submodule "fmt"]
+    path = externals/fmt
+    url = https://github.com/fmtlib/fmt.git
+[submodule "lz4"]
+    path = externals/lz4
+    url = https://github.com/lz4/lz4.git
 [submodule "unicorn"]
    path = externals/unicorn
    url = https://github.com/yuzu-emu/unicorn
+[submodule "mbedtls"]
+    path = externals/mbedtls
+    url = https://github.com/DarkLordZach/mbedtls
+[submodule "opus"]
+    path = externals/opus/opus
+    url = https://github.com/xiph/opus.git
 [submodule "soundtouch"]
    path = externals/soundtouch
    url = https://github.com/citra-emu/ext-soundtouch.git
+[submodule "libressl"]
+    path = externals/libressl
+    url = https://github.com/citra-emu/ext-libressl-portable.git
 [submodule "discord-rpc"]
    path = externals/discord-rpc
    url = https://github.com/discordapp/discord-rpc.git
 [submodule "Vulkan-Headers"]
    path = externals/Vulkan-Headers
    url = https://github.com/KhronosGroup/Vulkan-Headers.git
+[submodule "externals/zstd"]
+    path = externals/zstd
+    url = https://github.com/facebook/zstd
 [submodule "sirit"]
    path = externals/sirit
    url = https://github.com/ReinUsesLisp/sirit
-[submodule "mbedtls"]
-    path = externals/mbedtls
-    url = https://github.com/DarkLordZach/mbedtls
 [submodule "libzip"]
    path = externals/libzip/libzip
    url = https://github.com/nih-at/libzip.git
+[submodule "zlib"]
+    path = externals/zlib/zlib
+    url = https://github.com/madler/zlib.git
@@ -1,8 +1,7 @@
-cmake_minimum_required(VERSION 3.11)
+cmake_minimum_required(VERSION 3.7)

 list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/CMakeModules")
 list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/externals/cmake-modules")
-list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/externals/find-modules")
 include(DownloadExternals)
 include(CMakeDependentOption)

@@ -11,9 +10,10 @@ project(yuzu)
 # Set bundled sdl2/qt as dependent options.
 # OFF by default, but if ENABLE_SDL2 and MSVC are true then ON
 option(ENABLE_SDL2 "Enable the SDL2 frontend" ON)
+CMAKE_DEPENDENT_OPTION(YUZU_USE_BUNDLED_SDL2 "Download bundled SDL2 binaries" ON "ENABLE_SDL2;MSVC" OFF)

 option(ENABLE_QT "Enable the Qt frontend" ON)
-CMAKE_DEPENDENT_OPTION(YUZU_USE_BUNDLED_QT "Download bundled Qt binaries" OFF "ENABLE_QT;MSVC" OFF)
+CMAKE_DEPENDENT_OPTION(YUZU_USE_BUNDLED_QT "Download bundled Qt binaries" ON "ENABLE_QT;MSVC" OFF)

 option(ENABLE_WEB_SERVICE "Enable web services (telemetry, etc.)" ON)

@@ -29,13 +29,6 @@ option(ENABLE_VULKAN "Enables Vulkan backend" ON)

 option(USE_DISCORD_PRESENCE "Enables Discord Rich Presence" OFF)

-# Default to a Release build
-get_property(IS_MULTI_CONFIG GLOBAL PROPERTY GENERATOR_IS_MULTI_CONFIG)
-if (NOT IS_MULTI_CONFIG AND NOT CMAKE_BUILD_TYPE)
-    set(CMAKE_BUILD_TYPE "Release" CACHE STRING "Choose the type of build, options are: Debug Release RelWithDebInfo MinSizeRel." FORCE)
-    message(STATUS "Defaulting to a Release build")
-endif()
-
 if(EXISTS ${PROJECT_SOURCE_DIR}/hooks/pre-commit AND NOT EXISTS ${PROJECT_SOURCE_DIR}/.git/hooks/pre-commit)
    message(STATUS "Copying pre-commit hook")
    file(COPY hooks/pre-commit
@@ -60,6 +53,7 @@ endfunction()
 if(EXISTS ${PROJECT_SOURCE_DIR}/.gitmodules)
    check_submodules_present()
 endif()
+
 configure_file(${PROJECT_SOURCE_DIR}/dist/compatibility_list/compatibility_list.qrc
               ${PROJECT_BINARY_DIR}/dist/compatibility_list/compatibility_list.qrc
               COPYONLY)
@@ -121,227 +115,63 @@ message(STATUS "Target architecture: ${ARCHITECTURE}")
 set(CMAKE_CXX_STANDARD 17)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)

+# System imported libraries
+# ======================
+
+find_package(Boost 1.66.0 QUIET)
+if (NOT Boost_FOUND)
+    message(STATUS "Boost 1.66.0 or newer not found, falling back to externals")
+
+    set(BOOST_ROOT "${PROJECT_SOURCE_DIR}/externals/boost")
+    set(Boost_NO_SYSTEM_PATHS OFF)
+    find_package(Boost QUIET REQUIRED)
+endif()
+
 # Output binaries to bin/
 set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${PROJECT_BINARY_DIR}/bin)

-# System imported libraries
-# If not found, download any missing through Conan
-# =======================================================================
-set(CONAN_CMAKE_SILENT_OUTPUT TRUE)
-set(CMAKE_FIND_PACKAGE_PREFER_CONFIG TRUE)
-if (YUZU_CONAN_INSTALLED)
-    if (IS_MULTI_CONFIG)
-        include(${CMAKE_BINARY_DIR}/conanbuildinfo_multi.cmake)
-    else()
-        include(${CMAKE_BINARY_DIR}/conanbuildinfo.cmake)
-    endif()
-    list(APPEND CMAKE_MODULE_PATH "${CMAKE_BINARY_DIR}")
-    list(APPEND CMAKE_PREFIX_PATH "${CMAKE_BINARY_DIR}")
-    conan_basic_setup()
-    message(STATUS "Adding conan installed libraries to the search path")
-endif()
-
-macro(yuzu_find_packages)
-    set(options FORCE_REQUIRED)
-    cmake_parse_arguments(FN "${options}" "" "" ${ARGN})
-
-    # Cmake has a *serious* lack of 2D array or associative array...
-    # Capitalization matters here. We need the naming to match the generated paths from Conan
-    set(REQUIRED_LIBS
-    #    Cmake Pkg Prefix  Version     Conan Pkg
-        "Boost             1.71        boost/1.72.0"
-        "Catch2            2.11        catch2/2.11.0"
-        "fmt               6.2         fmt/6.2.0"
-        "OpenSSL           1.1         openssl/1.1.1f"
-    # 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"
-    )
-
-    foreach(PACKAGE ${REQUIRED_LIBS})
-        string(REGEX REPLACE "[ \t\r\n]+" ";" PACKAGE_SPLIT ${PACKAGE})
-        list(GET PACKAGE_SPLIT 0 PACKAGE_PREFIX)
-        list(GET PACKAGE_SPLIT 1 PACKAGE_VERSION)
-        list(GET PACKAGE_SPLIT 2 PACKAGE_CONAN)
-        # This function is called twice, once to check if the packages exist on the system already
-        # and a second time to check if conan installed them properly. The second check passes in FORCE_REQUIRED
-        if (NOT ${PACKAGE_PREFIX}_FOUND)
-            if (FN_FORCE_REQUIRED)
-                find_package(${PACKAGE_PREFIX} ${PACKAGE_VERSION} REQUIRED)
-            else()
-                find_package(${PACKAGE_PREFIX} ${PACKAGE_VERSION})
-            endif()
-        endif()
-        if (NOT ${PACKAGE_PREFIX}_FOUND)
-            list(APPEND CONAN_REQUIRED_LIBS ${PACKAGE_CONAN})
-        else()
-            # Set a legacy findPackage.cmake style PACKAGE_LIBRARIES variable for subprojects that rely on this
-            set(${PACKAGE_PREFIX}_LIBRARIES "${PACKAGE_PREFIX}::${PACKAGE_PREFIX}")
-        endif()
-    endforeach()
-    unset(FN_FORCE_REQUIRED)
-endmacro()
-
-# Attempt to locate any packages that are required and report the missing ones in CONAN_REQUIRED_LIBS
-yuzu_find_packages()
-
-# Qt5 requires that we find components, so it doesn't fit our pretty little find package function
-if(ENABLE_QT)
-    # We want to load the generated conan qt config so that we get the QT_ROOT var so that we can use the official
-    # Qt5Config inside the root folder instead of the conan generated one.
-    if(EXISTS ${CMAKE_BINARY_DIR}/qtConfig.cmake)
-        include(${CMAKE_BINARY_DIR}/qtConfig.cmake)
-        list(APPEND CMAKE_MODULE_PATH "${CONAN_QT_ROOT_RELEASE}")
-        list(APPEND CMAKE_PREFIX_PATH "${CONAN_QT_ROOT_RELEASE}")
-    endif()
-    # Workaround for an issue where conan tries to build Qt from scratch instead of download prebuilt binaries
-    set(QT_PREFIX_HINT)
-    if(YUZU_USE_BUNDLED_QT)
-        if ((MSVC_VERSION GREATER_EQUAL 1910 AND MSVC_VERSION LESS 1930) AND ARCHITECTURE_x86_64)
-            set(QT_VER qt-5.12.0-msvc2017_64)
-        else()
-            message(FATAL_ERROR "No bundled Qt binaries for your toolchain. Disable YUZU_USE_BUNDLED_QT and provide your own.")
-        endif()
-
-        if (DEFINED QT_VER)
-            download_bundled_external("qt/" ${QT_VER} QT_PREFIX)
-        endif()
-
-        set(QT_PREFIX_HINT HINTS "${QT_PREFIX}")
-    endif()
-    find_package(Qt5 5.9 COMPONENTS Widgets OpenGL ${QT_PREFIX_HINT})
-    if (NOT Qt5_FOUND)
-        list(APPEND CONAN_REQUIRED_LIBS "qt/5.14.1@bincrafters/stable")
-    endif()
-endif()
-# find SDL2 exports a bunch of variables that are needed, so its easier to do this outside of the yuzu_find_package
-if(ENABLE_SDL2)
-    if(EXISTS ${CMAKE_BINARY_DIR}/sdl2Config.cmake)
-        include(${CMAKE_BINARY_DIR}/sdl2Config.cmake)
-        list(APPEND CMAKE_MODULE_PATH "${CONAN_SDL2_ROOT_RELEASE}")
-        list(APPEND CMAKE_PREFIX_PATH "${CONAN_SDL2_ROOT_RELEASE}")
-    endif()
-    find_package(SDL2)
-    if (NOT SDL2_FOUND)
-        # otherwise add this to the list of libraries to install
-        list(APPEND CONAN_REQUIRED_LIBS "sdl2/2.0.12@bincrafters/stable")
-    endif()
-endif()
-
-# Install any missing dependencies with conan install
-if (CONAN_REQUIRED_LIBS)
-    message(STATUS "Packages ${CONAN_REQUIRED_LIBS} not found!")
-    # Use Conan to fetch the libraries that aren't found
-    # Download conan.cmake automatically, you can also just copy the conan.cmake file
-    if(NOT EXISTS "${CMAKE_BINARY_DIR}/conan.cmake")
-        message(STATUS "Downloading conan.cmake from https://github.com/conan-io/cmake-conan")
-        file(DOWNLOAD "https://github.com/conan-io/cmake-conan/raw/v0.15/conan.cmake"
-                        "${CMAKE_BINARY_DIR}/conan.cmake")
-    endif()
-    include(${CMAKE_BINARY_DIR}/conan.cmake)
-
-    set(CONAN_LIB_OPTIONS
-        libzip:with_openssl=False
-        libzip:enable_windows_crypto=False
-    )
-    conan_check(VERSION 1.24.0 REQUIRED)
-    # Add the bincrafters remote
-    conan_add_remote(NAME bincrafters
-                    URL https://api.bintray.com/conan/bincrafters/public-conan)
-
-    # Manually add iconv to fix a dep conflict between qt and sdl2
-    # We don't need to add it through find_package or anything since the other two can find it just fine
-    if ("${CONAN_REQUIRED_LIBS}" MATCHES "qt" AND "${CONAN_REQUIRED_LIBS}" MATCHES "sdl")
-        list(APPEND CONAN_REQUIRED_LIBS "libiconv/1.16")
-    endif()
-    if (IS_MULTI_CONFIG)
-        conan_cmake_run(REQUIRES ${CONAN_REQUIRED_LIBS}
-                        OPTIONS ${CONAN_LIB_OPTIONS}
-                        BUILD missing
-                        CONFIGURATION_TYPES "Release;Debug"
-                        GENERATORS cmake_multi cmake_find_package_multi)
-        include(${CMAKE_BINARY_DIR}/conanbuildinfo_multi.cmake)
-    else()
-        conan_cmake_run(REQUIRES ${CONAN_REQUIRED_LIBS}
-                        OPTIONS ${CONAN_LIB_OPTIONS}
-                        BUILD missing
-                        GENERATORS cmake cmake_find_package_multi)
-        include(${CMAKE_BINARY_DIR}/conanbuildinfo.cmake)
-    endif()
-    list(APPEND CMAKE_MODULE_PATH "${CMAKE_BINARY_DIR}")
-    list(APPEND CMAKE_PREFIX_PATH "${CMAKE_BINARY_DIR}")
-    conan_basic_setup()
-
-    set(YUZU_CONAN_INSTALLED TRUE CACHE BOOL "If true, the following builds will add conan to the lib search path" FORCE)
-
-    # Now that we've installed what we are missing, try to locate them again,
-    # this time with required, so we bail if its not found.
-    yuzu_find_packages(FORCE_REQUIRED)
-
-    # Due to issues with variable scopes in functions, we need to also find_package(qt5) outside of the function
-    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 OpenGL)
-        if (YUZU_USE_QT_WEB_ENGINE)
-            find_package(Qt5 REQUIRED COMPONENTS WebEngineCore WebEngineWidgets)
-        endif()
-    endif()
-    if(ENABLE_SDL2)
-        list(APPEND CMAKE_MODULE_PATH "${CONAN_SDL2_ROOT_RELEASE}")
-        list(APPEND CMAKE_PREFIX_PATH "${CONAN_SDL2_ROOT_RELEASE}")
-        find_package(SDL2 REQUIRED)
-    endif()
-
-endif()
-
-# Reexport some targets that are named differently when using the upstream CmakeConfig vs the generated Conan config
-# In order to ALIAS targets to a new name, they first need to be IMPORTED_GLOBAL
-# Dynarmic checks for target `boost` and so we want to make sure it can find it through our system instead of using their external
-if (TARGET Boost::Boost)
-    set_target_properties(Boost::Boost PROPERTIES IMPORTED_GLOBAL TRUE)
-    add_library(Boost::boost ALIAS Boost::Boost)
-    add_library(boost ALIAS Boost::Boost)
-elseif (TARGET Boost::boost)
-    set_target_properties(Boost::boost PROPERTIES IMPORTED_GLOBAL TRUE)
-    add_library(boost ALIAS Boost::boost)
-endif()
-
-if (NOT TARGET OpenSSL::SSL)
-    set_target_properties(OpenSSL::OpenSSL PROPERTIES IMPORTED_GLOBAL TRUE)
-    add_library(OpenSSL::SSL ALIAS OpenSSL::OpenSSL)
-endif()
-if (NOT TARGET OpenSSL::Crypto)
-    set_target_properties(OpenSSL::OpenSSL PROPERTIES IMPORTED_GLOBAL TRUE)
-    add_library(OpenSSL::Crypto ALIAS OpenSSL::OpenSSL)
-endif()
-
-if (TARGET sdl2::sdl2)
-    # imported from the conan generated sdl2Config.cmake
-    set_target_properties(sdl2::sdl2 PROPERTIES IMPORTED_GLOBAL TRUE)
-    add_library(SDL2 ALIAS sdl2::sdl2)
-elseif(SDL2_FOUND)
-    # found through the system package manager
-    # Some installations don't set SDL2_LIBRARIES
-    if("${SDL2_LIBRARIES}" STREQUAL "")
-        message(WARNING "SDL2_LIBRARIES wasn't set, manually setting to SDL2::SDL2")
-        set(SDL2_LIBRARIES "SDL2::SDL2")
-    endif()
-
-    include_directories(SYSTEM ${SDL2_INCLUDE_DIRS})
-    add_library(SDL2 INTERFACE)
-    target_link_libraries(SDL2 INTERFACE "${SDL2_LIBRARIES}")
-endif()
-
 # Prefer the -pthread flag on Linux.
 set(THREADS_PREFER_PTHREAD_FLAG ON)
 find_package(Threads REQUIRED)

+if (ENABLE_SDL2)
+    if (YUZU_USE_BUNDLED_SDL2)
+        # Detect toolchain and platform
+        if ((MSVC_VERSION GREATER_EQUAL 1910 AND MSVC_VERSION LESS 1930) AND ARCHITECTURE_x86_64)
+            set(SDL2_VER "SDL2-2.0.8")
+        else()
+            message(FATAL_ERROR "No bundled SDL2 binaries for your toolchain. Disable YUZU_USE_BUNDLED_SDL2 and provide your own.")
+        endif()
+
+        if (DEFINED SDL2_VER)
+            download_bundled_external("sdl2/" ${SDL2_VER} SDL2_PREFIX)
+        endif()
+
+        set(SDL2_FOUND YES)
+        set(SDL2_INCLUDE_DIR "${SDL2_PREFIX}/include" CACHE PATH "Path to SDL2 headers")
+        set(SDL2_LIBRARY "${SDL2_PREFIX}/lib/x64/SDL2.lib" CACHE PATH "Path to SDL2 library")
+        set(SDL2_DLL_DIR "${SDL2_PREFIX}/lib/x64/" CACHE PATH "Path to SDL2.dll")
+
+        add_library(SDL2 INTERFACE)
+        target_link_libraries(SDL2 INTERFACE "${SDL2_LIBRARY}")
+        target_include_directories(SDL2 INTERFACE "${SDL2_INCLUDE_DIR}")
+    else()
+        find_package(SDL2 REQUIRED)
+
+        # Some installations don't set SDL2_LIBRARIES
+        if("${SDL2_LIBRARIES}" STREQUAL "")
+            message(WARNING "SDL2_LIBRARIES wasn't set, manually setting to SDL2::SDL2")
+            set(SDL2_LIBRARIES "SDL2::SDL2")
+        endif()
+
+        include_directories(SYSTEM ${SDL2_INCLUDE_DIRS})
+        add_library(SDL2 INTERFACE)
+        target_link_libraries(SDL2 INTERFACE "${SDL2_LIBRARIES}")
+    endif()
+else()
+    set(SDL2_FOUND NO)
+endif()
+
 # If unicorn isn't found, msvc -> download bundled unicorn; everyone else -> build external
 if (YUZU_USE_BUNDLED_UNICORN)
    if (MSVC)
@@ -382,12 +212,8 @@ if (YUZU_USE_BUNDLED_UNICORN)
        find_package(PythonInterp 2.7 REQUIRED)

        if (MINGW)
-            # Intentionally call the unicorn makefile directly instead of using make.sh so that we can override the
-            # UNAME_S makefile variable to MINGW. This way we don't have to hack at the uname binary to build
-            # Additionally, overriding DO_WINDOWS_EXPORT prevents unicorn from patching the static unicorn.a by using msvc and cmd,
-            # which are both things we don't have in a mingw cross compiling environment.
            add_custom_command(OUTPUT ${LIBUNICORN_LIBRARY}
-                COMMAND ${CMAKE_COMMAND} -E env UNICORN_ARCHS="aarch64" PYTHON="${PYTHON_EXECUTABLE}" CC=x86_64-w64-mingw32-gcc AR=x86_64-w64-mingw32-gcc-ar RANLIB=x86_64-w64-mingw32-gcc-ranlib make UNAME_S=MINGW DO_WINDOWS_EXPORT=0
+                COMMAND ${CMAKE_COMMAND} -E env UNICORN_ARCHS="aarch64" PYTHON="${PYTHON_EXECUTABLE}" /bin/sh make.sh cross-win64
                WORKING_DIRECTORY ${UNICORN_PREFIX}
            )
        else()
@@ -417,6 +243,32 @@ else()
    message(FATAL_ERROR "Could not find or build unicorn which is required.")
 endif()

+if (ENABLE_QT)
+    if (YUZU_USE_BUNDLED_QT)
+        if ((MSVC_VERSION GREATER_EQUAL 1910 AND MSVC_VERSION LESS 1930) AND ARCHITECTURE_x86_64)
+            set(QT_VER qt-5.12.0-msvc2017_64)
+        else()
+            message(FATAL_ERROR "No bundled Qt binaries for your toolchain. Disable YUZU_USE_BUNDLED_QT and provide your own.")
+        endif()
+
+        if (DEFINED QT_VER)
+            download_bundled_external("qt/" ${QT_VER} QT_PREFIX)
+        endif()
+
+        set(QT_PREFIX_HINT HINTS "${QT_PREFIX}")
+    else()
+        # Passing an empty HINTS seems to cause default system paths to get ignored in CMake 2.8 so
+        # make sure to not pass anything if we don't have one.
+        set(QT_PREFIX_HINT)
+    endif()
+
+    find_package(Qt5 REQUIRED COMPONENTS Widgets OpenGL ${QT_PREFIX_HINT})
+
+    if (YUZU_USE_QT_WEB_ENGINE)
+        find_package(Qt5 REQUIRED COMPONENTS WebEngineCore WebEngineWidgets ${QT_PREFIX_HINT})
+    endif ()
+endif()
+
 # Platform-specific library requirements
 # ======================================

@@ -447,7 +299,7 @@ find_program(CLANG_FORMAT
    PATHS ${PROJECT_BINARY_DIR}/externals)
 # if find_program doesn't find it, try to download from externals
 if (NOT CLANG_FORMAT)
-    if (WIN32 AND NOT CMAKE_CROSSCOMPILING)
+    if (WIN32)
        message(STATUS "Clang format not found! Downloading...")
        set(CLANG_FORMAT "${PROJECT_BINARY_DIR}/externals/clang-format${CLANG_FORMAT_POSTFIX}.exe")
        file(DOWNLOAD
@@ -1,13 +1,30 @@
 # Definitions for all external bundled libraries

-list(APPEND CMAKE_MODULE_PATH "${PROJECT_SOURCE_DIR}/CMakeModules")
-list(APPEND CMAKE_MODULE_PATH "${PROJECT_SOURCE_DIR}/externals/find-modules")
+set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} ${PROJECT_SOURCE_DIR}/CMakeModules)
 include(DownloadExternals)

+# pkgconfig -- it is used to find shared libraries without cmake modules on linux systems
+find_package(PkgConfig)
+if (NOT PkgConfig_FOUND)
+    function(pkg_check_modules)
+        # STUB
+    endfunction()
+endif()
+
 # Catch
 add_library(catch-single-include INTERFACE)
 target_include_directories(catch-single-include INTERFACE catch/single_include)

+# libfmt
+pkg_check_modules(FMT IMPORTED_TARGET GLOBAL fmt>=6.2.0)
+if (FMT_FOUND)
+    add_library(fmt::fmt ALIAS PkgConfig::FMT)
+else()
+    message(STATUS "fmt 6.2.0 or newer not found, falling back to externals")
+    add_subdirectory(fmt)
+    add_library(fmt::fmt ALIAS fmt)
+endif()
+
 # Dynarmic
 if (ARCHITECTURE_x86_64)
    set(DYNARMIC_TESTS OFF)
@@ -26,6 +43,17 @@ add_subdirectory(glad)
 # inih
 add_subdirectory(inih)

+# lz4
+pkg_check_modules(LIBLZ4 IMPORTED_TARGET GLOBAL liblz4>=1.8.0)
+if (LIBLZ4_FOUND)
+    add_library(lz4_static ALIAS PkgConfig::LIBLZ4)
+else()
+    message(STATUS "liblz4 1.8.0 or newer not found, falling back to externals")
+    set(LZ4_BUNDLED_MODE ON)
+    add_subdirectory(lz4/contrib/cmake_unofficial EXCLUDE_FROM_ALL)
+    target_include_directories(lz4_static INTERFACE ./lz4/lib)
+endif()
+
 # mbedtls
 add_subdirectory(mbedtls EXCLUDE_FROM_ALL)
 target_include_directories(mbedtls PUBLIC ./mbedtls/include)
@@ -38,9 +66,29 @@ target_include_directories(microprofile INTERFACE ./microprofile)
 add_library(unicorn-headers INTERFACE)
 target_include_directories(unicorn-headers INTERFACE ./unicorn/include)

+# Zstandard
+pkg_check_modules(LIBZSTD IMPORTED_TARGET GLOBAL libzstd>=1.3.8)
+if (LIBZSTD_FOUND)
+    add_library(libzstd_static ALIAS PkgConfig::LIBZSTD)
+else()
+    message(STATUS "libzstd 1.3.8 or newer not found, falling back to externals")
+    add_subdirectory(zstd/build/cmake EXCLUDE_FROM_ALL)
+    target_include_directories(libzstd_static INTERFACE ./zstd/lib)
+endif()
+
 # SoundTouch
 add_subdirectory(soundtouch)

+# Opus
+pkg_check_modules(OPUS IMPORTED_TARGET GLOBAL opus>=1.3.1)
+if (OPUS_FOUND)
+    add_library(opus ALIAS PkgConfig::OPUS)
+else()
+    message(STATUS "opus 1.3.1 or newer not found, falling back to externals")
+    add_subdirectory(opus)
+    target_include_directories(opus INTERFACE ./opus/include)
+endif()
+
 # Cubeb
 if(ENABLE_CUBEB)
    set(BUILD_TESTS OFF CACHE BOOL "")
@@ -58,14 +106,37 @@ if (ENABLE_VULKAN)
    add_subdirectory(sirit)
 endif()

+# zlib
+find_package(ZLIB 1.2.11)
+if (NOT ZLIB_FOUND)
+    message(STATUS "zlib 1.2.11 or newer not found, falling back to externals")
+    add_subdirectory(zlib EXCLUDE_FROM_ALL)
+    set(ZLIB_LIBRARIES z)
+endif()
+
 # libzip
-find_package(Libzip 1.5)
-if (NOT LIBZIP_FOUND)
-    message(STATUS "libzip 1.5 or newer not found, falling back to externals")
+pkg_check_modules(LIBZIP IMPORTED_TARGET GLOBAL libzip>=1.5.3)
+if (LIBZIP_FOUND)
+    add_library(zip ALIAS PkgConfig::LIBZIP)
+else()
+    message(STATUS "libzip 1.5.3 or newer not found, falling back to externals")
    add_subdirectory(libzip EXCLUDE_FROM_ALL)
 endif()

 if (ENABLE_WEB_SERVICE)
+    # LibreSSL
+    find_package(OpenSSL COMPONENTS Crypto SSL)
+    if (NOT OpenSSL_FOUND)
+        message(STATUS "OpenSSL not found, falling back to externals")
+        set(LIBRESSL_SKIP_INSTALL ON CACHE BOOL "")
+        add_subdirectory(libressl EXCLUDE_FROM_ALL)
+        target_include_directories(ssl INTERFACE ./libressl/include)
+        target_compile_definitions(ssl PRIVATE -DHAVE_INET_NTOP)
+        get_directory_property(OPENSSL_LIBRARIES
+            DIRECTORY libressl
+            DEFINITION OPENSSL_LIBS)
+    endif()
+
    # lurlparser
    add_subdirectory(lurlparser EXCLUDE_FROM_ALL)

@@ -73,5 +144,9 @@ if (ENABLE_WEB_SERVICE)
    add_library(httplib INTERFACE)
    target_include_directories(httplib INTERFACE ./httplib)
    target_compile_definitions(httplib INTERFACE -DCPPHTTPLIB_OPENSSL_SUPPORT)
-    target_link_libraries(httplib INTERFACE OpenSSL::SSL OpenSSL::Crypto)
+    target_link_libraries(httplib INTERFACE ${OPENSSL_LIBRARIES})
+
+    # JSON
+    add_library(json-headers INTERFACE)
+    target_include_directories(json-headers INTERFACE ./json)
 endif()
@@ -1,49 +0,0 @@
-
-find_package(PkgConfig QUIET)
-pkg_check_modules(PC_Catch2 QUIET Catch2)
-
-find_path(Catch2_INCLUDE_DIR
-  NAMES catch.hpp
-  PATHS ${PC_Catch2_INCLUDE_DIRS} ${CONAN_CATCH2_ROOT}
-  PATH_SUFFIXES catch2
-)
-
-if(Catch2_INCLUDE_DIR)
-  file(STRINGS "${Catch2_INCLUDE_DIR}/catch.hpp" _Catch2_version_lines
-    REGEX "#define[ \t]+CATCH_VERSION_(MAJOR|MINOR|PATCH)")
-  string(REGEX REPLACE ".*CATCH_VERSION_MAJOR +\([0-9]+\).*" "\\1" _Catch2_version_major "${_Catch2_version_lines}")
-  string(REGEX REPLACE ".*CATCH_VERSION_MINOR +\([0-9]+\).*" "\\1" _Catch2_version_minor "${_Catch2_version_lines}")
-  string(REGEX REPLACE ".*CATCH_VERSION_PATCH +\([0-9]+\).*" "\\1" _Catch2_version_patch "${_Catch2_version_lines}")
-  set(Catch2_VERSION "${_Catch2_version_major}.${_Catch2_version_minor}.${_Catch2_version_patch}")
-  unset(_Catch2_version_major)
-  unset(_Catch2_version_minor)
-  unset(_Catch2_version_patch)
-  unset(_Catch2_version_lines)
-endif()
-
-include(FindPackageHandleStandardArgs)
-find_package_handle_standard_args(Catch2
-  FOUND_VAR Catch2_FOUND
-  REQUIRED_VARS
-    Catch2_INCLUDE_DIR
-    Catch2_VERSION
-  VERSION_VAR Catch2_VERSION
-)
-
-if(Catch2_FOUND)
-  set(Catch2_INCLUDE_DIRS ${Catch2_INCLUDE_DIR})
-  set(Catch2_DEFINITIONS ${PC_Catch2_CFLAGS_OTHER})
-endif()
-
-if(Catch2_FOUND AND NOT TARGET Catch2::Catch2)
-  add_library(Catch2::Catch2 UNKNOWN IMPORTED)
-  set_target_properties(Catch2::Catch2 PROPERTIES
-    IMPORTED_LOCATION "${Catch2_LIBRARY}"
-    INTERFACE_COMPILE_OPTIONS "${PC_Catch2_CFLAGS_OTHER}"
-    INTERFACE_INCLUDE_DIRECTORIES "${Catch2_INCLUDE_DIR}"
-  )
-endif()
-
-mark_as_advanced(
-    Catch2_INCLUDE_DIR
-)
@@ -1,72 +0,0 @@
-
-find_package(PkgConfig QUIET)
-pkg_check_modules(PC_LIBZIP QUIET libzip)
-
-find_path(LIBZIP_INCLUDE_DIR
-  NAMES zip.h
-  PATHS ${PC_LIBZIP_INCLUDE_DIRS}
-  "$ENV{LIB_DIR}/include"
-  "$ENV{INCLUDE}"
-  /usr/local/include
-  /usr/include
-)
-find_path(LIBZIP_INCLUDE_DIR_ZIPCONF
-  NAMES zipconf.h
-  HINTS ${PC_LIBZIP_INCLUDE_DIRS}
-  "$ENV{LIB_DIR}/include"
-  "$ENV{LIB_DIR}/lib/libzip/include"
-  "$ENV{LIB}/lib/libzip/include"
-  /usr/local/lib/libzip/include
-  /usr/lib/libzip/include
-  /usr/local/include
-  /usr/include
-  "$ENV{INCLUDE}"
-)
-find_library(LIBZIP_LIBRARY
-  NAMES zip
-  PATHS ${PC_LIBZIP_LIBRARY_DIRS}
-  "$ENV{LIB_DIR}/lib" "$ENV{LIB}" /usr/local/lib /usr/lib
-)
-
-if (LIBZIP_INCLUDE_DIR_ZIPCONF)
-  FILE(READ "${LIBZIP_INCLUDE_DIR_ZIPCONF}/zipconf.h" _LIBZIP_VERSION_CONTENTS)
-  if (_LIBZIP_VERSION_CONTENTS)
-    STRING(REGEX REPLACE ".*#define LIBZIP_VERSION \"([0-9.]+)\".*" "\\1" LIBZIP_VERSION "${_LIBZIP_VERSION_CONTENTS}")
-  endif()
-  unset(_LIBZIP_VERSION_CONTENTS)
-endif()
-
-set(LIBZIP_VERSION ${LIBZIP_VERSION} CACHE STRING "Version number of libzip")
-
-include(FindPackageHandleStandardArgs)
-find_package_handle_standard_args(Libzip
-  FOUND_VAR LIBZIP_FOUND
-  REQUIRED_VARS
-    LIBZIP_LIBRARY
-    LIBZIP_INCLUDE_DIR
-    LIBZIP_INCLUDE_DIR_ZIPCONF
-    LIBZIP_VERSION
-  VERSION_VAR LIBZIP_VERSION
-)
-
-if(LIBZIP_FOUND)
-  set(LIBZIP_LIBRARIES ${LIBZIP_LIBRARY})
-  set(LIBZIP_INCLUDE_DIRS ${LIBZIP_INCLUDE_DIR})
-  set(LIBZIP_DEFINITIONS ${PC_LIBZIP_CFLAGS_OTHER})
-endif()
-
-if(LIBZIP_FOUND AND NOT TARGET libzip::libzip)
-  add_library(libzip::libzip UNKNOWN IMPORTED)
-  set_target_properties(libzip::libzip PROPERTIES
-    IMPORTED_LOCATION "${LIBZIP_LIBRARY}"
-    INTERFACE_COMPILE_OPTIONS "${PC_LIBZIP_CFLAGS_OTHER}"
-    INTERFACE_INCLUDE_DIRECTORIES "${LIBZIP_INCLUDE_DIR}"
-  )
-endif()
-
-mark_as_advanced(
-    LIBZIP_INCLUDE_DIR
-    LIBZIP_INCLUDE_DIR_ZIPCONF
-    LIBZIP_LIBRARY
-    LIBZIP_VERSION
-)
@@ -1,69 +0,0 @@
-
-find_package(PkgConfig QUIET)
-pkg_check_modules(PC_fmt QUIET fmt)
-
-find_path(fmt_INCLUDE_DIR
-  NAMES format.h
-  PATHS ${PC_fmt_INCLUDE_DIRS} ${CONAN_INCLUDE_DIRS_fmt}
-  PATH_SUFFIXES fmt
-)
-
-find_library(fmt_LIBRARY
-  NAMES fmt
-  PATHS ${PC_fmt_LIBRARY_DIRS} ${CONAN_LIB_DIRS_fmt}
-)
-
-if(fmt_INCLUDE_DIR)
-  set(_fmt_version_file "${fmt_INCLUDE_DIR}/core.h")
-  if(NOT EXISTS "${_fmt_version_file}")
-    set(_fmt_version_file "${fmt_INCLUDE_DIR}/format.h")
-  endif()
-  if(EXISTS "${_fmt_version_file}")
-    # parse "#define FMT_VERSION 60200" to 6.2.0
-    file(STRINGS "${_fmt_version_file}" fmt_VERSION_LINE
-      REGEX "^#define[ \t]+FMT_VERSION[ \t]+[0-9]+$")
-    string(REGEX REPLACE "^#define[ \t]+FMT_VERSION[ \t]+([0-9]+)$"
-      "\\1" fmt_VERSION "${fmt_VERSION_LINE}")
-    foreach(ver "fmt_VERSION_PATCH" "fmt_VERSION_MINOR" "fmt_VERSION_MAJOR")
-      math(EXPR ${ver} "${fmt_VERSION} % 100")
-      math(EXPR fmt_VERSION "(${fmt_VERSION} - ${${ver}}) / 100")
-    endforeach()
-    set(fmt_VERSION
-      "${fmt_VERSION_MAJOR}.${fmt_VERSION_MINOR}.${fmt_VERSION_PATCH}")
-  endif()
-  unset(_fmt_version_file)
-  unset(fmt_VERSION_LINE)
-  unset(fmt_VERSION_MAJOR)
-  unset(fmt_VERSION_MINOR)
-  unset(fmt_VERSION_PATCH)
-endif()
-
-include(FindPackageHandleStandardArgs)
-find_package_handle_standard_args(fmt
-  FOUND_VAR fmt_FOUND
-  REQUIRED_VARS
-    fmt_LIBRARY
-    fmt_INCLUDE_DIR
-    fmt_VERSION
-  VERSION_VAR fmt_VERSION
-)
-
-if(fmt_FOUND)
-  set(fmt_LIBRARIES ${fmt_LIBRARY})
-  set(fmt_INCLUDE_DIRS ${fmt_INCLUDE_DIR})
-  set(fmt_DEFINITIONS ${PC_fmt_CFLAGS_OTHER})
-endif()
-
-if(fmt_FOUND AND NOT TARGET fmt::fmt)
-  add_library(fmt::fmt UNKNOWN IMPORTED)
-  set_target_properties(fmt::fmt PROPERTIES
-    IMPORTED_LOCATION "${fmt_LIBRARY}"
-    INTERFACE_COMPILE_OPTIONS "${PC_fmt_CFLAGS_OTHER}"
-    INTERFACE_INCLUDE_DIRECTORIES "${fmt_INCLUDE_DIR}"
-  )
-endif()
-
-mark_as_advanced(
-    fmt_INCLUDE_DIR
-    fmt_LIBRARY
-)
@@ -1,54 +0,0 @@
-
-find_package(PkgConfig QUIET)
-pkg_check_modules(PC_lz4 QUIET lz4)
-
-find_path(lz4_INCLUDE_DIR
-  NAMES lz4.h
-  PATHS ${PC_lz4_INCLUDE_DIRS}
-)
-find_library(lz4_LIBRARY
-  NAMES lz4
-  PATHS ${PC_lz4_LIBRARY_DIRS}
-)
-
-if(lz4_INCLUDE_DIR)
-  file(STRINGS "${lz4_INCLUDE_DIR}/lz4.h" _lz4_version_lines
-    REGEX "#define[ \t]+LZ4_VERSION_(MAJOR|MINOR|RELEASE)")
-  string(REGEX REPLACE ".*LZ4_VERSION_MAJOR *\([0-9]*\).*" "\\1" _lz4_version_major "${_lz4_version_lines}")
-  string(REGEX REPLACE ".*LZ4_VERSION_MINOR *\([0-9]*\).*" "\\1" _lz4_version_minor "${_lz4_version_lines}")
-  string(REGEX REPLACE ".*LZ4_VERSION_RELEASE *\([0-9]*\).*" "\\1" _lz4_version_release "${_lz4_version_lines}")
-  set(lz4_VERSION "${_lz4_version_major}.${_lz4_version_minor}.${_lz4_version_release}")
-  unset(_lz4_version_major)
-  unset(_lz4_version_minor)
-  unset(_lz4_version_release)
-  unset(_lz4_version_lines)
-endif()
-
-include(FindPackageHandleStandardArgs)
-find_package_handle_standard_args(lz4
-  FOUND_VAR lz4_FOUND
-  REQUIRED_VARS
-    lz4_LIBRARY
-    lz4_INCLUDE_DIR
-  VERSION_VAR lz4_VERSION
-)
-
-if(lz4_FOUND)
-  set(lz4_LIBRARIES ${lz4_LIBRARY})
-  set(lz4_INCLUDE_DIRS ${lz4_INCLUDE_DIR})
-  set(lz4_DEFINITIONS ${PC_lz4_CFLAGS_OTHER})
-endif()
-
-if(lz4_FOUND AND NOT TARGET lz4::lz4)
-  add_library(lz4::lz4 UNKNOWN IMPORTED)
-  set_target_properties(lz4::lz4 PROPERTIES
-    IMPORTED_LOCATION "${lz4_LIBRARY}"
-    INTERFACE_COMPILE_OPTIONS "${PC_lz4_CFLAGS_OTHER}"
-    INTERFACE_INCLUDE_DIRECTORIES "${lz4_INCLUDE_DIR}"
-  )
-endif()
-
-mark_as_advanced(
-    lz4_INCLUDE_DIR
-    lz4_LIBRARY
-)
@@ -1,49 +0,0 @@
-
-find_package(PkgConfig QUIET)
-pkg_check_modules(PC_nlohmann_json QUIET nlohmann_json)
-
-find_path(nlohmann_json_INCLUDE_DIR
-  NAMES json.hpp
-  PATHS ${PC_nlohmann_json_INCLUDE_DIRS}
-  PATH_SUFFIXES nlohmann
-)
-
-if(nlohmann_json_INCLUDE_DIR)
-  file(STRINGS "${nlohmann_json_INCLUDE_DIR}/json.hpp" _nlohmann_json_version_lines
-    REGEX "#define[ \t]+NLOHMANN_JSON_VERSION_(MAJOR|MINOR|PATCH)")
-  string(REGEX REPLACE ".*NLOHMANN_JSON_VERSION_MAJOR +\([0-9]+\).*" "\\1" _nlohmann_json_version_major "${_nlohmann_json_version_lines}")
-  string(REGEX REPLACE ".*NLOHMANN_JSON_VERSION_MINOR +\([0-9]+\).*" "\\1" _nlohmann_json_version_minor "${_nlohmann_json_version_lines}")
-  string(REGEX REPLACE ".*NLOHMANN_JSON_VERSION_PATCH +\([0-9]+\).*" "\\1" _nlohmann_json_version_patch "${_nlohmann_json_version_lines}")
-  set(nlohmann_json_VERSION "${_nlohmann_json_version_major}.${_nlohmann_json_version_minor}.${_nlohmann_json_version_patch}")
-  unset(_nlohmann_json_version_major)
-  unset(_nlohmann_json_version_minor)
-  unset(_nlohmann_json_version_patch)
-  unset(_nlohmann_json_version_lines)
-endif()
-
-include(FindPackageHandleStandardArgs)
-find_package_handle_standard_args(nlohmann_json
-  FOUND_VAR nlohmann_json_FOUND
-  REQUIRED_VARS
-    nlohmann_json_INCLUDE_DIR
-    nlohmann_json_VERSION
-  VERSION_VAR nlohmann_json_VERSION
-)
-
-if(nlohmann_json_FOUND)
-  set(nlohmann_json_INCLUDE_DIRS ${nlohmann_json_INCLUDE_DIR})
-  set(nlohmann_json_DEFINITIONS ${PC_nlohmann_json_CFLAGS_OTHER})
-endif()
-
-if(nlohmann_json_FOUND AND NOT TARGET nlohmann_json::nlohmann_json)
-  add_library(nlohmann_json::nlohmann_json UNKNOWN IMPORTED)
-  set_target_properties(nlohmann_json::nlohmann_json PROPERTIES
-    IMPORTED_LOCATION "${nlohmann_json_LIBRARY}"
-    INTERFACE_COMPILE_OPTIONS "${PC_nlohmann_json_CFLAGS_OTHER}"
-    INTERFACE_INCLUDE_DIRECTORIES "${nlohmann_json_INCLUDE_DIR}"
-  )
-endif()
-
-mark_as_advanced(
-    nlohmann_json_INCLUDE_DIR
-)
@@ -1,42 +0,0 @@
-
-find_package(PkgConfig QUIET)
-pkg_check_modules(PC_opus QUIET opus)
-
-find_path(opus_INCLUDE_DIR
-  NAMES opus.h
-  PATHS ${PC_opus_INCLUDE_DIRS}
-  PATH_SUFFIXES opus
-)
-find_library(opus_LIBRARY
-  NAMES opus
-  PATHS ${PC_opus_LIBRARY_DIRS}
-)
-
-include(FindPackageHandleStandardArgs)
-find_package_handle_standard_args(opus
-  FOUND_VAR opus_FOUND
-  REQUIRED_VARS
-    opus_LIBRARY
-    opus_INCLUDE_DIR
-  VERSION_VAR opus_VERSION
-)
-
-if(opus_FOUND)
-  set(Opus_LIBRARIES ${opus_LIBRARY})
-  set(Opus_INCLUDE_DIRS ${opus_INCLUDE_DIR})
-  set(Opus_DEFINITIONS ${PC_opus_CFLAGS_OTHER})
-endif()
-
-if(opus_FOUND AND NOT TARGET Opus::Opus)
-  add_library(Opus::Opus UNKNOWN IMPORTED)
-  set_target_properties(Opus::Opus PROPERTIES
-    IMPORTED_LOCATION "${opus_LIBRARY}"
-    INTERFACE_COMPILE_OPTIONS "${PC_opus_CFLAGS_OTHER}"
-    INTERFACE_INCLUDE_DIRECTORIES "${opus_INCLUDE_DIR}"
-  )
-endif()
-
-mark_as_advanced(
-    opus_INCLUDE_DIR
-    opus_LIBRARY
-)
@@ -1,55 +0,0 @@
-
-find_package(PkgConfig QUIET)
-pkg_check_modules(PC_zstd QUIET libzstd)
-
-find_path(zstd_INCLUDE_DIR
-  NAMES zstd.h
-  PATHS ${PC_zstd_INCLUDE_DIRS}
-)
-find_library(zstd_LIBRARY
-  NAMES zstd
-  PATHS ${PC_zstd_LIBRARY_DIRS}
-)
-
-if(zstd_INCLUDE_DIR)
-  file(STRINGS "${zstd_INCLUDE_DIR}/zstd.h" _zstd_version_lines
-    REGEX "#define[ \t]+ZSTD_VERSION_(MAJOR|MINOR|RELEASE)")
-  string(REGEX REPLACE ".*ZSTD_VERSION_MAJOR *\([0-9]*\).*" "\\1" _zstd_version_major "${_zstd_version_lines}")
-  string(REGEX REPLACE ".*ZSTD_VERSION_MINOR *\([0-9]*\).*" "\\1" _zstd_version_minor "${_zstd_version_lines}")
-  string(REGEX REPLACE ".*ZSTD_VERSION_RELEASE *\([0-9]*\).*" "\\1" _zstd_version_release "${_zstd_version_lines}")
-  set(zstd_VERSION "${_zstd_version_major}.${_zstd_version_minor}.${_zstd_version_release}")
-  unset(_zstd_version_major)
-  unset(_zstd_version_minor)
-  unset(_zstd_version_release)
-  unset(_zstd_version_lines)
-endif()
-
-include(FindPackageHandleStandardArgs)
-find_package_handle_standard_args(zstd
-  FOUND_VAR zstd_FOUND
-  REQUIRED_VARS
-    zstd_LIBRARY
-    zstd_INCLUDE_DIR
-    zstd_VERSION
-  VERSION_VAR zstd_VERSION
-)
-
-if(zstd_FOUND)
-  set(zstd_LIBRARIES ${zstd_LIBRARY})
-  set(zstd_INCLUDE_DIRS ${zstd_INCLUDE_DIR})
-  set(zstd_DEFINITIONS ${PC_zstd_CFLAGS_OTHER})
-endif()
-
-if(zstd_FOUND AND NOT TARGET zstd::zstd)
-  add_library(zstd::zstd UNKNOWN IMPORTED)
-  set_target_properties(zstd::zstd PROPERTIES
-    IMPORTED_LOCATION "${zstd_LIBRARY}"
-    INTERFACE_COMPILE_OPTIONS "${PC_zstd_CFLAGS_OTHER}"
-    INTERFACE_INCLUDE_DIRECTORIES "${zstd_INCLUDE_DIR}"
-  )
-endif()
-
-mark_as_advanced(
-    zstd_INCLUDE_DIR
-    zstd_LIBRARY
-)
@@ -0,0 +1,9 @@
+JSON for Modern C++
+===================
+
+v3.1.2
+
+This is a mirror providing the single required header file.
+
+The original repository can be found at:
+https://github.com/nlohmann/json/commit/d2dd27dc3b8472dbaa7d66f83619b3ebcd9185fe
@@ -0,0 +1,254 @@
+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
+)
@@ -0,0 +1,81 @@
+project(zlib C)
+
+include(CheckTypeSize)
+include(CheckFunctionExists)
+include(CheckIncludeFile)
+
+check_include_file(sys/types.h HAVE_SYS_TYPES_H)
+check_include_file(stdint.h    HAVE_STDINT_H)
+check_include_file(stddef.h    HAVE_STDDEF_H)
+
+# Check to see if we have large file support
+set(CMAKE_REQUIRED_DEFINITIONS -D_LARGEFILE64_SOURCE=1)
+# We add these other definitions here because CheckTypeSize.cmake
+# in CMake 2.4.x does not automatically do so and we want
+# compatibility with CMake 2.4.x.
+if(HAVE_SYS_TYPES_H)
+    list(APPEND CMAKE_REQUIRED_DEFINITIONS -DHAVE_SYS_TYPES_H)
+endif()
+if(HAVE_STDINT_H)
+    list(APPEND CMAKE_REQUIRED_DEFINITIONS -DHAVE_STDINT_H)
+endif()
+if(HAVE_STDDEF_H)
+    list(APPEND CMAKE_REQUIRED_DEFINITIONS -DHAVE_STDDEF_H)
+endif()
+check_type_size(off64_t OFF64_T)
+if(HAVE_OFF64_T)
+   add_definitions(-D_LARGEFILE64_SOURCE=1)
+endif()
+set(CMAKE_REQUIRED_DEFINITIONS) # clear variable
+
+# Check for fseeko
+check_function_exists(fseeko HAVE_FSEEKO)
+if(NOT HAVE_FSEEKO)
+    add_definitions(-DNO_FSEEKO)
+endif()
+
+# Check for unistd.h
+check_include_file(unistd.h HAVE_UNISTD_H)
+if(HAVE_UNISTD_H)
+    add_definitions(-DHAVE_UNISTD_H)
+endif()
+
+if(MSVC)
+    add_definitions(-D_CRT_SECURE_NO_DEPRECATE)
+    add_definitions(-D_CRT_NONSTDC_NO_DEPRECATE)
+endif()
+
+add_library(z STATIC
+    zlib/adler32.c
+    zlib/compress.c
+    zlib/crc32.c
+    zlib/crc32.h
+    zlib/deflate.c
+    zlib/deflate.h
+    zlib/gzclose.c
+    zlib/gzguts.h
+    zlib/gzlib.c
+    zlib/gzread.c
+    zlib/gzwrite.c
+    zlib/inffast.h
+    zlib/inffixed.h
+    zlib/inflate.c
+    zlib/inflate.h
+    zlib/infback.c
+    zlib/inftrees.c
+    zlib/inftrees.h
+    zlib/inffast.c
+    zlib/trees.c
+    zlib/trees.h
+    zlib/uncompr.c
+    zlib/zconf.h
+    zlib/zlib.h
+    zlib/zutil.c
+    zlib/zutil.h
+)
+add_library(ZLIB::ZLIB ALIAS z)
+
+target_include_directories(z
+PUBLIC
+    zlib/
+)
@@ -11,8 +11,10 @@
 #include "audio_core/stream.h"
 #include "common/assert.h"
 #include "common/logging/log.h"
+#include "core/core.h"
 #include "core/core_timing.h"
 #include "core/core_timing_util.h"
+#include "core/perf_stats.h"
 #include "core/settings.h"

 namespace AudioCore {
@@ -61,8 +63,11 @@ Stream::State Stream::GetState() const {

 s64 Stream::GetBufferReleaseCycles(const Buffer& buffer) const {
    const std::size_t num_samples{buffer.GetSamples().size() / GetNumChannels()};
-    const auto us =
-        std::chrono::microseconds((static_cast<u64>(num_samples) * 1000000) / sample_rate);
+    const double time_scale{Settings::values.enable_realtime_audio
+                                ? Core::System::GetInstance().GetPerfStats().GetLastFrameTimeScale()
+                                : 1.0f};
+    const auto us{std::chrono::microseconds(
+        (static_cast<u64>(num_samples) * static_cast<u64>(1000000 / time_scale)) / sample_rate)};
    return Core::Timing::usToCycles(us);
 }

@@ -148,8 +148,6 @@ add_library(common STATIC
    thread.h
    thread_queue_list.h
    threadsafe_queue.h
-    time_zone.cpp
-    time_zone.h
    timer.cpp
    timer.h
    uint128.cpp
@@ -174,5 +172,5 @@ endif()

 create_target_directory_groups(common)

-target_link_libraries(common PUBLIC Boost::boost fmt::fmt microprofile)
-target_link_libraries(common PRIVATE lz4::lz4 zstd::zstd)
+target_link_libraries(common PUBLIC Boost::boost fmt microprofile)
+target_link_libraries(common PRIVATE lz4_static libzstd_static)
@@ -1,49 +0,0 @@
-// Copyright 2020 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include <chrono>
-#include <iomanip>
-#include <sstream>
-
-#include "common/logging/log.h"
-#include "common/time_zone.h"
-
-namespace Common::TimeZone {
-
-std::string GetDefaultTimeZone() {
-    return "GMT";
-}
-
-static std::string GetOsTimeZoneOffset() {
-    const std::time_t t{std::time(nullptr)};
-    const std::tm tm{*std::localtime(&t)};
-
-    std::stringstream ss;
-    ss << std::put_time(&tm, "%z"); // Get the current timezone offset, e.g. "-400", as a string
-
-    return ss.str();
-}
-
-static int ConvertOsTimeZoneOffsetToInt(const std::string& timezone) {
-    try {
-        return std::stoi(timezone);
-    } catch (const std::invalid_argument&) {
-        LOG_CRITICAL(Common, "invalid_argument with {}!", timezone);
-        return 0;
-    } catch (const std::out_of_range&) {
-        LOG_CRITICAL(Common, "out_of_range with {}!", timezone);
-        return 0;
-    }
-}
-
-std::chrono::seconds GetCurrentOffsetSeconds() {
-    const int offset{ConvertOsTimeZoneOffsetToInt(GetOsTimeZoneOffset())};
-
-    int seconds{(offset / 100) * 60 * 60}; // Convert hour component to seconds
-    seconds += (offset % 100) * 60;        // Convert minute component to seconds
-
-    return std::chrono::seconds{seconds};
-}
-
-} // namespace Common::TimeZone
@@ -1,18 +0,0 @@
-// Copyright 2020 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <chrono>
-#include <string>
-
-namespace Common::TimeZone {
-
-/// Gets the default timezone, i.e. "GMT"
-std::string GetDefaultTimeZone();
-
-/// Gets the offset of the current timezone (from the default), in seconds
-std::chrono::seconds GetCurrentOffsetSeconds();
-
-} // namespace Common::TimeZone
@@ -606,11 +606,11 @@ 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::Opus unicorn)
+target_link_libraries(core PUBLIC Boost::boost PRIVATE fmt json-headers mbedtls opus unicorn)

 if (YUZU_ENABLE_BOXCAT)
    target_compile_definitions(core PRIVATE -DYUZU_ENABLE_BOXCAT)
-    target_link_libraries(core PRIVATE httplib nlohmann_json::nlohmann_json zip)
+    target_link_libraries(core PRIVATE httplib json-headers zip)
 endif()

 if (ENABLE_WEB_SERVICE)
@@ -12,17 +12,17 @@ namespace SystemVersionData {
 // This section should reflect the best system version to describe yuzu's HLE api.
 // TODO(DarkLordZach): Update when HLE gets better.

-constexpr u8 VERSION_MAJOR = 10;
-constexpr u8 VERSION_MINOR = 0;
-constexpr u8 VERSION_MICRO = 2;
+constexpr u8 VERSION_MAJOR = 5;
+constexpr u8 VERSION_MINOR = 1;
+constexpr u8 VERSION_MICRO = 0;

-constexpr u8 REVISION_MAJOR = 1;
+constexpr u8 REVISION_MAJOR = 3;
 constexpr u8 REVISION_MINOR = 0;

 constexpr char PLATFORM_STRING[] = "NX";
-constexpr char VERSION_HASH[] = "f90143fa8bbc061d4f68c35f95f04f8080c0ecdc";
-constexpr char DISPLAY_VERSION[] = "10.0.2";
-constexpr char DISPLAY_TITLE[] = "NintendoSDK Firmware for NX 10.0.2-1.0";
+constexpr char VERSION_HASH[] = "23f9df53e25709d756e0c76effcb2473bd3447dd";
+constexpr char DISPLAY_VERSION[] = "5.1.0";
+constexpr char DISPLAY_TITLE[] = "NintendoSDK Firmware for NX 5.1.0-3.0";

 } // namespace SystemVersionData

@@ -46,7 +46,7 @@ private:
 EmuWindow::EmuWindow() {
    // TODO: Find a better place to set this.
    config.min_client_area_size =
-        std::make_pair(Layout::MinimumSize::Width, Layout::MinimumSize::Height);
+        std::make_pair(Layout::ScreenUndocked::Width, Layout::ScreenUndocked::Height);
    active_config = config;
    touch_state = std::make_shared<TouchState>();
    Input::RegisterFactory<Input::TouchDevice>("emu_window", touch_state);
@@ -8,11 +8,6 @@

 namespace Layout {

-namespace MinimumSize {
-constexpr u32 Width = 640;
-constexpr u32 Height = 360;
-} // namespace MinimumSize
-
 namespace ScreenUndocked {
 constexpr u32 Width = 1280;
 constexpr u32 Height = 720;
@@ -13,6 +13,7 @@
 #include "common/common_funcs.h"
 #include "common/common_types.h"
 #include "common/logging/log.h"
+#include "core/core.h"
 #include "core/hle/ipc_helpers.h"
 #include "core/hle/kernel/handle_table.h"
 #include "core/hle/kernel/hle_ipc.h"
@@ -56,6 +57,7 @@ std::shared_ptr<WritableEvent> HLERequestContext::SleepClientThread(
            return true;
        });

+    auto& kernel = Core::System::GetInstance().Kernel();
    if (!writable_event) {
        // Create event if not provided
        const auto pair = WritableEvent::CreateEventPair(kernel, "HLE Pause Event: " + reason);
@@ -77,11 +79,9 @@ std::shared_ptr<WritableEvent> HLERequestContext::SleepClientThread(
    return writable_event;
 }

-HLERequestContext::HLERequestContext(KernelCore& kernel, Core::Memory::Memory& memory,
-                                     std::shared_ptr<ServerSession> server_session,
+HLERequestContext::HLERequestContext(std::shared_ptr<Kernel::ServerSession> server_session,
                                     std::shared_ptr<Thread> thread)
-    : server_session(std::move(server_session)),
-      thread(std::move(thread)), kernel{kernel}, memory{memory} {
+    : server_session(std::move(server_session)), thread(std::move(thread)) {
    cmd_buf[0] = 0;
 }

@@ -216,6 +216,7 @@ ResultCode HLERequestContext::PopulateFromIncomingCommandBuffer(const HandleTabl
 ResultCode HLERequestContext::WriteToOutgoingCommandBuffer(Thread& thread) {
    auto& owner_process = *thread.GetOwnerProcess();
    auto& handle_table = owner_process.GetHandleTable();
+    auto& memory = Core::System::GetInstance().Memory();

    std::array<u32, IPC::COMMAND_BUFFER_LENGTH> dst_cmdbuf;
    memory.ReadBlock(owner_process, thread.GetTLSAddress(), dst_cmdbuf.data(),
@@ -285,6 +286,7 @@ std::vector<u8> HLERequestContext::ReadBuffer(std::size_t buffer_index) const {
    std::vector<u8> buffer;
    const bool is_buffer_a{BufferDescriptorA().size() > buffer_index &&
                           BufferDescriptorA()[buffer_index].Size()};
+    auto& memory = Core::System::GetInstance().Memory();

    if (is_buffer_a) {
        ASSERT_MSG(BufferDescriptorA().size() > buffer_index,
@@ -317,6 +319,7 @@ std::size_t HLERequestContext::WriteBuffer(const void* buffer, std::size_t size,
        size = buffer_size; // TODO(bunnei): This needs to be HW tested
    }

+    auto& memory = Core::System::GetInstance().Memory();
    if (is_buffer_b) {
        ASSERT_MSG(BufferDescriptorB().size() > buffer_index,
                   "BufferDescriptorB invalid buffer_index {}", buffer_index);
@@ -19,10 +19,6 @@

 union ResultCode;

-namespace Core::Memory {
-class Memory;
-}
-
 namespace Service {
 class ServiceFrameworkBase;
 }
@@ -32,7 +28,6 @@ namespace Kernel {
 class Domain;
 class HandleTable;
 class HLERequestContext;
-class KernelCore;
 class Process;
 class ServerSession;
 class Thread;
@@ -103,8 +98,7 @@ protected:
 */
 class HLERequestContext {
 public:
-    explicit HLERequestContext(KernelCore& kernel, Core::Memory::Memory& memory,
-                               std::shared_ptr<ServerSession> session,
+    explicit HLERequestContext(std::shared_ptr<ServerSession> session,
                               std::shared_ptr<Thread> thread);
    ~HLERequestContext();

@@ -311,9 +305,6 @@ private:

    std::vector<std::shared_ptr<SessionRequestHandler>> domain_request_handlers;
    bool is_thread_waiting{};
-
-    KernelCore& kernel;
-    Core::Memory::Memory& memory;
 };

 } // namespace Kernel
@@ -2,8 +2,8 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.

-// This file references various implementation details from Atmosphere, an open-source firmware for
-// the Nintendo Switch. Copyright 2018-2020 Atmosphere-NX.
+// This file references various implementation details from Atmosphère, an open-source firmware for
+// the Nintendo Switch. Copyright 2018-2020 Atmosphère-NX.

 #include <array>

@@ -49,18 +49,18 @@ constexpr bool IsAllowedIndexForAddress(std::size_t index) {
    return index < std::size(AddressSpaceInfos) && AddressSpaceInfos[index].GetAddress() != Invalid;
 }

-constexpr std::array<std::size_t, static_cast<std::size_t>(AddressSpaceInfo::Type::Count)>
-    AddressSpaceIndices32Bit{
+constexpr std::size_t
+    AddressSpaceIndices32Bit[static_cast<std::size_t>(AddressSpaceInfo::Type::Count)]{
        0, 1, 0, 2, 0, 3,
    };

-constexpr std::array<std::size_t, static_cast<std::size_t>(AddressSpaceInfo::Type::Count)>
-    AddressSpaceIndices36Bit{
+constexpr std::size_t
+    AddressSpaceIndices36Bit[static_cast<std::size_t>(AddressSpaceInfo::Type::Count)]{
        4, 5, 4, 6, 4, 7,
    };

-constexpr std::array<std::size_t, static_cast<std::size_t>(AddressSpaceInfo::Type::Count)>
-    AddressSpaceIndices39Bit{
+constexpr std::size_t
+    AddressSpaceIndices39Bit[static_cast<std::size_t>(AddressSpaceInfo::Type::Count)]{
        9, 8, 8, 10, 12, 11,
    };

@@ -2,11 +2,12 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.

-// This file references various implementation details from Atmosphere, an open-source firmware for
-// the Nintendo Switch. Copyright 2018-2020 Atmosphere-NX.
+// This file references various implementation details from Atmosphère, an open-source firmware for
+// the Nintendo Switch. Copyright 2018-2020 Atmosphère-NX.

 #pragma once

+#include "common/common_funcs.h"
 #include "common/common_types.h"

 namespace Kernel::Memory {
@@ -2,8 +2,8 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.

-// This file references various implementation details from Atmosphere, an open-source firmware for
-// the Nintendo Switch. Copyright 2018-2020 Atmosphere-NX.
+// This file references various implementation details from Atmosphère, an open-source firmware for
+// the Nintendo Switch. Copyright 2018-2020 Atmosphère-NX.

 #pragma once

@@ -67,6 +67,7 @@ void MemoryBlockManager::Update(VAddr addr, std::size_t num_pages, MemoryState p
                                MemoryPermission prev_perm, MemoryAttribute prev_attribute,
                                MemoryState state, MemoryPermission perm,
                                MemoryAttribute attribute) {
+    const std::size_t prev_count{memory_block_tree.size()};
    const VAddr end_addr{addr + num_pages * PageSize};
    iterator node{memory_block_tree.begin()};

@@ -108,6 +109,7 @@ void MemoryBlockManager::Update(VAddr addr, std::size_t num_pages, MemoryState p

 void MemoryBlockManager::Update(VAddr addr, std::size_t num_pages, MemoryState state,
                                MemoryPermission perm, MemoryAttribute attribute) {
+    const std::size_t prev_count{memory_block_tree.size()};
    const VAddr end_addr{addr + num_pages * PageSize};
    iterator node{memory_block_tree.begin()};

@@ -143,6 +145,7 @@ void MemoryBlockManager::Update(VAddr addr, std::size_t num_pages, MemoryState s

 void MemoryBlockManager::UpdateLock(VAddr addr, std::size_t num_pages, LockFunc&& lock_func,
                                    MemoryPermission perm) {
+    const std::size_t prev_count{memory_block_tree.size()};
    const VAddr end_addr{addr + num_pages * PageSize};
    iterator node{memory_block_tree.begin()};

@@ -6,6 +6,7 @@

 #include <functional>
 #include <list>
+#include <memory>

 #include "common/common_types.h"
 #include "core/hle/kernel/memory/memory_block.h"
@@ -104,9 +104,9 @@ ResultCode MemoryManager::Allocate(PageLinkedList& page_list, std::size_t num_pa
    // Ensure that we don't leave anything un-freed
    auto group_guard = detail::ScopeExit([&] {
        for (const auto& it : page_list.Nodes()) {
-            const auto min_num_pages{std::min(
+            const auto num_pages{std::min(
                it.GetNumPages(), (chosen_manager.GetEndAddress() - it.GetAddress()) / PageSize)};
-            chosen_manager.Free(it.GetAddress(), min_num_pages);
+            chosen_manager.Free(it.GetAddress(), num_pages);
        }
    });

@@ -165,9 +165,9 @@ ResultCode MemoryManager::Free(PageLinkedList& page_list, std::size_t num_pages,

    // Free all of the pages
    for (const auto& it : page_list.Nodes()) {
-        const auto min_num_pages{std::min(
+        const auto num_pages{std::min(
            it.GetNumPages(), (chosen_manager.GetEndAddress() - it.GetAddress()) / PageSize)};
-        chosen_manager.Free(it.GetAddress(), min_num_pages);
+        chosen_manager.Free(it.GetAddress(), num_pages);
    }

    return RESULT_SUCCESS;
@@ -7,6 +7,7 @@
 #include <array>
 #include <mutex>

+#include "common/common_funcs.h"
 #include "common/common_types.h"
 #include "core/hle/kernel/memory/page_heap.h"
 #include "core/hle/result.h"
@@ -2,8 +2,8 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.

-// This file references various implementation details from Atmosphere, an open-source firmware for
-// the Nintendo Switch. Copyright 2018-2020 Atmosphere-NX.
+// This file references various implementation details from Atmosphère, an open-source firmware for
+// the Nintendo Switch. Copyright 2018-2020 Atmosphère-NX.

 #include "core/core.h"
 #include "core/hle/kernel/memory/page_heap.h"
@@ -2,8 +2,8 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.

-// This file references various implementation details from Atmosphere, an open-source firmware for
-// the Nintendo Switch. Copyright 2018-2020 Atmosphere-NX.
+// This file references various implementation details from Atmosphère, an open-source firmware for
+// the Nintendo Switch. Copyright 2018-2020 Atmosphère-NX.

 #pragma once

@@ -7,6 +7,7 @@
 #include <list>

 #include "common/assert.h"
+#include "common/common_funcs.h"
 #include "common/common_types.h"
 #include "core/hle/kernel/memory/memory_types.h"
 #include "core/hle/result.h"
@@ -6,6 +6,7 @@
 #include "common/assert.h"
 #include "common/scope_exit.h"
 #include "core/core.h"
+#include "core/device_memory.h"
 #include "core/hle/kernel/errors.h"
 #include "core/hle/kernel/kernel.h"
 #include "core/hle/kernel/memory/address_space_info.h"
@@ -4,15 +4,16 @@

 #pragma once

+#include <list>
 #include <memory>
 #include <mutex>

+#include "common/common_funcs.h"
 #include "common/common_types.h"
 #include "common/page_table.h"
 #include "core/file_sys/program_metadata.h"
 #include "core/hle/kernel/memory/memory_block.h"
 #include "core/hle/kernel/memory/memory_manager.h"
-#include "core/hle/result.h"

 namespace Core {
 class System;
@@ -2,14 +2,15 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.

-// This file references various implementation details from Atmosphere, an open-source firmware for
-// the Nintendo Switch. Copyright 2018-2020 Atmosphere-NX.
+// This file references various implementation details from Atmosphère, an open-source firmware for
+// the Nintendo Switch. Copyright 2018-2020 Atmosphère-NX.

 #pragma once

 #include <atomic>

 #include "common/assert.h"
+#include "common/common_funcs.h"
 #include "common/common_types.h"

 namespace Kernel::Memory {
@@ -2,6 +2,8 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.

+#pragma once
+
 #include <random>

 #include "core/hle/kernel/memory/system_control.h"
@@ -137,8 +137,8 @@ ResultCode ServerSession::HandleDomainSyncRequest(Kernel::HLERequestContext& con
 ResultCode ServerSession::QueueSyncRequest(std::shared_ptr<Thread> thread,
                                           Core::Memory::Memory& memory) {
    u32* cmd_buf{reinterpret_cast<u32*>(memory.GetPointer(thread->GetTLSAddress()))};
-    auto context =
-        std::make_shared<HLERequestContext>(kernel, memory, SharedFrom(this), std::move(thread));
+    std::shared_ptr<Kernel::HLERequestContext> context{
+        std::make_shared<Kernel::HLERequestContext>(SharedFrom(this), std::move(thread))};

    context->PopulateFromIncomingCommandBuffer(kernel.CurrentProcess()->GetHandleTable(), cmd_buf);
    request_queue.Push(std::move(context));
@@ -1525,15 +1525,14 @@ void InstallInterfaces(SM::ServiceManager& service_manager,
    std::make_shared<TCAP>()->InstallAsService(service_manager);
 }

-IHomeMenuFunctions::IHomeMenuFunctions(Kernel::KernelCore& kernel)
-    : ServiceFramework("IHomeMenuFunctions"), kernel(kernel) {
+IHomeMenuFunctions::IHomeMenuFunctions() : ServiceFramework("IHomeMenuFunctions") {
    // clang-format off
    static const FunctionInfo functions[] = {
        {10, &IHomeMenuFunctions::RequestToGetForeground, "RequestToGetForeground"},
        {11, nullptr, "LockForeground"},
        {12, nullptr, "UnlockForeground"},
        {20, nullptr, "PopFromGeneralChannel"},
-        {21, &IHomeMenuFunctions::GetPopFromGeneralChannelEvent, "GetPopFromGeneralChannelEvent"},
+        {21, nullptr, "GetPopFromGeneralChannelEvent"},
        {30, nullptr, "GetHomeButtonWriterLockAccessor"},
        {31, nullptr, "GetWriterLockAccessorEx"},
        {100, nullptr, "PopRequestLaunchApplicationForDebug"},
@@ -1543,9 +1542,6 @@ IHomeMenuFunctions::IHomeMenuFunctions(Kernel::KernelCore& kernel)
    // clang-format on

    RegisterHandlers(functions);
-
-    pop_from_general_channel_event = Kernel::WritableEvent::CreateEventPair(
-        kernel, "IHomeMenuFunctions:PopFromGeneralChannelEvent");
 }

 IHomeMenuFunctions::~IHomeMenuFunctions() = default;
@@ -1557,14 +1553,6 @@ void IHomeMenuFunctions::RequestToGetForeground(Kernel::HLERequestContext& ctx)
    rb.Push(RESULT_SUCCESS);
 }

-void IHomeMenuFunctions::GetPopFromGeneralChannelEvent(Kernel::HLERequestContext& ctx) {
-    LOG_WARNING(Service_AM, "(STUBBED) called");
-
-    IPC::ResponseBuilder rb{ctx, 2, 1};
-    rb.Push(RESULT_SUCCESS);
-    rb.PushCopyObjects(pop_from_general_channel_event.readable);
-}
-
 IGlobalStateController::IGlobalStateController() : ServiceFramework("IGlobalStateController") {
    // clang-format off
    static const FunctionInfo functions[] = {
@@ -292,15 +292,11 @@ private:

 class IHomeMenuFunctions final : public ServiceFramework<IHomeMenuFunctions> {
 public:
-    explicit IHomeMenuFunctions(Kernel::KernelCore& kernel);
+    IHomeMenuFunctions();
    ~IHomeMenuFunctions() override;

 private:
    void RequestToGetForeground(Kernel::HLERequestContext& ctx);
-    void GetPopFromGeneralChannelEvent(Kernel::HLERequestContext& ctx);
-
-    Kernel::EventPair pop_from_general_channel_event;
-    Kernel::KernelCore& kernel;
 };

 class IGlobalStateController final : public ServiceFramework<IGlobalStateController> {
@@ -202,7 +202,7 @@ private:

        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
        rb.Push(RESULT_SUCCESS);
-        rb.PushIpcInterface<IHomeMenuFunctions>(system.Kernel());
+        rb.PushIpcInterface<IHomeMenuFunctions>();
    }

    void GetGlobalStateController(Kernel::HLERequestContext& ctx) {
@@ -4,8 +4,8 @@

 #include <fmt/ostream.h>
 #include <httplib.h>
+#include <json.hpp>
 #include <mbedtls/sha256.h>
-#include <nlohmann/json.hpp>
 #include "common/hex_util.h"
 #include "common/logging/backend.h"
 #include "common/logging/log.h"
@@ -40,7 +40,10 @@ static FileSys::VirtualDir GetDirectoryRelativeWrapped(FileSys::VirtualDir base,
    if (dir_name.empty() || dir_name == "." || dir_name == "/" || dir_name == "\\")
        return base;

-    return base->GetDirectoryRelative(dir_name);
+    const auto res = base->GetDirectoryRelative(dir_name);
+    if (res == nullptr)
+        return base->CreateDirectoryRelative(dir_name);
+    return res;
 }

 VfsDirectoryServiceWrapper::VfsDirectoryServiceWrapper(FileSys::VirtualDir backing_)
@@ -38,11 +38,10 @@ void Controller_Keyboard::OnUpdate(const Core::Timing::CoreTiming& core_timing,
    cur_entry.sampling_number = last_entry.sampling_number + 1;
    cur_entry.sampling_number2 = cur_entry.sampling_number;

-    cur_entry.key.fill(0);
-    cur_entry.modifier = 0;
-
    for (std::size_t i = 0; i < keyboard_keys.size(); ++i) {
-        cur_entry.key[i / KEYS_PER_BYTE] |= (keyboard_keys[i]->GetStatus() << (i % KEYS_PER_BYTE));
+        for (std::size_t k = 0; k < KEYS_PER_BYTE; ++k) {
+            cur_entry.key[i / KEYS_PER_BYTE] |= (keyboard_keys[i]->GetStatus() << k);
+        }
    }

    for (std::size_t i = 0; i < keyboard_mods.size(); ++i) {
@@ -157,7 +157,7 @@ Hid::Hid(Core::System& system) : ServiceFramework("hid"), system(system) {
        {11, &Hid::ActivateTouchScreen, "ActivateTouchScreen"},
        {21, &Hid::ActivateMouse, "ActivateMouse"},
        {31, &Hid::ActivateKeyboard, "ActivateKeyboard"},
-        {32, &Hid::SendKeyboardLockKeyEvent, "SendKeyboardLockKeyEvent"},
+        {32, nullptr, "SendKeyboardLockKeyEvent"},
        {40, nullptr, "AcquireXpadIdEventHandle"},
        {41, nullptr, "ReleaseXpadIdEventHandle"},
        {51, &Hid::ActivateXpad, "ActivateXpad"},
@@ -871,15 +871,6 @@ void Hid::InitializeSevenSixAxisSensor(Kernel::HLERequestContext& ctx) {
    rb.Push(RESULT_SUCCESS);
 }

-void Hid::SendKeyboardLockKeyEvent(Kernel::HLERequestContext& ctx) {
-    IPC::RequestParser rp{ctx};
-    const auto flags{rp.Pop<u32>()};
-    LOG_WARNING(Service_HID, "(STUBBED) called. flags={}", flags);
-
-    IPC::ResponseBuilder rb{ctx, 2};
-    rb.Push(RESULT_SUCCESS);
-}
-
 class HidDbg final : public ServiceFramework<HidDbg> {
 public:
    explicit HidDbg() : ServiceFramework{"hid:dbg"} {
@@ -130,7 +130,6 @@ private:
    void SetPalmaBoostMode(Kernel::HLERequestContext& ctx);
    void StopSevenSixAxisSensor(Kernel::HLERequestContext& ctx);
    void InitializeSevenSixAxisSensor(Kernel::HLERequestContext& ctx);
-    void SendKeyboardLockKeyEvent(Kernel::HLERequestContext& ctx);

    std::shared_ptr<IAppletResource> applet_resource;
    Core::System& system;
@@ -138,7 +138,9 @@ u32 BufferQueue::Query(QueryType type) {

    switch (type) {
    case QueryType::NativeWindowFormat:
-        return static_cast<u32>(PixelFormat::RGBA8888);
+        // TODO(Subv): Use an enum for this
+        static constexpr u32 FormatABGR8 = 1;
+        return FormatABGR8;
    }

    UNIMPLEMENTED();
@@ -66,16 +66,6 @@ public:
        Rotate270 = 0x07,
    };

-    enum class PixelFormat : u32 {
-        RGBA8888 = 1,
-        RGBX8888 = 2,
-        RGB888 = 3,
-        RGB565 = 4,
-        BGRA8888 = 5,
-        RGBA5551 = 6,
-        RRGBA4444 = 7,
-    };
-
    struct Buffer {
        enum class Status { Free = 0, Queued = 1, Dequeued = 2, Acquired = 3 };

@@ -5,7 +5,6 @@
 #include <chrono>
 #include <ctime>

-#include "common/time_zone.h"
 #include "core/hle/service/time/ephemeral_network_system_clock_context_writer.h"
 #include "core/hle/service/time/local_system_clock_context_writer.h"
 #include "core/hle/service/time/network_system_clock_context_writer.h"
@@ -22,16 +21,8 @@ static std::chrono::seconds GetSecondsSinceEpoch() {
           Settings::values.custom_rtc_differential;
 }

-static s64 GetExternalTimeZoneOffset() {
-    // With "auto" timezone setting, we use the external system's timezone offset
-    if (Settings::GetTimeZoneString() == "auto") {
-        return Common::TimeZone::GetCurrentOffsetSeconds().count();
-    }
-    return 0;
-}
-
 static s64 GetExternalRtcValue() {
-    return GetSecondsSinceEpoch().count() + GetExternalTimeZoneOffset();
+    return GetSecondsSinceEpoch().count();
 }

 TimeManager::TimeManager(Core::System& system)
@@ -5,7 +5,6 @@
 #include <sstream>

 #include "common/logging/log.h"
-#include "common/time_zone.h"
 #include "core/core.h"
 #include "core/file_sys/content_archive.h"
 #include "core/file_sys/nca_metadata.h"
@@ -15,7 +14,6 @@
 #include "core/hle/service/filesystem/filesystem.h"
 #include "core/hle/service/time/time_manager.h"
 #include "core/hle/service/time/time_zone_content_manager.h"
-#include "core/settings.h"

 namespace Service::Time::TimeZone {

@@ -70,22 +68,10 @@ static std::vector<std::string> BuildLocationNameCache(Core::System& system) {

 TimeZoneContentManager::TimeZoneContentManager(TimeManager& time_manager, Core::System& system)
    : system{system}, location_name_cache{BuildLocationNameCache(system)} {
-
-    std::string location_name;
-    const auto timezone_setting = Settings::GetTimeZoneString();
-    if (timezone_setting == "auto") {
-        location_name = Common::TimeZone::GetDefaultTimeZone();
-    } else if (timezone_setting == "default") {
-        location_name = location_name;
-    } else {
-        location_name = timezone_setting;
-    }
-
-    if (FileSys::VirtualFile vfs_file;
-        GetTimeZoneInfoFile(location_name, vfs_file) == RESULT_SUCCESS) {
+    if (FileSys::VirtualFile vfs_file; GetTimeZoneInfoFile("GMT", vfs_file) == RESULT_SUCCESS) {
        const auto time_point{
            time_manager.GetStandardSteadyClockCore().GetCurrentTimePoint(system)};
-        time_manager.SetupTimeZoneManager(location_name, time_point, location_name_cache.size(), {},
+        time_manager.SetupTimeZoneManager("GMT", time_point, location_name_cache.size(), {},
                                          vfs_file);
    } else {
        time_zone_manager.MarkAsInitialized();
@@ -127,12 +113,6 @@ ResultCode TimeZoneContentManager::GetTimeZoneInfoFile(const std::string& locati
    }

    vfs_file = zoneinfo_dir->GetFile(location_name);
-    if (!vfs_file) {
-        LOG_ERROR(Service_Time, "{:016X} has no file \"{}\"! Using default timezone.",
-                  time_zone_binary_titleid, location_name);
-        vfs_file = zoneinfo_dir->GetFile(Common::TimeZone::GetDefaultTimeZone());
-    }
-
    if (!vfs_file) {
        LOG_ERROR(Service_Time, "{:016X} has no file \"{}\"!", time_zone_binary_titleid,
                  location_name);
@@ -108,13 +108,15 @@ PerfStatsResults PerfStats::GetAndResetStats(microseconds current_system_time_us
    system_frames = 0;
    game_frames = 0;

+    target_fps = static_cast<u32>(results.game_fps / results.emulation_speed);
+
    return results;
 }

 double PerfStats::GetLastFrameTimeScale() {
    std::lock_guard lock{object_mutex};

-    constexpr double FRAME_LENGTH = 1.0 / 60;
+    double FRAME_LENGTH = 1.0 / target_fps;
    return duration_cast<DoubleSecs>(previous_frame_length).count() / FRAME_LENGTH;
 }

@@ -81,6 +81,8 @@ private:
    Clock::time_point frame_begin = reset_point;
    /// Total visible duration (including frame-limiting, etc.) of the previous system frame
    Clock::duration previous_frame_length = Clock::duration::zero();
+
+    u32 target_fps{60};
 };

 class FrameLimiter {
@@ -4,12 +4,11 @@

 #include <ctime>
 #include <fstream>
-#include <iomanip>

 #include <fmt/chrono.h>
 #include <fmt/format.h>
 #include <fmt/ostream.h>
-#include <nlohmann/json.hpp>
+#include <json.hpp>

 #include "common/file_util.h"
 #include "common/hex_util.h"
@@ -63,21 +63,6 @@ const std::array<const char*, NumMouseButtons> mapping = {{

 Values values = {};

-std::string GetTimeZoneString() {
-    static constexpr std::array<const char*, 46> timezones{{
-        "auto",      "default",   "CET", "CST6CDT", "Cuba",    "EET",    "Egypt",     "Eire",
-        "EST",       "EST5EDT",   "GB",  "GB-Eire", "GMT",     "GMT+0",  "GMT-0",     "GMT0",
-        "Greenwich", "Hongkong",  "HST", "Iceland", "Iran",    "Israel", "Jamaica",   "Japan",
-        "Kwajalein", "Libya",     "MET", "MST",     "MST7MDT", "Navajo", "NZ",        "NZ-CHAT",
-        "Poland",    "Portugal",  "PRC", "PST8PDT", "ROC",     "ROK",    "Singapore", "Turkey",
-        "UCT",       "Universal", "UTC", "W-SU",    "WET",     "Zulu",
-    }};
-
-    ASSERT(Settings::values.time_zone_index < timezones.size());
-
-    return timezones[Settings::values.time_zone_index];
-}
-
 void Apply() {
    GDBStub::SetServerPort(values.gdbstub_port);
    GDBStub::ToggleServer(values.use_gdbstub);
@@ -102,7 +87,6 @@ void LogSettings() {
    LogSetting("System_CurrentUser", Settings::values.current_user);
    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);
@@ -115,6 +99,7 @@ void LogSettings() {
    LogSetting("Renderer_AnisotropicFilteringLevel", Settings::values.max_anisotropy);
    LogSetting("Audio_OutputEngine", Settings::values.sink_id);
    LogSetting("Audio_EnableAudioStretching", Settings::values.enable_audio_stretching);
+    LogSetting("Audio_EnableRealTime", Settings::values.enable_realtime_audio);
    LogSetting("Audio_OutputDevice", Settings::values.audio_device_id);
    LogSetting("DataStorage_UseVirtualSd", Settings::values.use_virtual_sd);
    LogSetting("DataStorage_NandDir", FileUtil::GetUserPath(FileUtil::UserPath::NANDDir));
@@ -394,7 +394,6 @@ struct Values {
    s32 current_user;
    s32 language_index;
    s32 region_index;
-    s32 time_zone_index;
    s32 sound_index;

    // Controls
@@ -460,6 +459,7 @@ struct Values {
    // Audio
    std::string sink_id;
    bool enable_audio_stretching;
+    bool enable_realtime_audio;
    std::string audio_device_id;
    float volume;

@@ -491,9 +491,6 @@ struct Values {
 bool IsGPULevelExtreme();
 bool IsGPULevelHigh();

-std::string GetTimeZoneString();
-
 void Apply();
 void LogSettings();
-
 } // namespace Settings
@@ -190,6 +190,7 @@ void TelemetrySession::AddInitialInfo(Loader::AppLoader& app_loader) {
    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);
+    AddField(field_type, "Audio_EnableRealTime", Settings::values.enable_realtime_audio);
    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);
@@ -8,7 +8,6 @@ add_library(video_core STATIC
    dma_pusher.h
    engines/const_buffer_engine_interface.h
    engines/const_buffer_info.h
-    engines/engine_interface.h
    engines/engine_upload.cpp
    engines/engine_upload.h
    engines/fermi_2d.cpp
@@ -27,8 +27,6 @@ void DmaPusher::DispatchCalls() {

    dma_pushbuffer_subindex = 0;

-    dma_state.is_last_call = true;
-
    while (system.IsPoweredOn()) {
        if (!Step()) {
            break;
@@ -54,7 +52,9 @@ bool DmaPusher::Step() {
        return true;
    });
    const CommandListHeader command_list_header{command_list[dma_pushbuffer_subindex++]};
-    const GPUVAddr dma_get = command_list_header.addr;
+    GPUVAddr dma_get = command_list_header.addr;
+    GPUVAddr dma_put = dma_get + command_list_header.size * sizeof(u32);
+    bool non_main = command_list_header.is_non_main;

    if (dma_pushbuffer_subindex >= command_list.size()) {
        // We've gone through the current list, remove it from the queue
@@ -82,11 +82,9 @@ bool DmaPusher::Step() {
                    index);
                CallMultiMethod(&command_header.argument, max_write);
                dma_state.method_count -= max_write;
-                dma_state.is_last_call = true;
                index += max_write;
                continue;
            } else {
-                dma_state.is_last_call = dma_state.method_count <= 1;
                CallMethod(command_header.argument);
            }

@@ -131,6 +129,11 @@ bool DmaPusher::Step() {
        index++;
    }

+    if (!non_main) {
+        // TODO (degasus): This is dead code, as dma_mget is never read.
+        dma_mget = dma_put;
+    }
+
    return true;
 }

@@ -141,22 +144,12 @@ void DmaPusher::SetState(const CommandHeader& command_header) {
 }

 void DmaPusher::CallMethod(u32 argument) const {
-    if (dma_state.method < non_puller_methods) {
-        gpu.CallMethod({dma_state.method, argument, dma_state.subchannel, dma_state.method_count});
-    } else {
-        subchannels[dma_state.subchannel]->CallMethod(dma_state.method, argument,
-                                                      dma_state.is_last_call);
-    }
+    gpu.CallMethod({dma_state.method, argument, dma_state.subchannel, dma_state.method_count});
 }

 void DmaPusher::CallMultiMethod(const u32* base_start, u32 num_methods) const {
-    if (dma_state.method < non_puller_methods) {
-        gpu.CallMultiMethod(dma_state.method, dma_state.subchannel, base_start, num_methods,
-                            dma_state.method_count);
-    } else {
-        subchannels[dma_state.subchannel]->CallMultiMethod(dma_state.method, base_start,
-                                                           num_methods, dma_state.method_count);
-    }
+    gpu.CallMultiMethod(dma_state.method, dma_state.subchannel, base_start, num_methods,
+                        dma_state.method_count);
 }

 } // namespace Tegra
@@ -4,13 +4,11 @@

 #pragma once

-#include <array>
 #include <vector>
 #include <queue>

 #include "common/bit_field.h"
 #include "common/common_types.h"
-#include "video_core/engines/engine_interface.h"

 namespace Core {
 class System;
@@ -71,13 +69,7 @@ public:

    void DispatchCalls();

-    void BindSubchannel(Tegra::Engines::EngineInterface* engine, u32 subchannel_id) {
-        subchannels[subchannel_id] = engine;
-    }
-
 private:
-    static constexpr u32 non_puller_methods = 0x40;
-    static constexpr u32 max_subchannels = 8;
    bool Step();

    void SetState(const CommandHeader& command_header);
@@ -96,16 +88,14 @@ private:
        u32 method_count;      ///< Current method count
        u32 length_pending;    ///< Large NI command length pending
        bool non_incrementing; ///< Current command's NI flag
-        bool is_last_call;
    };

    DmaState dma_state{};
    bool dma_increment_once{};

+    GPUVAddr dma_mget{};  ///< main pushbuffer last read address
    bool ib_enable{true}; ///< IB mode enabled

-    std::array<Tegra::Engines::EngineInterface*, max_subchannels> subchannels{};
-
    GPU& gpu;
    Core::System& system;
 };
@@ -1,22 +0,0 @@
-// Copyright 2020 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <type_traits>
-#include "common/common_types.h"
-
-namespace Tegra::Engines {
-
-class EngineInterface {
-public:
-    /// Write the value to the register identified by method.
-    virtual void CallMethod(u32 method, u32 method_argument, bool is_last_call) = 0;
-
-    /// Write multiple values to the register identified by method.
-    virtual void CallMultiMethod(u32 method, const u32* base_start, u32 amount,
-                                 u32 methods_pending) = 0;
-};
-
-} // namespace Tegra::Engines
@@ -12,13 +12,13 @@ namespace Tegra::Engines {

 Fermi2D::Fermi2D(VideoCore::RasterizerInterface& rasterizer) : rasterizer{rasterizer} {}

-void Fermi2D::CallMethod(u32 method, u32 method_argument, bool is_last_call) {
-    ASSERT_MSG(method < Regs::NUM_REGS,
+void Fermi2D::CallMethod(const GPU::MethodCall& method_call) {
+    ASSERT_MSG(method_call.method < Regs::NUM_REGS,
               "Invalid Fermi2D register, increase the size of the Regs structure");

-    regs.reg_array[method] = method_argument;
+    regs.reg_array[method_call.method] = method_call.argument;

-    switch (method) {
+    switch (method_call.method) {
    // Trigger the surface copy on the last register write. This is blit_src_y, but this is 64-bit,
    // so trigger on the second 32-bit write.
    case FERMI2D_REG_INDEX(blit_src_y) + 1: {
@@ -30,7 +30,7 @@ void Fermi2D::CallMethod(u32 method, u32 method_argument, bool is_last_call) {

 void Fermi2D::CallMultiMethod(u32 method, const u32* base_start, u32 amount, u32 methods_pending) {
    for (std::size_t i = 0; i < amount; i++) {
-        CallMethod(method, base_start[i], methods_pending - static_cast<u32>(i) <= 1);
+        CallMethod({method, base_start[i], 0, methods_pending - static_cast<u32>(i)});
    }
 }

@@ -10,7 +10,6 @@
 #include "common/common_funcs.h"
 #include "common/common_types.h"
 #include "common/math_util.h"
-#include "video_core/engines/engine_interface.h"
 #include "video_core/gpu.h"

 namespace Tegra {
@@ -32,17 +31,16 @@ namespace Tegra::Engines {
 #define FERMI2D_REG_INDEX(field_name)                                                              \
    (offsetof(Tegra::Engines::Fermi2D::Regs, field_name) / sizeof(u32))

-class Fermi2D final : public EngineInterface {
+class Fermi2D final {
 public:
    explicit Fermi2D(VideoCore::RasterizerInterface& rasterizer);
    ~Fermi2D() = default;

    /// Write the value to the register identified by method.
-    void CallMethod(u32 method, u32 method_argument, bool is_last_call) override;
+    void CallMethod(const GPU::MethodCall& method_call);

    /// Write multiple values to the register identified by method.
-    void CallMultiMethod(u32 method, const u32* base_start, u32 amount,
-                         u32 methods_pending) override;
+    void CallMultiMethod(u32 method, const u32* base_start, u32 amount, u32 methods_pending);

    enum class Origin : u32 {
        Center = 0,
@@ -24,19 +24,20 @@ KeplerCompute::KeplerCompute(Core::System& system, VideoCore::RasterizerInterfac

 KeplerCompute::~KeplerCompute() = default;

-void KeplerCompute::CallMethod(u32 method, u32 method_argument, bool is_last_call) {
-    ASSERT_MSG(method < Regs::NUM_REGS,
+void KeplerCompute::CallMethod(const GPU::MethodCall& method_call) {
+    ASSERT_MSG(method_call.method < Regs::NUM_REGS,
               "Invalid KeplerCompute register, increase the size of the Regs structure");

-    regs.reg_array[method] = method_argument;
+    regs.reg_array[method_call.method] = method_call.argument;

-    switch (method) {
+    switch (method_call.method) {
    case KEPLER_COMPUTE_REG_INDEX(exec_upload): {
        upload_state.ProcessExec(regs.exec_upload.linear != 0);
        break;
    }
    case KEPLER_COMPUTE_REG_INDEX(data_upload): {
-        upload_state.ProcessData(method_argument, is_last_call);
+        const bool is_last_call = method_call.IsLastCall();
+        upload_state.ProcessData(method_call.argument, is_last_call);
        if (is_last_call) {
            system.GPU().Maxwell3D().OnMemoryWrite();
        }
@@ -53,7 +54,7 @@ void KeplerCompute::CallMethod(u32 method, u32 method_argument, bool is_last_cal
 void KeplerCompute::CallMultiMethod(u32 method, const u32* base_start, u32 amount,
                                    u32 methods_pending) {
    for (std::size_t i = 0; i < amount; i++) {
-        CallMethod(method, base_start[i], methods_pending - static_cast<u32>(i) <= 1);
+        CallMethod({method, base_start[i], 0, methods_pending - static_cast<u32>(i)});
    }
 }

@@ -11,7 +11,6 @@
 #include "common/common_funcs.h"
 #include "common/common_types.h"
 #include "video_core/engines/const_buffer_engine_interface.h"
-#include "video_core/engines/engine_interface.h"
 #include "video_core/engines/engine_upload.h"
 #include "video_core/engines/shader_type.h"
 #include "video_core/gpu.h"
@@ -40,7 +39,7 @@ namespace Tegra::Engines {
 #define KEPLER_COMPUTE_REG_INDEX(field_name)                                                       \
    (offsetof(Tegra::Engines::KeplerCompute::Regs, field_name) / sizeof(u32))

-class KeplerCompute final : public ConstBufferEngineInterface, public EngineInterface {
+class KeplerCompute final : public ConstBufferEngineInterface {
 public:
    explicit KeplerCompute(Core::System& system, VideoCore::RasterizerInterface& rasterizer,
                           MemoryManager& memory_manager);
@@ -201,11 +200,10 @@ public:
                  "KeplerCompute LaunchParams has wrong size");

    /// Write the value to the register identified by method.
-    void CallMethod(u32 method, u32 method_argument, bool is_last_call) override;
+    void CallMethod(const GPU::MethodCall& method_call);

    /// Write multiple values to the register identified by method.
-    void CallMultiMethod(u32 method, const u32* base_start, u32 amount,
-                         u32 methods_pending) override;
+    void CallMultiMethod(u32 method, const u32* base_start, u32 amount, u32 methods_pending);

    Texture::FullTextureInfo GetTexture(std::size_t offset) const;

@@ -19,19 +19,20 @@ KeplerMemory::KeplerMemory(Core::System& system, MemoryManager& memory_manager)

 KeplerMemory::~KeplerMemory() = default;

-void KeplerMemory::CallMethod(u32 method, u32 method_argument, bool is_last_call) {
-    ASSERT_MSG(method < Regs::NUM_REGS,
+void KeplerMemory::CallMethod(const GPU::MethodCall& method_call) {
+    ASSERT_MSG(method_call.method < Regs::NUM_REGS,
               "Invalid KeplerMemory register, increase the size of the Regs structure");

-    regs.reg_array[method] = method_argument;
+    regs.reg_array[method_call.method] = method_call.argument;

-    switch (method) {
+    switch (method_call.method) {
    case KEPLERMEMORY_REG_INDEX(exec): {
        upload_state.ProcessExec(regs.exec.linear != 0);
        break;
    }
    case KEPLERMEMORY_REG_INDEX(data): {
-        upload_state.ProcessData(method_argument, is_last_call);
+        const bool is_last_call = method_call.IsLastCall();
+        upload_state.ProcessData(method_call.argument, is_last_call);
        if (is_last_call) {
            system.GPU().Maxwell3D().OnMemoryWrite();
        }
@@ -43,7 +44,7 @@ void KeplerMemory::CallMethod(u32 method, u32 method_argument, bool is_last_call
 void KeplerMemory::CallMultiMethod(u32 method, const u32* base_start, u32 amount,
                                   u32 methods_pending) {
    for (std::size_t i = 0; i < amount; i++) {
-        CallMethod(method, base_start[i], methods_pending - static_cast<u32>(i) <= 1);
+        CallMethod({method, base_start[i], 0, methods_pending - static_cast<u32>(i)});
    }
 }

@@ -10,7 +10,6 @@
 #include "common/bit_field.h"
 #include "common/common_funcs.h"
 #include "common/common_types.h"
-#include "video_core/engines/engine_interface.h"
 #include "video_core/engines/engine_upload.h"
 #include "video_core/gpu.h"

@@ -33,17 +32,16 @@ namespace Tegra::Engines {
 #define KEPLERMEMORY_REG_INDEX(field_name)                                                         \
    (offsetof(Tegra::Engines::KeplerMemory::Regs, field_name) / sizeof(u32))

-class KeplerMemory final : public EngineInterface {
+class KeplerMemory final {
 public:
    KeplerMemory(Core::System& system, MemoryManager& memory_manager);
    ~KeplerMemory();

    /// Write the value to the register identified by method.
-    void CallMethod(u32 method, u32 method_argument, bool is_last_call) override;
+    void CallMethod(const GPU::MethodCall& method_call);

    /// Write multiple values to the register identified by method.
-    void CallMultiMethod(u32 method, const u32* base_start, u32 amount,
-                         u32 methods_pending) override;
+    void CallMultiMethod(u32 method, const u32* base_start, u32 amount, u32 methods_pending);

    struct Regs {
        static constexpr size_t NUM_REGS = 0x7F;
@@ -44,12 +44,6 @@ void Maxwell3D::InitializeRegisterDefaults() {
        viewport.depth_range_near = 0.0f;
        viewport.depth_range_far = 1.0f;
    }
-    for (auto& viewport : regs.viewport_transform) {
-        viewport.swizzle.x.Assign(Regs::ViewportSwizzle::PositiveX);
-        viewport.swizzle.y.Assign(Regs::ViewportSwizzle::PositiveY);
-        viewport.swizzle.z.Assign(Regs::ViewportSwizzle::PositiveZ);
-        viewport.swizzle.w.Assign(Regs::ViewportSwizzle::PositiveW);
-    }

    // Doom and Bomberman seems to use the uninitialized registers and just enable blend
    // so initialize blend registers with sane values
@@ -131,10 +125,12 @@ void Maxwell3D::CallMacroMethod(u32 method, std::size_t num_parameters, const u3
    }
 }

-void Maxwell3D::CallMethod(u32 method, u32 method_argument, bool is_last_call) {
+void Maxwell3D::CallMethod(const GPU::MethodCall& method_call) {
+    const u32 method = method_call.method;
+
    if (method == cb_data_state.current) {
-        regs.reg_array[method] = method_argument;
-        ProcessCBData(method_argument);
+        regs.reg_array[method] = method_call.argument;
+        ProcessCBData(method_call.argument);
        return;
    } else if (cb_data_state.current != null_cb_data) {
        FinishCBData();
@@ -157,10 +153,10 @@ void Maxwell3D::CallMethod(u32 method, u32 method_argument, bool is_last_call) {
            executing_macro = method;
        }

-        macro_params.push_back(method_argument);
+        macro_params.push_back(method_call.argument);

        // Call the macro when there are no more parameters in the command buffer
-        if (is_last_call) {
+        if (method_call.IsLastCall()) {
            CallMacroMethod(executing_macro, macro_params.size(), macro_params.data());
            macro_params.clear();
        }
@@ -170,7 +166,7 @@ void Maxwell3D::CallMethod(u32 method, u32 method_argument, bool is_last_call) {
    ASSERT_MSG(method < Regs::NUM_REGS,
               "Invalid Maxwell3D register, increase the size of the Regs structure");

-    u32 arg = method_argument;
+    u32 arg = method_call.argument;
    // Keep track of the register value in shadow_state when requested.
    if (shadow_state.shadow_ram_control == Regs::ShadowRamControl::Track ||
        shadow_state.shadow_ram_control == Regs::ShadowRamControl::TrackWithFilter) {
@@ -193,7 +189,7 @@ void Maxwell3D::CallMethod(u32 method, u32 method_argument, bool is_last_call) {
        break;
    }
    case MAXWELL3D_REG_INDEX(shadow_ram_control): {
-        shadow_state.shadow_ram_control = static_cast<Regs::ShadowRamControl>(method_argument);
+        shadow_state.shadow_ram_control = static_cast<Regs::ShadowRamControl>(method_call.argument);
        break;
    }
    case MAXWELL3D_REG_INDEX(macros.data): {
@@ -276,6 +272,7 @@ void Maxwell3D::CallMethod(u32 method, u32 method_argument, bool is_last_call) {
        break;
    }
    case MAXWELL3D_REG_INDEX(data_upload): {
+        const bool is_last_call = method_call.IsLastCall();
        upload_state.ProcessData(arg, is_last_call);
        if (is_last_call) {
            OnMemoryWrite();
@@ -333,7 +330,7 @@ void Maxwell3D::CallMultiMethod(u32 method, const u32* base_start, u32 amount,
    }
    default: {
        for (std::size_t i = 0; i < amount; i++) {
-            CallMethod(method, base_start[i], methods_pending - static_cast<u32>(i) <= 1);
+            CallMethod({method, base_start[i], 0, methods_pending - static_cast<u32>(i)});
        }
    }
    }
@@ -363,15 +360,16 @@ void Maxwell3D::StepInstance(const MMEDrawMode expected_mode, const u32 count) {
    StepInstance(expected_mode, count);
 }

-void Maxwell3D::CallMethodFromMME(u32 method, u32 method_argument) {
+void Maxwell3D::CallMethodFromMME(const GPU::MethodCall& method_call) {
+    const u32 method = method_call.method;
    if (mme_inline[method]) {
-        regs.reg_array[method] = method_argument;
+        regs.reg_array[method] = method_call.argument;
        if (method == MAXWELL3D_REG_INDEX(vertex_buffer.count) ||
            method == MAXWELL3D_REG_INDEX(index_array.count)) {
            const MMEDrawMode expected_mode = method == MAXWELL3D_REG_INDEX(vertex_buffer.count)
                                                  ? MMEDrawMode::Array
                                                  : MMEDrawMode::Indexed;
-            StepInstance(expected_mode, method_argument);
+            StepInstance(expected_mode, method_call.argument);
        } else if (method == MAXWELL3D_REG_INDEX(draw.vertex_begin_gl)) {
            mme_draw.instance_mode =
                (regs.draw.instance_next != 0) || (regs.draw.instance_cont != 0);
@@ -383,7 +381,7 @@ void Maxwell3D::CallMethodFromMME(u32 method, u32 method_argument) {
        if (mme_draw.current_mode != MMEDrawMode::Undefined) {
            FlushMMEInlineDraw();
        }
-        CallMethod(method, method_argument, true);
+        CallMethod(method_call);
    }
 }

@@ -19,7 +19,6 @@
 #include "common/math_util.h"
 #include "video_core/engines/const_buffer_engine_interface.h"
 #include "video_core/engines/const_buffer_info.h"
-#include "video_core/engines/engine_interface.h"
 #include "video_core/engines/engine_upload.h"
 #include "video_core/engines/shader_type.h"
 #include "video_core/gpu.h"
@@ -49,7 +48,7 @@ namespace Tegra::Engines {
 #define MAXWELL3D_REG_INDEX(field_name)                                                            \
    (offsetof(Tegra::Engines::Maxwell3D::Regs, field_name) / sizeof(u32))

-class Maxwell3D final : public ConstBufferEngineInterface, public EngineInterface {
+class Maxwell3D final : public ConstBufferEngineInterface {
 public:
    explicit Maxwell3D(Core::System& system, VideoCore::RasterizerInterface& rasterizer,
                       MemoryManager& memory_manager);
@@ -576,17 +575,6 @@ public:
            Replay = 3,
        };

-        enum class ViewportSwizzle : u32 {
-            PositiveX = 0,
-            NegativeX = 1,
-            PositiveY = 2,
-            NegativeY = 3,
-            PositiveZ = 4,
-            NegativeZ = 5,
-            PositiveW = 6,
-            NegativeW = 7,
-        };
-
        struct RenderTargetConfig {
            u32 address_high;
            u32 address_low;
@@ -630,14 +618,7 @@ public:
            f32 translate_x;
            f32 translate_y;
            f32 translate_z;
-            union {
-                u32 raw;
-                BitField<0, 3, ViewportSwizzle> x;
-                BitField<4, 3, ViewportSwizzle> y;
-                BitField<8, 3, ViewportSwizzle> z;
-                BitField<12, 3, ViewportSwizzle> w;
-            } swizzle;
-            INSERT_UNION_PADDING_WORDS(1);
+            INSERT_UNION_PADDING_WORDS(2);

            Common::Rectangle<f32> GetRect() const {
                return {
@@ -1379,14 +1360,13 @@ public:
    u32 GetRegisterValue(u32 method) const;

    /// Write the value to the register identified by method.
-    void CallMethod(u32 method, u32 method_argument, bool is_last_call) override;
+    void CallMethod(const GPU::MethodCall& method_call);

    /// Write multiple values to the register identified by method.
-    void CallMultiMethod(u32 method, const u32* base_start, u32 amount,
-                         u32 methods_pending) override;
+    void CallMultiMethod(u32 method, const u32* base_start, u32 amount, u32 methods_pending);

    /// Write the value to the register identified by method.
-    void CallMethodFromMME(u32 method, u32 method_argument);
+    void CallMethodFromMME(const GPU::MethodCall& method_call);

    void FlushMMEInlineDraw();

@@ -17,16 +17,16 @@ namespace Tegra::Engines {
 MaxwellDMA::MaxwellDMA(Core::System& system, MemoryManager& memory_manager)
    : system{system}, memory_manager{memory_manager} {}

-void MaxwellDMA::CallMethod(u32 method, u32 method_argument, bool is_last_call) {
-    ASSERT_MSG(method < Regs::NUM_REGS,
+void MaxwellDMA::CallMethod(const GPU::MethodCall& method_call) {
+    ASSERT_MSG(method_call.method < Regs::NUM_REGS,
               "Invalid MaxwellDMA register, increase the size of the Regs structure");

-    regs.reg_array[method] = method_argument;
+    regs.reg_array[method_call.method] = method_call.argument;

 #define MAXWELLDMA_REG_INDEX(field_name)                                                           \
    (offsetof(Tegra::Engines::MaxwellDMA::Regs, field_name) / sizeof(u32))

-    switch (method) {
+    switch (method_call.method) {
    case MAXWELLDMA_REG_INDEX(exec): {
        HandleCopy();
        break;
@@ -39,7 +39,7 @@ void MaxwellDMA::CallMethod(u32 method, u32 method_argument, bool is_last_call)
 void MaxwellDMA::CallMultiMethod(u32 method, const u32* base_start, u32 amount,
                                 u32 methods_pending) {
    for (std::size_t i = 0; i < amount; i++) {
-        CallMethod(method, base_start[i], methods_pending - static_cast<u32>(i) <= 1);
+        CallMethod({method, base_start[i], 0, methods_pending - static_cast<u32>(i)});
    }
 }

@@ -90,47 +90,7 @@ void MaxwellDMA::HandleCopy() {
    ASSERT(regs.exec.enable_2d == 1);

    if (regs.exec.is_dst_linear && !regs.exec.is_src_linear) {
-
        ASSERT(regs.src_params.BlockDepth() == 0);
-        // Optimized path for micro copies.
-        if (regs.dst_pitch * regs.y_count < Texture::GetGOBSize() && regs.dst_pitch <= 64) {
-            const u32 bytes_per_pixel = regs.dst_pitch / regs.x_count;
-            const std::size_t src_size = Texture::GetGOBSize();
-            const std::size_t dst_size = regs.dst_pitch * regs.y_count;
-            u32 pos_x = regs.src_params.pos_x;
-            u32 pos_y = regs.src_params.pos_y;
-            const u64 offset =
-                Texture::GetGOBOffset(regs.src_params.size_x, regs.src_params.size_y, pos_x, pos_y,
-                                      regs.src_params.BlockDepth(), bytes_per_pixel);
-            const u32 x_in_gob = 64 / bytes_per_pixel;
-            pos_x = pos_x % x_in_gob;
-            pos_y = pos_y % 8;
-
-            if (read_buffer.size() < src_size) {
-                read_buffer.resize(src_size);
-            }
-
-            if (write_buffer.size() < dst_size) {
-                write_buffer.resize(dst_size);
-            }
-
-            if (Settings::IsGPULevelExtreme()) {
-                memory_manager.ReadBlock(source + offset, read_buffer.data(), src_size);
-                memory_manager.ReadBlock(dest, write_buffer.data(), dst_size);
-            } else {
-                memory_manager.ReadBlockUnsafe(source + offset, read_buffer.data(), src_size);
-                memory_manager.ReadBlockUnsafe(dest, write_buffer.data(), dst_size);
-            }
-
-            Texture::UnswizzleSubrect(regs.x_count, regs.y_count, regs.dst_pitch,
-                                      regs.src_params.size_x, bytes_per_pixel, read_buffer.data(),
-                                      write_buffer.data(), regs.src_params.BlockHeight(), pos_x,
-                                      pos_y);
-
-            memory_manager.WriteBlock(dest, write_buffer.data(), dst_size);
-
-            return;
-        }
        // If the input is tiled and the output is linear, deswizzle the input and copy it over.
        const u32 bytes_per_pixel = regs.dst_pitch / regs.x_count;
        const std::size_t src_size = Texture::CalculateSize(
@@ -10,7 +10,6 @@
 #include "common/bit_field.h"
 #include "common/common_funcs.h"
 #include "common/common_types.h"
-#include "video_core/engines/engine_interface.h"
 #include "video_core/gpu.h"

 namespace Core {
@@ -28,17 +27,16 @@ namespace Tegra::Engines {
 * https://github.com/envytools/envytools/blob/master/rnndb/fifo/gk104_copy.xml
 */

-class MaxwellDMA final : public EngineInterface {
+class MaxwellDMA final {
 public:
    explicit MaxwellDMA(Core::System& system, MemoryManager& memory_manager);
    ~MaxwellDMA() = default;

    /// Write the value to the register identified by method.
-    void CallMethod(u32 method, u32 method_argument, bool is_last_call) override;
+    void CallMethod(const GPU::MethodCall& method_call);

    /// Write multiple values to the register identified by method.
-    void CallMultiMethod(u32 method, const u32* base_start, u32 amount,
-                         u32 methods_pending) override;
+    void CallMultiMethod(u32 method, const u32* base_start, u32 amount, u32 methods_pending);

    struct Regs {
        static constexpr std::size_t NUM_REGS = 0x1D6;
@@ -168,22 +168,18 @@ enum class Pred : u64 {
 };

 enum class PredCondition : u64 {
-    F = 0,    // Always false
-    LT = 1,   // Ordered less than
-    EQ = 2,   // Ordered equal
-    LE = 3,   // Ordered less than or equal
-    GT = 4,   // Ordered greater than
-    NE = 5,   // Ordered not equal
-    GE = 6,   // Ordered greater than or equal
-    NUM = 7,  // Ordered
-    NAN_ = 8, // Unordered
-    LTU = 9,  // Unordered less than
-    EQU = 10, // Unordered equal
-    LEU = 11, // Unordered less than or equal
-    GTU = 12, // Unordered greater than
-    NEU = 13, // Unordered not equal
-    GEU = 14, // Unordered greater than or equal
-    T = 15,   // Always true
+    LessThan = 1,
+    Equal = 2,
+    LessEqual = 3,
+    GreaterThan = 4,
+    NotEqual = 5,
+    GreaterEqual = 6,
+    LessThanWithNan = 9,
+    LessEqualWithNan = 11,
+    GreaterThanWithNan = 12,
+    NotEqualWithNan = 13,
+    GreaterEqualWithNan = 14,
+    // TODO(Subv): Other condition types
 };

 enum class PredOperation : u64 {
@@ -299,21 +299,19 @@ void GPU::CallEngineMethod(const MethodCall& method_call) {

    switch (engine) {
    case EngineID::FERMI_TWOD_A:
-        fermi_2d->CallMethod(method_call.method, method_call.argument, method_call.IsLastCall());
+        fermi_2d->CallMethod(method_call);
        break;
    case EngineID::MAXWELL_B:
-        maxwell_3d->CallMethod(method_call.method, method_call.argument, method_call.IsLastCall());
+        maxwell_3d->CallMethod(method_call);
        break;
    case EngineID::KEPLER_COMPUTE_B:
-        kepler_compute->CallMethod(method_call.method, method_call.argument,
-                                   method_call.IsLastCall());
+        kepler_compute->CallMethod(method_call);
        break;
    case EngineID::MAXWELL_DMA_COPY_A:
-        maxwell_dma->CallMethod(method_call.method, method_call.argument, method_call.IsLastCall());
+        maxwell_dma->CallMethod(method_call);
        break;
    case EngineID::KEPLER_INLINE_TO_MEMORY_B:
-        kepler_memory->CallMethod(method_call.method, method_call.argument,
-                                  method_call.IsLastCall());
+        kepler_memory->CallMethod(method_call);
        break;
    default:
        UNIMPLEMENTED_MSG("Unimplemented engine");
@@ -349,27 +347,7 @@ void GPU::ProcessBindMethod(const MethodCall& method_call) {
    // Bind the current subchannel to the desired engine id.
    LOG_DEBUG(HW_GPU, "Binding subchannel {} to engine {}", method_call.subchannel,
              method_call.argument);
-    const auto engine_id = static_cast<EngineID>(method_call.argument);
-    bound_engines[method_call.subchannel] = static_cast<EngineID>(engine_id);
-    switch (engine_id) {
-    case EngineID::FERMI_TWOD_A:
-        dma_pusher->BindSubchannel(fermi_2d.get(), method_call.subchannel);
-        break;
-    case EngineID::MAXWELL_B:
-        dma_pusher->BindSubchannel(maxwell_3d.get(), method_call.subchannel);
-        break;
-    case EngineID::KEPLER_COMPUTE_B:
-        dma_pusher->BindSubchannel(kepler_compute.get(), method_call.subchannel);
-        break;
-    case EngineID::MAXWELL_DMA_COPY_A:
-        dma_pusher->BindSubchannel(maxwell_dma.get(), method_call.subchannel);
-        break;
-    case EngineID::KEPLER_INLINE_TO_MEMORY_B:
-        dma_pusher->BindSubchannel(kepler_memory.get(), method_call.subchannel);
-        break;
-    default:
-        UNIMPLEMENTED_MSG("Unimplemented engine {:04X}", static_cast<u32>(engine_id));
-    }
+    bound_engines[method_call.subchannel] = static_cast<EngineID>(method_call.argument);
 }

 void GPU::ProcessSemaphoreTriggerMethod() {
@@ -68,7 +68,6 @@ enum class RenderTargetFormat : u32 {
    BGR5A1_UNORM = 0xE9,
    RG8_UNORM = 0xEA,
    RG8_SNORM = 0xEB,
-    RG8_UINT = 0xED,
    R16_UNORM = 0xEE,
    R16_SNORM = 0xEF,
    R16_SINT = 0xF0,
@@ -328,7 +328,7 @@ void MacroInterpreter::SetMethodAddress(u32 address) {
 }

 void MacroInterpreter::Send(u32 value) {
-    maxwell3d.CallMethodFromMME(method_address.address, value);
+    maxwell3d.CallMethodFromMME({method_address.address, value});
    // Increment the method address by the method increment.
    method_address.address.Assign(method_address.address.Value() +
                                  method_address.increment.Value());
@@ -83,7 +83,6 @@ static constexpr ConversionArray morton_to_linear_fns = {
    MortonCopy<true, PixelFormat::RGBA8_SRGB>,
    MortonCopy<true, PixelFormat::RG8U>,
    MortonCopy<true, PixelFormat::RG8S>,
-    MortonCopy<true, PixelFormat::RG8UI>,
    MortonCopy<true, PixelFormat::RG32UI>,
    MortonCopy<true, PixelFormat::RGBX16F>,
    MortonCopy<true, PixelFormat::R32UI>,
@@ -167,7 +166,6 @@ static constexpr ConversionArray linear_to_morton_fns = {
    MortonCopy<false, PixelFormat::RGBA8_SRGB>,
    MortonCopy<false, PixelFormat::RG8U>,
    MortonCopy<false, PixelFormat::RG8S>,
-    MortonCopy<false, PixelFormat::RG8UI>,
    MortonCopy<false, PixelFormat::RG32UI>,
    MortonCopy<false, PixelFormat::RGBX16F>,
    MortonCopy<false, PixelFormat::R32UI>,
@@ -1019,14 +1019,6 @@ void RasterizerOpenGL::SyncViewport() {
            const GLdouble near_depth = src.translate_z - src.scale_z * reduce_z;
            const GLdouble far_depth = src.translate_z + src.scale_z;
            glDepthRangeIndexed(static_cast<GLuint>(i), near_depth, far_depth);
-
-            if (!GLAD_GL_NV_viewport_swizzle) {
-                continue;
-            }
-            glViewportSwizzleNV(static_cast<GLuint>(i), MaxwellToGL::ViewportSwizzle(src.swizzle.x),
-                                MaxwellToGL::ViewportSwizzle(src.swizzle.y),
-                                MaxwellToGL::ViewportSwizzle(src.swizzle.z),
-                                MaxwellToGL::ViewportSwizzle(src.swizzle.w));
        }
    }
 }
@@ -1840,40 +1840,34 @@ private:
                Type::HalfFloat};
    }

-    template <const std::string_view& op, Type type, bool unordered = false>
-    Expression Comparison(Operation operation) {
-        static_assert(!unordered || type == Type::Float);
-
-        const Expression expr = GenerateBinaryInfix(operation, op, Type::Bool, type, type);
-
-        if constexpr (op.compare("!=") == 0 && type == Type::Float && !unordered) {
-            // GLSL's operator!=(float, float) doesn't seem be ordered. This happens on both AMD's
-            // and Nvidia's proprietary stacks. Manually force an ordered comparison.
-            return {fmt::format("({} && !isnan({}) && !isnan({}))", expr.AsBool(),
-                                VisitOperand(operation, 0).AsFloat(),
-                                VisitOperand(operation, 1).AsFloat()),
-                    Type::Bool};
-        }
-        if constexpr (!unordered) {
-            return expr;
-        }
-        // Unordered comparisons are always true for NaN operands.
-        return {fmt::format("({} || isnan({}) || isnan({}))", expr.AsBool(),
-                            VisitOperand(operation, 0).AsFloat(),
-                            VisitOperand(operation, 1).AsFloat()),
-                Type::Bool};
+    template <Type type>
+    Expression LogicalLessThan(Operation operation) {
+        return GenerateBinaryInfix(operation, "<", Type::Bool, type, type);
    }

-    Expression FOrdered(Operation operation) {
-        return {fmt::format("(!isnan({}) && !isnan({}))", VisitOperand(operation, 0).AsFloat(),
-                            VisitOperand(operation, 1).AsFloat()),
-                Type::Bool};
+    template <Type type>
+    Expression LogicalEqual(Operation operation) {
+        return GenerateBinaryInfix(operation, "==", Type::Bool, type, type);
    }

-    Expression FUnordered(Operation operation) {
-        return {fmt::format("(isnan({}) || isnan({}))", VisitOperand(operation, 0).AsFloat(),
-                            VisitOperand(operation, 1).AsFloat()),
-                Type::Bool};
+    template <Type type>
+    Expression LogicalLessEqual(Operation operation) {
+        return GenerateBinaryInfix(operation, "<=", Type::Bool, type, type);
+    }
+
+    template <Type type>
+    Expression LogicalGreaterThan(Operation operation) {
+        return GenerateBinaryInfix(operation, ">", Type::Bool, type, type);
+    }
+
+    template <Type type>
+    Expression LogicalNotEqual(Operation operation) {
+        return GenerateBinaryInfix(operation, "!=", Type::Bool, type, type);
+    }
+
+    template <Type type>
+    Expression LogicalGreaterEqual(Operation operation) {
+        return GenerateBinaryInfix(operation, ">=", Type::Bool, type, type);
    }

    Expression LogicalAddCarry(Operation operation) {
@@ -2330,13 +2324,6 @@ private:
        Func() = delete;
        ~Func() = delete;

-        static constexpr std::string_view LessThan = "<";
-        static constexpr std::string_view Equal = "==";
-        static constexpr std::string_view LessEqual = "<=";
-        static constexpr std::string_view GreaterThan = ">";
-        static constexpr std::string_view NotEqual = "!=";
-        static constexpr std::string_view GreaterEqual = ">=";
-
        static constexpr std::string_view Add = "Add";
        static constexpr std::string_view Min = "Min";
        static constexpr std::string_view Max = "Max";
@@ -2438,34 +2425,27 @@ private:
        &GLSLDecompiler::LogicalPick2,
        &GLSLDecompiler::LogicalAnd2,

-        &GLSLDecompiler::Comparison<Func::LessThan, Type::Float, false>,
-        &GLSLDecompiler::Comparison<Func::Equal, Type::Float, false>,
-        &GLSLDecompiler::Comparison<Func::LessEqual, Type::Float, false>,
-        &GLSLDecompiler::Comparison<Func::GreaterThan, Type::Float, false>,
-        &GLSLDecompiler::Comparison<Func::NotEqual, Type::Float, false>,
-        &GLSLDecompiler::Comparison<Func::GreaterEqual, Type::Float, false>,
-        &GLSLDecompiler::FOrdered,
-        &GLSLDecompiler::FUnordered,
-        &GLSLDecompiler::Comparison<Func::LessThan, Type::Float, true>,
-        &GLSLDecompiler::Comparison<Func::Equal, Type::Float, true>,
-        &GLSLDecompiler::Comparison<Func::LessEqual, Type::Float, true>,
-        &GLSLDecompiler::Comparison<Func::GreaterThan, Type::Float, true>,
-        &GLSLDecompiler::Comparison<Func::NotEqual, Type::Float, true>,
-        &GLSLDecompiler::Comparison<Func::GreaterEqual, Type::Float, true>,
+        &GLSLDecompiler::LogicalLessThan<Type::Float>,
+        &GLSLDecompiler::LogicalEqual<Type::Float>,
+        &GLSLDecompiler::LogicalLessEqual<Type::Float>,
+        &GLSLDecompiler::LogicalGreaterThan<Type::Float>,
+        &GLSLDecompiler::LogicalNotEqual<Type::Float>,
+        &GLSLDecompiler::LogicalGreaterEqual<Type::Float>,
+        &GLSLDecompiler::LogicalFIsNan,

-        &GLSLDecompiler::Comparison<Func::LessThan, Type::Int>,
-        &GLSLDecompiler::Comparison<Func::Equal, Type::Int>,
-        &GLSLDecompiler::Comparison<Func::LessEqual, Type::Int>,
-        &GLSLDecompiler::Comparison<Func::GreaterThan, Type::Int>,
-        &GLSLDecompiler::Comparison<Func::NotEqual, Type::Int>,
-        &GLSLDecompiler::Comparison<Func::GreaterEqual, Type::Int>,
+        &GLSLDecompiler::LogicalLessThan<Type::Int>,
+        &GLSLDecompiler::LogicalEqual<Type::Int>,
+        &GLSLDecompiler::LogicalLessEqual<Type::Int>,
+        &GLSLDecompiler::LogicalGreaterThan<Type::Int>,
+        &GLSLDecompiler::LogicalNotEqual<Type::Int>,
+        &GLSLDecompiler::LogicalGreaterEqual<Type::Int>,

-        &GLSLDecompiler::Comparison<Func::LessThan, Type::Uint>,
-        &GLSLDecompiler::Comparison<Func::Equal, Type::Uint>,
-        &GLSLDecompiler::Comparison<Func::LessEqual, Type::Uint>,
-        &GLSLDecompiler::Comparison<Func::GreaterThan, Type::Uint>,
-        &GLSLDecompiler::Comparison<Func::NotEqual, Type::Uint>,
-        &GLSLDecompiler::Comparison<Func::GreaterEqual, Type::Uint>,
+        &GLSLDecompiler::LogicalLessThan<Type::Uint>,
+        &GLSLDecompiler::LogicalEqual<Type::Uint>,
+        &GLSLDecompiler::LogicalLessEqual<Type::Uint>,
+        &GLSLDecompiler::LogicalGreaterThan<Type::Uint>,
+        &GLSLDecompiler::LogicalNotEqual<Type::Uint>,
+        &GLSLDecompiler::LogicalGreaterEqual<Type::Uint>,

        &GLSLDecompiler::LogicalAddCarry,

@@ -83,7 +83,6 @@ constexpr std::array<FormatTuple, VideoCore::Surface::MaxPixelFormat> tex_format
    {GL_SRGB8_ALPHA8, GL_RGBA, GL_UNSIGNED_INT_8_8_8_8_REV},      // RGBA8_SRGB
    {GL_RG8, GL_RG, GL_UNSIGNED_BYTE},                            // RG8U
    {GL_RG8_SNORM, GL_RG, GL_BYTE},                               // RG8S
-    {GL_RG8UI, GL_RG_INTEGER, GL_UNSIGNED_INT},                   // RG8UI
    {GL_RG32UI, GL_RG_INTEGER, GL_UNSIGNED_INT},                  // RG32UI
    {GL_RGB16F, GL_RGBA, GL_HALF_FLOAT},                          // RGBX16F
    {GL_R32UI, GL_RED_INTEGER, GL_UNSIGNED_INT},                  // R32UI
@@ -503,10 +503,5 @@ inline GLenum PolygonMode(Maxwell::PolygonMode polygon_mode) {
    return GL_FILL;
 }

-inline GLenum ViewportSwizzle(Maxwell::ViewportSwizzle swizzle) {
-    // Enumeration order matches register order. We can convert it arithmetically.
-    return GL_VIEWPORT_SWIZZLE_POSITIVE_X_NV + static_cast<GLenum>(swizzle);
-}
-
 } // namespace MaxwellToGL
 } // namespace OpenGL
@@ -753,9 +753,6 @@ void RendererOpenGL::RenderScreenshot() {
 bool RendererOpenGL::Init() {
    if (GLAD_GL_KHR_debug) {
        glEnable(GL_DEBUG_OUTPUT);
-        if (Settings::values.renderer_debug) {
-            glEnable(GL_DEBUG_OUTPUT_SYNCHRONOUS);
-        }
        glDebugMessageCallback(DebugHandler, nullptr);
    }

@@ -2,7 +2,6 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.

-#include <algorithm>
 #include <cstring>
 #include <tuple>

@@ -93,7 +92,6 @@ void FixedPipelineState::Rasterizer::Fill(const Maxwell& regs) noexcept {
    tessellation_clockwise.Assign(regs.tess_mode.cw.Value());
    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
 }

@@ -103,12 +101,6 @@ void FixedPipelineState::ColorBlending::Fill(const Maxwell& regs) noexcept {
    }
 }

-void FixedPipelineState::ViewportSwizzles::Fill(const Maxwell& regs) noexcept {
-    const auto& transform = regs.viewport_transform;
-    std::transform(transform.begin(), transform.end(), swizzles.begin(),
-                   [](const auto& viewport) { return static_cast<u16>(viewport.swizzle.raw); });
-}
-
 void FixedPipelineState::BlendingAttachment::Fill(const Maxwell& regs, std::size_t index) {
    const auto& mask = regs.color_mask[regs.color_mask_common ? 0 : index];

@@ -152,7 +144,6 @@ 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 {
@@ -164,7 +164,6 @@ struct FixedPipelineState {
            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;
        };

        // TODO(Rodrigo): Move this to push constants
@@ -234,17 +233,10 @@ struct FixedPipelineState {
        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);

@@ -160,7 +160,6 @@ struct FormatTuple {
    {VK_FORMAT_R8G8B8A8_SRGB, Attachable},                      // RGBA8_SRGB
    {VK_FORMAT_R8G8_UNORM, Attachable | Storage},               // RG8U
    {VK_FORMAT_R8G8_SNORM, Attachable | Storage},               // RG8S
-    {VK_FORMAT_R8G8_UINT, Attachable | Storage},                // RG8UI
    {VK_FORMAT_R32G32_UINT, Attachable | Storage},              // RG32UI
    {VK_FORMAT_UNDEFINED},                                      // RGBX16F
    {VK_FORMAT_R32_UINT, Attachable | Storage},                 // R32UI
@@ -346,6 +345,8 @@ VkFormat VertexFormat(Maxwell::VertexAttribute::Type type, Maxwell::VertexAttrib
        break;
    case Maxwell::VertexAttribute::Type::SignedInt:
        switch (size) {
+        case Maxwell::VertexAttribute::Size::Size_16_16_16_16:
+            return VK_FORMAT_R16G16B16A16_SINT;
        case Maxwell::VertexAttribute::Size::Size_8:
            return VK_FORMAT_R8_SINT;
        case Maxwell::VertexAttribute::Size::Size_8_8:
@@ -354,22 +355,8 @@ VkFormat VertexFormat(Maxwell::VertexAttribute::Type type, Maxwell::VertexAttrib
            return VK_FORMAT_R8G8B8_SINT;
        case Maxwell::VertexAttribute::Size::Size_8_8_8_8:
            return VK_FORMAT_R8G8B8A8_SINT;
-        case Maxwell::VertexAttribute::Size::Size_16:
-            return VK_FORMAT_R16_SINT;
-        case Maxwell::VertexAttribute::Size::Size_16_16:
-            return VK_FORMAT_R16G16_SINT;
-        case Maxwell::VertexAttribute::Size::Size_16_16_16:
-            return VK_FORMAT_R16G16B16_SINT;
-        case Maxwell::VertexAttribute::Size::Size_16_16_16_16:
-            return VK_FORMAT_R16G16B16A16_SINT;
        case Maxwell::VertexAttribute::Size::Size_32:
            return VK_FORMAT_R32_SINT;
-        case Maxwell::VertexAttribute::Size::Size_32_32:
-            return VK_FORMAT_R32G32_SINT;
-        case Maxwell::VertexAttribute::Size::Size_32_32_32:
-            return VK_FORMAT_R32G32B32_SINT;
-        case Maxwell::VertexAttribute::Size::Size_32_32_32_32:
-            return VK_FORMAT_R32G32B32A32_SINT;
        default:
            break;
        }
@@ -685,27 +672,4 @@ VkComponentSwizzle SwizzleSource(Tegra::Texture::SwizzleSource swizzle) {
    return {};
 }

-VkViewportCoordinateSwizzleNV ViewportSwizzle(Maxwell::ViewportSwizzle swizzle) {
-    switch (swizzle) {
-    case Maxwell::ViewportSwizzle::PositiveX:
-        return VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_X_NV;
-    case Maxwell::ViewportSwizzle::NegativeX:
-        return VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_X_NV;
-    case Maxwell::ViewportSwizzle::PositiveY:
-        return VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Y_NV;
-    case Maxwell::ViewportSwizzle::NegativeY:
-        return VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Y_NV;
-    case Maxwell::ViewportSwizzle::PositiveZ:
-        return VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Z_NV;
-    case Maxwell::ViewportSwizzle::NegativeZ:
-        return VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Z_NV;
-    case Maxwell::ViewportSwizzle::PositiveW:
-        return VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_W_NV;
-    case Maxwell::ViewportSwizzle::NegativeW:
-        return VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_W_NV;
-    }
-    UNREACHABLE_MSG("Invalid swizzle={}", static_cast<int>(swizzle));
-    return {};
-}
-
 } // namespace Vulkan::MaxwellToVK
Author	SHA1	Message	Date
yuzubot	b4cdaa755a	"Merge Tagged PR 1012"	2020-05-04 12:01:20 +00:00
yuzubot	43e79d9b97	"Merge Tagged PR 1340"	2020-05-04 12:01:19 +00:00
yuzubot	9586aae9b3	"Merge Tagged PR 1703"	2020-05-04 12:01:19 +00:00
yuzubot	4833ce69d6	"Merge Tagged PR 3345"	2020-05-04 12:01:17 +00:00
yuzubot	e0641fd61e	"Merge Tagged PR 3665"	2020-05-04 12:01:16 +00:00
yuzubot	51c31f9f37	"Merge Tagged PR 3757"	2020-05-04 12:01:16 +00:00