VERY experimental Nintendo Switch 2 emulator
C++
[cmake] Fix some macOS compilation errors (#4350)
lizzie11de2645411b
diff --git a/.patch/vulkan-memory-allocator/0001-macos-clang.patch b/.patch/vulkan-memory-allocator/0001-macos-clang.patchnew file mode 100644index 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 <cstdlib>+-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 <typename CmpLess, typename IterT, typename KeyT>+-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<typename T>+-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<typename T>+-static T* VmaAllocate(const VkAllocationCallbacks* pAllocationCallbacks)++static inline T* VmaAllocate(const VkAllocationCallbacks* pAllocationCallbacks)+ {+ return (T*)VmaMalloc(pAllocationCallbacks, sizeof(T), VMA_ALIGN_OF(T));+ }++ template<typename T>+-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<type>((allocator), (count)))(type)++ template<typename T>+-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<typename T>+-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<T, AllocatorT>::remove(size_t index)+ #endif // _VMA_VECTOR_FUNCTIONS++ template<typename T, typename allocatorT>+-static void VmaVectorInsert(VmaVector<T, allocatorT>& vec, size_t index, const T& item)++static inline void VmaVectorInsert(VmaVector<T, allocatorT>& vec, size_t index, const T& item)+ {+ vec.insert(index, item);+ }++ template<typename T, typename allocatorT>+-static void VmaVectorRemove(VmaVector<T, allocatorT>& vec, size_t index)++static inline void VmaVectorRemove(VmaVector<T, allocatorT>& vec, size_t index)+ {+ vec.remove(index);+ }+@@ -10620,19 +10620,19 @@ static void VmaFree(VmaAllocator hAllocator, void* ptr)+ }++ template<typename T>+-static T* VmaAllocate(VmaAllocator hAllocator)++static inline T* VmaAllocate(VmaAllocator hAllocator)+ {+ return (T*)VmaMalloc(hAllocator, sizeof(T), VMA_ALIGN_OF(T));+ }++ template<typename T>+-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<typename T>+-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<typename T>+-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.txtindex 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.jsonindex 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.hindex 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 <iterator>+#include <cstring>#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<T[]>(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.hindex c3cbd7b479..3aa3212dd7 100644--- a/src/common/uuid.h+++ b/src/common/uuid.h@@ -10,6 +10,7 @@#include <functional>#include <span>#include <string>+#include <type_traits>#include "common/common_types.h"diff --git a/src/core/debugger/debugger.cpp b/src/core/debugger/debugger.cppindex 4ed69d8128..a9c1dcfb47 100644--- a/src/core/debugger/debugger.cpp+++ b/src/core/debugger/debugger.cpp@@ -6,13 +6,13 @@#include <mutex>#include <utility>+#include <type_traits>+#include <boost/asio.hpp>#include <boost/version.hpp>-#if BOOST_VERSION > 108400 && (!defined(_WINDOWS) && !defined(__ANDROID__)) || defined(YUZU_BOOST_v1)#define USE_BOOST_v1#endif-#ifdef USE_BOOST_v1#include <boost/process/v1/async_pipe.hpp>#elsediff --git a/src/core/file_sys/fssystem/fs_types.h b/src/core/file_sys/fssystem/fs_types.hindex 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 <type_traits>#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.hindex 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 <optional>+#include <type_traits>#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.cppindex 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 <type_traits>#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.hindex 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 <mutex>+#include <type_traits>#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.hindex 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 <type_traits>#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.hindex 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 <type_traits>+#include <cstddef>#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.hindex 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 <type_traits>#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.hindex 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 <type_traits>+#include <array>+#include <cstddef>#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.hindex 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 <optional>+#include <array>+#include <cstddef>+#include <type_traits>#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.hindex 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 <type_traits>+#include <cstddef>#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.hindex 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 <type_traits>+#include <array>+#include <cstddef>#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.hindex 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 <memory>+#include <type_traits>#include "common/common_funcs.h"#include "common/page_table.h"diff --git a/src/core/hle/result.h b/src/core/hle/result.hindex cfad30b992..da100ede90 100644--- a/src/core/hle/result.h+++ b/src/core/hle/result.h@@ -6,6 +6,7 @@#pragma once+#include <type_traits>#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.hindex 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 <array>+#include <type_traits>#include <functional>#include "common/common_funcs.h"diff --git a/src/core/hle/service/caps/caps_manager.cpp b/src/core/hle/service/caps/caps_manager.cppindex 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& oureturn 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.cppindex 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 rLayout::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.hindex 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 <type_traits>#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.hindex 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 <type_traits>#include <fmt/ranges.h>#include "common/common_funcs.h"diff --git a/src/core/hle/service/psc/time/common.h b/src/core/hle/service/psc/time/common.hindex 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 <array>#include <chrono>+#include <type_traits>#include <fmt/ranges.h>#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.hindex 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 <array>-+#include <type_traits>#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.hindex 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 <array>+#include <type_traits>#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.hindex 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 <cstddef>+#include <array>+#include <type_traits>+#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.txtindex 1e6a4d173a..957ed5fb55 100644--- a/src/shader_recompiler/CMakeLists.txt+++ b/src/shader_recompiler/CMakeLists.txt@@ -6,55 +6,6 @@add_library(shader_recompiler STATICbackend/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.hbackend/spirv/emit_spirv.cppbackend/spirv/emit_spirv.hbackend/spirv/emit_spirv_atomic.cpp@@ -239,9 +190,60 @@ add_library(shader_recompiler STATICprogram_header.hruntime_info.hshader_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.cppindex 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 <typename Descriptors, typename Descriptor, typename Func>-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<u32>(std::distance(descriptors.begin(), it));- }- descriptors.push_back(desc);- return static_cast<u32>(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.hindex 3a10afa8df..b2f80c822a 100644--- a/src/video_core/host1x/codec_types.h+++ b/src/video_core/host1x/codec_types.h@@ -8,6 +8,7 @@#include <array>#include <vector>+#include <type_traits>#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.hindex 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 <array>+#include <cstddef>+#include <type_traits>+#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.hindex 18eff3382f..1a580474b5 100644--- a/src/video_core/host1x/vic.h+++ b/src/video_core/host1x/vic.h@@ -7,6 +7,7 @@#pragma once#include <memory>+#include <type_traits>#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.cppindex 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 reusediff --git a/src/video_core/renderer_vulkan/vk_scheduler.cpp b/src/video_core/renderer_vulkan/vk_scheduler.cppindex 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.cppindex 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;- }-- [[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{};+ [[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]] 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]] 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]] 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]] 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 {};+ }--// This avoids calling vkGetBufferMemoryRequirements* directly.- template<typename T>- static VkBuffer GetVkHandleFromBuffer(const T &buf) {- if constexpr (requires { static_cast<VkBuffer>(buf); }) {- return static_cast<VkBuffer>(buf);- } else if constexpr (requires {{ buf.GetHandle() } -> std::convertible_to<VkBuffer>; }) {- return buf.GetHandle();- } else if constexpr (requires {{ buf.Handle() } -> std::convertible_to<VkBuffer>; }) {- return buf.Handle();- } else if constexpr (requires {{ buf.vk_handle() } -> std::convertible_to<VkBuffer>; }) {- return buf.vk_handle();- } else {- static_assert(sizeof(T) == 0, "Cannot extract VkBuffer handle from vk::Buffer");- return VK_NULL_HANDLE;- }+ [[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;}-- } // 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- if (GPU::Logging::IsActive() &&- Settings::values.gpu_log_memory_tracking.GetValue()) {- GPU::Logging::GPULogger::GetInstance().LogMemoryAllocation(- reinterpret_cast<uintptr_t>(memory),- static_cast<u64>(size),- 0 // Memory property flags (not easily available from VMA)- );- }+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<uintptr_t>(memory),+ static_cast<u64>(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;+}++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);}-- std::span<u8> MemoryCommit::Map()- {- if (!allocation) return {};- if (!mapped_ptr) {- if (vmaMapMemory(allocator, allocation, &mapped_ptr) != VK_SUCCESS) return {};- }- const size_t n = static_cast<size_t>(std::min<VkDeviceSize>(size,- (std::numeric_limits<size_t>::max)()));- return std::span<u8>{static_cast<u8 *>(mapped_ptr), n};+ return *this;+}++std::span<u8> MemoryCommit::Map()+{+ if (!allocation) return {};+ if (!mapped_ptr) {+ if (vmaMapMemory(allocator, allocation, &mapped_ptr) != VK_SUCCESS) return {};+ }+ const size_t n = static_cast<size_t>(std::min<VkDeviceSize>(size,+ (std::numeric_limits<size_t>::max)()));+ return std::span<u8>{static_cast<u8 *>(mapped_ptr), n};+}++std::span<const u8> MemoryCommit::Map() const+{+ if (!allocation) return {};+ if (!mapped_ptr) {+ void *p = nullptr;+ if (vmaMapMemory(allocator, allocation, &p) != VK_SUCCESS) return {};+ const_cast<MemoryCommit *>(this)->mapped_ptr = p;+ }+ const size_t n = static_cast<size_t>(std::min<VkDeviceSize>(size,+ (std::numeric_limits<size_t>::max)()));+ return std::span<const u8>{static_cast<const u8 *>(mapped_ptr), n};+}++void MemoryCommit::Unmap()+{+ if (allocation && mapped_ptr) {+ vmaUnmapMemory(allocator, allocation);+ mapped_ptr = nullptr;}+}- std::span<const u8> MemoryCommit::Map() const- {- if (!allocation) return {};- if (!mapped_ptr) {- void *p = nullptr;- if (vmaMapMemory(allocator, allocation, &p) != VK_SUCCESS) return {};- const_cast<MemoryCommit *>(this)->mapped_ptr = p;+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<uintptr_t>(memory)+ );}- const size_t n = static_cast<size_t>(std::min<VkDeviceSize>(size,- (std::numeric_limits<size_t>::max)()));- return std::span<const u8>{static_cast<const u8 *>(mapped_ptr), n};- }- void MemoryCommit::Unmap()- {- if (allocation && mapped_ptr) {+ if (mapped_ptr) {vmaUnmapMemory(allocator, allocation);mapped_ptr = nullptr;}+ vmaFreeMemory(allocator, allocation);}-- 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<uintptr_t>(memory)- );- }-- 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);- }+ 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);}}- });- }+ }+ });}+}- 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<uintptr_t>(alloc_info.deviceMemory),- static_cast<u64>(alloc_info.size),- VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT- );- }-- return vk::Image(handle, ci.usage, *device.GetLogical(), allocator, allocation,- device.GetDispatchLoader());- }+MemoryAllocator::~MemoryAllocator() = default;- 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{};-- 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<uintptr_t>(alloc_info.deviceMemory),- static_cast<u64>(alloc_info.size),- property_flags- );- }-- u8 *data = reinterpret_cast<u8 *>(alloc_info.pMappedData);- const std::span<u8> mapped_data = data ? std::span<u8>{data, ci.size} : std::span<u8>{};- const bool is_coherent = (property_flags & VK_MEMORY_PROPERTY_HOST_COHERENT_BIT) != 0;+ };++ 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<uintptr_t>(alloc_info.deviceMemory),+ static_cast<u64>(alloc_info.size),+ VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT+ );+ }- return vk::Buffer(handle, *device.GetLogical(), allocator, allocation, mapped_data,- is_coherent,- device.GetDispatchLoader());+ 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),+ .requiredFlags = 0,+ .preferredFlags = MemoryUsagePreferredVmaFlags(usage) | anv_flags,+ .memoryTypeBits = usage == MemoryUsage::Stream ? 0u : valid_memory_types,+ .pool = VK_NULL_HANDLE,+ .pUserData = nullptr,+ .priority = 0.f,+ };++ VkBuffer handle{};+ VmaAllocationInfo alloc_info{};+ VmaAllocation allocation{};+ VkMemoryPropertyFlags property_flags{};++ 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<uintptr_t>(alloc_info.deviceMemory),+ static_cast<u64>(alloc_info.size),+ property_flags+ );}- 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{};-- VkResult res = vmaAllocateMemory(allocator, &reqs, &ci, &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);-- // 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);- }+ u8 *data = reinterpret_cast<u8 *>(alloc_info.pMappedData);+ const std::span<u8> mapped_data = data ? std::span<u8>{data, ci.size} : std::span<u8>{};+ 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());+}++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{};++ VkResult res = vmaAllocateMemory(allocator, &reqs, &ci, &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);++ // 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);}- MemoryCommit MemoryAllocator::Commit(const vk::Buffer &buffer, MemoryUsage usage) {- // Allocate memory appropriate for this buffer automatically- const auto vma_usage = MemoryUsageVma(usage);+ vk::Check(res);+ return MemoryCommit(allocator, a, info);+}- 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;+MemoryCommit MemoryAllocator::Commit(const vk::Buffer &buffer, MemoryUsage usage) {+ // Allocate memory appropriate for this buffer automatically+ const auto vma_usage = MemoryUsageVma(usage);- const VkBuffer raw = *buffer;+ 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;- VmaAllocation a{};- VmaAllocationInfo info{};+ const VkBuffer raw = *buffer;- // Let VMA infer memory requirements from the buffer- VkResult res = vmaAllocateMemoryForBuffer(allocator, raw, &ci, &a, &info);+ VmaAllocation a{};+ VmaAllocationInfo info{};- if (res != VK_SUCCESS) {- auto ci2 = ci;- ci2.flags &= ~VMA_ALLOCATION_CREATE_WITHIN_BUDGET_BIT;- res = vmaAllocateMemoryForBuffer(allocator, raw, &ci2, &a, &info);+ // Let VMA infer memory requirements from the buffer+ VkResult res = vmaAllocateMemoryForBuffer(allocator, raw, &ci, &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);- }- }+ if (res != VK_SUCCESS) {+ auto ci2 = ci;+ ci2.flags &= ~VMA_ALLOCATION_CREATE_WITHIN_BUDGET_BIT;+ res = vmaAllocateMemoryForBuffer(allocator, raw, &ci2, &a, &info);- vk::Check(res);- vk::Check(vmaBindBufferMemory2(allocator, a, 0, raw, nullptr));- return MemoryCommit(allocator, 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 Vulkandiff --git a/src/yuzu/main_window.cpp b/src/yuzu/main_window.cppindex 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"#endifdiff --git a/tools/cpm/cmake/package/version.cmake b/tools/cpm/cmake/package/version.cmakeindex 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 cpmfileget_cpmfile_path(file)