vulkan: Initial implementation

.github/ISSUE_TEMPLATE.md

@@ -1,27 +1,16 @@
 <!--
 Please keep in mind yuzu is EXPERIMENTAL SOFTWARE.
 
-Please read the FAQ:
-https://yuzu-emu.org/wiki/faq/
+Please read the FAQ: https://yuzu-emu.org/wiki/faq/
 
-THIS IS NOT A SUPPORT FORUM, FOR SUPPORT GO TO:
-https://community.citra-emu.org/
+When submitting an issue, please do the following:
 
-If the FAQ does not answer your question, please go to:
-https://community.citra-emu.org/
-
-When submitting an issue, please check the following:
-
-- You have read the above.
-- You have provided the version (commit hash) of yuzu you are using.
-- You have provided sufficient detail for the issue to be reproduced.
-- You have provided system specs (if relevant).
-- Please also provide:
-  - For any issues, a log file
+- Provide the version (commit hash) of yuzu you are using.
+- Provide sufficient detail for the issue to be reproduced.
+- Provide:
   - For crashes, a backtrace.
   - For graphical issues, comparison screenshots with real hardware.
   - For emulation inaccuracies, a test-case (if able).
-
 -->
 
 

.gitmodules

@@ -37,6 +37,3 @@
 [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

.travis.yml

@@ -24,7 +24,7 @@ matrix:
     - os: osx
       env: NAME="macos build"
       sudo: false
-      osx_image: xcode10.1
+      osx_image: xcode10
       install: "./.travis/macos/deps.sh"
       script: "./.travis/macos/build.sh"
       after_success: "./.travis/macos/upload.sh"

.travis/common/travis-ci.env

@@ -6,8 +6,6 @@ TRAVIS_BRANCH
 TRAVIS_BUILD_ID
 TRAVIS_BUILD_NUMBER
 TRAVIS_COMMIT
-TRAVIS_COMMIT_RANGE
-TRAVIS_EVENT_TYPE
 TRAVIS_JOB_ID
 TRAVIS_JOB_NUMBER
 TRAVIS_REPO_SLUG

.travis/linux/docker.sh

@@ -1,12 +1,12 @@
 #!/bin/bash -ex
 
 apt-get update
-apt-get install --no-install-recommends -y build-essential git libqt5opengl5-dev libsdl2-dev libssl-dev python qtbase5-dev qtwebengine5-dev wget cmake ninja-build ccache
+apt-get install --no-install-recommends -y build-essential git libqt5opengl5-dev libsdl2-dev libssl-dev python qtbase5-dev wget cmake ninja-build ccache
 
 cd /yuzu
 
 mkdir build && cd build
-cmake .. -DYUZU_USE_BUNDLED_UNICORN=ON -DYUZU_USE_QT_WEB_ENGINE=ON -DCMAKE_BUILD_TYPE=Release -DCMAKE_C_COMPILER=/usr/lib/ccache/gcc -DCMAKE_CXX_COMPILER=/usr/lib/ccache/g++ -DYUZU_ENABLE_COMPATIBILITY_REPORTING=${ENABLE_COMPATIBILITY_REPORTING:-"OFF"} -DENABLE_COMPATIBILITY_LIST_DOWNLOAD=ON -DUSE_DISCORD_PRESENCE=ON -G Ninja
+cmake .. -DYUZU_USE_BUNDLED_UNICORN=ON -DCMAKE_BUILD_TYPE=Release -DCMAKE_C_COMPILER=/usr/lib/ccache/gcc -DCMAKE_CXX_COMPILER=/usr/lib/ccache/g++ -DYUZU_ENABLE_COMPATIBILITY_REPORTING=${ENABLE_COMPATIBILITY_REPORTING:-"OFF"} -DENABLE_COMPATIBILITY_LIST_DOWNLOAD=ON -DUSE_DISCORD_PRESENCE=ON -G Ninja
 ninja
 
 ccache -s

.travis/macos/build.sh

@@ -2,14 +2,14 @@
 
 set -o pipefail
 
-export MACOSX_DEPLOYMENT_TARGET=10.14
+export MACOSX_DEPLOYMENT_TARGET=10.13
 export Qt5_DIR=$(brew --prefix)/opt/qt5
 export UNICORNDIR=$(pwd)/externals/unicorn
 export PATH="/usr/local/opt/ccache/libexec:$PATH"
 
 mkdir build && cd build
 cmake --version
-cmake .. -DYUZU_USE_BUNDLED_UNICORN=ON -DYUZU_USE_QT_WEB_ENGINE=ON -DCMAKE_BUILD_TYPE=Release -DENABLE_COMPATIBILITY_LIST_DOWNLOAD=ON -DYUZU_ENABLE_COMPATIBILITY_REPORTING=${ENABLE_COMPATIBILITY_REPORTING:-"OFF"} -DUSE_DISCORD_PRESENCE=ON
+cmake .. -DYUZU_USE_BUNDLED_UNICORN=ON -DCMAKE_BUILD_TYPE=Release -DENABLE_COMPATIBILITY_LIST_DOWNLOAD=ON -DYUZU_ENABLE_COMPATIBILITY_REPORTING=${ENABLE_COMPATIBILITY_REPORTING:-"OFF"} -DUSE_DISCORD_PRESENCE=ON
 make -j4
 
 ccache -s

CMakeLists.txt

@@ -19,11 +19,9 @@ option(ENABLE_WEB_SERVICE "Enable web services (telemetry, etc.)" ON)
 
 option(YUZU_USE_BUNDLED_UNICORN "Build/Download bundled Unicorn" ON)
 
-option(YUZU_USE_QT_WEB_ENGINE "Use QtWebEngine for web applet implementation" OFF)
-
 option(ENABLE_CUBEB "Enables the cubeb audio backend" ON)
 
-option(ENABLE_VULKAN "Enables Vulkan backend" ON)
+option(ENABLE_VULKAN "Enables Vulkan backend" OFF)
 
 option(USE_DISCORD_PRESENCE "Enables Discord Rich Presence" OFF)
 
@@ -163,6 +161,12 @@ else()
     set(CMAKE_EXE_LINKER_FLAGS_RELEASE "/DEBUG /MANIFEST:NO /INCREMENTAL:NO /OPT:REF,ICF" CACHE STRING "" FORCE)
 endif()
 
+# Fix GCC C++17 and Boost.ICL incompatibility (needed to build dynarmic)
+# See https://bugzilla.redhat.com/show_bug.cgi?id=1485641#c1
+if (CMAKE_COMPILER_IS_GNUCC)
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fno-new-ttp-matching")
+endif()
+
 # Set file offset size to 64 bits.
 #
 # On modern Unixes, this is typically already the case. The lone exception is
@@ -179,9 +183,9 @@ set_property(DIRECTORY APPEND PROPERTY
 # System imported libraries
 # ======================
 
-find_package(Boost 1.66.0 QUIET)
+find_package(Boost 1.63.0 QUIET)
 if (NOT Boost_FOUND)
-    message(STATUS "Boost 1.66.0 or newer not found, falling back to externals")
+    message(STATUS "Boost 1.63.0 or newer not found, falling back to externals")
 
     set(BOOST_ROOT "${PROJECT_SOURCE_DIR}/externals/boost")
     set(Boost_NO_SYSTEM_PATHS OFF)
@@ -300,7 +304,7 @@ endif()
 if (ENABLE_QT)
     if (YUZU_USE_BUNDLED_QT)
         if ((MSVC_VERSION GREATER_EQUAL 1910 AND MSVC_VERSION LESS 1920) AND ARCHITECTURE_x86_64)
-            set(QT_VER qt-5.12.0-msvc2017_64)
+            set(QT_VER qt-5.10.0-msvc2015_64)
         else()
             message(FATAL_ERROR "No bundled Qt binaries for your toolchain. Disable YUZU_USE_BUNDLED_QT and provide your own.")
         endif()
@@ -317,10 +321,10 @@ if (ENABLE_QT)
     endif()
 
     find_package(Qt5 REQUIRED COMPONENTS Widgets OpenGL ${QT_PREFIX_HINT})
+endif()
 
-    if (YUZU_USE_QT_WEB_ENGINE)
-        find_package(Qt5 REQUIRED COMPONENTS WebEngineCore WebEngineWidgets ${QT_PREFIX_HINT})
-    endif ()
+if (ENABLE_VULKAN)
+    find_package(Vulkan REQUIRED)
 endif()
 
 # Platform-specific library requirements
@@ -415,6 +419,19 @@ function(create_target_directory_groups target_name)
     endforeach()
 endfunction()
 
+# Gets a UTC timstamp and sets the provided variable to it
+function(get_timestamp _var)
+    string(TIMESTAMP timestamp UTC)
+    set(${_var} "${timestamp}" PARENT_SCOPE)
+endfunction()
+
+# generate git/build information
+include(GetGitRevisionDescription)
+get_git_head_revision(GIT_REF_SPEC GIT_REV)
+git_describe(GIT_DESC --always --long --dirty)
+git_branch_name(GIT_BRANCH)
+get_timestamp(BUILD_DATE)
+
 enable_testing()
 add_subdirectory(externals)
 add_subdirectory(src)

CMakeModules/CopyYuzuQt5Deps.cmake

@@ -5,7 +5,6 @@ function(copy_yuzu_Qt5_deps target_dir)
     set(Qt5_PLATFORMS_DIR "${Qt5_DIR}/../../../plugins/platforms/")
     set(Qt5_STYLES_DIR "${Qt5_DIR}/../../../plugins/styles/")
     set(Qt5_IMAGEFORMATS_DIR "${Qt5_DIR}/../../../plugins/imageformats/")
-    set(Qt5_RESOURCES_DIR "${Qt5_DIR}/../../../resources/")
     set(PLATFORMS ${DLL_DEST}platforms/)
     set(STYLES ${DLL_DEST}styles/)
     set(IMAGEFORMATS ${DLL_DEST}imageformats/)
@@ -18,35 +17,7 @@ function(copy_yuzu_Qt5_deps target_dir)
         Qt5OpenGL$<$<CONFIG:Debug>:d>.*
         Qt5Widgets$<$<CONFIG:Debug>:d>.*
     )
-
-    if (YUZU_USE_QT_WEB_ENGINE)
-        windows_copy_files(${target_dir} ${Qt5_DLL_DIR} ${DLL_DEST} 
-            Qt5Network$<$<CONFIG:Debug>:d>.*
-            Qt5Positioning$<$<CONFIG:Debug>:d>.*
-            Qt5PrintSupport$<$<CONFIG:Debug>:d>.*
-            Qt5Qml$<$<CONFIG:Debug>:d>.*
-            Qt5Quick$<$<CONFIG:Debug>:d>.*
-            Qt5QuickWidgets$<$<CONFIG:Debug>:d>.*
-            Qt5WebChannel$<$<CONFIG:Debug>:d>.*
-            Qt5WebEngine$<$<CONFIG:Debug>:d>.*
-            Qt5WebEngineCore$<$<CONFIG:Debug>:d>.*
-            Qt5WebEngineWidgets$<$<CONFIG:Debug>:d>.*
-            QtWebEngineProcess$<$<CONFIG:Debug>:d>.*
-        )
-
-        windows_copy_files(${target_dir} ${Qt5_RESOURCES_DIR} ${DLL_DEST}
-            qtwebengine_resources.pak
-            qtwebengine_devtools_resources.pak
-            qtwebengine_resources_100p.pak
-            qtwebengine_resources_200p.pak
-            icudtl.dat
-        )
-    endif ()
-
     windows_copy_files(yuzu ${Qt5_PLATFORMS_DIR} ${PLATFORMS} qwindows$<$<CONFIG:Debug>:d>.*)
     windows_copy_files(yuzu ${Qt5_STYLES_DIR} ${STYLES} qwindowsvistastyle$<$<CONFIG:Debug>:d>.*)
-    windows_copy_files(yuzu ${Qt5_IMAGEFORMATS_DIR} ${IMAGEFORMATS}
-        qjpeg$<$<CONFIG:Debug>:d>.*
-        qgif$<$<CONFIG:Debug>:d>.*
-        )
+    windows_copy_files(yuzu ${Qt5_IMAGEFORMATS_DIR} ${IMAGEFORMATS} qjpeg$<$<CONFIG:Debug>:d>.*)
 endfunction(copy_yuzu_Qt5_deps)

CMakeModules/GenerateSCMRev.cmake

@@ -1,95 +0,0 @@
-# Gets a UTC timstamp and sets the provided variable to it
-function(get_timestamp _var)
-    string(TIMESTAMP timestamp UTC)
-    set(${_var} "${timestamp}" PARENT_SCOPE)
-endfunction()
-
-list(APPEND CMAKE_MODULE_PATH "${SRC_DIR}/externals/cmake-modules")
-# generate git/build information
-include(GetGitRevisionDescription)
-get_git_head_revision(GIT_REF_SPEC GIT_REV)
-git_describe(GIT_DESC --always --long --dirty)
-git_branch_name(GIT_BRANCH)
-get_timestamp(BUILD_DATE)
-
-# Generate cpp with Git revision from template
-# Also if this is a CI build, add the build name (ie: Nightly, Canary) to the scm_rev file as well
-set(REPO_NAME "")
-set(BUILD_VERSION "0")
-if (BUILD_REPOSITORY)
-  # regex capture the string nightly or canary into CMAKE_MATCH_1
-  string(REGEX MATCH "yuzu-emu/yuzu-?(.*)" OUTVAR ${BUILD_REPOSITORY})
-  if (${CMAKE_MATCH_COUNT} GREATER 0)
-    # capitalize the first letter of each word in the repo name.
-    string(REPLACE "-" ";" REPO_NAME_LIST ${CMAKE_MATCH_1})
-    foreach(WORD ${REPO_NAME_LIST})
-      string(SUBSTRING ${WORD} 0 1 FIRST_LETTER)
-      string(SUBSTRING ${WORD} 1 -1 REMAINDER)
-      string(TOUPPER ${FIRST_LETTER} FIRST_LETTER)
-      set(REPO_NAME "${REPO_NAME}${FIRST_LETTER}${REMAINDER}")
-    endforeach()
-    if (BUILD_TAG)
-      string(REGEX MATCH "${CMAKE_MATCH_1}-([0-9]+)" OUTVAR ${BUILD_TAG})
-      if (${CMAKE_MATCH_COUNT} GREATER 0)
-        set(BUILD_VERSION ${CMAKE_MATCH_1})
-      endif()
-      if (BUILD_VERSION)
-        # This leaves a trailing space on the last word, but we actually want that
-        # because of how it's styled in the title bar.
-        set(BUILD_FULLNAME "${REPO_NAME} ${BUILD_VERSION} ")
-      else()
-        set(BUILD_FULLNAME "")
-      endif()
-    endif()
-  endif()
-endif()
-
-# The variable SRC_DIR must be passed into the script (since it uses the current build directory for all values of CMAKE_*_DIR)
-set(VIDEO_CORE "${SRC_DIR}/src/video_core")
-set(HASH_FILES
-    "${VIDEO_CORE}/renderer_opengl/gl_shader_cache.cpp"
-    "${VIDEO_CORE}/renderer_opengl/gl_shader_cache.h"
-    "${VIDEO_CORE}/renderer_opengl/gl_shader_decompiler.cpp"
-    "${VIDEO_CORE}/renderer_opengl/gl_shader_decompiler.h"
-    "${VIDEO_CORE}/renderer_opengl/gl_shader_disk_cache.cpp"
-    "${VIDEO_CORE}/renderer_opengl/gl_shader_disk_cache.h"
-    "${VIDEO_CORE}/renderer_opengl/gl_shader_gen.cpp"
-    "${VIDEO_CORE}/renderer_opengl/gl_shader_gen.h"
-    "${VIDEO_CORE}/shader/decode/arithmetic.cpp"
-    "${VIDEO_CORE}/shader/decode/arithmetic_half.cpp"
-    "${VIDEO_CORE}/shader/decode/arithmetic_half_immediate.cpp"
-    "${VIDEO_CORE}/shader/decode/arithmetic_immediate.cpp"
-    "${VIDEO_CORE}/shader/decode/arithmetic_integer.cpp"
-    "${VIDEO_CORE}/shader/decode/arithmetic_integer_immediate.cpp"
-    "${VIDEO_CORE}/shader/decode/bfe.cpp"
-    "${VIDEO_CORE}/shader/decode/bfi.cpp"
-    "${VIDEO_CORE}/shader/decode/conversion.cpp"
-    "${VIDEO_CORE}/shader/decode/ffma.cpp"
-    "${VIDEO_CORE}/shader/decode/float_set.cpp"
-    "${VIDEO_CORE}/shader/decode/float_set_predicate.cpp"
-    "${VIDEO_CORE}/shader/decode/half_set.cpp"
-    "${VIDEO_CORE}/shader/decode/half_set_predicate.cpp"
-    "${VIDEO_CORE}/shader/decode/hfma2.cpp"
-    "${VIDEO_CORE}/shader/decode/integer_set.cpp"
-    "${VIDEO_CORE}/shader/decode/integer_set_predicate.cpp"
-    "${VIDEO_CORE}/shader/decode/memory.cpp"
-    "${VIDEO_CORE}/shader/decode/texture.cpp"
-    "${VIDEO_CORE}/shader/decode/other.cpp"
-    "${VIDEO_CORE}/shader/decode/predicate_set_predicate.cpp"
-    "${VIDEO_CORE}/shader/decode/predicate_set_register.cpp"
-    "${VIDEO_CORE}/shader/decode/register_set_predicate.cpp"
-    "${VIDEO_CORE}/shader/decode/shift.cpp"
-    "${VIDEO_CORE}/shader/decode/video.cpp"
-    "${VIDEO_CORE}/shader/decode/xmad.cpp"
-    "${VIDEO_CORE}/shader/decode.cpp"
-    "${VIDEO_CORE}/shader/shader_ir.cpp"
-    "${VIDEO_CORE}/shader/shader_ir.h"
-    "${VIDEO_CORE}/shader/track.cpp"
-)
-set(COMBINED "")
-foreach (F IN LISTS HASH_FILES)
-    file(READ ${F} TMP)
-    set(COMBINED "${COMBINED}${TMP}")
-endforeach()
-string(MD5 SHADER_CACHE_VERSION "${COMBINED}")
-configure_file("${SRC_DIR}/src/common/scm_rev.cpp.in" "scm_rev.cpp" @ONLY)

CONTRIBUTING.md

@@ -1 +1,136 @@
-**The Contributor's Guide has moved to [the Citra wiki](https://github.com/citra-emu/citra/wiki/Contributing).**
+# Reporting Issues
+
+**The issue tracker is not a support forum.** Unless you can provide precise *technical information* regarding an issue, you *should not post in it*. If you need support, first read the [FAQ](https://github.com/yuzu-emu/yuzu/wiki/FAQ) and then either visit our [Discord server](https://discordapp.com/invite/u77vRWY), [our forum](https://community.citra-emu.org) or ask in a general emulation forum such as [/r/emulation](https://www.reddit.com/r/emulation/). If you post support questions, generic messages to the developers or vague reports without technical details, they will be closed and locked.
+
+If you believe you have a valid issue report, please post text or a screenshot from the log (the console window that opens alongside yuzu) and build version (hex string visible in the titlebar and zip filename), as well as your hardware and software information if applicable.
+
+# Contributing
+yuzu is a brand new project, so we have a great opportunity to keep things clean and well organized early on. As such, coding style is very important when making commits. We run clang-format on our CI to check the code. Please use it to format your code when contributing. However, it doesn't cover all the rules below. Some of them aren't very strict rules since we want to be flexible and we understand that under certain circumstances some of them can be counterproductive. Just try to follow as many of them as possible.
+
+# Using clang format (version 6.0)
+When generating the native build script for your toolset, cmake will try to find the correct version of clang format (or will download it on windows). Before running cmake, please install clang format version 6.0 for your platform as follows:
+
+* Windows: do nothing; cmake will download a pre built binary for MSVC and MINGW. MSVC users can additionally install a clang format Visual Studio extension to add features like format on save.
+* OSX: run `brew install clang-format`.
+* Linux: use your package manager to get an appropriate binary.
+
+If clang format is found, then cmake will add a custom build target that can be run at any time to run clang format against *all* source files and update the formatting in them. This should be used before making a pull request so that the reviewers can spend more time reviewing the code instead of having to worry about minor style violations. On MSVC, you can run clang format by building the clang-format project in the solution. On OSX, you can either use the Makefile target `make clang-format` or by building the clang-format target in XCode. For Makefile builds, you can use the clang-format target with `make clang-format`
+
+### General Rules
+* A lot of code was taken from other projects (e.g. Citra, Dolphin, PPSSPP, Gekko). In general, when editing other people's code, follow the style of the module you're in (or better yet, fix the style if it drastically differs from our guide).
+* Line width is typically 100 characters. Please do not use 80-characters.
+* Don't ever introduce new external dependencies into Core
+* Don't use any platform specific code in Core
+* Use namespaces often
+* Avoid the use of C-style casts and instead prefer C++-style `static_cast` and `reinterpret_cast`. Try to avoid using `dynamic_cast`. Never use `const_cast`.
+
+### Naming Rules
+* Functions: `PascalCase`
+* Variables: `lower_case_underscored`. Prefix with `g_` if global.
+* Classes: `PascalCase`
+* Files and Directories: `lower_case_underscored`
+* Namespaces: `PascalCase`, `_` may also be used for clarity (e.g. `ARM_InitCore`)
+
+### Indentation/Whitespace Style
+Follow the indentation/whitespace style shown below. Do not use tabs, use 4-spaces instead.
+
+### Comments
+* For regular comments, use C++ style (`//`) comments, even for multi-line ones.
+* For doc-comments (Doxygen comments), use `/// ` if it's a single line, else use the `/**` `*/` style featured in the example. Start the text on the second line, not the first containing `/**`.
+* For items that are both defined and declared in two separate files, put the doc-comment only next to the associated declaration. (In a header file, usually.) Otherwise, put it next to the implementation. Never duplicate doc-comments in both places.
+
+```cpp
+// Includes should be sorted lexicographically
+// STD includes first
+#include <map>
+#include <memory>
+
+// then, library includes
+#include <nihstro/shared_binary.h>
+
+// finally, yuzu includes
+#include "common/math_util.h"
+#include "common/vector_math.h"
+
+// each major module is separated
+#include "video_core/pica.h"
+#include "video_core/video_core.h"
+
+namespace Example {
+
+// Namespace contents are not indented
+
+// Declare globals at the top
+int g_foo{}; // {} can be used to initialize types as 0, false, or nullptr
+char* g_some_pointer{}; // Pointer * and reference & stick to the type name, and make sure to initialize as nullptr!
+
+/// A colorful enum.
+enum SomeEnum {
+    ColorRed,   ///< The color of fire.
+    ColorGreen, ///< The color of grass.
+    ColorBlue,  ///< Not actually the color of water.
+};
+
+/**
+ * Very important struct that does a lot of stuff.
+ * Note that the asterisks are indented by one space to align to the first line.
+ */
+struct Position {
+    int x{}, y{}; // Always intitialize member variables!
+};
+
+// Use "typename" rather than "class" here
+template <typename T>
+void FooBar() {
+    const std::string some_string{ "prefer uniform initialization" };
+
+    int some_array[]{
+        5,
+        25,
+        7,
+        42,
+    };
+
+    if (note == the_space_after_the_if) {
+        CallAfunction();
+    } else {
+        // Use a space after the // when commenting
+    }
+
+    // Place a single space after the for loop semicolons, prefer pre-increment
+    for (int i{}; i != 25; ++i) {
+        // This is how we write loops
+    }
+
+    DoStuff(this, function, call, takes, up, multiple,
+            lines, like, this);
+
+    if (this || condition_takes_up_multiple &&
+        lines && like && this || everything ||
+        alright || then) {
+
+        // Leave a blank space before the if block body if the condition was continued across
+        // several lines.
+    }
+
+    switch (var) {
+    // No indentation for case label
+    case 1: {
+        int case_var{ var + 3 };
+        DoSomething(case_var);
+        break;
+    }
+    case 3:
+        DoSomething(var);
+        return;
+
+    default:
+        // Yes, even break for the last case
+        break;
+    }
+
+    std::vector<T> you_can_declare, a_few, variables, like_this;
+}
+
+}
+```

README.md

@@ -7,7 +7,7 @@ yuzu is an experimental open-source emulator for the Nintendo Switch from the cr
 
 It is written in C++ with portability in mind, with builds actively maintained for Windows, Linux and macOS. The emulator is currently only useful for homebrew development and research purposes.
 
-yuzu only emulates a subset of Switch hardware and therefore is generally only useful for running/debugging homebrew applications. At this time, yuzu cannot play any commercial games without major problems. yuzu can boot some games, to varying degrees of success.
+yuzu only emulates a subset of Switch hardware and therefore is generally only useful for running/debugging homebrew applications. At this time, yuzu cannot play any commercial games without major problems. yuzu can boot some games, to varying degrees of success, but does not implement any of the necessary GPU features to render 3D graphics.
 
 yuzu is licensed under the GPLv2 (or any later version). Refer to the license.txt file included.
 

appveyor.yml

@@ -42,7 +42,7 @@ before_build:
         $COMPAT = if ($env:ENABLE_COMPATIBILITY_REPORTING -eq $null) {0} else {$env:ENABLE_COMPATIBILITY_REPORTING}
         if ($env:BUILD_TYPE -eq 'msvc') {
           # redirect stderr and change the exit code to prevent powershell from cancelling the build if cmake prints a warning
-          cmd /C 'cmake -G "Visual Studio 15 2017 Win64" -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 .. 2>&1 && exit 0'
+          cmd /C 'cmake -G "Visual Studio 15 2017 Win64" -DYUZU_USE_BUNDLED_QT=1 -DYUZU_USE_BUNDLED_SDL2=1 -DYUZU_USE_BUNDLED_UNICORN=1 -DENABLE_COMPATIBILITY_LIST_DOWNLOAD=ON -DYUZU_ENABLE_COMPATIBILITY_REPORTING=${COMPAT} -DUSE_DISCORD_PRESENCE=ON .. 2>&1 && exit 0'
         } else {
           C:\msys64\usr\bin\bash.exe -lc "cmake -G 'MSYS Makefiles' -DYUZU_BUILD_UNICORN=1 -DCMAKE_BUILD_TYPE=Release -DENABLE_COMPATIBILITY_LIST_DOWNLOAD=ON -DYUZU_ENABLE_COMPATIBILITY_REPORTING=${COMPAT} -DUSE_DISCORD_PRESENCE=ON .. 2>&1"
         }
@@ -94,7 +94,6 @@ after_build:
           Copy-Item "$BUILD_DIR\*" -Destination $RELEASE_DIST -Recurse
           rm "$RELEASE_DIST\*.exe"
           Get-ChildItem "$BUILD_DIR" -Recurse -Filter "yuzu*.exe" | Copy-Item -destination $RELEASE_DIST
-          Get-ChildItem "$BUILD_DIR" -Recurse -Filter "QtWebEngineProcess*.exe" | Copy-Item -destination $RELEASE_DIST
           Copy-Item .\license.txt -Destination $RELEASE_DIST
           Copy-Item .\README.md -Destination $RELEASE_DIST
           7z a -tzip $MSVC_BUILD_ZIP $RELEASE_DIST\*

src/audio_core/algorithm/interpolate.cpp

@@ -54,9 +54,8 @@ std::vector<s16> Interpolate(InterpolationState& state, std::vector<s16> input,
             double l = 0.0;
             double r = 0.0;
             for (std::size_t j = 0; j < h.size(); j++) {
-                const double lanczos_calc = Lanczos(taps, pos + j - taps + 1);
-                l += lanczos_calc * h[j][0];
-                r += lanczos_calc * h[j][1];
+                l += Lanczos(taps, pos + j - taps + 1) * h[j][0];
+                r += Lanczos(taps, pos + j - taps + 1) * h[j][1];
             }
             output.emplace_back(static_cast<s16>(std::clamp(l, -32768.0, 32767.0)));
             output.emplace_back(static_cast<s16>(std::clamp(r, -32768.0, 32767.0)));

src/audio_core/audio_out.cpp

@@ -22,19 +22,20 @@ static Stream::Format ChannelsToStreamFormat(u32 num_channels) {
         return Stream::Format::Multi51Channel16;
     }
 
-    UNIMPLEMENTED_MSG("Unimplemented num_channels={}", num_channels);
+    LOG_CRITICAL(Audio, "Unimplemented num_channels={}", num_channels);
+    UNREACHABLE();
     return {};
 }
 
-StreamPtr AudioOut::OpenStream(Core::Timing::CoreTiming& core_timing, u32 sample_rate,
-                               u32 num_channels, std::string&& name,
+StreamPtr AudioOut::OpenStream(u32 sample_rate, u32 num_channels, std::string&& name,
                                Stream::ReleaseCallback&& release_callback) {
     if (!sink) {
-        sink = CreateSinkFromID(Settings::values.sink_id, Settings::values.audio_device_id);
+        const SinkDetails& sink_details = GetSinkDetails(Settings::values.sink_id);
+        sink = sink_details.factory(Settings::values.audio_device_id);
     }
 
     return std::make_shared<Stream>(
-        core_timing, sample_rate, ChannelsToStreamFormat(num_channels), std::move(release_callback),
+        sample_rate, ChannelsToStreamFormat(num_channels), std::move(release_callback),
         sink->AcquireSinkStream(sample_rate, num_channels, name), std::move(name));
 }
 

src/audio_core/audio_out.h

@@ -13,10 +13,6 @@
 #include "audio_core/stream.h"
 #include "common/common_types.h"
 
-namespace Core::Timing {
-class CoreTiming;
-}
-
 namespace AudioCore {
 
 /**
@@ -25,8 +21,8 @@ namespace AudioCore {
 class AudioOut {
 public:
     /// Opens a new audio stream
-    StreamPtr OpenStream(Core::Timing::CoreTiming& core_timing, u32 sample_rate, u32 num_channels,
-                         std::string&& name, Stream::ReleaseCallback&& release_callback);
+    StreamPtr OpenStream(u32 sample_rate, u32 num_channels, std::string&& name,
+                         Stream::ReleaseCallback&& release_callback);
 
     /// Returns a vector of recently released buffers specified by tag for the specified stream
     std::vector<Buffer::Tag> GetTagsAndReleaseBuffers(StreamPtr stream, std::size_t max_count);

src/audio_core/audio_renderer.cpp

@@ -8,8 +8,7 @@
 #include "audio_core/codec.h"
 #include "common/assert.h"
 #include "common/logging/log.h"
-#include "core/core.h"
-#include "core/hle/kernel/writable_event.h"
+#include "core/hle/kernel/event.h"
 #include "core/memory.h"
 
 namespace AudioCore {
@@ -72,14 +71,14 @@ private:
     EffectOutStatus out_status{};
     EffectInStatus info{};
 };
-AudioRenderer::AudioRenderer(Core::Timing::CoreTiming& core_timing, AudioRendererParameter params,
-                             Kernel::SharedPtr<Kernel::WritableEvent> buffer_event)
+AudioRenderer::AudioRenderer(AudioRendererParameter params,
+                             Kernel::SharedPtr<Kernel::Event> buffer_event)
     : worker_params{params}, buffer_event{buffer_event}, voices(params.voice_count),
       effects(params.effect_count) {
 
     audio_out = std::make_unique<AudioCore::AudioOut>();
-    stream = audio_out->OpenStream(core_timing, STREAM_SAMPLE_RATE, STREAM_NUM_CHANNELS,
-                                   "AudioRenderer", [=]() { buffer_event->Signal(); });
+    stream = audio_out->OpenStream(STREAM_SAMPLE_RATE, STREAM_NUM_CHANNELS, "AudioRenderer",
+                                   [=]() { buffer_event->Signal(); });
     audio_out->StartStream(stream);
 
     QueueMixedBuffer(0);
@@ -261,7 +260,8 @@ void AudioRenderer::VoiceState::RefreshBuffer() {
         break;
     }
     default:
-        UNIMPLEMENTED_MSG("Unimplemented sample_format={}", info.sample_format);
+        LOG_CRITICAL(Audio, "Unimplemented sample_format={}", info.sample_format);
+        UNREACHABLE();
         break;
     }
 
@@ -280,15 +280,13 @@ void AudioRenderer::VoiceState::RefreshBuffer() {
         break;
     }
     default:
-        UNIMPLEMENTED_MSG("Unimplemented channel_count={}", info.channel_count);
+        LOG_CRITICAL(Audio, "Unimplemented channel_count={}", info.channel_count);
+        UNREACHABLE();
         break;
     }
 
-    // Only interpolate when necessary, expensive.
-    if (GetInfo().sample_rate != STREAM_SAMPLE_RATE) {
-        samples = Interpolate(interp_state, std::move(samples), GetInfo().sample_rate,
-                              STREAM_SAMPLE_RATE);
-    }
+    samples =
+        Interpolate(interp_state, std::move(samples), GetInfo().sample_rate, STREAM_SAMPLE_RATE);
 
     is_refresh_pending = false;
 }

src/audio_core/audio_renderer.h

@@ -14,12 +14,8 @@
 #include "common/swap.h"
 #include "core/hle/kernel/object.h"
 
-namespace Core::Timing {
-class CoreTiming;
-}
-
 namespace Kernel {
-class WritableEvent;
+class Event;
 }
 
 namespace AudioCore {
@@ -46,18 +42,16 @@ struct AudioRendererParameter {
     u32_le sample_rate;
     u32_le sample_count;
     u32_le mix_buffer_count;
-    u32_le submix_count;
+    u32_le unknown_c;
     u32_le voice_count;
     u32_le sink_count;
     u32_le effect_count;
-    u32_le performance_frame_count;
-    u8 is_voice_drop_enabled;
-    u8 unknown_21;
-    u8 unknown_22;
-    u8 execution_mode;
+    u32_le unknown_1c;
+    u8 unknown_20;
+    INSERT_PADDING_BYTES(3);
     u32_le splitter_count;
-    u32_le num_splitter_send_channels;
-    u32_le unknown_30;
+    u32_le unknown_2c;
+    INSERT_PADDING_WORDS(1);
     u32_le revision;
 };
 static_assert(sizeof(AudioRendererParameter) == 52, "AudioRendererParameter is an invalid size");
@@ -214,8 +208,7 @@ static_assert(sizeof(UpdateDataHeader) == 0x40, "UpdateDataHeader has wrong size
 
 class AudioRenderer {
 public:
-    AudioRenderer(Core::Timing::CoreTiming& core_timing, AudioRendererParameter params,
-                  Kernel::SharedPtr<Kernel::WritableEvent> buffer_event);
+    AudioRenderer(AudioRendererParameter params, Kernel::SharedPtr<Kernel::Event> buffer_event);
     ~AudioRenderer();
 
     std::vector<u8> UpdateAudioRenderer(const std::vector<u8>& input_params);
@@ -231,7 +224,7 @@ private:
     class VoiceState;
 
     AudioRendererParameter worker_params;
-    Kernel::SharedPtr<Kernel::WritableEvent> buffer_event;
+    Kernel::SharedPtr<Kernel::Event> buffer_event;
     std::vector<VoiceState> voices;
     std::vector<EffectState> effects;
     std::unique_ptr<AudioOut> audio_out;

src/audio_core/buffer.h

@@ -21,7 +21,7 @@ public:
     Buffer(Tag tag, std::vector<s16>&& samples) : tag{tag}, samples{std::move(samples)} {}
 
     /// Returns the raw audio data for the buffer
-    std::vector<s16>& GetSamples() {
+    std::vector<s16>& Samples() {
         return samples;
     }
 

src/audio_core/codec.cpp

@@ -68,8 +68,8 @@ std::vector<s16> DecodeADPCM(const u8* const data, std::size_t size, const ADPCM
         }
     }
 
-    state.yn1 = static_cast<s16>(yn1);
-    state.yn2 = static_cast<s16>(yn2);
+    state.yn1 = yn1;
+    state.yn2 = yn2;
 
     return ret;
 }

src/audio_core/cubeb_sink.cpp

@@ -12,10 +12,6 @@
 #include "common/ring_buffer.h"
 #include "core/settings.h"
 
-#ifdef _WIN32
-#include <objbase.h>
-#endif
-
 namespace AudioCore {
 
 class CubebSinkStream final : public SinkStream {
@@ -50,7 +46,7 @@ public:
         }
     }
 
-    ~CubebSinkStream() override {
+    ~CubebSinkStream() {
         if (!ctx) {
             return;
         }
@@ -79,11 +75,11 @@ public:
         queue.Push(samples);
     }
 
-    std::size_t SamplesInQueue(u32 channel_count) const override {
+    std::size_t SamplesInQueue(u32 num_channels) const override {
         if (!ctx)
             return 0;
 
-        return queue.Size() / channel_count;
+        return queue.Size() / num_channels;
     }
 
     void Flush() override {
@@ -102,7 +98,7 @@ private:
     u32 num_channels{};
 
     Common::RingBuffer<s16, 0x10000> queue;
-    std::array<s16, 2> last_frame{};
+    std::array<s16, 2> last_frame;
     std::atomic<bool> should_flush{};
     TimeStretcher time_stretch;
 
@@ -111,12 +107,7 @@ private:
     static void StateCallback(cubeb_stream* stream, void* user_data, cubeb_state state);
 };
 
-CubebSink::CubebSink(std::string_view target_device_name) {
-    // Cubeb requires COM to be initialized on the thread calling cubeb_init on Windows
-#ifdef _WIN32
-    com_init_result = CoInitializeEx(nullptr, COINIT_MULTITHREADED);
-#endif
-
+CubebSink::CubebSink(std::string target_device_name) {
     if (cubeb_init(&ctx, "yuzu", nullptr) != CUBEB_OK) {
         LOG_CRITICAL(Audio_Sink, "cubeb_init failed");
         return;
@@ -151,12 +142,6 @@ CubebSink::~CubebSink() {
     }
 
     cubeb_destroy(ctx);
-
-#ifdef _WIN32
-    if (SUCCEEDED(com_init_result)) {
-        CoUninitialize();
-    }
-#endif
 }
 
 SinkStream& CubebSink::AcquireSinkStream(u32 sample_rate, u32 num_channels,

src/audio_core/cubeb_sink.h

@@ -15,7 +15,7 @@ namespace AudioCore {
 
 class CubebSink final : public Sink {
 public:
-    explicit CubebSink(std::string_view device_id);
+    explicit CubebSink(std::string device_id);
     ~CubebSink() override;
 
     SinkStream& AcquireSinkStream(u32 sample_rate, u32 num_channels,
@@ -25,10 +25,6 @@ private:
     cubeb* ctx{};
     cubeb_devid output_device{};
     std::vector<SinkStreamPtr> sink_streams;
-
-#ifdef _WIN32
-    u32 com_init_result = 0;
-#endif
 };
 
 std::vector<std::string> ListCubebSinkDevices();

src/audio_core/null_sink.h

@@ -10,7 +10,7 @@ namespace AudioCore {
 
 class NullSink final : public Sink {
 public:
-    explicit NullSink(std::string_view) {}
+    explicit NullSink(std::string){};
     ~NullSink() override = default;
 
     SinkStream& AcquireSinkStream(u32 /*sample_rate*/, u32 /*num_channels*/,

src/audio_core/sink_details.cpp

@@ -14,68 +14,31 @@
 #include "common/logging/log.h"
 
 namespace AudioCore {
-namespace {
-struct SinkDetails {
-    using FactoryFn = std::unique_ptr<Sink> (*)(std::string_view);
-    using ListDevicesFn = std::vector<std::string> (*)();
 
-    /// Name for this sink.
-    const char* id;
-    /// A method to call to construct an instance of this type of sink.
-    FactoryFn factory;
-    /// A method to call to list available devices.
-    ListDevicesFn list_devices;
-};
-
-// sink_details is ordered in terms of desirability, with the best choice at the top.
-constexpr SinkDetails sink_details[] = {
+// g_sink_details is ordered in terms of desirability, with the best choice at the top.
+const std::vector<SinkDetails> g_sink_details = {
 #ifdef HAVE_CUBEB
-    SinkDetails{"cubeb",
-                [](std::string_view device_id) -> std::unique_ptr<Sink> {
-                    return std::make_unique<CubebSink>(device_id);
-                },
-                &ListCubebSinkDevices},
+    SinkDetails{"cubeb", &std::make_unique<CubebSink, std::string>, &ListCubebSinkDevices},
 #endif
-    SinkDetails{"null",
-                [](std::string_view device_id) -> std::unique_ptr<Sink> {
-                    return std::make_unique<NullSink>(device_id);
-                },
+    SinkDetails{"null", &std::make_unique<NullSink, std::string>,
                 [] { return std::vector<std::string>{"null"}; }},
 };
 
 const SinkDetails& GetSinkDetails(std::string_view sink_id) {
     auto iter =
-        std::find_if(std::begin(sink_details), std::end(sink_details),
+        std::find_if(g_sink_details.begin(), g_sink_details.end(),
                      [sink_id](const auto& sink_detail) { return sink_detail.id == sink_id; });
 
-    if (sink_id == "auto" || iter == std::end(sink_details)) {
+    if (sink_id == "auto" || iter == g_sink_details.end()) {
         if (sink_id != "auto") {
             LOG_ERROR(Audio, "AudioCore::SelectSink given invalid sink_id {}", sink_id);
         }
         // Auto-select.
-        // sink_details is ordered in terms of desirability, with the best choice at the front.
-        iter = std::begin(sink_details);
+        // g_sink_details is ordered in terms of desirability, with the best choice at the front.
+        iter = g_sink_details.begin();
     }
 
     return *iter;
 }
-} // Anonymous namespace
-
-std::vector<const char*> GetSinkIDs() {
-    std::vector<const char*> sink_ids(std::size(sink_details));
-
-    std::transform(std::begin(sink_details), std::end(sink_details), std::begin(sink_ids),
-                   [](const auto& sink) { return sink.id; });
-
-    return sink_ids;
-}
-
-std::vector<std::string> GetDeviceListForSink(std::string_view sink_id) {
-    return GetSinkDetails(sink_id).list_devices();
-}
-
-std::unique_ptr<Sink> CreateSinkFromID(std::string_view sink_id, std::string_view device_id) {
-    return GetSinkDetails(sink_id).factory(device_id);
-}
 
 } // namespace AudioCore

src/audio_core/sink_details.h

@@ -4,21 +4,34 @@
 
 #pragma once
 
+#include <functional>
+#include <memory>
 #include <string>
 #include <string_view>
+#include <utility>
 #include <vector>
 
 namespace AudioCore {
 
 class Sink;
 
-/// Retrieves the IDs for all available audio sinks.
-std::vector<const char*> GetSinkIDs();
+struct SinkDetails {
+    using FactoryFn = std::function<std::unique_ptr<Sink>(std::string)>;
+    using ListDevicesFn = std::function<std::vector<std::string>()>;
 
-/// Gets the list of devices for a particular sink identified by the given ID.
-std::vector<std::string> GetDeviceListForSink(std::string_view sink_id);
+    SinkDetails(const char* id_, FactoryFn factory_, ListDevicesFn list_devices_)
+        : id(id_), factory(std::move(factory_)), list_devices(std::move(list_devices_)) {}
 
-/// Creates an audio sink identified by the given device ID.
-std::unique_ptr<Sink> CreateSinkFromID(std::string_view sink_id, std::string_view device_id);
+    /// Name for this sink.
+    const char* id;
+    /// A method to call to construct an instance of this type of sink.
+    FactoryFn factory;
+    /// A method to call to list available devices.
+    ListDevicesFn list_devices;
+};
+
+extern const std::vector<SinkDetails> g_sink_details;
+
+const SinkDetails& GetSinkDetails(std::string_view sink_id);
 
 } // namespace AudioCore

src/audio_core/stream.cpp

@@ -28,16 +28,17 @@ u32 Stream::GetNumChannels() const {
     case Format::Multi51Channel16:
         return 6;
     }
-    UNIMPLEMENTED_MSG("Unimplemented format={}", static_cast<u32>(format));
+    LOG_CRITICAL(Audio, "Unimplemented format={}", static_cast<u32>(format));
+    UNREACHABLE();
     return {};
 }
 
-Stream::Stream(Core::Timing::CoreTiming& core_timing, u32 sample_rate, Format format,
-               ReleaseCallback&& release_callback, SinkStream& sink_stream, std::string&& name_)
+Stream::Stream(u32 sample_rate, Format format, ReleaseCallback&& release_callback,
+               SinkStream& sink_stream, std::string&& name_)
     : sample_rate{sample_rate}, format{format}, release_callback{std::move(release_callback)},
-      sink_stream{sink_stream}, core_timing{core_timing}, name{std::move(name_)} {
+      sink_stream{sink_stream}, name{std::move(name_)} {
 
-    release_event = core_timing.RegisterEvent(
+    release_event = CoreTiming::RegisterEvent(
         name, [this](u64 userdata, int cycles_late) { ReleaseActiveBuffer(); });
 }
 
@@ -48,7 +49,7 @@ void Stream::Play() {
 
 void Stream::Stop() {
     state = State::Stopped;
-    UNIMPLEMENTED();
+    ASSERT_MSG(false, "Unimplemented");
 }
 
 Stream::State Stream::GetState() const {
@@ -57,7 +58,7 @@ Stream::State Stream::GetState() const {
 
 s64 Stream::GetBufferReleaseCycles(const Buffer& buffer) const {
     const std::size_t num_samples{buffer.GetSamples().size() / GetNumChannels()};
-    return Core::Timing::usToCycles((static_cast<u64>(num_samples) * 1000000) / sample_rate);
+    return CoreTiming::usToCycles((static_cast<u64>(num_samples) * 1000000) / sample_rate);
 }
 
 static void VolumeAdjustSamples(std::vector<s16>& samples) {
@@ -68,7 +69,7 @@ static void VolumeAdjustSamples(std::vector<s16>& samples) {
     }
 
     // Implementation of a volume slider with a dynamic range of 60 dB
-    const float volume_scale_factor = volume == 0 ? 0 : std::exp(6.90775f * volume) * 0.001f;
+    const float volume_scale_factor{std::exp(6.90775f * volume) * 0.001f};
     for (auto& sample : samples) {
         sample = static_cast<s16>(sample * volume_scale_factor);
     }
@@ -95,11 +96,11 @@ void Stream::PlayNextBuffer() {
     active_buffer = queued_buffers.front();
     queued_buffers.pop();
 
-    VolumeAdjustSamples(active_buffer->GetSamples());
+    VolumeAdjustSamples(active_buffer->Samples());
 
     sink_stream.EnqueueSamples(GetNumChannels(), active_buffer->GetSamples());
 
-    core_timing.ScheduleEventThreadsafe(GetBufferReleaseCycles(*active_buffer), release_event, {});
+    CoreTiming::ScheduleEventThreadsafe(GetBufferReleaseCycles(*active_buffer), release_event, {});
 }
 
 void Stream::ReleaseActiveBuffer() {
@@ -119,7 +120,7 @@ bool Stream::QueueBuffer(BufferPtr&& buffer) {
 }
 
 bool Stream::ContainsBuffer(Buffer::Tag tag) const {
-    UNIMPLEMENTED();
+    ASSERT_MSG(false, "Unimplemented");
     return {};
 }
 

src/audio_core/stream.h

@@ -13,10 +13,9 @@
 #include "audio_core/buffer.h"
 #include "common/common_types.h"
 
-namespace Core::Timing {
-class CoreTiming;
+namespace CoreTiming {
 struct EventType;
-} // namespace Core::Timing
+}
 
 namespace AudioCore {
 
@@ -43,8 +42,8 @@ public:
     /// Callback function type, used to change guest state on a buffer being released
     using ReleaseCallback = std::function<void()>;
 
-    Stream(Core::Timing::CoreTiming& core_timing, u32 sample_rate, Format format,
-           ReleaseCallback&& release_callback, SinkStream& sink_stream, std::string&& name_);
+    Stream(u32 sample_rate, Format format, ReleaseCallback&& release_callback,
+           SinkStream& sink_stream, std::string&& name_);
 
     /// Plays the audio stream
     void Play();
@@ -92,17 +91,16 @@ private:
     /// Gets the number of core cycles when the specified buffer will be released
     s64 GetBufferReleaseCycles(const Buffer& buffer) const;
 
-    u32 sample_rate;                          ///< Sample rate of the stream
-    Format format;                            ///< Format of the stream
-    ReleaseCallback release_callback;         ///< Buffer release callback for the stream
-    State state{State::Stopped};              ///< Playback state of the stream
-    Core::Timing::EventType* release_event{}; ///< Core timing release event for the stream
-    BufferPtr active_buffer;                  ///< Actively playing buffer in the stream
-    std::queue<BufferPtr> queued_buffers;     ///< Buffers queued to be played in the stream
-    std::queue<BufferPtr> released_buffers;   ///< Buffers recently released from the stream
-    SinkStream& sink_stream;                  ///< Output sink for the stream
-    Core::Timing::CoreTiming& core_timing;    ///< Core timing instance.
-    std::string name;                         ///< Name of the stream, must be unique
+    u32 sample_rate;                        ///< Sample rate of the stream
+    Format format;                          ///< Format of the stream
+    ReleaseCallback release_callback;       ///< Buffer release callback for the stream
+    State state{State::Stopped};            ///< Playback state of the stream
+    CoreTiming::EventType* release_event{}; ///< Core timing release event for the stream
+    BufferPtr active_buffer;                ///< Actively playing buffer in the stream
+    std::queue<BufferPtr> queued_buffers;   ///< Buffers queued to be played in the stream
+    std::queue<BufferPtr> released_buffers; ///< Buffers recently released from the stream
+    SinkStream& sink_stream;                ///< Output sink for the stream
+    std::string name;                       ///< Name of the stream, must be unique
 };
 
 using StreamPtr = std::shared_ptr<Stream>;

src/audio_core/time_stretch.cpp

@@ -53,8 +53,8 @@ std::size_t TimeStretcher::Process(const s16* in, std::size_t num_in, s16* out,
     const double lpf_gain = 1.0 - std::exp(-time_delta / lpf_time_scale);
     m_stretch_ratio += lpf_gain * (current_ratio - m_stretch_ratio);
 
-    // Place a lower limit of 5% speed. When a game boots up, there will be
-    // many silence samples. These do not need to be timestretched.
+    // Place a lower limit of 5% speed.  When a game boots up, there will be
+    // many silence samples.  These do not need to be timestretched.
     m_stretch_ratio = std::max(m_stretch_ratio, 0.05);
     m_sound_touch.setTempo(m_stretch_ratio);
 

src/common/CMakeLists.txt

@@ -1,70 +1,42 @@
-# Add a custom command to generate a new shader_cache_version hash when any of the following files change
-# NOTE: This is an approximation of what files affect shader generation, its possible something else
-# could affect the result, but much more unlikely than the following files. Keeping a list of files
-# like this allows for much better caching since it doesn't force the user to recompile binary shaders every update
-set(VIDEO_CORE "${CMAKE_SOURCE_DIR}/src/video_core")
-if (DEFINED ENV{CI})
-  if (DEFINED ENV{TRAVIS})
+# Generate cpp with Git revision from template
+# Also if this is a CI build, add the build name (ie: Nightly, Canary) to the scm_rev file as well
+set(REPO_NAME "")
+set(BUILD_VERSION "0")
+if ($ENV{CI})
+  if ($ENV{TRAVIS})
     set(BUILD_REPOSITORY $ENV{TRAVIS_REPO_SLUG})
     set(BUILD_TAG $ENV{TRAVIS_TAG})
-  elseif(DEFINED ENV{APPVEYOR})
+  elseif($ENV{APPVEYOR})
     set(BUILD_REPOSITORY $ENV{APPVEYOR_REPO_NAME})
     set(BUILD_TAG $ENV{APPVEYOR_REPO_TAG_NAME})
   endif()
+  # regex capture the string nightly or canary into CMAKE_MATCH_1
+  string(REGEX MATCH "yuzu-emu/yuzu-?(.*)" OUTVAR ${BUILD_REPOSITORY})
+  if (${CMAKE_MATCH_COUNT} GREATER 0)
+    # capitalize the first letter of each word in the repo name.
+    string(REPLACE "-" ";" REPO_NAME_LIST ${CMAKE_MATCH_1})
+    foreach(WORD ${REPO_NAME_LIST})
+      string(SUBSTRING ${WORD} 0 1 FIRST_LETTER)
+      string(SUBSTRING ${WORD} 1 -1 REMAINDER)
+      string(TOUPPER ${FIRST_LETTER} FIRST_LETTER)
+      set(REPO_NAME "${REPO_NAME}${FIRST_LETTER}${REMAINDER}")
+    endforeach()
+    if (BUILD_TAG)
+      string(REGEX MATCH "${CMAKE_MATCH_1}-([0-9]+)" OUTVAR ${BUILD_TAG})
+      if (${CMAKE_MATCH_COUNT} GREATER 0)
+        set(BUILD_VERSION ${CMAKE_MATCH_1})
+      endif()
+      if (BUILD_VERSION)
+        # This leaves a trailing space on the last word, but we actually want that
+        # because of how it's styled in the title bar.
+        set(BUILD_FULLNAME "${REPO_NAME} ${BUILD_VERSION} ")
+      else()
+        set(BUILD_FULLNAME "")
+      endif()
+    endif()
+  endif()
 endif()
-add_custom_command(OUTPUT scm_rev.cpp
-    COMMAND ${CMAKE_COMMAND}
-      -DSRC_DIR="${CMAKE_SOURCE_DIR}"
-      -DBUILD_REPOSITORY="${BUILD_REPOSITORY}"
-      -DBUILD_TAG="${BUILD_TAG}"
-      -P "${CMAKE_SOURCE_DIR}/CMakeModules/GenerateSCMRev.cmake"
-    DEPENDS
-      # WARNING! It was too much work to try and make a common location for this list,
-      # so if you need to change it, please update CMakeModules/GenerateSCMRev.cmake as well
-      "${VIDEO_CORE}/renderer_opengl/gl_shader_cache.cpp"
-      "${VIDEO_CORE}/renderer_opengl/gl_shader_cache.h"
-      "${VIDEO_CORE}/renderer_opengl/gl_shader_decompiler.cpp"
-      "${VIDEO_CORE}/renderer_opengl/gl_shader_decompiler.h"
-      "${VIDEO_CORE}/renderer_opengl/gl_shader_disk_cache.cpp"
-      "${VIDEO_CORE}/renderer_opengl/gl_shader_disk_cache.h"
-      "${VIDEO_CORE}/renderer_opengl/gl_shader_gen.cpp"
-      "${VIDEO_CORE}/renderer_opengl/gl_shader_gen.h"
-      "${VIDEO_CORE}/shader/decode/arithmetic.cpp"
-      "${VIDEO_CORE}/shader/decode/arithmetic_half.cpp"
-      "${VIDEO_CORE}/shader/decode/arithmetic_half_immediate.cpp"
-      "${VIDEO_CORE}/shader/decode/arithmetic_immediate.cpp"
-      "${VIDEO_CORE}/shader/decode/arithmetic_integer.cpp"
-      "${VIDEO_CORE}/shader/decode/arithmetic_integer_immediate.cpp"
-      "${VIDEO_CORE}/shader/decode/bfe.cpp"
-      "${VIDEO_CORE}/shader/decode/bfi.cpp"
-      "${VIDEO_CORE}/shader/decode/conversion.cpp"
-      "${VIDEO_CORE}/shader/decode/ffma.cpp"
-      "${VIDEO_CORE}/shader/decode/float_set.cpp"
-      "${VIDEO_CORE}/shader/decode/float_set_predicate.cpp"
-      "${VIDEO_CORE}/shader/decode/half_set.cpp"
-      "${VIDEO_CORE}/shader/decode/half_set_predicate.cpp"
-      "${VIDEO_CORE}/shader/decode/hfma2.cpp"
-      "${VIDEO_CORE}/shader/decode/integer_set.cpp"
-      "${VIDEO_CORE}/shader/decode/integer_set_predicate.cpp"
-      "${VIDEO_CORE}/shader/decode/memory.cpp"
-      "${VIDEO_CORE}/shader/decode/texture.cpp"
-      "${VIDEO_CORE}/shader/decode/other.cpp"
-      "${VIDEO_CORE}/shader/decode/predicate_set_predicate.cpp"
-      "${VIDEO_CORE}/shader/decode/predicate_set_register.cpp"
-      "${VIDEO_CORE}/shader/decode/register_set_predicate.cpp"
-      "${VIDEO_CORE}/shader/decode/shift.cpp"
-      "${VIDEO_CORE}/shader/decode/video.cpp"
-      "${VIDEO_CORE}/shader/decode/xmad.cpp"
-      "${VIDEO_CORE}/shader/decode.cpp"
-      "${VIDEO_CORE}/shader/shader_ir.cpp"
-      "${VIDEO_CORE}/shader/shader_ir.h"
-      "${VIDEO_CORE}/shader/track.cpp"
-      # and also check that the scm_rev files haven't changed
-      "${CMAKE_CURRENT_SOURCE_DIR}/scm_rev.cpp.in"
-      "${CMAKE_CURRENT_SOURCE_DIR}/scm_rev.h"
-      # technically we should regenerate if the git version changed, but its not worth the effort imo
-      "${CMAKE_SOURCE_DIR}/CMakeModules/GenerateSCMRev.cmake"
-)
+configure_file("${CMAKE_CURRENT_SOURCE_DIR}/scm_rev.cpp.in" "${CMAKE_CURRENT_SOURCE_DIR}/scm_rev.cpp" @ONLY)
 
 add_library(common STATIC
     alignment.h
@@ -72,7 +44,6 @@ add_library(common STATIC
     detached_tasks.cpp
     detached_tasks.h
     bit_field.h
-    bit_util.h
     cityhash.cpp
     cityhash.h
     color.h
@@ -92,14 +63,10 @@ add_library(common STATIC
     logging/text_formatter.cpp
     logging/text_formatter.h
     math_util.h
-    memory_hook.cpp
-    memory_hook.h
     microprofile.cpp
     microprofile.h
     microprofileui.h
     misc.cpp
-    page_table.cpp
-    page_table.h
     param_package.cpp
     param_package.h
     quaternion.h
@@ -118,8 +85,6 @@ add_library(common STATIC
     threadsafe_queue.h
     timer.cpp
     timer.h
-    uint128.cpp
-    uint128.h
     vector_math.h
     web_result.h
 )

src/common/bit_field.h

@@ -111,6 +111,12 @@
 template <std::size_t Position, std::size_t Bits, typename T>
 struct BitField {
 private:
+    // We hide the copy assigment operator here, because the default copy
+    // assignment would copy the full storage value, rather than just the bits
+    // relevant to this particular bit field.
+    // We don't delete it because we want BitField to be trivially copyable.
+    constexpr BitField& operator=(const BitField&) = default;
+
     // UnderlyingType is T for non-enum types and the underlying type of T if
     // T is an enumeration. Note that T is wrapped within an enable_if in the
     // former case to workaround compile errors which arise when using
@@ -157,13 +163,9 @@ public:
     BitField(T val) = delete;
     BitField& operator=(T val) = delete;
 
-    constexpr BitField() noexcept = default;
-
-    constexpr BitField(const BitField&) noexcept = default;
-    constexpr BitField& operator=(const BitField&) noexcept = default;
-
-    constexpr BitField(BitField&&) noexcept = default;
-    constexpr BitField& operator=(BitField&&) noexcept = default;
+    // Force default constructor to be created
+    // so that we can use this within unions
+    constexpr BitField() = default;
 
     constexpr FORCE_INLINE operator T() const {
         return Value();

src/common/bit_util.h

@@ -1,61 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <climits>
-#include <cstddef>
-
-#ifdef _MSC_VER
-#include <intrin.h>
-#endif
-
-#include "common/common_types.h"
-
-namespace Common {
-
-/// Gets the size of a specified type T in bits.
-template <typename T>
-constexpr std::size_t BitSize() {
-    return sizeof(T) * CHAR_BIT;
-}
-
-#ifdef _MSC_VER
-inline u32 CountLeadingZeroes32(u32 value) {
-    unsigned long leading_zero = 0;
-
-    if (_BitScanReverse(&leading_zero, value) != 0) {
-        return 31 - leading_zero;
-    }
-
-    return 32;
-}
-
-inline u64 CountLeadingZeroes64(u64 value) {
-    unsigned long leading_zero = 0;
-
-    if (_BitScanReverse64(&leading_zero, value) != 0) {
-        return 63 - leading_zero;
-    }
-
-    return 64;
-}
-#else
-inline u32 CountLeadingZeroes32(u32 value) {
-    if (value == 0) {
-        return 32;
-    }
-
-    return __builtin_clz(value);
-}
-
-inline u64 CountLeadingZeroes64(u64 value) {
-    if (value == 0) {
-        return 64;
-    }
-
-    return __builtin_clzll(value);
-}
-#endif
-} // namespace Common

src/common/color.h

@@ -55,36 +55,36 @@ constexpr u8 Convert8To6(u8 value) {
 /**
  * Decode a color stored in RGBA8 format
  * @param bytes Pointer to encoded source color
- * @return Result color decoded as Common::Vec4<u8>
+ * @return Result color decoded as Math::Vec4<u8>
  */
-inline Common::Vec4<u8> DecodeRGBA8(const u8* bytes) {
+inline Math::Vec4<u8> DecodeRGBA8(const u8* bytes) {
     return {bytes[3], bytes[2], bytes[1], bytes[0]};
 }
 
 /**
  * Decode a color stored in RGB8 format
  * @param bytes Pointer to encoded source color
- * @return Result color decoded as Common::Vec4<u8>
+ * @return Result color decoded as Math::Vec4<u8>
  */
-inline Common::Vec4<u8> DecodeRGB8(const u8* bytes) {
+inline Math::Vec4<u8> DecodeRGB8(const u8* bytes) {
     return {bytes[2], bytes[1], bytes[0], 255};
 }
 
 /**
  * Decode a color stored in RG8 (aka HILO8) format
  * @param bytes Pointer to encoded source color
- * @return Result color decoded as Common::Vec4<u8>
+ * @return Result color decoded as Math::Vec4<u8>
  */
-inline Common::Vec4<u8> DecodeRG8(const u8* bytes) {
+inline Math::Vec4<u8> DecodeRG8(const u8* bytes) {
     return {bytes[1], bytes[0], 0, 255};
 }
 
 /**
  * Decode a color stored in RGB565 format
  * @param bytes Pointer to encoded source color
- * @return Result color decoded as Common::Vec4<u8>
+ * @return Result color decoded as Math::Vec4<u8>
  */
-inline Common::Vec4<u8> DecodeRGB565(const u8* bytes) {
+inline Math::Vec4<u8> DecodeRGB565(const u8* bytes) {
     u16_le pixel;
     std::memcpy(&pixel, bytes, sizeof(pixel));
     return {Convert5To8((pixel >> 11) & 0x1F), Convert6To8((pixel >> 5) & 0x3F),
@@ -94,9 +94,9 @@ inline Common::Vec4<u8> DecodeRGB565(const u8* bytes) {
 /**
  * Decode a color stored in RGB5A1 format
  * @param bytes Pointer to encoded source color
- * @return Result color decoded as Common::Vec4<u8>
+ * @return Result color decoded as Math::Vec4<u8>
  */
-inline Common::Vec4<u8> DecodeRGB5A1(const u8* bytes) {
+inline Math::Vec4<u8> DecodeRGB5A1(const u8* bytes) {
     u16_le pixel;
     std::memcpy(&pixel, bytes, sizeof(pixel));
     return {Convert5To8((pixel >> 11) & 0x1F), Convert5To8((pixel >> 6) & 0x1F),
@@ -106,9 +106,9 @@ inline Common::Vec4<u8> DecodeRGB5A1(const u8* bytes) {
 /**
  * Decode a color stored in RGBA4 format
  * @param bytes Pointer to encoded source color
- * @return Result color decoded as Common::Vec4<u8>
+ * @return Result color decoded as Math::Vec4<u8>
  */
-inline Common::Vec4<u8> DecodeRGBA4(const u8* bytes) {
+inline Math::Vec4<u8> DecodeRGBA4(const u8* bytes) {
     u16_le pixel;
     std::memcpy(&pixel, bytes, sizeof(pixel));
     return {Convert4To8((pixel >> 12) & 0xF), Convert4To8((pixel >> 8) & 0xF),
@@ -138,9 +138,9 @@ inline u32 DecodeD24(const u8* bytes) {
 /**
  * Decode a depth value and a stencil value stored in D24S8 format
  * @param bytes Pointer to encoded source values
- * @return Resulting values stored as a Common::Vec2
+ * @return Resulting values stored as a Math::Vec2
  */
-inline Common::Vec2<u32> DecodeD24S8(const u8* bytes) {
+inline Math::Vec2<u32> DecodeD24S8(const u8* bytes) {
     return {static_cast<u32>((bytes[2] << 16) | (bytes[1] << 8) | bytes[0]), bytes[3]};
 }
 
@@ -149,7 +149,7 @@ inline Common::Vec2<u32> DecodeD24S8(const u8* bytes) {
  * @param color Source color to encode
  * @param bytes Destination pointer to store encoded color
  */
-inline void EncodeRGBA8(const Common::Vec4<u8>& color, u8* bytes) {
+inline void EncodeRGBA8(const Math::Vec4<u8>& color, u8* bytes) {
     bytes[3] = color.r();
     bytes[2] = color.g();
     bytes[1] = color.b();
@@ -161,7 +161,7 @@ inline void EncodeRGBA8(const Common::Vec4<u8>& color, u8* bytes) {
  * @param color Source color to encode
  * @param bytes Destination pointer to store encoded color
  */
-inline void EncodeRGB8(const Common::Vec4<u8>& color, u8* bytes) {
+inline void EncodeRGB8(const Math::Vec4<u8>& color, u8* bytes) {
     bytes[2] = color.r();
     bytes[1] = color.g();
     bytes[0] = color.b();
@@ -172,7 +172,7 @@ inline void EncodeRGB8(const Common::Vec4<u8>& color, u8* bytes) {
  * @param color Source color to encode
  * @param bytes Destination pointer to store encoded color
  */
-inline void EncodeRG8(const Common::Vec4<u8>& color, u8* bytes) {
+inline void EncodeRG8(const Math::Vec4<u8>& color, u8* bytes) {
     bytes[1] = color.r();
     bytes[0] = color.g();
 }
@@ -181,7 +181,7 @@ inline void EncodeRG8(const Common::Vec4<u8>& color, u8* bytes) {
  * @param color Source color to encode
  * @param bytes Destination pointer to store encoded color
  */
-inline void EncodeRGB565(const Common::Vec4<u8>& color, u8* bytes) {
+inline void EncodeRGB565(const Math::Vec4<u8>& color, u8* bytes) {
     const u16_le data =
         (Convert8To5(color.r()) << 11) | (Convert8To6(color.g()) << 5) | Convert8To5(color.b());
 
@@ -193,7 +193,7 @@ inline void EncodeRGB565(const Common::Vec4<u8>& color, u8* bytes) {
  * @param color Source color to encode
  * @param bytes Destination pointer to store encoded color
  */
-inline void EncodeRGB5A1(const Common::Vec4<u8>& color, u8* bytes) {
+inline void EncodeRGB5A1(const Math::Vec4<u8>& color, u8* bytes) {
     const u16_le data = (Convert8To5(color.r()) << 11) | (Convert8To5(color.g()) << 6) |
                         (Convert8To5(color.b()) << 1) | Convert8To1(color.a());
 
@@ -205,7 +205,7 @@ inline void EncodeRGB5A1(const Common::Vec4<u8>& color, u8* bytes) {
  * @param color Source color to encode
  * @param bytes Destination pointer to store encoded color
  */
-inline void EncodeRGBA4(const Common::Vec4<u8>& color, u8* bytes) {
+inline void EncodeRGBA4(const Math::Vec4<u8>& color, u8* bytes) {
     const u16 data = (Convert8To4(color.r()) << 12) | (Convert8To4(color.g()) << 8) |
                      (Convert8To4(color.b()) << 4) | Convert8To4(color.a());
 

src/common/common_paths.h

@@ -35,7 +35,6 @@
 #define KEYS_DIR "keys"
 #define LOAD_DIR "load"
 #define DUMP_DIR "dump"
-#define SHADER_DIR "shader"
 #define LOG_DIR "log"
 
 // Filenames

src/common/file_util.cpp

@@ -710,7 +710,6 @@ const std::string& GetUserPath(UserPath path, const std::string& new_path) {
         paths.emplace(UserPath::NANDDir, user_path + NAND_DIR DIR_SEP);
         paths.emplace(UserPath::LoadDir, user_path + LOAD_DIR DIR_SEP);
         paths.emplace(UserPath::DumpDir, user_path + DUMP_DIR DIR_SEP);
-        paths.emplace(UserPath::ShaderDir, user_path + SHADER_DIR DIR_SEP);
         paths.emplace(UserPath::SysDataDir, user_path + SYSDATA_DIR DIR_SEP);
         paths.emplace(UserPath::KeysDir, user_path + KEYS_DIR DIR_SEP);
         // TODO: Put the logs in a better location for each OS

src/common/file_util.h

@@ -31,7 +31,6 @@ enum class UserPath {
     SDMCDir,
     LoadDir,
     DumpDir,
-    ShaderDir,
     SysDataDir,
     UserDir,
 };

src/common/logging/backend.cpp

@@ -13,7 +13,7 @@
 #include <vector>
 #ifdef _WIN32
 #include <share.h>   // For _SH_DENYWR
-#include <windows.h> // For OutputDebugStringW
+#include <windows.h> // For OutputDebugStringA
 #else
 #define _SH_DENYWR 0
 #endif
@@ -39,10 +39,10 @@ public:
     Impl(Impl const&) = delete;
     const Impl& operator=(Impl const&) = delete;
 
-    void PushEntry(Class log_class, Level log_level, const char* filename, unsigned int line_num,
-                   const char* function, std::string message) {
-        message_queue.Push(
-            CreateEntry(log_class, log_level, filename, line_num, function, std::move(message)));
+    void PushEntry(Entry e) {
+        std::lock_guard<std::mutex> lock(message_mutex);
+        message_queue.Push(std::move(e));
+        message_cv.notify_one();
     }
 
     void AddBackend(std::unique_ptr<Backend> backend) {
@@ -86,13 +86,15 @@ private:
                 }
             };
             while (true) {
-                entry = message_queue.PopWait();
-                if (entry.final_entry) {
+                {
+                    std::unique_lock<std::mutex> lock(message_mutex);
+                    message_cv.wait(lock, [&] { return !running || message_queue.Pop(entry); });
+                }
+                if (!running) {
                     break;
                 }
                 write_logs(entry);
             }
-
             // Drain the logging queue. Only writes out up to MAX_LOGS_TO_WRITE to prevent a case
             // where a system is repeatedly spamming logs even on close.
             const int MAX_LOGS_TO_WRITE = filter.IsDebug() ? INT_MAX : 100;
@@ -104,36 +106,18 @@ private:
     }
 
     ~Impl() {
-        Entry entry;
-        entry.final_entry = true;
-        message_queue.Push(entry);
+        running = false;
+        message_cv.notify_one();
         backend_thread.join();
     }
 
-    Entry CreateEntry(Class log_class, Level log_level, const char* filename, unsigned int line_nr,
-                      const char* function, std::string message) const {
-        using std::chrono::duration_cast;
-        using std::chrono::steady_clock;
-
-        Entry entry;
-        entry.timestamp =
-            duration_cast<std::chrono::microseconds>(steady_clock::now() - time_origin);
-        entry.log_class = log_class;
-        entry.log_level = log_level;
-        entry.filename = Common::TrimSourcePath(filename);
-        entry.line_num = line_nr;
-        entry.function = function;
-        entry.message = std::move(message);
-
-        return entry;
-    }
-
-    std::mutex writing_mutex;
+    std::atomic_bool running{true};
+    std::mutex message_mutex, writing_mutex;
+    std::condition_variable message_cv;
     std::thread backend_thread;
     std::vector<std::unique_ptr<Backend>> backends;
     Common::MPSCQueue<Log::Entry> message_queue;
     Filter filter;
-    std::chrono::steady_clock::time_point time_origin{std::chrono::steady_clock::now()};
 };
 
 void ConsoleBackend::Write(const Entry& entry) {
@@ -164,7 +148,7 @@ void FileBackend::Write(const Entry& entry) {
 
 void DebuggerBackend::Write(const Entry& entry) {
 #ifdef _WIN32
-    ::OutputDebugStringW(Common::UTF8ToUTF16W(FormatLogMessage(entry).append(1, '\n')).c_str());
+    ::OutputDebugStringA(FormatLogMessage(entry).append(1, '\n').c_str());
 #endif
 }
 
@@ -292,6 +276,25 @@ const char* GetLevelName(Level log_level) {
 #undef LVL
 }
 
+Entry CreateEntry(Class log_class, Level log_level, const char* filename, unsigned int line_nr,
+                  const char* function, std::string message) {
+    using std::chrono::duration_cast;
+    using std::chrono::steady_clock;
+
+    static steady_clock::time_point time_origin = steady_clock::now();
+
+    Entry entry;
+    entry.timestamp = duration_cast<std::chrono::microseconds>(steady_clock::now() - time_origin);
+    entry.log_class = log_class;
+    entry.log_level = log_level;
+    entry.filename = Common::TrimSourcePath(filename);
+    entry.line_num = line_nr;
+    entry.function = function;
+    entry.message = std::move(message);
+
+    return entry;
+}
+
 void SetGlobalFilter(const Filter& filter) {
     Impl::Instance().SetGlobalFilter(filter);
 }
@@ -316,7 +319,9 @@ void FmtLogMessageImpl(Class log_class, Level log_level, const char* filename,
     if (!filter.CheckMessage(log_class, log_level))
         return;
 
-    instance.PushEntry(log_class, log_level, filename, line_num, function,
-                       fmt::vformat(format, args));
+    Entry entry =
+        CreateEntry(log_class, log_level, filename, line_num, function, fmt::vformat(format, args));
+
+    instance.PushEntry(std::move(entry));
 }
 } // namespace Log

src/common/logging/backend.h

@@ -27,7 +27,6 @@ struct Entry {
     unsigned int line_num;
     std::string function;
     std::string message;
-    bool final_entry = false;
 
     Entry() = default;
     Entry(Entry&& o) = default;
@@ -135,6 +134,10 @@ const char* GetLogClassName(Class log_class);
  */
 const char* GetLevelName(Level log_level);
 
+/// Creates a log entry by formatting the given source location, and message.
+Entry CreateEntry(Class log_class, Level log_level, const char* filename, unsigned int line_nr,
+                  const char* function, std::string message);
+
 /**
  * The global filter will prevent any messages from even being processed if they are filtered. Each
  * backend can have a filter, but if the level is lower than the global filter, the backend will

src/common/math_util.h

@@ -7,7 +7,7 @@
 #include <cstdlib>
 #include <type_traits>
 
-namespace Common {
+namespace MathUtil {
 
 constexpr float PI = 3.14159265f;
 
@@ -41,4 +41,4 @@ struct Rectangle {
     }
 };
 
-} // namespace Common
+} // namespace MathUtil

src/common/page_table.cpp

@@ -1,29 +0,0 @@
-// Copyright 2019 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include "common/page_table.h"
-
-namespace Common {
-
-PageTable::PageTable(std::size_t page_size_in_bits) : page_size_in_bits{page_size_in_bits} {}
-
-PageTable::~PageTable() = default;
-
-void PageTable::Resize(std::size_t address_space_width_in_bits) {
-    const std::size_t num_page_table_entries = 1ULL
-                                               << (address_space_width_in_bits - page_size_in_bits);
-
-    pointers.resize(num_page_table_entries);
-    attributes.resize(num_page_table_entries);
-
-    // The default is a 39-bit address space, which causes an initial 1GB allocation size. If the
-    // vector size is subsequently decreased (via resize), the vector might not automatically
-    // actually reallocate/resize its underlying allocation, which wastes up to ~800 MB for
-    // 36-bit titles. Call shrink_to_fit to reduce capacity to what's actually in use.
-
-    pointers.shrink_to_fit();
-    attributes.shrink_to_fit();
-}
-
-} // namespace Common

src/common/page_table.h

@@ -1,80 +0,0 @@
-// Copyright 2019 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <vector>
-#include <boost/icl/interval_map.hpp>
-#include "common/common_types.h"
-#include "common/memory_hook.h"
-
-namespace Common {
-
-enum class PageType : u8 {
-    /// Page is unmapped and should cause an access error.
-    Unmapped,
-    /// Page is mapped to regular memory. This is the only type you can get pointers to.
-    Memory,
-    /// Page is mapped to regular memory, but also needs to check for rasterizer cache flushing and
-    /// invalidation
-    RasterizerCachedMemory,
-    /// Page is mapped to a I/O region. Writing and reading to this page is handled by functions.
-    Special,
-};
-
-struct SpecialRegion {
-    enum class Type {
-        DebugHook,
-        IODevice,
-    } type;
-
-    MemoryHookPointer handler;
-
-    bool operator<(const SpecialRegion& other) const {
-        return std::tie(type, handler) < std::tie(other.type, other.handler);
-    }
-
-    bool operator==(const SpecialRegion& other) const {
-        return std::tie(type, handler) == std::tie(other.type, other.handler);
-    }
-};
-
-/**
- * A (reasonably) fast way of allowing switchable and remappable process address spaces. It loosely
- * mimics the way a real CPU page table works.
- */
-struct PageTable {
-    explicit PageTable(std::size_t page_size_in_bits);
-    ~PageTable();
-
-    /**
-     * Resizes the page table to be able to accomodate enough pages within
-     * a given address space.
-     *
-     * @param address_space_width_in_bits The address size width in bits.
-     */
-    void Resize(std::size_t address_space_width_in_bits);
-
-    /**
-     * Vector of memory pointers backing each page. An entry can only be non-null if the
-     * corresponding entry in the `attributes` vector is of type `Memory`.
-     */
-    std::vector<u8*> pointers;
-
-    /**
-     * Contains MMIO handlers that back memory regions whose entries in the `attribute` vector is
-     * of type `Special`.
-     */
-    boost::icl::interval_map<VAddr, std::set<SpecialRegion>> special_regions;
-
-    /**
-     * Vector of fine grained page attributes. If it is set to any value other than `Memory`, then
-     * the corresponding entry in `pointers` MUST be set to null.
-     */
-    std::vector<PageType> attributes;
-
-    const std::size_t page_size_in_bits{};
-};
-
-} // namespace Common

src/common/quaternion.h

@@ -6,13 +6,13 @@
 
 #include "common/vector_math.h"
 
-namespace Common {
+namespace Math {
 
 template <typename T>
 class Quaternion {
 public:
-    Vec3<T> xyz;
-    T w{};
+    Math::Vec3<T> xyz;
+    T w;
 
     Quaternion<decltype(-T{})> Inverse() const {
         return {-xyz, w};
@@ -38,12 +38,12 @@ public:
 };
 
 template <typename T>
-auto QuaternionRotate(const Quaternion<T>& q, const Vec3<T>& v) {
+auto QuaternionRotate(const Quaternion<T>& q, const Math::Vec3<T>& v) {
     return v + 2 * Cross(q.xyz, Cross(q.xyz, v) + v * q.w);
 }
 
-inline Quaternion<float> MakeQuaternion(const Vec3<float>& axis, float angle) {
+inline Quaternion<float> MakeQuaternion(const Math::Vec3<float>& axis, float angle) {
     return {axis * std::sin(angle / 2), std::cos(angle / 2)};
 }
 
-} // namespace Common
+} // namespace Math

src/common/scm_rev.cpp.in

@@ -11,7 +11,6 @@
 #define BUILD_DATE   "@BUILD_DATE@"
 #define BUILD_FULLNAME "@BUILD_FULLNAME@"
 #define BUILD_VERSION "@BUILD_VERSION@"
-#define SHADER_CACHE_VERSION "@SHADER_CACHE_VERSION@"
 
 namespace Common {
 
@@ -22,7 +21,6 @@ const char g_build_name[]   = BUILD_NAME;
 const char g_build_date[]   = BUILD_DATE;
 const char g_build_fullname[] = BUILD_FULLNAME;
 const char g_build_version[]  = BUILD_VERSION;
-const char g_shader_cache_version[] = SHADER_CACHE_VERSION;
 
 } // namespace
 

src/common/scm_rev.h

@@ -13,6 +13,5 @@ extern const char g_build_name[];
 extern const char g_build_date[];
 extern const char g_build_fullname[];
 extern const char g_build_version[];
-extern const char g_shader_cache_version[];
 
 } // namespace Common

src/common/swap.h

@@ -28,8 +28,8 @@
 #include <cstring>
 #include "common/common_types.h"
 
-// GCC
-#ifdef __GNUC__
+// GCC 4.6+
+#if __GNUC__ >= 5 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)
 
 #if __BYTE_ORDER__ && (__BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__) && !defined(COMMON_LITTLE_ENDIAN)
 #define COMMON_LITTLE_ENDIAN 1
@@ -38,7 +38,7 @@
 #endif
 
 // LLVM/clang
-#elif defined(__clang__)
+#elif __clang__
 
 #if __LITTLE_ENDIAN__ && !defined(COMMON_LITTLE_ENDIAN)
 #define COMMON_LITTLE_ENDIAN 1

src/common/thread_queue_list.h

@@ -49,22 +49,6 @@ struct ThreadQueueList {
         return T();
     }
 
-    template <typename UnaryPredicate>
-    T get_first_filter(UnaryPredicate filter) const {
-        const Queue* cur = first;
-        while (cur != nullptr) {
-            if (!cur->data.empty()) {
-                for (const auto& item : cur->data) {
-                    if (filter(item))
-                        return item;
-                }
-            }
-            cur = cur->next_nonempty;
-        }
-
-        return T();
-    }
-
     T pop_first() {
         Queue* cur = first;
         while (cur != nullptr) {

src/common/threadsafe_queue.h

@@ -7,17 +7,17 @@
 // a simple lockless thread-safe,
 // single reader, single writer queue
 
+#include <algorithm>
 #include <atomic>
-#include <condition_variable>
 #include <cstddef>
 #include <mutex>
-#include <utility>
+#include "common/common_types.h"
 
 namespace Common {
-template <typename T>
+template <typename T, bool NeedSize = true>
 class SPSCQueue {
 public:
-    SPSCQueue() {
+    SPSCQueue() : size(0) {
         write_ptr = read_ptr = new ElementPtr();
     }
     ~SPSCQueue() {
@@ -25,12 +25,13 @@ public:
         delete read_ptr;
     }
 
-    std::size_t Size() const {
+    u32 Size() const {
+        static_assert(NeedSize, "using Size() on FifoQueue without NeedSize");
         return size.load();
     }
 
     bool Empty() const {
-        return Size() == 0;
+        return !read_ptr->next.load();
     }
 
     T& Front() const {
@@ -46,14 +47,13 @@ public:
         ElementPtr* new_ptr = new ElementPtr();
         write_ptr->next.store(new_ptr, std::memory_order_release);
         write_ptr = new_ptr;
-        cv.notify_one();
-
-        ++size;
+        if (NeedSize)
+            size++;
     }
 
     void Pop() {
-        --size;
-
+        if (NeedSize)
+            size--;
         ElementPtr* tmpptr = read_ptr;
         // advance the read pointer
         read_ptr = tmpptr->next.load();
@@ -66,7 +66,8 @@ public:
         if (Empty())
             return false;
 
-        --size;
+        if (NeedSize)
+            size--;
 
         ElementPtr* tmpptr = read_ptr;
         read_ptr = tmpptr->next.load(std::memory_order_acquire);
@@ -76,16 +77,6 @@ public:
         return true;
     }
 
-    T PopWait() {
-        if (Empty()) {
-            std::unique_lock<std::mutex> lock(cv_mutex);
-            cv.wait(lock, [this]() { return !Empty(); });
-        }
-        T t;
-        Pop(t);
-        return t;
-    }
-
     // not thread-safe
     void Clear() {
         size.store(0);
@@ -98,7 +89,7 @@ private:
     // and a pointer to the next ElementPtr
     class ElementPtr {
     public:
-        ElementPtr() {}
+        ElementPtr() : next(nullptr) {}
         ~ElementPtr() {
             ElementPtr* next_ptr = next.load();
 
@@ -107,23 +98,21 @@ private:
         }
 
         T current;
-        std::atomic<ElementPtr*> next{nullptr};
+        std::atomic<ElementPtr*> next;
     };
 
     ElementPtr* write_ptr;
     ElementPtr* read_ptr;
-    std::atomic_size_t size{0};
-    std::mutex cv_mutex;
-    std::condition_variable cv;
+    std::atomic<u32> size;
 };
 
 // a simple thread-safe,
 // single reader, multiple writer queue
 
-template <typename T>
+template <typename T, bool NeedSize = true>
 class MPSCQueue {
 public:
-    std::size_t Size() const {
+    u32 Size() const {
         return spsc_queue.Size();
     }
 
@@ -149,17 +138,13 @@ public:
         return spsc_queue.Pop(t);
     }
 
-    T PopWait() {
-        return spsc_queue.PopWait();
-    }
-
     // not thread-safe
     void Clear() {
         spsc_queue.Clear();
     }
 
 private:
-    SPSCQueue<T> spsc_queue;
+    SPSCQueue<T, NeedSize> spsc_queue;
     std::mutex write_lock;
 };
 } // namespace Common

src/common/uint128.cpp

@@ -1,41 +0,0 @@
-#ifdef _MSC_VER
-#include <intrin.h>
-
-#pragma intrinsic(_umul128)
-#endif
-#include <cstring>
-#include "common/uint128.h"
-
-namespace Common {
-
-u128 Multiply64Into128(u64 a, u64 b) {
-    u128 result;
-#ifdef _MSC_VER
-    result[0] = _umul128(a, b, &result[1]);
-#else
-    unsigned __int128 tmp = a;
-    tmp *= b;
-    std::memcpy(&result, &tmp, sizeof(u128));
-#endif
-    return result;
-}
-
-std::pair<u64, u64> Divide128On32(u128 dividend, u32 divisor) {
-    u64 remainder = dividend[0] % divisor;
-    u64 accum = dividend[0] / divisor;
-    if (dividend[1] == 0)
-        return {accum, remainder};
-    // We ignore dividend[1] / divisor as that overflows
-    const u64 first_segment = (dividend[1] % divisor) << 32;
-    accum += (first_segment / divisor) << 32;
-    const u64 second_segment = (first_segment % divisor) << 32;
-    accum += (second_segment / divisor);
-    remainder += second_segment % divisor;
-    if (remainder >= divisor) {
-        accum++;
-        remainder -= divisor;
-    }
-    return {accum, remainder};
-}
-
-} // namespace Common

src/common/uint128.h

@@ -1,14 +0,0 @@
-
-#include <utility>
-#include "common/common_types.h"
-
-namespace Common {
-
-// This function multiplies 2 u64 values and produces a u128 value;
-u128 Multiply64Into128(u64 a, u64 b);
-
-// This function divides a u128 by a u32 value and produces two u64 values:
-// the result of division and the remainder
-std::pair<u64, u64> Divide128On32(u128 dividend, u32 divisor);
-
-} // namespace Common

src/common/vector_math.h

@@ -33,7 +33,7 @@
 #include <cmath>
 #include <type_traits>
 
-namespace Common {
+namespace Math {
 
 template <typename T>
 class Vec2;
@@ -690,4 +690,4 @@ constexpr Vec4<T> MakeVec(const T& x, const Vec3<T>& yzw) {
     return MakeVec(x, yzw[0], yzw[1], yzw[2]);
 }
 
-} // namespace Common
+} // namespace Math

src/core/CMakeLists.txt

@@ -1,6 +1,5 @@
 add_library(core STATIC
     arm/arm_interface.h
-    arm/arm_interface.cpp
     arm/exclusive_monitor.cpp
     arm/exclusive_monitor.h
     arm/unicorn/arm_unicorn.cpp
@@ -64,10 +63,6 @@ add_library(core STATIC
     file_sys/sdmc_factory.h
     file_sys/submission_package.cpp
     file_sys/submission_package.h
-    file_sys/system_archive/ng_word.cpp
-    file_sys/system_archive/ng_word.h
-    file_sys/system_archive/system_archive.cpp
-    file_sys/system_archive/system_archive.h
     file_sys/vfs.cpp
     file_sys/vfs.h
     file_sys/vfs_concat.cpp
@@ -84,19 +79,13 @@ add_library(core STATIC
     file_sys/vfs_vector.h
     file_sys/xts_archive.cpp
     file_sys/xts_archive.h
-    frontend/applets/profile_select.cpp
-    frontend/applets/profile_select.h
     frontend/applets/software_keyboard.cpp
     frontend/applets/software_keyboard.h
-    frontend/applets/web_browser.cpp
-    frontend/applets/web_browser.h
     frontend/emu_window.cpp
     frontend/emu_window.h
     frontend/framebuffer_layout.cpp
     frontend/framebuffer_layout.h
     frontend/input.h
-    frontend/scope_acquire_window_context.cpp
-    frontend/scope_acquire_window_context.h
     gdbstub/gdbstub.cpp
     gdbstub/gdbstub.h
     hle/ipc.h
@@ -108,6 +97,8 @@ add_library(core STATIC
     hle/kernel/client_session.cpp
     hle/kernel/client_session.h
     hle/kernel/errors.h
+    hle/kernel/event.cpp
+    hle/kernel/event.h
     hle/kernel/handle_table.cpp
     hle/kernel/handle_table.h
     hle/kernel/hle_ipc.cpp
@@ -120,10 +111,6 @@ add_library(core STATIC
     hle/kernel/object.h
     hle/kernel/process.cpp
     hle/kernel/process.h
-    hle/kernel/process_capability.cpp
-    hle/kernel/process_capability.h
-    hle/kernel/readable_event.cpp
-    hle/kernel/readable_event.h
     hle/kernel/resource_limit.cpp
     hle/kernel/resource_limit.h
     hle/kernel/scheduler.cpp
@@ -140,12 +127,12 @@ add_library(core STATIC
     hle/kernel/svc_wrap.h
     hle/kernel/thread.cpp
     hle/kernel/thread.h
+    hle/kernel/timer.cpp
+    hle/kernel/timer.h
     hle/kernel/vm_manager.cpp
     hle/kernel/vm_manager.h
     hle/kernel/wait_object.cpp
     hle/kernel/wait_object.h
-    hle/kernel/writable_event.cpp
-    hle/kernel/writable_event.h
     hle/lock.cpp
     hle/lock.h
     hle/result.h
@@ -169,14 +156,10 @@ add_library(core STATIC
     hle/service/am/applet_oe.h
     hle/service/am/applets/applets.cpp
     hle/service/am/applets/applets.h
-    hle/service/am/applets/profile_select.cpp
-    hle/service/am/applets/profile_select.h
     hle/service/am/applets/software_keyboard.cpp
     hle/service/am/applets/software_keyboard.h
     hle/service/am/applets/stub_applet.cpp
     hle/service/am/applets/stub_applet.h
-    hle/service/am/applets/web_browser.cpp
-    hle/service/am/applets/web_browser.h
     hle/service/am/idle.cpp
     hle/service/am/idle.h
     hle/service/am/omm.cpp
@@ -217,7 +200,6 @@ add_library(core STATIC
     hle/service/audio/audren_u.h
     hle/service/audio/codecctl.cpp
     hle/service/audio/codecctl.h
-    hle/service/audio/errors.h
     hle/service/audio/hwopus.cpp
     hle/service/audio/hwopus.h
     hle/service/bcat/bcat.cpp
@@ -401,10 +383,6 @@ add_library(core STATIC
     hle/service/time/time.h
     hle/service/usb/usb.cpp
     hle/service/usb/usb.h
-    hle/service/vi/display/vi_display.cpp
-    hle/service/vi/display/vi_display.h
-    hle/service/vi/layer/vi_layer.cpp
-    hle/service/vi/layer/vi_layer.h
     hle/service/vi/vi.cpp
     hle/service/vi/vi.h
     hle/service/vi/vi_m.cpp
@@ -437,6 +415,8 @@ add_library(core STATIC
     loader/xci.h
     memory.cpp
     memory.h
+    memory_hook.cpp
+    memory_hook.h
     memory_setup.h
     perf_stats.cpp
     perf_stats.h

src/core/arm/arm_interface.cpp

@@ -1,27 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include "common/common_types.h"
-#include "common/logging/log.h"
-#include "core/arm/arm_interface.h"
-#include "core/memory.h"
-
-namespace Core {
-void ARM_Interface::LogBacktrace() const {
-    VAddr fp = GetReg(29);
-    VAddr lr = GetReg(30);
-    const VAddr sp = GetReg(13);
-    const VAddr pc = GetPC();
-
-    LOG_ERROR(Core_ARM, "Backtrace, sp={:016X}, pc={:016X}", sp, pc);
-    while (true) {
-        LOG_ERROR(Core_ARM, "{:016X}", lr);
-        if (!fp) {
-            break;
-        }
-        lr = Memory::Read64(fp + 8) - 4;
-        fp = Memory::Read64(fp);
-    }
-}
-} // namespace Core

src/core/arm/arm_interface.h

@@ -141,14 +141,6 @@ public:
 
     /// Prepare core for thread reschedule (if needed to correctly handle state)
     virtual void PrepareReschedule() = 0;
-
-    /// fp (= r29) points to the last frame record.
-    /// Note that this is the frame record for the *previous* frame, not the current one.
-    /// Note we need to subtract 4 from our last read to get the proper address
-    /// Frame records are two words long:
-    /// fp+0 : pointer to previous frame record
-    /// fp+8 : value of lr for frame
-    void LogBacktrace() const;
 };
 
 } // namespace Core

src/core/arm/dynarmic/arm_dynarmic.cpp

@@ -12,7 +12,6 @@
 #include "core/core.h"
 #include "core/core_cpu.h"
 #include "core/core_timing.h"
-#include "core/core_timing_util.h"
 #include "core/gdbstub/gdbstub.h"
 #include "core/hle/kernel/process.h"
 #include "core/hle/kernel/svc.h"
@@ -113,14 +112,14 @@ public:
         // Always execute at least one tick.
         amortized_ticks = std::max<u64>(amortized_ticks, 1);
 
-        parent.core_timing.AddTicks(amortized_ticks);
+        CoreTiming::AddTicks(amortized_ticks);
         num_interpreted_instructions = 0;
     }
     u64 GetTicksRemaining() override {
-        return std::max(parent.core_timing.GetDowncount(), 0);
+        return std::max(CoreTiming::GetDowncount(), 0);
     }
     u64 GetCNTPCT() override {
-        return Timing::CpuCyclesToClockCycles(parent.core_timing.GetTicks());
+        return CoreTiming::GetTicks();
     }
 
     ARM_Dynarmic& parent;
@@ -152,7 +151,6 @@ std::unique_ptr<Dynarmic::A64::Jit> ARM_Dynarmic::MakeJit() const {
     config.tpidr_el0 = &cb->tpidr_el0;
     config.dczid_el0 = 4;
     config.ctr_el0 = 0x8444c004;
-    config.cntfrq_el0 = Timing::CNTFREQ;
 
     // Unpredictable instructions
     config.define_unpredictable_behaviour = true;
@@ -173,10 +171,8 @@ void ARM_Dynarmic::Step() {
     cb->InterpreterFallback(jit->GetPC(), 1);
 }
 
-ARM_Dynarmic::ARM_Dynarmic(Timing::CoreTiming& core_timing, ExclusiveMonitor& exclusive_monitor,
-                           std::size_t core_index)
-    : cb(std::make_unique<ARM_Dynarmic_Callbacks>(*this)), inner_unicorn{core_timing},
-      core_index{core_index}, core_timing{core_timing},
+ARM_Dynarmic::ARM_Dynarmic(ExclusiveMonitor& exclusive_monitor, std::size_t core_index)
+    : cb(std::make_unique<ARM_Dynarmic_Callbacks>(*this)), core_index{core_index},
       exclusive_monitor{dynamic_cast<DynarmicExclusiveMonitor&>(exclusive_monitor)} {
     ThreadContext ctx{};
     inner_unicorn.SaveContext(ctx);

src/core/arm/dynarmic/arm_dynarmic.h

@@ -12,14 +12,10 @@
 #include "core/arm/exclusive_monitor.h"
 #include "core/arm/unicorn/arm_unicorn.h"
 
-namespace Common {
+namespace Memory {
 struct PageTable;
 }
 
-namespace Core::Timing {
-class CoreTiming;
-}
-
 namespace Core {
 
 class ARM_Dynarmic_Callbacks;
@@ -27,8 +23,7 @@ class DynarmicExclusiveMonitor;
 
 class ARM_Dynarmic final : public ARM_Interface {
 public:
-    ARM_Dynarmic(Timing::CoreTiming& core_timing, ExclusiveMonitor& exclusive_monitor,
-                 std::size_t core_index);
+    ARM_Dynarmic(ExclusiveMonitor& exclusive_monitor, std::size_t core_index);
     ~ARM_Dynarmic();
 
     void MapBackingMemory(VAddr address, std::size_t size, u8* memory,
@@ -67,10 +62,9 @@ private:
     ARM_Unicorn inner_unicorn;
 
     std::size_t core_index;
-    Timing::CoreTiming& core_timing;
     DynarmicExclusiveMonitor& exclusive_monitor;
 
-    Common::PageTable* current_page_table = nullptr;
+    Memory::PageTable* current_page_table = nullptr;
 };
 
 class DynarmicExclusiveMonitor final : public ExclusiveMonitor {

src/core/arm/unicorn/arm_unicorn.cpp

@@ -10,7 +10,6 @@
 #include "core/core.h"
 #include "core/core_timing.h"
 #include "core/hle/kernel/svc.h"
-#include "core/memory.h"
 
 namespace Core {
 
@@ -72,7 +71,7 @@ static bool UnmappedMemoryHook(uc_engine* uc, uc_mem_type type, u64 addr, int si
     return {};
 }
 
-ARM_Unicorn::ARM_Unicorn(Timing::CoreTiming& core_timing) : core_timing{core_timing} {
+ARM_Unicorn::ARM_Unicorn() {
     CHECKED(uc_open(UC_ARCH_ARM64, UC_MODE_ARM, &uc));
 
     auto fpv = 3 << 20;
@@ -177,7 +176,7 @@ void ARM_Unicorn::Run() {
     if (GDBStub::IsServerEnabled()) {
         ExecuteInstructions(std::max(4000000, 0));
     } else {
-        ExecuteInstructions(std::max(core_timing.GetDowncount(), 0));
+        ExecuteInstructions(std::max(CoreTiming::GetDowncount(), 0));
     }
 }
 
@@ -190,7 +189,7 @@ MICROPROFILE_DEFINE(ARM_Jit_Unicorn, "ARM JIT", "Unicorn", MP_RGB(255, 64, 64));
 void ARM_Unicorn::ExecuteInstructions(int num_instructions) {
     MICROPROFILE_SCOPE(ARM_Jit_Unicorn);
     CHECKED(uc_emu_start(uc, GetPC(), 1ULL << 63, 0, num_instructions));
-    core_timing.AddTicks(num_instructions);
+    CoreTiming::AddTicks(num_instructions);
     if (GDBStub::IsServerEnabled()) {
         if (last_bkpt_hit) {
             uc_reg_write(uc, UC_ARM64_REG_PC, &last_bkpt.address);

src/core/arm/unicorn/arm_unicorn.h

@@ -9,17 +9,12 @@
 #include "core/arm/arm_interface.h"
 #include "core/gdbstub/gdbstub.h"
 
-namespace Core::Timing {
-class CoreTiming;
-}
-
 namespace Core {
 
 class ARM_Unicorn final : public ARM_Interface {
 public:
-    explicit ARM_Unicorn(Timing::CoreTiming& core_timing);
+    ARM_Unicorn();
     ~ARM_Unicorn();
-
     void MapBackingMemory(VAddr address, std::size_t size, u8* memory,
                           Kernel::VMAPermission perms) override;
     void UnmapMemory(VAddr address, std::size_t size) override;
@@ -48,7 +43,6 @@ public:
 
 private:
     uc_engine* uc{};
-    Timing::CoreTiming& core_timing;
     GDBStub::BreakpointAddress last_bkpt{};
     bool last_bkpt_hit;
 };

src/core/core.cpp

@@ -8,7 +8,6 @@
 #include <thread>
 #include <utility>
 
-#include "common/file_util.h"
 #include "common/logging/log.h"
 #include "common/string_util.h"
 #include "core/arm/exclusive_monitor.h"
@@ -30,14 +29,10 @@
 #include "core/hle/service/sm/sm.h"
 #include "core/loader/loader.h"
 #include "core/perf_stats.h"
-#include "core/settings.h"
 #include "core/telemetry_session.h"
-#include "frontend/applets/profile_select.h"
 #include "frontend/applets/software_keyboard.h"
-#include "frontend/applets/web_browser.h"
 #include "video_core/debug_utils/debug_utils.h"
-#include "video_core/gpu_asynch.h"
-#include "video_core/gpu_synch.h"
+#include "video_core/gpu.h"
 #include "video_core/renderer_base.h"
 #include "video_core/video_core.h"
 
@@ -45,6 +40,7 @@ namespace Core {
 
 /*static*/ System System::s_instance;
 
+namespace {
 FileSys::VirtualFile GetGameFileFromPath(const FileSys::VirtualFilesystem& vfs,
                                          const std::string& path) {
     // To account for split 00+01+etc files.
@@ -73,14 +69,11 @@ FileSys::VirtualFile GetGameFileFromPath(const FileSys::VirtualFilesystem& vfs,
         return FileSys::ConcatenatedVfsFile::MakeConcatenatedFile(concat, dir->GetName());
     }
 
-    if (FileUtil::IsDirectory(path))
-        return vfs->OpenFile(path + "/" + "main", FileSys::Mode::Read);
-
     return vfs->OpenFile(path, FileSys::Mode::Read);
 }
-struct System::Impl {
-    explicit Impl(System& system) : kernel{system} {}
+} // Anonymous namespace
 
+struct System::Impl {
     Cpu& CurrentCpuCore() {
         return cpu_core_manager.GetCurrentCore();
     }
@@ -96,50 +89,35 @@ struct System::Impl {
     ResultStatus Init(System& system, Frontend::EmuWindow& emu_window) {
         LOG_DEBUG(HW_Memory, "initialized OK");
 
-        core_timing.Initialize();
+        CoreTiming::Init();
         kernel.Initialize();
 
-        const auto current_time = std::chrono::duration_cast<std::chrono::seconds>(
-            std::chrono::system_clock::now().time_since_epoch());
-        Settings::values.custom_rtc_differential =
-            Settings::values.custom_rtc.value_or(current_time) - current_time;
-
         // Create a default fs if one doesn't already exist.
         if (virtual_filesystem == nullptr)
             virtual_filesystem = std::make_shared<FileSys::RealVfsFilesystem>();
 
         /// Create default implementations of applets if one is not provided.
-        if (profile_selector == nullptr)
-            profile_selector = std::make_unique<Core::Frontend::DefaultProfileSelectApplet>();
         if (software_keyboard == nullptr)
             software_keyboard = std::make_unique<Core::Frontend::DefaultSoftwareKeyboardApplet>();
-        if (web_browser == nullptr)
-            web_browser = std::make_unique<Core::Frontend::DefaultWebBrowserApplet>();
 
-        auto main_process = Kernel::Process::Create(system, "main");
+        auto main_process = Kernel::Process::Create(kernel, "main");
         kernel.MakeCurrentProcess(main_process.get());
 
         telemetry_session = std::make_unique<Core::TelemetrySession>();
         service_manager = std::make_shared<Service::SM::ServiceManager>();
 
-        Service::Init(service_manager, system, *virtual_filesystem);
+        Service::Init(service_manager, *virtual_filesystem);
         GDBStub::Init();
 
-        renderer = VideoCore::CreateRenderer(emu_window, system);
+        renderer = VideoCore::CreateRenderer(emu_window);
         if (!renderer->Init()) {
             return ResultStatus::ErrorVideoCore;
         }
 
-        is_powered_on = true;
-
-        if (Settings::values.use_asynchronous_gpu_emulation) {
-            gpu_core = std::make_unique<VideoCommon::GPUAsynch>(system, *renderer);
-        } else {
-            gpu_core = std::make_unique<VideoCommon::GPUSynch>(system, *renderer);
-        }
+        gpu_core = std::make_unique<Tegra::GPU>(renderer->Rasterizer());
 
         cpu_core_manager.Initialize(system);
-
+        is_powered_on = true;
         LOG_DEBUG(Core, "Initialized OK");
 
         // Reset counters and set time origin to current frame
@@ -183,20 +161,19 @@ struct System::Impl {
             return static_cast<ResultStatus>(static_cast<u32>(ResultStatus::ErrorLoader) +
                                              static_cast<u32>(load_result));
         }
-
         status = ResultStatus::Success;
         return status;
     }
 
     void Shutdown() {
         // Log last frame performance stats
-        const auto perf_results = GetAndResetPerfStats();
-        telemetry_session->AddField(Telemetry::FieldType::Performance, "Shutdown_EmulationSpeed",
-                                    perf_results.emulation_speed * 100.0);
-        telemetry_session->AddField(Telemetry::FieldType::Performance, "Shutdown_Framerate",
-                                    perf_results.game_fps);
-        telemetry_session->AddField(Telemetry::FieldType::Performance, "Shutdown_Frametime",
-                                    perf_results.frametime * 1000.0);
+        auto perf_results = GetAndResetPerfStats();
+        Telemetry().AddField(Telemetry::FieldType::Performance, "Shutdown_EmulationSpeed",
+                             perf_results.emulation_speed * 100.0);
+        Telemetry().AddField(Telemetry::FieldType::Performance, "Shutdown_Framerate",
+                             perf_results.game_fps);
+        Telemetry().AddField(Telemetry::FieldType::Performance, "Shutdown_Frametime",
+                             perf_results.frametime * 1000.0);
 
         is_powered_on = false;
 
@@ -213,16 +190,11 @@ struct System::Impl {
 
         // Shutdown kernel and core timing
         kernel.Shutdown();
-        core_timing.Shutdown();
+        CoreTiming::Shutdown();
 
         // Close app loader
         app_loader.reset();
 
-        // Clear all applets
-        profile_selector.reset();
-        software_keyboard.reset();
-        web_browser.reset();
-
         LOG_DEBUG(Core, "Shutdown OK");
     }
 
@@ -240,10 +212,9 @@ struct System::Impl {
     }
 
     PerfStatsResults GetAndResetPerfStats() {
-        return perf_stats.GetAndResetStats(core_timing.GetGlobalTimeUs());
+        return perf_stats.GetAndResetStats(CoreTiming::GetGlobalTimeUs());
     }
 
-    Timing::CoreTiming core_timing;
     Kernel::KernelCore kernel;
     /// RealVfsFilesystem instance
     FileSys::VirtualFilesystem virtual_filesystem;
@@ -256,9 +227,7 @@ struct System::Impl {
     bool is_powered_on = false;
 
     /// Frontend applets
-    std::unique_ptr<Core::Frontend::ProfileSelectApplet> profile_selector;
     std::unique_ptr<Core::Frontend::SoftwareKeyboardApplet> software_keyboard;
-    std::unique_ptr<Core::Frontend::WebBrowserApplet> web_browser;
 
     /// Service manager
     std::shared_ptr<Service::SM::ServiceManager> service_manager;
@@ -273,7 +242,7 @@ struct System::Impl {
     Core::FrameLimiter frame_limiter;
 };
 
-System::System() : impl{std::make_unique<Impl>(*this)} {}
+System::System() : impl{std::make_unique<Impl>()} {}
 System::~System() = default;
 
 Cpu& System::CurrentCpuCore() {
@@ -405,14 +374,6 @@ const Kernel::KernelCore& System::Kernel() const {
     return impl->kernel;
 }
 
-Timing::CoreTiming& System::CoreTiming() {
-    return impl->core_timing;
-}
-
-const Timing::CoreTiming& System::CoreTiming() const {
-    return impl->core_timing;
-}
-
 Core::PerfStats& System::GetPerfStats() {
     return impl->perf_stats;
 }
@@ -461,34 +422,14 @@ std::shared_ptr<FileSys::VfsFilesystem> System::GetFilesystem() const {
     return impl->virtual_filesystem;
 }
 
-void System::SetProfileSelector(std::unique_ptr<Frontend::ProfileSelectApplet> applet) {
-    impl->profile_selector = std::move(applet);
-}
-
-const Frontend::ProfileSelectApplet& System::GetProfileSelector() const {
-    return *impl->profile_selector;
-}
-
-void System::SetSoftwareKeyboard(std::unique_ptr<Frontend::SoftwareKeyboardApplet> applet) {
+void System::SetSoftwareKeyboard(std::unique_ptr<Core::Frontend::SoftwareKeyboardApplet> applet) {
     impl->software_keyboard = std::move(applet);
 }
 
-const Frontend::SoftwareKeyboardApplet& System::GetSoftwareKeyboard() const {
+const Core::Frontend::SoftwareKeyboardApplet& System::GetSoftwareKeyboard() const {
     return *impl->software_keyboard;
 }
 
-void System::SetWebBrowser(std::unique_ptr<Frontend::WebBrowserApplet> applet) {
-    impl->web_browser = std::move(applet);
-}
-
-Frontend::WebBrowserApplet& System::GetWebBrowser() {
-    return *impl->web_browser;
-}
-
-const Frontend::WebBrowserApplet& System::GetWebBrowser() const {
-    return *impl->web_browser;
-}
-
 System::ResultStatus System::Init(Frontend::EmuWindow& emu_window) {
     return impl->Init(*this, emu_window);
 }

src/core/core.h

@@ -9,14 +9,11 @@
 #include <string>
 
 #include "common/common_types.h"
-#include "core/file_sys/vfs_types.h"
 #include "core/hle/kernel/object.h"
 
 namespace Core::Frontend {
 class EmuWindow;
-class ProfileSelectApplet;
 class SoftwareKeyboardApplet;
-class WebBrowserApplet;
 } // namespace Core::Frontend
 
 namespace FileSys {
@@ -47,10 +44,6 @@ namespace VideoCore {
 class RendererBase;
 } // namespace VideoCore
 
-namespace Core::Timing {
-class CoreTiming;
-}
-
 namespace Core {
 
 class ARM_Interface;
@@ -62,9 +55,6 @@ class TelemetrySession;
 
 struct PerfStatsResults;
 
-FileSys::VirtualFile GetGameFileFromPath(const FileSys::VirtualFilesystem& vfs,
-                                         const std::string& path);
-
 class System {
 public:
     System(const System&) = delete;
@@ -209,12 +199,6 @@ public:
     /// Provides a constant pointer to the current process.
     const Kernel::Process* CurrentProcess() const;
 
-    /// Provides a reference to the core timing instance.
-    Timing::CoreTiming& CoreTiming();
-
-    /// Provides a constant reference to the core timing instance.
-    const Timing::CoreTiming& CoreTiming() const;
-
     /// Provides a reference to the kernel instance.
     Kernel::KernelCore& Kernel();
 
@@ -253,18 +237,9 @@ public:
 
     std::shared_ptr<FileSys::VfsFilesystem> GetFilesystem() const;
 
-    void SetProfileSelector(std::unique_ptr<Frontend::ProfileSelectApplet> applet);
+    void SetSoftwareKeyboard(std::unique_ptr<Core::Frontend::SoftwareKeyboardApplet> applet);
 
-    const Frontend::ProfileSelectApplet& GetProfileSelector() const;
-
-    void SetSoftwareKeyboard(std::unique_ptr<Frontend::SoftwareKeyboardApplet> applet);
-
-    const Frontend::SoftwareKeyboardApplet& GetSoftwareKeyboard() const;
-
-    void SetWebBrowser(std::unique_ptr<Frontend::WebBrowserApplet> applet);
-
-    Frontend::WebBrowserApplet& GetWebBrowser();
-    const Frontend::WebBrowserApplet& GetWebBrowser() const;
+    const Core::Frontend::SoftwareKeyboardApplet& GetSoftwareKeyboard() const;
 
 private:
     System();
@@ -293,6 +268,10 @@ inline ARM_Interface& CurrentArmInterface() {
     return System::GetInstance().CurrentArmInterface();
 }
 
+inline TelemetrySession& Telemetry() {
+    return System::GetInstance().TelemetrySession();
+}
+
 inline Kernel::Process* CurrentProcess() {
     return System::GetInstance().CurrentProcess();
 }

src/core/core_cpu.cpp

@@ -11,7 +11,6 @@
 #endif
 #include "core/arm/exclusive_monitor.h"
 #include "core/arm/unicorn/arm_unicorn.h"
-#include "core/core.h"
 #include "core/core_cpu.h"
 #include "core/core_timing.h"
 #include "core/hle/kernel/scheduler.h"
@@ -50,21 +49,20 @@ bool CpuBarrier::Rendezvous() {
     return false;
 }
 
-Cpu::Cpu(System& system, ExclusiveMonitor& exclusive_monitor, CpuBarrier& cpu_barrier,
-         std::size_t core_index)
-    : cpu_barrier{cpu_barrier}, core_timing{system.CoreTiming()}, core_index{core_index} {
+Cpu::Cpu(ExclusiveMonitor& exclusive_monitor, CpuBarrier& cpu_barrier, std::size_t core_index)
+    : cpu_barrier{cpu_barrier}, core_index{core_index} {
     if (Settings::values.use_cpu_jit) {
 #ifdef ARCHITECTURE_x86_64
-        arm_interface = std::make_unique<ARM_Dynarmic>(core_timing, exclusive_monitor, core_index);
+        arm_interface = std::make_unique<ARM_Dynarmic>(exclusive_monitor, core_index);
 #else
         arm_interface = std::make_unique<ARM_Unicorn>();
         LOG_WARNING(Core, "CPU JIT requested, but Dynarmic not available");
 #endif
     } else {
-        arm_interface = std::make_unique<ARM_Unicorn>(core_timing);
+        arm_interface = std::make_unique<ARM_Unicorn>();
     }
 
-    scheduler = std::make_unique<Kernel::Scheduler>(system, *arm_interface);
+    scheduler = std::make_unique<Kernel::Scheduler>(*arm_interface);
 }
 
 Cpu::~Cpu() = default;
@@ -95,14 +93,14 @@ void Cpu::RunLoop(bool tight_loop) {
 
         if (IsMainCore()) {
             // TODO(Subv): Only let CoreTiming idle if all 4 cores are idling.
-            core_timing.Idle();
-            core_timing.Advance();
+            CoreTiming::Idle();
+            CoreTiming::Advance();
         }
 
         PrepareReschedule();
     } else {
         if (IsMainCore()) {
-            core_timing.Advance();
+            CoreTiming::Advance();
         }
 
         if (tight_loop) {

src/core/core_cpu.h

@@ -15,14 +15,6 @@ namespace Kernel {
 class Scheduler;
 }
 
-namespace Core {
-class System;
-}
-
-namespace Core::Timing {
-class CoreTiming;
-}
-
 namespace Core {
 
 class ARM_Interface;
@@ -49,8 +41,7 @@ private:
 
 class Cpu {
 public:
-    Cpu(System& system, ExclusiveMonitor& exclusive_monitor, CpuBarrier& cpu_barrier,
-        std::size_t core_index);
+    Cpu(ExclusiveMonitor& exclusive_monitor, CpuBarrier& cpu_barrier, std::size_t core_index);
     ~Cpu();
 
     void RunLoop(bool tight_loop = true);
@@ -91,7 +82,6 @@ private:
     std::unique_ptr<ARM_Interface> arm_interface;
     CpuBarrier& cpu_barrier;
     std::unique_ptr<Kernel::Scheduler> scheduler;
-    Timing::CoreTiming& core_timing;
 
     std::atomic<bool> reschedule_pending = false;
     std::size_t core_index;

src/core/core_timing.cpp

@@ -8,60 +8,71 @@
 #include <mutex>
 #include <string>
 #include <tuple>
-
+#include <unordered_map>
+#include <vector>
 #include "common/assert.h"
 #include "common/thread.h"
+#include "common/threadsafe_queue.h"
 #include "core/core_timing_util.h"
 
-namespace Core::Timing {
+namespace CoreTiming {
 
-constexpr int MAX_SLICE_LENGTH = 20000;
+static s64 global_timer;
+static int slice_length;
+static int downcount;
 
-struct CoreTiming::Event {
+struct EventType {
+    TimedCallback callback;
+    const std::string* name;
+};
+
+struct Event {
     s64 time;
     u64 fifo_order;
     u64 userdata;
     const EventType* type;
-
-    // Sort by time, unless the times are the same, in which case sort by
-    // the order added to the queue
-    friend bool operator>(const Event& left, const Event& right) {
-        return std::tie(left.time, left.fifo_order) > std::tie(right.time, right.fifo_order);
-    }
-
-    friend bool operator<(const Event& left, const Event& right) {
-        return std::tie(left.time, left.fifo_order) < std::tie(right.time, right.fifo_order);
-    }
 };
 
-CoreTiming::CoreTiming() = default;
-CoreTiming::~CoreTiming() = default;
-
-void CoreTiming::Initialize() {
-    downcount = MAX_SLICE_LENGTH;
-    slice_length = MAX_SLICE_LENGTH;
-    global_timer = 0;
-    idled_cycles = 0;
-
-    // The time between CoreTiming being initialized and the first call to Advance() is considered
-    // the slice boundary between slice -1 and slice 0. Dispatcher loops must call Advance() before
-    // executing the first cycle of each slice to prepare the slice length and downcount for
-    // that slice.
-    is_global_timer_sane = true;
-
-    event_fifo_id = 0;
-
-    const auto empty_timed_callback = [](u64, s64) {};
-    ev_lost = RegisterEvent("_lost_event", empty_timed_callback);
+// Sort by time, unless the times are the same, in which case sort by the order added to the queue
+static bool operator>(const Event& left, const Event& right) {
+    return std::tie(left.time, left.fifo_order) > std::tie(right.time, right.fifo_order);
 }
 
-void CoreTiming::Shutdown() {
-    MoveEvents();
-    ClearPendingEvents();
-    UnregisterAllEvents();
+static bool operator<(const Event& left, const Event& right) {
+    return std::tie(left.time, left.fifo_order) < std::tie(right.time, right.fifo_order);
 }
 
-EventType* CoreTiming::RegisterEvent(const std::string& name, TimedCallback callback) {
+// unordered_map stores each element separately as a linked list node so pointers to elements
+// remain stable regardless of rehashes/resizing.
+static std::unordered_map<std::string, EventType> event_types;
+
+// The queue is a min-heap using std::make_heap/push_heap/pop_heap.
+// We don't use std::priority_queue because we need to be able to serialize, unserialize and
+// erase arbitrary events (RemoveEvent()) regardless of the queue order. These aren't accomodated
+// by the standard adaptor class.
+static std::vector<Event> event_queue;
+static u64 event_fifo_id;
+// the queue for storing the events from other threads threadsafe until they will be added
+// to the event_queue by the emu thread
+static Common::MPSCQueue<Event, false> ts_queue;
+
+// the queue for unscheduling the events from other threads threadsafe
+static Common::MPSCQueue<std::pair<const EventType*, u64>, false> unschedule_queue;
+
+constexpr int MAX_SLICE_LENGTH = 20000;
+
+static s64 idled_cycles;
+
+// Are we in a function that has been called from Advance()
+// If events are sheduled from a function that gets called from Advance(),
+// don't change slice_length and downcount.
+static bool is_global_timer_sane;
+
+static EventType* ev_lost = nullptr;
+
+static void EmptyTimedCallback(u64 userdata, s64 cyclesLate) {}
+
+EventType* RegisterEvent(const std::string& name, TimedCallback callback) {
     // check for existing type with same name.
     // we want event type names to remain unique so that we can use them for serialization.
     ASSERT_MSG(event_types.find(name) == event_types.end(),
@@ -75,31 +86,71 @@ EventType* CoreTiming::RegisterEvent(const std::string& name, TimedCallback call
     return event_type;
 }
 
-void CoreTiming::UnregisterAllEvents() {
+void UnregisterAllEvents() {
     ASSERT_MSG(event_queue.empty(), "Cannot unregister events with events pending");
     event_types.clear();
 }
 
-void CoreTiming::ScheduleEvent(s64 cycles_into_future, const EventType* event_type, u64 userdata) {
-    ASSERT(event_type != nullptr);
-    const s64 timeout = GetTicks() + cycles_into_future;
+void Init() {
+    downcount = MAX_SLICE_LENGTH;
+    slice_length = MAX_SLICE_LENGTH;
+    global_timer = 0;
+    idled_cycles = 0;
 
-    // If this event needs to be scheduled before the next advance(), force one early
+    // The time between CoreTiming being intialized and the first call to Advance() is considered
+    // the slice boundary between slice -1 and slice 0. Dispatcher loops must call Advance() before
+    // executing the first cycle of each slice to prepare the slice length and downcount for
+    // that slice.
+    is_global_timer_sane = true;
+
+    event_fifo_id = 0;
+    ev_lost = RegisterEvent("_lost_event", &EmptyTimedCallback);
+}
+
+void Shutdown() {
+    MoveEvents();
+    ClearPendingEvents();
+    UnregisterAllEvents();
+}
+
+// This should only be called from the CPU thread. If you are calling
+// it from any other thread, you are doing something evil
+u64 GetTicks() {
+    u64 ticks = static_cast<u64>(global_timer);
     if (!is_global_timer_sane) {
-        ForceExceptionCheck(cycles_into_future);
+        ticks += slice_length - downcount;
     }
+    return ticks;
+}
 
+void AddTicks(u64 ticks) {
+    downcount -= static_cast<int>(ticks);
+}
+
+u64 GetIdleTicks() {
+    return static_cast<u64>(idled_cycles);
+}
+
+void ClearPendingEvents() {
+    event_queue.clear();
+}
+
+void ScheduleEvent(s64 cycles_into_future, const EventType* event_type, u64 userdata) {
+    ASSERT(event_type != nullptr);
+    s64 timeout = GetTicks() + cycles_into_future;
+    // If this event needs to be scheduled before the next advance(), force one early
+    if (!is_global_timer_sane)
+        ForceExceptionCheck(cycles_into_future);
     event_queue.emplace_back(Event{timeout, event_fifo_id++, userdata, event_type});
     std::push_heap(event_queue.begin(), event_queue.end(), std::greater<>());
 }
 
-void CoreTiming::ScheduleEventThreadsafe(s64 cycles_into_future, const EventType* event_type,
-                                         u64 userdata) {
+void ScheduleEventThreadsafe(s64 cycles_into_future, const EventType* event_type, u64 userdata) {
     ts_queue.Push(Event{global_timer + cycles_into_future, 0, userdata, event_type});
 }
 
-void CoreTiming::UnscheduleEvent(const EventType* event_type, u64 userdata) {
-    const auto itr = std::remove_if(event_queue.begin(), event_queue.end(), [&](const Event& e) {
+void UnscheduleEvent(const EventType* event_type, u64 userdata) {
+    auto itr = std::remove_if(event_queue.begin(), event_queue.end(), [&](const Event& e) {
         return e.type == event_type && e.userdata == userdata;
     });
 
@@ -110,33 +161,13 @@ void CoreTiming::UnscheduleEvent(const EventType* event_type, u64 userdata) {
     }
 }
 
-void CoreTiming::UnscheduleEventThreadsafe(const EventType* event_type, u64 userdata) {
+void UnscheduleEventThreadsafe(const EventType* event_type, u64 userdata) {
     unschedule_queue.Push(std::make_pair(event_type, userdata));
 }
 
-u64 CoreTiming::GetTicks() const {
-    u64 ticks = static_cast<u64>(global_timer);
-    if (!is_global_timer_sane) {
-        ticks += slice_length - downcount;
-    }
-    return ticks;
-}
-
-u64 CoreTiming::GetIdleTicks() const {
-    return static_cast<u64>(idled_cycles);
-}
-
-void CoreTiming::AddTicks(u64 ticks) {
-    downcount -= static_cast<int>(ticks);
-}
-
-void CoreTiming::ClearPendingEvents() {
-    event_queue.clear();
-}
-
-void CoreTiming::RemoveEvent(const EventType* event_type) {
-    const auto itr = std::remove_if(event_queue.begin(), event_queue.end(),
-                                    [&](const Event& e) { return e.type == event_type; });
+void RemoveEvent(const EventType* event_type) {
+    auto itr = std::remove_if(event_queue.begin(), event_queue.end(),
+                              [&](const Event& e) { return e.type == event_type; });
 
     // Removing random items breaks the invariant so we have to re-establish it.
     if (itr != event_queue.end()) {
@@ -145,24 +176,22 @@ void CoreTiming::RemoveEvent(const EventType* event_type) {
     }
 }
 
-void CoreTiming::RemoveNormalAndThreadsafeEvent(const EventType* event_type) {
+void RemoveNormalAndThreadsafeEvent(const EventType* event_type) {
     MoveEvents();
     RemoveEvent(event_type);
 }
 
-void CoreTiming::ForceExceptionCheck(s64 cycles) {
+void ForceExceptionCheck(s64 cycles) {
     cycles = std::max<s64>(0, cycles);
-    if (downcount <= cycles) {
-        return;
+    if (downcount > cycles) {
+        // downcount is always (much) smaller than MAX_INT so we can safely cast cycles to an int
+        // here. Account for cycles already executed by adjusting the g.slice_length
+        slice_length -= downcount - static_cast<int>(cycles);
+        downcount = static_cast<int>(cycles);
     }
-
-    // downcount is always (much) smaller than MAX_INT so we can safely cast cycles to an int
-    // here. Account for cycles already executed by adjusting the g.slice_length
-    slice_length -= downcount - static_cast<int>(cycles);
-    downcount = static_cast<int>(cycles);
 }
 
-void CoreTiming::MoveEvents() {
+void MoveEvents() {
     for (Event ev; ts_queue.Pop(ev);) {
         ev.fifo_order = event_fifo_id++;
         event_queue.emplace_back(std::move(ev));
@@ -170,13 +199,13 @@ void CoreTiming::MoveEvents() {
     }
 }
 
-void CoreTiming::Advance() {
+void Advance() {
     MoveEvents();
     for (std::pair<const EventType*, u64> ev; unschedule_queue.Pop(ev);) {
         UnscheduleEvent(ev.first, ev.second);
     }
 
-    const int cycles_executed = slice_length - downcount;
+    int cycles_executed = slice_length - downcount;
     global_timer += cycles_executed;
     slice_length = MAX_SLICE_LENGTH;
 
@@ -200,17 +229,17 @@ void CoreTiming::Advance() {
     downcount = slice_length;
 }
 
-void CoreTiming::Idle() {
+void Idle() {
     idled_cycles += downcount;
     downcount = 0;
 }
 
-std::chrono::microseconds CoreTiming::GetGlobalTimeUs() const {
+std::chrono::microseconds GetGlobalTimeUs() {
     return std::chrono::microseconds{GetTicks() * 1000000 / BASE_CLOCK_RATE};
 }
 
-int CoreTiming::GetDowncount() const {
+int GetDowncount() {
     return downcount;
 }
 
-} // namespace Core::Timing
+} // namespace CoreTiming

src/core/core_timing.h

@@ -4,27 +4,6 @@
 
 #pragma once
 
-#include <chrono>
-#include <functional>
-#include <string>
-#include <unordered_map>
-#include <vector>
-#include "common/common_types.h"
-#include "common/threadsafe_queue.h"
-
-namespace Core::Timing {
-
-/// A callback that may be scheduled for a particular core timing event.
-using TimedCallback = std::function<void(u64 userdata, int cycles_late)>;
-
-/// Contains the characteristics of a particular event.
-struct EventType {
-    /// The event's callback function.
-    TimedCallback callback;
-    /// A pointer to the name of the event.
-    const std::string* name;
-};
-
 /**
  * This is a system to schedule events into the emulated machine's future. Time is measured
  * in main CPU clock cycles.
@@ -37,120 +16,80 @@ struct EventType {
  * inside callback:
  *   ScheduleEvent(periodInCycles - cyclesLate, callback, "whatever")
  */
-class CoreTiming {
-public:
-    CoreTiming();
-    ~CoreTiming();
 
-    CoreTiming(const CoreTiming&) = delete;
-    CoreTiming(CoreTiming&&) = delete;
+#include <chrono>
+#include <functional>
+#include <string>
+#include "common/common_types.h"
 
-    CoreTiming& operator=(const CoreTiming&) = delete;
-    CoreTiming& operator=(CoreTiming&&) = delete;
+namespace CoreTiming {
 
-    /// CoreTiming begins at the boundary of timing slice -1. An initial call to Advance() is
-    /// required to end slice - 1 and start slice 0 before the first cycle of code is executed.
-    void Initialize();
+struct EventType;
 
-    /// Tears down all timing related functionality.
-    void Shutdown();
+using TimedCallback = std::function<void(u64 userdata, int cycles_late)>;
 
-    /// Registers a core timing event with the given name and callback.
-    ///
-    /// @param name     The name of the core timing event to register.
-    /// @param callback The callback to execute for the event.
-    ///
-    /// @returns An EventType instance representing the registered event.
-    ///
-    /// @pre The name of the event being registered must be unique among all
-    ///      registered events.
-    ///
-    EventType* RegisterEvent(const std::string& name, TimedCallback callback);
+/**
+ * CoreTiming begins at the boundary of timing slice -1. An initial call to Advance() is
+ * required to end slice -1 and start slice 0 before the first cycle of code is executed.
+ */
+void Init();
+void Shutdown();
 
-    /// Unregisters all registered events thus far.
-    void UnregisterAllEvents();
+/**
+ * This should only be called from the emu thread, if you are calling it any other thread, you are
+ * doing something evil
+ */
+u64 GetTicks();
+u64 GetIdleTicks();
+void AddTicks(u64 ticks);
 
-    /// After the first Advance, the slice lengths and the downcount will be reduced whenever an
-    /// event is scheduled earlier than the current values.
-    ///
-    /// Scheduling from a callback will not update the downcount until the Advance() completes.
-    void ScheduleEvent(s64 cycles_into_future, const EventType* event_type, u64 userdata = 0);
+/**
+ * Returns the event_type identifier. if name is not unique, it will assert.
+ */
+EventType* RegisterEvent(const std::string& name, TimedCallback callback);
+void UnregisterAllEvents();
 
-    /// This is to be called when outside of hle threads, such as the graphics thread, wants to
-    /// schedule things to be executed on the main thread.
-    ///
-    /// @note This doesn't change slice_length and thus events scheduled by this might be
-    /// called with a delay of up to MAX_SLICE_LENGTH
-    void ScheduleEventThreadsafe(s64 cycles_into_future, const EventType* event_type,
-                                 u64 userdata = 0);
+/**
+ * After the first Advance, the slice lengths and the downcount will be reduced whenever an event
+ * is scheduled earlier than the current values.
+ * Scheduling from a callback will not update the downcount until the Advance() completes.
+ */
+void ScheduleEvent(s64 cycles_into_future, const EventType* event_type, u64 userdata = 0);
 
-    void UnscheduleEvent(const EventType* event_type, u64 userdata);
-    void UnscheduleEventThreadsafe(const EventType* event_type, u64 userdata);
+/**
+ * This is to be called when outside of hle threads, such as the graphics thread, wants to
+ * schedule things to be executed on the main thread.
+ * Not that this doesn't change slice_length and thus events scheduled by this might be called
+ * with a delay of up to MAX_SLICE_LENGTH
+ */
+void ScheduleEventThreadsafe(s64 cycles_into_future, const EventType* event_type, u64 userdata);
 
-    /// We only permit one event of each type in the queue at a time.
-    void RemoveEvent(const EventType* event_type);
-    void RemoveNormalAndThreadsafeEvent(const EventType* event_type);
+void UnscheduleEvent(const EventType* event_type, u64 userdata);
+void UnscheduleEventThreadsafe(const EventType* event_type, u64 userdata);
 
-    void ForceExceptionCheck(s64 cycles);
+/// We only permit one event of each type in the queue at a time.
+void RemoveEvent(const EventType* event_type);
+void RemoveNormalAndThreadsafeEvent(const EventType* event_type);
 
-    /// This should only be called from the emu thread, if you are calling it any other thread,
-    /// you are doing something evil
-    u64 GetTicks() const;
+/** Advance must be called at the beginning of dispatcher loops, not the end. Advance() ends
+ * the previous timing slice and begins the next one, you must Advance from the previous
+ * slice to the current one before executing any cycles. CoreTiming starts in slice -1 so an
+ * Advance() is required to initialize the slice length before the first cycle of emulated
+ * instructions is executed.
+ */
+void Advance();
+void MoveEvents();
 
-    u64 GetIdleTicks() const;
+/// Pretend that the main CPU has executed enough cycles to reach the next event.
+void Idle();
 
-    void AddTicks(u64 ticks);
+/// Clear all pending events. This should ONLY be done on exit.
+void ClearPendingEvents();
 
-    /// Advance must be called at the beginning of dispatcher loops, not the end. Advance() ends
-    /// the previous timing slice and begins the next one, you must Advance from the previous
-    /// slice to the current one before executing any cycles. CoreTiming starts in slice -1 so an
-    /// Advance() is required to initialize the slice length before the first cycle of emulated
-    /// instructions is executed.
-    void Advance();
+void ForceExceptionCheck(s64 cycles);
 
-    /// Pretend that the main CPU has executed enough cycles to reach the next event.
-    void Idle();
+std::chrono::microseconds GetGlobalTimeUs();
 
-    std::chrono::microseconds GetGlobalTimeUs() const;
+int GetDowncount();
 
-    int GetDowncount() const;
-
-private:
-    struct Event;
-
-    /// Clear all pending events. This should ONLY be done on exit.
-    void ClearPendingEvents();
-    void MoveEvents();
-
-    s64 global_timer = 0;
-    s64 idled_cycles = 0;
-    int slice_length = 0;
-    int downcount = 0;
-
-    // Are we in a function that has been called from Advance()
-    // If events are scheduled from a function that gets called from Advance(),
-    // don't change slice_length and downcount.
-    bool is_global_timer_sane = false;
-
-    // The queue is a min-heap using std::make_heap/push_heap/pop_heap.
-    // We don't use std::priority_queue because we need to be able to serialize, unserialize and
-    // erase arbitrary events (RemoveEvent()) regardless of the queue order. These aren't
-    // accomodated by the standard adaptor class.
-    std::vector<Event> event_queue;
-    u64 event_fifo_id = 0;
-
-    // Stores each element separately as a linked list node so pointers to elements
-    // remain stable regardless of rehashes/resizing.
-    std::unordered_map<std::string, EventType> event_types;
-
-    // The queue for storing the events from other threads threadsafe until they will be added
-    // to the event_queue by the emu thread
-    Common::MPSCQueue<Event> ts_queue;
-
-    // The queue for unscheduling the events from other threads threadsafe
-    Common::MPSCQueue<std::pair<const EventType*, u64>> unschedule_queue;
-
-    EventType* ev_lost = nullptr;
-};
-
-} // namespace Core::Timing
+} // namespace CoreTiming

src/core/core_timing_util.cpp

@@ -7,9 +7,8 @@
 #include <cinttypes>
 #include <limits>
 #include "common/logging/log.h"
-#include "common/uint128.h"
 
-namespace Core::Timing {
+namespace CoreTiming {
 
 constexpr u64 MAX_VALUE_TO_MULTIPLY = std::numeric_limits<s64>::max() / BASE_CLOCK_RATE;
 
@@ -61,9 +60,4 @@ s64 nsToCycles(u64 ns) {
     return (BASE_CLOCK_RATE * static_cast<s64>(ns)) / 1000000000;
 }
 
-u64 CpuCyclesToClockCycles(u64 ticks) {
-    const u128 temporal = Common::Multiply64Into128(ticks, CNTFREQ);
-    return Common::Divide128On32(temporal, static_cast<u32>(BASE_CLOCK_RATE)).first;
-}
-
-} // namespace Core::Timing
+} // namespace CoreTiming

src/core/core_timing_util.h

@@ -6,12 +6,11 @@
 
 #include "common/common_types.h"
 
-namespace Core::Timing {
+namespace CoreTiming {
 
 // The below clock rate is based on Switch's clockspeed being widely known as 1.020GHz
 // The exact value used is of course unverified.
 constexpr u64 BASE_CLOCK_RATE = 1019215872; // Switch clock speed is 1020MHz un/docked
-constexpr u64 CNTFREQ = 19200000;           // Value from fusee.
 
 inline s64 msToCycles(int ms) {
     // since ms is int there is no way to overflow
@@ -62,6 +61,4 @@ inline u64 cyclesToMs(s64 cycles) {
     return cycles * 1000 / BASE_CLOCK_RATE;
 }
 
-u64 CpuCyclesToClockCycles(u64 ticks);
-
-} // namespace Core::Timing
+} // namespace CoreTiming

src/core/cpu_core_manager.cpp

@@ -27,7 +27,7 @@ void CpuCoreManager::Initialize(System& system) {
     exclusive_monitor = Cpu::MakeExclusiveMonitor(cores.size());
 
     for (std::size_t index = 0; index < cores.size(); ++index) {
-        cores[index] = std::make_unique<Cpu>(system, *exclusive_monitor, *barrier, index);
+        cores[index] = std::make_unique<Cpu>(*exclusive_monitor, *barrier, index);
     }
 
     // Create threads for CPU cores 1-3, and build thread_to_cpu map

src/core/crypto/key_manager.cpp

@@ -246,6 +246,7 @@ std::vector<TicketRaw> GetTicketblob(const FileUtil::IOFile& ticket_save) {
     }
 
     std::vector<TicketRaw> out;
+    u32 magic{};
     for (std::size_t offset = 0; offset + 0x4 < buffer.size(); ++offset) {
         if (buffer[offset] == 0x4 && buffer[offset + 1] == 0x0 && buffer[offset + 2] == 0x1 &&
             buffer[offset + 3] == 0x0) {
@@ -398,8 +399,7 @@ static bool ValidCryptoRevisionString(std::string_view base, size_t begin, size_
 }
 
 void KeyManager::LoadFromFile(const std::string& filename, bool is_title_keys) {
-    std::ifstream file;
-    OpenFStream(file, filename, std::ios_base::in);
+    std::ifstream file(filename);
     if (!file.is_open())
         return;
 
@@ -794,7 +794,7 @@ void KeyManager::DeriveBase() {
 
 void KeyManager::DeriveETicket(PartitionDataManager& data) {
     // ETicket keys
-    const auto es = Service::FileSystem::GetUnionContents().GetEntry(
+    const auto es = Service::FileSystem::GetUnionContents()->GetEntry(
         0x0100000000000033, FileSys::ContentRecordType::Program);
 
     if (es == nullptr)

src/core/file_sys/content_archive.cpp

@@ -359,8 +359,6 @@ bool NCA::ReadPFS0Section(const NCASectionHeader& section, const NCASectionTable
             dirs.push_back(std::move(npfs));
             if (IsDirectoryExeFS(dirs.back()))
                 exefs = dirs.back();
-            else if (IsDirectoryLogoPartition(dirs.back()))
-                logo = dirs.back();
         } else {
             if (has_rights_id)
                 status = Loader::ResultStatus::ErrorIncorrectTitlekeyOrTitlekek;
@@ -548,8 +546,4 @@ u64 NCA::GetBaseIVFCOffset() const {
     return ivfc_offset;
 }
 
-VirtualDir NCA::GetLogoPartition() const {
-    return logo;
-}
-
 } // namespace FileSys

src/core/file_sys/content_archive.h

@@ -74,13 +74,6 @@ inline bool IsDirectoryExeFS(const std::shared_ptr<VfsDirectory>& pfs) {
     return pfs->GetFile("main") != nullptr && pfs->GetFile("main.npdm") != nullptr;
 }
 
-inline bool IsDirectoryLogoPartition(const VirtualDir& pfs) {
-    // NintendoLogo is the static image in the top left corner while StartupMovie is the animation
-    // in the bottom right corner.
-    return pfs->GetFile("NintendoLogo.png") != nullptr &&
-           pfs->GetFile("StartupMovie.gif") != nullptr;
-}
-
 // An implementation of VfsDirectory that represents a Nintendo Content Archive (NCA) conatiner.
 // After construction, use GetStatus to determine if the file is valid and ready to be used.
 class NCA : public ReadOnlyVfsDirectory {
@@ -109,8 +102,6 @@ public:
     // Returns the base ivfc offset used in BKTR patching.
     u64 GetBaseIVFCOffset() const;
 
-    VirtualDir GetLogoPartition() const;
-
 private:
     bool CheckSupportedNCA(const NCAHeader& header);
     bool HandlePotentialHeaderDecryption();
@@ -131,7 +122,6 @@ private:
 
     VirtualFile romfs = nullptr;
     VirtualDir exefs = nullptr;
-    VirtualDir logo = nullptr;
     VirtualFile file;
     VirtualFile bktr_base_romfs;
     u64 ivfc_offset = 0;

src/core/file_sys/control_metadata.cpp

@@ -36,20 +36,18 @@ std::string LanguageEntry::GetDeveloperName() const {
                                                        developer_name.size());
 }
 
-NACP::NACP() = default;
-
-NACP::NACP(VirtualFile file) {
-    file->ReadObject(&raw);
+NACP::NACP(VirtualFile file) : raw(std::make_unique<RawNACP>()) {
+    file->ReadObject(raw.get());
 }
 
 NACP::~NACP() = default;
 
 const LanguageEntry& NACP::GetLanguageEntry(Language language) const {
     if (language != Language::Default) {
-        return raw.language_entries.at(static_cast<u8>(language));
+        return raw->language_entries.at(static_cast<u8>(language));
     }
 
-    for (const auto& language_entry : raw.language_entries) {
+    for (const auto& language_entry : raw->language_entries) {
         if (!language_entry.GetApplicationName().empty())
             return language_entry;
     }
@@ -67,29 +65,21 @@ std::string NACP::GetDeveloperName(Language language) const {
 }
 
 u64 NACP::GetTitleId() const {
-    return raw.title_id;
+    return raw->title_id;
 }
 
 u64 NACP::GetDLCBaseTitleId() const {
-    return raw.dlc_base_title_id;
+    return raw->dlc_base_title_id;
 }
 
 std::string NACP::GetVersionString() const {
-    return Common::StringFromFixedZeroTerminatedBuffer(raw.version_string.data(),
-                                                       raw.version_string.size());
-}
-
-u64 NACP::GetDefaultNormalSaveSize() const {
-    return raw.normal_save_data_size;
-}
-
-u64 NACP::GetDefaultJournalSaveSize() const {
-    return raw.journal_sava_data_size;
+    return Common::StringFromFixedZeroTerminatedBuffer(raw->version_string.data(),
+                                                       raw->version_string.size());
 }
 
 std::vector<u8> NACP::GetRawBytes() const {
     std::vector<u8> out(sizeof(RawNACP));
-    std::memcpy(out.data(), &raw, sizeof(RawNACP));
+    std::memcpy(out.data(), raw.get(), sizeof(RawNACP));
     return out;
 }
 } // namespace FileSys

src/core/file_sys/control_metadata.h

@@ -28,30 +28,17 @@ static_assert(sizeof(LanguageEntry) == 0x300, "LanguageEntry has incorrect size.
 // The raw file format of a NACP file.
 struct RawNACP {
     std::array<LanguageEntry, 16> language_entries;
-    std::array<u8, 0x25> isbn;
-    u8 startup_user_account;
-    INSERT_PADDING_BYTES(2);
-    u32_le application_attribute;
-    u32_le supported_languages;
-    u32_le parental_control;
-    bool screenshot_enabled;
-    u8 video_capture_mode;
-    bool data_loss_confirmation;
-    INSERT_PADDING_BYTES(1);
+    INSERT_PADDING_BYTES(0x38);
     u64_le title_id;
-    std::array<u8, 0x20> rating_age;
+    INSERT_PADDING_BYTES(0x20);
     std::array<char, 0x10> version_string;
     u64_le dlc_base_title_id;
     u64_le title_id_2;
-    u64_le normal_save_data_size;
-    u64_le journal_sava_data_size;
-    INSERT_PADDING_BYTES(0x18);
+    INSERT_PADDING_BYTES(0x28);
     u64_le product_code;
-    std::array<u64_le, 0x8> local_communication;
-    u8 logo_type;
-    u8 logo_handling;
-    bool runtime_add_on_content_install;
-    INSERT_PADDING_BYTES(5);
+    u64_le title_id_3;
+    std::array<u64_le, 0x7> title_id_array;
+    INSERT_PADDING_BYTES(0x8);
     u64_le title_id_update;
     std::array<u8, 0x40> bcat_passphrase;
     INSERT_PADDING_BYTES(0xEC0);
@@ -85,7 +72,6 @@ extern const std::array<const char*, 15> LANGUAGE_NAMES;
 // These store application name, dev name, title id, and other miscellaneous data.
 class NACP {
 public:
-    explicit NACP();
     explicit NACP(VirtualFile file);
     ~NACP();
 
@@ -95,12 +81,10 @@ public:
     u64 GetTitleId() const;
     u64 GetDLCBaseTitleId() const;
     std::string GetVersionString() const;
-    u64 GetDefaultNormalSaveSize() const;
-    u64 GetDefaultJournalSaveSize() const;
     std::vector<u8> GetRawBytes() const;
 
 private:
-    RawNACP raw{};
+    std::unique_ptr<RawNACP> raw;
 };
 
 } // namespace FileSys

src/core/file_sys/directory.h

@@ -29,8 +29,8 @@ struct Entry {
         filename[copy_size] = '\0';
     }
 
-    char filename[0x301];
-    INSERT_PADDING_BYTES(3);
+    char filename[0x300];
+    INSERT_PADDING_BYTES(4);
     EntryType type;
     INSERT_PADDING_BYTES(3);
     u64 file_size;
@@ -39,4 +39,27 @@ static_assert(sizeof(Entry) == 0x310, "Directory Entry struct isn't exactly 0x31
 static_assert(offsetof(Entry, type) == 0x304, "Wrong offset for type in Entry.");
 static_assert(offsetof(Entry, file_size) == 0x308, "Wrong offset for file_size in Entry.");
 
+class DirectoryBackend : NonCopyable {
+public:
+    DirectoryBackend() {}
+    virtual ~DirectoryBackend() {}
+
+    /**
+     * List files contained in the directory
+     * @param count Number of entries to return at once in entries
+     * @param entries Buffer to read data into
+     * @return Number of entries listed
+     */
+    virtual u64 Read(const u64 count, Entry* entries) = 0;
+
+    /// Returns the number of entries still left to read.
+    virtual u64 GetEntryCount() const = 0;
+
+    /**
+     * Close the directory
+     * @return true if the directory closed correctly
+     */
+    virtual bool Close() const = 0;
+};
+
 } // namespace FileSys

src/core/file_sys/patch_manager.cpp

@@ -56,10 +56,6 @@ PatchManager::PatchManager(u64 title_id) : title_id(title_id) {}
 
 PatchManager::~PatchManager() = default;
 
-u64 PatchManager::GetTitleID() const {
-    return title_id;
-}
-
 VirtualDir PatchManager::PatchExeFS(VirtualDir exefs) const {
     LOG_INFO(Loader, "Patching ExeFS for title_id={:016X}", title_id);
 
@@ -77,18 +73,14 @@ VirtualDir PatchManager::PatchExeFS(VirtualDir exefs) const {
 
     const auto installed = Service::FileSystem::GetUnionContents();
 
-    const auto& disabled = Settings::values.disabled_addons[title_id];
-    const auto update_disabled =
-        std::find(disabled.begin(), disabled.end(), "Update") != disabled.end();
-
     // Game Updates
     const auto update_tid = GetUpdateTitleID(title_id);
-    const auto update = installed.GetEntry(update_tid, ContentRecordType::Program);
+    const auto update = installed->GetEntry(update_tid, ContentRecordType::Program);
 
-    if (!update_disabled && update != nullptr && update->GetExeFS() != nullptr &&
+    if (update != nullptr && update->GetExeFS() != nullptr &&
         update->GetStatus() == Loader::ResultStatus::ErrorMissingBKTRBaseRomFS) {
         LOG_INFO(Loader, "    ExeFS: Update ({}) applied successfully",
-                 FormatTitleVersion(installed.GetEntryVersion(update_tid).value_or(0)));
+                 FormatTitleVersion(installed->GetEntryVersion(update_tid).value_or(0)));
         exefs = update->GetExeFS();
     }
 
@@ -103,9 +95,6 @@ VirtualDir PatchManager::PatchExeFS(VirtualDir exefs) const {
         std::vector<VirtualDir> layers;
         layers.reserve(patch_dirs.size() + 1);
         for (const auto& subdir : patch_dirs) {
-            if (std::find(disabled.begin(), disabled.end(), subdir->GetName()) != disabled.end())
-                continue;
-
             auto exefs_dir = subdir->GetSubdirectory("exefs");
             if (exefs_dir != nullptr)
                 layers.push_back(std::move(exefs_dir));
@@ -122,16 +111,11 @@ VirtualDir PatchManager::PatchExeFS(VirtualDir exefs) const {
     return exefs;
 }
 
-std::vector<VirtualFile> PatchManager::CollectPatches(const std::vector<VirtualDir>& patch_dirs,
-                                                      const std::string& build_id) const {
-    const auto& disabled = Settings::values.disabled_addons[title_id];
-
+static std::vector<VirtualFile> CollectPatches(const std::vector<VirtualDir>& patch_dirs,
+                                               const std::string& build_id) {
     std::vector<VirtualFile> out;
     out.reserve(patch_dirs.size());
     for (const auto& subdir : patch_dirs) {
-        if (std::find(disabled.begin(), disabled.end(), subdir->GetName()) != disabled.end())
-            continue;
-
         auto exefs_dir = subdir->GetSubdirectory("exefs");
         if (exefs_dir != nullptr) {
             for (const auto& file : exefs_dir->GetFiles()) {
@@ -244,7 +228,6 @@ static void ApplyLayeredFS(VirtualFile& romfs, u64 title_id, ContentRecordType t
         return;
     }
 
-    const auto& disabled = Settings::values.disabled_addons[title_id];
     auto patch_dirs = load_dir->GetSubdirectories();
     std::sort(patch_dirs.begin(), patch_dirs.end(),
               [](const VirtualDir& l, const VirtualDir& r) { return l->GetName() < r->GetName(); });
@@ -254,9 +237,6 @@ static void ApplyLayeredFS(VirtualFile& romfs, u64 title_id, ContentRecordType t
     layers.reserve(patch_dirs.size() + 1);
     layers_ext.reserve(patch_dirs.size() + 1);
     for (const auto& subdir : patch_dirs) {
-        if (std::find(disabled.begin(), disabled.end(), subdir->GetName()) != disabled.end())
-            continue;
-
         auto romfs_dir = subdir->GetSubdirectory("romfs");
         if (romfs_dir != nullptr)
             layers.push_back(std::move(romfs_dir));
@@ -286,12 +266,13 @@ static void ApplyLayeredFS(VirtualFile& romfs, u64 title_id, ContentRecordType t
 VirtualFile PatchManager::PatchRomFS(VirtualFile romfs, u64 ivfc_offset, ContentRecordType type,
                                      VirtualFile update_raw) const {
     const auto log_string = fmt::format("Patching RomFS for title_id={:016X}, type={:02X}",
-                                        title_id, static_cast<u8>(type));
+                                        title_id, static_cast<u8>(type))
+                                .c_str();
 
     if (type == ContentRecordType::Program || type == ContentRecordType::Data)
-        LOG_INFO(Loader, "{}", log_string);
+        LOG_INFO(Loader, log_string);
     else
-        LOG_DEBUG(Loader, "{}", log_string);
+        LOG_DEBUG(Loader, log_string);
 
     if (romfs == nullptr)
         return romfs;
@@ -300,21 +281,16 @@ VirtualFile PatchManager::PatchRomFS(VirtualFile romfs, u64 ivfc_offset, Content
 
     // Game Updates
     const auto update_tid = GetUpdateTitleID(title_id);
-    const auto update = installed.GetEntryRaw(update_tid, type);
-
-    const auto& disabled = Settings::values.disabled_addons[title_id];
-    const auto update_disabled =
-        std::find(disabled.begin(), disabled.end(), "Update") != disabled.end();
-
-    if (!update_disabled && update != nullptr) {
+    const auto update = installed->GetEntryRaw(update_tid, type);
+    if (update != nullptr) {
         const auto new_nca = std::make_shared<NCA>(update, romfs, ivfc_offset);
         if (new_nca->GetStatus() == Loader::ResultStatus::Success &&
             new_nca->GetRomFS() != nullptr) {
             LOG_INFO(Loader, "    RomFS: Update ({}) applied successfully",
-                     FormatTitleVersion(installed.GetEntryVersion(update_tid).value_or(0)));
+                     FormatTitleVersion(installed->GetEntryVersion(update_tid).value_or(0)));
             romfs = new_nca->GetRomFS();
         }
-    } else if (!update_disabled && update_raw != nullptr) {
+    } else if (update_raw != nullptr) {
         const auto new_nca = std::make_shared<NCA>(update_raw, romfs, ivfc_offset);
         if (new_nca->GetStatus() == Loader::ResultStatus::Success &&
             new_nca->GetRomFS() != nullptr) {
@@ -344,30 +320,25 @@ std::map<std::string, std::string, std::less<>> PatchManager::GetPatchVersionNam
     VirtualFile update_raw) const {
     std::map<std::string, std::string, std::less<>> out;
     const auto installed = Service::FileSystem::GetUnionContents();
-    const auto& disabled = Settings::values.disabled_addons[title_id];
 
     // Game Updates
     const auto update_tid = GetUpdateTitleID(title_id);
     PatchManager update{update_tid};
     auto [nacp, discard_icon_file] = update.GetControlMetadata();
 
-    const auto update_disabled =
-        std::find(disabled.begin(), disabled.end(), "Update") != disabled.end();
-    const auto update_label = update_disabled ? "[D] Update" : "Update";
-
     if (nacp != nullptr) {
-        out.insert_or_assign(update_label, nacp->GetVersionString());
+        out.insert_or_assign("Update", nacp->GetVersionString());
     } else {
-        if (installed.HasEntry(update_tid, ContentRecordType::Program)) {
-            const auto meta_ver = installed.GetEntryVersion(update_tid);
+        if (installed->HasEntry(update_tid, ContentRecordType::Program)) {
+            const auto meta_ver = installed->GetEntryVersion(update_tid);
             if (meta_ver.value_or(0) == 0) {
-                out.insert_or_assign(update_label, "");
+                out.insert_or_assign("Update", "");
             } else {
                 out.insert_or_assign(
-                    update_label, FormatTitleVersion(*meta_ver, TitleVersionFormat::ThreeElements));
+                    "Update", FormatTitleVersion(*meta_ver, TitleVersionFormat::ThreeElements));
             }
         } else if (update_raw != nullptr) {
-            out.insert_or_assign(update_label, "PACKED");
+            out.insert_or_assign("Update", "PACKED");
         }
     }
 
@@ -407,20 +378,19 @@ std::map<std::string, std::string, std::less<>> PatchManager::GetPatchVersionNam
             if (types.empty())
                 continue;
 
-            const auto mod_disabled =
-                std::find(disabled.begin(), disabled.end(), mod->GetName()) != disabled.end();
-            out.insert_or_assign(mod_disabled ? "[D] " + mod->GetName() : mod->GetName(), types);
+            out.insert_or_assign(mod->GetName(), types);
         }
     }
 
     // DLC
-    const auto dlc_entries = installed.ListEntriesFilter(TitleType::AOC, ContentRecordType::Data);
+    const auto dlc_entries = installed->ListEntriesFilter(TitleType::AOC, ContentRecordType::Data);
     std::vector<RegisteredCacheEntry> dlc_match;
     dlc_match.reserve(dlc_entries.size());
     std::copy_if(dlc_entries.begin(), dlc_entries.end(), std::back_inserter(dlc_match),
                  [this, &installed](const RegisteredCacheEntry& entry) {
                      return (entry.title_id & DLC_BASE_TITLE_ID_MASK) == title_id &&
-                            installed.GetEntry(entry)->GetStatus() == Loader::ResultStatus::Success;
+                            installed->GetEntry(entry)->GetStatus() ==
+                                Loader::ResultStatus::Success;
                  });
     if (!dlc_match.empty()) {
         // Ensure sorted so DLC IDs show in order.
@@ -432,9 +402,7 @@ std::map<std::string, std::string, std::less<>> PatchManager::GetPatchVersionNam
 
         list += fmt::format("{}", dlc_match.back().title_id & 0x7FF);
 
-        const auto dlc_disabled =
-            std::find(disabled.begin(), disabled.end(), "DLC") != disabled.end();
-        out.insert_or_assign(dlc_disabled ? "[D] DLC" : "DLC", std::move(list));
+        out.insert_or_assign("DLC", std::move(list));
     }
 
     return out;
@@ -443,7 +411,7 @@ std::map<std::string, std::string, std::less<>> PatchManager::GetPatchVersionNam
 std::pair<std::unique_ptr<NACP>, VirtualFile> PatchManager::GetControlMetadata() const {
     const auto installed{Service::FileSystem::GetUnionContents()};
 
-    const auto base_control_nca = installed.GetEntry(title_id, ContentRecordType::Control);
+    const auto base_control_nca = installed->GetEntry(title_id, ContentRecordType::Control);
     if (base_control_nca == nullptr)
         return {};
 

src/core/file_sys/patch_manager.h

@@ -30,8 +30,6 @@ public:
     explicit PatchManager(u64 title_id);
     ~PatchManager();
 
-    u64 GetTitleID() const;
-
     // Currently tracked ExeFS patches:
     // - Game Updates
     VirtualDir PatchExeFS(VirtualDir exefs) const;
@@ -65,9 +63,6 @@ public:
     std::pair<std::unique_ptr<NACP>, VirtualFile> ParseControlNCA(const NCA& nca) const;
 
 private:
-    std::vector<VirtualFile> CollectPatches(const std::vector<VirtualDir>& patch_dirs,
-                                            const std::string& build_id) const;
-
     u64 title_id;
 };
 

src/core/file_sys/program_metadata.cpp

@@ -40,13 +40,6 @@ Loader::ResultStatus ProgramMetadata::Load(VirtualFile file) {
     if (sizeof(FileAccessHeader) != file->ReadObject(&aci_file_access, aci_header.fah_offset))
         return Loader::ResultStatus::ErrorBadFileAccessHeader;
 
-    aci_kernel_capabilities.resize(aci_header.kac_size / sizeof(u32));
-    const u64 read_size = aci_header.kac_size;
-    const u64 read_offset = npdm_header.aci_offset + aci_header.kac_offset;
-    if (file->ReadBytes(aci_kernel_capabilities.data(), read_size, read_offset) != read_size) {
-        return Loader::ResultStatus::ErrorBadKernelCapabilityDescriptors;
-    }
-
     return Loader::ResultStatus::Success;
 }
 
@@ -78,10 +71,6 @@ u64 ProgramMetadata::GetFilesystemPermissions() const {
     return aci_file_access.permissions;
 }
 
-const ProgramMetadata::KernelCapabilityDescriptors& ProgramMetadata::GetKernelCapabilities() const {
-    return aci_kernel_capabilities;
-}
-
 void ProgramMetadata::Print() const {
     LOG_DEBUG(Service_FS, "Magic:                  {:.4}", npdm_header.magic.data());
     LOG_DEBUG(Service_FS, "Main thread priority:   0x{:02X}", npdm_header.main_thread_priority);
@@ -92,19 +81,15 @@ void ProgramMetadata::Print() const {
     LOG_DEBUG(Service_FS, " > 64-bit instructions: {}",
               npdm_header.has_64_bit_instructions ? "YES" : "NO");
 
-    const char* address_space = "Unknown";
+    auto address_space = "Unknown";
     switch (npdm_header.address_space_type) {
     case ProgramAddressSpaceType::Is36Bit:
-        address_space = "64-bit (36-bit address space)";
-        break;
     case ProgramAddressSpaceType::Is39Bit:
-        address_space = "64-bit (39-bit address space)";
+        address_space = "64-bit";
         break;
     case ProgramAddressSpaceType::Is32Bit:
-        address_space = "32-bit";
-        break;
     case ProgramAddressSpaceType::Is32BitNoMap:
-        address_space = "32-bit (no map region)";
+        address_space = "32-bit";
         break;
     }
 

src/core/file_sys/program_metadata.h

@@ -5,7 +5,6 @@
 #pragma once
 
 #include <array>
-#include <vector>
 #include "common/bit_field.h"
 #include "common/common_types.h"
 #include "common/swap.h"
@@ -39,8 +38,6 @@ enum class ProgramFilePermission : u64 {
  */
 class ProgramMetadata {
 public:
-    using KernelCapabilityDescriptors = std::vector<u32>;
-
     ProgramMetadata();
     ~ProgramMetadata();
 
@@ -53,7 +50,6 @@ public:
     u32 GetMainThreadStackSize() const;
     u64 GetTitleID() const;
     u64 GetFilesystemPermissions() const;
-    const KernelCapabilityDescriptors& GetKernelCapabilities() const;
 
     void Print() const;
 
@@ -158,8 +154,6 @@ private:
 
     FileAccessControl acid_file_access;
     FileAccessHeader aci_file_access;
-
-    KernelCapabilityDescriptors aci_kernel_capabilities;
 };
 
 } // namespace FileSys

src/core/file_sys/registered_cache.cpp

@@ -107,41 +107,42 @@ static ContentRecordType GetCRTypeFromNCAType(NCAContentType type) {
 VirtualFile RegisteredCache::OpenFileOrDirectoryConcat(const VirtualDir& dir,
                                                        std::string_view path) const {
     const auto file = dir->GetFileRelative(path);
-    if (file != nullptr) {
+    if (file != nullptr)
         return file;
-    }
 
     const auto nca_dir = dir->GetDirectoryRelative(path);
-    if (nca_dir == nullptr) {
-        return nullptr;
-    }
+    if (nca_dir != nullptr) {
+        const auto nca_dir = dir->GetDirectoryRelative(path);
+        VirtualFile file = nullptr;
 
-    const auto files = nca_dir->GetFiles();
-    if (files.size() == 1 && files[0]->GetName() == "00") {
-        return files[0];
-    }
-
-    std::vector<VirtualFile> concat;
-    // Since the files are a two-digit hex number, max is FF.
-    for (std::size_t i = 0; i < 0x100; ++i) {
-        auto next = nca_dir->GetFile(fmt::format("{:02X}", i));
-        if (next != nullptr) {
-            concat.push_back(std::move(next));
+        const auto files = nca_dir->GetFiles();
+        if (files.size() == 1 && files[0]->GetName() == "00") {
+            file = files[0];
         } else {
-            next = nca_dir->GetFile(fmt::format("{:02x}", i));
-            if (next != nullptr) {
-                concat.push_back(std::move(next));
-            } else {
-                break;
+            std::vector<VirtualFile> concat;
+            // Since the files are a two-digit hex number, max is FF.
+            for (std::size_t i = 0; i < 0x100; ++i) {
+                auto next = nca_dir->GetFile(fmt::format("{:02X}", i));
+                if (next != nullptr) {
+                    concat.push_back(std::move(next));
+                } else {
+                    next = nca_dir->GetFile(fmt::format("{:02x}", i));
+                    if (next != nullptr)
+                        concat.push_back(std::move(next));
+                    else
+                        break;
+                }
             }
+
+            if (concat.empty())
+                return nullptr;
+
+            file = ConcatenatedVfsFile::MakeConcatenatedFile(concat, concat.front()->GetName());
         }
-    }
 
-    if (concat.empty()) {
-        return nullptr;
+        return file;
     }
-
-    return ConcatenatedVfsFile::MakeConcatenatedFile(concat, concat.front()->GetName());
+    return nullptr;
 }
 
 VirtualFile RegisteredCache::GetFileAtID(NcaID id) const {

src/core/file_sys/romfs.cpp

@@ -119,9 +119,6 @@ VirtualDir ExtractRomFS(VirtualFile file, RomFSExtractionType type) {
 
     VirtualDir out = std::move(root);
 
-    if (type == RomFSExtractionType::SingleDiscard)
-        return out->GetSubdirectories().front();
-
     while (out->GetSubdirectories().size() == 1 && out->GetFiles().empty()) {
         if (out->GetSubdirectories().front()->GetName() == "data" &&
             type == RomFSExtractionType::Truncated)

src/core/file_sys/romfs.h

@@ -33,9 +33,8 @@ struct IVFCHeader {
 static_assert(sizeof(IVFCHeader) == 0xE0, "IVFCHeader has incorrect size.");
 
 enum class RomFSExtractionType {
-    Full,          // Includes data directory
-    Truncated,     // Traverses into data directory
-    SingleDiscard, // Traverses into the first subdirectory of root
+    Full,      // Includes data directory
+    Truncated, // Traverses into data directory
 };
 
 // Converts a RomFS binary blob to VFS Filesystem

src/core/file_sys/romfs_factory.cpp

@@ -48,7 +48,7 @@ ResultVal<VirtualFile> RomFSFactory::Open(u64 title_id, StorageId storage, Conte
 
     switch (storage) {
     case StorageId::None:
-        res = Service::FileSystem::GetUnionContents().GetEntry(title_id, type);
+        res = Service::FileSystem::GetUnionContents()->GetEntry(title_id, type);
         break;
     case StorageId::NandSystem:
         res = Service::FileSystem::GetSystemNANDContents()->GetEntry(title_id, type);

src/core/file_sys/savedata_factory.cpp

@@ -13,18 +13,12 @@
 
 namespace FileSys {
 
-constexpr char SAVE_DATA_SIZE_FILENAME[] = ".yuzu_save_size";
-
 std::string SaveDataDescriptor::DebugInfo() const {
     return fmt::format("[type={:02X}, title_id={:016X}, user_id={:016X}{:016X}, save_id={:016X}]",
                        static_cast<u8>(type), title_id, user_id[1], user_id[0], save_id);
 }
 
-SaveDataFactory::SaveDataFactory(VirtualDir save_directory) : dir(std::move(save_directory)) {
-    // Delete all temporary storages
-    // On hardware, it is expected that temporary storage be empty at first use.
-    dir->DeleteSubdirectoryRecursive("temp");
-}
+SaveDataFactory::SaveDataFactory(VirtualDir save_directory) : dir(std::move(save_directory)) {}
 
 SaveDataFactory::~SaveDataFactory() = default;
 
@@ -126,40 +120,9 @@ std::string SaveDataFactory::GetFullPath(SaveDataSpaceId space, SaveDataType typ
     case SaveDataType::TemporaryStorage:
         return fmt::format("{}{:016X}/{:016X}{:016X}/{:016X}", out, 0, user_id[1], user_id[0],
                            title_id);
-    case SaveDataType::CacheStorage:
-        return fmt::format("{}save/cache/{:016X}", out, title_id);
     default:
         ASSERT_MSG(false, "Unrecognized SaveDataType: {:02X}", static_cast<u8>(type));
-        return fmt::format("{}save/unknown_{:X}/{:016X}", out, static_cast<u8>(type), title_id);
     }
 }
 
-SaveDataSize SaveDataFactory::ReadSaveDataSize(SaveDataType type, u64 title_id,
-                                               u128 user_id) const {
-    const auto path = GetFullPath(SaveDataSpaceId::NandUser, type, title_id, user_id, 0);
-    const auto dir = GetOrCreateDirectoryRelative(this->dir, path);
-
-    const auto size_file = dir->GetFile(SAVE_DATA_SIZE_FILENAME);
-    if (size_file == nullptr || size_file->GetSize() < sizeof(SaveDataSize))
-        return {0, 0};
-
-    SaveDataSize out;
-    if (size_file->ReadObject(&out) != sizeof(SaveDataSize))
-        return {0, 0};
-    return out;
-}
-
-void SaveDataFactory::WriteSaveDataSize(SaveDataType type, u64 title_id, u128 user_id,
-                                        SaveDataSize new_value) {
-    const auto path = GetFullPath(SaveDataSpaceId::NandUser, type, title_id, user_id, 0);
-    const auto dir = GetOrCreateDirectoryRelative(this->dir, path);
-
-    const auto size_file = dir->CreateFile(SAVE_DATA_SIZE_FILENAME);
-    if (size_file == nullptr)
-        return;
-
-    size_file->Resize(sizeof(SaveDataSize));
-    size_file->WriteObject(new_value);
-}
-
 } // namespace FileSys

src/core/file_sys/savedata_factory.h

@@ -17,10 +17,8 @@ namespace FileSys {
 enum class SaveDataSpaceId : u8 {
     NandSystem = 0,
     NandUser = 1,
-    SdCardSystem = 2,
+    SdCard = 2,
     TemporaryStorage = 3,
-    SdCardUser = 4,
-    ProperSystem = 100,
 };
 
 enum class SaveDataType : u8 {
@@ -46,11 +44,6 @@ struct SaveDataDescriptor {
 };
 static_assert(sizeof(SaveDataDescriptor) == 0x40, "SaveDataDescriptor has incorrect size.");
 
-struct SaveDataSize {
-    u64 normal;
-    u64 journal;
-};
-
 /// File system interface to the SaveData archive
 class SaveDataFactory {
 public:
@@ -65,9 +58,6 @@ public:
     static std::string GetFullPath(SaveDataSpaceId space, SaveDataType type, u64 title_id,
                                    u128 user_id, u64 save_id);
 
-    SaveDataSize ReadSaveDataSize(SaveDataType type, u64 title_id, u128 user_id) const;
-    void WriteSaveDataSize(SaveDataType type, u64 title_id, u128 user_id, SaveDataSize new_value);
-
 private:
     VirtualDir dir;
 };

src/core/file_sys/system_archive/ng_word.cpp

@@ -1,81 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include <fmt/format.h>
-#include "common/common_types.h"
-#include "core/file_sys/system_archive/ng_word.h"
-#include "core/file_sys/vfs_vector.h"
-
-namespace FileSys::SystemArchive {
-
-namespace NgWord1Data {
-
-constexpr std::size_t NUMBER_WORD_TXT_FILES = 0x10;
-
-// Should this archive replacement mysteriously not work on a future game, consider updating.
-constexpr std::array<u8, 4> VERSION_DAT{0x0, 0x0, 0x0, 0x19}; // 5.1.0 System Version
-
-constexpr std::array<u8, 30> WORD_TXT{
-    0xFE, 0xFF, 0x00, 0x5E, 0x00, 0x76, 0x00, 0x65, 0x00, 0x72, 0x00, 0x79, 0x00, 0x62, 0x00,
-    0x61, 0x00, 0x64, 0x00, 0x77, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x64, 0x00, 0x24, 0x00, 0x0A,
-}; // "^verybadword$" in UTF-16
-
-} // namespace NgWord1Data
-
-VirtualDir NgWord1() {
-    std::vector<VirtualFile> files(NgWord1Data::NUMBER_WORD_TXT_FILES);
-
-    for (std::size_t i = 0; i < files.size(); ++i) {
-        files[i] = std::make_shared<ArrayVfsFile<NgWord1Data::WORD_TXT.size()>>(
-            NgWord1Data::WORD_TXT, fmt::format("{}.txt", i));
-    }
-
-    files.push_back(std::make_shared<ArrayVfsFile<NgWord1Data::WORD_TXT.size()>>(
-        NgWord1Data::WORD_TXT, "common.txt"));
-    files.push_back(std::make_shared<ArrayVfsFile<NgWord1Data::VERSION_DAT.size()>>(
-        NgWord1Data::VERSION_DAT, "version.dat"));
-
-    return std::make_shared<VectorVfsDirectory>(files, std::vector<VirtualDir>{}, "data");
-}
-
-namespace NgWord2Data {
-
-constexpr std::size_t NUMBER_AC_NX_FILES = 0x10;
-
-// Should this archive replacement mysteriously not work on a future game, consider updating.
-constexpr std::array<u8, 4> VERSION_DAT{0x0, 0x0, 0x0, 0x15}; // 5.1.0 System Version
-
-constexpr std::array<u8, 0x2C> AC_NX_DATA{
-    0x1F, 0x8B, 0x08, 0x08, 0xD5, 0x2C, 0x09, 0x5C, 0x04, 0x00, 0x61, 0x63, 0x72, 0x61, 0x77,
-    0x00, 0xED, 0xC1, 0x01, 0x0D, 0x00, 0x00, 0x00, 0xC2, 0x20, 0xFB, 0xA7, 0xB6, 0xC7, 0x07,
-    0x0C, 0x00, 0x00, 0x00, 0xC8, 0x3B, 0x11, 0x00, 0x1C, 0xC7, 0x00, 0x10, 0x00, 0x00,
-}; // Deserializes to no bad words
-
-} // namespace NgWord2Data
-
-VirtualDir NgWord2() {
-    std::vector<VirtualFile> files(NgWord2Data::NUMBER_AC_NX_FILES * 3);
-
-    for (std::size_t i = 0; i < NgWord2Data::NUMBER_AC_NX_FILES; ++i) {
-        files[3 * i] = std::make_shared<ArrayVfsFile<NgWord2Data::AC_NX_DATA.size()>>(
-            NgWord2Data::AC_NX_DATA, fmt::format("ac_{}_b1_nx", i));
-        files[3 * i + 1] = std::make_shared<ArrayVfsFile<NgWord2Data::AC_NX_DATA.size()>>(
-            NgWord2Data::AC_NX_DATA, fmt::format("ac_{}_b2_nx", i));
-        files[3 * i + 2] = std::make_shared<ArrayVfsFile<NgWord2Data::AC_NX_DATA.size()>>(
-            NgWord2Data::AC_NX_DATA, fmt::format("ac_{}_not_b_nx", i));
-    }
-
-    files.push_back(std::make_shared<ArrayVfsFile<NgWord2Data::AC_NX_DATA.size()>>(
-        NgWord2Data::AC_NX_DATA, "ac_common_b1_nx"));
-    files.push_back(std::make_shared<ArrayVfsFile<NgWord2Data::AC_NX_DATA.size()>>(
-        NgWord2Data::AC_NX_DATA, "ac_common_b2_nx"));
-    files.push_back(std::make_shared<ArrayVfsFile<NgWord2Data::AC_NX_DATA.size()>>(
-        NgWord2Data::AC_NX_DATA, "ac_common_not_b_nx"));
-    files.push_back(std::make_shared<ArrayVfsFile<NgWord2Data::VERSION_DAT.size()>>(
-        NgWord2Data::VERSION_DAT, "version.dat"));
-
-    return std::make_shared<VectorVfsDirectory>(files, std::vector<VirtualDir>{}, "data");
-}
-
-} // namespace FileSys::SystemArchive

src/core/file_sys/system_archive/ng_word.h

@@ -1,14 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include "core/file_sys/vfs_types.h"
-
-namespace FileSys::SystemArchive {
-
-VirtualDir NgWord1();
-VirtualDir NgWord2();
-
-} // namespace FileSys::SystemArchive

src/core/file_sys/system_archive/system_archive.cpp

@@ -1,90 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include "common/logging/log.h"
-#include "core/file_sys/romfs.h"
-#include "core/file_sys/system_archive/ng_word.h"
-#include "core/file_sys/system_archive/system_archive.h"
-
-namespace FileSys::SystemArchive {
-
-constexpr u64 SYSTEM_ARCHIVE_BASE_TITLE_ID = 0x0100000000000800;
-constexpr std::size_t SYSTEM_ARCHIVE_COUNT = 0x28;
-
-using SystemArchiveSupplier = VirtualDir (*)();
-
-struct SystemArchiveDescriptor {
-    u64 title_id;
-    const char* name;
-    SystemArchiveSupplier supplier;
-};
-
-constexpr std::array<SystemArchiveDescriptor, SYSTEM_ARCHIVE_COUNT> SYSTEM_ARCHIVES{{
-    {0x0100000000000800, "CertStore", nullptr},
-    {0x0100000000000801, "ErrorMessage", nullptr},
-    {0x0100000000000802, "MiiModel", nullptr},
-    {0x0100000000000803, "BrowserDll", nullptr},
-    {0x0100000000000804, "Help", nullptr},
-    {0x0100000000000805, "SharedFont", nullptr},
-    {0x0100000000000806, "NgWord", &NgWord1},
-    {0x0100000000000807, "SsidList", nullptr},
-    {0x0100000000000808, "Dictionary", nullptr},
-    {0x0100000000000809, "SystemVersion", nullptr},
-    {0x010000000000080A, "AvatarImage", nullptr},
-    {0x010000000000080B, "LocalNews", nullptr},
-    {0x010000000000080C, "Eula", nullptr},
-    {0x010000000000080D, "UrlBlackList", nullptr},
-    {0x010000000000080E, "TimeZoneBinary", nullptr},
-    {0x010000000000080F, "CertStoreCruiser", nullptr},
-    {0x0100000000000810, "FontNintendoExtension", nullptr},
-    {0x0100000000000811, "FontStandard", nullptr},
-    {0x0100000000000812, "FontKorean", nullptr},
-    {0x0100000000000813, "FontChineseTraditional", nullptr},
-    {0x0100000000000814, "FontChineseSimple", nullptr},
-    {0x0100000000000815, "FontBfcpx", nullptr},
-    {0x0100000000000816, "SystemUpdate", nullptr},
-    {0x0100000000000817, "0100000000000817", nullptr},
-    {0x0100000000000818, "FirmwareDebugSettings", nullptr},
-    {0x0100000000000819, "BootImagePackage", nullptr},
-    {0x010000000000081A, "BootImagePackageSafe", nullptr},
-    {0x010000000000081B, "BootImagePackageExFat", nullptr},
-    {0x010000000000081C, "BootImagePackageExFatSafe", nullptr},
-    {0x010000000000081D, "FatalMessage", nullptr},
-    {0x010000000000081E, "ControllerIcon", nullptr},
-    {0x010000000000081F, "PlatformConfigIcosa", nullptr},
-    {0x0100000000000820, "PlatformConfigCopper", nullptr},
-    {0x0100000000000821, "PlatformConfigHoag", nullptr},
-    {0x0100000000000822, "ControllerFirmware", nullptr},
-    {0x0100000000000823, "NgWord2", &NgWord2},
-    {0x0100000000000824, "PlatformConfigIcosaMariko", nullptr},
-    {0x0100000000000825, "ApplicationBlackList", nullptr},
-    {0x0100000000000826, "RebootlessSystemUpdateVersion", nullptr},
-    {0x0100000000000827, "ContentActionTable", nullptr},
-}};
-
-VirtualFile SynthesizeSystemArchive(const u64 title_id) {
-    if (title_id < SYSTEM_ARCHIVES.front().title_id || title_id > SYSTEM_ARCHIVES.back().title_id)
-        return nullptr;
-
-    const auto& desc = SYSTEM_ARCHIVES[title_id - SYSTEM_ARCHIVE_BASE_TITLE_ID];
-
-    LOG_INFO(Service_FS, "Synthesizing system archive '{}' (0x{:016X}).", desc.name, desc.title_id);
-
-    if (desc.supplier == nullptr)
-        return nullptr;
-
-    const auto dir = desc.supplier();
-
-    if (dir == nullptr)
-        return nullptr;
-
-    const auto romfs = CreateRomFS(dir);
-
-    if (romfs == nullptr)
-        return nullptr;
-
-    LOG_INFO(Service_FS, "    - System archive generation successful!");
-    return romfs;
-}
-} // namespace FileSys::SystemArchive

src/core/file_sys/system_archive/system_archive.h

@@ -1,14 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include "common/common_types.h"
-#include "core/file_sys/vfs_types.h"
-
-namespace FileSys::SystemArchive {
-
-VirtualFile SynthesizeSystemArchive(u64 title_id);
-
-} // namespace FileSys::SystemArchive

src/core/file_sys/vfs.cpp

@@ -384,28 +384,6 @@ bool VfsDirectory::DeleteSubdirectoryRecursive(std::string_view name) {
     return success;
 }
 
-bool VfsDirectory::CleanSubdirectoryRecursive(std::string_view name) {
-    auto dir = GetSubdirectory(name);
-    if (dir == nullptr) {
-        return false;
-    }
-
-    bool success = true;
-    for (const auto& file : dir->GetFiles()) {
-        if (!dir->DeleteFile(file->GetName())) {
-            success = false;
-        }
-    }
-
-    for (const auto& sdir : dir->GetSubdirectories()) {
-        if (!dir->DeleteSubdirectoryRecursive(sdir->GetName())) {
-            success = false;
-        }
-    }
-
-    return success;
-}
-
 bool VfsDirectory::Copy(std::string_view src, std::string_view dest) {
     const auto f1 = GetFile(src);
     auto f2 = CreateFile(dest);
@@ -453,34 +431,10 @@ std::shared_ptr<VfsFile> ReadOnlyVfsDirectory::CreateFile(std::string_view name)
     return nullptr;
 }
 
-std::shared_ptr<VfsFile> ReadOnlyVfsDirectory::CreateFileAbsolute(std::string_view path) {
-    return nullptr;
-}
-
-std::shared_ptr<VfsFile> ReadOnlyVfsDirectory::CreateFileRelative(std::string_view path) {
-    return nullptr;
-}
-
-std::shared_ptr<VfsDirectory> ReadOnlyVfsDirectory::CreateDirectoryAbsolute(std::string_view path) {
-    return nullptr;
-}
-
-std::shared_ptr<VfsDirectory> ReadOnlyVfsDirectory::CreateDirectoryRelative(std::string_view path) {
-    return nullptr;
-}
-
 bool ReadOnlyVfsDirectory::DeleteSubdirectory(std::string_view name) {
     return false;
 }
 
-bool ReadOnlyVfsDirectory::DeleteSubdirectoryRecursive(std::string_view name) {
-    return false;
-}
-
-bool ReadOnlyVfsDirectory::CleanSubdirectoryRecursive(std::string_view name) {
-    return false;
-}
-
 bool ReadOnlyVfsDirectory::DeleteFile(std::string_view name) {
     return false;
 }

src/core/file_sys/vfs.h

@@ -150,7 +150,7 @@ public:
     template <typename T>
     std::size_t WriteArray(const T* data, std::size_t number_elements, std::size_t offset = 0) {
         static_assert(std::is_trivially_copyable_v<T>, "Data type must be trivially copyable.");
-        return Write(reinterpret_cast<const u8*>(data), number_elements * sizeof(T), offset);
+        return Write(data, number_elements * sizeof(T), offset);
     }
 
     // Writes size bytes starting at memory location data to offset in file.
@@ -166,7 +166,7 @@ public:
     template <typename T>
     std::size_t WriteObject(const T& data, std::size_t offset = 0) {
         static_assert(std::is_trivially_copyable_v<T>, "Data type must be trivially copyable.");
-        return Write(reinterpret_cast<const u8*>(&data), sizeof(T), offset);
+        return Write(&data, sizeof(T), offset);
     }
 
     // Renames the file to name. Returns whether or not the operation was successsful.
@@ -245,18 +245,12 @@ public:
     // any failure.
     virtual std::shared_ptr<VfsDirectory> CreateDirectoryAbsolute(std::string_view path);
 
-    // Deletes the subdirectory with the given name and returns true on success.
+    // Deletes the subdirectory with name and returns true on success.
     virtual bool DeleteSubdirectory(std::string_view name) = 0;
-
-    // Deletes all subdirectories and files within the provided directory and then deletes
-    // the directory itself. Returns true on success.
+    // Deletes all subdirectories and files of subdirectory with name recirsively and then deletes
+    // the subdirectory. Returns true on success.
     virtual bool DeleteSubdirectoryRecursive(std::string_view name);
-
-    // Deletes all subdirectories and files within the provided directory.
-    // Unlike DeleteSubdirectoryRecursive, this does not delete the provided directory.
-    virtual bool CleanSubdirectoryRecursive(std::string_view name);
-
-    // Returns whether or not the file with name name was deleted successfully.
+    // Returnes whether or not the file with name name was deleted successfully.
     virtual bool DeleteFile(std::string_view name) = 0;
 
     // Returns whether or not this directory was renamed to name.
@@ -282,13 +276,7 @@ public:
     bool IsReadable() const override;
     std::shared_ptr<VfsDirectory> CreateSubdirectory(std::string_view name) override;
     std::shared_ptr<VfsFile> CreateFile(std::string_view name) override;
-    std::shared_ptr<VfsFile> CreateFileAbsolute(std::string_view path) override;
-    std::shared_ptr<VfsFile> CreateFileRelative(std::string_view path) override;
-    std::shared_ptr<VfsDirectory> CreateDirectoryAbsolute(std::string_view path) override;
-    std::shared_ptr<VfsDirectory> CreateDirectoryRelative(std::string_view path) override;
     bool DeleteSubdirectory(std::string_view name) override;
-    bool DeleteSubdirectoryRecursive(std::string_view name) override;
-    bool CleanSubdirectoryRecursive(std::string_view name) override;
     bool DeleteFile(std::string_view name) override;
     bool Rename(std::string_view name) override;
 };

src/core/file_sys/vfs_vector.cpp

@@ -3,6 +3,7 @@
 // Refer to the license.txt file included.
 
 #include <algorithm>
+#include <cstring>
 #include <utility>
 #include "core/file_sys/vfs_vector.h"
 
@@ -47,7 +48,7 @@ std::size_t VectorVfsFile::Write(const u8* data_, std::size_t length, std::size_
     if (offset + length > data.size())
         data.resize(offset + length);
     const auto write = std::min(length, data.size() - offset);
-    std::memcpy(data.data() + offset, data_, write);
+    std::memcpy(data.data(), data_, write);
     return write;
 }
 

src/core/file_sys/vfs_vector.h

@@ -4,63 +4,10 @@
 
 #pragma once
 
-#include <cstring>
 #include "core/file_sys/vfs.h"
 
 namespace FileSys {
 
-// An implementation of VfsFile that is backed by a statically-sized array
-template <std::size_t size>
-class ArrayVfsFile : public VfsFile {
-public:
-    ArrayVfsFile(std::array<u8, size> data, std::string name = "", VirtualDir parent = nullptr)
-        : data(data), name(std::move(name)), parent(std::move(parent)) {}
-
-    std::string GetName() const override {
-        return name;
-    }
-
-    std::size_t GetSize() const override {
-        return size;
-    }
-
-    bool Resize(std::size_t new_size) override {
-        return false;
-    }
-
-    std::shared_ptr<VfsDirectory> GetContainingDirectory() const override {
-        return parent;
-    }
-
-    bool IsWritable() const override {
-        return false;
-    }
-
-    bool IsReadable() const override {
-        return true;
-    }
-
-    std::size_t Read(u8* data_, std::size_t length, std::size_t offset) const override {
-        const auto read = std::min(length, size - offset);
-        std::memcpy(data_, data.data() + offset, read);
-        return read;
-    }
-
-    std::size_t Write(const u8* data, std::size_t length, std::size_t offset) override {
-        return 0;
-    }
-
-    bool Rename(std::string_view name) override {
-        this->name = name;
-        return true;
-    }
-
-private:
-    std::array<u8, size> data;
-    std::string name;
-    VirtualDir parent;
-};
-
 // An implementation of VfsFile that is backed by a vector optionally supplied upon construction
 class VectorVfsFile : public VfsFile {
 public:

src/core/frontend/applets/profile_select.cpp

@@ -1,19 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include "core/frontend/applets/profile_select.h"
-#include "core/settings.h"
-
-namespace Core::Frontend {
-
-ProfileSelectApplet::~ProfileSelectApplet() = default;
-
-void DefaultProfileSelectApplet::SelectProfile(
-    std::function<void(std::optional<Service::Account::UUID>)> callback) const {
-    Service::Account::ProfileManager manager;
-    callback(manager.GetUser(Settings::values.current_user).value_or(Service::Account::UUID{}));
-    LOG_INFO(Service_ACC, "called, selecting current user instead of prompting...");
-}
-
-} // namespace Core::Frontend

src/core/frontend/applets/profile_select.h

@@ -1,27 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <functional>
-#include <optional>
-#include "core/hle/service/acc/profile_manager.h"
-
-namespace Core::Frontend {
-
-class ProfileSelectApplet {
-public:
-    virtual ~ProfileSelectApplet();
-
-    virtual void SelectProfile(
-        std::function<void(std::optional<Service::Account::UUID>)> callback) const = 0;
-};
-
-class DefaultProfileSelectApplet final : public ProfileSelectApplet {
-public:
-    void SelectProfile(
-        std::function<void(std::optional<Service::Account::UUID>)> callback) const override;
-};
-
-} // namespace Core::Frontend

src/core/frontend/applets/web_browser.cpp

@@ -1,24 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include "common/logging/log.h"
-#include "core/frontend/applets/web_browser.h"
-
-namespace Core::Frontend {
-
-WebBrowserApplet::~WebBrowserApplet() = default;
-
-DefaultWebBrowserApplet::~DefaultWebBrowserApplet() = default;
-
-void DefaultWebBrowserApplet::OpenPage(std::string_view filename,
-                                       std::function<void()> unpack_romfs_callback,
-                                       std::function<void()> finished_callback) {
-    LOG_INFO(Service_AM,
-             "(STUBBED) called - No suitable web browser implementation found to open website page "
-             "at '{}'!",
-             filename);
-    finished_callback();
-}
-
-} // namespace Core::Frontend

src/core/frontend/applets/web_browser.h

@@ -1,28 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <functional>
-#include <string_view>
-
-namespace Core::Frontend {
-
-class WebBrowserApplet {
-public:
-    virtual ~WebBrowserApplet();
-
-    virtual void OpenPage(std::string_view url, std::function<void()> unpack_romfs_callback,
-                          std::function<void()> finished_callback) = 0;
-};
-
-class DefaultWebBrowserApplet final : public WebBrowserApplet {
-public:
-    ~DefaultWebBrowserApplet() override;
-
-    void OpenPage(std::string_view url, std::function<void()> unpack_romfs_callback,
-                  std::function<void()> finished_callback) override;
-};
-
-} // namespace Core::Frontend

src/core/frontend/emu_window.cpp

@@ -67,7 +67,7 @@ static bool IsWithinTouchscreen(const Layout::FramebufferLayout& layout, unsigne
             framebuffer_x >= layout.screen.left && framebuffer_x < layout.screen.right);
 }
 
-std::tuple<unsigned, unsigned> EmuWindow::ClipToTouchScreen(unsigned new_x, unsigned new_y) const {
+std::tuple<unsigned, unsigned> EmuWindow::ClipToTouchScreen(unsigned new_x, unsigned new_y) {
     new_x = std::max(new_x, framebuffer_layout.screen.left);
     new_x = std::min(new_x, framebuffer_layout.screen.right - 1);
 

src/core/frontend/emu_window.h

@@ -52,6 +52,12 @@ public:
     /// Releases (dunno if this is the "right" word) the GLFW context from the caller thread
     virtual void DoneCurrent() = 0;
 
+    /// Returns if window is shown (not minimized)
+    virtual bool IsShown() const = 0;
+
+    /// Retrieves Vulkan specific handlers from the window
+    virtual void RetrieveVulkanHandlers(void** instance, void** surface) const = 0;
+
     /**
      * Signal that a touch pressed event has occurred (e.g. mouse click pressed)
      * @param framebuffer_x Framebuffer x-coordinate that was pressed
@@ -166,7 +172,7 @@ private:
     /**
      * Clip the provided coordinates to be inside the touchscreen area.
      */
-    std::tuple<unsigned, unsigned> ClipToTouchScreen(unsigned new_x, unsigned new_y) const;
+    std::tuple<unsigned, unsigned> ClipToTouchScreen(unsigned new_x, unsigned new_y);
 };
 
 } // namespace Core::Frontend

src/core/frontend/framebuffer_layout.cpp

@@ -6,18 +6,17 @@
 
 #include "common/assert.h"
 #include "core/frontend/framebuffer_layout.h"
-#include "core/settings.h"
 
 namespace Layout {
 
 // Finds the largest size subrectangle contained in window area that is confined to the aspect ratio
 template <class T>
-static Common::Rectangle<T> MaxRectangle(Common::Rectangle<T> window_area,
-                                         float screen_aspect_ratio) {
+static MathUtil::Rectangle<T> maxRectangle(MathUtil::Rectangle<T> window_area,
+                                           float screen_aspect_ratio) {
     float scale = std::min(static_cast<float>(window_area.GetWidth()),
                            window_area.GetHeight() / screen_aspect_ratio);
-    return Common::Rectangle<T>{0, 0, static_cast<T>(std::round(scale)),
-                                static_cast<T>(std::round(scale * screen_aspect_ratio))};
+    return MathUtil::Rectangle<T>{0, 0, static_cast<T>(std::round(scale)),
+                                  static_cast<T>(std::round(scale * screen_aspect_ratio))};
 }
 
 FramebufferLayout DefaultFrameLayout(unsigned width, unsigned height) {
@@ -29,8 +28,8 @@ FramebufferLayout DefaultFrameLayout(unsigned width, unsigned height) {
 
     const float emulation_aspect_ratio{static_cast<float>(ScreenUndocked::Height) /
                                        ScreenUndocked::Width};
-    Common::Rectangle<unsigned> screen_window_area{0, 0, width, height};
-    Common::Rectangle<unsigned> screen = MaxRectangle(screen_window_area, emulation_aspect_ratio);
+    MathUtil::Rectangle<unsigned> screen_window_area{0, 0, width, height};
+    MathUtil::Rectangle<unsigned> screen = maxRectangle(screen_window_area, emulation_aspect_ratio);
 
     float window_aspect_ratio = static_cast<float>(height) / width;
 
@@ -43,18 +42,4 @@ FramebufferLayout DefaultFrameLayout(unsigned width, unsigned height) {
     return res;
 }
 
-FramebufferLayout FrameLayoutFromResolutionScale(u16 res_scale) {
-    int width, height;
-
-    if (Settings::values.use_docked_mode) {
-        width = ScreenDocked::WidthDocked * res_scale;
-        height = ScreenDocked::HeightDocked * res_scale;
-    } else {
-        width = ScreenUndocked::Width * res_scale;
-        height = ScreenUndocked::Height * res_scale;
-    }
-
-    return DefaultFrameLayout(width, height);
-}
-
 } // namespace Layout

src/core/frontend/framebuffer_layout.h

@@ -9,14 +9,13 @@
 namespace Layout {
 
 enum ScreenUndocked : unsigned { Width = 1280, Height = 720 };
-enum ScreenDocked : unsigned { WidthDocked = 1920, HeightDocked = 1080 };
 
 /// Describes the layout of the window framebuffer
 struct FramebufferLayout {
     unsigned width{ScreenUndocked::Width};
     unsigned height{ScreenUndocked::Height};
 
-    Common::Rectangle<unsigned> screen;
+    MathUtil::Rectangle<unsigned> screen;
 
     /**
      * Returns the ration of pixel size of the screen, compared to the native size of the undocked
@@ -35,10 +34,4 @@ struct FramebufferLayout {
  */
 FramebufferLayout DefaultFrameLayout(unsigned width, unsigned height);
 
-/**
- * Convenience method to get frame layout by resolution scale
- * @param res_scale resolution scale factor
- */
-FramebufferLayout FrameLayoutFromResolutionScale(u16 res_scale);
-
 } // namespace Layout