hdkv/yuzu
1
Fork 0
Code Issues Pull Requests Releases 1 Activity

early-access version 1890

Browse Source
This commit is contained in:
pineappleEA 2021-07-19 05:44:59 +02:00
parent 8cde2bad21
commit 0a6abc3bd0
9 changed files with 57 additions and 81 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
README.md
View File

@ -1,7 +1,7 @@
yuzu emulator early access yuzu emulator early access
============= =============
This is the source code for early-access 1888. This is the source code for early-access 1890.
## Legal Notice ## Legal Notice

10
src/common/CMakeLists.txt
View File

@ -1,8 +1,3 @@
# 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{AZURECIREPO}) if (DEFINED ENV{AZURECIREPO})
set(BUILD_REPOSITORY $ENV{AZURECIREPO}) set(BUILD_REPOSITORY $ENV{AZURECIREPO})
endif() endif()
@ -30,10 +25,7 @@ add_custom_command(OUTPUT scm_rev.cpp
-DGIT_EXECUTABLE=${GIT_EXECUTABLE} -DGIT_EXECUTABLE=${GIT_EXECUTABLE}
-P ${CMAKE_SOURCE_DIR}/CMakeModules/GenerateSCMRev.cmake -P ${CMAKE_SOURCE_DIR}/CMakeModules/GenerateSCMRev.cmake
DEPENDS DEPENDS
# WARNING! It was too much work to try and make a common location for this list, # Check that the scm_rev files haven't changed
# so if you need to change it, please update CMakeModules/GenerateSCMRev.cmake as well
# ...
# 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.cpp.in"
"${CMAKE_CURRENT_SOURCE_DIR}/scm_rev.h" "${CMAKE_CURRENT_SOURCE_DIR}/scm_rev.h"
# technically we should regenerate if the git version changed, but its not worth the effort imo # technically we should regenerate if the git version changed, but its not worth the effort imo

2
src/common/scm_rev.cpp.in
View File

@ -14,7 +14,6 @@
#define BUILD_ID "@BUILD_ID@" #define BUILD_ID "@BUILD_ID@"
#define TITLE_BAR_FORMAT_IDLE "@TITLE_BAR_FORMAT_IDLE@" #define TITLE_BAR_FORMAT_IDLE "@TITLE_BAR_FORMAT_IDLE@"
#define TITLE_BAR_FORMAT_RUNNING "@TITLE_BAR_FORMAT_RUNNING@" #define TITLE_BAR_FORMAT_RUNNING "@TITLE_BAR_FORMAT_RUNNING@"
#define SHADER_CACHE_VERSION "@SHADER_CACHE_VERSION@"
namespace Common { namespace Common {
@ -28,7 +27,6 @@ const char g_build_version[] = BUILD_VERSION;
const char g_build_id[] = BUILD_ID; const char g_build_id[] = BUILD_ID;
const char g_title_bar_format_idle[] = TITLE_BAR_FORMAT_IDLE; const char g_title_bar_format_idle[] = TITLE_BAR_FORMAT_IDLE;
const char g_title_bar_format_running[] = TITLE_BAR_FORMAT_RUNNING; const char g_title_bar_format_running[] = TITLE_BAR_FORMAT_RUNNING;
const char g_shader_cache_version[] = SHADER_CACHE_VERSION;
} // namespace } // namespace

1
src/core/reporter.cpp
View File

@ -62,7 +62,6 @@ json GetYuzuVersionData() {
{"build_date", std::string(Common::g_build_date)}, {"build_date", std::string(Common::g_build_date)},
{"build_fullname", std::string(Common::g_build_fullname)}, {"build_fullname", std::string(Common::g_build_fullname)},
{"build_version", std::string(Common::g_build_version)}, {"build_version", std::string(Common::g_build_version)},
{"shader_cache_version", std::string(Common::g_shader_cache_version)},
}; };
} }

10
src/video_core/renderer_opengl/gl_shader_cache.cpp
View File

