add UUID validation check

Co-authored-by: VolcaEM <63682805+VolcaEM@users.noreply.github.com>

.ci/scripts/format/exec.sh

@@ -1,4 +1,7 @@
 #!/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 ./

.ci/scripts/linux/exec.sh

@@ -2,4 +2,7 @@
 
 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 ./

.ci/scripts/windows/docker.sh

@@ -4,22 +4,10 @@ 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"

.ci/scripts/windows/exec.sh

@@ -2,4 +2,7 @@
 
 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 ./

.ci/templates/build-msvc.yml

@@ -4,7 +4,9 @@ parameters:
   version: ''
 
 steps:
-- 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 ..
+- 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 ..
   displayName: 'Configure CMake'
 - task: MSBuild@1
   displayName: 'Build'

.ci/yuzu-patreon-step2.yml

@@ -5,18 +5,7 @@ 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

.gitmodules

@@ -1,54 +1,30 @@
 [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

CMakeLists.txt

@@ -1,7 +1,8 @@
-cmake_minimum_required(VERSION 3.7)
+cmake_minimum_required(VERSION 3.11)
 
 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)
 
@@ -10,10 +11,9 @@ 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" ON "ENABLE_QT;MSVC" OFF)
+CMAKE_DEPENDENT_OPTION(YUZU_USE_BUNDLED_QT "Download bundled Qt binaries" OFF "ENABLE_QT;MSVC" OFF)
 
 option(ENABLE_WEB_SERVICE "Enable web services (telemetry, etc.)" ON)
 
@@ -29,6 +29,13 @@ 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
@@ -53,7 +60,6 @@ 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)
@@ -115,63 +121,227 @@ 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)
@@ -212,8 +382,12 @@ 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}" /bin/sh make.sh cross-win64
+                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
                 WORKING_DIRECTORY ${UNICORN_PREFIX}
             )
         else()
@@ -243,32 +417,6 @@ 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
 # ======================================
 
@@ -299,7 +447,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)
+    if (WIN32 AND NOT CMAKE_CROSSCOMPILING)
         message(STATUS "Clang format not found! Downloading...")
         set(CLANG_FORMAT "${PROJECT_BINARY_DIR}/externals/clang-format${CLANG_FORMAT_POSTFIX}.exe")
         file(DOWNLOAD

externals/CMakeLists.txt

@@ -1,30 +1,13 @@
 # Definitions for all external bundled libraries
 
-set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} ${PROJECT_SOURCE_DIR}/CMakeModules)
+list(APPEND CMAKE_MODULE_PATH "${PROJECT_SOURCE_DIR}/CMakeModules")
+list(APPEND CMAKE_MODULE_PATH "${PROJECT_SOURCE_DIR}/externals/find-modules")
 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)
@@ -43,17 +26,6 @@ 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)
@@ -66,29 +38,9 @@ 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 "")
@@ -106,37 +58,14 @@ 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
-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")
+find_package(Libzip 1.5)
+if (NOT LIBZIP_FOUND)
+    message(STATUS "libzip 1.5 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)
 
@@ -144,9 +73,5 @@ 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_LIBRARIES})
-
-    # JSON
-    add_library(json-headers INTERFACE)
-    target_include_directories(json-headers INTERFACE ./json)
+    target_link_libraries(httplib INTERFACE OpenSSL::SSL OpenSSL::Crypto)
 endif()

externals/find-modules/FindCatch2.cmake

@@ -0,0 +1,49 @@
+
+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
+)

externals/find-modules/FindLibzip.cmake

@@ -0,0 +1,72 @@
+
+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
+)

externals/find-modules/Findfmt.cmake

@@ -0,0 +1,69 @@
+
+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
+)

externals/find-modules/Findlz4.cmake

@@ -0,0 +1,54 @@
+
+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
+)

externals/find-modules/Findnlohmann_json.cmake

@@ -0,0 +1,49 @@
+
+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
+)

externals/find-modules/Findopus.cmake

@@ -0,0 +1,42 @@
+
+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
+)

externals/find-modules/Findzstd.cmake

@@ -0,0 +1,55 @@
+
+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
+)

externals/json/README.md

@@ -1,9 +0,0 @@
-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

externals/opus/CMakeLists.txt

