early-access version 3568

README.md

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

src/core/file_sys/vfs_layered.cpp

@@ -2,9 +2,9 @@
 // SPDX-License-Identifier: GPL-2.0-or-later
 
 #include <algorithm>
+#include <set>
 #include <utility>
 #include "core/file_sys/vfs_layered.h"
-#include "core/file_sys/vfs_types.h"
 
 namespace FileSys {
 
@@ -59,13 +59,13 @@ std::string LayeredVfsDirectory::GetFullPath() const {
 
 std::vector<VirtualFile> LayeredVfsDirectory::GetFiles() const {
     std::vector<VirtualFile> out;
-    std::map<std::string, size_t, std::less<>> out_positions;
+    std::set<std::string, std::less<>> out_names;
 
     for (const auto& layer : dirs) {
         for (const auto& file : layer->GetFiles()) {
             auto file_name = file->GetName();
-            if (!out_positions.contains(file_name)) {
+            if (!out_names.contains(file_name)) {
-                out_positions.emplace(std::move(file_name), out.size());
+                out_names.emplace(std::move(file_name));
                 out.push_back(file);
             }
         }

src/core/hid/emulated_controller.cpp

@@ -979,7 +979,6 @@ void EmulatedController::SetMotion(const Common::Input::CallbackStatus& callback
     emulated.SetUserGyroThreshold(raw_status.gyro.x.properties.threshold);
     emulated.UpdateRotation(raw_status.delta_timestamp);
     emulated.UpdateOrientation(raw_status.delta_timestamp);
-    force_update_motion = raw_status.force_update;
 
     auto& motion = controller.motion_state[index];
     motion.accel = emulated.GetAcceleration();
@@ -1618,19 +1617,6 @@ NpadGcTriggerState EmulatedController::GetTriggers() const {
 
 MotionState EmulatedController::GetMotions() const {
     std::unique_lock lock{mutex};
-
-    // Some drivers like mouse motion need constant refreshing
-    if (force_update_motion) {
-        for (auto& device : motion_devices) {
-            if (!device) {
-                continue;
-            }
-            lock.unlock();
-            device->ForceUpdate();
-            lock.lock();
-        }
-    }
-
     return controller.motion_state;
 }
 
@@ -1696,8 +1682,21 @@ void EmulatedController::DeleteCallback(int key) {
     callback_list.erase(iterator);
 }
 
-void EmulatedController::TurboButtonUpdate() {
+void EmulatedController::StatusUpdate() {
     turbo_button_state = (turbo_button_state + 1) % (TURBO_BUTTON_DELAY * 2);
+
+    // Some drivers like key motion need constant refreshing
+    for (std::size_t index = 0; index < motion_devices.size(); ++index) {
+        const auto& raw_status = controller.motion_values[index].raw_status;
+        auto& device = motion_devices[index];
+        if (!raw_status.force_update) {
+            continue;
+        }
+        if (!device) {
+            continue;
+        }
+        device->ForceUpdate();
+    }
 }
 
 NpadButton EmulatedController::GetTurboButtonMask() const {

src/core/hid/emulated_controller.h

@@ -415,8 +415,8 @@ public:
      */
     void DeleteCallback(int key);
 
-    /// Swaps the state of the turbo buttons
+    /// Swaps the state of the turbo buttons and updates motion input
-    void TurboButtonUpdate();
+    void StatusUpdate();
 
 private:
     /// creates input devices from params
@@ -528,7 +528,6 @@ private:
     bool is_configuring{false};
     bool system_buttons_enabled{true};
     f32 motion_sensitivity{Core::HID::MotionInput::IsAtRestStandard};
-    bool force_update_motion{false};
     u32 turbo_button_state{0};
 
     // Temporary values to avoid doing changes while the controller is in configuring mode

src/core/hid/input_converter.cpp

@@ -86,7 +86,7 @@ Common::Input::MotionStatus TransformToMotion(const Common::Input::CallbackStatu
             .range = 1.0f,
             .offset = 0.0f,
         };
-        status.delta_timestamp = 5000;
+        status.delta_timestamp = 1000;
         status.force_update = true;
         status.accel.x = {
             .value = 0.0f,

src/core/hle/service/hid/controllers/npad.cpp

@@ -423,8 +423,8 @@ void Controller_NPad::RequestPadStateUpdate(Core::HID::NpadIdType npad_id) {
         return;
     }
 
-    // This function is unique to yuzu for the turbo buttons to work properly
+    // This function is unique to yuzu for the turbo buttons and motion to work properly
-    controller.device->TurboButtonUpdate();
+    controller.device->StatusUpdate();
 
     auto& pad_entry = controller.npad_pad_state;
     auto& trigger_entry = controller.npad_trigger_state;

src/input_common/input_poller.cpp

@@ -667,7 +667,7 @@ public:
             .raw_value = input_engine->GetAxis(identifier, axis_z),
             .properties = properties_z,
         };
-        status.delta_timestamp = 5000;
+        status.delta_timestamp = 1000;
         status.force_update = true;
         return status;
     }

src/video_core/buffer_cache/buffer_cache.h

@@ -203,11 +203,8 @@ bool BufferCache<P>::DMACopy(GPUVAddr src_address, GPUVAddr dest_address, u64 am
         const VAddr new_base_address = *cpu_dest_address + diff;
         const IntervalType add_interval{new_base_address, new_base_address + size};
         tmp_intervals.push_back(add_interval);
-        if (!Settings::values.use_reactive_flushing.GetValue() ||
-            memory_tracker.IsRegionPreflushable(new_base_address, new_base_address + size)) {
         uncommitted_ranges.add(add_interval);
         pending_ranges.add(add_interval);
-        }
     };
     ForEachInRangeSet(common_ranges, *cpu_src_address, amount, mirror);
     // This subtraction in this order is important for overlapping copies.
@@ -1234,10 +1231,6 @@ void BufferCache<P>::MarkWrittenBuffer(BufferId buffer_id, VAddr cpu_addr, u32 s
 
     const IntervalType base_interval{cpu_addr, cpu_addr + size};
     common_ranges.add(base_interval);
-    if (Settings::values.use_reactive_flushing.GetValue() &&
-        !memory_tracker.IsRegionPreflushable(cpu_addr, cpu_addr + size)) {
-        return;
-    }
     uncommitted_ranges.add(base_interval);
     pending_ranges.add(base_interval);
 }

src/video_core/engines/maxwell_dma.cpp

@@ -288,7 +288,7 @@ void MaxwellDMA::CopyPitchToBlockLinear() {
     write_buffer.resize_destructive(dst_size);
 
     memory_manager.ReadBlock(regs.offset_in, read_buffer.data(), src_size);
-    memory_manager.ReadBlock(regs.offset_out, write_buffer.data(), dst_size);
+    memory_manager.ReadBlockUnsafe(regs.offset_out, write_buffer.data(), dst_size);
 
     // If the input is linear and the output is tiled, swizzle the input and copy it over.
     SwizzleSubrect(write_buffer, read_buffer, bytes_per_pixel, width, height, depth, x_offset,

src/video_core/renderer_opengl/gl_rasterizer.cpp

@@ -1304,7 +1304,7 @@ bool AccelerateDMA::DmaBufferImageCopy(const Tegra::DMA::ImageCopy& copy_info,
                                        const Tegra::DMA::BufferOperand& buffer_operand,
                                        const Tegra::DMA::ImageOperand& image_operand) {
     std::scoped_lock lock{buffer_cache.mutex, texture_cache.mutex};
-    const auto image_id = texture_cache.DmaImageId(image_operand);
+    const auto image_id = texture_cache.DmaImageId(image_operand, IS_IMAGE_UPLOAD);
     if (image_id == VideoCommon::NULL_IMAGE_ID) {
         return false;
     }

src/video_core/renderer_vulkan/vk_rasterizer.cpp

@@ -510,13 +510,6 @@ VideoCore::RasterizerDownloadArea RasterizerVulkan::GetFlushArea(VAddr addr, u64
             return *area;
         }
     }
-    {
-        std::scoped_lock lock{buffer_cache.mutex};
-        auto area = buffer_cache.GetFlushArea(addr, size);
-        if (area) {
-            return *area;
-        }
-    }
     VideoCore::RasterizerDownloadArea new_area{
         .start_address = Common::AlignDown(addr, Core::Memory::YUZU_PAGESIZE),
         .end_address = Common::AlignUp(addr + size, Core::Memory::YUZU_PAGESIZE),
@@ -800,7 +793,7 @@ bool AccelerateDMA::DmaBufferImageCopy(const Tegra::DMA::ImageCopy& copy_info,
                                        const Tegra::DMA::BufferOperand& buffer_operand,
                                        const Tegra::DMA::ImageOperand& image_operand) {
     std::scoped_lock lock{buffer_cache.mutex, texture_cache.mutex};
-    const auto image_id = texture_cache.DmaImageId(image_operand);
+    const auto image_id = texture_cache.DmaImageId(image_operand, IS_IMAGE_UPLOAD);
     if (image_id == VideoCommon::NULL_IMAGE_ID) {
         return false;
     }

src/video_core/texture_cache/texture_cache.h

@@ -811,7 +811,7 @@ void TextureCache<P>::PopAsyncFlushes() {
 }
 
 template <class P>
-ImageId TextureCache<P>::DmaImageId(const Tegra::DMA::ImageOperand& operand) {
+ImageId TextureCache<P>::DmaImageId(const Tegra::DMA::ImageOperand& operand, bool is_upload) {
     const ImageInfo dst_info(operand);
     const ImageId dst_id = FindDMAImage(dst_info, operand.address);
     if (!dst_id) {
@@ -822,7 +822,7 @@ ImageId TextureCache<P>::DmaImageId(const Tegra::DMA::ImageOperand& operand) {
         // No need to waste time on an image that's synced with guest
         return NULL_IMAGE_ID;
     }
-    if (!image.info.dma_downloaded) {
+    if (!is_upload && !image.info.dma_downloaded) {
         // Force a full sync.
         image.info.dma_downloaded = true;
         return NULL_IMAGE_ID;
@@ -1323,7 +1323,6 @@ ImageId TextureCache<P>::JoinImages(const ImageInfo& info, GPUVAddr gpu_addr, VA
             all_siblings.push_back(overlap_id);
         } else {
             bad_overlap_ids.push_back(overlap_id);
-            overlap.flags |= ImageFlagBits::BadOverlap;
         }
     };
     ForEachImageInRegion(cpu_addr, size_bytes, region_check);
@@ -1434,8 +1433,13 @@ ImageId TextureCache<P>::JoinImages(const ImageInfo& info, GPUVAddr gpu_addr, VA
         ImageBase& aliased = slot_images[aliased_id];
         aliased.overlapping_images.push_back(new_image_id);
         new_image.overlapping_images.push_back(aliased_id);
+        if (aliased.info.resources.levels == 1 && aliased.overlapping_images.size() > 1) {
+            aliased.flags |= ImageFlagBits::BadOverlap;
+        }
+        if (new_image.info.resources.levels == 1 && new_image.overlapping_images.size() > 1) {
             new_image.flags |= ImageFlagBits::BadOverlap;
         }
+    }
     RegisterImage(new_image_id);
     return new_image_id;
 }

src/video_core/texture_cache/texture_cache_base.h

@@ -207,7 +207,7 @@ public:
     /// Pop asynchronous downloads
     void PopAsyncFlushes();
 
-    [[nodiscard]] ImageId DmaImageId(const Tegra::DMA::ImageOperand& operand);
+    [[nodiscard]] ImageId DmaImageId(const Tegra::DMA::ImageOperand& operand, bool is_upload);
 
     [[nodiscard]] std::pair<Image*, BufferImageCopy> DmaBufferImageCopy(
         const Tegra::DMA::ImageCopy& copy_info, const Tegra::DMA::BufferOperand& buffer_operand,