GitHub/skyline
2
0
Fork 0
mirror of https://github.com/skyline-emu/skyline.git synced 2024-12-28 09:45:28 +03:00
Code Issues Packages Projects Releases Wiki Activity
81eb8fd231
skyline/app/CMakeLists.txt

407 lines
22 KiB
CMake
Raw Normal View History

Update NDK, Gradle and dependencies + Improve Settings API + Migrate to PugiXML
2021-01-22 06:02:01 +03:00
cmake_minimum_required(VERSION 3.16)
Use libcxx from LLVM Project submodule The version of libcxx shipped with Android NDK is fairly outdated and doesn't contain several features we desire such as C++ 20 ranges. This has been fixed by using libcxx directly from the LLVM Project which has been added as a submodule and can be updated independently of NDK.
2021-10-31 00:43:41 +03:00
project(Skyline LANGUAGES C CXX ASM VERSION 0.3)
Structure Code and Link libunicorn
2019-06-29 16:35:24 +03:00
Update NDK, Gradle and dependencies + Improve Settings API + Migrate to PugiXML
2021-01-22 06:02:01 +03:00
set(BUILD_TESTS OFF CACHE BOOL "Build Tests" FORCE)
set(BUILD_TESTING OFF CACHE BOOL "Build Testing" FORCE)
Fix occurrence of multiple headers in game list + Make TinyXML2 Static This commit mainly fixes multiple headers in the game list, which was caused by using the wrong variable for the recursive function. In addition, it makes TinyXML2 statically linked to libskyline which makes it the lone shared objects present in APKs.
2020-03-29 22:07:11 +03:00
set(BUILD_SHARED_LIBS OFF CACHE BOOL "Build Shared Libraries" FORCE)
Update NDK, Gradle and dependencies + Improve Settings API + Migrate to PugiXML
2021-01-22 06:02:01 +03:00
set(CMAKE_CXX_STANDARD 20)
Rewrite C++ parts and UI update This update took way way too long to create. However, it was worthwhile. :)
2019-07-24 23:19:43 +03:00
set(CMAKE_CXX_STANDARD_REQUIRED TRUE)
Fix occurrence of multiple headers in game list + Make TinyXML2 Static This commit mainly fixes multiple headers in the game list, which was caused by using the wrong variable for the recursive function. In addition, it makes TinyXML2 statically linked to libskyline which makes it the lone shared objects present in APKs.
2020-03-29 22:07:11 +03:00
Framebuffer and NativeActivity What was added: * Framebuffer * NativeActivity * NV Services * IOCTL Handler * NV Devices: * * /dev/nvmap - 0xC0080101, 0xC0080103, 0xC0200104, 0xC0180105, 0xC00C0109, 0xC008010E * * /dev/nvhost-as-gpu * * /dev/nvhost-channel - 0x40044801, 0xC0104809, 0xC010480B, 0xC018480C, 0x4004480D, 0xC020481A, 0x40084714 * * /dev/nvhost-ctrl * * /dev/nvhost-ctrl-gpu - 0x80044701, 0x80284702, 0xC0184706, 0xC0B04705, 0x80084714 * SVCs: * * SetMemoryAttribute * * CreateTransferMemory * * ResetSignal * * GetSystemTick * Addition of Compact Logger What was fixed: * SVCs: * * SetHeapSize * * SetMemoryAttribute * * QueryMemory * A release build would not set CMAKE_BUILD_TYPE to "RELEASE" * The logger code was simplified
2019-11-13 23:09:31 +03:00
set(source_DIR ${CMAKE_SOURCE_DIR}/src/main/cpp)
Enable fwrapv for defined signed integer overflow behaviour Nintendo enables this for HOS so we should do the same to avoid any cases where it's relied on.
2022-07-29 21:48:39 +03:00
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fno-strict-aliasing -Wno-unused-command-line-argument -fwrapv")
Use libcxx from LLVM Project submodule The version of libcxx shipped with Android NDK is fairly outdated and doesn't contain several features we desire such as C++ 20 ranges. This has been fixed by using libcxx directly from the LLVM Project which has been added as a submodule and can be updated independently of NDK.
2021-10-31 00:43:41 +03:00
set(CMAKE_CXX_FLAGS_RELEASE "-Ofast -flto=full -fno-stack-protector -DNDEBUG")
Introduce a `releasedebug` build variant
2022-10-07 18:05:35 +03:00
# Build all libraries with -Ofast but with default debug data (-g) for debug and reldebug builds
Build libraries with `-Ofast` for debug builds To offset some of the performance overhead of using debug builds, we now optimize all libraries using `-Ofast` while building Skyline itself with `-O0`.
2021-10-31 00:46:21 +03:00
set(CMAKE_CXX_FLAGS_DEBUG "-Ofast")
Introduce a `releasedebug` build variant
2022-10-07 18:05:35 +03:00
set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "-Ofast")
Build libraries with `-Ofast` for debug builds To offset some of the performance overhead of using debug builds, we now optimize all libraries using `-Ofast` while building Skyline itself with `-O0`.
2021-10-31 00:46:21 +03:00
Use libcxx from LLVM Project submodule The version of libcxx shipped with Android NDK is fairly outdated and doesn't contain several features we desire such as C++ 20 ranges. This has been fixed by using libcxx directly from the LLVM Project which has been added as a submodule and can be updated independently of NDK.
2021-10-31 00:43:41 +03:00
# libcxx
set(ANDROID_STL "none")
set(LIBCXX_INCLUDE_TESTS OFF)
set(LIBCXX_INCLUDE_BENCHMARKS OFF)
set(LIBCXX_INCLUDE_DOCS OFF)
set(LIBCXX_ENABLE_SHARED FALSE)
set(LIBCXX_ENABLE_ASSERTIONS FALSE)
set(LIBCXX_STANDALONE_BUILD FALSE)
add_subdirectory("libraries/llvm/libcxx")
link_libraries(cxx_static)
get_target_property(LIBCXX_INCLUDE_COMPILE_OPTION cxx-headers INTERFACE_COMPILE_OPTIONS)
string(REGEX REPLACE "-I" "" LIBCXX_INCLUDE_DIRECTORY_LIST "${LIBCXX_INCLUDE_COMPILE_OPTION}")
list(GET LIBCXX_INCLUDE_DIRECTORY_LIST 1 LIBCXX_TARGET_INCLUDE_DIRECTORY) # We just want the target include directory
set_target_properties(cxx-headers PROPERTIES INTERFACE_COMPILE_OPTIONS -isystem${LIBCXX_TARGET_INCLUDE_DIRECTORY})
# libcxxabi
set(LIBCXXABI_INCLUDE_TESTS OFF)
set(LIBCXXABI_ENABLE_SHARED FALSE)
set(LIBCXXABI_STANDALONE_BUILD FALSE)
set(LIBCXXABI_LIBCXX_INCLUDES "${LIBCXX_TARGET_INCLUDE_DIRECTORY}" CACHE STRING "" FORCE)
add_subdirectory("libraries/llvm/libcxxabi")
link_libraries(cxxabi_static)
Framebuffer and NativeActivity What was added: * Framebuffer * NativeActivity * NV Services * IOCTL Handler * NV Devices: * * /dev/nvmap - 0xC0080101, 0xC0080103, 0xC0200104, 0xC0180105, 0xC00C0109, 0xC008010E * * /dev/nvhost-as-gpu * * /dev/nvhost-channel - 0x40044801, 0xC0104809, 0xC010480B, 0xC018480C, 0x4004480D, 0xC020481A, 0x40084714 * * /dev/nvhost-ctrl * * /dev/nvhost-ctrl-gpu - 0x80044701, 0x80284702, 0xC0184706, 0xC0B04705, 0x80084714 * SVCs: * * SetMemoryAttribute * * CreateTransferMemory * * ResetSignal * * GetSystemTick * Addition of Compact Logger What was fixed: * SVCs: * * SetHeapSize * * SetMemoryAttribute * * QueryMemory * A release build would not set CMAKE_BUILD_TYPE to "RELEASE" * The logger code was simplified
2019-11-13 23:09:31 +03:00
Swap out boostorg/boost for skyline-emu/boost
2022-04-04 15:56:06 +03:00
# Skyline's Boost fork
set(Boost_USE_STATIC_LIBS ON)
set(Boost_USE_MULTITHREADED ON)
add_subdirectory("libraries/boost")
Implement Fence Cycle, Memory Manager and Command Scheduler Implements a wrapper over fences to track a single cycle of activation, implement a Vulkan memory manager that wraps the Vulkan-Memory-Allocator library and a command scheduler for scheduling Vulkan command buffers
2021-05-22 19:31:22 +03:00
# {fmt}
Rewrite C++ parts and UI update This update took way way too long to create. However, it was worthwhile. :)
2019-07-24 23:19:43 +03:00
add_subdirectory("libraries/fmt")
Disable All Warnings from TZCode This just disables all compiler warnings generated while compiling TZCode as those are irrelevant while compiling Skyline and need to be tackled in that repository.
2021-03-21 18:04:59 +03:00
Implement Fence Cycle, Memory Manager and Command Scheduler Implements a wrapper over fences to track a single cycle of activation, implement a Vulkan memory manager that wraps the Vulkan-Memory-Allocator library and a command scheduler for scheduling Vulkan command buffers
2021-05-22 19:31:22 +03:00
# TzCode
Pull in tzcode submodule and add tzdata assets These are used for timezone conversions between POSIX and calander time. Tzdata is in exactly the same format as HOS to allow loading sysarchives in the future if needed. See its README for more info. Details on tzcode can be found in its own repo, there are several changes done Vs the base release to allow for HOS compat.
2021-03-03 23:40:16 +03:00
add_subdirectory("libraries/tzcode")
Disable All Warnings from TZCode This just disables all compiler warnings generated while compiling TZCode as those are irrelevant while compiling Skyline and need to be tackled in that repository.
2021-03-21 18:04:59 +03:00
target_compile_options(tzcode PRIVATE -Wno-everything)
Update NDK, Gradle and dependencies + Improve Settings API + Migrate to PugiXML
2021-01-22 06:02:01 +03:00
Implement Fence Cycle, Memory Manager and Command Scheduler Implements a wrapper over fences to track a single cycle of activation, implement a Vulkan memory manager that wraps the Vulkan-Memory-Allocator library and a command scheduler for scheduling Vulkan command buffers
2021-05-22 19:31:22 +03:00
# LZ4
Update NDK, Gradle and dependencies + Improve Settings API + Migrate to PugiXML
2021-01-22 06:02:01 +03:00
set(LZ4_BUILD_CLI OFF CACHE BOOL "Build LZ4 CLI" FORCE)
Replace skyline-emu/VkHpp with KhronosGroup/Vulkan-Hpp We used a custom version of Vulkan-Hpp which split the files a lot prior to avoid any developers needing to manually set IDE settings for IntelliJ to work but this wasn't practical due to how it required modifications to Vulkan-Hpp's generator which would make maintenance extremely difficult. It was determined that we should just add the requirement for changing the IDE settings and use Vulkan-Hpp directly.
2021-03-26 21:12:19 +03:00
set(LZ4_BUILD_LEGACY_LZ4C OFF CACHE BOOL "Build lz4c progam with legacy argument support" FORCE)
Update NDK, Gradle and dependencies + Improve Settings API + Migrate to PugiXML
2021-01-22 06:02:01 +03:00
add_subdirectory("libraries/lz4/build/cmake")
Silence errors from libraries Library headers would produce errors that are out of our control and as a result of that, we just want to ignore this. This is possible by including the offending headers as system headers, compilers don't emit any warnings arising from them. This was extended to all libraries rather than just those which currently emitted warnings for consistency's sake.
2021-10-26 16:35:16 +03:00
include_directories(SYSTEM "libraries/lz4/lib")
Update NDK, Gradle and dependencies + Improve Settings API + Migrate to PugiXML
2021-01-22 06:02:01 +03:00
Update NDK to 21.4.7075529
2021-04-03 23:58:49 +03:00
# Vulkan + Vulkan-Hpp
Vulkan PhysicalDevice + Device Initialization + Report Accurate Version Vulkan Device initialization is handled now, it supports required extensions but support for optional extensions/features/properties will come in later when we require those. In addition, we now correctly report the version of Skyline to Vulkan which can be accessed from debugging tools. There's also a minor change regarding the search pattern for `SkylineLibraries` which now only searches in headers of libraries and it also explicitly excludes the redundant `vulkan.hpp` from the `Vulkan-Headers` repository.
2021-03-28 17:35:13 +03:00
add_compile_definitions(VK_USE_PLATFORM_ANDROID_KHR) # We want all the Android-specific structures to be defined
Replace skyline-emu/VkHpp with KhronosGroup/Vulkan-Hpp We used a custom version of Vulkan-Hpp which split the files a lot prior to avoid any developers needing to manually set IDE settings for IntelliJ to work but this wasn't practical due to how it required modifications to Vulkan-Hpp's generator which would make maintenance extremely difficult. It was determined that we should just add the requirement for changing the IDE settings and use Vulkan-Hpp directly.
2021-03-26 21:12:19 +03:00
add_compile_definitions(VULKAN_HPP_NO_SPACESHIP_OPERATOR) # libcxx doesn't implement operator<=> for std::array which breaks this
add_compile_definitions(VULKAN_HPP_NO_STRUCT_CONSTRUCTORS) # We want to use designated initializers in Vulkan-Hpp
Disable unused Vulkan HPP setters and smart handles
2022-07-31 17:01:42 +03:00
add_compile_definitions(VULKAN_HPP_NO_SETTERS)
add_compile_definitions(VULKAN_HPP_NO_SMART_HANDLE)
Vulkan Instance + Validation Layer + Debug Report Initialization The GPU class has been extended in this for Vulkan initialization, this is done to the point of initializing the instance alongside loading in `VK_LAYER_KHRONOS_validation` which is also now packed into all Debug APKs for Skyline. In addition, `VK_EXT_debug_report` is also initialized and it's output is piped directly into the Logger. A minor change regarding the type of the `Fps` and `Frametime` globals was changed to `skyline::i32`s which is a more suitable type due to those having a smaller chance of overflowing while being signed as Java doesn't have unsigned integral types.
2021-03-28 00:17:35 +03:00
add_compile_definitions(VULKAN_HPP_DISPATCH_LOADER_DYNAMIC=1) # We use the dynamic loader rather than the static one to avoid an additional level of indirection
Add support for turnip and driver file redirection via libadrenotools
2021-12-09 02:10:54 +03:00
add_compile_definitions(VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL=0) # We disable the dynamic loader tool so we can supply our own getInstanceProcAddress function from a custom driver
Silence errors from libraries Library headers would produce errors that are out of our control and as a result of that, we just want to ignore this. This is possible by including the offending headers as system headers, compilers don't emit any warnings arising from them. This was extended to all libraries rather than just those which currently emitted warnings for consistency's sake.
2021-10-26 16:35:16 +03:00
include_directories(SYSTEM "libraries/vkhpp")
include_directories(SYSTEM "libraries/vkhpp/Vulkan-Headers/include") # We use base Vulkan headers from this to ensure version parity with Vulkan-Hpp
Replace skyline-emu/VkHpp with KhronosGroup/Vulkan-Hpp We used a custom version of Vulkan-Hpp which split the files a lot prior to avoid any developers needing to manually set IDE settings for IntelliJ to work but this wasn't practical due to how it required modifications to Vulkan-Hpp's generator which would make maintenance extremely difficult. It was determined that we should just add the requirement for changing the IDE settings and use Vulkan-Hpp directly.
2021-03-26 21:12:19 +03:00
Implement Fence Cycle, Memory Manager and Command Scheduler Implements a wrapper over fences to track a single cycle of activation, implement a Vulkan memory manager that wraps the Vulkan-Memory-Allocator library and a command scheduler for scheduling Vulkan command buffers
2021-05-22 19:31:22 +03:00
# Vulkan Memory Allocator
include_directories("libraries/vkma/include")
add_library(vkma STATIC libraries/vkma.cpp)
target_compile_options(vkma PRIVATE -Wno-everything)
# Frozen
Silence errors from libraries Library headers would produce errors that are out of our control and as a result of that, we just want to ignore this. This is possible by including the offending headers as system headers, compilers don't emit any warnings arising from them. This was extended to all libraries rather than just those which currently emitted warnings for consistency's sake.
2021-10-26 16:35:16 +03:00
include_directories(SYSTEM "libraries/frozen/include")
Rewrite C++ parts and UI update This update took way way too long to create. However, it was worthwhile. :)
2019-07-24 23:19:43 +03:00
Implement Fence Cycle, Memory Manager and Command Scheduler Implements a wrapper over fences to track a single cycle of activation, implement a Vulkan memory manager that wraps the Vulkan-Memory-Allocator library and a command scheduler for scheduling Vulkan command buffers
2021-05-22 19:31:22 +03:00
# MbedTLS
Move Mbed TLS to submodule + Update Java Libraries We've moved from using an AAR for Mbed TLS to a submodule as the AAR was packaged manually and used from a local repository which ended up being very hacky and resulted in Linter errors, it could also not be updated with ease as it would need to be repackaged. All of these issues have been solved by moving to a git submodule tied to the official Mbed TLS GitHub repository.
2021-07-11 21:17:59 +03:00
set(ENABLE_TESTING OFF CACHE BOOL "Build mbed TLS tests." FORCE)
set(ENABLE_PROGRAMS OFF CACHE BOOL "Build mbed TLS programs." FORCE)
set(UNSAFE_BUILD ON CACHE BOOL "Allow unsafe builds. These builds ARE NOT SECURE." FORCE)
add_subdirectory("libraries/mbedtls")
Silence errors from libraries Library headers would produce errors that are out of our control and as a result of that, we just want to ignore this. This is possible by including the offending headers as system headers, compilers don't emit any warnings arising from them. This was extended to all libraries rather than just those which currently emitted warnings for consistency's sake.
2021-10-26 16:35:16 +03:00
include_directories(SYSTEM "libraries/mbedtls/include")
Upgrade AGP to `7.1.0-beta01` & NDK to `24.0.7856742` We've moved to using a beta AGP as `7.0.2` is breaks `clangd` and other C++ features on Beta/Canary Android Studio. NDK was additionally updated with `mbedtls` to fix warnings caused by it alongside some other minor fixes to code for newer versions of libcxx. The new AGP has a bug where it does not look for executables specified in `android_gradle_build.json` in `PATH` that includes `ninja` which is provided by the `ninja-build` package on the system rather than Android SDK's CMake on GitHub Actions (Ubuntu 20.04). This has been fixed by symlinking `/usr/bin/ninja` to the project root which is searched in for the `ninja` executable.
2021-10-31 01:03:27 +03:00
target_compile_options(mbedcrypto PRIVATE -Wno-everything)
NCA decryption (#99) * NCA decryption * Remove unnecessary new lines * Remove loader error dialog * Always show ROMs * Address CRs * Add subtitle padding in grid mode
2020-09-14 16:53:40 +03:00
Add Opus submodule
2021-07-14 17:28:02 +03:00
# Opus
Use libcxx from LLVM Project submodule The version of libcxx shipped with Android NDK is fairly outdated and doesn't contain several features we desire such as C++ 20 ranges. This has been fixed by using libcxx directly from the LLVM Project which has been added as a submodule and can be updated independently of NDK.
2021-10-31 00:43:41 +03:00
set(OPUS_INSTALL_CMAKE_CONFIG_MODULE OFF CACHE BOOL "Install Opus CMake package config module" FORCE)
Silence errors from libraries Library headers would produce errors that are out of our control and as a result of that, we just want to ignore this. This is possible by including the offending headers as system headers, compilers don't emit any warnings arising from them. This was extended to all libraries rather than just those which currently emitted warnings for consistency's sake.
2021-10-26 16:35:16 +03:00
include_directories(SYSTEM "libraries/opus/include")
Add Opus submodule
2021-07-14 17:28:02 +03:00
add_subdirectory("libraries/opus")
Use libcxx from LLVM Project submodule The version of libcxx shipped with Android NDK is fairly outdated and doesn't contain several features we desire such as C++ 20 ranges. This has been fixed by using libcxx directly from the LLVM Project which has been added as a submodule and can be updated independently of NDK.
2021-10-31 00:43:41 +03:00
target_compile_definitions(opus PRIVATE OPUS_WILL_BE_SLOW=1) # libopus will warn when built without optimizations
Add Opus submodule
2021-07-14 17:28:02 +03:00
Reimplement audout and audren using yuzu audio_core The yuzu audio_core code is mostly untouched, with a set of wrappers used to bridge it with skyline kernel primitives. Huge thanks to maide and their advice, whom without this wouldn't have been possible.
2023-03-15 20:49:17 +03:00
# Cubeb
Use OpenSL over AAudio AAudio lacks support for multiple streams on some devices, whereas OpenSL doesn't.
2023-03-16 01:02:52 +03:00
set(USE_OPENSL ON)
Reimplement audout and audren using yuzu audio_core The yuzu audio_core code is mostly untouched, with a set of wrappers used to bridge it with skyline kernel primitives. Huge thanks to maide and their advice, whom without this wouldn't have been possible.
2023-03-15 20:49:17 +03:00
set(USE_SANITIZERS OFF)
Prevent aaudio backend usage
2023-03-28 00:14:53 +03:00
set(USE_LAZY_LOAD_LIBS OFF)
set(USE_AAUDIO OFF)
Reimplement audout and audren using yuzu audio_core The yuzu audio_core code is mostly untouched, with a set of wrappers used to bridge it with skyline kernel primitives. Huge thanks to maide and their advice, whom without this wouldn't have been possible.
2023-03-15 20:49:17 +03:00
set(BUNDLE_SPEEX ON)
add_subdirectory("libraries/cubeb")
include_directories(SYSTEM "libraries/cubeb/include")
Extend Perfetto Tracing Add Tracing for SVCs, Services, NVDRV, and Synchronization Primitives. In addition, fix `TRACE_EVENT_END("guest")` being emitted when a signal is received while being in the guest rather than host which would cause an exception. This commit also disables warnings for the Perfetto library as we do not control fixing them.
2021-03-20 19:52:08 +03:00
# Perfetto SDK
Silence errors from libraries Library headers would produce errors that are out of our control and as a result of that, we just want to ignore this. This is possible by including the offending headers as system headers, compilers don't emit any warnings arising from them. This was extended to all libraries rather than just those which currently emitted warnings for consistency's sake.
2021-10-26 16:35:16 +03:00
include_directories(SYSTEM "libraries/perfetto/sdk")
Implement Perfetto Tracing This commit implements tracing Skyline using https://perfetto.dev/ for SVCs, IPC, Scheduler and Presentation
2021-03-11 21:41:12 +03:00
add_library(perfetto STATIC libraries/perfetto/sdk/perfetto.cc)
Extend Perfetto Tracing Add Tracing for SVCs, Services, NVDRV, and Synchronization Primitives. In addition, fix `TRACE_EVENT_END("guest")` being emitted when a signal is received while being in the guest rather than host which would cause an exception. This commit also disables warnings for the Perfetto library as we do not control fixing them.
2021-03-20 19:52:08 +03:00
target_compile_options(perfetto PRIVATE -Wno-everything)
Implement Perfetto Tracing This commit implements tracing Skyline using https://perfetto.dev/ for SVCs, IPC, Scheduler and Presentation
2021-03-11 21:41:12 +03:00
Add Range v3 as a submodule We want to utilize features from C++ 20 ranges but they haven't been entirely implemented in libc++ so in the meantime we use the reference implementation for it which is Ranges v3.
2021-11-21 10:25:33 +03:00
# C++ Range v3
add_subdirectory("libraries/range")
Add Sirit as a submodule We require Sirit as it is a dependency for yuzu's shader compiler where it uses it to emit SPIR-V in an easy and efficient manner.
2021-11-21 10:35:18 +03:00
# Sirit
add_subdirectory("libraries/sirit")
Integrate BCeNabler support into QuirkManager Allows using BCn format textures on devices where they are unsupported by the driver.
2022-01-12 23:45:05 +03:00
# libadrenotools
add_subdirectory("libraries/adrenotools")
Introduce a pipeline manager and partial pipeline object gpu-new will use a monolithic pipeline object for each pipeline to store state, keyed by the PackedPipelineState contents. This allows for a greater level of per-pipeline optimisations and a reduction in the overall number of lookups in a draw compared to the previous system.
2022-09-10 23:03:01 +03:00
# Tessil Robin Map
add_subdirectory("libraries/robin-map")
Support using in-app renderdoc API to capture individual executions
2022-10-16 22:54:43 +03:00
# Renderdoc in-app API
include_directories("libraries/renderdoc")
Include BS thread pool library
2022-12-03 22:50:53 +03:00
# Thread Pool
include_directories("libraries/thread-pool")
Build libraries with `-Ofast` for debug builds To offset some of the performance overhead of using debug builds, we now optimize all libraries using `-Ofast` while building Skyline itself with `-O0`.
2021-10-31 00:46:21 +03:00
# Build Skyline with full debugging data and -Og for debug builds
Add stack tracing to `skyline::exception` Skyline's `exception` class now stores a list of all stack frames during the invocation of the exception. These can later be parsed by the exception handler to generate a human-readable stack trace. To assist with more complete stack traces, `-fno-omit-frame-pointer` is now passed on debug builds which forces the inclusion of frames on function calls.
2022-04-11 19:07:47 +03:00
set(CMAKE_CXX_FLAGS_DEBUG "-O0 -g3 -glldb -gdwarf-5 -fno-omit-frame-pointer")
Introduce a `releasedebug` build variant
2022-10-07 18:05:35 +03:00
# Build Skyline with full debugging data and some optimizations for reldebug builds, build speed is pioritised
set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "-O1 -g3 -glldb -gdwarf-5 -fno-omit-frame-pointer -fno-stack-protector")
Build libraries with `-Ofast` for debug builds To offset some of the performance overhead of using debug builds, we now optimize all libraries using `-Ofast` while building Skyline itself with `-O0`.
2021-10-31 00:46:21 +03:00
Add yuzu Shader Compiler as a submodule We plan to use our fork of yuzu's shader compiler for GPU shader compilation so it's been added as a submodule.
2021-11-21 11:06:39 +03:00
# Include headers from libraries as system headers to silence warnings from them
function(target_link_libraries_system target)
set(libraries ${ARGN})
foreach (library ${libraries})
if (TARGET ${library})
get_target_property(library_include_directories ${library} INTERFACE_INCLUDE_DIRECTORIES)
if (NOT "${library_include_directories}" STREQUAL "library_include_directories-NOTFOUND")
target_include_directories(${target} SYSTEM PRIVATE ${library_include_directories})
endif ()
endif ()
target_link_libraries(${target} PRIVATE ${library})
endforeach (library)
endfunction(target_link_libraries_system)
# yuzu Shader Compiler
add_subdirectory("libraries/shader-compiler")
target_include_directories(shader_recompiler PUBLIC "libraries/shader-compiler/include")
target_link_libraries_system(shader_recompiler Boost::intrusive Boost::container range-v3)
Reimplement audout and audren using yuzu audio_core The yuzu audio_core code is mostly untouched, with a set of wrappers used to bridge it with skyline kernel primitives. Huge thanks to maide and their advice, whom without this wouldn't have been possible.
2023-03-15 20:49:17 +03:00
# yuzu Audio Core
add_subdirectory("libraries/audio-core")
include_directories(SYSTEM "libraries/audio-core/include")
target_link_libraries_system(audio_core Boost::intrusive Boost::container range-v3)
Introduce Boost as a submodule + Minor Fixes Utilize Boost Container's `small_vector` for optimizing allocations, fix certain implicit casting issues and make `ILogger` not output an additional newline in the log when the application supplies one at the end of the log
2021-08-20 22:57:22 +03:00
# Skyline
Milestone 3 - Services API This commit adds the Services API and implements some services. It also changes the name of the application to Skyline and replaces the icon.
2019-09-24 23:54:27 +03:00
add_library(skyline SHARED
Add utilities for reading and installing gpu driver packages
2022-07-30 18:29:25 +03:00
${source_DIR}/driver_jni.cpp
Introduce new loader JNI for parsing application data and port Kotlin code to use it This will help ease the process of implementing new formats in the future and remove duplicated code.
2020-06-19 23:18:33 +03:00
${source_DIR}/emu_jni.cpp
${source_DIR}/loader_jni.cpp
Milestone 3 - Services API This commit adds the Services API and implements some services. It also changes the name of the application to Skyline and replaces the icon.
2019-09-24 23:54:27 +03:00
${source_DIR}/skyline/common.cpp
Add stack tracing to `skyline::exception` Skyline's `exception` class now stores a list of all stack frames during the invocation of the exception. These can later be parsed by the exception handler to generate a human-readable stack trace. To assist with more complete stack traces, `-fno-omit-frame-pointer` is now passed on debug builds which forces the inclusion of frames on function calls.
2022-04-11 19:07:47 +03:00
${source_DIR}/skyline/common/exception.cpp
Make `Logger` class static and introduce `LoggerContext` A thread local LoggerContext is now used to hold the output file stream instead of the `Logger` class. Before doing any logging operations, a LoggerContext must be initialized. This commit will not build successfully on purpose.
2021-10-28 00:27:44 +03:00
${source_DIR}/skyline/common/logger.cpp
Implement Exceptional Signal Handler + Fix Destruction Behavior An exceptional signal handler allows us to convert an OS signal into a C++ exception, this allows us to alleviate a lot of crashes that would otherwise occur from signals being thrown during execution of games and be able to handle them gracefully.
2020-11-03 12:44:09 +03:00
${source_DIR}/skyline/common/signal.cpp
Introduce a spin lock for resources locked at a very high frequency Constant buffer updates result in a barrage of std::mutex calls that take a lot of time even under no contention (around 5%). Using a custom spinlock in cases like these allows inlining locking code reducing the cost of locks under no contention to almost 0.
2022-08-31 18:38:04 +03:00
${source_DIR}/skyline/common/spin_lock.cpp
Add a UUID struct for holding and generating RFC4122 UUIDs Time uses UUIDs for clock identification.
2021-02-13 15:53:17 +03:00
${source_DIR}/skyline/common/uuid.cpp
Extend Perfetto Tracing Add Tracing for SVCs, Services, NVDRV, and Synchronization Primitives. In addition, fix `TRACE_EVENT_END("guest")` being emitted when a signal is received while being in the guest rather than host which would cause an exception. This commit also disables warnings for the Perfetto library as we do not control fixing them.
2021-03-20 19:52:08 +03:00
${source_DIR}/skyline/common/trace.cpp
Move from ptrace to junction branching and make kernel multithreaded This commit is a huge step in the direction of better performance, as we move from ptrace to junction branching and have kernel call overhead similar to that of a native kernel call! In addition, this sets the base for the kernel to go fully multi-threaded. However, the kernel is currently not thread-safe and therefore this commit currently causes a crash.
2020-01-07 05:36:08 +03:00
${source_DIR}/skyline/nce/guest.S
Milestone 3 - Services API This commit adds the Services API and implements some services. It also changes the name of the application to Skyline and replaces the icon.
2019-09-24 23:54:27 +03:00
${source_DIR}/skyline/nce.cpp
Fix JNI Race Condition, Fix Release Builds and Fix Searching This commit fixes JNI race conditions by usage of a mutex, fixes a bug in release builds due to ProGuard member obfuscation and fix searching by fixing the HeaderAdapter filter.
2019-12-05 18:35:34 +03:00
${source_DIR}/skyline/jvm.cpp
Implement NPDM, Core Mask SVCs + Fix VMM bug + Introduce Verbose Log Level
2020-10-21 20:09:35 +03:00
${source_DIR}/skyline/os.cpp
${source_DIR}/skyline/kernel/memory.cpp
Implement Cooperative Scheduling With Load Balancing
2020-12-05 20:41:52 +03:00
${source_DIR}/skyline/kernel/scheduler.cpp
Implement NPDM, Core Mask SVCs + Fix VMM bug + Introduce Verbose Log Level
2020-10-21 20:09:35 +03:00
${source_DIR}/skyline/kernel/ipc.cpp
${source_DIR}/skyline/kernel/svc.cpp
${source_DIR}/skyline/kernel/types/KProcess.cpp
${source_DIR}/skyline/kernel/types/KThread.cpp
${source_DIR}/skyline/kernel/types/KSharedMemory.cpp
${source_DIR}/skyline/kernel/types/KPrivateMemory.cpp
Improve Synchronization SVCs + Fix TLS Page Allocation Race + Fix KProcess::GetHandle<KObject>
2021-01-11 22:17:06 +03:00
${source_DIR}/skyline/kernel/types/KSyncObject.cpp
Refactor Audio This commit refactors a lot of audio by fixing a lot of nitpicks here and there.
2020-04-18 00:23:38 +03:00
${source_DIR}/skyline/audio.cpp
Vulkan Instance + Validation Layer + Debug Report Initialization The GPU class has been extended in this for Vulkan initialization, this is done to the point of initializing the instance alongside loading in `VK_LAYER_KHRONOS_validation` which is also now packed into all Debug APKs for Skyline. In addition, `VK_EXT_debug_report` is also initialized and it's output is piped directly into the Logger. A minor change regarding the type of the `Fps` and `Frametime` globals was changed to `skyline::i32`s which is a more suitable type due to those having a smaller chance of overflowing while being signed as Java doesn't have unsigned integral types.
2021-03-28 00:17:35 +03:00
${source_DIR}/skyline/gpu.cpp
Rename `QuirkManager` to `TraitManager` Quirk terminology was deemed to be inappropriate for describing the features/extensions of a device. It has been replaced with traits which is far more fitting but quirks will be used as a terminology for errata in devices.
2022-01-22 17:45:28 +03:00
${source_DIR}/skyline/gpu/trait_manager.cpp
Implement Fence Cycle, Memory Manager and Command Scheduler Implements a wrapper over fences to track a single cycle of activation, implement a Vulkan memory manager that wraps the Vulkan-Memory-Allocator library and a command scheduler for scheduling Vulkan command buffers
2021-05-22 19:31:22 +03:00
${source_DIR}/skyline/gpu/memory_manager.cpp
Initial Texture Manager Implementation + Maxwell3D Render Target Implement the groundwork for the texture manager to be able to report basic overlaps and be extended to support more in the future. The Maxwell3D registers `RenderTargetControl`, `RenderTarget` and a stub for `ClearBuffers` were implemented. A lot of changes were also made to `GuestTexture`/`Texture` for supporting mipmapping and multiple array layers alongside significant architectural changes to `GuestTexture` effectively disconnecting it from `Texture` with it no longer being a parent rather an object that can be used to create a `Texture` object. Note: Support for fragmented CPU mappings hasn't been added for texture synchronization yet
2021-08-20 23:17:13 +03:00
${source_DIR}/skyline/gpu/texture_manager.cpp
Introduce `BufferManager` The Buffer Manager handles mapping of guest buffers to host buffer views with automatic handling of sub-buffers and eventually supporting recreation of overlapping buffers to create a single larger buffer.
2021-12-06 19:13:43 +03:00
${source_DIR}/skyline/gpu/buffer_manager.cpp
Implement Fence Cycle, Memory Manager and Command Scheduler Implements a wrapper over fences to track a single cycle of activation, implement a Vulkan memory manager that wraps the Vulkan-Memory-Allocator library and a command scheduler for scheduling Vulkan command buffers
2021-05-22 19:31:22 +03:00
${source_DIR}/skyline/gpu/command_scheduler.cpp
Implement Vulkan Descriptor Set Allocator A fixed descriptor set allocator which manages the size of the pool with automatic reallocations when any allocations run out of descriptors.
2021-12-22 15:24:00 +03:00
${source_DIR}/skyline/gpu/descriptor_allocator.cpp
Implement CPU BCn Texture Decoding Certain GPU vendors such as ARM's Mali do not have support for BCn textures whatsoever while other vendors such as AMD only have partial support (BC1-BC3). Most titles on the guest utilize BC textures and to address this on host GPUs without support for BCn, we need to decompress the texture on the CPU. This commit implements a CPU BCn texture decoder based off Swiftshader's BC decoder, it also adds the necessary infrastructure to have different formats for the `GuestTexture` and `Texture` objects.
2022-05-28 17:56:24 +03:00
${source_DIR}/skyline/gpu/texture/bc_decoder.cpp
Redesign Texture Class + Improve Presentation Engine This commit reworks the `Texture` class to include a Vulkan Image backing that can be optionally owning or non-owning and swapped in with consideration for Vulkan image layout, it also adds CPU-sided synchronization for the texture objects with FenceCycle. It also makes the appropriate changes to `PresentationEngine` and `GraphicBufferProducer` to work with the new `Texture` class while setting the groundwork for supporting swapchain recreation. It also fixes a log in `IpcResponse` and improves the display mode selection algorithm by further weighing refresh rate.
2021-05-22 20:46:28 +03:00
${source_DIR}/skyline/gpu/texture/texture.cpp
Refactor Texture Swizzling The API for texture swizzling is now more concrete and abstracted out from `GuestTexture`, this allows for neater usage in certain areas such as MaxwellDMA while having a `GuestTexture` wrapper as well allowing for neater usage in those cases. The code itself has also been cleaned up slightly with all usage of `u32`s being upgraded to `size_t` as this is simply more efficient due to the compiler not needing to emulate wraparound behavior for integer types smaller than the processor word size.
2022-05-19 14:43:13 +03:00
${source_DIR}/skyline/gpu/texture/layout.cpp
Introduce `Buffer` and `BufferView` Implements infrastructure for using guest buffers on the host for rendering, a `BufferManager` is still missing which'd handle mapping from guest buffers to host buffers and will be subsequently committed. It should be noted that `BufferView` is also disconnected from `Buffer` and shared for every instance with the same properties like `TextureView` is now.
2021-12-06 09:30:39 +03:00
${source_DIR}/skyline/gpu/buffer.cpp
Introduce chunked `MegaBuffer` allocation After the introduction of workahead a system to hold a single large megabuffer per submission was implemented, this worked fine for most cases however when many submissions were flight at the same time memory usage would increase dramatically due to the amount of megabuffers needed. Since only one megabuffer was allowed per execution, it forced the buffer to be fairly large in order to accomodate the upper-bound, even further increasing memory usage. This commit implements a system to fix the memory usage issue described above by allowing multiple megabuffers to be allocated per execution, as well as reuse across executions. Allocations now go through a global allocator object which chooses which chunk to allocate into on a per-allocation scale, if all are in use by the GPU another chunk will be allocated, that can then be reused for future allocations too. This reduces Hollow Knight megabuffer memory usage by a factor 4 and SMO by even more.
2022-08-07 00:29:33 +03:00
${source_DIR}/skyline/gpu/megabuffer.cpp
Run Guest on Main Emulator Thread + Remove Mutex/GroupMutex + Introduce PresentationEngine
2020-10-28 19:00:39 +03:00
${source_DIR}/skyline/gpu/presentation_engine.cpp
Introduce `ShaderManager` with Proxy Shader Compiler Logger/Settings This class will be entirely responsible for any interop with the shader compiler, it is also responsible for caching and compilation of shaders in itself.
2021-12-01 22:13:10 +03:00
${source_DIR}/skyline/gpu/shader_manager.cpp
Introduce a pipeline cache manager for simple read/write cache accesses All writes are done async into a staging file, which is then merged into the main pipeline cache file at the time of the next launch. Upon encountering file corruption the cache can be trimmed up to the last-known-good entry to avoid any excessive loss of data from just one error.
2022-12-10 18:43:06 +03:00
${source_DIR}/skyline/gpu/pipeline_cache_manager.cpp
Move graphics piplines away from storing hades shader info struct By only using what we need, and mirroring the descriptor structs to allow for much tighter packing (while keeping the same member names) we can reduce pipeline memory to about 1/3 of what it was before.
2023-01-18 23:04:50 +03:00
${source_DIR}/skyline/gpu/graphics_pipeline_assembler.cpp
Implement Render Pass Cache Implements a cache for storing `VkRenderPass` objects which are often reused, they are not extremely expensive to create generally but this is a required step to build up to a framebuffer cache which is an extremely expensive object to create on TBDRs generally since it involves calculating tiling memory allocations and in the case of Adreno's proprietary driver involves several kernel calls for mapping and allocating the corresponding memory.
2022-05-01 15:45:50 +03:00
${source_DIR}/skyline/gpu/cache/renderpass_cache.cpp
Implement Framebuffer Cache Implements a cache for storing `VkFramebuffer` objects with a special path on devices with `VK_KHR_imageless_framebuffer` to allow for more cache hits due to an abstract image rather than a specific one. Caching framebuffers is a fairly crucial optimization due to the cost of creating framebuffers on TBDRs since it involves calculating tiling memory allocations and in the case of Adreno's proprietary driver involves several kernel calls for mapping and allocating the corresponding framebuffer memory.
2022-05-01 15:36:55 +03:00
${source_DIR}/skyline/gpu/cache/framebuffer_cache.cpp
Implement a system for helper shaders together with a simple blit shader It is desirable for us to use a shader for blits to allow easily emulating out of bounds blits and blits between different swizzled colour formats. The helper shader infrastructure is designed to be generic so it can be reused by any other helper shaders that we may need in the future.
2022-07-31 17:05:20 +03:00
${source_DIR}/skyline/gpu/interconnect/fermi_2d.cpp
Implement accelerated uploads/copies through buffer manager Previously, both I2M uploads and DMA copies would force GPU serialisation if they happened to hit a trap or were used to copy GPU dirty buffers. By using the buffer manager to implement them on the host GPU we can avoid such slowdowns entiely.
2022-10-25 22:57:30 +03:00
${source_DIR}/skyline/gpu/interconnect/maxwell_dma.cpp
${source_DIR}/skyline/gpu/interconnect/inline2memory.cpp
Rewrite constant buffer interconnect code Adepted from the previous code to use dirty state tracking. The cache has also been removed since with the new buffer view and GMMU optimisations it actually ended up slowing lookups down, another result of the buffer view optimisations is that raw pointers are no longer used for buffer views since destruction is now much cheaper.
2022-09-02 14:02:25 +03:00
${source_DIR}/skyline/gpu/interconnect/maxwell_3d/active_state.cpp
${source_DIR}/skyline/gpu/interconnect/maxwell_3d/pipeline_state.cpp
Abstract out pipeline-compile-time GPU state accesses Introduces the base abstractions that will be used for pipeline caching, with a 'PipelineStateBundle' that can be (de)serialised to/from disk and an abstract accessor class to allow switching between creating disk-cached pipelines and fresh ones.
2022-12-03 17:36:30 +03:00
${source_DIR}/skyline/gpu/interconnect/maxwell_3d/graphics_pipeline_state_accessor.cpp
Move packed pipeline state to a seperate file
2022-09-10 22:51:14 +03:00
${source_DIR}/skyline/gpu/interconnect/maxwell_3d/packed_pipeline_state.cpp
Introduce a pipeline manager and partial pipeline object gpu-new will use a monolithic pipeline object for each pipeline to store state, keyed by the PackedPipelineState contents. This allows for a greater level of per-pipeline optimisations and a reduction in the overall number of lookups in a draw compared to the previous system.
2022-09-10 23:03:01 +03:00
${source_DIR}/skyline/gpu/interconnect/maxwell_3d/pipeline_manager.cpp
Rewrite constant buffer interconnect code Adepted from the previous code to use dirty state tracking. The cache has also been removed since with the new buffer view and GMMU optimisations it actually ended up slowing lookups down, another result of the buffer view optimisations is that raw pointers are no longer used for buffer views since destruction is now much cheaper.
2022-09-02 14:02:25 +03:00
${source_DIR}/skyline/gpu/interconnect/maxwell_3d/constant_buffers.cpp
${source_DIR}/skyline/gpu/interconnect/maxwell_3d/maxwell_3d.cpp
CMake build file updates
2022-11-19 00:54:44 +03:00
${source_DIR}/skyline/gpu/interconnect/kepler_compute/pipeline_manager.cpp
${source_DIR}/skyline/gpu/interconnect/kepler_compute/pipeline_state.cpp
${source_DIR}/skyline/gpu/interconnect/kepler_compute/kepler_compute.cpp
${source_DIR}/skyline/gpu/interconnect/kepler_compute/constant_buffers.cpp
Introduce `CommandExecutor` + Implement `ClearBuffers` + More RT Formats This commit introduces the `CommandExecutor` which is responsible for creating and orchestrating a Vulkan command graph comprising of `CommandNode`s that construct all the objects required for rendering. As a result of the infrastructure provided by `CommandExecutor`, `ClearBuffers` could be implemented and be appropriately utilized. A bug regarding scissors was also determined and fixed in the PR, the extent of them were previously inaccurate and this has now been fixed. Note: We don't synchronize any textures from the guest for now as this would override the contents on the host, this'll be fixed with the appropriate write tracking but it also results in a black screen for anything that writes to FB
2021-09-14 19:00:12 +03:00
${source_DIR}/skyline/gpu/interconnect/command_executor.cpp
Address CR Comments
2021-10-22 12:59:38 +03:00
${source_DIR}/skyline/gpu/interconnect/command_nodes.cpp
Implement `QuadList` support for non-indexed draws
2022-04-20 12:26:06 +03:00
${source_DIR}/skyline/gpu/interconnect/conversion/quads.cpp
CMake build file updates
2022-11-19 00:54:44 +03:00
${source_DIR}/skyline/gpu/interconnect/common/common.cpp
${source_DIR}/skyline/gpu/interconnect/common/samplers.cpp
${source_DIR}/skyline/gpu/interconnect/common/textures.cpp
${source_DIR}/skyline/gpu/interconnect/common/shader_cache.cpp
Abstract out pipeline-compile-time GPU state accesses Introduces the base abstractions that will be used for pipeline caching, with a 'PipelineStateBundle' that can be (de)serialised to/from disk and an abstract accessor class to allow switching between creating disk-cached pipelines and fresh ones.
2022-12-03 17:36:30 +03:00
${source_DIR}/skyline/gpu/interconnect/common/pipeline_state_bundle.cpp
Introduce a pipeline state accessor that reads from a bundle
2022-12-10 18:41:02 +03:00
${source_DIR}/skyline/gpu/interconnect/common/file_pipeline_state_accessor.cpp
Implement a system for helper shaders together with a simple blit shader It is desirable for us to use a shader for blits to allow easily emulating out of bounds blits and blits between different swizzled colour formats. The helper shader infrastructure is designed to be generic so it can be reused by any other helper shaders that we may need in the future.
2022-07-31 17:05:20 +03:00
${source_DIR}/skyline/gpu/shaders/helper_shaders.cpp
Hookup FlatMemoryManager for SMMU into SoC The SMMU is used to control the mappings of peripherals such as the VIC and NVDEC.
2021-10-26 00:54:03 +03:00
${source_DIR}/skyline/soc/smmu.cpp
Move Guest GPU into SoC Directory We decided to restructure Skyline to draw a layer of separation between guest and host GPU. We're reserving the `gpu` namespace and directory for purely host GPU and creating a new `soc` directory and namespace for emulation of parts of the X1 SoC which is currently limited to guest GPU but will be expanded to contain components like the audio DSP down the line.
2021-03-24 23:09:21 +03:00
${source_DIR}/skyline/soc/host1x/syncpoint.cpp
Implement the Host1x command FIFO together with barebones Host1x classes The Host1x block of the TX1 supports 14 separate channels to which commands can be issued, these all run asynchronously so are emulated the same way as GPU channels with one FIFO emulation thread each. The command FIFO itself is very similar to the GPFIFO found in the GPU however there are some differences, mainly the introduction of classes (similar to engines) and the Mask opcode (which allows writing to a specific set of offsets much more efficiently). There is an internal Host1x class which functions similar to the GPFIFO class in the GPU, handling general operations such as syncpoint waits, this is accessed via the simple method interface. Other channels such as NVDEC and VIC are behind the 'Tegra Host Interface' (THI) in HW, this abstracts out the classes internal details and provides a uniform method interface ontop of the Host1x method one. We emulate the THI as a templated wrapper for the underlying class. Syncpoint increments in Host1x are different to GPU, the THI allows submitting increment requests that will be queued up and only be applied after a specific condition in the associated engine is met; however the option to for immediate increments is also available.
2021-10-30 20:57:53 +03:00
${source_DIR}/skyline/soc/host1x/command_fifo.cpp
${source_DIR}/skyline/soc/host1x/classes/host1x.cpp
${source_DIR}/skyline/soc/host1x/classes/vic.cpp
${source_DIR}/skyline/soc/host1x/classes/nvdec.cpp
Implement multichannel support for GPU Allows the execution of multiple channels at the same time, with locking being performed on the host GPU scheduler layer, address spaces can be bound to one or more channels.
2021-10-08 22:25:21 +03:00
${source_DIR}/skyline/soc/gm20b/channel.cpp
Move Guest GPU into SoC Directory We decided to restructure Skyline to draw a layer of separation between guest and host GPU. We're reserving the `gpu` namespace and directory for purely host GPU and creating a new `soc` directory and namespace for emulation of parts of the X1 SoC which is currently limited to guest GPU but will be expanded to contain components like the audio DSP down the line.
2021-03-24 23:09:21 +03:00
${source_DIR}/skyline/soc/gm20b/gpfifo.cpp
Implement multichannel support for GPU Allows the execution of multiple channels at the same time, with locking being performed on the host GPU scheduler layer, address spaces can be bound to one or more channels.
2021-10-08 22:25:21 +03:00
${source_DIR}/skyline/soc/gm20b/gmmu.cpp
Implement macro HLE for instanced draw macros gm20b performs instanced draws by repeating draw methods for each instance, the code to detect this together with the cost of interpreting macros took up around 6% of GPFIFO time in Metro Kingdom. By detecting these specific macros and performing an instanced draw directly much of that cost can be avoided.
2022-09-15 00:01:50 +03:00
${source_DIR}/skyline/soc/gm20b/macro/macro_state.cpp
Rework GPFIFO method distribution and macros to support multiple engines Fermi2D supports macros in addition to Maxwell3D, these both share code memory. To support this we rework the macro interpreter to support passing in a target engine and abstract the communications out into an interface that can be implemented by applicable engines. ``` GPFIFO <-> MME <-> Maxwell3D ^ ^---> Fermi2D X------------> I2M X------------> MaxwellComputeB X--Flush-----> MaxwellDMA ```
2022-01-19 23:45:51 +03:00
${source_DIR}/skyline/soc/gm20b/macro/macro_interpreter.cpp
${source_DIR}/skyline/soc/gm20b/engines/engine.cpp
Implement pre-wait and post-increment syncpoint operations in submit These are used by both OpenGL and Vulkan games as opposed to including the operations inside the main commandbuffer.
2021-10-11 22:08:42 +03:00
${source_DIR}/skyline/soc/gm20b/engines/gpfifo.cpp
Move Guest GPU into SoC Directory We decided to restructure Skyline to draw a layer of separation between guest and host GPU. We're reserving the `gpu` namespace and directory for purely host GPU and creating a new `soc` directory and namespace for emulation of parts of the X1 SoC which is currently limited to guest GPU but will be expanded to contain components like the audio DSP down the line.
2021-03-24 23:09:21 +03:00
${source_DIR}/skyline/soc/gm20b/engines/maxwell_3d.cpp
Implement basic inline2memory engine support Not currently used by anything but will be used by both compute, 3D and its own engine in the future. Block linear copies are currently unsupported.
2022-03-20 21:00:34 +03:00
${source_DIR}/skyline/soc/gm20b/engines/inline2memory.cpp
Implement a skeleton compute engine The Kepler compute engine is used to run compute jobs encapsulated in to QMDs on the GPU, this commit doesn't implement compute itself but adds the register and QMD structs that will be needed for it in the future.
2022-03-20 21:08:11 +03:00
${source_DIR}/skyline/soc/gm20b/engines/kepler_compute.cpp
Implement the Maxwell DMA engine The DMA engine is used to perform DMA buffer/texture copies directly on the GPU. It can deswizzle arbritary regions of input textures, perform component remapping and swizzle into output textures. This impl only supports 1D buffer copies, 2D ones will come later.
2022-04-09 15:14:06 +03:00
${source_DIR}/skyline/soc/gm20b/engines/maxwell_dma.cpp
Initialize Maxwell3D Registers Correctly Maxwell3D Registers weren't initialized to the correct values prior, this commit fixes that by doing `HandleMethod` calls with all the register values being initialized. This is in contrast to the registers being set without calling the methods in `GraphicsContext` or otherwise resulting in bugs.
2021-11-12 11:54:43 +03:00
${source_DIR}/skyline/soc/gm20b/engines/maxwell/initialization.cpp
Implement the Fermi 2D blitting engine The Fermi 2D engine implements both image blit and resolve operations, supporting subpixel sampling with both linear and point filtering. Resolve operations are performed by sampling from the center of each pixel in order to resolve the final image from the MSAA samples MSAA images are stored in memory like regular images but each pixels dimensions are scaled: e.g for 2x2 MSAA ``` 112233 112233 445566 445566 ``` These would be sampled with both duDx and duDy as 2 (integer part), resolving to the following: ``` 123 456 ``` Blit operations are performed by sampling from the corner of each pixel, scaling the image as one would expect. This implementation isn't fully complete as Vulkan blit doesn't support some combinations which Fermi does, most notably between colour and depth stencil. These will be implemented properly at a later date, likely after the texture manager rework. Out of Bounds Blit, used by some OpenGL games is also missing since supporting it requires texture aliasing, this will also be supported after the texture manager rework. Co-authored-by: Billy Laws <blaws05@gmail.com>
2022-02-07 16:15:55 +03:00
${source_DIR}/skyline/soc/gm20b/engines/fermi_2d.cpp
Write HID LIFO entries at fixed intervals Certain titles depend on HID LIFO entries being written out at a fixed frequency rather than on actual state change, not doing this can lead to applications freezing till the LIFO is filled up to maximum size, this behavior is seen in Super Mario Odyssey. In other cases such as Metroid Dread, the game can run into race conditions that would lead to crashes, these were worked around by smashing a button during loading prior. This commit introduces a thread which sleeps and wakes up occasionally to write LIFO entries into HID shared memory at the desired frequencies. This alleviates any issues as it fills up the LIFO instantly and correctly emulates HID Shared Memory behavior expected by the guest. Co-authored-by: Narr the Reg <juangerman-13@hotmail.com>
2022-08-31 20:03:42 +03:00
${source_DIR}/skyline/input.cpp
Initial C++ Input Implementation This commit contains the C++ side of the initial Input implementation, this is based on the work done in the `hid` branch in `bylaws/skyline`. Co-authored-by: ◱ PixelyIon <pixelyion@protonmail.com>
2020-04-26 02:34:35 +03:00
${source_DIR}/skyline/input/npad.cpp
Refactor C++ Input This commit refactors the C++ end of Input so it'll be in line with the rest of the codebase and be ready for the extension with multiple players and controller configuration.
2020-05-01 00:53:45 +03:00
${source_DIR}/skyline/input/npad_device.cpp
Implement Guest Touch-Screen Support
2020-09-07 19:39:05 +03:00
${source_DIR}/skyline/input/touch.cpp
Implement NPDM, Core Mask SVCs + Fix VMM bug + Introduce Verbose Log Level
2020-10-21 20:09:35 +03:00
${source_DIR}/skyline/crypto/aes_cipher.cpp
${source_DIR}/skyline/crypto/key_store.cpp
Commonise executable loading infrastructure Mapping and writing segments into memory is now handled by a common function that can be shared between all loaders. All they need to do now is to pack each segment into a common struct.
2020-06-25 18:29:35 +03:00
${source_DIR}/skyline/loader/loader.cpp
Milestone 3 - Services API This commit adds the Services API and implements some services. It also changes the name of the application to Skyline and replaces the icon.
2019-09-24 23:54:27 +03:00
${source_DIR}/skyline/loader/nro.cpp
Implement NSO loader The NSO format is used by all retail games and some homebrew. It supports compressing sections with lz4 and dynamic linking through the use of rtld.
2020-06-25 18:51:05 +03:00
${source_DIR}/skyline/loader/nso.cpp
Implement an NCA parser and loader Nintendo Content Archives are used to store the assets, executables and updates of applications. They support holding either a PFS0 or a RomFS. An NCA's ExeFS can be loaded by placing each NSO sequentially into memory, starting with rtld which will link them together. Currently only decrypted NCAs are supported, encryption and BKTR handling will be added at a later time.
2020-06-29 21:23:33 +03:00
${source_DIR}/skyline/loader/nca.cpp
Add XCI file format support
2021-02-28 01:11:09 +03:00
${source_DIR}/skyline/loader/xci.cpp
Implement a basic NSP loader An NSP (Nintendo Submission Package) is effectively a PFS0 containing NCAs, there are also tickets and a CNMT file which contains metadata about updates. The current implementation is very basic and only support Control and Program NCAs which is enough for loading games. Support for updates and dlc will be added at a later date.
2020-06-29 23:19:32 +03:00
${source_DIR}/skyline/loader/nsp.cpp
Implement Symbol Hooking Symbol hooking is required for HLE implementations of certain features in the future such as `nvdec` and for more in-depth debugging of games as we can inspect them on a SDK function level which allows us to debug issues far more easily.
2022-11-07 21:16:34 +03:00
${source_DIR}/skyline/hle/symbol_hooks.cpp
Implement NPDM, Core Mask SVCs + Fix VMM bug + Introduce Verbose Log Level
2020-10-21 20:09:35 +03:00
${source_DIR}/skyline/vfs/partition_filesystem.cpp
${source_DIR}/skyline/vfs/ctr_encrypted_backing.cpp
${source_DIR}/skyline/vfs/rom_filesystem.cpp
Add AndroidAsset{Backing,FileSystem} for accessing built-in assets These only implement the subset of VFS needed for time, implementing more is difficult due to some issues in the AAsset API which make support quite ugly. The abstract asset filesystem can be accessed by services through the OS class allowing other implementations to be used in the future.
2021-03-03 23:35:24 +03:00
${source_DIR}/skyline/vfs/os_filesystem.cpp
Implement NPDM, Core Mask SVCs + Fix VMM bug + Introduce Verbose Log Level
2020-10-21 20:09:35 +03:00
${source_DIR}/skyline/vfs/os_backing.cpp
Add AndroidAsset{Backing,FileSystem} for accessing built-in assets These only implement the subset of VFS needed for time, implementing more is difficult due to some issues in the AAsset API which make support quite ugly. The abstract asset filesystem can be accessed by services through the OS class allowing other implementations to be used in the future.
2021-03-03 23:35:24 +03:00
${source_DIR}/skyline/vfs/android_asset_filesystem.cpp
${source_DIR}/skyline/vfs/android_asset_backing.cpp
Implement NPDM, Core Mask SVCs + Fix VMM bug + Introduce Verbose Log Level
2020-10-21 20:09:35 +03:00
${source_DIR}/skyline/vfs/nacp.cpp
${source_DIR}/skyline/vfs/npdm.cpp
${source_DIR}/skyline/vfs/nca.cpp
Add NSP ticket extraction support
2021-02-23 14:33:42 +03:00
${source_DIR}/skyline/vfs/ticket.cpp
Framebuffer and NativeActivity What was added: * Framebuffer * NativeActivity * NV Services * IOCTL Handler * NV Devices: * * /dev/nvmap - 0xC0080101, 0xC0080103, 0xC0200104, 0xC0180105, 0xC00C0109, 0xC008010E * * /dev/nvhost-as-gpu * * /dev/nvhost-channel - 0x40044801, 0xC0104809, 0xC010480B, 0xC018480C, 0x4004480D, 0xC020481A, 0x40084714 * * /dev/nvhost-ctrl * * /dev/nvhost-ctrl-gpu - 0x80044701, 0x80284702, 0xC0184706, 0xC0B04705, 0x80084714 * SVCs: * * SetMemoryAttribute * * CreateTransferMemory * * ResetSignal * * GetSystemTick * Addition of Compact Logger What was fixed: * SVCs: * * SetHeapSize * * SetMemoryAttribute * * QueryMemory * A release build would not set CMAKE_BUILD_TYPE to "RELEASE" * The logger code was simplified
2019-11-13 23:09:31 +03:00
${source_DIR}/skyline/services/serviceman.cpp
Constexpr Maps for Service Functions
2020-09-21 13:04:26 +03:00
${source_DIR}/skyline/services/base_service.cpp
Refactor service manager services Use the new service naming convention. Fix some small code style issues with {} on if statements
2020-02-16 22:11:43 +03:00
${source_DIR}/skyline/services/sm/IUserInterface.cpp
Refactor fatal services Use the new service naming convention.
2020-02-17 17:50:53 +03:00
${source_DIR}/skyline/services/fatalsrv/IService.cpp
Stub audin:u
2022-06-04 21:11:57 +03:00
${source_DIR}/skyline/services/audio/IAudioInManager.cpp
Refactor audio backend and services Use the new service naming convention. Move both audout and audren into one directory. Close the audio stream upon emulator exit.
2020-02-17 22:11:59 +03:00
${source_DIR}/skyline/services/audio/IAudioOutManager.cpp
${source_DIR}/skyline/services/audio/IAudioOut.cpp
Implement IAudioDevice for accessing audio output properties This is used by Super Mario Odyssey in its init routine.
2020-07-09 16:48:14 +03:00
${source_DIR}/skyline/services/audio/IAudioDevice.cpp
Refactor audio backend and services Use the new service naming convention. Move both audout and audren into one directory. Close the audio stream upon emulator exit.
2020-02-17 22:11:59 +03:00
${source_DIR}/skyline/services/audio/IAudioRendererManager.cpp
Reimplement audout and audren using yuzu audio_core The yuzu audio_core code is mostly untouched, with a set of wrappers used to bridge it with skyline kernel primitives. Huge thanks to maide and their advice, whom without this wouldn't have been possible.
2023-03-15 20:49:17 +03:00
${source_DIR}/skyline/services/audio/IAudioRenderer.cpp
Implement the set service together with GetAvailableLanguageCodes The 'set' service is used to obtain user settings such as language. This is used by Puyo Puyo Tetris.
2020-07-04 23:22:35 +03:00
${source_DIR}/skyline/services/settings/ISettingsServer.cpp
Refactor settings services Use the new service naming convention.
2020-02-16 22:25:18 +03:00
${source_DIR}/skyline/services/settings/ISystemSettingsServer.cpp
Refactor apm services Use the new service naming scheme. Switch to std::array for performanceConfig.
2020-02-18 14:41:22 +03:00
${source_DIR}/skyline/services/apm/IManager.cpp
${source_DIR}/skyline/services/apm/ISession.cpp
Refactor am services Use the new service naming scheme. Remove redundant casts and template specifiers in response.Push.
2020-02-19 23:35:54 +03:00
${source_DIR}/skyline/services/am/IAllSystemAppletProxiesService.cpp
${source_DIR}/skyline/services/am/IApplicationProxyService.cpp
${source_DIR}/skyline/services/am/proxy/base_proxy.cpp
${source_DIR}/skyline/services/am/proxy/IApplicationProxy.cpp
${source_DIR}/skyline/services/am/proxy/ILibraryAppletProxy.cpp
${source_DIR}/skyline/services/am/proxy/IOverlayAppletProxy.cpp
${source_DIR}/skyline/services/am/proxy/ISystemAppletProxy.cpp
${source_DIR}/skyline/services/am/controller/IAppletCommonFunctions.cpp
${source_DIR}/skyline/services/am/controller/IApplicationFunctions.cpp
${source_DIR}/skyline/services/am/controller/IAudioController.cpp
${source_DIR}/skyline/services/am/controller/ICommonStateGetter.cpp
${source_DIR}/skyline/services/am/controller/IDebugFunctions.cpp
${source_DIR}/skyline/services/am/controller/IDisplayController.cpp
${source_DIR}/skyline/services/am/controller/ILibraryAppletCreator.cpp
${source_DIR}/skyline/services/am/controller/ISelfController.cpp
${source_DIR}/skyline/services/am/controller/IWindowController.cpp
Implement IStorage services in Applet Manager In the case of am, IStorage is used to exchange buffers of data such as application launch parameters or an applets result. It has no relation to fsp-srv's IStorage.
2020-07-04 22:15:33 +03:00
${source_DIR}/skyline/services/am/storage/IStorage.cpp
Infrastructure for applets to be implemented This removes a stub for an applet and implements several applet related service calls.
2022-04-10 06:16:11 +03:00
${source_DIR}/skyline/services/am/storage/VectorIStorage.cpp
${source_DIR}/skyline/services/am/storage/TransferMemoryIStorage.cpp
Implement IStorage services in Applet Manager In the case of am, IStorage is used to exchange buffers of data such as application launch parameters or an applets result. It has no relation to fsp-srv's IStorage.
2020-07-04 22:15:33 +03:00
${source_DIR}/skyline/services/am/storage/IStorageAccessor.cpp
Extend applet manager services for the library applet This commit adds stubs for the library applet and adds support for writing to an AM IStorage.
2020-07-07 17:58:38 +03:00
${source_DIR}/skyline/services/am/applet/ILibraryAppletAccessor.cpp
Infrastructure for applets to be implemented This removes a stub for an applet and implements several applet related service calls.
2022-04-10 06:16:11 +03:00
${source_DIR}/skyline/services/am/applet/IApplet.cpp
Basic `bcat:u` implementation A basic `bcat:u` implementation to prevent titles such as "Kirby and the Forgotten Land" dependent on BCAT support from crashing due to the lack of an implementation.
2022-05-06 10:47:49 +03:00
${source_DIR}/skyline/services/bcat/IBcatService.cpp
service: bcat: Stub CreateDeliveryCacheStorageService
2022-10-25 08:30:58 +03:00
${source_DIR}/skyline/services/bcat/IDeliveryCacheStorageService.cpp
Stub IDeliveryCacheFileService and IDeliveryCacheDirectoryService
2023-01-09 12:40:53 +03:00
${source_DIR}/skyline/services/bcat/IDeliveryCacheFileService.cpp
${source_DIR}/skyline/services/bcat/IDeliveryCacheDirectoryService.cpp
service: bcat: Stub CreateDeliveryCacheStorageService
2022-10-25 08:30:58 +03:00
${source_DIR}/skyline/services/bcat/IServiceCreator.cpp
Stub `bt` and `btm:u` Stub BT services which is required by titles such as Pokémon Let's GO Pikachu and Eevee (non-Demo versions).
2022-05-11 12:12:53 +03:00
${source_DIR}/skyline/services/bt/IBluetoothUser.cpp
${source_DIR}/skyline/services/btm/IBtmUser.cpp
${source_DIR}/skyline/services/btm/IBtmUserCore.cpp
Stub caps:a
2022-11-04 15:13:37 +03:00
${source_DIR}/skyline/services/capsrv/IAlbumAccessorService.cpp
Stub caps:c
2022-11-04 15:15:35 +03:00
${source_DIR}/skyline/services/capsrv/ICaptureControllerService.cpp
Stub caps:u
2022-11-04 15:16:54 +03:00
${source_DIR}/skyline/services/capsrv/IAlbumApplicationService.cpp
Stub caps:su
2022-11-04 15:18:40 +03:00
${source_DIR}/skyline/services/capsrv/IScreenShotApplicationService.cpp
Stub ldr:ro IRoInterface Some games initialise this service on startup however don't actually use it. Add a simple stub to allow such games to boot.
2022-09-29 22:22:00 +03:00
${source_DIR}/skyline/services/ro/IRoInterface.cpp
Infrastructure for applets to be implemented This removes a stub for an applet and implements several applet related service calls.
2022-04-10 06:16:11 +03:00
${source_DIR}/skyline/applet/applet_creator.cpp
Stub the controller applet Mostly based off of yuzu's implementation, this will need to be extended in the future to open up a UI for configuring controllers according to the applications requirements.
2022-04-15 15:18:55 +03:00
${source_DIR}/skyline/applet/controller_applet.cpp
Write `ApplicationErrorArg` `ErrorApplet`s to log These applets are used by applications to display a custom error message to the user. Both the error message and the detailed error message are printed to the error log. Co-authored-by: lynxnb <niccolo.betto@gmail.com>
2022-07-01 21:41:36 +03:00
${source_DIR}/skyline/applet/error_applet.cpp
Stub LibraryAppletPlayerSelect
2022-05-12 01:15:03 +03:00
${source_DIR}/skyline/applet/player_select_applet.cpp
Stub the web applet
2022-10-30 19:10:05 +03:00
${source_DIR}/skyline/applet/web_applet.cpp
Implement Software Keyboard applet This implements the non-inline version of the Software Keyboard (swkbd) applet, which games use to get text input from the user.
2022-06-28 10:25:01 +03:00
${source_DIR}/skyline/applet/swkbd/software_keyboard_applet.cpp
${source_DIR}/skyline/applet/swkbd/software_keyboard_config.cpp
hwopus decoder service implementation
2021-07-14 17:39:17 +03:00
${source_DIR}/skyline/services/codec/IHardwareOpusDecoder.cpp
${source_DIR}/skyline/services/codec/IHardwareOpusDecoderManager.cpp
Refactor HID services Use the new service naming convention. Tidy up some unused includes. Move constants to service namespace.
2020-02-16 22:42:32 +03:00
${source_DIR}/skyline/services/hid/IHidServer.cpp
${source_DIR}/skyline/services/hid/IAppletResource.cpp
Implement Rumble Support for Controllers and Device Vibrators
2020-09-05 02:06:07 +03:00
${source_DIR}/skyline/services/hid/IActiveVibrationDeviceList.cpp
Stub IRS Service
2022-03-27 04:12:11 +03:00
${source_DIR}/skyline/services/irs/IIrSensorServer.cpp
Implement the entirety of time services This reimplements our time backend to be significantly more accurate to the real PSC and provides complete implementations for every time IPC allowing many newer games to work properly. Time is unique in its use of glue services, the core sysmodule is fully isolated and doesn't interface with any other services. Glue is instead used where that is needed (e.g. for fetching settings), this distinction is also present in our implementation. Another unique feature of time is its global state, as time is calibrated from the start of the service its state cannot be lost as that would result in the application offsetting time incorrectly whenever it closed a session. A large proportion of this is based off of Thog's 9.0.0 PSC reversing.
2021-02-20 17:27:50 +03:00
${source_DIR}/skyline/services/timesrv/common.cpp
${source_DIR}/skyline/services/timesrv/core.cpp
${source_DIR}/skyline/services/timesrv/time_shared_memory.cpp
Implement full timezone service support This serves as an extension to the initial time commit and combined they provide a complete implementation of everything application facing in time. psc:ITimeZoneService and glue:ITimeZoneService are used to convert between POSIX and calendar times according to the device location. Timezone binaries are used during the conversion, details of them can be read about in the previous commit. This is based off my own glue RE and Thog's time RE.
2021-03-03 23:42:51 +03:00
${source_DIR}/skyline/services/timesrv/timezone_manager.cpp
Implement the entirety of time services This reimplements our time backend to be significantly more accurate to the real PSC and provides complete implementations for every time IPC allowing many newer games to work properly. Time is unique in its use of glue services, the core sysmodule is fully isolated and doesn't interface with any other services. Glue is instead used where that is needed (e.g. for fetching settings), this distinction is also present in our implementation. Another unique feature of time is its global state, as time is calibrated from the start of the service its state cannot be lost as that would result in the application offsetting time incorrectly whenever it closed a session. A large proportion of this is based off of Thog's 9.0.0 PSC reversing.
2021-02-20 17:27:50 +03:00
${source_DIR}/skyline/services/timesrv/time_manager_server.cpp
Refactor time services Use the new service naming convention. Split out each sub-service into it's own file. Fix some incorrect comments.
2020-02-16 21:42:38 +03:00
${source_DIR}/skyline/services/timesrv/IStaticService.cpp
${source_DIR}/skyline/services/timesrv/ISystemClock.cpp
Extend time services with support for the steady clock The steady clock has a fixed timepoint that can not change while an application is running.
2020-07-09 21:36:28 +03:00
${source_DIR}/skyline/services/timesrv/ISteadyClock.cpp
Refactor time services Use the new service naming convention. Split out each sub-service into it's own file. Fix some incorrect comments.
2020-02-16 21:42:38 +03:00
${source_DIR}/skyline/services/timesrv/ITimeZoneService.cpp
Implement the entirety of time services This reimplements our time backend to be significantly more accurate to the real PSC and provides complete implementations for every time IPC allowing many newer games to work properly. Time is unique in its use of glue services, the core sysmodule is fully isolated and doesn't interface with any other services. Glue is instead used where that is needed (e.g. for fetching settings), this distinction is also present in our implementation. Another unique feature of time is its global state, as time is calibrated from the start of the service its state cannot be lost as that would result in the application offsetting time incorrectly whenever it closed a session. A large proportion of this is based off of Thog's 9.0.0 PSC reversing.
2021-02-20 17:27:50 +03:00
${source_DIR}/skyline/services/glue/IStaticService.cpp
Implement full timezone service support This serves as an extension to the initial time commit and combined they provide a complete implementation of everything application facing in time. psc:ITimeZoneService and glue:ITimeZoneService are used to convert between POSIX and calendar times according to the device location. Timezone binaries are used during the conversion, details of them can be read about in the previous commit. This is based off my own glue RE and Thog's time RE.
2021-03-03 23:42:51 +03:00
${source_DIR}/skyline/services/glue/ITimeZoneService.cpp
Stub `ectx:w` and `ectx:aw` Glue services
2021-12-13 15:26:59 +03:00
${source_DIR}/skyline/services/glue/IWriterForSystem.cpp
Stub INotificationServicesForApplication
2023-01-09 15:36:32 +03:00
${source_DIR}/skyline/services/glue/INotificationServicesForApplication.cpp
Refactor filesystem services Use the new service naming convention.
2020-02-16 23:05:22 +03:00
${source_DIR}/skyline/services/fssrv/IFileSystemProxy.cpp
${source_DIR}/skyline/services/fssrv/IFileSystem.cpp
Initial Savedata Implementation (#75) * Rework VFS to support creating and writing files and introduce OsFileSystem OsFileSystem abstracts a directory on the device using the filesystem API. This also introduces GetEntryType and changes FileExists to use it. * Implement the Horizon FileSystem APIs using our VFS framework Horizon provides access to files through its IFileSystem class, we can closely map this to our vfs::FileSystem class. * Add support for creating application savedata This implements basic savedata creation using the OsFileSystem API. The data is stored in Skyline's private directory is stored in the same format as yuzu.
2020-08-08 22:38:51 +03:00
${source_DIR}/skyline/services/fssrv/IFile.cpp
Fixes for control IPC (#57) * Correctly handle -WithContext IPC Requests They should be treated the same as the non WithContext variants. * Only send domain data on non-control IPC responses Control IPC doesn't make use of domains so we shouldn't send extra data in the response. * Add the IStorage implementation to CMakeLists
2020-06-23 21:49:06 +03:00
${source_DIR}/skyline/services/fssrv/IStorage.cpp
Extend NvServices and implement IDirectory (#107) * Fix alignment handling in NvHostAsGpu::AllocSpace * Implement Ioctl{2,3} ioctls These were added in HOS 3.0.0 in order to ease handling ioctl buffers. * Introduce support for GPU address space remapping * Fix nvdrv and am service bugs Syncpoints are supposed to be allocated from ID 1, they were allocated at 0 before. The ioctl functions were also missing from the service map * Fix friend:u service name * Stub NVGPU_IOCTL_CHANNEL_SET_TIMESLICE * Stub IManagerForApplication::CheckAvailability * Add OsFileSystem Directory support and add a size field to directory entries The size field will be needed by the incoming HOS IDirectory support. * Implement support for IDirectory This is used by applications to list the contents of a directory. * Address feedback
2020-11-03 12:40:42 +03:00
${source_DIR}/skyline/services/fssrv/IDirectory.cpp
Refactor Display Services and GPU This commit addresses the incorrect hierarchy of the GPU and refactors them at the same time. Now, the hierarchy much closely matches HOS. This commit also introduces a texture classes, albeit they're not complete and only partially implemented.
2020-03-24 23:17:31 +03:00
${source_DIR}/skyline/services/nvdrv/INvDrvServices.cpp
Move NVDRV + IHOSBinder Internals to Discrete Components + Fix Lint
2020-09-14 17:13:36 +03:00
${source_DIR}/skyline/services/nvdrv/driver.cpp
Update CMakeLists for nvdrv rework
2021-07-17 19:48:59 +03:00
${source_DIR}/skyline/services/nvdrv/core/nvmap.cpp
${source_DIR}/skyline/services/nvdrv/core/syncpoint_manager.cpp
Improve NvDevice Registration + Access
2020-09-17 23:38:23 +03:00
${source_DIR}/skyline/services/nvdrv/devices/nvdevice.cpp
Refactor Display Services and GPU This commit addresses the incorrect hierarchy of the GPU and refactors them at the same time. Now, the hierarchy much closely matches HOS. This commit also introduces a texture classes, albeit they're not complete and only partially implemented.
2020-03-24 23:17:31 +03:00
${source_DIR}/skyline/services/nvdrv/devices/nvmap.cpp
Update CMakeLists for nvdrv rework
2021-07-17 19:48:59 +03:00
${source_DIR}/skyline/services/nvdrv/devices/nvhost/as_gpu.cpp
${source_DIR}/skyline/services/nvdrv/devices/nvhost/ctrl.cpp
${source_DIR}/skyline/services/nvdrv/devices/nvhost/ctrl_gpu.cpp
${source_DIR}/skyline/services/nvdrv/devices/nvhost/gpu_channel.cpp
Stub host1x channel devices and IOCTLs host1x channels are generally similar to GPU channels however there is only one channel for each specific class (like a GPU engine) and an address space is shared between them all. This PR implements the simple IOCTLs with the larger ones that will depend on changes outside of nvdrv being left for future commits. This is enough to partly run oss-nvjpeg.
2021-10-24 18:16:23 +03:00
${source_DIR}/skyline/services/nvdrv/devices/nvhost/host1x_channel.cpp
Rework VI + IHOSBinder VI/IHOSBinder suffered from major inaccuracies in their function due to being quickly thrown together initially with little concern for accuracy, this has now been fixed with them being substantially more accurate now.
2021-07-04 02:51:19 +03:00
${source_DIR}/skyline/services/hosbinder/parcel.cpp
Refactor Display Services and GPU This commit addresses the incorrect hierarchy of the GPU and refactors them at the same time. Now, the hierarchy much closely matches HOS. This commit also introduces a texture classes, albeit they're not complete and only partially implemented.
2020-03-24 23:17:31 +03:00
${source_DIR}/skyline/services/hosbinder/IHOSBinderDriver.cpp
Move NVDRV + IHOSBinder Internals to Discrete Components + Fix Lint
2020-09-14 17:13:36 +03:00
${source_DIR}/skyline/services/hosbinder/GraphicBufferProducer.cpp
Refactor Display Services and GPU This commit addresses the incorrect hierarchy of the GPU and refactors them at the same time. Now, the hierarchy much closely matches HOS. This commit also introduces a texture classes, albeit they're not complete and only partially implemented.
2020-03-24 23:17:31 +03:00
${source_DIR}/skyline/services/visrv/IDisplayService.cpp
${source_DIR}/skyline/services/visrv/IApplicationDisplayService.cpp
${source_DIR}/skyline/services/visrv/IManagerDisplayService.cpp
Rework VI + IHOSBinder VI/IHOSBinder suffered from major inaccuracies in their function due to being quickly thrown together initially with little concern for accuracy, this has now been fixed with them being substantially more accurate now.
2021-07-04 02:51:19 +03:00
${source_DIR}/skyline/services/visrv/IRootService.cpp
Refactor Display Services and GPU This commit addresses the incorrect hierarchy of the GPU and refactors them at the same time. Now, the hierarchy much closely matches HOS. This commit also introduces a texture classes, albeit they're not complete and only partially implemented.
2020-03-24 23:17:31 +03:00
${source_DIR}/skyline/services/visrv/ISystemDisplayService.cpp
Implement pl:u for accessing shared fonts Fonts are stored in an array of TTF data with an 8 byte header containing a magic and an XOR'd length. Instead of requiring users to provide original Nintendo fonts we pack open source replacements. They are generated with the scripts here https://github.com/FearlessTobi/yuzu_system_archives. All the fonts are licenced under the Open Font or Apache 2 License so we can include them all freely.
2020-07-04 23:52:07 +03:00
${source_DIR}/skyline/services/pl/IPlatformServiceManager.cpp
Add an empty aoc:u implementation This is required by Puyo Puyo Tetris, it will be extended in the future to allow using real DLC with the emulator.
2020-07-04 22:58:16 +03:00
${source_DIR}/skyline/services/aocsrv/IAddOnContentManager.cpp
Stub some IPurchaseEventManager functions
2022-12-30 20:00:03 +03:00
${source_DIR}/skyline/services/aocsrv/IPurchaseEventManager.cpp
Add an empty pctl implementation This is required by Puyo Puyo Tetris. It may be stubbed further if needed in the future.
2020-07-04 23:06:58 +03:00
${source_DIR}/skyline/services/pctl/IParentalControlServiceFactory.cpp
Extend parental control services
2020-07-08 13:59:02 +03:00
${source_DIR}/skyline/services/pctl/IParentalControlService.cpp
Implement log services (lm) lm is used by applications to print messages to the system log. Log messages are made up of a header and then several fields containing metadata or string messages.
2020-07-04 21:56:33 +03:00
${source_DIR}/skyline/services/lm/ILogService.cpp
${source_DIR}/skyline/services/lm/ILogger.cpp
Stub ldn:u service
2022-10-16 19:55:04 +03:00
${source_DIR}/skyline/services/ldn/IUserServiceCreator.cpp
${source_DIR}/skyline/services/ldn/IUserLocalCommunicationService.cpp
Add an empty account services implementation This implements the base account service and stubs InitializeApplicationInfoV0 which is used by Puyo Puyo Tetris. Support for the entirety of account services will be added in the future.
2020-07-04 22:35:07 +03:00
${source_DIR}/skyline/services/account/IAccountServiceForApplication.cpp
Extend account services to support BAAS and some user operations These are needed by Super Mario Odyssey and several other games.
2020-07-09 16:16:51 +03:00
${source_DIR}/skyline/services/account/IManagerForApplication.cpp
Add profile service to support custom usernames
2020-07-19 23:35:50 +03:00
${source_DIR}/skyline/services/account/IProfile.cpp
Add an empty friend service implementation This is used to access a users friends. It is used by Super Mario Odyssey.
2020-07-09 16:22:49 +03:00
${source_DIR}/skyline/services/friends/IServiceCreator.cpp
${source_DIR}/skyline/services/friends/IFriendService.cpp
Format code and misc cleanup
2020-08-09 17:02:38 +03:00
${source_DIR}/skyline/services/friends/INotificationService.cpp
Implement nfp services
2020-07-09 16:28:26 +03:00
${source_DIR}/skyline/services/nfp/IUserManager.cpp
${source_DIR}/skyline/services/nfp/IUser.cpp
Implement network interface services nifm:u is used by applications to enable a connection to the network.
2020-07-09 16:31:04 +03:00
${source_DIR}/skyline/services/nifm/IStaticService.cpp
${source_DIR}/skyline/services/nifm/IGeneralService.cpp
Add additional nifm stubs
2022-05-12 01:15:56 +03:00
${source_DIR}/skyline/services/nifm/IScanRequest.cpp
Implement network interface services nifm:u is used by applications to enable a connection to the network.
2020-07-09 16:31:04 +03:00
${source_DIR}/skyline/services/nifm/IRequest.cpp
Stub nim services used for eShop communication We obviously don't need to implement these so add a simple set of stubs to satify games using them (mainly demos such as DQXII)
2022-06-01 00:07:01 +03:00
${source_DIR}/skyline/services/nim/IShopServiceAccessor.cpp
${source_DIR}/skyline/services/nim/IShopServiceAccessServer.cpp
${source_DIR}/skyline/services/nim/IShopServiceAccessServerInterface.cpp
${source_DIR}/skyline/services/nim/IShopServiceAsync.cpp
Add a base socket (bsd) services implementation This stubs enough to pass SMO's socket init.
2020-07-09 16:35:51 +03:00
${source_DIR}/skyline/services/socket/bsd/IClient.cpp
Stub nsd:u/nsd:a and sfdnsres services
2022-10-31 18:38:46 +03:00
${source_DIR}/skyline/services/socket/nsd/IManager.cpp
${source_DIR}/skyline/services/socket/sfdnsres/IResolver.cpp
csrng service implementation Implements the 'csrng:' service using C++ <random>'s Mersenne Twister, this does make it insecure for cryptographic purposes but it is pointless to attempt to do this regardless as we cannot ensure that the guest will run in a secure environment which cannot be mutated by an attacker. Used by Prison Princess, Pokemon Cafe Mix, Paint your Pet and more.
2021-08-16 11:10:07 +03:00
${source_DIR}/skyline/services/spl/IRandomInterface.cpp
Add an empty ssl service implementation This stubs a single function that is needed for SMO's init.
2020-07-09 16:38:18 +03:00
${source_DIR}/skyline/services/ssl/ISslService.cpp
Format code and misc cleanup
2020-08-09 17:02:38 +03:00
${source_DIR}/skyline/services/ssl/ISslContext.cpp
Stub play reporting services
2020-07-09 16:41:30 +03:00
${source_DIR}/skyline/services/prepo/IPrepoService.cpp
Implement mmnv::IRequest for media module clock control This is used by games before calling into nvdec in order to clock up the HW module, it can also be used to request a RAM frequency. Since we obviously don't emulate the hardware down to this level a basic stub that provides the correct reponses is enough. Fixes a crash on first level of Super Mario Odyssey.
2021-05-30 20:08:18 +03:00
${source_DIR}/skyline/services/mmnv/IRequest.cpp
Stub mii:e/mii:u Needed for SSBU
2022-11-30 19:57:52 +03:00
${source_DIR}/skyline/services/mii/IStaticService.cpp
${source_DIR}/skyline/services/mii/IDatabaseService.cpp
Rewrite C++ parts and UI update This update took way way too long to create. However, it was worthwhile. :)
2019-07-24 23:19:43 +03:00
)
Introduce Boost as a submodule + Minor Fixes Utilize Boost Container's `small_vector` for optimizing allocations, fix certain implicit casting issues and make `ILogger` not output an additional newline in the log when the application supplies one at the end of the log
2021-08-20 22:57:22 +03:00
target_include_directories(skyline PRIVATE ${source_DIR}/skyline)
Fix Logger Settings + Use Java 8 + Update Kotlin + Extract Native SOs
2021-02-08 07:17:17 +03:00
# target_precompile_headers(skyline PRIVATE ${source_DIR}/skyline/common.h) # PCH will currently break Intellisense
Add `-fsigned-bitfields` for defined bitfield `int` behavior We want consistent behavior between signed `int`s in bitfields and outside of bitfields, the `-fsigned-bitfields` flag enforces this behavior.
2021-12-28 10:04:06 +03:00
target_compile_options(skyline PRIVATE -Wall -Wno-unknown-attributes -Wno-c++20-extensions -Wno-c++17-extensions -Wno-c99-designator -Wno-reorder -Wno-missing-braces -Wno-unused-variable -Wno-unused-private-field -Wno-dangling-else -Wconversion -fsigned-bitfields)
Silence errors from libraries Library headers would produce errors that are out of our control and as a result of that, we just want to ignore this. This is possible by including the offending headers as system headers, compilers don't emit any warnings arising from them. This was extended to all libraries rather than just those which currently emitted warnings for consistency's sake.
2021-10-26 16:35:16 +03:00
Reimplement audout and audren using yuzu audio_core The yuzu audio_core code is mostly untouched, with a set of wrappers used to bridge it with skyline kernel primitives. Huge thanks to maide and their advice, whom without this wouldn't have been possible.
2023-03-15 20:49:17 +03:00
target_link_libraries(skyline PRIVATE shader_recompiler audio_core)
target_link_libraries_system(skyline android perfetto fmt lz4_static tzcode vkma mbedcrypto opus Boost::intrusive Boost::container range-v3 adrenotools tsl::robin_map)
Reference in New Issue Copy Permalink