@@ -1,254 +0,0 @@
-cmake_minimum_required(VERSION 3.8)
-
-project(opus)
-
-option(OPUS_STACK_PROTECTOR "Use stack protection" OFF)
-option(OPUS_USE_ALLOCA "Use alloca for stack arrays (on non-C99 compilers)" OFF)
-option(OPUS_CUSTOM_MODES "Enable non-Opus modes, e.g. 44.1 kHz & 2^n frames" OFF)
-option(OPUS_FIXED_POINT "Compile as fixed-point (for machines without a fast enough FPU)" OFF)
-option(OPUS_ENABLE_FLOAT_API "Compile with the floating point API (for machines with float library" ON)
-
-include(opus/opus_functions.cmake)
-
-if(OPUS_STACK_PROTECTOR)
-    if(NOT MSVC) # GC on by default on MSVC
-        check_and_set_flag(STACK_PROTECTION_STRONG -fstack-protector-strong)
-    endif()
-else()
-    if(MSVC)
-        check_and_set_flag(BUFFER_SECURITY_CHECK /GS-)
-    endif()
-endif()
-
-add_library(opus STATIC
-    # CELT sources
-    opus/celt/bands.c
-    opus/celt/celt.c
-    opus/celt/celt_decoder.c
-    opus/celt/celt_encoder.c
-    opus/celt/celt_lpc.c
-    opus/celt/cwrs.c
-    opus/celt/entcode.c
-    opus/celt/entdec.c
-    opus/celt/entenc.c
-    opus/celt/kiss_fft.c
-    opus/celt/laplace.c
-    opus/celt/mathops.c
-    opus/celt/mdct.c
-    opus/celt/modes.c
-    opus/celt/pitch.c
-    opus/celt/quant_bands.c
-    opus/celt/rate.c
-    opus/celt/vq.c
-
-    # SILK sources
-    opus/silk/A2NLSF.c
-    opus/silk/CNG.c
-    opus/silk/HP_variable_cutoff.c
-    opus/silk/LPC_analysis_filter.c
-    opus/silk/LPC_fit.c
-    opus/silk/LPC_inv_pred_gain.c
-    opus/silk/LP_variable_cutoff.c
-    opus/silk/NLSF2A.c
-    opus/silk/NLSF_VQ.c
-    opus/silk/NLSF_VQ_weights_laroia.c
-    opus/silk/NLSF_decode.c
-    opus/silk/NLSF_del_dec_quant.c
-    opus/silk/NLSF_encode.c
-    opus/silk/NLSF_stabilize.c
-    opus/silk/NLSF_unpack.c
-    opus/silk/NSQ.c
-    opus/silk/NSQ_del_dec.c
-    opus/silk/PLC.c
-    opus/silk/VAD.c
-    opus/silk/VQ_WMat_EC.c
-    opus/silk/ana_filt_bank_1.c
-    opus/silk/biquad_alt.c
-    opus/silk/bwexpander.c
-    opus/silk/bwexpander_32.c
-    opus/silk/check_control_input.c
-    opus/silk/code_signs.c
-    opus/silk/control_SNR.c
-    opus/silk/control_audio_bandwidth.c
-    opus/silk/control_codec.c
-    opus/silk/dec_API.c
-    opus/silk/decode_core.c
-    opus/silk/decode_frame.c
-    opus/silk/decode_indices.c
-    opus/silk/decode_parameters.c
-    opus/silk/decode_pitch.c
-    opus/silk/decode_pulses.c
-    opus/silk/decoder_set_fs.c
-    opus/silk/enc_API.c
-    opus/silk/encode_indices.c
-    opus/silk/encode_pulses.c
-    opus/silk/gain_quant.c
-    opus/silk/init_decoder.c
-    opus/silk/init_encoder.c
-    opus/silk/inner_prod_aligned.c
-    opus/silk/interpolate.c
-    opus/silk/lin2log.c
-    opus/silk/log2lin.c
-    opus/silk/pitch_est_tables.c
-    opus/silk/process_NLSFs.c
-    opus/silk/quant_LTP_gains.c
-    opus/silk/resampler.c
-    opus/silk/resampler_down2.c
-    opus/silk/resampler_down2_3.c
-    opus/silk/resampler_private_AR2.c
-    opus/silk/resampler_private_IIR_FIR.c
-    opus/silk/resampler_private_down_FIR.c
-    opus/silk/resampler_private_up2_HQ.c
-    opus/silk/resampler_rom.c
-    opus/silk/shell_coder.c
-    opus/silk/sigm_Q15.c
-    opus/silk/sort.c
-    opus/silk/stereo_LR_to_MS.c
-    opus/silk/stereo_MS_to_LR.c
-    opus/silk/stereo_decode_pred.c
-    opus/silk/stereo_encode_pred.c
-    opus/silk/stereo_find_predictor.c
-    opus/silk/stereo_quant_pred.c
-    opus/silk/sum_sqr_shift.c
-    opus/silk/table_LSF_cos.c
-    opus/silk/tables_LTP.c
-    opus/silk/tables_NLSF_CB_NB_MB.c
-    opus/silk/tables_NLSF_CB_WB.c
-    opus/silk/tables_gain.c
-    opus/silk/tables_other.c
-    opus/silk/tables_pitch_lag.c
-    opus/silk/tables_pulses_per_block.c
-
-    # Opus sources
-    opus/src/analysis.c
-    opus/src/mapping_matrix.c
-    opus/src/mlp.c
-    opus/src/mlp_data.c
-    opus/src/opus.c
-    opus/src/opus_decoder.c
-    opus/src/opus_encoder.c
-    opus/src/opus_multistream.c
-    opus/src/opus_multistream_decoder.c
-    opus/src/opus_multistream_encoder.c
-    opus/src/opus_projection_decoder.c
-    opus/src/opus_projection_encoder.c
-    opus/src/repacketizer.c
-)
-
-if (DEBUG)
-    target_sources(opus PRIVATE opus/silk/debug.c)
-endif()
-
-if (OPUS_FIXED_POINT)
-    target_sources(opus PRIVATE
-        opus/silk/fixed/LTP_analysis_filter_FIX.c
-        opus/silk/fixed/LTP_scale_ctrl_FIX.c
-        opus/silk/fixed/apply_sine_window_FIX.c
-        opus/silk/fixed/autocorr_FIX.c
-        opus/silk/fixed/burg_modified_FIX.c
-        opus/silk/fixed/corrMatrix_FIX.c
-        opus/silk/fixed/encode_frame_FIX.c
-        opus/silk/fixed/find_LPC_FIX.c
-        opus/silk/fixed/find_LTP_FIX.c
-        opus/silk/fixed/find_pitch_lags_FIX.c
-        opus/silk/fixed/find_pred_coefs_FIX.c
-        opus/silk/fixed/k2a_FIX.c
-        opus/silk/fixed/k2a_Q16_FIX.c
-        opus/silk/fixed/noise_shape_analysis_FIX.c
-        opus/silk/fixed/pitch_analysis_core_FIX.c
-        opus/silk/fixed/prefilter_FIX.c
-        opus/silk/fixed/process_gains_FIX.c
-        opus/silk/fixed/regularize_correlations_FIX.c
-        opus/silk/fixed/residual_energy16_FIX.c
-        opus/silk/fixed/residual_energy_FIX.c
-        opus/silk/fixed/schur64_FIX.c
-        opus/silk/fixed/schur_FIX.c
-        opus/silk/fixed/solve_LS_FIX.c
-        opus/silk/fixed/vector_ops_FIX.c
-        opus/silk/fixed/warped_autocorrelation_FIX.c
-    )
-else()
-    target_sources(opus PRIVATE
-        opus/silk/float/LPC_analysis_filter_FLP.c
-        opus/silk/float/LPC_inv_pred_gain_FLP.c
-        opus/silk/float/LTP_analysis_filter_FLP.c
-        opus/silk/float/LTP_scale_ctrl_FLP.c
-        opus/silk/float/apply_sine_window_FLP.c
-        opus/silk/float/autocorrelation_FLP.c
-        opus/silk/float/burg_modified_FLP.c
-        opus/silk/float/bwexpander_FLP.c
-        opus/silk/float/corrMatrix_FLP.c
-        opus/silk/float/encode_frame_FLP.c
-        opus/silk/float/energy_FLP.c
-        opus/silk/float/find_LPC_FLP.c
-        opus/silk/float/find_LTP_FLP.c
-        opus/silk/float/find_pitch_lags_FLP.c
-        opus/silk/float/find_pred_coefs_FLP.c
-        opus/silk/float/inner_product_FLP.c
-        opus/silk/float/k2a_FLP.c
-        opus/silk/float/noise_shape_analysis_FLP.c
-        opus/silk/float/pitch_analysis_core_FLP.c
-        opus/silk/float/process_gains_FLP.c
-        opus/silk/float/regularize_correlations_FLP.c
-        opus/silk/float/residual_energy_FLP.c
-        opus/silk/float/scale_copy_vector_FLP.c
-        opus/silk/float/scale_vector_FLP.c
-        opus/silk/float/schur_FLP.c
-        opus/silk/float/sort_FLP.c
-        opus/silk/float/warped_autocorrelation_FLP.c
-        opus/silk/float/wrappers_FLP.c
-    )
-endif()
-
-target_compile_definitions(opus PRIVATE OPUS_BUILD ENABLE_HARDENING)
-
-if(NOT MSVC)
-    if(MINGW)
-        target_compile_definitions(opus PRIVATE _FORTIFY_SOURCE=0)
-    else()
-        target_compile_definitions(opus PRIVATE _FORTIFY_SOURCE=2)
-    endif()
-endif()
-
-# It is strongly recommended to uncomment one of these VAR_ARRAYS: Use C99
-# variable-length arrays for stack allocation USE_ALLOCA: Use alloca() for stack
-# allocation If none is defined, then the fallback is a non-threadsafe global
-# array
-if(OPUS_USE_ALLOCA OR MSVC)
-    target_compile_definitions(opus PRIVATE USE_ALLOCA)
-else()
-    target_compile_definitions(opus PRIVATE VAR_ARRAYS)
-endif()
-
-if(OPUS_CUSTOM_MODES)
-    target_compile_definitions(opus PRIVATE CUSTOM_MODES)
-endif()
-
-if(NOT OPUS_ENABLE_FLOAT_API)
-    target_compile_definitions(opus PRIVATE DISABLE_FLOAT_API)
-endif()
-
-target_compile_definitions(opus
-PUBLIC
-    -DOPUS_VERSION="\\"1.3.1\\""
-
-PRIVATE
-    # Use C99 intrinsics to speed up float-to-int conversion
-    HAVE_LRINTF
-)
-
-if (FIXED_POINT)
-    target_compile_definitions(opus PRIVATE -DFIXED_POINT=1 -DDISABLE_FLOAT_API)
-endif()
-
-target_include_directories(opus
-PUBLIC
-    opus/include
-
-PRIVATE
-    opus/celt
-    opus/silk
-    opus/silk/fixed
-    opus/silk/float
-    opus/src
-)

externals/zlib/CMakeLists.txt

@@ -1,81 +0,0 @@
-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/
-)

src/audio_core/audio_renderer.cpp