@ -48,9 +48,12 @@ using VideoCommon::ComputeEnvironment;
using VideoCommon::FileEnvironment; using VideoCommon::FileEnvironment;
using VideoCommon::GenericEnvironment; using VideoCommon::GenericEnvironment;
using VideoCommon::GraphicsEnvironment; using VideoCommon::GraphicsEnvironment;
using VideoCommon::LoadPipelines;
using VideoCommon::SerializePipeline; using VideoCommon::SerializePipeline;
using Context = ShaderContext::Context; using Context = ShaderContext::Context;
constexpr u32 CACHE_VERSION = 5;
template <typename Container> template <typename Container>
auto MakeSpan(Container& container) { auto MakeSpan(Container& container) {
return std::span(container.data(), container.size()); return std::span(container.data(), container.size());
@ -287,7 +290,7 @@ void ShaderCache::LoadDiskResources(u64 title_id, std::stop_token stop_loading,
}); });
++state.total; ++state.total;
}}; }};
VideoCommon::LoadPipelines(stop_loading, shader_cache_filename, load_compute, load_graphics); LoadPipelines(stop_loading, shader_cache_filename, CACHE_VERSION, load_compute, load_graphics);
std::unique_lock lock{state.mutex}; std::unique_lock lock{state.mutex};
callback(VideoCore::LoadCallbackStage::Build, 0, state.total); callback(VideoCore::LoadCallbackStage::Build, 0, state.total);
@ -394,7 +397,7 @@ std::unique_ptr<GraphicsPipeline> ShaderCache::CreateGraphicsPipeline() {
env_ptrs.push_back(&environments.envs[index]); env_ptrs.push_back(&environments.envs[index]);
} }
} }
SerializePipeline(graphics_key, env_ptrs, shader_cache_filename); SerializePipeline(graphics_key, env_ptrs, shader_cache_filename, CACHE_VERSION);
return pipeline; return pipeline;
} }
@ -492,7 +495,8 @@ std::unique_ptr<ComputePipeline> ShaderCache::CreateComputePipeline(
if (!pipeline || shader_cache_filename.empty()) { if (!pipeline || shader_cache_filename.empty()) {
return pipeline; return pipeline;
} }
SerializePipeline(key, std::array<const GenericEnvironment*, 1>{&env}, shader_cache_filename); SerializePipeline(key, std::array<const GenericEnvironment*, 1>{&env}, shader_cache_filename,
CACHE_VERSION);
return pipeline; return pipeline;
} }

9
src/video_core/renderer_vulkan/vk_pipeline_cache.cpp
View File

@ -54,6 +54,8 @@ using VideoCommon::FileEnvironment;
using VideoCommon::GenericEnvironment; using VideoCommon::GenericEnvironment;
using VideoCommon::GraphicsEnvironment; using VideoCommon::GraphicsEnvironment;
constexpr u32 CACHE_VERSION = 5;
template <typename Container> template <typename Container>
auto MakeSpan(Container& container) { auto MakeSpan(Container& container) {
return std::span(container.data(), container.size()); return std::span(container.data(), container.size());
@ -434,7 +436,8 @@ void PipelineCache::LoadDiskResources(u64 title_id, std::stop_token stop_loading
}); });
++state.total; ++state.total;
}}; }};
VideoCommon::LoadPipelines(stop_loading, pipeline_cache_filename, load_compute, load_graphics); VideoCommon::LoadPipelines(stop_loading, pipeline_cache_filename, CACHE_VERSION, load_compute,
load_graphics);
std::unique_lock lock{state.mutex}; std::unique_lock lock{state.mutex};
callback(VideoCore::LoadCallbackStage::Build, 0, state.total); callback(VideoCore::LoadCallbackStage::Build, 0, state.total);
@ -562,7 +565,7 @@ std::unique_ptr<GraphicsPipeline> PipelineCache::CreateGraphicsPipeline() {
env_ptrs.push_back(&envs[index]); env_ptrs.push_back(&envs[index]);
} }
} }
SerializePipeline(key, env_ptrs, pipeline_cache_filename); SerializePipeline(key, env_ptrs, pipeline_cache_filename, CACHE_VERSION);
}); });
return pipeline; return pipeline;
} }
@ -581,7 +584,7 @@ std::unique_ptr<ComputePipeline> PipelineCache::CreateComputePipeline(
} }
serialization_thread.QueueWork([this, key, env = std::move(env)] { serialization_thread.QueueWork([this, key, env = std::move(env)] {
SerializePipeline(key, std::array<const GenericEnvironment*, 1>{&env}, SerializePipeline(key, std::array<const GenericEnvironment*, 1>{&env},
pipeline_cache_filename); pipeline_cache_filename, CACHE_VERSION);
}); });
return pipeline; return pipeline;
} }

