Merge branch 'yuzu-emu:master' into new-shortcut

src/core/core.cpp

@@ -116,11 +116,8 @@ FileSys::VirtualFile GetGameFileFromPath(const FileSys::VirtualFilesystem& vfs,
             }
         }
 
-        if (concat.empty()) {
+        return FileSys::ConcatenatedVfsFile::MakeConcatenatedFile(dir->GetName(),
-            return nullptr;
+                                                                  std::move(concat));
-        }
-
-        return FileSys::ConcatenatedVfsFile::MakeConcatenatedFile(concat, dir->GetName());
     }
 
     if (Common::FS::IsDir(path)) {

src/core/file_sys/fsmitm_romfsbuild.cpp

@@ -107,62 +107,56 @@ static u64 romfs_get_hash_table_count(u64 num_entries) {
 
 void RomFSBuildContext::VisitDirectory(VirtualDir romfs_dir, VirtualDir ext_dir,
                                        std::shared_ptr<RomFSBuildDirectoryContext> parent) {
-    std::vector<std::shared_ptr<RomFSBuildDirectoryContext>> child_dirs;
+    for (auto& child_romfs_file : romfs_dir->GetFiles()) {
+        const auto name = child_romfs_file->GetName();
+        const auto child = std::make_shared<RomFSBuildFileContext>();
+        // Set child's path.
+        child->cur_path_ofs = parent->path_len + 1;
+        child->path_len = child->cur_path_ofs + static_cast<u32>(name.size());
+        child->path = parent->path + "/" + name;
 
-    const auto entries = romfs_dir->GetEntries();
+        if (ext_dir != nullptr && ext_dir->GetFile(name + ".stub") != nullptr) {
+            continue;
+        }
 
-    for (const auto& kv : entries) {
+        // Sanity check on path_len
-        if (kv.second == VfsEntryType::Directory) {
+        ASSERT(child->path_len < FS_MAX_PATH);
-            const auto child = std::make_shared<RomFSBuildDirectoryContext>();
-            // Set child's path.
-            child->cur_path_ofs = parent->path_len + 1;
-            child->path_len = child->cur_path_ofs + static_cast<u32>(kv.first.size());
-            child->path = parent->path + "/" + kv.first;
 
-            if (ext_dir != nullptr && ext_dir->GetFile(kv.first + ".stub") != nullptr) {
+        child->source = std::move(child_romfs_file);
-                continue;
-            }
 
-            // Sanity check on path_len
+        if (ext_dir != nullptr) {
-            ASSERT(child->path_len < FS_MAX_PATH);
+            if (const auto ips = ext_dir->GetFile(name + ".ips")) {
-
+                if (auto patched = PatchIPS(child->source, ips)) {
-            if (AddDirectory(parent, child)) {
+                    child->source = std::move(patched);
-                child_dirs.push_back(child);
-            }
-        } else {
-            const auto child = std::make_shared<RomFSBuildFileContext>();
-            // Set child's path.
-            child->cur_path_ofs = parent->path_len + 1;
-            child->path_len = child->cur_path_ofs + static_cast<u32>(kv.first.size());
-            child->path = parent->path + "/" + kv.first;
-
-            if (ext_dir != nullptr && ext_dir->GetFile(kv.first + ".stub") != nullptr) {
-                continue;
-            }
-
-            // Sanity check on path_len
-            ASSERT(child->path_len < FS_MAX_PATH);
-
-            child->source = romfs_dir->GetFile(kv.first);
-
-            if (ext_dir != nullptr) {
-                if (const auto ips = ext_dir->GetFile(kv.first + ".ips")) {
-                    if (auto patched = PatchIPS(child->source, ips)) {
-                        child->source = std::move(patched);
-                    }
                 }
             }
-
-            child->size = child->source->GetSize();
-
-            AddFile(parent, child);
         }
+
+        child->size = child->source->GetSize();
+
+        AddFile(parent, child);
     }
 
-    for (auto& child : child_dirs) {
+    for (auto& child_romfs_dir : romfs_dir->GetSubdirectories()) {
-        auto subdir_name = std::string_view(child->path).substr(child->cur_path_ofs);
+        const auto name = child_romfs_dir->GetName();
-        auto child_romfs_dir = romfs_dir->GetSubdirectory(subdir_name);
+        const auto child = std::make_shared<RomFSBuildDirectoryContext>();
-        auto child_ext_dir = ext_dir != nullptr ? ext_dir->GetSubdirectory(subdir_name) : nullptr;
+        // Set child's path.
+        child->cur_path_ofs = parent->path_len + 1;
+        child->path_len = child->cur_path_ofs + static_cast<u32>(name.size());
+        child->path = parent->path + "/" + name;
+
+        if (ext_dir != nullptr && ext_dir->GetFile(name + ".stub") != nullptr) {
+            continue;
+        }
+
+        // Sanity check on path_len
+        ASSERT(child->path_len < FS_MAX_PATH);
+
+        if (!AddDirectory(parent, child)) {
+            continue;
+        }
+
+        auto child_ext_dir = ext_dir != nullptr ? ext_dir->GetSubdirectory(name) : nullptr;
         this->VisitDirectory(child_romfs_dir, child_ext_dir, child);
     }
 }
@@ -293,7 +287,7 @@ std::multimap<u64, VirtualFile> RomFSBuildContext::Build() {
 
         cur_entry.name_size = name_size;
 
-        out.emplace(cur_file->offset + ROMFS_FILEPARTITION_OFS, cur_file->source);
+        out.emplace(cur_file->offset + ROMFS_FILEPARTITION_OFS, std::move(cur_file->source));
         std::memcpy(file_table.data() + cur_file->entry_offset, &cur_entry, sizeof(RomFSFileEntry));
         std::memset(file_table.data() + cur_file->entry_offset + sizeof(RomFSFileEntry), 0,
                     Common::AlignUp(cur_entry.name_size, 4));

src/core/file_sys/patch_manager.cpp

@@ -377,16 +377,16 @@ static void ApplyLayeredFS(VirtualFile& romfs, u64 title_id, ContentRecordType t
 
         auto romfs_dir = FindSubdirectoryCaseless(subdir, "romfs");
         if (romfs_dir != nullptr)
-            layers.push_back(std::make_shared<CachedVfsDirectory>(romfs_dir));
+            layers.emplace_back(std::make_shared<CachedVfsDirectory>(std::move(romfs_dir)));
 
         auto ext_dir = FindSubdirectoryCaseless(subdir, "romfs_ext");
         if (ext_dir != nullptr)
-            layers_ext.push_back(std::make_shared<CachedVfsDirectory>(ext_dir));
+            layers_ext.emplace_back(std::make_shared<CachedVfsDirectory>(std::move(ext_dir)));
 
         if (type == ContentRecordType::HtmlDocument) {
             auto manual_dir = FindSubdirectoryCaseless(subdir, "manual_html");
             if (manual_dir != nullptr)
-                layers.push_back(std::make_shared<CachedVfsDirectory>(manual_dir));
+                layers.emplace_back(std::make_shared<CachedVfsDirectory>(std::move(manual_dir)));
         }
     }
 
@@ -400,7 +400,7 @@ static void ApplyLayeredFS(VirtualFile& romfs, u64 title_id, ContentRecordType t
         return;
     }
 
-    layers.push_back(std::move(extracted));
+    layers.emplace_back(std::move(extracted));
 
     auto layered = LayeredVfsDirectory::MakeLayeredDirectory(std::move(layers));
     if (layered == nullptr) {

src/core/file_sys/registered_cache.cpp

@@ -322,7 +322,8 @@ VirtualFile RegisteredCache::OpenFileOrDirectoryConcat(const VirtualDir& open_di
         return nullptr;
     }
 
-    return ConcatenatedVfsFile::MakeConcatenatedFile(concat, concat.front()->GetName());
+    auto name = concat.front()->GetName();
+    return ConcatenatedVfsFile::MakeConcatenatedFile(std::move(name), std::move(concat));
 }
 
 VirtualFile RegisteredCache::GetFileAtID(NcaID id) const {

src/core/file_sys/romfs.cpp

@@ -133,7 +133,7 @@ VirtualDir ExtractRomFS(VirtualFile file, RomFSExtractionType type) {
         out = out->GetSubdirectories().front();
     }
 
-    return std::make_shared<CachedVfsDirectory>(out);
+    return std::make_shared<CachedVfsDirectory>(std::move(out));
 }
 
 VirtualFile CreateRomFS(VirtualDir dir, VirtualDir ext) {
@@ -141,8 +141,7 @@ VirtualFile CreateRomFS(VirtualDir dir, VirtualDir ext) {
         return nullptr;
 
     RomFSBuildContext ctx{dir, ext};
-    auto file_map = ctx.Build();
+    return ConcatenatedVfsFile::MakeConcatenatedFile(0, dir->GetName(), ctx.Build());
-    return ConcatenatedVfsFile::MakeConcatenatedFile(0, file_map, dir->GetName());
 }
 
 } // namespace FileSys

src/core/file_sys/vfs_cached.cpp

@@ -6,13 +6,13 @@
 
 namespace FileSys {
 
-CachedVfsDirectory::CachedVfsDirectory(VirtualDir& source_dir)
+CachedVfsDirectory::CachedVfsDirectory(VirtualDir&& source_dir)
     : name(source_dir->GetName()), parent(source_dir->GetParentDirectory()) {
     for (auto& dir : source_dir->GetSubdirectories()) {
-        dirs.emplace(dir->GetName(), std::make_shared<CachedVfsDirectory>(dir));
+        dirs.emplace(dir->GetName(), std::make_shared<CachedVfsDirectory>(std::move(dir)));
     }
     for (auto& file : source_dir->GetFiles()) {
-        files.emplace(file->GetName(), file);
+        files.emplace(file->GetName(), std::move(file));
     }
 }
 

src/core/file_sys/vfs_cached.h

@@ -11,7 +11,7 @@ namespace FileSys {
 
 class CachedVfsDirectory : public ReadOnlyVfsDirectory {
 public:
-    CachedVfsDirectory(VirtualDir& source_directory);
+    CachedVfsDirectory(VirtualDir&& source_directory);
 
     ~CachedVfsDirectory() override;
     VirtualFile GetFile(std::string_view file_name) const override;

src/core/file_sys/vfs_concat.cpp

@@ -10,7 +10,7 @@
 
 namespace FileSys {
 
-ConcatenatedVfsFile::ConcatenatedVfsFile(ConcatenationMap&& concatenation_map_, std::string&& name_)
+ConcatenatedVfsFile::ConcatenatedVfsFile(std::string&& name_, ConcatenationMap&& concatenation_map_)
     : concatenation_map(std::move(concatenation_map_)), name(std::move(name_)) {
     DEBUG_ASSERT(this->VerifyContinuity());
 }
@@ -30,8 +30,8 @@ bool ConcatenatedVfsFile::VerifyContinuity() const {
 
 ConcatenatedVfsFile::~ConcatenatedVfsFile() = default;
 
-VirtualFile ConcatenatedVfsFile::MakeConcatenatedFile(const std::vector<VirtualFile>& files,
+VirtualFile ConcatenatedVfsFile::MakeConcatenatedFile(std::string&& name,
-                                                      std::string&& name) {
+                                                      std::vector<VirtualFile>&& files) {
     // Fold trivial cases.
     if (files.empty()) {
         return nullptr;
@@ -46,20 +46,21 @@ VirtualFile ConcatenatedVfsFile::MakeConcatenatedFile(const std::vector<VirtualF
     u64 last_offset = 0;
 
     for (auto& file : files) {
+        const auto size = file->GetSize();
+
         concatenation_map.emplace_back(ConcatenationEntry{
             .offset = last_offset,
-            .file = file,
+            .file = std::move(file),
         });
 
-        last_offset += file->GetSize();
+        last_offset += size;
     }
 
-    return VirtualFile(new ConcatenatedVfsFile(std::move(concatenation_map), std::move(name)));
+    return VirtualFile(new ConcatenatedVfsFile(std::move(name), std::move(concatenation_map)));
 }
 
-VirtualFile ConcatenatedVfsFile::MakeConcatenatedFile(u8 filler_byte,
+VirtualFile ConcatenatedVfsFile::MakeConcatenatedFile(u8 filler_byte, std::string&& name,
-                                                      const std::multimap<u64, VirtualFile>& files,
+                                                      std::multimap<u64, VirtualFile>&& files) {
-                                                      std::string&& name) {
     // Fold trivial cases.
     if (files.empty()) {
         return nullptr;
@@ -76,6 +77,8 @@ VirtualFile ConcatenatedVfsFile::MakeConcatenatedFile(u8 filler_byte,
 
     // Iteration of a multimap is ordered, so offset will be strictly non-decreasing.
     for (auto& [offset, file] : files) {
+        const auto size = file->GetSize();
+
         if (offset > last_offset) {
             concatenation_map.emplace_back(ConcatenationEntry{
                 .offset = last_offset,
@@ -85,13 +88,13 @@ VirtualFile ConcatenatedVfsFile::MakeConcatenatedFile(u8 filler_byte,
 
         concatenation_map.emplace_back(ConcatenationEntry{
             .offset = offset,
-            .file = file,
+            .file = std::move(file),
         });
 
-        last_offset = offset + file->GetSize();
+        last_offset = offset + size;
     }
 
-    return VirtualFile(new ConcatenatedVfsFile(std::move(concatenation_map), std::move(name)));
+    return VirtualFile(new ConcatenatedVfsFile(std::move(name), std::move(concatenation_map)));
 }
 
 std::string ConcatenatedVfsFile::GetName() const {

src/core/file_sys/vfs_concat.h

@@ -24,22 +24,20 @@ private:
     };
     using ConcatenationMap = std::vector<ConcatenationEntry>;
 
-    explicit ConcatenatedVfsFile(std::vector<ConcatenationEntry>&& concatenation_map,
+    explicit ConcatenatedVfsFile(std::string&& name,
-                                 std::string&& name);
+                                 std::vector<ConcatenationEntry>&& concatenation_map);
     bool VerifyContinuity() const;
 
 public:
     ~ConcatenatedVfsFile() override;
 
     /// Wrapper function to allow for more efficient handling of files.size() == 0, 1 cases.
-    static VirtualFile MakeConcatenatedFile(const std::vector<VirtualFile>& files,
+    static VirtualFile MakeConcatenatedFile(std::string&& name, std::vector<VirtualFile>&& files);
-                                            std::string&& name);
 
     /// Convenience function that turns a map of offsets to files into a concatenated file, filling
     /// gaps with a given filler byte.
-    static VirtualFile MakeConcatenatedFile(u8 filler_byte,
+    static VirtualFile MakeConcatenatedFile(u8 filler_byte, std::string&& name,
-                                            const std::multimap<u64, VirtualFile>& files,
+                                            std::multimap<u64, VirtualFile>&& files);
-                                            std::string&& name);
 
     std::string GetName() const override;
     std::size_t GetSize() const override;

src/core/file_sys/vfs_layered.cpp

@@ -38,7 +38,7 @@ VirtualDir LayeredVfsDirectory::GetDirectoryRelative(std::string_view path) cons
     for (const auto& layer : dirs) {
         auto dir = layer->GetDirectoryRelative(path);
         if (dir != nullptr) {
-            out.push_back(std::move(dir));
+            out.emplace_back(std::move(dir));
         }
     }
 
@@ -62,11 +62,11 @@ std::vector<VirtualFile> LayeredVfsDirectory::GetFiles() const {
     std::set<std::string, std::less<>> out_names;
 
     for (const auto& layer : dirs) {
-        for (const auto& file : layer->GetFiles()) {
+        for (auto& file : layer->GetFiles()) {
             auto file_name = file->GetName();
             if (!out_names.contains(file_name)) {
                 out_names.emplace(std::move(file_name));
-                out.push_back(file);
+                out.emplace_back(std::move(file));
             }
         }
     }
@@ -86,7 +86,7 @@ std::vector<VirtualDir> LayeredVfsDirectory::GetSubdirectories() const {
     std::vector<VirtualDir> out;
     out.reserve(names.size());
     for (const auto& subdir : names)
-        out.push_back(GetSubdirectory(subdir));
+        out.emplace_back(GetSubdirectory(subdir));
 
     return out;
 }

src/video_core/buffer_cache/buffer_cache_base.h

@@ -62,7 +62,11 @@ using BufferId = SlotId;
 using VideoCore::Surface::PixelFormat;
 using namespace Common::Literals;
 
+#ifdef __APPLE__
+constexpr u32 NUM_VERTEX_BUFFERS = 16;
+#else
 constexpr u32 NUM_VERTEX_BUFFERS = 32;
+#endif
 constexpr u32 NUM_TRANSFORM_FEEDBACK_BUFFERS = 4;
 constexpr u32 NUM_GRAPHICS_UNIFORM_BUFFERS = 18;
 constexpr u32 NUM_COMPUTE_UNIFORM_BUFFERS = 8;

src/video_core/host_shaders/convert_d24s8_to_abgr8.frag

@@ -3,16 +3,16 @@
 
 #version 450
 
+precision mediump int;
+precision highp float;
+
 layout(binding = 0) uniform sampler2D depth_tex;
-layout(binding = 1) uniform isampler2D stencil_tex;
+layout(binding = 1) uniform usampler2D stencil_tex;
 
 layout(location = 0) out vec4 color;
 
 void main() {
     ivec2 coord = ivec2(gl_FragCoord.xy);
-    uint depth = uint(textureLod(depth_tex, coord, 0).r * (exp2(24.0) - 1.0f));
-    uint stencil = uint(textureLod(stencil_tex, coord, 0).r);
-
     highp uint depth_val =
         uint(textureLod(depth_tex, coord, 0).r * (exp2(32.0) - 1.0));
     lowp uint stencil_val = textureLod(stencil_tex, coord, 0).r;

src/video_core/host_shaders/convert_s8d24_to_abgr8.frag

@@ -3,16 +3,16 @@
 
 #version 450
 
+precision mediump int;
+precision highp float;
+
 layout(binding = 0) uniform sampler2D depth_tex;
-layout(binding = 1) uniform isampler2D stencil_tex;
+layout(binding = 1) uniform usampler2D stencil_tex;
 
 layout(location = 0) out vec4 color;
 
 void main() {
     ivec2 coord = ivec2(gl_FragCoord.xy);
-    uint depth = uint(textureLod(depth_tex, coord, 0).r * (exp2(24.0) - 1.0f));
-    uint stencil = uint(textureLod(stencil_tex, coord, 0).r);
-
     highp uint depth_val =
         uint(textureLod(depth_tex, coord, 0).r * (exp2(32.0) - 1.0));
     lowp uint stencil_val = textureLod(stencil_tex, coord, 0).r;

src/video_core/renderer_vulkan/vk_query_cache.cpp

@@ -1436,6 +1436,7 @@ void QueryCacheRuntime::Barriers(bool is_prebarrier) {
         .srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT,
         .dstAccessMask = VK_ACCESS_MEMORY_READ_BIT | VK_ACCESS_MEMORY_WRITE_BIT,
     };
+    impl->scheduler.RequestOutsideRenderPassOperationContext();
     if (is_prebarrier) {
         impl->scheduler.Record([](vk::CommandBuffer cmdbuf) {
             cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_ALL_COMMANDS_BIT,

src/video_core/renderer_vulkan/vk_rasterizer.cpp

@@ -975,6 +975,19 @@ void RasterizerVulkan::UpdateScissorsState(Tegra::Engines::Maxwell3D::Regs& regs
     if (!state_tracker.TouchScissors()) {
         return;
     }
+    if (!regs.viewport_scale_offset_enabled) {
+        const auto x = static_cast<float>(regs.surface_clip.x);
+        const auto y = static_cast<float>(regs.surface_clip.y);
+        const auto width = static_cast<float>(regs.surface_clip.width);
+        const auto height = static_cast<float>(regs.surface_clip.height);
+        VkRect2D scissor;
+        scissor.offset.x = static_cast<u32>(x);
+        scissor.offset.y = static_cast<u32>(y);
+        scissor.extent.width = static_cast<u32>(width != 0.0f ? width : 1.0f);
+        scissor.extent.height = static_cast<u32>(height != 0.0f ? height : 1.0f);
+        scheduler.Record([scissor](vk::CommandBuffer cmdbuf) { cmdbuf.SetScissor(0, scissor); });
+        return;
+    }
     u32 up_scale = 1;
     u32 down_shift = 0;
     if (texture_cache.IsRescaling()) {

src/video_core/renderer_vulkan/vk_render_pass_cache.cpp

@@ -19,7 +19,7 @@ VkAttachmentDescription AttachmentDescription(const Device& device, PixelFormat
                                               VkSampleCountFlagBits samples) {
     using MaxwellToVK::SurfaceFormat;
     return {
-        .flags = VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT,
+        .flags = {},
         .format = SurfaceFormat(device, FormatType::Optimal, true, format).format,
         .samples = samples,
         .loadOp = VK_ATTACHMENT_LOAD_OP_LOAD,

src/video_core/texture_cache/formatter.cpp

@@ -10,19 +10,23 @@
 #include "video_core/texture_cache/image_info.h"
 #include "video_core/texture_cache/image_view_base.h"
 #include "video_core/texture_cache/render_targets.h"
+#include "video_core/texture_cache/samples_helper.h"
 
 namespace VideoCommon {
 
 std::string Name(const ImageBase& image) {
     const GPUVAddr gpu_addr = image.gpu_addr;
     const ImageInfo& info = image.info;
-    const u32 width = info.size.width;
+    u32 width = info.size.width;
-    const u32 height = info.size.height;
+    u32 height = info.size.height;
     const u32 depth = info.size.depth;
     const u32 num_layers = image.info.resources.layers;
     const u32 num_levels = image.info.resources.levels;
     std::string resource;
     if (image.info.num_samples > 1) {
+        const auto [samples_x, samples_y] = VideoCommon::SamplesLog2(image.info.num_samples);
+        width >>= samples_x;
+        height >>= samples_y;
         resource += fmt::format(":{}xMSAA", image.info.num_samples);
     }
     if (num_layers > 1) {

src/video_core/texture_cache/samples_helper.h

@@ -24,7 +24,7 @@ namespace VideoCommon {
         return {2, 2};
     }
     ASSERT_MSG(false, "Invalid number of samples={}", num_samples);
-    return {1, 1};
+    return {0, 0};
 }
 
 [[nodiscard]] inline int NumSamples(Tegra::Texture::MsaaMode msaa_mode) {

src/video_core/texture_cache/util.cpp

@@ -167,6 +167,13 @@ template <u32 GOB_EXTENT>
 }
 
 [[nodiscard]] constexpr Extent3D TileShift(const LevelInfo& info, u32 level) {
+    if (level == 0 && info.num_levels == 1) {
+        return Extent3D{
+            .width = info.block.width,
+            .height = info.block.height,
+            .depth = info.block.depth,
+        };
+    }
     const Extent3D blocks = NumLevelBlocks(info, level);
     return Extent3D{
         .width = AdjustTileSize(info.block.width, GOB_SIZE_X, blocks.width),
@@ -1293,9 +1300,9 @@ u32 MapSizeBytes(const ImageBase& image) {
 
 static_assert(CalculateLevelSize(LevelInfo{{1920, 1080, 1}, {0, 2, 0}, {1, 1}, 2, 0, 1}, 0) ==
               0x7f8000);
-static_assert(CalculateLevelSize(LevelInfo{{32, 32, 1}, {0, 0, 4}, {1, 1}, 4, 0, 1}, 0) == 0x4000);
+static_assert(CalculateLevelSize(LevelInfo{{32, 32, 1}, {0, 0, 4}, {1, 1}, 4, 0, 1}, 0) == 0x40000);
 
-static_assert(CalculateLevelSize(LevelInfo{{128, 8, 1}, {0, 4, 0}, {1, 1}, 4, 0, 1}, 0) == 0x4000);
+static_assert(CalculateLevelSize(LevelInfo{{128, 8, 1}, {0, 4, 0}, {1, 1}, 4, 0, 1}, 0) == 0x40000);
 
 static_assert(CalculateLevelOffset(PixelFormat::R8_SINT, {1920, 1080, 1}, {0, 2, 0}, 0, 7) ==
               0x2afc00);