@@ -17,7 +17,7 @@ namespace AudioCore {
 
 constexpr u32 STREAM_SAMPLE_RATE{48000};
 constexpr u32 STREAM_NUM_CHANNELS{2};
-
+using VoiceChannelHolder = std::array<VoiceResourceInformation*, 6>;
 class AudioRenderer::VoiceState {
 public:
     bool IsPlaying() const {
@@ -37,9 +37,10 @@ public:
     }
 
     void SetWaveIndex(std::size_t index);
-    std::vector<s16> DequeueSamples(std::size_t sample_count, Core::Memory::Memory& memory);
+    std::vector<s16> DequeueSamples(std::size_t sample_count, Core::Memory::Memory& memory,
+                                    const VoiceChannelHolder& voice_resources);
     void UpdateState();
-    void RefreshBuffer(Core::Memory::Memory& memory);
+    void RefreshBuffer(Core::Memory::Memory& memory, const VoiceChannelHolder& voice_resources);
 
 private:
     bool is_in_use{};
@@ -79,7 +80,7 @@ AudioRenderer::AudioRenderer(Core::Timing::CoreTiming& core_timing, Core::Memory
                              std::shared_ptr<Kernel::WritableEvent> buffer_event,
                              std::size_t instance_number)
     : worker_params{params}, buffer_event{buffer_event}, voices(params.voice_count),
-      effects(params.effect_count), memory{memory_} {
+      voice_resources(params.voice_count), effects(params.effect_count), memory{memory_} {
     behavior_info.SetUserRevision(params.revision);
     audio_out = std::make_unique<AudioCore::AudioOut>();
     stream = audio_out->OpenStream(core_timing, STREAM_SAMPLE_RATE, STREAM_NUM_CHANNELS,
@@ -127,6 +128,12 @@ ResultVal<std::vector<u8>> AudioRenderer::UpdateAudioRenderer(const std::vector<
                 input_params.data() + sizeof(UpdateDataHeader) + config.behavior_size,
                 memory_pool_count * sizeof(MemoryPoolInfo));
 
+    // Copy voice resources
+    const std::size_t voice_resource_offset{sizeof(UpdateDataHeader) + config.behavior_size +
+                                            config.memory_pools_size};
+    std::memcpy(voice_resources.data(), input_params.data() + voice_resource_offset,
+                sizeof(VoiceResourceInformation) * voice_resources.size());
+
     // Copy VoiceInfo structs
     std::size_t voice_offset{sizeof(UpdateDataHeader) + config.behavior_size +
                              config.memory_pools_size + config.voice_resource_size};
@@ -220,14 +227,15 @@ void AudioRenderer::VoiceState::SetWaveIndex(std::size_t index) {
     is_refresh_pending = true;
 }
 
-std::vector<s16> AudioRenderer::VoiceState::DequeueSamples(std::size_t sample_count,
-                                                           Core::Memory::Memory& memory) {
+std::vector<s16> AudioRenderer::VoiceState::DequeueSamples(
+    std::size_t sample_count, Core::Memory::Memory& memory,
+    const VoiceChannelHolder& voice_resources) {
     if (!IsPlaying()) {
         return {};
     }
 
     if (is_refresh_pending) {
-        RefreshBuffer(memory);
+        RefreshBuffer(memory, voice_resources);
     }
 
     const std::size_t max_size{samples.size() - offset};
@@ -271,7 +279,8 @@ void AudioRenderer::VoiceState::UpdateState() {
     is_in_use = info.is_in_use;
 }
 
-void AudioRenderer::VoiceState::RefreshBuffer(Core::Memory::Memory& memory) {
+void AudioRenderer::VoiceState::RefreshBuffer(Core::Memory::Memory& memory,
+                                              const VoiceChannelHolder& voice_resources) {
     const auto wave_buffer_address = info.wave_buffer[wave_index].buffer_addr;
     const auto wave_buffer_size = info.wave_buffer[wave_index].buffer_sz;
     std::vector<s16> new_samples(wave_buffer_size / sizeof(s16));
@@ -296,17 +305,77 @@ void AudioRenderer::VoiceState::RefreshBuffer(Core::Memory::Memory& memory) {
     }
 
     switch (info.channel_count) {
-    case 1:
+    case 1: {
         // 1 channel is upsampled to 2 channel
         samples.resize(new_samples.size() * 2);
+
         for (std::size_t index = 0; index < new_samples.size(); ++index) {
-            samples[index * 2] = new_samples[index];
-            samples[index * 2 + 1] = new_samples[index];
+            auto sample = static_cast<float>(new_samples[index]);
+            if (voice_resources[0]->in_use) {
+                sample *= voice_resources[0]->mix_volumes[0];
+            }
+
+            samples[index * 2] = static_cast<s16>(sample * info.volume);
+            samples[index * 2 + 1] = static_cast<s16>(sample * info.volume);
         }
         break;
+    }
     case 2: {
         // 2 channel is played as is
         samples = std::move(new_samples);
+        const std::size_t sample_count = (samples.size() / 2);
+        for (std::size_t index = 0; index < sample_count; ++index) {
+            const std::size_t index_l = index * 2;
+            const std::size_t index_r = index * 2 + 1;
+
+            auto sample_l = static_cast<float>(samples[index_l]);
+            auto sample_r = static_cast<float>(samples[index_r]);
+
+            if (voice_resources[0]->in_use) {
+                sample_l *= voice_resources[0]->mix_volumes[0];
+            }
+
+            if (voice_resources[1]->in_use) {
+                sample_r *= voice_resources[1]->mix_volumes[1];
+            }
+
+            samples[index_l] = static_cast<s16>(sample_l * info.volume);
+            samples[index_r] = static_cast<s16>(sample_r * info.volume);
+        }
+        break;
+    }
+    case 6: {
+        samples.resize((new_samples.size() / 6) * 2);
+        const std::size_t sample_count = samples.size() / 2;
+
+        for (std::size_t index = 0; index < sample_count; ++index) {
+            auto FL = static_cast<float>(new_samples[index * 6]);
+            auto FR = static_cast<float>(new_samples[index * 6 + 1]);
+            auto FC = static_cast<float>(new_samples[index * 6 + 2]);
+            auto BL = static_cast<float>(new_samples[index * 6 + 4]);
+            auto BR = static_cast<float>(new_samples[index * 6 + 5]);
+
+            if (voice_resources[0]->in_use) {
+                FL *= voice_resources[0]->mix_volumes[0];
+            }
+            if (voice_resources[1]->in_use) {
+                FR *= voice_resources[1]->mix_volumes[1];
+            }
+            if (voice_resources[2]->in_use) {
+                FC *= voice_resources[2]->mix_volumes[2];
+            }
+            if (voice_resources[4]->in_use) {
+                BL *= voice_resources[4]->mix_volumes[4];
+            }
+            if (voice_resources[5]->in_use) {
+                BR *= voice_resources[5]->mix_volumes[5];
+            }
+
+            samples[index * 2] =
+                static_cast<s16>((0.3694f * FL + 0.2612f * FC + 0.3694f * BL) * info.volume);
+            samples[index * 2 + 1] =
+                static_cast<s16>((0.3694f * FR + 0.2612f * FC + 0.3694f * BR) * info.volume);
+        }
         break;
     }
     default:
@@ -352,11 +421,17 @@ void AudioRenderer::QueueMixedBuffer(Buffer::Tag tag) {
         if (!voice.IsPlaying()) {
             continue;
         }
+        VoiceChannelHolder resources{};
+        for (u32 channel = 0; channel < voice.GetInfo().channel_count; channel++) {
+            const auto channel_resource_id = voice.GetInfo().voice_channel_resource_ids[channel];
+            resources[channel] = &voice_resources[channel_resource_id];
+        }
 
         std::size_t offset{};
         s64 samples_remaining{BUFFER_SIZE};
         while (samples_remaining > 0) {
-            const std::vector<s16> samples{voice.DequeueSamples(samples_remaining, memory)};
+            const std::vector<s16> samples{
+                voice.DequeueSamples(samples_remaining, memory, resources)};
 
             if (samples.empty()) {
                 break;

src/audio_core/audio_renderer.h

@@ -9,6 +9,7 @@
 #include <vector>
 
 #include "audio_core/behavior_info.h"
+#include "audio_core/common.h"
 #include "audio_core/stream.h"
 #include "common/common_funcs.h"
 #include "common/common_types.h"
@@ -116,6 +117,14 @@ struct WaveBuffer {
 };
 static_assert(sizeof(WaveBuffer) == 0x38, "WaveBuffer has wrong size");
 
+struct VoiceResourceInformation {
+    s32_le id{};
+    std::array<float_le, MAX_MIX_BUFFERS> mix_volumes{};
+    bool in_use{};
+    INSERT_PADDING_BYTES(11);
+};
+static_assert(sizeof(VoiceResourceInformation) == 0x70, "VoiceResourceInformation has wrong size");
+
 struct VoiceInfo {
     u32_le id;
     u32_le node_id;
@@ -244,6 +253,7 @@ private:
     AudioRendererParameter worker_params;
     std::shared_ptr<Kernel::WritableEvent> buffer_event;
     std::vector<VoiceState> voices;
+    std::vector<VoiceResourceInformation> voice_resources;
     std::vector<EffectState> effects;
     std::unique_ptr<AudioOut> audio_out;
     StreamPtr stream;

src/audio_core/common.h

@@ -14,6 +14,7 @@ constexpr ResultCode ERR_INVALID_PARAMETERS{ErrorModule::Audio, 41};
 }
 
 constexpr u32_le CURRENT_PROCESS_REVISION = Common::MakeMagic('R', 'E', 'V', '8');
+constexpr std::size_t MAX_MIX_BUFFERS = 24;
 
 static constexpr u32 VersionFromRevision(u32_le rev) {
     // "REV7" -> 7

src/common/CMakeLists.txt

@@ -148,6 +148,8 @@ 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
@@ -172,5 +174,5 @@ endif()
 
 create_target_directory_groups(common)
 
-target_link_libraries(common PUBLIC Boost::boost fmt microprofile)
-target_link_libraries(common PRIVATE lz4_static libzstd_static)
+target_link_libraries(common PUBLIC Boost::boost fmt::fmt microprofile)
+target_link_libraries(common PRIVATE lz4::lz4 zstd::zstd)

src/common/time_zone.cpp

@@ -0,0 +1,49 @@
+// 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

src/common/time_zone.h

@@ -0,0 +1,18 @@
+// 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

src/common/uuid.h

@@ -40,6 +40,11 @@ struct UUID {
         uuid = INVALID_UUID;
     }
 
+    // TODO(ogniK): Properly generate a Nintendo ID
+    constexpr u64 GetNintendoID() const {
+        return uuid[0];
+    }
+
     std::string Format() const;
     std::string FormatSwitch() const;
 };

src/core/CMakeLists.txt

@@ -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 json-headers mbedtls opus unicorn)
+target_link_libraries(core PUBLIC Boost::boost PRIVATE fmt::fmt nlohmann_json::nlohmann_json mbedtls Opus::Opus unicorn)
 
 if (YUZU_ENABLE_BOXCAT)
     target_compile_definitions(core PRIVATE -DYUZU_ENABLE_BOXCAT)
-    target_link_libraries(core PRIVATE httplib json-headers zip)
+    target_link_libraries(core PRIVATE httplib nlohmann_json::nlohmann_json zip)
 endif()
 
 if (ENABLE_WEB_SERVICE)

src/core/file_sys/control_metadata.cpp

@@ -95,6 +95,10 @@ u32 NACP::GetSupportedLanguages() const {
     return raw.supported_languages;
 }
 
+u64 NACP::GetDeviceSaveDataSize() const {
+    return raw.device_save_data_size;
+}
+
 std::vector<u8> NACP::GetRawBytes() const {
     std::vector<u8> out(sizeof(RawNACP));
     std::memcpy(out.data(), &raw, sizeof(RawNACP));

src/core/file_sys/control_metadata.h

@@ -113,6 +113,7 @@ public:
     u32 GetSupportedLanguages() const;
     std::vector<u8> GetRawBytes() const;
     bool GetUserAccountSwitchLock() const;
+    u64 GetDeviceSaveDataSize() const;
 
 private:
     RawNACP raw{};

src/core/file_sys/savedata_factory.cpp

@@ -57,7 +57,8 @@ void PrintSaveDataDescriptorWarnings(SaveDataDescriptor meta) {
 bool ShouldSaveDataBeAutomaticallyCreated(SaveDataSpaceId space, const SaveDataDescriptor& desc) {
     return desc.type == SaveDataType::CacheStorage || desc.type == SaveDataType::TemporaryStorage ||
            (space == SaveDataSpaceId::NandUser && ///< Normal Save Data -- Current Title & User
-            desc.type == SaveDataType::SaveData && desc.title_id == 0 && desc.save_id == 0);
+            (desc.type == SaveDataType::SaveData || desc.type == SaveDataType::DeviceSaveData) &&
+            desc.title_id == 0 && desc.save_id == 0);
 }
 
 } // Anonymous namespace
@@ -139,8 +140,10 @@ std::string SaveDataFactory::GetFullPath(SaveDataSpaceId space, SaveDataType typ
                                          u128 user_id, u64 save_id) {
     // According to switchbrew, if a save is of type SaveData and the title id field is 0, it should
     // be interpreted as the title id of the current process.
-    if (type == SaveDataType::SaveData && title_id == 0) {
-        title_id = Core::System::GetInstance().CurrentProcess()->GetTitleID();
+    if (type == SaveDataType::SaveData || type == SaveDataType::DeviceSaveData) {
+        if (title_id == 0) {
+            title_id = Core::System::GetInstance().CurrentProcess()->GetTitleID();
+        }
     }
 
     std::string out = GetSaveDataSpaceIdPath(space);

src/core/frontend/emu_window.cpp

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

src/core/frontend/framebuffer_layout.h

@@ -8,6 +8,11 @@
 
 namespace Layout {
 
+namespace MinimumSize {
+constexpr u32 Width = 640;
+constexpr u32 Height = 360;
+} // namespace MinimumSize
+
 namespace ScreenUndocked {
 constexpr u32 Width = 1280;
 constexpr u32 Height = 720;

src/core/hle/kernel/memory/address_space_info.cpp

@@ -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 Atmosphère, an open-source firmware for
-// the Nintendo Switch. Copyright 2018-2020 Atmosphère-NX.
+// This file references various implementation details from Atmosphere, an open-source firmware for
+// the Nintendo Switch. Copyright 2018-2020 Atmosphere-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::size_t
-    AddressSpaceIndices32Bit[static_cast<std::size_t>(AddressSpaceInfo::Type::Count)]{
+constexpr std::array<std::size_t, static_cast<std::size_t>(AddressSpaceInfo::Type::Count)>
+    AddressSpaceIndices32Bit{
         0, 1, 0, 2, 0, 3,
     };
 
-constexpr std::size_t
-    AddressSpaceIndices36Bit[static_cast<std::size_t>(AddressSpaceInfo::Type::Count)]{
+constexpr std::array<std::size_t, static_cast<std::size_t>(AddressSpaceInfo::Type::Count)>
+    AddressSpaceIndices36Bit{
         4, 5, 4, 6, 4, 7,
     };
 
-constexpr std::size_t
-    AddressSpaceIndices39Bit[static_cast<std::size_t>(AddressSpaceInfo::Type::Count)]{
+constexpr std::array<std::size_t, static_cast<std::size_t>(AddressSpaceInfo::Type::Count)>
+    AddressSpaceIndices39Bit{
         9, 8, 8, 10, 12, 11,
     };
 

src/core/hle/kernel/memory/address_space_info.h

@@ -2,12 +2,11 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
-// This file references various implementation details from Atmosphère, an open-source firmware for
-// the Nintendo Switch. Copyright 2018-2020 Atmosphère-NX.
+// This file references various implementation details from Atmosphere, an open-source firmware for
+// the Nintendo Switch. Copyright 2018-2020 Atmosphere-NX.
 
 #pragma once
 
-#include "common/common_funcs.h"
 #include "common/common_types.h"
 
 namespace Kernel::Memory {

src/core/hle/kernel/memory/memory_block.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 Atmosphère, an open-source firmware for
-// the Nintendo Switch. Copyright 2018-2020 Atmosphère-NX.
+// This file references various implementation details from Atmosphere, an open-source firmware for
+// the Nintendo Switch. Copyright 2018-2020 Atmosphere-NX.
 
 #pragma once
 

src/core/hle/kernel/memory/memory_block_manager.cpp

@@ -67,7 +67,6 @@ 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()};
 
@@ -109,7 +108,6 @@ 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()};
 
@@ -145,7 +143,6 @@ 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()};
 

src/core/hle/kernel/memory/memory_block_manager.h

@@ -6,7 +6,6 @@
 
 #include <functional>
 #include <list>
-#include <memory>
 
 #include "common/common_types.h"
 #include "core/hle/kernel/memory/memory_block.h"

src/core/hle/kernel/memory/memory_manager.cpp

@@ -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 num_pages{std::min(
+            const auto min_num_pages{std::min(
                 it.GetNumPages(), (chosen_manager.GetEndAddress() - it.GetAddress()) / PageSize)};
-            chosen_manager.Free(it.GetAddress(), num_pages);
+            chosen_manager.Free(it.GetAddress(), min_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 num_pages{std::min(
+        const auto min_num_pages{std::min(
             it.GetNumPages(), (chosen_manager.GetEndAddress() - it.GetAddress()) / PageSize)};
-        chosen_manager.Free(it.GetAddress(), num_pages);
+        chosen_manager.Free(it.GetAddress(), min_num_pages);
     }
 
     return RESULT_SUCCESS;

src/core/hle/kernel/memory/memory_manager.h

@@ -7,7 +7,6 @@
 #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"

src/core/hle/kernel/memory/page_heap.cpp

@@ -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 Atmosphère, an open-source firmware for
-// the Nintendo Switch. Copyright 2018-2020 Atmosphère-NX.
+// This file references various implementation details from Atmosphere, an open-source firmware for
+// the Nintendo Switch. Copyright 2018-2020 Atmosphere-NX.
 
 #include "core/core.h"
 #include "core/hle/kernel/memory/page_heap.h"

src/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 Atmosphère, an open-source firmware for
-// the Nintendo Switch. Copyright 2018-2020 Atmosphère-NX.
+// This file references various implementation details from Atmosphere, an open-source firmware for
+// the Nintendo Switch. Copyright 2018-2020 Atmosphere-NX.
 
 #pragma once
 

src/core/hle/kernel/memory/page_linked_list.h

@@ -7,7 +7,6 @@
 #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"

src/core/hle/kernel/memory/page_table.cpp

@@ -6,7 +6,6 @@
 #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"

src/core/hle/kernel/memory/page_table.h

@@ -4,16 +4,15 @@
 
 #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;

src/core/hle/kernel/memory/slab_heap.h

@@ -2,15 +2,14 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
-// This file references various implementation details from Atmosphère, an open-source firmware for
-// the Nintendo Switch. Copyright 2018-2020 Atmosphère-NX.
+// This file references various implementation details from Atmosphere, an open-source firmware for
+// the Nintendo Switch. Copyright 2018-2020 Atmosphere-NX.
 
 #pragma once
 
 #include <atomic>
 
 #include "common/assert.h"
-#include "common/common_funcs.h"
 #include "common/common_types.h"
 
 namespace Kernel::Memory {

src/core/hle/kernel/memory/system_control.cpp

@@ -2,8 +2,6 @@
 // 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"

src/core/hle/service/acc/acc.cpp

@@ -228,7 +228,8 @@ public:
 
 class IManagerForApplication final : public ServiceFramework<IManagerForApplication> {
 public:
-    IManagerForApplication() : ServiceFramework("IManagerForApplication") {
+    explicit IManagerForApplication(Common::UUID user_id)
+        : ServiceFramework("IManagerForApplication"), user_id(user_id) {
         // clang-format off
         static const FunctionInfo functions[] = {
             {0, &IManagerForApplication::CheckAvailability, "CheckAvailability"},
@@ -254,12 +255,14 @@ private:
     }
 
     void GetAccountId(Kernel::HLERequestContext& ctx) {
-        LOG_WARNING(Service_ACC, "(STUBBED) called");
-        // Should return a nintendo account ID
+        LOG_DEBUG(Service_ACC, "called");
+
         IPC::ResponseBuilder rb{ctx, 4};
         rb.Push(RESULT_SUCCESS);
-        rb.PushRaw<u64>(1);
+        rb.PushRaw<u64>(user_id.GetNintendoID());
     }
+
+    Common::UUID user_id;
 };
 
 void Module::Interface::GetUserCount(Kernel::HLERequestContext& ctx) {
@@ -382,7 +385,7 @@ void Module::Interface::GetBaasAccountManagerForApplication(Kernel::HLERequestCo
     LOG_DEBUG(Service_ACC, "called");
     IPC::ResponseBuilder rb{ctx, 2, 0, 1};
     rb.Push(RESULT_SUCCESS);
-    rb.PushIpcInterface<IManagerForApplication>();
+    rb.PushIpcInterface<IManagerForApplication>(profile_manager->GetLastOpenedUser());
 }
 
 void Module::Interface::IsUserAccountSwitchLocked(Kernel::HLERequestContext& ctx) {

src/core/hle/service/am/am.cpp

@@ -1525,14 +1525,15 @@ void InstallInterfaces(SM::ServiceManager& service_manager,
     std::make_shared<TCAP>()->InstallAsService(service_manager);
 }
 
-IHomeMenuFunctions::IHomeMenuFunctions() : ServiceFramework("IHomeMenuFunctions") {
+IHomeMenuFunctions::IHomeMenuFunctions(Kernel::KernelCore& kernel)
+    : ServiceFramework("IHomeMenuFunctions"), kernel(kernel) {
     // clang-format off
     static const FunctionInfo functions[] = {
         {10, &IHomeMenuFunctions::RequestToGetForeground, "RequestToGetForeground"},
         {11, nullptr, "LockForeground"},
         {12, nullptr, "UnlockForeground"},
         {20, nullptr, "PopFromGeneralChannel"},
-        {21, nullptr, "GetPopFromGeneralChannelEvent"},
+        {21, &IHomeMenuFunctions::GetPopFromGeneralChannelEvent, "GetPopFromGeneralChannelEvent"},
         {30, nullptr, "GetHomeButtonWriterLockAccessor"},
         {31, nullptr, "GetWriterLockAccessorEx"},
         {100, nullptr, "PopRequestLaunchApplicationForDebug"},
@@ -1542,6 +1543,9 @@ IHomeMenuFunctions::IHomeMenuFunctions() : ServiceFramework("IHomeMenuFunctions"
     // clang-format on
 
     RegisterHandlers(functions);
+
+    pop_from_general_channel_event = Kernel::WritableEvent::CreateEventPair(
+        kernel, "IHomeMenuFunctions:PopFromGeneralChannelEvent");
 }
 
 IHomeMenuFunctions::~IHomeMenuFunctions() = default;
@@ -1553,6 +1557,14 @@ 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[] = {

src/core/hle/service/am/am.h

@@ -292,11 +292,15 @@ private:
 
 class IHomeMenuFunctions final : public ServiceFramework<IHomeMenuFunctions> {
 public:
-    IHomeMenuFunctions();
+    explicit IHomeMenuFunctions(Kernel::KernelCore& kernel);
     ~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> {

src/core/hle/service/am/applet_ae.cpp

@@ -202,7 +202,7 @@ private:
 
         IPC::ResponseBuilder rb{ctx, 2, 0, 1};
         rb.Push(RESULT_SUCCESS);
-        rb.PushIpcInterface<IHomeMenuFunctions>();
+        rb.PushIpcInterface<IHomeMenuFunctions>(system.Kernel());
     }
 
     void GetGlobalStateController(Kernel::HLERequestContext& ctx) {

src/core/hle/service/bcat/backend/boxcat.cpp

@@ -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"

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

@@ -767,7 +767,7 @@ FSP_SRV::FSP_SRV(FileSystemController& fsc, const Core::Reporter& reporter)
         {1014, nullptr, "OutputMultiProgramTagAccessLog"},
         {1100, nullptr, "OverrideSaveDataTransferTokenSignVerificationKey"},
         {1110, nullptr, "CorruptSaveDataFileSystemBySaveDataSpaceId2"},
-        {1200, nullptr, "OpenMultiCommitManager"},
+        {1200, &FSP_SRV::OpenMultiCommitManager, "OpenMultiCommitManager"},
         {1300, nullptr, "OpenBisWiper"},
     };
     // clang-format on
@@ -988,4 +988,40 @@ void FSP_SRV::GetAccessLogVersionInfo(Kernel::HLERequestContext& ctx) {
     rb.Push(access_log_program_index);
 }
 
+class IMultiCommitManager final : public ServiceFramework<IMultiCommitManager> {
+public:
+    explicit IMultiCommitManager() : ServiceFramework("IMultiCommitManager") {
+        static const FunctionInfo functions[] = {
+            {1, &IMultiCommitManager::Add, "Add"},
+            {2, &IMultiCommitManager::Commit, "Commit"},
+        };
+        RegisterHandlers(functions);
+    }
+
+private:
+    FileSys::VirtualFile backend;
+
+    void Add(Kernel::HLERequestContext& ctx) {
+        LOG_WARNING(Service_FS, "(STUBBED) called");
+
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(RESULT_SUCCESS);
+    }
+
+    void Commit(Kernel::HLERequestContext& ctx) {
+        LOG_WARNING(Service_FS, "(STUBBED) called");
+
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(RESULT_SUCCESS);
+    }
+};
+
+void FSP_SRV::OpenMultiCommitManager(Kernel::HLERequestContext& ctx) {
+    LOG_DEBUG(Service_FS, "called");
+
+    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
+    rb.Push(RESULT_SUCCESS);
+    rb.PushIpcInterface<IMultiCommitManager>(std::make_shared<IMultiCommitManager>());
+}
+
 } // namespace Service::FileSystem

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

@@ -50,6 +50,7 @@ private:
     void OpenPatchDataStorageByCurrentProcess(Kernel::HLERequestContext& ctx);
     void OutputAccessLogToSdCard(Kernel::HLERequestContext& ctx);
     void GetAccessLogVersionInfo(Kernel::HLERequestContext& ctx);
+    void OpenMultiCommitManager(Kernel::HLERequestContext& ctx);
 
     FileSystemController& fsc;
 

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

@@ -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, nullptr, "SendKeyboardLockKeyEvent"},
+        {32, &Hid::SendKeyboardLockKeyEvent, "SendKeyboardLockKeyEvent"},
         {40, nullptr, "AcquireXpadIdEventHandle"},
         {41, nullptr, "ReleaseXpadIdEventHandle"},
         {51, &Hid::ActivateXpad, "ActivateXpad"},
@@ -871,6 +871,15 @@ 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"} {

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

@@ -130,6 +130,7 @@ 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;

src/core/hle/service/nvflinger/buffer_queue.cpp

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

src/core/hle/service/nvflinger/buffer_queue.h

@@ -66,6 +66,16 @@ 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 };
 

src/core/hle/service/time/time_manager.cpp

@@ -5,6 +5,7 @@
 #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"
@@ -21,8 +22,16 @@ 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();
+    return GetSecondsSinceEpoch().count() + GetExternalTimeZoneOffset();
 }
 
 TimeManager::TimeManager(Core::System& system)

src/core/hle/service/time/time_zone_content_manager.cpp

@@ -5,6 +5,7 @@
 #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"
@@ -14,6 +15,7 @@
 #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 {
 
@@ -68,10 +70,22 @@ static std::vector<std::string> BuildLocationNameCache(Core::System& system) {
 
 TimeZoneContentManager::TimeZoneContentManager(TimeManager& time_manager, Core::System& system)
     : system{system}, location_name_cache{BuildLocationNameCache(system)} {
-    if (FileSys::VirtualFile vfs_file; GetTimeZoneInfoFile("GMT", vfs_file) == RESULT_SUCCESS) {
+
+    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) {
         const auto time_point{
             time_manager.GetStandardSteadyClockCore().GetCurrentTimePoint(system)};
-        time_manager.SetupTimeZoneManager("GMT", time_point, location_name_cache.size(), {},
+        time_manager.SetupTimeZoneManager(location_name, time_point, location_name_cache.size(), {},
                                           vfs_file);
     } else {
         time_zone_manager.MarkAsInitialized();
@@ -113,6 +127,12 @@ 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);

src/core/reporter.cpp

@@ -4,11 +4,12 @@
 
 #include <ctime>
 #include <fstream>
+#include <iomanip>
 
 #include <fmt/chrono.h>
 #include <fmt/format.h>
 #include <fmt/ostream.h>
-#include <json.hpp>
+#include <nlohmann/json.hpp>
 
 #include "common/file_util.h"
 #include "common/hex_util.h"

src/core/settings.cpp

@@ -63,6 +63,21 @@ 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);
@@ -87,6 +102,7 @@ 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);

src/core/settings.h

@@ -394,6 +394,7 @@ struct Values {
     s32 current_user;
     s32 language_index;
     s32 region_index;
+    s32 time_zone_index;
     s32 sound_index;
 
     // Controls
@@ -490,6 +491,9 @@ struct Values {
 bool IsGPULevelExtreme();
 bool IsGPULevelHigh();
 
+std::string GetTimeZoneString();
+
 void Apply();
 void LogSettings();
+
 } // namespace Settings

src/video_core/CMakeLists.txt

@@ -8,6 +8,7 @@ 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

src/video_core/dma_pusher.cpp

@@ -27,6 +27,8 @@ void DmaPusher::DispatchCalls() {
 
     dma_pushbuffer_subindex = 0;
 
+    dma_state.is_last_call = true;
+
     while (system.IsPoweredOn()) {
         if (!Step()) {
             break;
@@ -52,9 +54,7 @@ bool DmaPusher::Step() {
         return true;
     });
     const CommandListHeader command_list_header{command_list[dma_pushbuffer_subindex++]};
-    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;
+    const GPUVAddr dma_get = command_list_header.addr;
 
     if (dma_pushbuffer_subindex >= command_list.size()) {
         // We've gone through the current list, remove it from the queue
@@ -82,9 +82,11 @@ 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);
             }
 
@@ -129,11 +131,6 @@ 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;
 }
 
@@ -144,12 +141,22 @@ void DmaPusher::SetState(const CommandHeader& command_header) {
 }
 
 void DmaPusher::CallMethod(u32 argument) const {
-    gpu.CallMethod({dma_state.method, argument, dma_state.subchannel, dma_state.method_count});
+    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);
+    }
 }
 
 void DmaPusher::CallMultiMethod(const u32* base_start, u32 num_methods) const {
-    gpu.CallMultiMethod(dma_state.method, dma_state.subchannel, base_start, num_methods,
-                        dma_state.method_count);
+    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);
+    }
 }
 
 } // namespace Tegra

src/video_core/dma_pusher.h

@@ -4,11 +4,13 @@
 
 #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;
@@ -69,7 +71,13 @@ 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);
@@ -88,14 +96,16 @@ 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;
 };

src/video_core/engines/engine_interface.h

@@ -0,0 +1,22 @@
+// 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

src/video_core/engines/fermi_2d.cpp

@@ -12,13 +12,13 @@ namespace Tegra::Engines {
 
 Fermi2D::Fermi2D(VideoCore::RasterizerInterface& rasterizer) : rasterizer{rasterizer} {}
 
-void Fermi2D::CallMethod(const GPU::MethodCall& method_call) {
-    ASSERT_MSG(method_call.method < Regs::NUM_REGS,
+void Fermi2D::CallMethod(u32 method, u32 method_argument, bool is_last_call) {
+    ASSERT_MSG(method < Regs::NUM_REGS,
                "Invalid Fermi2D register, increase the size of the Regs structure");
 
-    regs.reg_array[method_call.method] = method_call.argument;
+    regs.reg_array[method] = method_argument;
 
-    switch (method_call.method) {
+    switch (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(const GPU::MethodCall& method_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], 0, methods_pending - static_cast<u32>(i)});
+        CallMethod(method, base_start[i], methods_pending - static_cast<u32>(i) <= 1);
     }
 }
 

src/video_core/engines/fermi_2d.h

@@ -10,6 +10,7 @@
 #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 {
@@ -31,16 +32,17 @@ namespace Tegra::Engines {
 #define FERMI2D_REG_INDEX(field_name)                                                              \
     (offsetof(Tegra::Engines::Fermi2D::Regs, field_name) / sizeof(u32))
 
-class Fermi2D final {
+class Fermi2D final : public EngineInterface {
 public:
     explicit Fermi2D(VideoCore::RasterizerInterface& rasterizer);
     ~Fermi2D() = default;
 
     /// Write the value to the register identified by method.
-    void CallMethod(const GPU::MethodCall& method_call);
+    void CallMethod(u32 method, u32 method_argument, bool is_last_call) override;
 
     /// Write multiple values to the register identified by method.
-    void CallMultiMethod(u32 method, const u32* base_start, u32 amount, u32 methods_pending);
+    void CallMultiMethod(u32 method, const u32* base_start, u32 amount,
+                         u32 methods_pending) override;
 
     enum class Origin : u32 {
         Center = 0,

src/video_core/engines/kepler_compute.cpp

@@ -24,20 +24,19 @@ KeplerCompute::KeplerCompute(Core::System& system, VideoCore::RasterizerInterfac
 
 KeplerCompute::~KeplerCompute() = default;
 
-void KeplerCompute::CallMethod(const GPU::MethodCall& method_call) {
-    ASSERT_MSG(method_call.method < Regs::NUM_REGS,
+void KeplerCompute::CallMethod(u32 method, u32 method_argument, bool is_last_call) {
+    ASSERT_MSG(method < Regs::NUM_REGS,
                "Invalid KeplerCompute register, increase the size of the Regs structure");
 
-    regs.reg_array[method_call.method] = method_call.argument;
+    regs.reg_array[method] = method_argument;
 
-    switch (method_call.method) {
+    switch (method) {
     case KEPLER_COMPUTE_REG_INDEX(exec_upload): {
         upload_state.ProcessExec(regs.exec_upload.linear != 0);
         break;
     }
     case KEPLER_COMPUTE_REG_INDEX(data_upload): {
-        const bool is_last_call = method_call.IsLastCall();
-        upload_state.ProcessData(method_call.argument, is_last_call);
+        upload_state.ProcessData(method_argument, is_last_call);
         if (is_last_call) {
             system.GPU().Maxwell3D().OnMemoryWrite();
         }
@@ -54,7 +53,7 @@ void KeplerCompute::CallMethod(const GPU::MethodCall& method_call) {
 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], 0, methods_pending - static_cast<u32>(i)});
+        CallMethod(method, base_start[i], methods_pending - static_cast<u32>(i) <= 1);
     }
 }
 

src/video_core/engines/kepler_compute.h

@@ -11,6 +11,7 @@
 #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"
@@ -39,7 +40,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 {
+class KeplerCompute final : public ConstBufferEngineInterface, public EngineInterface {
 public:
     explicit KeplerCompute(Core::System& system, VideoCore::RasterizerInterface& rasterizer,
                            MemoryManager& memory_manager);
@@ -200,10 +201,11 @@ public:
                   "KeplerCompute LaunchParams has wrong size");
 
     /// Write the value to the register identified by method.
-    void CallMethod(const GPU::MethodCall& method_call);
+    void CallMethod(u32 method, u32 method_argument, bool is_last_call) override;
 
     /// Write multiple values to the register identified by method.
-    void CallMultiMethod(u32 method, const u32* base_start, u32 amount, u32 methods_pending);
+    void CallMultiMethod(u32 method, const u32* base_start, u32 amount,
+                         u32 methods_pending) override;
 
     Texture::FullTextureInfo GetTexture(std::size_t offset) const;
 

src/video_core/engines/kepler_memory.cpp

@@ -19,20 +19,19 @@ KeplerMemory::KeplerMemory(Core::System& system, MemoryManager& memory_manager)
 
 KeplerMemory::~KeplerMemory() = default;
 
-void KeplerMemory::CallMethod(const GPU::MethodCall& method_call) {
-    ASSERT_MSG(method_call.method < Regs::NUM_REGS,
+void KeplerMemory::CallMethod(u32 method, u32 method_argument, bool is_last_call) {
+    ASSERT_MSG(method < Regs::NUM_REGS,
                "Invalid KeplerMemory register, increase the size of the Regs structure");
 
-    regs.reg_array[method_call.method] = method_call.argument;
+    regs.reg_array[method] = method_argument;
 
-    switch (method_call.method) {
+    switch (method) {
     case KEPLERMEMORY_REG_INDEX(exec): {
         upload_state.ProcessExec(regs.exec.linear != 0);
         break;
     }
     case KEPLERMEMORY_REG_INDEX(data): {
-        const bool is_last_call = method_call.IsLastCall();
-        upload_state.ProcessData(method_call.argument, is_last_call);
+        upload_state.ProcessData(method_argument, is_last_call);
         if (is_last_call) {
             system.GPU().Maxwell3D().OnMemoryWrite();
         }
@@ -44,7 +43,7 @@ void KeplerMemory::CallMethod(const GPU::MethodCall& method_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], 0, methods_pending - static_cast<u32>(i)});
+        CallMethod(method, base_start[i], methods_pending - static_cast<u32>(i) <= 1);
     }
 }
 

src/video_core/engines/kepler_memory.h

@@ -10,6 +10,7 @@
 #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"
 
@@ -32,16 +33,17 @@ namespace Tegra::Engines {
 #define KEPLERMEMORY_REG_INDEX(field_name)                                                         \
     (offsetof(Tegra::Engines::KeplerMemory::Regs, field_name) / sizeof(u32))
 
-class KeplerMemory final {
+class KeplerMemory final : public EngineInterface {
 public:
     KeplerMemory(Core::System& system, MemoryManager& memory_manager);
     ~KeplerMemory();
 
     /// Write the value to the register identified by method.
-    void CallMethod(const GPU::MethodCall& method_call);
+    void CallMethod(u32 method, u32 method_argument, bool is_last_call) override;
 
     /// Write multiple values to the register identified by method.
-    void CallMultiMethod(u32 method, const u32* base_start, u32 amount, u32 methods_pending);
+    void CallMultiMethod(u32 method, const u32* base_start, u32 amount,
+                         u32 methods_pending) override;
 
     struct Regs {
         static constexpr size_t NUM_REGS = 0x7F;

src/video_core/engines/maxwell_3d.cpp

@@ -44,6 +44,12 @@ 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
@@ -125,12 +131,10 @@ void Maxwell3D::CallMacroMethod(u32 method, std::size_t num_parameters, const u3
     }
 }
 
-void Maxwell3D::CallMethod(const GPU::MethodCall& method_call) {
-    const u32 method = method_call.method;
-
+void Maxwell3D::CallMethod(u32 method, u32 method_argument, bool is_last_call) {
     if (method == cb_data_state.current) {
-        regs.reg_array[method] = method_call.argument;
-        ProcessCBData(method_call.argument);
+        regs.reg_array[method] = method_argument;
+        ProcessCBData(method_argument);
         return;
     } else if (cb_data_state.current != null_cb_data) {
         FinishCBData();
@@ -153,10 +157,10 @@ void Maxwell3D::CallMethod(const GPU::MethodCall& method_call) {
             executing_macro = method;
         }
 
-        macro_params.push_back(method_call.argument);
+        macro_params.push_back(method_argument);
 
         // Call the macro when there are no more parameters in the command buffer
-        if (method_call.IsLastCall()) {
+        if (is_last_call) {
             CallMacroMethod(executing_macro, macro_params.size(), macro_params.data());
             macro_params.clear();
         }
@@ -166,7 +170,7 @@ void Maxwell3D::CallMethod(const GPU::MethodCall& method_call) {
     ASSERT_MSG(method < Regs::NUM_REGS,
                "Invalid Maxwell3D register, increase the size of the Regs structure");
 
-    u32 arg = method_call.argument;
+    u32 arg = method_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) {
@@ -189,7 +193,7 @@ void Maxwell3D::CallMethod(const GPU::MethodCall& method_call) {
         break;
     }
     case MAXWELL3D_REG_INDEX(shadow_ram_control): {
-        shadow_state.shadow_ram_control = static_cast<Regs::ShadowRamControl>(method_call.argument);
+        shadow_state.shadow_ram_control = static_cast<Regs::ShadowRamControl>(method_argument);
         break;
     }
     case MAXWELL3D_REG_INDEX(macros.data): {
@@ -272,7 +276,6 @@ void Maxwell3D::CallMethod(const GPU::MethodCall& method_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();
@@ -330,7 +333,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], 0, methods_pending - static_cast<u32>(i)});
+            CallMethod(method, base_start[i], methods_pending - static_cast<u32>(i) <= 1);
         }
     }
     }
@@ -360,16 +363,15 @@ void Maxwell3D::StepInstance(const MMEDrawMode expected_mode, const u32 count) {
     StepInstance(expected_mode, count);
 }
 
-void Maxwell3D::CallMethodFromMME(const GPU::MethodCall& method_call) {
-    const u32 method = method_call.method;
+void Maxwell3D::CallMethodFromMME(u32 method, u32 method_argument) {
     if (mme_inline[method]) {
-        regs.reg_array[method] = method_call.argument;
+        regs.reg_array[method] = method_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_call.argument);
+            StepInstance(expected_mode, method_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);
@@ -381,7 +383,7 @@ void Maxwell3D::CallMethodFromMME(const GPU::MethodCall& method_call) {
         if (mme_draw.current_mode != MMEDrawMode::Undefined) {
             FlushMMEInlineDraw();
         }
-        CallMethod(method_call);
+        CallMethod(method, method_argument, true);
     }
 }
 

src/video_core/engines/maxwell_3d.h

@@ -19,6 +19,7 @@
 #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"
@@ -48,7 +49,7 @@ namespace Tegra::Engines {
 #define MAXWELL3D_REG_INDEX(field_name)                                                            \
     (offsetof(Tegra::Engines::Maxwell3D::Regs, field_name) / sizeof(u32))
 
-class Maxwell3D final : public ConstBufferEngineInterface {
+class Maxwell3D final : public ConstBufferEngineInterface, public EngineInterface {
 public:
     explicit Maxwell3D(Core::System& system, VideoCore::RasterizerInterface& rasterizer,
                        MemoryManager& memory_manager);
@@ -575,6 +576,17 @@ 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;
@@ -618,7 +630,14 @@ public:
             f32 translate_x;
             f32 translate_y;
             f32 translate_z;
-            INSERT_UNION_PADDING_WORDS(2);
+            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);
 
             Common::Rectangle<f32> GetRect() const {
                 return {
@@ -1360,13 +1379,14 @@ public:
     u32 GetRegisterValue(u32 method) const;
 
     /// Write the value to the register identified by method.
-    void CallMethod(const GPU::MethodCall& method_call);
+    void CallMethod(u32 method, u32 method_argument, bool is_last_call) override;
 
     /// Write multiple values to the register identified by method.
-    void CallMultiMethod(u32 method, const u32* base_start, u32 amount, u32 methods_pending);
+    void CallMultiMethod(u32 method, const u32* base_start, u32 amount,
+                         u32 methods_pending) override;
 
     /// Write the value to the register identified by method.
-    void CallMethodFromMME(const GPU::MethodCall& method_call);
+    void CallMethodFromMME(u32 method, u32 method_argument);
 
     void FlushMMEInlineDraw();
 

src/video_core/engines/maxwell_dma.cpp

@@ -17,16 +17,16 @@ namespace Tegra::Engines {
 MaxwellDMA::MaxwellDMA(Core::System& system, MemoryManager& memory_manager)
     : system{system}, memory_manager{memory_manager} {}
 
-void MaxwellDMA::CallMethod(const GPU::MethodCall& method_call) {
-    ASSERT_MSG(method_call.method < Regs::NUM_REGS,
+void MaxwellDMA::CallMethod(u32 method, u32 method_argument, bool is_last_call) {
+    ASSERT_MSG(method < Regs::NUM_REGS,
                "Invalid MaxwellDMA register, increase the size of the Regs structure");
 
-    regs.reg_array[method_call.method] = method_call.argument;
+    regs.reg_array[method] = method_argument;
 
 #define MAXWELLDMA_REG_INDEX(field_name)                                                           \
     (offsetof(Tegra::Engines::MaxwellDMA::Regs, field_name) / sizeof(u32))
 
-    switch (method_call.method) {
+    switch (method) {
     case MAXWELLDMA_REG_INDEX(exec): {
         HandleCopy();
         break;
@@ -39,7 +39,7 @@ void MaxwellDMA::CallMethod(const GPU::MethodCall& method_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], 0, methods_pending - static_cast<u32>(i)});
+        CallMethod(method, base_start[i], methods_pending - static_cast<u32>(i) <= 1);
     }
 }
 
@@ -90,7 +90,47 @@ 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(

src/video_core/engines/maxwell_dma.h

@@ -10,6 +10,7 @@
 #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 {
@@ -27,16 +28,17 @@ namespace Tegra::Engines {
  * https://github.com/envytools/envytools/blob/master/rnndb/fifo/gk104_copy.xml
  */
 
-class MaxwellDMA final {
+class MaxwellDMA final : public EngineInterface {
 public:
     explicit MaxwellDMA(Core::System& system, MemoryManager& memory_manager);
     ~MaxwellDMA() = default;
 
     /// Write the value to the register identified by method.
-    void CallMethod(const GPU::MethodCall& method_call);
+    void CallMethod(u32 method, u32 method_argument, bool is_last_call) override;
 
     /// Write multiple values to the register identified by method.
-    void CallMultiMethod(u32 method, const u32* base_start, u32 amount, u32 methods_pending);
+    void CallMultiMethod(u32 method, const u32* base_start, u32 amount,
+                         u32 methods_pending) override;
 
     struct Regs {
         static constexpr std::size_t NUM_REGS = 0x1D6;

src/video_core/engines/shader_bytecode.h

@@ -168,18 +168,22 @@ enum class Pred : u64 {
 };
 
 enum class PredCondition : u64 {
-    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
+    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
 };
 
 enum class PredOperation : u64 {

src/video_core/gpu.cpp

@@ -299,19 +299,21 @@ void GPU::CallEngineMethod(const MethodCall& method_call) {
 
     switch (engine) {
     case EngineID::FERMI_TWOD_A:
-        fermi_2d->CallMethod(method_call);
+        fermi_2d->CallMethod(method_call.method, method_call.argument, method_call.IsLastCall());
         break;
     case EngineID::MAXWELL_B:
-        maxwell_3d->CallMethod(method_call);
+        maxwell_3d->CallMethod(method_call.method, method_call.argument, method_call.IsLastCall());
         break;
     case EngineID::KEPLER_COMPUTE_B:
-        kepler_compute->CallMethod(method_call);
+        kepler_compute->CallMethod(method_call.method, method_call.argument,
+                                   method_call.IsLastCall());
         break;
     case EngineID::MAXWELL_DMA_COPY_A:
-        maxwell_dma->CallMethod(method_call);
+        maxwell_dma->CallMethod(method_call.method, method_call.argument, method_call.IsLastCall());
         break;
     case EngineID::KEPLER_INLINE_TO_MEMORY_B:
-        kepler_memory->CallMethod(method_call);
+        kepler_memory->CallMethod(method_call.method, method_call.argument,
+                                  method_call.IsLastCall());
         break;
     default:
         UNIMPLEMENTED_MSG("Unimplemented engine");
@@ -347,7 +349,27 @@ 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);
-    bound_engines[method_call.subchannel] = static_cast<EngineID>(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));
+    }
 }
 
 void GPU::ProcessSemaphoreTriggerMethod() {

src/video_core/gpu.h

@@ -68,6 +68,7 @@ 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,

src/video_core/macro_interpreter.cpp

@@ -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());

src/video_core/morton.cpp

@@ -83,6 +83,7 @@ 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>,
@@ -166,6 +167,7 @@ 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>,

src/video_core/renderer_opengl/gl_rasterizer.cpp

@@ -1019,6 +1019,14 @@ 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));
         }
     }
 }

src/video_core/renderer_opengl/gl_shader_decompiler.cpp

@@ -1840,34 +1840,40 @@ private:
                 Type::HalfFloat};
     }
 
-    template <Type type>
-    Expression LogicalLessThan(Operation operation) {
-        return GenerateBinaryInfix(operation, "<", Type::Bool, type, type);
+    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 LogicalEqual(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 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 FUnordered(Operation operation) {
+        return {fmt::format("(isnan({}) || isnan({}))", VisitOperand(operation, 0).AsFloat(),
+                            VisitOperand(operation, 1).AsFloat()),
+                Type::Bool};
     }
 
     Expression LogicalAddCarry(Operation operation) {
@@ -2324,6 +2330,13 @@ 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";
@@ -2425,27 +2438,34 @@ private:
         &GLSLDecompiler::LogicalPick2,
         &GLSLDecompiler::LogicalAnd2,
 
-        &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::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::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::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::Uint>,
-        &GLSLDecompiler::LogicalEqual<Type::Uint>,
-        &GLSLDecompiler::LogicalLessEqual<Type::Uint>,
-        &GLSLDecompiler::LogicalGreaterThan<Type::Uint>,
-        &GLSLDecompiler::LogicalNotEqual<Type::Uint>,
-        &GLSLDecompiler::LogicalGreaterEqual<Type::Uint>,
+        &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::LogicalAddCarry,
 

src/video_core/renderer_opengl/gl_texture_cache.cpp

@@ -83,6 +83,7 @@ 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

src/video_core/renderer_opengl/maxwell_to_gl.h

@@ -503,5 +503,10 @@ 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

src/video_core/renderer_vulkan/fixed_pipeline_state.cpp

@@ -2,6 +2,7 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
+#include <algorithm>
 #include <cstring>
 #include <tuple>
 
@@ -92,6 +93,7 @@ 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
 }
 
@@ -101,6 +103,12 @@ 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];
 
@@ -144,6 +152,7 @@ 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 {

src/video_core/renderer_vulkan/fixed_pipeline_state.h

@@ -164,6 +164,7 @@ 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
@@ -233,10 +234,17 @@ 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);
 

src/video_core/renderer_vulkan/maxwell_to_vk.cpp

@@ -160,6 +160,7 @@ 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
@@ -345,8 +346,6 @@ 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:
@@ -355,8 +354,22 @@ 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;
         }
@@ -672,4 +685,27 @@ 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

src/video_core/renderer_vulkan/maxwell_to_vk.h

@@ -59,4 +59,6 @@ VkCullModeFlags CullFace(Maxwell::CullFace cull_face);
 
 VkComponentSwizzle SwizzleSource(Tegra::Texture::SwizzleSource swizzle);
 
+VkViewportCoordinateSwizzleNV ViewportSwizzle(Maxwell::ViewportSwizzle swizzle);
+
 } // namespace Vulkan::MaxwellToVK