Add for windows and Android

Signed-off-by: lizzie <lizzie@eden-emu.dev>

externals/ffmpeg/CMakeLists.txt

@@ -217,7 +217,6 @@ else()
                 --disable-ffmpeg
                 --disable-ffprobe
                 --disable-network
-                --disable-postproc
                 --disable-swresample
                 --enable-decoder=h264
                 --enable-decoder=vp8

src/android/app/build.gradle.kts

@@ -39,7 +39,6 @@ android {
 
     buildFeatures {
         viewBinding = true
-        buildConfig = true
     }
 
     compileOptions {

src/android/gradle.properties

@@ -14,6 +14,8 @@ android.useAndroidX=true
 # Kotlin code style for this project: "official" or "obsolete":
 kotlin.code.style=official
 kotlin.parallel.tasks.in.project=true
+android.defaults.buildfeatures.buildconfig=true
+
 # Android Gradle plugin 8.0.2
 android.suppressUnsupportedCompileSdk=34
 android.native.buildOutput=verbose

src/common/announce_multiplayer_room.h

@@ -34,8 +34,8 @@ struct Member {
 struct RoomInformation {
     std::string name;          ///< Name of the server
     std::string description;   ///< Server description
-    u32 member_slots;          ///< Maximum number of members in this room
-    u16 port;                  ///< The port of this room
+    u32 member_slots{};        ///< Maximum number of members in this room
+    u16 port{};                ///< The port of this room
     GameInfo preferred_game;   ///< Game to advertise that you want to play
     std::string host_username; ///< Forum username of the host
 };
@@ -46,8 +46,8 @@ struct Room {
     std::string id;
     std::string verify_uid; ///< UID used for verification
     std::string ip;
-    u32 net_version;
-    bool has_password;
+    u32 net_version{};
+    bool has_password = false;
 
     std::vector<Member> members;
 };

src/common/fs/file.cpp

@@ -13,12 +13,17 @@
 #include "common/fs/fs_android.h"
 #endif
 #include "common/logging/log.h"
+#include "common/literals.h"
 
 #ifdef _WIN32
 #include <io.h>
 #include <share.h>
+#include <windows.h>
 #else
 #include <unistd.h>
+#include <sys/mman.h>
+#include <sys/stat.h>
+#include <fcntl.h>
 #endif
 
 #ifdef _MSC_VER
@@ -36,13 +41,13 @@ namespace {
 #ifdef _WIN32
 
 /**
- * Converts the file access mode and file type enums to a file access mode wide string.
- *
- * @param mode File access mode
- * @param type File type
- *
- * @returns A pointer to a wide string representing the file access mode.
- */
+* Converts the file access mode and file type enums to a file access mode wide string.
+*
+* @param mode File access mode
+* @param type File type
+*
+* @returns A pointer to a wide string representing the file access mode.
+*/
 [[nodiscard]] constexpr const wchar_t* AccessModeToWStr(FileAccessMode mode, FileType type) {
     switch (type) {
     case FileType::BinaryFile:
@@ -79,12 +84,12 @@ namespace {
 }
 
 /**
- * Converts the file-share access flag enum to a Windows defined file-share access flag.
- *
- * @param flag File-share access flag
- *
- * @returns Windows defined file-share access flag.
- */
+* Converts the file-share access flag enum to a Windows defined file-share access flag.
+*
+* @param flag File-share access flag
+*
+* @returns Windows defined file-share access flag.
+*/
 [[nodiscard]] constexpr int ToWindowsFileShareFlag(FileShareFlag flag) {
     switch (flag) {
     case FileShareFlag::ShareNone:
@@ -102,13 +107,13 @@ namespace {
 #else
 
 /**
- * Converts the file access mode and file type enums to a file access mode string.
- *
- * @param mode File access mode
- * @param type File type
- *
- * @returns A pointer to a string representing the file access mode.
- */
+* Converts the file access mode and file type enums to a file access mode string.
+*
+* @param mode File access mode
+* @param type File type
+*
+* @returns A pointer to a string representing the file access mode.
+*/
 [[nodiscard]] constexpr const char* AccessModeToStr(FileAccessMode mode, FileType type) {
     switch (type) {
     case FileType::BinaryFile:
@@ -147,12 +152,12 @@ namespace {
 #endif
 
 /**
- * Converts the seek origin enum to a seek origin integer.
- *
- * @param origin Seek origin
- *
- * @returns Seek origin integer.
- */
+* Converts the seek origin enum to a seek origin integer.
+*
+* @param origin Seek origin
+*
+* @returns Seek origin integer.
+*/
 [[nodiscard]] constexpr int ToSeekOrigin(SeekOrigin origin) {
     switch (origin) {
     case SeekOrigin::SetOrigin:
@@ -178,7 +183,7 @@ std::string ReadStringFromFile(const std::filesystem::path& path, FileType type)
 }
 
 size_t WriteStringToFile(const std::filesystem::path& path, FileType type,
-                         std::string_view string) {
+                        std::string_view string) {
     if (Exists(path) && !IsFile(path)) {
         return 0;
     }
@@ -189,7 +194,7 @@ size_t WriteStringToFile(const std::filesystem::path& path, FileType type,
 }
 
 size_t AppendStringToFile(const std::filesystem::path& path, FileType type,
-                          std::string_view string) {
+                        std::string_view string) {
     if (Exists(path) && !IsFile(path)) {
         return 0;
     }
@@ -244,15 +249,103 @@ FileType IOFile::GetType() const {
     return file_type;
 }
 
+#ifdef __unix__
+int PlatformMapReadOnly(IOFile& io, const char* path) {
+    io.mmap_fd = open(path., O_RDONLY);
+    if (io.mmap_fd > 0) {
+        struct stat st;
+        fstat(io.mmap_fd, &st);
+        io.mmap_size = st.st_size;
+
+        int map_flags = MAP_PRIVATE;
+#ifdef MAP_PREFAULT_READ
+        // Prefaults reads so the final resulting pagetable from this big stupid mmap()
+        // isn't comically lazily loaded, we just coalesce everything in-place for our
+        // lovely mmap flags; if we didn't prefault the reads the page table will be
+        // constructed in-place (i.e on a read-by-read basis) causing lovely soft-faults
+        // which would nuke any performance gains.
+        //
+        // This of course incurs a cost in the initial mmap(2) call, but that is fine.
+        map_flags |= MAP_PREFAULT_READ;
+#endif
+#ifdef MAP_NOSYNC
+        // This causes physical media to not be synched to our file/memory
+        // This means that if the read-only file is written to, we won't see changes
+        // or we may see changes which are just funnily scattered, in any case
+        // this presumes the files won't be changed during execution
+        //
+        // Do not ever use this on write files (if we ever support that); this will create
+        // a fun amount of fragmentation on the disk.
+        map_flags |= MAP_NOSYNC;
+#endif
+#ifdef MAP_ALIGNED_SUPER
+        // File must be big enough that it's worth to super align. We can't just super-align every
+        // file otherwise we will run out of alignments for actually important files :)
+        // System doesn't guarantee a super alignment, but if it's available it will delete
+        // about 3 layers(?) of the TLB tree for each read/write.
+        // Again the cost of faults may make this negligible gains, but hey, we gotta work
+        // what we gotta work with.
+        using namespace Common::Literals;
+        u64 big_file_threshold = 512_MiB;
+        map_flags |= u64(st.st_size) >= big_file_threshold ? MAP_ALIGNED_SUPER : 0;
+#endif
+        io.mmap_base = (u8*)mmap(nullptr, io.mmap_size, PROT_READ, map_flags, io.mmap_fd, 0);
+        if (io.mmap_base == MAP_FAILED) {
+            close(io.mmap_fd);
+            io.mmap_fd = -1;
+        } else {
+            posix_madvise(mmap_base, io.mmap_size, POSIX_MADV_WILLNEED);
+        }
+    }
+    return io.mmap_fd;
+}
+void PlatformUnmap(IOFile& io) {
+    if (io.mmap_fd != -1) {
+        munmap(io.mmap_base, io.mmap_size);
+        close(io.mmap_fd);
+        io.mmap_fd = -1;
+    }
+}
+#else
+int PlatformMapReadOnly(IOFile& io, const char* path) {
+    io.file_handle = CreateFileA(path, GENERIC_READ, FILE_SHARE_READ, nullptr, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL | FILE_FLAG_SEQUENTIAL_SCAN, nullptr);
+    if (HANDLE(io.file_handle) != INVALID_HANDLE_VALUE) {
+        io.mapping_handle = CreateFileMappingW(file_handle, nullptr, PAGE_READONLY, 0, 0, nullptr);
+        if (io.mapping_handle) {
+            io.mmap_base = (char const*)MapViewOfFile(HANDLE(io.mapping_handle), FILE_MAP_READ, 0, 0, 0);
+            if (io.mmap_base) {
+                _LARGE_INTEGER pvalue;
+                GetFileSizeEx(file_handle, &pvalue);
+                io.mmap_size = uint32_t(pvalue.QuadPart);
+            } else {
+                CloseHandle(io.mapping_handle);
+                CloseHandle(io.file_handle);
+                return -1;
+            }
+        } else {
+            CloseHandle(io.file_handle);
+            return -1;
+        }
+    }
+    return 0;
+}
+void PlatformUnmap(IOFile& io) {
+    if(io.mapping_handle) {
+        if(io.mmap_base)
+            UnmapViewOfFile(HANDLE(io.mmap_base));
+        CloseHandle(HANDLE(io.mapping_handle));
+    }
+    if(io.file_handle != INVALID_HANDLE_VALUE)
+        CloseHandle(HANDLE(io.file_handle));
+}
+#endif
+
 void IOFile::Open(const fs::path& path, FileAccessMode mode, FileType type, FileShareFlag flag) {
     Close();
-
     file_path = path;
     file_access_mode = mode;
     file_type = type;
-
     errno = 0;
-
 #ifdef _WIN32
     if (flag != FileShareFlag::ShareNone) {
         file = _wfsopen(path.c_str(), AccessModeToWStr(mode, type), ToWindowsFileShareFlag(flag));
@@ -262,51 +355,58 @@ void IOFile::Open(const fs::path& path, FileAccessMode mode, FileType type, File
 #elif ANDROID
     if (Android::IsContentUri(path)) {
         ASSERT_MSG(mode == FileAccessMode::Read, "Content URI file access is for read-only!");
-        const auto fd = Android::OpenContentUri(path, Android::OpenMode::Read);
-        if (fd != -1) {
-            file = fdopen(fd, "r");
-            const auto error_num = errno;
-            if (error_num != 0 && file == nullptr) {
-                LOG_ERROR(Common_Filesystem, "Error opening file: {}, error: {}", path.c_str(),
-                          strerror(error_num));
+        if (PlatformMapReadOnly(*this, path.c_str()) == -1) {
+            LOG_ERROR(Common_Filesystem, "Error mmap'ing file: {}", path.c_str());
+            int const fd = Android::OpenContentUri(path, Android::OpenMode::Read);
+            if (fd != -1) {
+                file = fdopen(fd, "r");
+                if (errno != 0 && file == nullptr)
+                    LOG_ERROR(Common_Filesystem, "Error opening file: {}, error: {}", path.c_str(), strerror(errno));
+            } else {
+                LOG_ERROR(Common_Filesystem, "Error opening file: {}", path.c_str());
             }
-        } else {
-            LOG_ERROR(Common_Filesystem, "Error opening file: {}", path.c_str());
         }
     } else {
         file = std::fopen(path.c_str(), AccessModeToStr(mode, type));
     }
+#elif defined(__HAIKU__) || defined(__managarm__) || defined(__OPENORBIS__) || defined(__APPLE__)
+    file = std::fopen(path.c_str(), AccessModeToStr(mode, type));
+#elif defined(__unix__)
+    if (type == FileType::BinaryFile && mode == FileAccessMode::Read) {
+        if (PlatformMapReadOnly(*this, path.c_str()) == -1) {
+            LOG_ERROR(Common_Filesystem, "Error mmap'ing file: {}", path.c_str());
+        }
+    }
+    if (mmap_fd == -1) {
+        file = std::fopen(path.c_str(), AccessModeToStr(mode, type)); // mmap(2) failed or simply we can't use it
+    }
 #else
+    // Some other fancy OS (ahem fucking Darwin/Mac OSX)
     file = std::fopen(path.c_str(), AccessModeToStr(mode, type));
 #endif
-
     if (!IsOpen()) {
         const auto ec = std::error_code{errno, std::generic_category()};
         LOG_ERROR(Common_Filesystem, "Failed to open the file at path={}, ec_message={}",
-                  PathToUTF8String(file_path), ec.message());
+            PathToUTF8String(file_path), ec.message());
     }
 }
 
 void IOFile::Close() {
-    if (!IsOpen()) {
-        return;
+    PlatformUnmap(*this);
+    if (file) {
+        errno = 0;
+        const auto close_result = std::fclose(file) == 0;
+        if (!close_result) {
+            const auto ec = std::error_code{errno, std::generic_category()};
+            LOG_ERROR(Common_Filesystem, "Failed to close the file at path={}, ec_message={}",
+                PathToUTF8String(file_path), ec.message());
+        }
+        file = nullptr;
     }
-
-    errno = 0;
-
-    const auto close_result = std::fclose(file) == 0;
-
-    if (!close_result) {
-        const auto ec = std::error_code{errno, std::generic_category()};
-        LOG_ERROR(Common_Filesystem, "Failed to close the file at path={}, ec_message={}",
-                  PathToUTF8String(file_path), ec.message());
-    }
-
-    file = nullptr;
 }
 
 bool IOFile::IsOpen() const {
-    return file != nullptr;
+    return file != nullptr || IsMappedFile();
 }
 
 std::string IOFile::ReadString(size_t length) const {
@@ -323,137 +423,132 @@ size_t IOFile::WriteString(std::span<const char> string) const {
 }
 
 bool IOFile::Flush() const {
-    if (!IsOpen()) {
-        return false;
+    ASSERT(!IsMappedFile());
+    if (file) {
+        errno = 0;
+        auto const flush_result = std::fflush(file) == 0;
+        if (!flush_result) {
+            const auto ec = std::error_code{errno, std::generic_category()};
+            LOG_ERROR(Common_Filesystem, "Failed to flush the file at path={}, ec_message={}",
+                PathToUTF8String(file_path), ec.message());
+        }
+        return flush_result;
     }
-
-    errno = 0;
-
-#ifdef _WIN32
-    const auto flush_result = std::fflush(file) == 0;
-#else
-    const auto flush_result = std::fflush(file) == 0;
-#endif
-
-    if (!flush_result) {
-        const auto ec = std::error_code{errno, std::generic_category()};
-        LOG_ERROR(Common_Filesystem, "Failed to flush the file at path={}, ec_message={}",
-                  PathToUTF8String(file_path), ec.message());
-    }
-
-    return flush_result;
+    return false;
 }
 
 bool IOFile::Commit() const {
-    if (!IsOpen()) {
-        return false;
-    }
-
-    errno = 0;
-
+    ASSERT(!IsMappedFile());
+    if (file) {
+        errno = 0;
 #ifdef _WIN32
-    const auto commit_result = std::fflush(file) == 0 && _commit(fileno(file)) == 0;
+        const auto commit_result = std::fflush(file) == 0 && _commit(fileno(file)) == 0;
 #else
-    const auto commit_result = std::fflush(file) == 0 && fsync(fileno(file)) == 0;
+        const auto commit_result = std::fflush(file) == 0 && fsync(fileno(file)) == 0;
 #endif
-
-    if (!commit_result) {
-        const auto ec = std::error_code{errno, std::generic_category()};
-        LOG_ERROR(Common_Filesystem, "Failed to commit the file at path={}, ec_message={}",
-                  PathToUTF8String(file_path), ec.message());
+        if (!commit_result) {
+            const auto ec = std::error_code{errno, std::generic_category()};
+            LOG_ERROR(Common_Filesystem, "Failed to commit the file at path={}, ec_message={}",
+                PathToUTF8String(file_path), ec.message());
+        }
+        return commit_result;
     }
-
-    return commit_result;
+    return false;
 }
 
 bool IOFile::SetSize(u64 size) const {
-    if (!IsOpen()) {
-        return false;
-    }
-
-    errno = 0;
-
+    ASSERT(!IsMappedFile());
+    if (file) {
+        errno = 0;
 #ifdef _WIN32
-    const auto set_size_result = _chsize_s(fileno(file), static_cast<s64>(size)) == 0;
+        const auto set_size_result = _chsize_s(fileno(file), s64(size)) == 0;
 #else
-    const auto set_size_result = ftruncate(fileno(file), static_cast<s64>(size)) == 0;
+        const auto set_size_result = ftruncate(fileno(file), s64(size)) == 0;
 #endif
-
-    if (!set_size_result) {
-        const auto ec = std::error_code{errno, std::generic_category()};
-        LOG_ERROR(Common_Filesystem, "Failed to resize the file at path={}, size={}, ec_message={}",
-                  PathToUTF8String(file_path), size, ec.message());
+        if (!set_size_result) {
+            const auto ec = std::error_code{errno, std::generic_category()};
+            LOG_ERROR(Common_Filesystem, "Failed to resize the file at path={}, size={}, ec_message={}",
+                PathToUTF8String(file_path), size, ec.message());
+        }
+        return set_size_result;
     }
-
-    return set_size_result;
+    return false;
 }
 
 u64 IOFile::GetSize() const {
-    if (!IsOpen()) {
-        return 0;
-    }
-
-    // Flush any unwritten buffered data into the file prior to retrieving the file size.
-    std::fflush(file);
-
+    if (IsMappedFile())
+        return mmap_size;
+    if (file) {
+        // Flush any unwritten buffered data into the file prior to retrieving the file mmap_size.
+        std::fflush(file);
 #if ANDROID
-    u64 file_size = 0;
-    if (Android::IsContentUri(file_path)) {
-        file_size = Android::GetSize(file_path);
-    } else {
+        u64 file_size = 0;
+        if (Android::IsContentUri(file_path)) {
+            file_size = Android::GetSize(file_path);
+        } else {
+            std::error_code ec;
+
+            file_size = fs::file_size(file_path, ec);
+
+            if (ec) {
+                LOG_ERROR(Common_Filesystem, "Failed to retrieve the file mmap_size of path={}, ec_message={}",
+                    PathToUTF8String(file_path), ec.message());
+                return 0;
+            }
+        }
+#else
         std::error_code ec;
-
-        file_size = fs::file_size(file_path, ec);
-
+        auto const file_size = fs::file_size(file_path, ec);
         if (ec) {
-            LOG_ERROR(Common_Filesystem,
-                      "Failed to retrieve the file size of path={}, ec_message={}",
-                      PathToUTF8String(file_path), ec.message());
+            LOG_ERROR(Common_Filesystem, "Failed to retrieve the file mmap_size of path={}, ec_message={}",
+                PathToUTF8String(file_path), ec.message());
             return 0;
         }
-    }
-#else
-    std::error_code ec;
-
-    const auto file_size = fs::file_size(file_path, ec);
-
-    if (ec) {
-        LOG_ERROR(Common_Filesystem, "Failed to retrieve the file size of path={}, ec_message={}",
-                  PathToUTF8String(file_path), ec.message());
-        return 0;
-    }
 #endif
-
-    return file_size;
+        return file_size;
+    }
+    return 0;
 }
 
 bool IOFile::Seek(s64 offset, SeekOrigin origin) const {
-    if (!IsOpen()) {
-        return false;
+    if (IsMappedFile()) {
+        // fuck you to whoever made this method const
+        switch (origin) {
+        case SeekOrigin::SetOrigin:
+            mmap_offset = off_t(offset);
+            break;
+        case SeekOrigin::CurrentPosition:
+            mmap_offset += off_t(offset);
+            break;
+        case SeekOrigin::End:
+            mmap_offset = off_t(mmap_size) + off_t(offset);
+            break;
+        }
+        return true;
     }
-
-    errno = 0;
-
-    const auto seek_result = fseeko(file, offset, ToSeekOrigin(origin)) == 0;
-
-    if (!seek_result) {
-        const auto ec = std::error_code{errno, std::generic_category()};
-        LOG_ERROR(Common_Filesystem,
-                  "Failed to seek the file at path={}, offset={}, origin={}, ec_message={}",
-                  PathToUTF8String(file_path), offset, origin, ec.message());
+    if (file) {
+        errno = 0;
+        const auto seek_result = fseeko(file, offset, ToSeekOrigin(origin)) == 0;
+        if (!seek_result) {
+            const auto ec = std::error_code{errno, std::generic_category()};
+            LOG_ERROR(Common_Filesystem, "Failed to seek the file at path={}, offset={}, origin={}, ec_message={}",
+                PathToUTF8String(file_path), offset, origin, ec.message());
+        }
+        return seek_result;
     }
-
-    return seek_result;
+    return false;
 }
 
 s64 IOFile::Tell() const {
-    if (!IsOpen()) {
-        return 0;
+    if (IsMappedFile()) {
+        errno = 0;
+        return s64(mmap_offset);
     }
-
-    errno = 0;
-
-    return ftello(file);
+    if (file) {
+        errno = 0;
+        return ftello(file);
+    }
+    return 0;
 }
 
 } // namespace Common::FS

src/common/fs/file.h

@@ -1,9 +1,13 @@
+// SPDX-FileCopyrightText: Copyright 2025 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 <cstdio>
+#include <cstring>
 #include <filesystem>
 #include <span>
 #include <type_traits>
@@ -21,12 +25,12 @@ enum class SeekOrigin {
 };
 
 /**
- * Opens a file stream at path with the specified open mode.
- *
- * @param file_stream Reference to file stream
- * @param path Filesystem path
- * @param open_mode File stream open mode
- */
+* Opens a file stream at path with the specified open mode.
+*
+* @param file_stream Reference to file stream
+* @param path Filesystem path
+* @param open_mode File stream open mode
+*/
 template <typename FileStream>
 void OpenFileStream(FileStream& file_stream, const std::filesystem::path& path,
                     std::ios_base::openmode open_mode) {
@@ -45,14 +49,14 @@ void OpenFileStream(FileStream& file_stream, const Path& path, std::ios_base::op
 #endif
 
 /**
- * Reads an entire file at path and returns a string of the contents read from the file.
- * If the filesystem object at path is not a regular file, this function returns an empty string.
- *
- * @param path Filesystem path
- * @param type File type
- *
- * @returns A string of the contents read from the file.
- */
+* Reads an entire file at path and returns a string of the contents read from the file.
+* If the filesystem object at path is not a regular file, this function returns an empty string.
+*
+* @param path Filesystem path
+* @param type File type
+*
+* @returns A string of the contents read from the file.
+*/
 [[nodiscard]] std::string ReadStringFromFile(const std::filesystem::path& path, FileType type);
 
 #ifdef _WIN32
@@ -67,18 +71,18 @@ template <typename Path>
 #endif
 
 /**
- * Writes a string to a file at path and returns the number of characters successfully written.
- * If a file already exists at path, its contents will be erased.
- * If a file does not exist at path, it creates and opens a new empty file for writing.
- * If the filesystem object at path exists and is not a regular file, this function returns 0.
- *
- * @param path Filesystem path
- * @param type File type
- *
- * @returns Number of characters successfully written.
- */
+* Writes a string to a file at path and returns the number of characters successfully written.
+* If a file already exists at path, its contents will be erased.
+* If a file does not exist at path, it creates and opens a new empty file for writing.
+* If the filesystem object at path exists and is not a regular file, this function returns 0.
+*
+* @param path Filesystem path
+* @param type File type
+*
+* @returns Number of characters successfully written.
+*/
 [[nodiscard]] size_t WriteStringToFile(const std::filesystem::path& path, FileType type,
-                                       std::string_view string);
+                                    std::string_view string);
 
 #ifdef _WIN32
 template <typename Path>
@@ -92,15 +96,15 @@ template <typename Path>
 #endif
 
 /**
- * Appends a string to a file at path and returns the number of characters successfully written.
- * If a file does not exist at path, it creates and opens a new empty file for appending.
- * If the filesystem object at path exists and is not a regular file, this function returns 0.
- *
- * @param path Filesystem path
- * @param type File type
- *
- * @returns Number of characters successfully written.
- */
+* Appends a string to a file at path and returns the number of characters successfully written.
+* If a file does not exist at path, it creates and opens a new empty file for appending.
+* If the filesystem object at path exists and is not a regular file, this function returns 0.
+*
+* @param path Filesystem path
+* @param type File type
+*
+* @returns Number of characters successfully written.
+*/
 [[nodiscard]] size_t AppendStringToFile(const std::filesystem::path& path, FileType type,
                                         std::string_view string);
 
@@ -128,14 +132,14 @@ public:
                     FileShareFlag flag = FileShareFlag::ShareReadOnly);
 
     /**
-     * An IOFile is a lightweight wrapper on C Library file operations.
-     * Automatically closes an open file on the destruction of an IOFile object.
-     *
-     * @param path Filesystem path
-     * @param mode File access mode
-     * @param type File type, default is BinaryFile. Use TextFile to open the file as a text file
-     * @param flag (Windows only) File-share access flag, default is ShareReadOnly
-     */
+    * An IOFile is a lightweight wrapper on C Library file operations.
+    * Automatically closes an open file on the destruction of an IOFile object.
+    *
+    * @param path Filesystem path
+    * @param mode File access mode
+    * @param type File type, default is BinaryFile. Use TextFile to open the file as a text file
+    * @param flag (Windows only) File-share access flag, default is ShareReadOnly
+    */
     explicit IOFile(const std::filesystem::path& path, FileAccessMode mode,
                     FileType type = FileType::BinaryFile,
                     FileShareFlag flag = FileShareFlag::ShareReadOnly);
@@ -149,84 +153,70 @@ public:
     IOFile& operator=(IOFile&& other) noexcept;
 
     /**
-     * Gets the path of the file.
-     *
-     * @returns The path of the file.
-     */
+    * Gets the path of the file.
+    *
+    * @returns The path of the file.
+    */
     [[nodiscard]] std::filesystem::path GetPath() const;
 
     /**
-     * Gets the access mode of the file.
-     *
-     * @returns The access mode of the file.
-     */
+    * Gets the access mode of the file.
+    *
+    * @returns The access mode of the file.
+    */
     [[nodiscard]] FileAccessMode GetAccessMode() const;
 
     /**
-     * Gets the type of the file.
-     *
-     * @returns The type of the file.
-     */
+    * Gets the type of the file.
+    *
+    * @returns The type of the file.
+    */
     [[nodiscard]] FileType GetType() const;
 
     /**
-     * Opens a file at path with the specified file access mode.
-     * This function behaves differently depending on the FileAccessMode.
-     * These behaviors are documented in each enum value of FileAccessMode.
-     *
-     * @param path Filesystem path
-     * @param mode File access mode
-     * @param type File type, default is BinaryFile. Use TextFile to open the file as a text file
-     * @param flag (Windows only) File-share access flag, default is ShareReadOnly
-     */
+    * Opens a file at path with the specified file access mode.
+    * This function behaves differently depending on the FileAccessMode.
+    * These behaviors are documented in each enum value of FileAccessMode.
+    *
+    * @param path Filesystem path
+    * @param mode File access mode
+    * @param type File type, default is BinaryFile. Use TextFile to open the file as a text file
+    * @param flag (Windows only) File-share access flag, default is ShareReadOnly
+    */
     void Open(const std::filesystem::path& path, FileAccessMode mode,
-              FileType type = FileType::BinaryFile,
-              FileShareFlag flag = FileShareFlag::ShareReadOnly);
-
-// #ifdef _WIN32
-//     template <typename Path>
-//     void Open(const Path& path, FileAccessMode mode, FileType type = FileType::BinaryFile,
-//               FileShareFlag flag = FileShareFlag::ShareReadOnly) {
-//         using ValueType = typename Path::value_type;
-//         if constexpr (IsChar<ValueType>) {
-//             Open(ToU8String(path), mode, type, flag);
-//         } else {
-//             Open(std::filesystem::path{path}, mode, type, flag);
-//         }
-//     }
-// #endif
+            FileType type = FileType::BinaryFile,
+            FileShareFlag flag = FileShareFlag::ShareReadOnly);
 
     /// Closes the file if it is opened.
     void Close();
 
     /**
-     * Checks whether the file is open.
-     * Use this to check whether the calls to Open() or Close() succeeded.
-     *
-     * @returns True if the file is open, false otherwise.
-     */
+    * Checks whether the file is open.
+    * Use this to check whether the calls to Open() or Close() succeeded.
+    *
+    * @returns True if the file is open, false otherwise.
+    */
     [[nodiscard]] bool IsOpen() const;
 
     /**
-     * Helper function which deduces the value type of a contiguous STL container used in ReadSpan.
-     * If T is not a contiguous container as defined by the concept IsContiguousContainer, this
-     * calls ReadObject and T must be a trivially copyable object.
-     *
-     * See ReadSpan for more details if T is a contiguous container.
-     * See ReadObject for more details if T is a trivially copyable object.
-     *
-     * @tparam T Contiguous container or trivially copyable object
-     *
-     * @param data Container of T::value_type data or reference to object
-     *
-     * @returns Count of T::value_type data or objects successfully read.
-     */
+    * Helper function which deduces the value type of a contiguous STL container used in ReadSpan.
+    * If T is not a contiguous container as defined by the concept IsContiguousContainer, this
+    * calls ReadObject and T must be a trivially copyable object.
+    *
+    * See ReadSpan for more details if T is a contiguous container.
+    * See ReadObject for more details if T is a trivially copyable object.
+    *
+    * @tparam T Contiguous container or trivially copyable object
+    *
+    * @param data Container of T::value_type data or reference to object
+    *
+    * @returns Count of T::value_type data or objects successfully read.
+    */
     template <typename T>
     [[nodiscard]] size_t Read(T& data) const {
         if constexpr (IsContiguousContainer<T>) {
             using ContiguousType = typename T::value_type;
-            static_assert(std::is_trivially_copyable_v<ContiguousType>,
-                          "Data type must be trivially copyable.");
+            static_assert(std::is_trivially_copyable_v<ContiguousType>, "Data type must be trivially copyable.");
             return ReadSpan<ContiguousType>(data);
         } else {
             return ReadObject(data) ? 1 : 0;
@@ -234,25 +224,24 @@ public:
     }
 
     /**
-     * Helper function which deduces the value type of a contiguous STL container used in WriteSpan.
-     * If T is not a contiguous STL container as defined by the concept IsContiguousContainer, this
-     * calls WriteObject and T must be a trivially copyable object.
-     *
-     * See WriteSpan for more details if T is a contiguous container.
-     * See WriteObject for more details if T is a trivially copyable object.
-     *
-     * @tparam T Contiguous container or trivially copyable object
-     *
-     * @param data Container of T::value_type data or const reference to object
-     *
-     * @returns Count of T::value_type data or objects successfully written.
-     */
+    * Helper function which deduces the value type of a contiguous STL container used in WriteSpan.
+    * If T is not a contiguous STL container as defined by the concept IsContiguousContainer, this
+    * calls WriteObject and T must be a trivially copyable object.
+    *
+    * See WriteSpan for more details if T is a contiguous container.
+    * See WriteObject for more details if T is a trivially copyable object.
+    *
+    * @tparam T Contiguous container or trivially copyable object
+    *
+    * @param data Container of T::value_type data or const reference to object
+    *
+    * @returns Count of T::value_type data or objects successfully written.
+    */
     template <typename T>
     [[nodiscard]] size_t Write(const T& data) const {
         if constexpr (IsContiguousContainer<T>) {
             using ContiguousType = typename T::value_type;
-            static_assert(std::is_trivially_copyable_v<ContiguousType>,
-                          "Data type must be trivially copyable.");
+            static_assert(std::is_trivially_copyable_v<ContiguousType>, "Data type must be trivially copyable.");
             return WriteSpan<ContiguousType>(data);
         } else {
             static_assert(std::is_trivially_copyable_v<T>, "Data type must be trivially copyable.");
@@ -261,199 +250,209 @@ public:
     }
 
     /**
-     * Reads a span of T data from a file sequentially.
-     * This function reads from the current position of the file pointer and
-     * advances it by the (count of T * sizeof(T)) bytes successfully read.
-     *
-     * Failures occur when:
-     * - The file is not open
-     * - The opened file lacks read permissions
-     * - Attempting to read beyond the end-of-file
-     *
-     * @tparam T Data type
-     *
-     * @param data Span of T data
-     *
-     * @returns Count of T data successfully read.
-     */
+    * Reads a span of T data from a file sequentially.
+    * This function reads from the current position of the file pointer and
+    * advances it by the (count of T * sizeof(T)) bytes successfully read.
+    *
+    * Failures occur when:
+    * - The file is not open
+    * - The opened file lacks read permissions
+    * - Attempting to read beyond the end-of-file
+    *
+    * @tparam T Data type
+    *
+    * @param data Span of T data
+    *
+    * @returns Count of T data successfully read.
+    */
     template <typename T>
     [[nodiscard]] size_t ReadSpan(std::span<T> data) const {
         static_assert(std::is_trivially_copyable_v<T>, "Data type must be trivially copyable.");
-
-        if (!IsOpen()) {
-            return 0;
+        if (IsMappedFile()) {
+            std::memcpy(data.data(), mmap_base + mmap_offset, sizeof(T) * data.size());
+            return data.size();
         }
-
-        return std::fread(data.data(), sizeof(T), data.size(), file);
+        return IsOpen() ? std::fread(data.data(), sizeof(T), data.size(), file) : 0;
     }
 
     /**
-     * Writes a span of T data to a file sequentially.
-     * This function writes from the current position of the file pointer and
-     * advances it by the (count of T * sizeof(T)) bytes successfully written.
-     *
-     * Failures occur when:
-     * - The file is not open
-     * - The opened file lacks write permissions
-     *
-     * @tparam T Data type
-     *
-     * @param data Span of T data
-     *
-     * @returns Count of T data successfully written.
-     */
+    * Writes a span of T data to a file sequentially.
+    * This function writes from the current position of the file pointer and
+    * advances it by the (count of T * sizeof(T)) bytes successfully written.
+    *
+    * Failures occur when:
+    * - The file is not open
+    * - The opened file lacks write permissions
+    *
+    * @tparam T Data type
+    *
+    * @param data Span of T data
+    *
+    * @returns Count of T data successfully written.
+    */
     template <typename T>
     [[nodiscard]] size_t WriteSpan(std::span<const T> data) const {
         static_assert(std::is_trivially_copyable_v<T>, "Data type must be trivially copyable.");
-
-        if (!IsOpen()) {
-            return 0;
+        if (IsMappedFile()) {
+            std::memcpy(mmap_base + mmap_offset, data.data(), sizeof(T) * data.size());
+            return data.size();
         }
-
-        return std::fwrite(data.data(), sizeof(T), data.size(), file);
+        return IsOpen() ? std::fwrite(data.data(), sizeof(T), data.size(), file) : 0;
     }
 
     /**
-     * Reads a T object from a file sequentially.
-     * This function reads from the current position of the file pointer and
-     * advances it by the sizeof(T) bytes successfully read.
-     *
-     * Failures occur when:
-     * - The file is not open
-     * - The opened file lacks read permissions
-     * - Attempting to read beyond the end-of-file
-     *
-     * @tparam T Data type
-     *
-     * @param object Reference to object
-     *
-     * @returns True if the object is successfully read from the file, false otherwise.
-     */
+    * Reads a T object from a file sequentially.
+    * This function reads from the current position of the file pointer and
+    * advances it by the sizeof(T) bytes successfully read.
+    *
+    * Failures occur when:
+    * - The file is not open
+    * - The opened file lacks read permissions
+    * - Attempting to read beyond the end-of-file
+    *
+    * @tparam T Data type
+    *
+    * @param object Reference to object
+    *
+    * @returns True if the object is successfully read from the file, false otherwise.
+    */
     template <typename T>
     [[nodiscard]] bool ReadObject(T& object) const {
         static_assert(std::is_trivially_copyable_v<T>, "Data type must be trivially copyable.");
         static_assert(!std::is_pointer_v<T>, "T must not be a pointer to an object.");
-
-        if (!IsOpen()) {
-            return false;
+        if (IsMappedFile()) {
+            std::memcpy(&object, mmap_base + mmap_offset, sizeof(T));
+            return sizeof(T);
         }
-
-        return std::fread(&object, sizeof(T), 1, file) == 1;
+        return IsOpen() ? std::fread(&object, sizeof(T), 1, file) == 1 : false;
     }
 
     /**
-     * Writes a T object to a file sequentially.
-     * This function writes from the current position of the file pointer and
-     * advances it by the sizeof(T) bytes successfully written.
-     *
-     * Failures occur when:
-     * - The file is not open
-     * - The opened file lacks write permissions
-     *
-     * @tparam T Data type
-     *
-     * @param object Const reference to object
-     *
-     * @returns True if the object is successfully written to the file, false otherwise.
-     */
+    * Writes a T object to a file sequentially.
+    * This function writes from the current position of the file pointer and
+    * advances it by the sizeof(T) bytes successfully written.
+    *
+    * Failures occur when:
+    * - The file is not open
+    * - The opened file lacks write permissions
+    *
+    * @tparam T Data type
+    *
+    * @param object Const reference to object
+    *
+    * @returns True if the object is successfully written to the file, false otherwise.
+    */
     template <typename T>
     [[nodiscard]] bool WriteObject(const T& object) const {
         static_assert(std::is_trivially_copyable_v<T>, "Data type must be trivially copyable.");
         static_assert(!std::is_pointer_v<T>, "T must not be a pointer to an object.");
-
-        if (!IsOpen()) {
-            return false;
+        if (IsMappedFile()) {
+            std::memcpy(mmap_base + mmap_offset, &object, sizeof(T));
+            return sizeof(T);
         }
-
-        return std::fwrite(&object, sizeof(T), 1, file) == 1;
+        return IsOpen() ? std::fwrite(&object, sizeof(T), 1, file) == 1 : false;
     }
 
     /**
-     * Specialized function to read a string of a given length from a file sequentially.
-     * This function writes from the current position of the file pointer and
-     * advances it by the number of characters successfully read.
-     * The size of the returned string may not match length if not all bytes are successfully read.
-     *
-     * @param length Length of the string
-     *
-     * @returns A string read from the file.
-     */
+    * Specialized function to read a string of a given length from a file sequentially.
+    * This function writes from the current position of the file pointer and
+    * advances it by the number of characters successfully read.
+    * The size of the returned string may not match length if not all bytes are successfully read.
+    *
+    * @param length Length of the string
+    *
+    * @returns A string read from the file.
+    */
     [[nodiscard]] std::string ReadString(size_t length) const;
 
     /**
-     * Specialized function to write a string to a file sequentially.
-     * This function writes from the current position of the file pointer and
-     * advances it by the number of characters successfully written.
-     *
-     * @param string Span of const char backed std::string or std::string_view
-     *
-     * @returns Number of characters successfully written.
-     */
+    * Specialized function to write a string to a file sequentially.
+    * This function writes from the current position of the file pointer and
+    * advances it by the number of characters successfully written.
+    *
+    * @param string Span of const char backed std::string or std::string_view
+    *
+    * @returns Number of characters successfully written.
+    */
     [[nodiscard]] size_t WriteString(std::span<const char> string) const;
 
     /**
-     * Attempts to flush any unwritten buffered data into the file.
-     *
-     * @returns True if the flush was successful, false otherwise.
-     */
+    * Attempts to flush any unwritten buffered data into the file.
+    *
+    * @returns True if the flush was successful, false otherwise.
+    */
     bool Flush() const;
 
     /**
-     * Attempts to commit the file into the disk.
-     * Note that this is an expensive operation as this forces the operating system to write
-     * the contents of the file associated with the file descriptor into the disk.
-     *
-     * @returns True if the commit was successful, false otherwise.
-     */
+    * Attempts to commit the file into the disk.
+    * Note that this is an expensive operation as this forces the operating system to write
+    * the contents of the file associated with the file descriptor into the disk.
+    *
+    * @returns True if the commit was successful, false otherwise.
+    */
     bool Commit() const;
 
     /**
-     * Resizes the file to a given size.
-     * If the file is resized to a smaller size, the remainder of the file is discarded.
-     * If the file is resized to a larger size, the new area appears as if zero-filled.
-     *
-     * Failures occur when:
-     * - The file is not open
-     *
-     * @param size File size in bytes
-     *
-     * @returns True if the file resize succeeded, false otherwise.
-     */
+    * Resizes the file to a given size.
+    * If the file is resized to a smaller size, the remainder of the file is discarded.
+    * If the file is resized to a larger size, the new area appears as if zero-filled.
+    *
+    * Failures occur when:
+    * - The file is not open
+    *
+    * @param size File size in bytes
+    *
+    * @returns True if the file resize succeeded, false otherwise.
+    */
     [[nodiscard]] bool SetSize(u64 size) const;
 
     /**
-     * Gets the size of the file.
-     *
-     * Failures occur when:
-     * - The file is not open
-     *
-     * @returns The file size in bytes of the file. Returns 0 on failure.
-     */
+    * Gets the size of the file.
+    *
+    * Failures occur when:
+    * - The file is not open
+    *
+    * @returns The file size in bytes of the file. Returns 0 on failure.
+    */
     [[nodiscard]] u64 GetSize() const;
 
     /**
-     * Moves the current position of the file pointer with the specified offset and seek origin.
-     *
-     * @param offset Offset from seek origin
-     * @param origin Seek origin
-     *
-     * @returns True if the file pointer has moved to the specified offset, false otherwise.
-     */
+    * Moves the current position of the file pointer with the specified offset and seek origin.
+    *
+    * @param offset Offset from seek origin
+    * @param origin Seek origin
+    *
+    * @returns True if the file pointer has moved to the specified offset, false otherwise.
+    */
     [[nodiscard]] bool Seek(s64 offset, SeekOrigin origin = SeekOrigin::SetOrigin) const;
 
     /**
-     * Gets the current position of the file pointer.
-     *
-     * @returns The current position of the file pointer.
-     */
+    * Gets the current position of the file pointer.
+    *
+    * @returns The current position of the file pointer.
+    */
     [[nodiscard]] s64 Tell() const;
 
 private:
     std::filesystem::path file_path;
     FileAccessMode file_access_mode{};
     FileType file_type{};
-
     std::FILE* file = nullptr;
+
+    // Any decent system should have mmap() for files
+    // Systems with artifical mmap() limitations should simply change the logic within file.cpp
+    // and reduce the threshold for which the mmap() is set to
+#ifdef _WIN32
+    void *mapping_handle = nullptr;
+    void *file_handle = nullptr;
+    bool IsMappedFile() { return file_handle != nullptr; }
+#else // POSIX
+    int mmap_fd = -1;
+    bool IsMappedFile() { return mmap_fd != -1; }
+#endif
+    u8* mmap_base = nullptr;
+    size_t mmap_size = 0;
+    mutable off_t mmap_offset = 0; // fuck you
 };
 
 } // namespace Common::FS

src/core/frontend/applets/cabinet.h

@@ -21,7 +21,7 @@ namespace Core::Frontend {
 struct CabinetParameters {
     Service::NFP::TagInfo tag_info;
     Service::NFP::RegisterInfo register_info;
-    Service::NFP::CabinetMode mode;
+    Service::NFP::CabinetMode mode{};
 };
 
 using CabinetCallback = std::function<void(bool, const std::string&)>;

src/core/frontend/applets/software_keyboard.h

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2025 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
 
@@ -20,9 +23,9 @@ struct KeyboardInitializeParameters {
     std::u16string initial_text;
     char16_t left_optional_symbol_key;
     char16_t right_optional_symbol_key;
-    u32 max_text_length;
-    u32 min_text_length;
-    s32 initial_cursor_position;
+    u32 max_text_length{};
+    u32 min_text_length{};
+    s32 initial_cursor_position{};
     Service::AM::Frontend::SwkbdType type;
     Service::AM::Frontend::SwkbdPasswordMode password_mode;
     Service::AM::Frontend::SwkbdTextDrawType text_draw_type;
@@ -34,12 +37,12 @@ struct KeyboardInitializeParameters {
 };
 
 struct InlineAppearParameters {
-    u32 max_text_length;
-    u32 min_text_length;
-    f32 key_top_scale_x;
-    f32 key_top_scale_y;
-    f32 key_top_translate_x;
-    f32 key_top_translate_y;
+    u32 max_text_length{};
+    u32 min_text_length{};
+    f32 key_top_scale_x{};
+    f32 key_top_scale_y{};
+    f32 key_top_translate_x{};
+    f32 key_top_translate_y{};
     Service::AM::Frontend::SwkbdType type;
     Service::AM::Frontend::SwkbdKeyDisableFlags key_disable_flags;
     bool key_top_as_floating;
@@ -50,7 +53,7 @@ struct InlineAppearParameters {
 
 struct InlineTextParameters {
     std::u16string input_text;
-    s32 cursor_position;
+    s32 cursor_position{};
 };
 
 class SoftwareKeyboardApplet : public Applet {

src/core/hle/service/nfc/nfc_types.h

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
@@ -79,7 +82,7 @@ using DeviceHandle = u64;
 
 // This is nn::nfc::TagInfo
 struct TagInfo {
-    UniqueSerialNumber uuid;
+    UniqueSerialNumber uuid{};
     u8 uuid_length;
     INSERT_PADDING_BYTES(0x15);
     NfcProtocol protocol;

src/core/hle/service/nfp/nfp_types.h

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
@@ -315,7 +318,7 @@ static_assert(sizeof(ModelInfo) == 0x40, "ModelInfo is an invalid size");
 // This is nn::nfp::RegisterInfo
 struct RegisterInfo {
     Service::Mii::CharInfo mii_char_info;
-    WriteDate creation_date;
+    WriteDate creation_date{};
     AmiiboName amiibo_name;
     u8 font_region;
     INSERT_PADDING_BYTES(0x7A);

src/core/hle/service/ns/platform_service_manager.cpp

@@ -164,7 +164,7 @@ IPlatformServiceManager::IPlatformServiceManager(Core::System& system_, const ch
     // Rebuild shared fonts from data ncas or synthesize
 
     impl->shared_font = std::make_shared<Kernel::PhysicalMemory>(SHARED_FONT_MEM_SIZE);
-    for (auto font : SHARED_FONTS) {
+    for (auto& font : SHARED_FONTS) {
         FileSys::VirtualFile romfs;
         const auto nca =
             nand->GetEntry(static_cast<u64>(font.first), FileSys::ContentRecordType::Data);
@@ -261,7 +261,7 @@ Result IPlatformServiceManager::GetSharedFontInOrderOfPriority(
                                     out_font_sizes.size(), impl->shared_font_regions.size()});
 
     for (size_t i = 0; i < max_size; i++) {
-        auto region = impl->GetSharedFontRegion(i);
+        auto& region = impl->GetSharedFontRegion(i);
 
         out_font_codes[i] = static_cast<u32>(i);
         out_font_offsets[i] = region.offset;

src/frontend_common/play_time_manager.h

@@ -48,7 +48,7 @@ private:
     void Save();
 
     PlayTimeDatabase database;
-    u64 running_program_id;
+    u64 running_program_id{};
     std::jthread play_time_thread;
 };
 

src/input_common/helpers/joycon_protocol/poller.cpp

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2025 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
 

src/network/room_member.h

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2017 Citra Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -53,7 +56,7 @@ struct ChatEntry {
 
 /// Represents a system status message.
 struct StatusMessageEntry {
-    StatusMessageTypes type; ///< Type of the message
+    StatusMessageTypes type{}; ///< Type of the message
     /// Subject of the message. i.e. the user who is joining/leaving/being banned, etc.
     std::string nickname;
     std::string username;

src/video_core/buffer_cache/buffer_cache.h

@@ -7,7 +7,6 @@
 #pragma once
 
 #include <algorithm>
-#include <cstring>
 #include <memory>
 #include <numeric>
 
@@ -16,8 +15,6 @@
 #include "video_core/guest_memory.h"
 #include "video_core/host1x/gpu_device_memory_manager.h"
 #include "video_core/texture_cache/util.h"
-#include "video_core/polygon_mode_utils.h"
-#include "video_core/renderer_vulkan/line_loop_utils.h"
 
 namespace VideoCommon {
 
@@ -356,37 +353,14 @@ void BufferCache<P>::UpdateComputeBuffers() {
 
 template <class P>
 void BufferCache<P>::BindHostGeometryBuffers(bool is_indexed) {
-    const auto& draw_state = maxwell3d->draw_manager->GetDrawState();
     if (is_indexed) {
         BindHostIndexBuffer();
-    } else {
-        if constexpr (!P::IS_OPENGL) {
-            const auto polygon_mode = VideoCore::EffectivePolygonMode(maxwell3d->regs);
-            if (draw_state.topology == Maxwell::PrimitiveTopology::Polygon &&
-                polygon_mode == Maxwell::PolygonMode::Line && draw_state.vertex_buffer.count > 1) {
-                const u32 vertex_count = draw_state.vertex_buffer.count;
-                const u32 generated_count = vertex_count + 1;
-                const bool use_u16 = vertex_count <= 0x10000;
-                const u32 element_size = use_u16 ? sizeof(u16) : sizeof(u32);
-                auto staging = runtime.UploadStagingBuffer(
-                    static_cast<size_t>(generated_count) * element_size);
-                std::span<u8> dst_span{staging.mapped_span.data(),
-                                       generated_count * static_cast<size_t>(element_size)};
-                Vulkan::LineLoop::GenerateSequentialWithClosureRaw(dst_span, element_size);
-                const auto synthetic_format = use_u16 ? Maxwell::IndexFormat::UnsignedShort
-                                                      : Maxwell::IndexFormat::UnsignedInt;
-                runtime.BindIndexBuffer(draw_state.topology, synthetic_format,
-                                        draw_state.vertex_buffer.first, generated_count,
-                                        staging.buffer, static_cast<u32>(staging.offset),
-                                        generated_count * element_size);
-            }
-        }
-        if constexpr (!HAS_FULL_INDEX_AND_PRIMITIVE_SUPPORT) {
-            if (draw_state.topology == Maxwell::PrimitiveTopology::Quads ||
-                draw_state.topology == Maxwell::PrimitiveTopology::QuadStrip) {
-                runtime.BindQuadIndexBuffer(draw_state.topology, draw_state.vertex_buffer.first,
-                                            draw_state.vertex_buffer.count);
-            }
+    } else if constexpr (!HAS_FULL_INDEX_AND_PRIMITIVE_SUPPORT) {
+        const auto& draw_state = maxwell3d->draw_manager->GetDrawState();
+        if (draw_state.topology == Maxwell::PrimitiveTopology::Quads ||
+            draw_state.topology == Maxwell::PrimitiveTopology::QuadStrip) {
+            runtime.BindQuadIndexBuffer(draw_state.topology, draw_state.vertex_buffer.first,
+                                        draw_state.vertex_buffer.count);
         }
     }
     BindHostVertexBuffers();
@@ -715,44 +689,6 @@ void BufferCache<P>::BindHostIndexBuffer() {
     const u32 offset = buffer.Offset(channel_state->index_buffer.device_addr);
     const u32 size = channel_state->index_buffer.size;
     const auto& draw_state = maxwell3d->draw_manager->GetDrawState();
-    if constexpr (!P::IS_OPENGL) {
-        const auto polygon_mode = VideoCore::EffectivePolygonMode(maxwell3d->regs);
-        const bool polygon_line =
-            draw_state.topology == Maxwell::PrimitiveTopology::Polygon &&
-            polygon_mode == Maxwell::PolygonMode::Line;
-        if (polygon_line && draw_state.index_buffer.count > 1) {
-            const u32 element_size = draw_state.index_buffer.FormatSizeInBytes();
-            const size_t src_bytes = static_cast<size_t>(draw_state.index_buffer.count) * element_size;
-            const size_t total_bytes = src_bytes + element_size;
-            auto staging = runtime.UploadStagingBuffer(total_bytes);
-            std::span<u8> dst_span{staging.mapped_span.data(), total_bytes};
-            std::span<const u8> src_span;
-            if (!draw_state.inline_index_draw_indexes.empty()) {
-                const u8* const src =
-                    draw_state.inline_index_draw_indexes.data() +
-                    static_cast<size_t>(draw_state.index_buffer.first) * element_size;
-                src_span = {src, src_bytes};
-            } else if (const u8* const cpu_base =
-                           device_memory.GetPointer<u8>(channel_state->index_buffer.device_addr)) {
-                const u8* const src = cpu_base +
-                                      static_cast<size_t>(draw_state.index_buffer.first) * element_size;
-                src_span = {src, src_bytes};
-            } else {
-                const DAddr src_addr =
-                    channel_state->index_buffer.device_addr +
-                    static_cast<DAddr>(draw_state.index_buffer.first) * element_size;
-                device_memory.ReadBlockUnsafe(src_addr, dst_span.data(), src_bytes);
-                src_span = {dst_span.data(), src_bytes};
-            }
-            Vulkan::LineLoop::CopyWithClosureRaw(dst_span, src_span, element_size);
-            buffer.MarkUsage(offset, size);
-            runtime.BindIndexBuffer(draw_state.topology, draw_state.index_buffer.format,
-                                    draw_state.index_buffer.first, draw_state.index_buffer.count + 1,
-                                    staging.buffer, static_cast<u32>(staging.offset),
-                                    static_cast<u32>(total_bytes));
-            return;
-        }
-    }
     if (!draw_state.inline_index_draw_indexes.empty()) [[unlikely]] {
         if constexpr (USE_MEMORY_MAPS_FOR_UPLOADS) {
             auto upload_staging = runtime.UploadStagingBuffer(size);
@@ -1769,21 +1705,26 @@ Binding BufferCache<P>::StorageBufferBinding(GPUVAddr ssbo_addr, u32 cbuf_index,
         return NULL_BINDING;
     }
 
+    // xbzk: New size logic. Fixes MCI.
+    // If ever the * comment below prove wrong, the 'if' block may be removed.
     const auto size = [&]() {
         const bool is_nvn_cbuf = cbuf_index == 0;
-        // The NVN driver buffer (index 0) is known to pack the SSBO address followed by its size.
         if (is_nvn_cbuf) {
-            const u32 ssbo_size = gpu_memory->Read<u32>(ssbo_addr + 8);
-            if (ssbo_size != 0) {
-                return ssbo_size;
+            // * The NVN driver buffer (index 0) is known to pack the SSBO address followed by its size.
+            const u64 next_qword = gpu_memory->Read<u64>(ssbo_addr + 8);
+            const u32 upper_32 = static_cast<u32>(next_qword >> 32);
+            // Hardware-based detection: GPU addresses have non-zero upper bits
+            if (upper_32 == 0) {
+                // This is a size field, not a GPU address
+                return static_cast<u32>(next_qword);  // Return lower_32
             }
         }
-        // Other titles (notably Doom Eternal) may use STG/LDG on buffer addresses in custom defined
-        // cbufs, which do not store the sizes adjacent to the addresses, so use the fully
-        // mapped buffer size for now.
+        // Fall through: either not NVN cbuf (Doom Eternal & +), or NVN but ssbo_addr+8 is a GPU address (MCI)
         const u32 memory_layout_size = static_cast<u32>(gpu_memory->GetMemoryLayoutSize(gpu_addr));
+        // Cap at 8MB to prevent allocator overflow from misinterpreted addresses
         return (std::min)(memory_layout_size, static_cast<u32>(8_MiB));
     }();
+
     // Alignment only applies to the offset of the buffer
     const u32 alignment = runtime.GetStorageBufferAlignment();
     const GPUVAddr aligned_gpu_addr = Common::AlignDown(gpu_addr, alignment);

src/video_core/control/scheduler.cpp

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: 2021 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
@@ -17,7 +20,7 @@ void Scheduler::Push(s32 channel, CommandList&& entries) {
     std::unique_lock lk(scheduling_guard);
     auto it = channels.find(channel);
     ASSERT(it != channels.end());
-    auto channel_state = it->second;
+    auto& channel_state = it->second;
     gpu.BindChannel(channel_state->bind_id);
     channel_state->dma_pusher->Push(std::move(entries));
     channel_state->dma_pusher->DispatchCalls();

src/video_core/polygon_mode_utils.h

@@ -1,46 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
-#pragma once
-
-#include "video_core/engines/maxwell_3d.h"
-
-namespace VideoCore {
-
-inline Tegra::Engines::Maxwell3D::Regs::PolygonMode EffectivePolygonMode(
-    const Tegra::Engines::Maxwell3D::Regs& regs) {
-    using Maxwell = Tegra::Engines::Maxwell3D::Regs;
-
-    const bool cull_enabled = regs.gl_cull_test_enabled != 0;
-    const auto cull_face = regs.gl_cull_face;
-    const bool cull_front = cull_enabled && (cull_face == Maxwell::CullFace::Front ||
-                                             cull_face == Maxwell::CullFace::FrontAndBack);
-    const bool cull_back = cull_enabled && (cull_face == Maxwell::CullFace::Back ||
-                                            cull_face == Maxwell::CullFace::FrontAndBack);
-
-    const bool render_front = !cull_front;
-    const bool render_back = !cull_back;
-
-    const auto front_mode = regs.polygon_mode_front;
-    const auto back_mode = regs.polygon_mode_back;
-
-    if (render_front && render_back && front_mode != back_mode) {
-        if (front_mode == Maxwell::PolygonMode::Line || back_mode == Maxwell::PolygonMode::Line) {
-            return Maxwell::PolygonMode::Line;
-        }
-        if (front_mode == Maxwell::PolygonMode::Point || back_mode == Maxwell::PolygonMode::Point) {
-            return Maxwell::PolygonMode::Point;
-        }
-    }
-
-    if (render_front) {
-        return front_mode;
-    }
-    if (render_back) {
-        return back_mode;
-    }
-    return front_mode;
-}
-
-} // namespace VideoCore
-

src/video_core/renderer_vulkan/fixed_pipeline_state.cpp

@@ -15,7 +15,6 @@
 #include "video_core/engines/draw_manager.h"
 #include "video_core/renderer_vulkan/fixed_pipeline_state.h"
 #include "video_core/renderer_vulkan/vk_state_tracker.h"
-#include "video_core/polygon_mode_utils.h"
 
 namespace Vulkan {
 namespace {
@@ -66,7 +65,7 @@ void FixedPipelineState::Refresh(Tegra::Engines::Maxwell3D& maxwell3d, DynamicFe
     dynamic_vertex_input.Assign(features.has_dynamic_vertex_input ? 1 : 0);
     xfb_enabled.Assign(regs.transform_feedback_enabled != 0);
     ndc_minus_one_to_one.Assign(regs.depth_mode == Maxwell::DepthMode::MinusOneToOne ? 1 : 0);
-    polygon_mode.Assign(PackPolygonMode(VideoCore::EffectivePolygonMode(regs)));
+    polygon_mode.Assign(PackPolygonMode(regs.polygon_mode_front));
     tessellation_primitive.Assign(static_cast<u32>(regs.tessellation.params.domain_type.Value()));
     tessellation_spacing.Assign(static_cast<u32>(regs.tessellation.params.spacing.Value()));
     tessellation_clockwise.Assign(regs.tessellation.params.output_primitives.Value() ==

src/video_core/renderer_vulkan/line_loop_utils.h

@@ -1,68 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
-#pragma once
-
-#include <algorithm>
-#include <cstring>
-#include <span>
-
-#include "common/assert.h"
-#include "common/common_types.h"
-
-namespace Vulkan::LineLoop {
-
-inline void CopyWithClosureRaw(std::span<u8> dst, std::span<const u8> src, size_t element_size) {
-    ASSERT_MSG(dst.size() == src.size() + element_size, "Invalid line loop copy sizes");
-    if (src.empty()) {
-        if (!dst.empty()) {
-            std::fill(dst.begin(), dst.end(), u8{0});
-        }
-        return;
-    }
-    std::memcpy(dst.data(), src.data(), src.size());
-    std::memcpy(dst.data() + src.size(), src.data(), element_size);
-}
-
-inline void GenerateSequentialWithClosureRaw(std::span<u8> dst, size_t element_size,
-                                             u64 start_value = 0) {
-    if (dst.empty()) {
-        return;
-    }
-    const size_t last = dst.size() - element_size;
-    size_t offset = 0;
-    u64 value = start_value;
-    while (offset < last) {
-        std::memcpy(dst.data() + offset, &value, element_size);
-        offset += element_size;
-        ++value;
-    }
-    std::memcpy(dst.data() + offset, &start_value, element_size);
-}
-
-template <typename T>
-inline void CopyWithClosure(std::span<T> dst, std::span<const T> src) {
-    ASSERT_MSG(dst.size() == src.size() + 1, "Invalid destination size for line loop copy");
-    if (src.empty()) {
-        if (!dst.empty()) {
-            dst.front() = {};
-        }
-        return;
-    }
-    std::copy(src.begin(), src.end(), dst.begin());
-    dst.back() = src.front();
-}
-
-template <typename T>
-inline void GenerateSequentialWithClosure(std::span<T> dst, T start_value = {}) {
-    if (dst.empty()) {
-        return;
-    }
-    const size_t last = dst.size() - 1;
-    for (size_t i = 0; i < last; ++i) {
-        dst[i] = static_cast<T>(start_value + static_cast<T>(i));
-    }
-    dst.back() = start_value;
-}
-
-} // namespace Vulkan::LineLoop

src/video_core/renderer_vulkan/maxwell_to_vk.cpp

@@ -1,6 +1,3 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: Copyright 2019 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -326,9 +323,44 @@ VkShaderStageFlagBits ShaderStage(Shader::Stage stage) {
 }
 
 VkPrimitiveTopology PrimitiveTopology([[maybe_unused]] const Device& device,
-                                      Maxwell::PrimitiveTopology topology,
-                                      Maxwell::PolygonMode polygon_mode) {
-    return detail::PrimitiveTopologyNoDevice(topology, polygon_mode);
+                                      Maxwell::PrimitiveTopology topology) {
+    switch (topology) {
+    case Maxwell::PrimitiveTopology::Points:
+        return VK_PRIMITIVE_TOPOLOGY_POINT_LIST;
+    case Maxwell::PrimitiveTopology::Lines:
+        return VK_PRIMITIVE_TOPOLOGY_LINE_LIST;
+    case Maxwell::PrimitiveTopology::LineLoop:
+        return VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST;
+    case Maxwell::PrimitiveTopology::LineStrip:
+        return VK_PRIMITIVE_TOPOLOGY_LINE_STRIP;
+    case Maxwell::PrimitiveTopology::Triangles:
+        return VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST;
+    case Maxwell::PrimitiveTopology::TriangleStrip:
+        return VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP;
+    case Maxwell::PrimitiveTopology::TriangleFan:
+        return VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN;
+    case Maxwell::PrimitiveTopology::LinesAdjacency:
+        return VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY;
+    case Maxwell::PrimitiveTopology::LineStripAdjacency:
+        return VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY;
+    case Maxwell::PrimitiveTopology::TrianglesAdjacency:
+        return VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY;
+    case Maxwell::PrimitiveTopology::TriangleStripAdjacency:
+        return VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY;
+    case Maxwell::PrimitiveTopology::Quads:
+    case Maxwell::PrimitiveTopology::QuadStrip:
+        // TODO: Use VK_PRIMITIVE_TOPOLOGY_QUAD_LIST_EXT/VK_PRIMITIVE_TOPOLOGY_QUAD_STRIP_EXT
+        // whenever it releases
+        return VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST;
+    case Maxwell::PrimitiveTopology::Patches:
+        return VK_PRIMITIVE_TOPOLOGY_PATCH_LIST;
+    case Maxwell::PrimitiveTopology::Polygon:
+        LOG_WARNING(Render_Vulkan, "Draw mode is Polygon with a polygon mode of lines should be a "
+                                   "single body and not a bunch of triangles.");
+        return VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN;
+    }
+    UNIMPLEMENTED_MSG("Unimplemented topology={}", topology);
+    return {};
 }
 
 VkFormat VertexFormat(const Device& device, Maxwell::VertexAttribute::Type type,

src/video_core/renderer_vulkan/maxwell_to_vk.h

@@ -1,6 +1,3 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: Copyright 2019 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -18,52 +15,6 @@ namespace Vulkan::MaxwellToVK {
 using Maxwell = Tegra::Engines::Maxwell3D::Regs;
 using PixelFormat = VideoCore::Surface::PixelFormat;
 
-namespace detail {
-constexpr VkPrimitiveTopology PrimitiveTopologyNoDevice(Maxwell::PrimitiveTopology topology,
-                                                        Maxwell::PolygonMode polygon_mode) {
-    switch (topology) {
-    case Maxwell::PrimitiveTopology::Points:
-        return VK_PRIMITIVE_TOPOLOGY_POINT_LIST;
-    case Maxwell::PrimitiveTopology::Lines:
-        return VK_PRIMITIVE_TOPOLOGY_LINE_LIST;
-    case Maxwell::PrimitiveTopology::LineLoop:
-        return VK_PRIMITIVE_TOPOLOGY_LINE_STRIP;
-    case Maxwell::PrimitiveTopology::LineStrip:
-        return VK_PRIMITIVE_TOPOLOGY_LINE_STRIP;
-    case Maxwell::PrimitiveTopology::Triangles:
-        return VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST;
-    case Maxwell::PrimitiveTopology::TriangleStrip:
-        return VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP;
-    case Maxwell::PrimitiveTopology::TriangleFan:
-        return VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN;
-    case Maxwell::PrimitiveTopology::LinesAdjacency:
-        return VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY;
-    case Maxwell::PrimitiveTopology::LineStripAdjacency:
-        return VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY;
-    case Maxwell::PrimitiveTopology::TrianglesAdjacency:
-        return VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY;
-    case Maxwell::PrimitiveTopology::TriangleStripAdjacency:
-        return VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY;
-    case Maxwell::PrimitiveTopology::Quads:
-    case Maxwell::PrimitiveTopology::QuadStrip:
-        return VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST;
-    case Maxwell::PrimitiveTopology::Patches:
-        return VK_PRIMITIVE_TOPOLOGY_PATCH_LIST;
-    case Maxwell::PrimitiveTopology::Polygon:
-        switch (polygon_mode) {
-        case Maxwell::PolygonMode::Fill:
-            return VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN;
-        case Maxwell::PolygonMode::Line:
-            return VK_PRIMITIVE_TOPOLOGY_LINE_STRIP;
-        case Maxwell::PolygonMode::Point:
-            return VK_PRIMITIVE_TOPOLOGY_POINT_LIST;
-        }
-        break;
-    }
-    return VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST;
-}
-} // namespace detail
-
 namespace Sampler {
 
 VkFilter Filter(Tegra::Texture::TextureFilter filter);
@@ -95,8 +46,7 @@ struct FormatInfo {
 
 VkShaderStageFlagBits ShaderStage(Shader::Stage stage);
 
-VkPrimitiveTopology PrimitiveTopology(const Device& device, Maxwell::PrimitiveTopology topology,
-                                      Maxwell::PolygonMode polygon_mode);
+VkPrimitiveTopology PrimitiveTopology(const Device& device, Maxwell::PrimitiveTopology topology);
 
 VkFormat VertexFormat(const Device& device, Maxwell::VertexAttribute::Type type,
                       Maxwell::VertexAttribute::Size size);

src/video_core/renderer_vulkan/vk_graphics_pipeline.cpp

@@ -7,7 +7,6 @@
 #include <algorithm>
 #include <iostream>
 #include <span>
-#include <string_view>
 
 #include <boost/container/small_vector.hpp>
 #include <boost/container/static_vector.hpp>
@@ -23,7 +22,6 @@
 #include "video_core/renderer_vulkan/vk_scheduler.h"
 #include "video_core/renderer_vulkan/vk_texture_cache.h"
 #include "video_core/renderer_vulkan/vk_update_descriptor.h"
-#include "video_core/polygon_mode_utils.h"
 #include "video_core/shader_notify.h"
 #include "video_core/texture_cache/texture_cache.h"
 #include "video_core/vulkan_common/vulkan_device.h"
@@ -616,10 +614,7 @@ void GraphicsPipeline::MakePipeline(VkRenderPass render_pass) {
         vertex_input_ci.pNext = &input_divisor_ci;
     }
     const bool has_tess_stages = spv_modules[1] || spv_modules[2];
-    const auto polygon_mode =
-        FixedPipelineState::UnpackPolygonMode(key.state.polygon_mode.Value());
-    auto input_assembly_topology =
-        MaxwellToVK::PrimitiveTopology(device, key.state.topology, polygon_mode);
+    auto input_assembly_topology = MaxwellToVK::PrimitiveTopology(device, key.state.topology);
     if (input_assembly_topology == VK_PRIMITIVE_TOPOLOGY_PATCH_LIST) {
         if (!has_tess_stages) {
             LOG_WARNING(Render_Vulkan, "Patch topology used without tessellation, using points");
@@ -634,33 +629,6 @@ void GraphicsPipeline::MakePipeline(VkRenderPass render_pass) {
             input_assembly_topology = VK_PRIMITIVE_TOPOLOGY_PATCH_LIST;
         }
     }
-    if (key.state.topology == Maxwell::PrimitiveTopology::Polygon) {
-        const auto polygon_mode_name = [polygon_mode]() -> std::string_view {
-            switch (polygon_mode) {
-            case Maxwell::PolygonMode::Fill:
-                return "Fill";
-            case Maxwell::PolygonMode::Line:
-                return "Line";
-            case Maxwell::PolygonMode::Point:
-                return "Point";
-            }
-            return "Unknown";
-        }();
-        const auto vk_topology_name = [input_assembly_topology]() -> std::string_view {
-            switch (input_assembly_topology) {
-            case VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN:
-                return "TriangleFan";
-            case VK_PRIMITIVE_TOPOLOGY_LINE_STRIP:
-                return "LineStrip";
-            case VK_PRIMITIVE_TOPOLOGY_POINT_LIST:
-                return "PointList";
-            default:
-                return "Unexpected";
-            }
-        }();
-        LOG_DEBUG(Render_Vulkan, "Polygon primitive in {} mode mapped to {}", polygon_mode_name,
-                  vk_topology_name);
-    }
     const VkPipelineInputAssemblyStateCreateInfo input_assembly_ci{
         .sType = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO,
         .pNext = nullptr,

src/video_core/renderer_vulkan/vk_rasterizer.cpp

@@ -37,7 +37,6 @@
 #include "video_core/renderer_vulkan/vk_update_descriptor.h"
 #include "video_core/shader_cache.h"
 #include "video_core/texture_cache/texture_cache_base.h"
-#include "video_core/polygon_mode_utils.h"
 #include "video_core/vulkan_common/vulkan_device.h"
 #include "video_core/vulkan_common/vulkan_wrapper.h"
 
@@ -109,7 +108,7 @@ VkViewport GetViewportState(const Device& device, const Maxwell& regs, size_t in
 
 VkRect2D GetScissorState(const Maxwell& regs, size_t index, u32 up_scale = 1, u32 down_shift = 0) {
     const auto& src = regs.scissor_test[index];
-    VkRect2D scissor;
+    VkRect2D scissor{};
     const auto scale_up = [&](s32 value) -> s32 {
         if (value == 0) {
             return 0U;
@@ -149,8 +148,7 @@ VkRect2D GetScissorState(const Maxwell& regs, size_t index, u32 up_scale = 1, u3
     return scissor;
 }
 
-DrawParams MakeDrawParams(const MaxwellDrawState& draw_state, u32 num_instances, bool is_indexed,
-                          Maxwell::PolygonMode polygon_mode) {
+DrawParams MakeDrawParams(const MaxwellDrawState& draw_state, u32 num_instances, bool is_indexed) {
     DrawParams params{
         .base_instance = draw_state.base_instance,
         .num_instances = num_instances,
@@ -170,21 +168,6 @@ DrawParams MakeDrawParams(const MaxwellDrawState& draw_state, u32 num_instances,
         params.base_vertex = 0;
         params.is_indexed = true;
     }
-    const bool polygon_line =
-        draw_state.topology == Maxwell::PrimitiveTopology::Polygon &&
-        polygon_mode == Maxwell::PolygonMode::Line;
-    if (polygon_line) {
-        if (params.is_indexed) {
-            if (draw_state.index_buffer.count > 1) {
-                params.num_vertices = draw_state.index_buffer.count + 1;
-            }
-        } else if (draw_state.vertex_buffer.count > 1) {
-            params.num_vertices = draw_state.vertex_buffer.count + 1;
-            params.is_indexed = true;
-            params.first_index = 0;
-            params.base_vertex = draw_state.vertex_buffer.first;
-        }
-    }
     return params;
 }
 } // Anonymous namespace
@@ -250,8 +233,7 @@ void RasterizerVulkan::Draw(bool is_indexed, u32 instance_count) {
     PrepareDraw(is_indexed, [this, is_indexed, instance_count] {
         const auto& draw_state = maxwell3d->draw_manager->GetDrawState();
         const u32 num_instances{instance_count};
-        const auto polygon_mode = VideoCore::EffectivePolygonMode(maxwell3d->regs);
-        const DrawParams draw_params{MakeDrawParams(draw_state, num_instances, is_indexed, polygon_mode)};
+        const DrawParams draw_params{MakeDrawParams(draw_state, num_instances, is_indexed)};
         scheduler.Record([draw_params](vk::CommandBuffer cmdbuf) {
             if (draw_params.is_indexed) {
                 cmdbuf.DrawIndexed(draw_params.num_vertices, draw_params.num_instances,
@@ -392,7 +374,7 @@ void RasterizerVulkan::Clear(u32 layer_count) {
     }
     UpdateViewportsState(regs);
 
-    VkRect2D default_scissor;
+    VkRect2D default_scissor{};
     default_scissor.offset.x = 0;
     default_scissor.offset.y = 0;
     default_scissor.extent.width = (std::numeric_limits<s32>::max)();

src/yuzu/configuration/configure_input.h

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: 2016 Citra Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -71,11 +74,11 @@ private:
 
     std::unique_ptr<InputProfiles> profiles;
 
-    std::array<ConfigureInputPlayer*, 8> player_controllers;
-    std::array<QWidget*, 8> player_tabs;
+    std::array<ConfigureInputPlayer*, 8> player_controllers{};
+    std::array<QWidget*, 8> player_tabs{};
     // Checkboxes representing the "Connected Controllers".
-    std::array<QCheckBox*, 8> connected_controller_checkboxes;
-    ConfigureInputAdvanced* advanced;
+    std::array<QCheckBox*, 8> connected_controller_checkboxes{};
+    ConfigureInputAdvanced* advanced = nullptr;
 
     Core::System& system;
 };

src/yuzu/configuration/configure_input_player_widget.cpp

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2025 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
 
@@ -689,10 +692,10 @@ void PlayerControlPreview::DrawHandheldController(QPainter& p, const QPointF cen
     {
         // Draw joysticks
         using namespace Settings::NativeAnalog;
-        const auto l_stick = QPointF(stick_values[LStick].x.value, stick_values[LStick].y.value);
-        const auto l_button = button_values[Settings::NativeButton::LStick];
-        const auto r_stick = QPointF(stick_values[RStick].x.value, stick_values[RStick].y.value);
-        const auto r_button = button_values[Settings::NativeButton::RStick];
+        const auto& l_stick = QPointF(stick_values[LStick].x.value, stick_values[LStick].y.value);
+        const auto& l_button = button_values[Settings::NativeButton::LStick];
+        const auto& r_stick = QPointF(stick_values[RStick].x.value, stick_values[RStick].y.value);
+        const auto& r_button = button_values[Settings::NativeButton::RStick];
 
         DrawJoystick(p, center + QPointF(-171, -41) + (l_stick * 4), 1.0f, l_button);
         DrawJoystick(p, center + QPointF(171, 8) + (r_stick * 4), 1.0f, r_button);

src/yuzu/configuration/configure_input_player_widget.h

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2025 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
 
@@ -214,7 +217,7 @@ private:
 
     bool mapping_active{};
     int blink_counter{};
-    int callback_key;
+    int callback_key{};
     QColor button_color{};
     ColorMapping colors{};
     Core::HID::LedPattern led_pattern{0, 0, 0, 0};

src/yuzu/main_window.cpp

@@ -1495,7 +1495,7 @@ void MainWindow::OnAppFocusStateChanged(Qt::ApplicationState state) {
             (state & (Qt::ApplicationHidden | Qt::ApplicationInactive))) {
             auto_paused = true;
             OnPauseGame();
-        } else if (!emu_thread->IsRunning() && auto_paused && state == Qt::ApplicationActive) {
+        } else if (!emu_thread->IsRunning() && auto_paused && (state & Qt::ApplicationActive)) {
             auto_paused = false;
             OnStartGame();
         }
@@ -1505,7 +1505,7 @@ void MainWindow::OnAppFocusStateChanged(Qt::ApplicationState state) {
             (state & (Qt::ApplicationHidden | Qt::ApplicationInactive))) {
             Settings::values.audio_muted = true;
             auto_muted = true;
-        } else if (auto_muted && state == Qt::ApplicationActive) {
+        } else if (auto_muted && (state & Qt::ApplicationActive)) {
             Settings::values.audio_muted = false;
             auto_muted = false;
         }

src/yuzu/main_window.h

@@ -482,13 +482,13 @@ private:
 
     MultiplayerState* multiplayer_state = nullptr;
 
-    GRenderWindow* render_window;
-    GameList* game_list;
-    LoadingScreen* loading_screen;
+    GRenderWindow* render_window = nullptr;
+    GameList* game_list = nullptr;
+    LoadingScreen* loading_screen = nullptr;
     QTimer shutdown_timer;
     OverlayDialog* shutdown_dialog{};
 
-    GameListPlaceholder* game_list_placeholder;
+    GameListPlaceholder* game_list_placeholder = nullptr;
 
     std::vector<VkDeviceInfo::Record> vk_device_records;
 
@@ -531,7 +531,7 @@ private:
     QString startup_icon_theme;
 
     // Debugger panes
-    ControllerDialog* controller_dialog;
+    ControllerDialog* controller_dialog = nullptr;
 
     QAction* actions_recent_files[max_recent_files_item];
 
@@ -543,7 +543,7 @@ private:
     QTranslator translator;
 
     // Install progress dialog
-    QProgressDialog* install_progress;
+    QProgressDialog* install_progress = nullptr;
 
     // Last game booted, used for multi-process apps
     QString last_filename_booted;

src/yuzu/multiplayer/lobby_p.h

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2017 Citra Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -175,7 +178,7 @@ public:
 private:
     QString username;
     QString nickname;
-    u64 title_id;
+    u64 title_id{};
     QString game_name;
 };