diff --git a/.patch/vulkan-memory-allocator/0001-macos-clang.patch b/.patch/vulkan-memory-allocator/0001-macos-clang.patch new file mode 100644 index 0000000000..e965292f6f --- /dev/null +++ b/.patch/vulkan-memory-allocator/0001-macos-clang.patch @@ -0,0 +1,112 @@ +diff --git a/include/vk_mem_alloc.h b/include/vk_mem_alloc.h +index 8df0364..4856064 100644 +--- a/include/vk_mem_alloc.h ++++ b/include/vk_mem_alloc.h +@@ -3017,7 +3017,7 @@ remove them if not needed. + + #if defined(__ANDROID_API__) && (__ANDROID_API__ < 16) + #include +-static void* vma_aligned_alloc(size_t alignment, size_t size) ++static inline void* vma_aligned_alloc(size_t alignment, size_t size) + { + // alignment must be >= sizeof(void*) + if(alignment < sizeof(void*)) +@@ -3860,7 +3860,7 @@ Returned value is the found element, if present in the collection or place where + new element with value (key) should be inserted. + */ + template +-static IterT VmaBinaryFindFirstNotLess(IterT beg, IterT end, const KeyT& key, const CmpLess& cmp) ++static inline IterT VmaBinaryFindFirstNotLess(IterT beg, IterT end, const KeyT& key, const CmpLess& cmp) + { + size_t down = 0; + size_t up = size_t(end - beg); +@@ -3898,7 +3898,7 @@ Warning! O(n^2) complexity. Use only inside VMA_HEAVY_ASSERT. + T must be pointer type, e.g. VmaAllocation, VmaPool. + */ + template +-static bool VmaValidatePointerArray(uint32_t count, const T* arr) ++static inline bool VmaValidatePointerArray(uint32_t count, const T* arr) + { + for (uint32_t i = 0; i < count; ++i) + { +@@ -4188,13 +4188,13 @@ static void VmaFree(const VkAllocationCallbacks* pAllocationCallbacks, void* ptr + } + + template +-static T* VmaAllocate(const VkAllocationCallbacks* pAllocationCallbacks) ++static inline T* VmaAllocate(const VkAllocationCallbacks* pAllocationCallbacks) + { + return (T*)VmaMalloc(pAllocationCallbacks, sizeof(T), VMA_ALIGN_OF(T)); + } + + template +-static T* VmaAllocateArray(const VkAllocationCallbacks* pAllocationCallbacks, size_t count) ++static inline T* VmaAllocateArray(const VkAllocationCallbacks* pAllocationCallbacks, size_t count) + { + return (T*)VmaMalloc(pAllocationCallbacks, sizeof(T) * count, VMA_ALIGN_OF(T)); + } +@@ -4204,14 +4204,14 @@ static T* VmaAllocateArray(const VkAllocationCallbacks* pAllocationCallbacks, si + #define vma_new_array(allocator, type, count) new(VmaAllocateArray((allocator), (count)))(type) + + template +-static void vma_delete(const VkAllocationCallbacks* pAllocationCallbacks, T* ptr) ++static inline void vma_delete(const VkAllocationCallbacks* pAllocationCallbacks, T* ptr) + { + ptr->~T(); + VmaFree(pAllocationCallbacks, ptr); + } + + template +-static void vma_delete_array(const VkAllocationCallbacks* pAllocationCallbacks, T* ptr, size_t count) ++static inline void vma_delete_array(const VkAllocationCallbacks* pAllocationCallbacks, T* ptr, size_t count) + { + if (ptr != VMA_NULL) + { +@@ -4658,13 +4658,13 @@ void VmaVector::remove(size_t index) + #endif // _VMA_VECTOR_FUNCTIONS + + template +-static void VmaVectorInsert(VmaVector& vec, size_t index, const T& item) ++static inline void VmaVectorInsert(VmaVector& vec, size_t index, const T& item) + { + vec.insert(index, item); + } + + template +-static void VmaVectorRemove(VmaVector& vec, size_t index) ++static inline void VmaVectorRemove(VmaVector& vec, size_t index) + { + vec.remove(index); + } +@@ -10620,19 +10620,19 @@ static void VmaFree(VmaAllocator hAllocator, void* ptr) + } + + template +-static T* VmaAllocate(VmaAllocator hAllocator) ++static inline T* VmaAllocate(VmaAllocator hAllocator) + { + return (T*)VmaMalloc(hAllocator, sizeof(T), VMA_ALIGN_OF(T)); + } + + template +-static T* VmaAllocateArray(VmaAllocator hAllocator, size_t count) ++static inline T* VmaAllocateArray(VmaAllocator hAllocator, size_t count) + { + return (T*)VmaMalloc(hAllocator, sizeof(T) * count, VMA_ALIGN_OF(T)); + } + + template +-static void vma_delete(VmaAllocator hAllocator, T* ptr) ++static inline void vma_delete(VmaAllocator hAllocator, T* ptr) + { + if(ptr != VMA_NULL) + { +@@ -10642,7 +10642,7 @@ static void vma_delete(VmaAllocator hAllocator, T* ptr) + } + + template +-static void vma_delete_array(VmaAllocator hAllocator, T* ptr, size_t count) ++static inline void vma_delete_array(VmaAllocator hAllocator, T* ptr, size_t count) + { + if(ptr != VMA_NULL) + { diff --git a/CMakeLists.txt b/CMakeLists.txt index 310237bc59..8b068b85b4 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -3,6 +3,7 @@ cmake_minimum_required(VERSION 3.31) +set(CMAKE_OSX_DEPLOYMENT_TARGET "15.0" CACHE STRING "macOS deployment target") project(yuzu) list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/CMakeModules") @@ -512,7 +513,7 @@ endfunction() # ============================================= if (APPLE) - foreach(fw Carbon Metal Cocoa IOKit CoreVideo CoreMedia Security UniformTypeIdentifiers) + foreach(fw Carbon Metal Cocoa IOKit CoreVideo CoreMedia Security UniformTypeIdentifiers Foundation) find_library(${fw}_LIBRARY ${fw} REQUIRED) list(APPEND PLATFORM_LIBRARIES ${${fw}_LIBRARY}) endforeach() diff --git a/cpmfile.json b/cpmfile.json index c5ea35c955..af773e0bd0 100644 --- a/cpmfile.json +++ b/cpmfile.json @@ -1,12 +1,4 @@ { - "": { - "ci": true, - "hash": "9f50d993c39529e022ad456163de91ac5934e16faf8fc348f305355fc0a643c534f87ded707e11bd03bcbc0a1760bd20852b6533a67ac0558a078385181cb184", - "name": "SDL3", - "package": "SDL3", - "repo": "crueter-ci/SDL3", - "version": "3.4.14-1788231389-147a8ee32d" - }, "biscuit": { "hash": "1229f345b014f7ca544dedb4edb3311e41ba736f9aa9a67f88b5f26f3c983288c6bb6cdedcfb0b8a02c63088a37e6a0d7ba97d9c2a4d721b213916327cffe28a", "min_version": "0.9.1", @@ -68,10 +60,10 @@ }, "discord-rpc": { "find_args": "MODULE", - "hash": "8213c43dcb0f7d479f5861091d111ed12fbdec1e62e6d729d65a4bc181d82f48a35d5fd3cd5c291f2393ac7c9681eabc6b76609755f55376284c8a8d67e148f3", + "hash": "8d680b3a16d6f6bf292ad823cf8635595ff986f2a49f758e3009f505b540a9d75194a8cf44cddea75736a8c3e3b5160166e716a0939ce3f18cc463cf648753fe", "package": "DiscordRPC", "repo": "eden-emulator/discord-rpc", - "version": "0d8b2d6a37" + "version": "76616d8675" }, "enet": { "find_args": "MODULE", @@ -311,6 +303,9 @@ "find_args": "CONFIG", "hash": "deb5902ef8db0e329fbd5f3f4385eb0e26bdd9f14f3a2334823fb3fe18f36bc5d235d620d6e5f6fe3551ec3ea7038638899db8778c09f6d5c278f5ff95c3344b", "package": "VulkanMemoryAllocator", + "patches": [ + "0001-macos-clang.patch" + ], "repo": "GPUOpen-LibrariesAndSDKs/VulkanMemoryAllocator", "version": "v3.3.0" }, diff --git a/src/common/scratch_buffer.h b/src/common/scratch_buffer.h index 2a98cda539..8c1f566301 100644 --- a/src/common/scratch_buffer.h +++ b/src/common/scratch_buffer.h @@ -1,9 +1,13 @@ +// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project +// SPDX-License-Identifier: GPL-3.0-or-later + // SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project // SPDX-License-Identifier: GPL-2.0-or-later #pragma once #include +#include #include "common/make_unique_for_overwrite.h" @@ -61,7 +65,7 @@ public: void resize(size_type size) { if (size > buffer_capacity) { auto new_buffer = Common::make_unique_for_overwrite(size); - std::move(buffer.get(), buffer.get() + buffer_capacity, new_buffer.get()); + std::memcpy(new_buffer.get(), buffer.get(), buffer_capacity * sizeof(T)); buffer = std::move(new_buffer); buffer_capacity = size; } diff --git a/src/common/uuid.h b/src/common/uuid.h index c3cbd7b479..3aa3212dd7 100644 --- a/src/common/uuid.h +++ b/src/common/uuid.h @@ -10,6 +10,7 @@ #include #include #include +#include #include "common/common_types.h" diff --git a/src/core/debugger/debugger.cpp b/src/core/debugger/debugger.cpp index 4ed69d8128..a9c1dcfb47 100644 --- a/src/core/debugger/debugger.cpp +++ b/src/core/debugger/debugger.cpp @@ -6,13 +6,13 @@ #include #include +#include + #include #include - #if BOOST_VERSION > 108400 && (!defined(_WINDOWS) && !defined(__ANDROID__)) || defined(YUZU_BOOST_v1) #define USE_BOOST_v1 #endif - #ifdef USE_BOOST_v1 #include #else diff --git a/src/core/file_sys/fssystem/fs_types.h b/src/core/file_sys/fssystem/fs_types.h index f11b7f1dae..fb16697c8f 100644 --- a/src/core/file_sys/fssystem/fs_types.h +++ b/src/core/file_sys/fssystem/fs_types.h @@ -1,4 +1,4 @@ -// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project +// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project // SPDX-License-Identifier: GPL-3.0-or-later // SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project @@ -6,6 +6,7 @@ #pragma once +#include #include "common/common_funcs.h" namespace FileSys { diff --git a/src/core/file_sys/fssystem/fssystem_aes_ctr_counter_extended_storage.h b/src/core/file_sys/fssystem/fssystem_aes_ctr_counter_extended_storage.h index b7b004f9e3..b409b3acf3 100644 --- a/src/core/file_sys/fssystem/fssystem_aes_ctr_counter_extended_storage.h +++ b/src/core/file_sys/fssystem/fssystem_aes_ctr_counter_extended_storage.h @@ -7,6 +7,7 @@ #pragma once #include +#include #include "common/literals.h" #include "core/file_sys/fssystem/fs_i_storage.h" diff --git a/src/core/file_sys/fssystem/fssystem_bucket_tree.cpp b/src/core/file_sys/fssystem/fssystem_bucket_tree.cpp index 07926b7acf..e457f6b239 100644 --- a/src/core/file_sys/fssystem/fssystem_bucket_tree.cpp +++ b/src/core/file_sys/fssystem/fssystem_bucket_tree.cpp @@ -4,6 +4,7 @@ // SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project // SPDX-License-Identifier: GPL-2.0-or-later +#include #include "core/file_sys/errors.h" #include "core/file_sys/fssystem/fssystem_bucket_tree.h" #include "core/file_sys/fssystem/fssystem_bucket_tree_utils.h" diff --git a/src/core/file_sys/fssystem/fssystem_bucket_tree.h b/src/core/file_sys/fssystem/fssystem_bucket_tree.h index 3a5e21d1a4..66b6a17bbc 100644 --- a/src/core/file_sys/fssystem/fssystem_bucket_tree.h +++ b/src/core/file_sys/fssystem/fssystem_bucket_tree.h @@ -1,9 +1,13 @@ +// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project +// SPDX-License-Identifier: GPL-3.0-or-later + // SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project // SPDX-License-Identifier: GPL-2.0-or-later #pragma once #include +#include #include "common/alignment.h" #include "common/common_funcs.h" diff --git a/src/core/file_sys/fssystem/fssystem_bucket_tree_template_impl.h b/src/core/file_sys/fssystem/fssystem_bucket_tree_template_impl.h index fac6c37214..5e7402e71c 100644 --- a/src/core/file_sys/fssystem/fssystem_bucket_tree_template_impl.h +++ b/src/core/file_sys/fssystem/fssystem_bucket_tree_template_impl.h @@ -1,4 +1,4 @@ -// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project +// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project // SPDX-License-Identifier: GPL-3.0-or-later // SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project @@ -6,6 +6,7 @@ #pragma once +#include #include "core/file_sys/errors.h" #include "core/file_sys/fssystem/fssystem_bucket_tree.h" #include "core/file_sys/fssystem/fssystem_bucket_tree_utils.h" diff --git a/src/core/file_sys/fssystem/fssystem_compressed_storage.h b/src/core/file_sys/fssystem/fssystem_compressed_storage.h index 3fc0449664..97de0f0c9a 100644 --- a/src/core/file_sys/fssystem/fssystem_compressed_storage.h +++ b/src/core/file_sys/fssystem/fssystem_compressed_storage.h @@ -6,6 +6,8 @@ #pragma once +#include +#include #include "common/literals.h" #include "core/file_sys/errors.h" diff --git a/src/core/file_sys/fssystem/fssystem_hierarchical_integrity_verification_storage.h b/src/core/file_sys/fssystem/fssystem_hierarchical_integrity_verification_storage.h index bd129db47a..ada1656ef7 100644 --- a/src/core/file_sys/fssystem/fssystem_hierarchical_integrity_verification_storage.h +++ b/src/core/file_sys/fssystem/fssystem_hierarchical_integrity_verification_storage.h @@ -1,8 +1,12 @@ +// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project +// SPDX-License-Identifier: GPL-3.0-or-later + // SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project // SPDX-License-Identifier: GPL-2.0-or-later #pragma once +#include #include "common/alignment.h" #include "core/file_sys/fssystem/fs_i_storage.h" #include "core/file_sys/fssystem/fs_types.h" diff --git a/src/core/file_sys/fssystem/fssystem_indirect_storage.h b/src/core/file_sys/fssystem/fssystem_indirect_storage.h index 81f94e2e19..728616b964 100644 --- a/src/core/file_sys/fssystem/fssystem_indirect_storage.h +++ b/src/core/file_sys/fssystem/fssystem_indirect_storage.h @@ -6,6 +6,9 @@ #pragma once +#include +#include +#include #include "core/file_sys/errors.h" #include "core/file_sys/fssystem/fs_i_storage.h" #include "core/file_sys/fssystem/fssystem_bucket_tree.h" diff --git a/src/core/file_sys/fssystem/fssystem_integrity_verification_storage.h b/src/core/file_sys/fssystem/fssystem_integrity_verification_storage.h index 09f76799db..b4259419dd 100644 --- a/src/core/file_sys/fssystem/fssystem_integrity_verification_storage.h +++ b/src/core/file_sys/fssystem/fssystem_integrity_verification_storage.h @@ -1,9 +1,15 @@ +// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project +// SPDX-License-Identifier: GPL-3.0-or-later + // SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project // SPDX-License-Identifier: GPL-2.0-or-later #pragma once #include +#include +#include +#include #include "core/file_sys/fssystem/fs_i_storage.h" #include "core/file_sys/fssystem/fs_types.h" diff --git a/src/core/file_sys/fssystem/fssystem_nca_file_system_driver.h b/src/core/file_sys/fssystem/fssystem_nca_file_system_driver.h index e09bfc588a..ad8095b6f0 100644 --- a/src/core/file_sys/fssystem/fssystem_nca_file_system_driver.h +++ b/src/core/file_sys/fssystem/fssystem_nca_file_system_driver.h @@ -1,4 +1,4 @@ -// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project +// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project // SPDX-License-Identifier: GPL-3.0-or-later // SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project @@ -6,6 +6,8 @@ #pragma once +#include +#include #include "core/file_sys/fssystem/fssystem_compression_common.h" #include "core/file_sys/fssystem/fssystem_nca_header.h" #include "core/file_sys/vfs/vfs.h" diff --git a/src/core/file_sys/fssystem/fssystem_nca_header.h b/src/core/file_sys/fssystem/fssystem_nca_header.h index a02c5d881c..b10bb39e66 100644 --- a/src/core/file_sys/fssystem/fssystem_nca_header.h +++ b/src/core/file_sys/fssystem/fssystem_nca_header.h @@ -1,8 +1,14 @@ +// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project +// SPDX-License-Identifier: GPL-3.0-or-later + // SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project // SPDX-License-Identifier: GPL-2.0-or-later #pragma once +#include +#include +#include #include "common/common_funcs.h" #include "common/common_types.h" #include "common/literals.h" diff --git a/src/core/hle/kernel/k_page_table_base.h b/src/core/hle/kernel/k_page_table_base.h index 160e722985..1d4fa85f04 100644 --- a/src/core/hle/kernel/k_page_table_base.h +++ b/src/core/hle/kernel/k_page_table_base.h @@ -7,6 +7,7 @@ #pragma once #include +#include #include "common/common_funcs.h" #include "common/page_table.h" diff --git a/src/core/hle/result.h b/src/core/hle/result.h index cfad30b992..da100ede90 100644 --- a/src/core/hle/result.h +++ b/src/core/hle/result.h @@ -6,6 +6,7 @@ #pragma once +#include #include "common/assert.h" #include "common/bit_field.h" #include "common/common_funcs.h" diff --git a/src/core/hle/service/bcat/bcat_types.h b/src/core/hle/service/bcat/bcat_types.h index b35dab7c5a..303c243542 100644 --- a/src/core/hle/service/bcat/bcat_types.h +++ b/src/core/hle/service/bcat/bcat_types.h @@ -1,9 +1,13 @@ +// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project +// SPDX-License-Identifier: GPL-3.0-or-later + // SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project // SPDX-License-Identifier: GPL-3.0-or-later #pragma once #include +#include #include #include "common/common_funcs.h" diff --git a/src/core/hle/service/caps/caps_manager.cpp b/src/core/hle/service/caps/caps_manager.cpp index 407557b472..d3c4ab57d1 100644 --- a/src/core/hle/service/caps/caps_manager.cpp +++ b/src/core/hle/service/caps/caps_manager.cpp @@ -175,19 +175,10 @@ Result AlbumManager::LoadAlbumScreenShotImage(LoadAlbumScreenShotImageOutput& ou return ResultIsNotMounted; } - out_image_output = { - .width = 1280, - .height = 720, - .attribute = - { - .unknown_0{}, - .orientation = AlbumImageOrientation::None, - .unknown_1{}, - .unknown_2{}, - .pad163{}, - }, - .pad179{}, - }; + out_image_output = {}; + out_image_output.width = 1280; + out_image_output.height = 720; + out_image_output.attribute.orientation = AlbumImageOrientation::None; std::filesystem::path path; const auto result = GetFile(path, file_id); @@ -211,19 +202,10 @@ Result AlbumManager::LoadAlbumScreenShotThumbnail( return ResultIsNotMounted; } - out_image_output = { - .width = 320, - .height = 180, - .attribute = - { - .unknown_0{}, - .orientation = AlbumImageOrientation::None, - .unknown_1{}, - .unknown_2{}, - .pad163{}, - }, - .pad179{}, - }; + out_image_output = {}; + out_image_output.width = 320; + out_image_output.height = 180; + out_image_output.attribute.orientation = AlbumImageOrientation::None; std::filesystem::path path; const auto result = GetFile(path, file_id); diff --git a/src/core/hle/service/caps/caps_su.cpp b/src/core/hle/service/caps/caps_su.cpp index 3d54564612..4ecfc840e4 100644 --- a/src/core/hle/service/caps/caps_su.cpp +++ b/src/core/hle/service/caps/caps_su.cpp @@ -73,13 +73,8 @@ void IScreenShotApplicationService::CaptureAndSaveScreenshot(AlbumReportOption r Layout::FramebufferLayout layout = Layout::DefaultFrameLayout(screenshot_width, screenshot_height); - const Capture::ScreenShotAttribute attribute{ - .unknown_0{}, - .orientation = Capture::AlbumImageOrientation::None, - .unknown_1{}, - .unknown_2{}, - .pad163{}, - }; + Capture::ScreenShotAttribute attribute{}; + attribute.orientation = Capture::AlbumImageOrientation::None; renderer.RequestScreenshot( image_data.data(), diff --git a/src/core/hle/service/caps/caps_types.h b/src/core/hle/service/caps/caps_types.h index 3deaaad5b8..549ce4a307 100644 --- a/src/core/hle/service/caps/caps_types.h +++ b/src/core/hle/service/caps/caps_types.h @@ -1,8 +1,12 @@ +// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project +// SPDX-License-Identifier: GPL-3.0-or-later + // SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project // SPDX-License-Identifier: GPL-2.0-or-later #pragma once +#include #include "common/common_funcs.h" #include "common/common_types.h" diff --git a/src/core/hle/service/ldn/ldn_types.h b/src/core/hle/service/ldn/ldn_types.h index 975af5b6c8..4107d579ab 100644 --- a/src/core/hle/service/ldn/ldn_types.h +++ b/src/core/hle/service/ldn/ldn_types.h @@ -1,4 +1,4 @@ -// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project +// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project // SPDX-License-Identifier: GPL-3.0-or-later // SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project @@ -6,6 +6,7 @@ #pragma once +#include #include #include "common/common_funcs.h" diff --git a/src/core/hle/service/psc/time/common.h b/src/core/hle/service/psc/time/common.h index 36a90cd828..2183fa72b8 100644 --- a/src/core/hle/service/psc/time/common.h +++ b/src/core/hle/service/psc/time/common.h @@ -8,6 +8,7 @@ #include #include +#include #include #include "common/common_types.h" diff --git a/src/core/hle/service/psc/time/shared_memory.h b/src/core/hle/service/psc/time/shared_memory.h index b7bd00fc1d..58363bd698 100644 --- a/src/core/hle/service/psc/time/shared_memory.h +++ b/src/core/hle/service/psc/time/shared_memory.h @@ -1,10 +1,13 @@ +// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project +// SPDX-License-Identifier: GPL-3.0-or-later + // SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project // SPDX-License-Identifier: GPL-2.0-or-later #pragma once #include - +#include #include "common/common_types.h" #include "core/hle/service/psc/time/common.h" diff --git a/src/core/hle/service/set/settings_types.h b/src/core/hle/service/set/settings_types.h index 696938c4c7..acb54856e0 100644 --- a/src/core/hle/service/set/settings_types.h +++ b/src/core/hle/service/set/settings_types.h @@ -7,6 +7,7 @@ #pragma once #include +#include #include "common/bit_field.h" #include "common/common_funcs.h" diff --git a/src/hid_core/hid_types.h b/src/hid_core/hid_types.h index 40a90c2bc3..66d661c80b 100644 --- a/src/hid_core/hid_types.h +++ b/src/hid_core/hid_types.h @@ -1,8 +1,15 @@ +// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project +// SPDX-License-Identifier: GPL-3.0-or-later + // SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project // SPDX-License-Identifier: GPL-2.0-or-later #pragma once +#include +#include +#include + #include "common/bit_field.h" #include "common/common_funcs.h" #include "common/common_types.h" diff --git a/src/shader_recompiler/CMakeLists.txt b/src/shader_recompiler/CMakeLists.txt index 1e6a4d173a..957ed5fb55 100644 --- a/src/shader_recompiler/CMakeLists.txt +++ b/src/shader_recompiler/CMakeLists.txt @@ -6,55 +6,6 @@ add_library(shader_recompiler STATIC backend/bindings.h - backend/glasm/emit_glasm.cpp - backend/glasm/emit_glasm.h - backend/glasm/emit_glasm_barriers.cpp - backend/glasm/emit_glasm_bitwise_conversion.cpp - backend/glasm/emit_glasm_composite.cpp - backend/glasm/emit_glasm_context_get_set.cpp - backend/glasm/emit_glasm_control_flow.cpp - backend/glasm/emit_glasm_convert.cpp - backend/glasm/emit_glasm_floating_point.cpp - backend/glasm/emit_glasm_image.cpp - backend/glasm/emit_glasm_instructions.h - backend/glasm/emit_glasm_integer.cpp - backend/glasm/emit_glasm_logical.cpp - backend/glasm/emit_glasm_memory.cpp - backend/glasm/emit_glasm_not_implemented.cpp - backend/glasm/emit_glasm_select.cpp - backend/glasm/emit_glasm_shared_memory.cpp - backend/glasm/emit_glasm_special.cpp - backend/glasm/emit_glasm_undefined.cpp - backend/glasm/emit_glasm_warp.cpp - backend/glasm/glasm_emit_context.cpp - backend/glasm/glasm_emit_context.h - backend/glasm/reg_alloc.cpp - backend/glasm/reg_alloc.h - backend/glsl/emit_glsl.cpp - backend/glsl/emit_glsl.h - backend/glsl/emit_glsl_atomic.cpp - backend/glsl/emit_glsl_barriers.cpp - backend/glsl/emit_glsl_bitwise_conversion.cpp - backend/glsl/emit_glsl_composite.cpp - backend/glsl/emit_glsl_context_get_set.cpp - backend/glsl/emit_glsl_control_flow.cpp - backend/glsl/emit_glsl_convert.cpp - backend/glsl/emit_glsl_floating_point.cpp - backend/glsl/emit_glsl_image.cpp - backend/glsl/emit_glsl_instructions.h - backend/glsl/emit_glsl_integer.cpp - backend/glsl/emit_glsl_logical.cpp - backend/glsl/emit_glsl_memory.cpp - backend/glsl/emit_glsl_not_implemented.cpp - backend/glsl/emit_glsl_select.cpp - backend/glsl/emit_glsl_shared_memory.cpp - backend/glsl/emit_glsl_special.cpp - backend/glsl/emit_glsl_undefined.cpp - backend/glsl/emit_glsl_warp.cpp - backend/glsl/glsl_emit_context.cpp - backend/glsl/glsl_emit_context.h - backend/glsl/var_alloc.cpp - backend/glsl/var_alloc.h backend/spirv/emit_spirv.cpp backend/spirv/emit_spirv.h backend/spirv/emit_spirv_atomic.cpp @@ -239,9 +190,60 @@ add_library(shader_recompiler STATIC program_header.h runtime_info.h shader_info.h - varying_state.h + varying_state.h) -) +if (ENABLE_OPENGL) + target_sources(shader_recompiler PRIVATE + backend/glasm/emit_glasm.cpp + backend/glasm/emit_glasm.h + backend/glasm/emit_glasm_barriers.cpp + backend/glasm/emit_glasm_bitwise_conversion.cpp + backend/glasm/emit_glasm_composite.cpp + backend/glasm/emit_glasm_context_get_set.cpp + backend/glasm/emit_glasm_control_flow.cpp + backend/glasm/emit_glasm_convert.cpp + backend/glasm/emit_glasm_floating_point.cpp + backend/glasm/emit_glasm_image.cpp + backend/glasm/emit_glasm_instructions.h + backend/glasm/emit_glasm_integer.cpp + backend/glasm/emit_glasm_logical.cpp + backend/glasm/emit_glasm_memory.cpp + backend/glasm/emit_glasm_not_implemented.cpp + backend/glasm/emit_glasm_select.cpp + backend/glasm/emit_glasm_shared_memory.cpp + backend/glasm/emit_glasm_special.cpp + backend/glasm/emit_glasm_undefined.cpp + backend/glasm/emit_glasm_warp.cpp + backend/glasm/glasm_emit_context.cpp + backend/glasm/glasm_emit_context.h + backend/glasm/reg_alloc.cpp + backend/glasm/reg_alloc.h + backend/glsl/emit_glsl.cpp + backend/glsl/emit_glsl.h + backend/glsl/emit_glsl_atomic.cpp + backend/glsl/emit_glsl_barriers.cpp + backend/glsl/emit_glsl_bitwise_conversion.cpp + backend/glsl/emit_glsl_composite.cpp + backend/glsl/emit_glsl_context_get_set.cpp + backend/glsl/emit_glsl_control_flow.cpp + backend/glsl/emit_glsl_convert.cpp + backend/glsl/emit_glsl_floating_point.cpp + backend/glsl/emit_glsl_image.cpp + backend/glsl/emit_glsl_instructions.h + backend/glsl/emit_glsl_integer.cpp + backend/glsl/emit_glsl_logical.cpp + backend/glsl/emit_glsl_memory.cpp + backend/glsl/emit_glsl_not_implemented.cpp + backend/glsl/emit_glsl_select.cpp + backend/glsl/emit_glsl_shared_memory.cpp + backend/glsl/emit_glsl_special.cpp + backend/glsl/emit_glsl_undefined.cpp + backend/glsl/emit_glsl_warp.cpp + backend/glsl/glsl_emit_context.cpp + backend/glsl/glsl_emit_context.h + backend/glsl/var_alloc.cpp + backend/glsl/var_alloc.h) +endif() target_link_libraries(shader_recompiler PUBLIC common fmt::fmt sirit::sirit) diff --git a/src/shader_recompiler/ir_opt/global_memory_to_storage_buffer_pass.cpp b/src/shader_recompiler/ir_opt/global_memory_to_storage_buffer_pass.cpp index 3929475ddc..f49d54e7ab 100644 --- a/src/shader_recompiler/ir_opt/global_memory_to_storage_buffer_pass.cpp +++ b/src/shader_recompiler/ir_opt/global_memory_to_storage_buffer_pass.cpp @@ -553,17 +553,6 @@ void GlobalMemoryToStorageBufferPass(IR::Program& program, const HostTranslateIn } } -template -static u32 Add(Descriptors& descriptors, const Descriptor& desc, Func&& pred) { - // TODO: Handle arrays - const auto it{std::ranges::find_if(descriptors, pred)}; - if (it != descriptors.end()) { - return static_cast(std::distance(descriptors.begin(), it)); - } - descriptors.push_back(desc); - return static_cast(descriptors.size()) - 1; -} - void JoinStorageInfo(Info& base, Info& source) { auto& descriptors = base.storage_buffers_descriptors; for (auto& desc : source.storage_buffers_descriptors) { diff --git a/src/video_core/host1x/codec_types.h b/src/video_core/host1x/codec_types.h index 3a10afa8df..b2f80c822a 100644 --- a/src/video_core/host1x/codec_types.h +++ b/src/video_core/host1x/codec_types.h @@ -8,6 +8,7 @@ #include #include +#include #include "common/bit_field.h" #include "common/common_funcs.h" diff --git a/src/video_core/host1x/nvdec_common.h b/src/video_core/host1x/nvdec_common.h index dfd8bb3770..0857a9f95c 100644 --- a/src/video_core/host1x/nvdec_common.h +++ b/src/video_core/host1x/nvdec_common.h @@ -1,8 +1,15 @@ +// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project +// SPDX-License-Identifier: GPL-3.0-or-later + // SPDX-FileCopyrightText: Copyright 2020 yuzu Emulator Project // SPDX-License-Identifier: GPL-2.0-or-later #pragma once +#include +#include +#include + #include "common/bit_field.h" #include "common/common_funcs.h" #include "common/common_types.h" diff --git a/src/video_core/host1x/vic.h b/src/video_core/host1x/vic.h index 18eff3382f..1a580474b5 100644 --- a/src/video_core/host1x/vic.h +++ b/src/video_core/host1x/vic.h @@ -7,6 +7,7 @@ #pragma once #include +#include #include "common/common_types.h" #include "common/scratch_buffer.h" diff --git a/src/video_core/renderer_vulkan/vk_present_manager.cpp b/src/video_core/renderer_vulkan/vk_present_manager.cpp index 523e6d02cb..3491f8fb75 100644 --- a/src/video_core/renderer_vulkan/vk_present_manager.cpp +++ b/src/video_core/renderer_vulkan/vk_present_manager.cpp @@ -338,7 +338,7 @@ void PresentManager::PresentThread(std::stop_token token) { // By exchanging the lock ownership we take the swapchain lock // before the queue lock goes out of scope. This way the swapchain // lock in WaitPresent is guaranteed to occur after here. - std::exchange(lock, std::unique_lock{swapchain_mutex}); + void(std::exchange(lock, std::unique_lock{swapchain_mutex})); CopyToSwapchain(frame); // Free the frame for reuse diff --git a/src/video_core/renderer_vulkan/vk_scheduler.cpp b/src/video_core/renderer_vulkan/vk_scheduler.cpp index 92dcd20111..4a7a7d5e78 100644 --- a/src/video_core/renderer_vulkan/vk_scheduler.cpp +++ b/src/video_core/renderer_vulkan/vk_scheduler.cpp @@ -300,7 +300,7 @@ void Scheduler::WorkerThread(std::stop_token stop_token) { // Exchange lock ownership so that we take the execution lock before // the queue lock goes out of scope. This allows us to force execution // to complete in the next step. - std::exchange(lk, std::unique_lock{execution_mutex}); + void(std::exchange(lk, std::unique_lock{execution_mutex})); // Perform the work, tracking whether the chunk was a submission // before executing. diff --git a/src/video_core/vulkan_common/vulkan_memory_allocator.cpp b/src/video_core/vulkan_common/vulkan_memory_allocator.cpp index e57864ede8..20b6b55ef7 100644 --- a/src/video_core/vulkan_common/vulkan_memory_allocator.cpp +++ b/src/video_core/vulkan_common/vulkan_memory_allocator.cpp @@ -26,350 +26,329 @@ #include "common/settings.h" namespace Vulkan { - namespace { +namespace { // Helpers translating MemoryUsage to flags/usage - [[maybe_unused]] VkMemoryPropertyFlags MemoryUsagePropertyFlags(MemoryUsage usage) { - switch (usage) { - case MemoryUsage::DeviceLocal: - return VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT; - case MemoryUsage::Upload: - return VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | - VK_MEMORY_PROPERTY_HOST_COHERENT_BIT; - case MemoryUsage::Download: - return VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | - VK_MEMORY_PROPERTY_HOST_COHERENT_BIT | - VK_MEMORY_PROPERTY_HOST_CACHED_BIT; - case MemoryUsage::Stream: - return VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT | - VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | - VK_MEMORY_PROPERTY_HOST_COHERENT_BIT; - } - ASSERT_MSG(false, "Invalid memory usage={}", usage); - return VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT; + [[maybe_unused]] VkMemoryPropertyFlags MemoryUsagePropertyFlags(MemoryUsage usage) { + switch (usage) { + case MemoryUsage::DeviceLocal: + return VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT; + case MemoryUsage::Upload: + return VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | + VK_MEMORY_PROPERTY_HOST_COHERENT_BIT; + case MemoryUsage::Download: + return VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | + VK_MEMORY_PROPERTY_HOST_COHERENT_BIT | + VK_MEMORY_PROPERTY_HOST_CACHED_BIT; + case MemoryUsage::Stream: + return VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT | + VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | + VK_MEMORY_PROPERTY_HOST_COHERENT_BIT; } + ASSERT_MSG(false, "Invalid memory usage={}", usage); + return VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT; + } - [[nodiscard]] VkMemoryPropertyFlags MemoryUsagePreferredVmaFlags(MemoryUsage usage) { - if (usage == MemoryUsage::Download) { - return VK_MEMORY_PROPERTY_HOST_CACHED_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT; - } - return usage != MemoryUsage::DeviceLocal ? VK_MEMORY_PROPERTY_HOST_COHERENT_BIT - : VkMemoryPropertyFlagBits{}; + [[nodiscard]] VkMemoryPropertyFlags MemoryUsagePreferredVmaFlags(MemoryUsage usage) { + if (usage == MemoryUsage::Download) { + return VK_MEMORY_PROPERTY_HOST_CACHED_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT; } + return usage != MemoryUsage::DeviceLocal ? VK_MEMORY_PROPERTY_HOST_COHERENT_BIT + : VkMemoryPropertyFlagBits{}; + } - [[nodiscard]] VmaAllocationCreateFlags MemoryUsageVmaFlags(MemoryUsage usage) { - switch (usage) { - case MemoryUsage::Upload: - case MemoryUsage::Stream: - return VMA_ALLOCATION_CREATE_MAPPED_BIT | - VMA_ALLOCATION_CREATE_HOST_ACCESS_SEQUENTIAL_WRITE_BIT; - case MemoryUsage::Download: - return VMA_ALLOCATION_CREATE_MAPPED_BIT | - VMA_ALLOCATION_CREATE_HOST_ACCESS_RANDOM_BIT; - case MemoryUsage::DeviceLocal: - return {}; - } - return {}; + [[nodiscard]] VmaAllocationCreateFlags MemoryUsageVmaFlags(MemoryUsage usage) { + switch (usage) { + case MemoryUsage::Upload: + case MemoryUsage::Stream: + return VMA_ALLOCATION_CREATE_MAPPED_BIT | + VMA_ALLOCATION_CREATE_HOST_ACCESS_SEQUENTIAL_WRITE_BIT; + case MemoryUsage::Download: + return VMA_ALLOCATION_CREATE_MAPPED_BIT | + VMA_ALLOCATION_CREATE_HOST_ACCESS_RANDOM_BIT; + case MemoryUsage::DeviceLocal: + return {}; } + return {}; + } - [[nodiscard]] VmaMemoryUsage MemoryUsageVma(MemoryUsage usage) { - switch (usage) { - case MemoryUsage::DeviceLocal: - case MemoryUsage::Stream: - return VMA_MEMORY_USAGE_AUTO_PREFER_DEVICE; - case MemoryUsage::Upload: - case MemoryUsage::Download: - return VMA_MEMORY_USAGE_AUTO_PREFER_HOST; - } - return VMA_MEMORY_USAGE_AUTO_PREFER_DEVICE; + [[nodiscard]] VmaMemoryUsage MemoryUsageVma(MemoryUsage usage) { + switch (usage) { + case MemoryUsage::DeviceLocal: + case MemoryUsage::Stream: + return VMA_MEMORY_USAGE_AUTO_PREFER_DEVICE; + case MemoryUsage::Upload: + case MemoryUsage::Download: + return VMA_MEMORY_USAGE_AUTO_PREFER_HOST; } - - -// This avoids calling vkGetBufferMemoryRequirements* directly. - template - static VkBuffer GetVkHandleFromBuffer(const T &buf) { - if constexpr (requires { static_cast(buf); }) { - return static_cast(buf); - } else if constexpr (requires {{ buf.GetHandle() } -> std::convertible_to; }) { - return buf.GetHandle(); - } else if constexpr (requires {{ buf.Handle() } -> std::convertible_to; }) { - return buf.Handle(); - } else if constexpr (requires {{ buf.vk_handle() } -> std::convertible_to; }) { - return buf.vk_handle(); - } else { - static_assert(sizeof(T) == 0, "Cannot extract VkBuffer handle from vk::Buffer"); - return VK_NULL_HANDLE; - } - } - - } // namespace + return VMA_MEMORY_USAGE_AUTO_PREFER_DEVICE; + } +} // namespace //MemoryCommit is now VMA-backed - MemoryCommit::MemoryCommit(VmaAllocator alloc, VmaAllocation a, - const VmaAllocationInfo &info) noexcept - : allocator{alloc}, allocation{a}, memory{info.deviceMemory}, - offset{info.offset}, size{info.size}, mapped_ptr{info.pMappedData} { - // Log GPU memory allocation +MemoryCommit::MemoryCommit(VmaAllocator alloc, VmaAllocation a, + const VmaAllocationInfo &info) noexcept + : allocator{alloc}, allocation{a}, memory{info.deviceMemory}, + offset{info.offset}, size{info.size}, mapped_ptr{info.pMappedData} { + // Log GPU memory allocation + if (GPU::Logging::IsActive() && + Settings::values.gpu_log_memory_tracking.GetValue()) { + GPU::Logging::GPULogger::GetInstance().LogMemoryAllocation( + reinterpret_cast(memory), + static_cast(size), + 0 // Memory property flags (not easily available from VMA) + ); + } +} + +MemoryCommit::~MemoryCommit() { Release(); } + +MemoryCommit::MemoryCommit(MemoryCommit &&rhs) noexcept + : allocator{std::exchange(rhs.allocator, nullptr)}, + allocation{std::exchange(rhs.allocation, nullptr)}, + memory{std::exchange(rhs.memory, VK_NULL_HANDLE)}, + offset{std::exchange(rhs.offset, 0)}, + size{std::exchange(rhs.size, 0)}, + mapped_ptr{std::exchange(rhs.mapped_ptr, nullptr)} {} + +MemoryCommit &MemoryCommit::operator=(MemoryCommit &&rhs) noexcept { + if (this != &rhs) { + Release(); + allocator = std::exchange(rhs.allocator, nullptr); + allocation = std::exchange(rhs.allocation, nullptr); + memory = std::exchange(rhs.memory, VK_NULL_HANDLE); + offset = std::exchange(rhs.offset, 0); + size = std::exchange(rhs.size, 0); + mapped_ptr = std::exchange(rhs.mapped_ptr, nullptr); + } + return *this; +} + +std::span MemoryCommit::Map() +{ + if (!allocation) return {}; + if (!mapped_ptr) { + if (vmaMapMemory(allocator, allocation, &mapped_ptr) != VK_SUCCESS) return {}; + } + const size_t n = static_cast(std::min(size, + (std::numeric_limits::max)())); + return std::span{static_cast(mapped_ptr), n}; +} + +std::span MemoryCommit::Map() const +{ + if (!allocation) return {}; + if (!mapped_ptr) { + void *p = nullptr; + if (vmaMapMemory(allocator, allocation, &p) != VK_SUCCESS) return {}; + const_cast(this)->mapped_ptr = p; + } + const size_t n = static_cast(std::min(size, + (std::numeric_limits::max)())); + return std::span{static_cast(mapped_ptr), n}; +} + +void MemoryCommit::Unmap() +{ + if (allocation && mapped_ptr) { + vmaUnmapMemory(allocator, allocation); + mapped_ptr = nullptr; + } +} + +void MemoryCommit::Release() { + if (allocation && allocator) { + // Log GPU memory deallocation if (GPU::Logging::IsActive() && - Settings::values.gpu_log_memory_tracking.GetValue()) { - GPU::Logging::GPULogger::GetInstance().LogMemoryAllocation( - reinterpret_cast(memory), - static_cast(size), - 0 // Memory property flags (not easily available from VMA) + Settings::values.gpu_log_memory_tracking.GetValue() && + memory != VK_NULL_HANDLE) { + GPU::Logging::GPULogger::GetInstance().LogMemoryDeallocation( + reinterpret_cast(memory) ); } - } - MemoryCommit::~MemoryCommit() { Release(); } - - MemoryCommit::MemoryCommit(MemoryCommit &&rhs) noexcept - : allocator{std::exchange(rhs.allocator, nullptr)}, - allocation{std::exchange(rhs.allocation, nullptr)}, - memory{std::exchange(rhs.memory, VK_NULL_HANDLE)}, - offset{std::exchange(rhs.offset, 0)}, - size{std::exchange(rhs.size, 0)}, - mapped_ptr{std::exchange(rhs.mapped_ptr, nullptr)} {} - - MemoryCommit &MemoryCommit::operator=(MemoryCommit &&rhs) noexcept { - if (this != &rhs) { - Release(); - allocator = std::exchange(rhs.allocator, nullptr); - allocation = std::exchange(rhs.allocation, nullptr); - memory = std::exchange(rhs.memory, VK_NULL_HANDLE); - offset = std::exchange(rhs.offset, 0); - size = std::exchange(rhs.size, 0); - mapped_ptr = std::exchange(rhs.mapped_ptr, nullptr); - } - return *this; - } - - std::span MemoryCommit::Map() - { - if (!allocation) return {}; - if (!mapped_ptr) { - if (vmaMapMemory(allocator, allocation, &mapped_ptr) != VK_SUCCESS) return {}; - } - const size_t n = static_cast(std::min(size, - (std::numeric_limits::max)())); - return std::span{static_cast(mapped_ptr), n}; - } - - std::span MemoryCommit::Map() const - { - if (!allocation) return {}; - if (!mapped_ptr) { - void *p = nullptr; - if (vmaMapMemory(allocator, allocation, &p) != VK_SUCCESS) return {}; - const_cast(this)->mapped_ptr = p; - } - const size_t n = static_cast(std::min(size, - (std::numeric_limits::max)())); - return std::span{static_cast(mapped_ptr), n}; - } - - void MemoryCommit::Unmap() - { - if (allocation && mapped_ptr) { + if (mapped_ptr) { vmaUnmapMemory(allocator, allocation); mapped_ptr = nullptr; } + vmaFreeMemory(allocator, allocation); } + allocation = nullptr; + allocator = nullptr; + memory = VK_NULL_HANDLE; + offset = 0; + size = 0; +} - void MemoryCommit::Release() { - if (allocation && allocator) { - // Log GPU memory deallocation - if (GPU::Logging::IsActive() && - Settings::values.gpu_log_memory_tracking.GetValue() && - memory != VK_NULL_HANDLE) { - GPU::Logging::GPULogger::GetInstance().LogMemoryDeallocation( - reinterpret_cast(memory) - ); - } +MemoryAllocator::MemoryAllocator(const Device &device_) + : device{device_}, allocator{device.GetAllocator()}, + properties{device_.GetPhysical().GetMemoryProperties().memoryProperties}, + buffer_image_granularity{ + device_.GetPhysical().GetProperties().limits.bufferImageGranularity} { - if (mapped_ptr) { - vmaUnmapMemory(allocator, allocation); - mapped_ptr = nullptr; - } - vmaFreeMemory(allocator, allocation); - } - allocation = nullptr; - allocator = nullptr; - memory = VK_NULL_HANDLE; - offset = 0; - size = 0; - } - - MemoryAllocator::MemoryAllocator(const Device &device_) - : device{device_}, allocator{device.GetAllocator()}, - properties{device_.GetPhysical().GetMemoryProperties().memoryProperties}, - buffer_image_granularity{ - device_.GetPhysical().GetProperties().limits.bufferImageGranularity} { - - // Preserve the previous "RenderDoc small heap" trimming behavior that we had in original vma minus the heap bug - if (device.HasDebuggingToolAttached()) - { - using namespace Common::Literals; - ForEachDeviceLocalHostVisibleHeap(device, [this](size_t heap_idx, VkMemoryHeap &heap) { - if (heap.size <= 256_MiB) { - for (u32 t = 0; t < properties.memoryTypeCount; ++t) { - if (properties.memoryTypes[t].heapIndex == heap_idx) { - valid_memory_types &= ~(1u << t); - } + // Preserve the previous "RenderDoc small heap" trimming behavior that we had in original vma minus the heap bug + if (device.HasDebuggingToolAttached()) + { + using namespace Common::Literals; + ForEachDeviceLocalHostVisibleHeap(device, [this](size_t heap_idx, VkMemoryHeap &heap) { + if (heap.size <= 256_MiB) { + for (u32 t = 0; t < properties.memoryTypeCount; ++t) { + if (properties.memoryTypes[t].heapIndex == heap_idx) { + valid_memory_types &= ~(1u << t); } } - }); - } + } + }); } +} - MemoryAllocator::~MemoryAllocator() = default; +MemoryAllocator::~MemoryAllocator() = default; - vk::Image MemoryAllocator::CreateImage(const VkImageCreateInfo &ci) const - { - const VmaAllocationCreateInfo alloc_ci = { - .flags = VMA_ALLOCATION_CREATE_WITHIN_BUDGET_BIT, - .usage = VMA_MEMORY_USAGE_AUTO_PREFER_DEVICE, - .requiredFlags = 0, - .preferredFlags = VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, - .memoryTypeBits = 0, - .pool = VK_NULL_HANDLE, - .pUserData = nullptr, - .priority = 0.f, - }; - - VkImage handle{}; - VmaAllocation allocation{}; - VmaAllocationInfo alloc_info{}; - vk::Check(vmaCreateImage(allocator, &ci, &alloc_ci, &handle, &allocation, &alloc_info)); - - // Log GPU memory allocation for images - if (GPU::Logging::IsActive() && - Settings::values.gpu_log_memory_tracking.GetValue()) { - GPU::Logging::GPULogger::GetInstance().LogMemoryAllocation( - reinterpret_cast(alloc_info.deviceMemory), - static_cast(alloc_info.size), - VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT - ); - } - - return vk::Image(handle, ci.usage, *device.GetLogical(), allocator, allocation, - device.GetDispatchLoader()); - } - - vk::Buffer MemoryAllocator::CreateBuffer(const VkBufferCreateInfo &ci, MemoryUsage usage) const { - // MESA will do memcpy() if not marked as host cached, so just force mark it for most buffers - auto const anv_flags = (usage == MemoryUsage::Stream - && device.GetDriverID() == VK_DRIVER_ID_INTEL_OPEN_SOURCE_MESA) - ? VK_MEMORY_PROPERTY_HOST_CACHED_BIT : 0; - const VmaAllocationCreateInfo alloc_ci = { - .flags = VMA_ALLOCATION_CREATE_WITHIN_BUDGET_BIT | MemoryUsageVmaFlags(usage), - .usage = MemoryUsageVma(usage), +vk::Image MemoryAllocator::CreateImage(const VkImageCreateInfo &ci) const +{ + const VmaAllocationCreateInfo alloc_ci = { + .flags = VMA_ALLOCATION_CREATE_WITHIN_BUDGET_BIT, + .usage = VMA_MEMORY_USAGE_AUTO_PREFER_DEVICE, .requiredFlags = 0, - .preferredFlags = MemoryUsagePreferredVmaFlags(usage) | anv_flags, - .memoryTypeBits = usage == MemoryUsage::Stream ? 0u : valid_memory_types, + .preferredFlags = VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, + .memoryTypeBits = 0, .pool = VK_NULL_HANDLE, .pUserData = nullptr, .priority = 0.f, - }; + }; - VkBuffer handle{}; - VmaAllocationInfo alloc_info{}; - VmaAllocation allocation{}; - VkMemoryPropertyFlags property_flags{}; + VkImage handle{}; + VmaAllocation allocation{}; + VmaAllocationInfo alloc_info{}; + vk::Check(vmaCreateImage(allocator, &ci, &alloc_ci, &handle, &allocation, &alloc_info)); - vk::Check(vmaCreateBuffer(allocator, &ci, &alloc_ci, &handle, &allocation, &alloc_info)); - vmaGetAllocationMemoryProperties(allocator, allocation, &property_flags); - - // Log GPU memory allocation for buffers - if (GPU::Logging::IsActive() && - Settings::values.gpu_log_memory_tracking.GetValue()) { - GPU::Logging::GPULogger::GetInstance().LogMemoryAllocation( - reinterpret_cast(alloc_info.deviceMemory), - static_cast(alloc_info.size), - property_flags - ); - } - - u8 *data = reinterpret_cast(alloc_info.pMappedData); - const std::span mapped_data = data ? std::span{data, ci.size} : std::span{}; - const bool is_coherent = (property_flags & VK_MEMORY_PROPERTY_HOST_COHERENT_BIT) != 0; - - return vk::Buffer(handle, *device.GetLogical(), allocator, allocation, mapped_data, - is_coherent, - device.GetDispatchLoader()); + // Log GPU memory allocation for images + if (GPU::Logging::IsActive() && + Settings::values.gpu_log_memory_tracking.GetValue()) { + GPU::Logging::GPULogger::GetInstance().LogMemoryAllocation( + reinterpret_cast(alloc_info.deviceMemory), + static_cast(alloc_info.size), + VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT + ); } - MemoryCommit MemoryAllocator::Commit(const VkMemoryRequirements &reqs, MemoryUsage usage) - { - const auto vma_usage = MemoryUsageVma(usage); - VmaAllocationCreateInfo ci{}; - ci.flags = VMA_ALLOCATION_CREATE_WITHIN_BUDGET_BIT | MemoryUsageVmaFlags(usage); - ci.usage = vma_usage; - ci.memoryTypeBits = reqs.memoryTypeBits & valid_memory_types; - ci.requiredFlags = 0; - ci.preferredFlags = MemoryUsagePreferredVmaFlags(usage); + return vk::Image(handle, ci.usage, *device.GetLogical(), allocator, allocation, + device.GetDispatchLoader()); +} - VmaAllocation a{}; - VmaAllocationInfo info{}; +vk::Buffer MemoryAllocator::CreateBuffer(const VkBufferCreateInfo &ci, MemoryUsage usage) const { + // MESA will do memcpy() if not marked as host cached, so just force mark it for most buffers + auto const anv_flags = (usage == MemoryUsage::Stream + && device.GetDriverID() == VK_DRIVER_ID_INTEL_OPEN_SOURCE_MESA) + ? VK_MEMORY_PROPERTY_HOST_CACHED_BIT : 0; + const VmaAllocationCreateInfo alloc_ci = { + .flags = VMA_ALLOCATION_CREATE_WITHIN_BUDGET_BIT | MemoryUsageVmaFlags(usage), + .usage = MemoryUsageVma(usage), + .requiredFlags = 0, + .preferredFlags = MemoryUsagePreferredVmaFlags(usage) | anv_flags, + .memoryTypeBits = usage == MemoryUsage::Stream ? 0u : valid_memory_types, + .pool = VK_NULL_HANDLE, + .pUserData = nullptr, + .priority = 0.f, + }; - VkResult res = vmaAllocateMemory(allocator, &reqs, &ci, &a, &info); + VkBuffer handle{}; + VmaAllocationInfo alloc_info{}; + VmaAllocation allocation{}; + VkMemoryPropertyFlags property_flags{}; - if (res != VK_SUCCESS) { - // Relax 1: drop budget constraint - auto ci2 = ci; - ci2.flags &= ~VMA_ALLOCATION_CREATE_WITHIN_BUDGET_BIT; - res = vmaAllocateMemory(allocator, &reqs, &ci2, &a, &info); + vk::Check(vmaCreateBuffer(allocator, &ci, &alloc_ci, &handle, &allocation, &alloc_info)); + vmaGetAllocationMemoryProperties(allocator, allocation, &property_flags); - // Relax 2: if we preferred DEVICE_LOCAL, drop that preference - if (res != VK_SUCCESS && (ci.preferredFlags & VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT)) { - auto ci3 = ci2; - ci3.preferredFlags &= ~VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT; - res = vmaAllocateMemory(allocator, &reqs, &ci3, &a, &info); - } - } - - vk::Check(res); - return MemoryCommit(allocator, a, info); + // Log GPU memory allocation for buffers + if (GPU::Logging::IsActive() && + Settings::values.gpu_log_memory_tracking.GetValue()) { + GPU::Logging::GPULogger::GetInstance().LogMemoryAllocation( + reinterpret_cast(alloc_info.deviceMemory), + static_cast(alloc_info.size), + property_flags + ); } - MemoryCommit MemoryAllocator::Commit(const vk::Buffer &buffer, MemoryUsage usage) { - // Allocate memory appropriate for this buffer automatically - const auto vma_usage = MemoryUsageVma(usage); + u8 *data = reinterpret_cast(alloc_info.pMappedData); + const std::span mapped_data = data ? std::span{data, ci.size} : std::span{}; + const bool is_coherent = (property_flags & VK_MEMORY_PROPERTY_HOST_COHERENT_BIT) != 0; - VmaAllocationCreateInfo ci{}; - ci.flags = VMA_ALLOCATION_CREATE_WITHIN_BUDGET_BIT | MemoryUsageVmaFlags(usage); - ci.usage = vma_usage; - ci.requiredFlags = 0; - ci.preferredFlags = MemoryUsagePreferredVmaFlags(usage); - ci.pool = VK_NULL_HANDLE; - ci.pUserData = nullptr; - ci.priority = 0.0f; + return vk::Buffer(handle, *device.GetLogical(), allocator, allocation, mapped_data, + is_coherent, + device.GetDispatchLoader()); +} - const VkBuffer raw = *buffer; +MemoryCommit MemoryAllocator::Commit(const VkMemoryRequirements &reqs, MemoryUsage usage) +{ + const auto vma_usage = MemoryUsageVma(usage); + VmaAllocationCreateInfo ci{}; + ci.flags = VMA_ALLOCATION_CREATE_WITHIN_BUDGET_BIT | MemoryUsageVmaFlags(usage); + ci.usage = vma_usage; + ci.memoryTypeBits = reqs.memoryTypeBits & valid_memory_types; + ci.requiredFlags = 0; + ci.preferredFlags = MemoryUsagePreferredVmaFlags(usage); - VmaAllocation a{}; - VmaAllocationInfo info{}; + VmaAllocation a{}; + VmaAllocationInfo info{}; - // Let VMA infer memory requirements from the buffer - VkResult res = vmaAllocateMemoryForBuffer(allocator, raw, &ci, &a, &info); + VkResult res = vmaAllocateMemory(allocator, &reqs, &ci, &a, &info); - if (res != VK_SUCCESS) { - auto ci2 = ci; - ci2.flags &= ~VMA_ALLOCATION_CREATE_WITHIN_BUDGET_BIT; - res = vmaAllocateMemoryForBuffer(allocator, raw, &ci2, &a, &info); + if (res != VK_SUCCESS) { + // Relax 1: drop budget constraint + auto ci2 = ci; + ci2.flags &= ~VMA_ALLOCATION_CREATE_WITHIN_BUDGET_BIT; + res = vmaAllocateMemory(allocator, &reqs, &ci2, &a, &info); - if (res != VK_SUCCESS && (ci.preferredFlags & VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT)) { - auto ci3 = ci2; - ci3.preferredFlags &= ~VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT; - res = vmaAllocateMemoryForBuffer(allocator, raw, &ci3, &a, &info); - } + // Relax 2: if we preferred DEVICE_LOCAL, drop that preference + if (res != VK_SUCCESS && (ci.preferredFlags & VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT)) { + auto ci3 = ci2; + ci3.preferredFlags &= ~VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT; + res = vmaAllocateMemory(allocator, &reqs, &ci3, &a, &info); } - - vk::Check(res); - vk::Check(vmaBindBufferMemory2(allocator, a, 0, raw, nullptr)); - return MemoryCommit(allocator, a, info); } + vk::Check(res); + return MemoryCommit(allocator, a, info); +} +MemoryCommit MemoryAllocator::Commit(const vk::Buffer &buffer, MemoryUsage usage) { + // Allocate memory appropriate for this buffer automatically + const auto vma_usage = MemoryUsageVma(usage); + + VmaAllocationCreateInfo ci{}; + ci.flags = VMA_ALLOCATION_CREATE_WITHIN_BUDGET_BIT | MemoryUsageVmaFlags(usage); + ci.usage = vma_usage; + ci.requiredFlags = 0; + ci.preferredFlags = MemoryUsagePreferredVmaFlags(usage); + ci.pool = VK_NULL_HANDLE; + ci.pUserData = nullptr; + ci.priority = 0.0f; + + const VkBuffer raw = *buffer; + + VmaAllocation a{}; + VmaAllocationInfo info{}; + + // Let VMA infer memory requirements from the buffer + VkResult res = vmaAllocateMemoryForBuffer(allocator, raw, &ci, &a, &info); + + if (res != VK_SUCCESS) { + auto ci2 = ci; + ci2.flags &= ~VMA_ALLOCATION_CREATE_WITHIN_BUDGET_BIT; + res = vmaAllocateMemoryForBuffer(allocator, raw, &ci2, &a, &info); + + if (res != VK_SUCCESS && (ci.preferredFlags & VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT)) { + auto ci3 = ci2; + ci3.preferredFlags &= ~VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT; + res = vmaAllocateMemoryForBuffer(allocator, raw, &ci3, &a, &info); + } + } + + vk::Check(res); + vk::Check(vmaBindBufferMemory2(allocator, a, 0, raw, nullptr)); + return MemoryCommit(allocator, a, info); +} } // namespace Vulkan diff --git a/src/yuzu/main_window.cpp b/src/yuzu/main_window.cpp index 27b018d9d9..3f7feb83b2 100644 --- a/src/yuzu/main_window.cpp +++ b/src/yuzu/main_window.cpp @@ -4796,6 +4796,6 @@ void VolumeButton::ResetMultiplier() { #endif #if !defined(QT_STATICPLUGIN) || defined(__APPLE__) -#define VMA_IMPLEMENTATION +#define VMA_IMPLEMENTATION 1 #include "video_core/vulkan_common/vma.h" #endif diff --git a/tools/cpm/cmake/package/version.cmake b/tools/cpm/cmake/package/version.cmake index 6ce42a06cd..0f31c1d558 100755 --- a/tools/cpm/cmake/package/version.cmake +++ b/tools/cpm/cmake/package/version.cmake @@ -65,7 +65,7 @@ else() endif() # update cached cpmfile content -string(JSON cpmfile SET "${cpmfile}" "${key}" "${new_object}") +string(JSON cpmfile SET "${cpmfile}" "${KEY}" "${new_object}") # write cached cpmfile get_cpmfile_path(file)