11
src/video_core/shader_environment.cpp
View File

@ -22,7 +22,6 @@
namespace VideoCommon { namespace VideoCommon {
constexpr std::array<char, 8> MAGIC_NUMBER{'y', 'u', 'z', 'u', 'c', 'a', 'c', 'h'}; constexpr std::array<char, 8> MAGIC_NUMBER{'y', 'u', 'z', 'u', 'c', 'a', 'c', 'h'};
constexpr u32 CACHE_VERSION = 5;
constexpr size_t INST_SIZE = sizeof(u64); constexpr size_t INST_SIZE = sizeof(u64);
@ -370,7 +369,7 @@ std::array<u32, 3> FileEnvironment::WorkgroupSize() const {
} }
void SerializePipeline(std::span<const char> key, std::span<const GenericEnvironment* const> envs, void SerializePipeline(std::span<const char> key, std::span<const GenericEnvironment* const> envs,
const std::filesystem::path& filename) try { const std::filesystem::path& filename, u32 cache_version) try {
std::ofstream file(filename, std::ios::binary | std::ios::ate | std::ios::app); std::ofstream file(filename, std::ios::binary | std::ios::ate | std::ios::app);
file.exceptions(std::ifstream::failbit); file.exceptions(std::ifstream::failbit);
if (!file.is_open()) { if (!file.is_open()) {
@ -381,7 +380,7 @@ void SerializePipeline(std::span<const char> key, std::span<const GenericEnviron
if (file.tellp() == 0) { if (file.tellp() == 0) {
// Write header // Write header
file.write(MAGIC_NUMBER.data(), MAGIC_NUMBER.size()) file.write(MAGIC_NUMBER.data(), MAGIC_NUMBER.size())
.write(reinterpret_cast<const char*>(&CACHE_VERSION), sizeof(CACHE_VERSION)); .write(reinterpret_cast<const char*>(&cache_version), sizeof(cache_version));
} }
if (!std::ranges::all_of(envs, &GenericEnvironment::CanBeSerialized)) { if (!std::ranges::all_of(envs, &GenericEnvironment::CanBeSerialized)) {
return; return;
@ -402,7 +401,7 @@ void SerializePipeline(std::span<const char> key, std::span<const GenericEnviron
} }
void LoadPipelines( void LoadPipelines(
std::stop_token stop_loading, const std::filesystem::path& filename, std::stop_token stop_loading, const std::filesystem::path& filename, u32 expected_cache_version,
Common::UniqueFunction<void, std::ifstream&, FileEnvironment> load_compute, Common::UniqueFunction<void, std::ifstream&, FileEnvironment> load_compute,
Common::UniqueFunction<void, std::ifstream&, std::vector<FileEnvironment>> load_graphics) try { Common::UniqueFunction<void, std::ifstream&, std::vector<FileEnvironment>> load_graphics) try {
std::ifstream file(filename, std::ios::binary | std::ios::ate); std::ifstream file(filename, std::ios::binary | std::ios::ate);
@ -417,13 +416,13 @@ void LoadPipelines(
u32 cache_version; u32 cache_version;
file.read(magic_number.data(), magic_number.size()) file.read(magic_number.data(), magic_number.size())
.read(reinterpret_cast<char*>(&cache_version), sizeof(cache_version)); .read(reinterpret_cast<char*>(&cache_version), sizeof(cache_version));
if (magic_number != MAGIC_NUMBER || cache_version != CACHE_VERSION) { if (magic_number != MAGIC_NUMBER || cache_version != expected_cache_version) {
file.close(); file.close();
if (Common::FS::RemoveFile(filename)) { if (Common::FS::RemoveFile(filename)) {
if (magic_number != MAGIC_NUMBER) { if (magic_number != MAGIC_NUMBER) {
LOG_ERROR(Common_Filesystem, "Invalid pipeline cache file"); LOG_ERROR(Common_Filesystem, "Invalid pipeline cache file");
} }
if (cache_version != CACHE_VERSION) { if (cache_version != expected_cache_version) {
LOG_INFO(Common_Filesystem, "Deleting old pipeline cache"); LOG_INFO(Common_Filesystem, "Deleting old pipeline cache");
} }
} else { } else {

9
src/video_core/shader_environment.h
View File

@ -164,18 +164,19 @@ private:
}; };
void SerializePipeline(std::span<const char> key, std::span<const GenericEnvironment* const> envs, void SerializePipeline(std::span<const char> key, std::span<const GenericEnvironment* const> envs,
const std::filesystem::path& filename); const std::filesystem::path& filename, u32 cache_version);
template <typename Key, typename Envs> template <typename Key, typename Envs>
void SerializePipeline(const Key& key, const Envs& envs, const std::filesystem::path& filename) { void SerializePipeline(const Key& key, const Envs& envs, const std::filesystem::path& filename,
u32 cache_version) {
static_assert(std::is_trivially_copyable_v<Key>); static_assert(std::is_trivially_copyable_v<Key>);
static_assert(std::has_unique_object_representations_v<Key>); static_assert(std::has_unique_object_representations_v<Key>);
SerializePipeline(std::span(reinterpret_cast<const char*>(&key), sizeof(key)), SerializePipeline(std::span(reinterpret_cast<const char*>(&key), sizeof(key)),
std::span(envs.data(), envs.size()), filename); std::span(envs.data(), envs.size()), filename, cache_version);
} }
void LoadPipelines( void LoadPipelines(
std::stop_token stop_loading, const std::filesystem::path& filename, std::stop_token stop_loading, const std::filesystem::path& filename, u32 expected_cache_version,
Common::UniqueFunction<void, std::ifstream&, FileEnvironment> load_compute, Common::UniqueFunction<void, std::ifstream&, FileEnvironment> load_compute,
Common::UniqueFunction<void, std::ifstream&, std::vector<FileEnvironment>> load_graphics); Common::UniqueFunction<void, std::ifstream&, std::vector<FileEnvironment>> load_graphics);

84
src/video_core/texture_cache/util.cpp
View File

@ -169,23 +169,6 @@ template <u32 GOB_EXTENT>
return Common::DivCeil(AdjustMipSize(size, level), block_size); return Common::DivCeil(AdjustMipSize(size, level), block_size);
} }
[[nodiscard]] constexpr std::pair<int, int> Samples(int num_samples) {
switch (num_samples) {
case 1:
return {1, 1};
case 2:
return {2, 1};
case 4:
return {2, 2};
case 8:
return {4, 2};
case 16:
return {4, 4};
}
UNREACHABLE_MSG("Invalid number of samples={}", num_samples);
return {1, 1};
}
[[nodiscard]] constexpr Extent2D DefaultBlockSize(PixelFormat format) { [[nodiscard]] constexpr Extent2D DefaultBlockSize(PixelFormat format) {
return {DefaultBlockWidth(format), DefaultBlockHeight(format)}; return {DefaultBlockWidth(format), DefaultBlockHeight(format)};
} }
@ -283,14 +266,13 @@ template <u32 GOB_EXTENT>
} }
[[nodiscard]] constexpr LevelInfo MakeLevelInfo(PixelFormat format, Extent3D size, Extent3D block, [[nodiscard]] constexpr LevelInfo MakeLevelInfo(PixelFormat format, Extent3D size, Extent3D block,
u32 num_samples, u32 tile_width_spacing) { u32 tile_width_spacing) {
const auto [samples_x, samples_y] = Samples(num_samples);
const u32 bytes_per_block = BytesPerBlock(format); const u32 bytes_per_block = BytesPerBlock(format);
return { return {
.size = .size =
{ {
.width = size.width * samples_x, .width = size.width,
.height = size.height * samples_y, .height = size.height,
.depth = size.depth, .depth = size.depth,
}, },
.block = block, .block = block,
@ -301,14 +283,12 @@ template <u32 GOB_EXTENT>
} }
[[nodiscard]] constexpr LevelInfo MakeLevelInfo(const ImageInfo& info) { [[nodiscard]] constexpr LevelInfo MakeLevelInfo(const ImageInfo& info) {
return MakeLevelInfo(info.format, info.size, info.block, info.num_samples, return MakeLevelInfo(info.format, info.size, info.block, info.tile_width_spacing);
info.tile_width_spacing);
} }
[[nodiscard]] constexpr u32 CalculateLevelOffset(PixelFormat format, Extent3D size, Extent3D block, [[nodiscard]] constexpr u32 CalculateLevelOffset(PixelFormat format, Extent3D size, Extent3D block,
u32 num_samples, u32 tile_width_spacing, u32 tile_width_spacing, u32 level) {
u32 level) { const LevelInfo info = MakeLevelInfo(format, size, block, tile_width_spacing);
const LevelInfo info = MakeLevelInfo(format, size, block, num_samples, tile_width_spacing);
u32 offset = 0; u32 offset = 0;
for (u32 current_level = 0; current_level < level; ++current_level) { for (u32 current_level = 0; current_level < level; ++current_level) {
offset += CalculateLevelSize(info, current_level); offset += CalculateLevelSize(info, current_level);
@ -645,8 +625,8 @@ u32 CalculateLayerStride(const ImageInfo& info) noexcept {
u32 CalculateLayerSize(const ImageInfo& info) noexcept { u32 CalculateLayerSize(const ImageInfo& info) noexcept {
ASSERT(info.type != ImageType::Linear); ASSERT(info.type != ImageType::Linear);
return CalculateLevelOffset(info.format, info.size, info.block, info.num_samples, return CalculateLevelOffset(info.format, info.size, info.block, info.tile_width_spacing,
info.tile_width_spacing, info.resources.levels); info.resources.levels);
} }
LevelArray CalculateMipLevelOffsets(const ImageInfo& info) noexcept { LevelArray CalculateMipLevelOffsets(const ImageInfo& info) noexcept {
@ -1195,37 +1175,37 @@ static_assert(CalculateLevelSize(LevelInfo{{1920, 1080, 1}, {0, 2, 0}, {1, 1}, 2
0x7f8000); 0x7f8000);
static_assert(CalculateLevelSize(LevelInfo{{32, 32, 1}, {0, 0, 4}, {1, 1}, 4, 0}, 0) == 0x4000); static_assert(CalculateLevelSize(LevelInfo{{32, 32, 1}, {0, 0, 4}, {1, 1}, 4, 0}, 0) == 0x4000);
static_assert(CalculateLevelOffset(PixelFormat::R8_SINT, {1920, 1080, 1}, {0, 2, 0}, 1, 0, 7) == static_assert(CalculateLevelOffset(PixelFormat::R8_SINT, {1920, 1080, 1}, {0, 2, 0}, 0, 7) ==
0x2afc00); 0x2afc00);
static_assert(CalculateLevelOffset(PixelFormat::ASTC_2D_12X12_UNORM, {8192, 4096, 1}, {0, 2, 0}, 1, static_assert(CalculateLevelOffset(PixelFormat::ASTC_2D_12X12_UNORM, {8192, 4096, 1}, {0, 2, 0}, 0,
0, 12) == 0x50d200); 12) == 0x50d200);
static_assert(CalculateLevelOffset(PixelFormat::A8B8G8R8_UNORM, {1024, 1024, 1}, {0, 4, 0}, 1, 0, static_assert(CalculateLevelOffset(PixelFormat::A8B8G8R8_UNORM, {1024, 1024, 1}, {0, 4, 0}, 0, 0) ==
0) == 0); 0);
static_assert(CalculateLevelOffset(PixelFormat::A8B8G8R8_UNORM, {1024, 1024, 1}, {0, 4, 0}, 1, 0, static_assert(CalculateLevelOffset(PixelFormat::A8B8G8R8_UNORM, {1024, 1024, 1}, {0, 4, 0}, 0, 1) ==
1) == 0x400000); 0x400000);
static_assert(CalculateLevelOffset(PixelFormat::A8B8G8R8_UNORM, {1024, 1024, 1}, {0, 4, 0}, 1, 0, static_assert(CalculateLevelOffset(PixelFormat::A8B8G8R8_UNORM, {1024, 1024, 1}, {0, 4, 0}, 0, 2) ==
2) == 0x500000); 0x500000);
static_assert(CalculateLevelOffset(PixelFormat::A8B8G8R8_UNORM, {1024, 1024, 1}, {0, 4, 0}, 1, 0, static_assert(CalculateLevelOffset(PixelFormat::A8B8G8R8_UNORM, {1024, 1024, 1}, {0, 4, 0}, 0, 3) ==
3) == 0x540000); 0x540000);
static_assert(CalculateLevelOffset(PixelFormat::A8B8G8R8_UNORM, {1024, 1024, 1}, {0, 4, 0}, 1, 0, static_assert(CalculateLevelOffset(PixelFormat::A8B8G8R8_UNORM, {1024, 1024, 1}, {0, 4, 0}, 0, 4) ==
4) == 0x550000); 0x550000);
static_assert(CalculateLevelOffset(PixelFormat::A8B8G8R8_UNORM, {1024, 1024, 1}, {0, 4, 0}, 1, 0, static_assert(CalculateLevelOffset(PixelFormat::A8B8G8R8_UNORM, {1024, 1024, 1}, {0, 4, 0}, 0, 5) ==
5) == 0x554000); 0x554000);
static_assert(CalculateLevelOffset(PixelFormat::A8B8G8R8_UNORM, {1024, 1024, 1}, {0, 4, 0}, 1, 0, static_assert(CalculateLevelOffset(PixelFormat::A8B8G8R8_UNORM, {1024, 1024, 1}, {0, 4, 0}, 0, 6) ==
6) == 0x555000); 0x555000);
static_assert(CalculateLevelOffset(PixelFormat::A8B8G8R8_UNORM, {1024, 1024, 1}, {0, 4, 0}, 1, 0, static_assert(CalculateLevelOffset(PixelFormat::A8B8G8R8_UNORM, {1024, 1024, 1}, {0, 4, 0}, 0, 7) ==
7) == 0x555400); 0x555400);
static_assert(CalculateLevelOffset(PixelFormat::A8B8G8R8_UNORM, {1024, 1024, 1}, {0, 4, 0}, 1, 0, static_assert(CalculateLevelOffset(PixelFormat::A8B8G8R8_UNORM, {1024, 1024, 1}, {0, 4, 0}, 0, 8) ==
8) == 0x555600); 0x555600);
static_assert(CalculateLevelOffset(PixelFormat::A8B8G8R8_UNORM, {1024, 1024, 1}, {0, 4, 0}, 1, 0, static_assert(CalculateLevelOffset(PixelFormat::A8B8G8R8_UNORM, {1024, 1024, 1}, {0, 4, 0}, 0, 9) ==
9) == 0x555800); 0x555800);
constexpr u32 ValidateLayerSize(PixelFormat format, u32 width, u32 height, u32 block_height, constexpr u32 ValidateLayerSize(PixelFormat format, u32 width, u32 height, u32 block_height,
u32 tile_width_spacing, u32 level) { u32 tile_width_spacing, u32 level) {
const Extent3D size{width, height, 1}; const Extent3D size{width, height, 1};
const Extent3D block{0, block_height, 0}; const Extent3D block{0, block_height, 0};
const u32 offset = CalculateLevelOffset(format, size, block, 1, tile_width_spacing, level); const u32 offset = CalculateLevelOffset(format, size, block, tile_width_spacing, level);
return AlignLayerSize(offset, size, block, DefaultBlockHeight(format), tile_width_spacing); return AlignLayerSize(offset, size, block, DefaultBlockHeight(format), tile_width_spacing);
} }