+ // XC2 passes in NaN mix volumes, causing further issues as we handle everything as s32 rather

+ // than float, so the NaN propogation is lost. As the samples get further modified for

+ // volume etc, they can get out of NaN range, so a later heuristic for catching this is

+ // more difficult. Handle it here by setting these samples to silence.

+ if (std::isnan(gain)) {

+ gain = 0.0f;

+ delta = 0.0f;

+ }

+

+ if (values.cpu_debug_mode) {

+ return values.volume.GetValue() / 100.0f;

+ Auto = 0,

+ Accurate = 1,

+ Unsafe = 2,

+ Setting<u8> volume{100, "volume"};

+ Setting<CPUAccuracy> cpu_accuracy{CPUAccuracy::Auto, "cpu_accuracy"};

+ // TODO: remove cpu_accuracy_first_time, migration setting added 8 July 2021

+ BasicSetting<bool> cpu_accuracy_first_time{true, "cpu_accuracy_first_time"};

+ BasicSetting<bool> cpu_debug_mode{false, "cpu_debug_mode"};

+ BasicSetting<bool> disable_fps_limit{false, "disable_fps_limit"};

+ Setting<u8> bg_red{0, "bg_red"};

+ Setting<u8> bg_green{0, "bg_green"};

+ Setting<u8> bg_blue{0, "bg_blue"};

+ BasicSetting<u8> mouse_panning_sensitivity{10, "mouse_panning_sensitivity"};

+ hle/service/am/applets/applet_controller.cpp

+ hle/service/am/applets/applet_controller.h

+ hle/service/am/applets/applet_error.cpp

+ hle/service/am/applets/applet_error.h

+ hle/service/am/applets/applet_general_backend.cpp

+ hle/service/am/applets/applet_general_backend.h

+ hle/service/am/applets/applet_profile_select.cpp

+ hle/service/am/applets/applet_profile_select.h

+ hle/service/am/applets/applet_software_keyboard.cpp

+ hle/service/am/applets/applet_software_keyboard.h

+ hle/service/am/applets/applet_software_keyboard_types.h

+ hle/service/am/applets/applet_web_browser.cpp

+ hle/service/am/applets/applet_web_browser.h

+ hle/service/am/applets/applet_web_browser_types.h

+ hle/service/apm/apm_controller.cpp

+ hle/service/apm/apm_controller.h

+ hle/service/apm/apm_interface.cpp

+ hle/service/apm/apm_interface.h

+ hle/service/bcat/bcat_module.cpp

+ hle/service/bcat/bcat_module.h

+ hle/service/friend/friend_interface.cpp

+ hle/service/friend/friend_interface.h

+ hle/service/glue/glue_manager.cpp

+ hle/service/glue/glue_manager.h

+ hle/service/mii/mii_manager.cpp

+ hle/service/mii/mii_manager.h

+ hle/service/nvdrv/nvdrv_interface.cpp

+ hle/service/nvdrv/nvdrv_interface.h

+ hle/service/pctl/pctl_module.cpp

+ hle/service/pctl/pctl_module.h

+ hle/service/sm/sm_controller.cpp

+ hle/service/sm/sm_controller.h

+ hle/service/spl/spl_module.cpp

+ hle/service/spl/spl_module.h

+ hle/service/time/time_interface.cpp

+ hle/service/time/time_interface.h

+ if (Settings::values.cpu_debug_mode) {

+ if (Settings::values.cpuopt_unsafe_unfuse_fma) {

+ if (Settings::values.cpuopt_unsafe_reduce_fp_error) {

+ if (Settings::values.cpuopt_unsafe_ignore_standard_fpcr) {

+ if (Settings::values.cpuopt_unsafe_inaccurate_nan) {

+ // Curated optimizations

+ if (Settings::values.cpu_accuracy.GetValue() == Settings::CPUAccuracy::Auto) {

+ config.unsafe_optimizations = true;

+ config.optimizations |= Dynarmic::OptimizationFlag::Unsafe_UnfuseFMA;

+ config.optimizations |= Dynarmic::OptimizationFlag::Unsafe_IgnoreStandardFPCRValue;

+ config.optimizations |= Dynarmic::OptimizationFlag::Unsafe_InaccurateNaN;

+ }

+

+ if (Settings::values.cpu_debug_mode) {

+ if (Settings::values.cpuopt_unsafe_unfuse_fma) {

+ if (Settings::values.cpuopt_unsafe_reduce_fp_error) {

+ if (Settings::values.cpuopt_unsafe_inaccurate_nan) {

+ if (Settings::values.cpuopt_unsafe_fastmem_check) {

+ // Curated optimizations

+ if (Settings::values.cpu_accuracy.GetValue() == Settings::CPUAccuracy::Auto) {

+ config.unsafe_optimizations = true;

+ config.optimizations |= Dynarmic::OptimizationFlag::Unsafe_UnfuseFMA;

+ config.optimizations |= Dynarmic::OptimizationFlag::Unsafe_InaccurateNaN;

+ config.fastmem_address_space_bits = 64;

+ }

+

+#include "core/hle/service/apm/apm_controller.h"

+#include "core/hle/service/glue/glue_manager.h"

+#include "core/hle/service/am/applets/applet_software_keyboard_types.h"

+#include "core/hle/service/am/applets/applet_web_browser_types.h"

+#include "core/hle/service/nvdrv/nvdrv_interface.h"

+#include "core/hle/service/glue/glue_manager.h"

+#include "core/hle/service/glue/glue_manager.h"

+#include "core/hle/service/am/applets/applet_profile_select.h"

+#include "core/hle/service/am/applets/applet_software_keyboard.h"

+#include "core/hle/service/am/applets/applet_web_browser.h"

+#include "core/hle/service/apm/apm_controller.h"

+#include "core/hle/service/apm/apm_interface.h"

+#include "core/hle/service/am/applets/applet_controller.h"

+#include "core/hle/service/am/applets/applet_error.h"

+#include "core/hle/service/am/applets/applet_general_backend.h"

+#include "core/hle/service/am/applets/applet_profile_select.h"

+#include "core/hle/service/am/applets/applet_software_keyboard.h"

+#include "core/hle/service/am/applets/applet_software_keyboard_types.h"

+#include "core/hle/service/am/applets/applet_web_browser.h"

+std::string ResolveURL(const std::string& url) {

+ const auto index = url.find_first_of('%');

+

+ if (index == std::string::npos) {

+ return url;

+ }

+

+ return url.substr(0, index) + "lp1" + url.substr(index + 1);

+}

+

+

+ // Resolve Nintendo CDN URLs.

+ external_url = ResolveURL(external_url);

+#include "core/hle/service/am/applets/applet_web_browser_types.h"

+#include "core/hle/service/am/applets/applet_controller.h"

+#include "core/hle/service/am/applets/applet_error.h"

+#include "core/hle/service/am/applets/applet_general_backend.h"

+#include "core/hle/service/am/applets/applet_profile_select.h"

+#include "core/hle/service/am/applets/applet_software_keyboard.h"

+#include "core/hle/service/am/applets/applet_web_browser.h"

+#include "core/hle/service/apm/apm_interface.h"

+#include "core/hle/service/apm/apm_controller.h"

+#include "core/hle/service/apm/apm_controller.h"

+#include "core/hle/service/apm/apm_interface.h"

+#ifndef __clang__

+#pragma GCC diagnostic ignored "-Wmaybe-uninitialized"

+#endif

+#include "core/hle/service/bcat/bcat_module.h"

+#include "core/hle/service/bcat/bcat_module.h"

+#include "core/hle/service/friend/friend_interface.h"

+#include "core/hle/service/friend/friend_interface.h"

+#include "core/hle/service/glue/glue_manager.h"

+#include "core/hle/service/glue/glue_manager.h"

+ if (!Settings::values.vibration_enabled.GetValue()) {

+ vibration_devices_mounted[npad_index][device_index] = false;

+ return;

+ }

+

+#include "core/hle/service/mii/mii_manager.h"

+#include "core/hle/service/mii/mii_manager.h"

+#include "core/hle/service/mii/mii_manager.h"

+// Copies count amount of type T from the input vector into the dst vector.

+// Returns the number of bytes written into dst.

+std::size_t SliceVectors(const std::vector<u8>& input, std::vector<T>& dst, std::size_t count,

+ std::size_t offset) {

+ if (dst.empty()) {

+ return 0;

+ const size_t bytes_copied = count * sizeof(T);

+ std::memcpy(dst.data(), input.data() + offset, bytes_copied);

+ return bytes_copied;

+// Writes the data in src to an offset into the dst vector. The offset is specified in bytes

+// Returns the number of bytes written into dst.

+ const size_t bytes_copied = src.size() * sizeof(T);

+ std::memcpy(dst.data() + offset, src.data(), bytes_copied);

+ return bytes_copied;

+ // Slice input into their respective buffers

+ std::size_t offset = sizeof(IoctlSubmit);

+ offset += SliceVectors(input, command_buffers, params.cmd_buffer_count, offset);

+ offset += SliceVectors(input, relocs, params.relocation_count, offset);

+ offset += SliceVectors(input, reloc_shifts, params.relocation_count, offset);

+ offset += SliceVectors(input, syncpt_increments, params.syncpoint_count, offset);

+ offset += SliceVectors(input, wait_checks, params.syncpoint_count, offset);

+ offset += SliceVectors(input, fences, params.fence_count, offset);

+ const auto object = nvmap_dev->GetObject(cmd_buffer.memory_id);

+ system.Memory().ReadBlock(object->addr + cmd_buffer.offset, cmdlist.data(),

+ cmdlist.size() * sizeof(u32));

+ offset += WriteVectors(output, command_buffers, offset);

+ offset += WriteVectors(output, relocs, offset);

+ offset += WriteVectors(output, reloc_shifts, offset);

+ offset += WriteVectors(output, syncpt_increments, offset);

+ offset += WriteVectors(output, wait_checks, offset);

+ offset += WriteVectors(output, fences, offset);

+ SliceVectors(input, cmd_buffer_handles, params.num_entries, sizeof(IoctlMapBuffer));

+ for (auto& cmd_buffer : cmd_buffer_handles) {

+ auto object{nvmap_dev->GetObject(cmd_buffer.map_handle)};

+ LOG_ERROR(Service_NVDRV, "invalid cmd_buffer nvmap_handle={:X}", cmd_buffer.map_handle);

+ cmd_buffer.map_address = object->dma_map_addr;

+ SliceVectors(input, cmd_buffer_handles, params.num_entries, sizeof(IoctlMapBuffer));

+ for (auto& cmd_buffer : cmd_buffer_handles) {

+ const auto object{nvmap_dev->GetObject(cmd_buffer.map_handle)};

+ LOG_ERROR(Service_NVDRV, "invalid cmd_buffer nvmap_handle={:X}", cmd_buffer.map_handle);

+#include "core/hle/service/nvdrv/nvdrv_interface.h"

+#include "core/hle/service/nvdrv/nvdrv_interface.h"

+#include "core/hle/service/pctl/pctl_module.h"

+#include "core/hle/service/pctl/pctl_module.h"

+#include "core/hle/service/bcat/bcat_module.h"

+#include "core/hle/service/pctl/pctl_module.h"

+#include "core/hle/service/spl/spl_module.h"

+#include "core/hle/service/sm/sm_controller.h"

+#include "core/hle/service/sm/sm_controller.h"

+#include "core/hle/service/spl/spl_module.h"

+#include "core/hle/service/spl/spl_module.h"

+#include "core/hle/service/spl/spl_module.h"

+#include "core/hle/service/time/time_interface.h"

+#include "core/hle/service/time/time_interface.h"

+std::vector<std::unique_ptr<Polling::DevicePoller>> InputSubsystem::GetPollers([

+ [maybe_unused]] Polling::DeviceType type) const {

+ const float sensitivity = Settings::values.mouse_panning_sensitivity.GetValue() * 0.10f;

+ buffer.ForEachDownloadRangeAndClear(c, WORD, [&](u64 offset, u64 size) { ++num; });

+ ForEachModifiedRange<Type::CPU>(query_cpu_range, size, true, func);

+ void ForEachDownloadRange(VAddr query_cpu_range, u64 size, bool clear, Func&& func) {

+ ForEachModifiedRange<Type::GPU>(query_cpu_range, size, clear, func);

+ }

+

+ template <typename Func>

+ void ForEachDownloadRangeAndClear(VAddr query_cpu_range, u64 size, Func&& func) {

+ ForEachModifiedRange<Type::GPU>(query_cpu_range, size, true, func);

+ ForEachModifiedRange<Type::GPU>(cpu_addr, SizeBytes(), true, func);

+ void ForEachModifiedRange(VAddr query_cpu_range, s64 size, bool clear, Func&& func) {

+ if (clear) {

+ state_words[word_index] &= ~bits;

+ }

+#include <boost/icl/interval_set.hpp>

+ using IntervalSet = boost::icl::interval_set<VAddr>;

+ using IntervalType = typename IntervalSet::interval_type;

+

+ void AccumulateFlushes();

+

+ void CommitAsyncFlushesHigh();

+ [[nodiscard]] bool DMACopy(GPUVAddr src_address, GPUVAddr dest_address, u64 amount);

+

+ /// Return true when a CPU region is modified from the CPU

+ [[nodiscard]] bool IsRegionCpuModified(VAddr addr, size_t size);

+

+ template <typename Func>

+ void ForEachWrittenRange(VAddr cpu_addr, u64 size, Func&& func) {

+ const VAddr start_address = cpu_addr;

+ const VAddr end_address = start_address + size;

+ const VAddr search_base =

+ static_cast<VAddr>(std::min<s64>(0LL, static_cast<s64>(start_address - size)));

+ const IntervalType search_interval{search_base, search_base + 1};

+ auto it = common_ranges.lower_bound(search_interval);

+ if (it == common_ranges.end()) {

+ it = common_ranges.begin();

+ }

+ for (; it != common_ranges.end(); it++) {

+ VAddr inter_addr_end = it->upper();

+ VAddr inter_addr = it->lower();

+ if (inter_addr >= end_address) {

+ break;

+ }

+ if (inter_addr_end <= start_address) {

+ continue;

+ }

+ if (inter_addr_end > end_address) {

+ inter_addr_end = end_address;

+ }

+ if (inter_addr < start_address) {

+ inter_addr = start_address;

+ }

+ func(inter_addr, inter_addr_end);

+ }

+ }

+

+ IntervalSet uncommitted_ranges;

+ IntervalSet common_ranges;

+ std::deque<IntervalSet> committed_ranges;

+ common_ranges.clear();

+bool BufferCache<P>::DMACopy(GPUVAddr src_address, GPUVAddr dest_address, u64 amount) {

+ const std::optional<VAddr> cpu_src_address = gpu_memory.GpuToCpuAddress(src_address);

+ const std::optional<VAddr> cpu_dest_address = gpu_memory.GpuToCpuAddress(dest_address);

+ if (!cpu_src_address || !cpu_dest_address) {

+ return false;

+ }

+ const bool source_dirty = IsRegionGpuModified(*cpu_src_address, amount);

+ const bool dest_dirty = IsRegionGpuModified(*cpu_dest_address, amount);

+ if (!source_dirty && !dest_dirty) {

+ return false;

+ }

+

+ const IntervalType subtract_interval{*cpu_dest_address, *cpu_dest_address + amount};

+ uncommitted_ranges.subtract(subtract_interval);

+ for (auto& interval_set : committed_ranges) {

+ interval_set.subtract(subtract_interval);

+ }

+

+ BufferId buffer_a;

+ BufferId buffer_b;

+ do {

+ has_deleted_buffers = false;

+ buffer_a = FindBuffer(*cpu_src_address, static_cast<u32>(amount));

+ buffer_b = FindBuffer(*cpu_dest_address, static_cast<u32>(amount));

+ } while (has_deleted_buffers);

+ auto& src_buffer = slot_buffers[buffer_a];

+ auto& dest_buffer = slot_buffers[buffer_b];

+ SynchronizeBuffer(src_buffer, *cpu_src_address, static_cast<u32>(amount));

+ SynchronizeBuffer(dest_buffer, *cpu_dest_address, static_cast<u32>(amount));

+ std::array copies{BufferCopy{

+ .src_offset = src_buffer.Offset(*cpu_src_address),

+ .dst_offset = dest_buffer.Offset(*cpu_dest_address),

+ .size = amount,

+ }};

+

+ boost::container::small_vector<IntervalType, 4> tmp_intervals;

+ auto mirror = [&](VAddr base_address, VAddr base_address_end) {

+ const u64 size = base_address_end - base_address;

+ const VAddr diff = base_address - *cpu_src_address;

+ const VAddr new_base_address = *cpu_dest_address + diff;

+ const IntervalType add_interval{new_base_address, new_base_address + size};

+ uncommitted_ranges.add(add_interval);

+ tmp_intervals.push_back(add_interval);

+ };

+ ForEachWrittenRange(*cpu_src_address, amount, mirror);

+ // This subtraction in this order is important for overlapping copies.

+ common_ranges.subtract(subtract_interval);

+ for (const IntervalType add_interval : tmp_intervals) {

+ common_ranges.add(add_interval);

+ }

+

+ runtime.CopyBuffer(dest_buffer, src_buffer, copies);

+ if (source_dirty) {

+ dest_buffer.MarkRegionAsGpuModified(*cpu_dest_address, amount);

+ }

+ std::vector<u8> tmp_buffer(amount);

+ cpu_memory.ReadBlockUnsafe(*cpu_src_address, tmp_buffer.data(), amount);

+ cpu_memory.WriteBlockUnsafe(*cpu_dest_address, tmp_buffer.data(), amount);

+ return true;

+}

+

+template <class P>

+ return !uncommitted_ranges.empty() || !committed_ranges.empty();

+void BufferCache<P>::AccumulateFlushes() {

+ if (Settings::values.gpu_accuracy.GetValue() != Settings::GPUAccuracy::High) {

+ uncommitted_ranges.clear();

+ return;

+ }

+ if (uncommitted_ranges.empty()) {

+ return;

+ }

+ committed_ranges.emplace_back(std::move(uncommitted_ranges));

+bool BufferCache<P>::ShouldWaitAsyncFlushes() const noexcept {

+ return false;

+void BufferCache<P>::CommitAsyncFlushesHigh() {

+ AccumulateFlushes();

+ if (committed_ranges.empty()) {

+ for (const IntervalSet& intervals : committed_ranges) {

+ for (auto& interval : intervals) {

+ const std::size_t size = interval.upper() - interval.lower();

+ const VAddr cpu_addr = interval.lower();

+ ForEachBufferInRange(cpu_addr, size, [&](BufferId buffer_id, Buffer& buffer) {

+ boost::container::small_vector<BufferCopy, 1> copies;

+ buffer.ForEachDownloadRangeAndClear(

+ cpu_addr, size, [&](u64 range_offset, u64 range_size) {

+ const VAddr buffer_addr = buffer.CpuAddr();

+ const auto add_download = [&](VAddr start, VAddr end) {

+ const u64 new_offset = start - buffer_addr;

+ const u64 new_size = end - start;

+ downloads.push_back({

+ BufferCopy{

+ .src_offset = new_offset,

+ .dst_offset = total_size_bytes,

+ .size = new_size,

+ },

+ buffer_id,

+ });

+ // Align up to avoid cache conflicts

+ constexpr u64 align = 256ULL;

+ constexpr u64 mask = ~(align - 1ULL);

+ total_size_bytes += (new_size + align - 1) & mask;

+ largest_copy = std::max(largest_copy, new_size);

+ };

+

+ const VAddr start_address = buffer_addr + range_offset;

+ const VAddr end_address = start_address + range_size;

+ ForEachWrittenRange(start_address, range_size, add_download);

+ const IntervalType subtract_interval{start_address, end_address};

+ common_ranges.subtract(subtract_interval);

+ });

+ }

+ committed_ranges.clear();

+void BufferCache<P>::CommitAsyncFlushes() {

+ if (Settings::values.gpu_accuracy.GetValue() == Settings::GPUAccuracy::High) {

+ CommitAsyncFlushesHigh();

+ } else {

+ uncommitted_ranges.clear();

+ committed_ranges.clear();

+ }

+}

+

+template <class P>

+void BufferCache<P>::PopAsyncFlushes() {}

+

+template <class P>

+bool BufferCache<P>::IsRegionCpuModified(VAddr addr, size_t size) {

+ const u64 page_end = Common::DivCeil(addr + size, PAGE_SIZE);

+ for (u64 page = addr >> PAGE_BITS; page < page_end;) {

+ const BufferId image_id = page_table[page];

+ if (!image_id) {

+ ++page;

+ continue;

+ }

+ Buffer& buffer = slot_buffers[image_id];

+ if (buffer.IsRegionCpuModified(addr, size)) {

+ return true;

+ }

+ const VAddr end_addr = buffer.CpuAddr() + buffer.SizeBytes();

+ page = Common::DivCeil(end_addr, PAGE_SIZE);

+ }

+ return false;

+}

+

+template <class P>

+ const u32 new_offset = offset + maxwell3d.regs.index_array.first *

+ maxwell3d.regs.index_array.FormatSizeInBytes();

+ runtime.BindIndexBuffer(buffer, new_offset, size);

+ const u32 draw_size = (index_array.count + index_array.first) * index_array.FormatSizeInBytes();

+ const IntervalType base_interval{cpu_addr, cpu_addr + size};

+ common_ranges.add(base_interval);

+

+ const bool is_accuracy_high =

+ Settings::values.gpu_accuracy.GetValue() == Settings::GPUAccuracy::High;

+ if (!is_async && !is_accuracy_high) {

+ uncommitted_ranges.add(base_interval);

+ buffer.ForEachDownloadRangeAndClear(cpu_addr, size, [&](u64 range_offset, u64 range_size) {

+ const VAddr buffer_addr = buffer.CpuAddr();

+ const auto add_download = [&](VAddr start, VAddr end) {

+ const u64 new_offset = start - buffer_addr;

+ const u64 new_size = end - start;

+ copies.push_back(BufferCopy{

+ .src_offset = new_offset,

+ .dst_offset = total_size_bytes,

+ .size = new_size,

+ });

+ // Align up to avoid cache conflicts

+ constexpr u64 align = 256ULL;

+ constexpr u64 mask = ~(align - 1ULL);

+ total_size_bytes += (new_size + align - 1) & mask;

+ largest_copy = std::max(largest_copy, new_size);

+ };

+

+ const VAddr start_address = buffer_addr + range_offset;

+ const VAddr end_address = start_address + range_size;

+ ForEachWrittenRange(start_address, range_size, add_download);

+ const IntervalType subtract_interval{start_address, end_address};

+ common_ranges.subtract(subtract_interval);

+ .size = size,

+ const auto frame_width = std::min(surface_width, static_cast<size_t>(frame->width));

+ const auto frame_height = std::min(surface_height, static_cast<size_t>(frame->height));

+ const std::size_t half_width = frame_width / 2;

+ const std::size_t half_height = frame_height / 2;

+ const auto stride = static_cast<size_t>(frame->linesize[0]);

+ const auto half_stride = static_cast<size_t>(frame->linesize[1]);

+ chroma_buffer.resize(aligned_width * surface_height / 2);

+ for (std::size_t y = 0; y < frame_height; ++y) {

+ for (std::size_t x = 0; x < frame_width; ++x) {

+ luma_buffer[dst + x] = luma_ptr[src + x];

+#include "common/settings.h"

+ if (Settings::IsGPULevelHigh()) {

+ gpu.MemoryManager().ReadBlock(dma_get, command_headers.data(),

+ command_list_header.size * sizeof(u32));

+ } else {

+ gpu.MemoryManager().ReadBlockUnsafe(dma_get, command_headers.data(),

+ command_list_header.size * sizeof(u32));

+ }

+void MaxwellDMA::BindRasterizer(VideoCore::RasterizerInterface* rasterizer_) {

+ rasterizer = rasterizer_;

+}

+

+ auto& accelerate = rasterizer->AccessAccelerateDMA();

+ const bool is_buffer_clear = regs.launch_dma.remap_enable != 0 &&

+ regs.remap_const.dst_x == RemapConst::Swizzle::CONST_A;

+ // TODO: allow multisized components.

+ if (is_buffer_clear) {

+ ASSERT(regs.remap_const.component_size_minus_one == 3);

+ std::vector<u32> tmp_buffer(regs.line_length_in, regs.remap_consta_value);

+ memory_manager.WriteBlock(regs.offset_out, reinterpret_cast<u8*>(tmp_buffer.data()),

+ regs.line_length_in * sizeof(u32));

+ return;

+ }

+ UNIMPLEMENTED_IF(regs.launch_dma.remap_enable != 0);

+ if (!accelerate.BufferCopy(regs.offset_in, regs.offset_out, regs.line_length_in)) {

+ std::vector<u8> tmp_buffer(regs.line_length_in);

+ memory_manager.ReadBlockUnsafe(regs.offset_in, tmp_buffer.data(), regs.line_length_in);

+ memory_manager.WriteBlock(regs.offset_out, tmp_buffer.data(), regs.line_length_in);

+ }

+ UNIMPLEMENTED_IF(regs.launch_dma.remap_enable != 0);

+

+ UNIMPLEMENTED_IF(regs.launch_dma.remap_enable != 0);

+ UNIMPLEMENTED_IF(regs.launch_dma.remap_enable != 0);

+ memory_manager.ReadBlock(regs.offset_in, read_buffer.data(), src_size);

+ memory_manager.ReadBlock(regs.offset_out, write_buffer.data(), dst_size);

+namespace VideoCore {

+class RasterizerInterface;

+}

+

+class AccelerateDMAInterface {

+public:

+ /// Write the value to the register identified by method.

+ virtual bool BufferCopy(GPUVAddr src_address, GPUVAddr dest_address, u64 amount) = 0;

+};

+

+ void BindRasterizer(VideoCore::RasterizerInterface* rasterizer);

+

+ VideoCore::RasterizerInterface* rasterizer;

+ u32 reserved06[0xb6];

+ u32 remap_consta_value;

+ u32 remap_constb_value;

+#include "common/settings.h"

+ // Unlike other fences, this one doesn't

+ void SignalOrdering() {

+ std::scoped_lock lock{buffer_cache.mutex};

+ buffer_cache.AccumulateFlushes();

+ }

+

+ maxwell_dma->BindRasterizer(rasterizer);

+ case BufferMethods::RefCnt:

+ rasterizer->SignalReference();

+ break;

+namespace Engines {

+class AccelerateDMAInterface;

+} // namespace Tegra

+ /// Signal a GPU based reference as point

+ virtual void SignalReference() = 0;

+

+ [[nodiscard]] virtual Tegra::Engines::AccelerateDMAInterface& AccessAccelerateDMA() = 0;

+

+ query_cache(*this, maxwell3d, gpu_memory), accelerate_dma(buffer_cache),

+void RasterizerOpenGL::SignalReference() {

+ if (!gpu.IsAsync()) {

+ return;

+ }

+ fence_manager.SignalOrdering();

+}

+

+ SignalReference();

+Tegra::Engines::AccelerateDMAInterface& RasterizerOpenGL::AccessAccelerateDMA() {

+ return accelerate_dma;

+}

+

+AccelerateDMA::AccelerateDMA(BufferCache& buffer_cache_) : buffer_cache{buffer_cache_} {}

+

+bool AccelerateDMA::BufferCopy(GPUVAddr src_address, GPUVAddr dest_address, u64 amount) {

+ std::scoped_lock lock{buffer_cache.mutex};

+ return buffer_cache.DMACopy(src_address, dest_address, amount);

+}

+

+#include "video_core/engines/maxwell_dma.h"

+class AccelerateDMA : public Tegra::Engines::AccelerateDMAInterface {

+public:

+ explicit AccelerateDMA(BufferCache& buffer_cache);

+

+ bool BufferCopy(GPUVAddr src_address, GPUVAddr dest_address, u64 amount) override;

+

+private:

+ BufferCache& buffer_cache;

+};

+

+ void SignalReference() override;

+ Tegra::Engines::AccelerateDMAInterface& AccessAccelerateDMA() override;

+ AccelerateDMA accelerate_dma;

+ glClearColor(Settings::values.bg_red.GetValue() / 255.0f,

+ Settings::values.bg_green.GetValue() / 255.0f,

+ Settings::values.bg_blue.GetValue() / 255.0f, 1.0f);

+ const f32 bg_red = Settings::values.bg_red.GetValue() / 255.0f;

+ const f32 bg_green = Settings::values.bg_green.GetValue() / 255.0f;

+ const f32 bg_blue = Settings::values.bg_blue.GetValue() / 255.0f;

+ .color = {.float32 = {bg_red, bg_green, bg_blue, 1.0f}},

+ static constexpr VkMemoryBarrier write_barrier{

+ .sType = VK_STRUCTURE_TYPE_MEMORY_BARRIER,

+ .pNext = nullptr,

+ .srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT,

+ .dstAccessMask = VK_ACCESS_SHADER_READ_BIT,

+ };

+ const VkBufferCopy copy{

+ .srcOffset = offset,

+ .dstOffset = 0,

+ .size = TOTAL_BUFFER_SIZE,

+ };

+ cmdbuf.CopyBuffer(src, dst, copy);

+ cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT,

+ 0, write_barrier);

+ .srcAccessMask = is_initialized ? VK_ACCESS_SHADER_WRITE_BIT : VkAccessFlags{},

+ cmdbuf.PipelineBarrier(is_initialized ? VK_PIPELINE_STAGE_ALL_COMMANDS_BIT

+ : VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,

+ query_cache{*this, maxwell3d, gpu_memory, device, scheduler}, accelerate_dma{buffer_cache},

+ const u32 color_attachment = regs.clear_buffers.RT;

+ const auto attachment_aspect_mask = framebuffer->ImageRanges()[color_attachment].aspectMask;

+ const bool is_color_rt = (attachment_aspect_mask & VK_IMAGE_ASPECT_COLOR_BIT) != 0;

+ if (use_color && is_color_rt) {

+void RasterizerVulkan::SignalReference() {

+ if (!gpu.IsAsync()) {

+ return;

+ }

+ fence_manager.SignalOrdering();

+}

+

+ SignalReference();

+Tegra::Engines::AccelerateDMAInterface& RasterizerVulkan::AccessAccelerateDMA() {

+ return accelerate_dma;

+}

+

+AccelerateDMA::AccelerateDMA(BufferCache& buffer_cache_) : buffer_cache{buffer_cache_} {}

+

+bool AccelerateDMA::BufferCopy(GPUVAddr src_address, GPUVAddr dest_address, u64 amount) {

+ std::scoped_lock lock{buffer_cache.mutex};

+ return buffer_cache.DMACopy(src_address, dest_address, amount);

+}

+

+#include "video_core/engines/maxwell_dma.h"

+class AccelerateDMA : public Tegra::Engines::AccelerateDMAInterface {

+public:

+ explicit AccelerateDMA(BufferCache& buffer_cache);

+

+ bool BufferCopy(GPUVAddr start_address, GPUVAddr end_address, u64 amount) override;

+

+private:

+ BufferCache& buffer_cache;

+};

+

+ void SignalReference() override;

+ Tegra::Engines::AccelerateDMAInterface& AccessAccelerateDMA() override;

+ AccelerateDMA accelerate_dma;

+ if (aspect_mask != ImageAspectMask(dst.format)) {

+ UNIMPLEMENTED_MSG("Incompatible blit from format {} to {}", src.format, dst.format);

+ return;

+ }

+ scheduler->RequestOutsideRenderPassOperationContext();

+ for (size_t index = 0; index < NUM_RT; ++index) {

+ ImageViewId& color_buffer_id = render_targets.color_buffer_ids[index];

+ PrepareImageView(color_buffer_id, true, is_clear && IsFullClear(color_buffer_id));

+ }

+ const ImageViewId depth_buffer_id = render_targets.depth_buffer_id;

+ PrepareImageView(depth_buffer_id, true, is_clear && IsFullClear(depth_buffer_id));

+ u64 src_offset;

+ u64 dst_offset;

+ u32 tile_width_spacing) {

+ .width = size.width,

+ .height = size.height,

+ return MakeLevelInfo(info.format, info.size, info.block, info.tile_width_spacing);

+ u32 tile_width_spacing, u32 level) {

+ const LevelInfo info = MakeLevelInfo(format, size, block, tile_width_spacing);

+ return CalculateLevelOffset(info.format, info.size, info.block, info.tile_width_spacing,

+ info.resources.levels);

+static_assert(CalculateLevelOffset(PixelFormat::R8_SINT, {1920, 1080, 1}, {0, 2, 0}, 0, 7) ==

+static_assert(CalculateLevelOffset(PixelFormat::ASTC_2D_12X12_UNORM, {8192, 4096, 1}, {0, 2, 0}, 0,

+ 12) == 0x50d200);

+

+static_assert(CalculateLevelOffset(PixelFormat::A8B8G8R8_UNORM, {1024, 1024, 1}, {0, 4, 0}, 0, 0) ==

+ 0);

+static_assert(CalculateLevelOffset(PixelFormat::A8B8G8R8_UNORM, {1024, 1024, 1}, {0, 4, 0}, 0, 1) ==

+ 0x400000);

+static_assert(CalculateLevelOffset(PixelFormat::A8B8G8R8_UNORM, {1024, 1024, 1}, {0, 4, 0}, 0, 2) ==

+ 0x500000);

+static_assert(CalculateLevelOffset(PixelFormat::A8B8G8R8_UNORM, {1024, 1024, 1}, {0, 4, 0}, 0, 3) ==

+ 0x540000);

+static_assert(CalculateLevelOffset(PixelFormat::A8B8G8R8_UNORM, {1024, 1024, 1}, {0, 4, 0}, 0, 4) ==

+ 0x550000);

+static_assert(CalculateLevelOffset(PixelFormat::A8B8G8R8_UNORM, {1024, 1024, 1}, {0, 4, 0}, 0, 5) ==

+ 0x554000);

+static_assert(CalculateLevelOffset(PixelFormat::A8B8G8R8_UNORM, {1024, 1024, 1}, {0, 4, 0}, 0, 6) ==

+ 0x555000);

+static_assert(CalculateLevelOffset(PixelFormat::A8B8G8R8_UNORM, {1024, 1024, 1}, {0, 4, 0}, 0, 7) ==

+ 0x555400);

+static_assert(CalculateLevelOffset(PixelFormat::A8B8G8R8_UNORM, {1024, 1024, 1}, {0, 4, 0}, 0, 8) ==

+ 0x555600);

+static_assert(CalculateLevelOffset(PixelFormat::A8B8G8R8_UNORM, {1024, 1024, 1}, {0, 4, 0}, 0, 9) ==

+ 0x555800);

+ const u32 offset = CalculateLevelOffset(format, size, block, tile_width_spacing, level);

+

+#ifdef __GNUC__

+#pragma GCC diagnostic push

+#ifndef __clang__

+#pragma GCC diagnostic ignored "-Wmaybe-uninitialized"

+#endif

+#endif

+#ifdef __GNUC__

+#pragma GCC diagnostic pop

+#endif

+ applets/qt_controller.cpp

+ applets/qt_controller.h

+ applets/qt_controller.ui

+ applets/qt_error.cpp

+ applets/qt_error.h

+ applets/qt_profile_select.cpp

+ applets/qt_profile_select.h

+ applets/qt_software_keyboard.cpp

+ applets/qt_software_keyboard.h

+ applets/qt_software_keyboard.ui

+ applets/qt_web_browser.cpp

+ applets/qt_web_browser.h

+ applets/qt_web_browser_scripts.h

+ configuration/configure_debug_tab.cpp

+ configuration/configure_debug_tab.h

+ configuration/configure_debug_tab.ui

+#include "ui_qt_controller.h"

+#include "yuzu/applets/qt_controller.h"

+#include "yuzu/applets/qt_error.h"

+#include "yuzu/applets/qt_profile_select.h"

+#include "ui_qt_software_keyboard.h"

+#include "yuzu/applets/qt_software_keyboard.h"

+#include "yuzu/applets/qt_web_browser.h"

+#include "yuzu/applets/qt_web_browser_scripts.h"

+ // Qt sometimes returns the parent coordinates. To avoid this we read the global mouse

+ // coordinates and map them to the current render area

+ const auto pos = mapFromGlobal(QCursor::pos());

+ // Qt sometimes returns the parent coordinates. To avoid this we read the global mouse

+ // coordinates and map them to the current render area

+ const auto pos = mapFromGlobal(QCursor::pos());

+ ReadBasicSetting(Settings::values.cpu_accuracy_first_time);

+ if (Settings::values.cpu_accuracy_first_time) {

+ Settings::values.cpu_accuracy.SetValue(Settings::values.cpu_accuracy.GetDefault());

+ Settings::values.cpu_accuracy_first_time.SetValue(false);

+ } else {

+ ReadGlobalSetting(Settings::values.cpu_accuracy);

+ }

+ ReadBasicSetting(Settings::values.cpu_debug_mode);

+ if (global) {

+ ReadBasicSetting(Settings::values.renderer_debug);

+ }

+

+ WriteBasicSetting(Settings::values.cpu_accuracy_first_time);

+ WriteBasicSetting(Settings::values.cpu_debug_mode);

+ if (global) {

+ WriteBasicSetting(Settings::values.renderer_debug);

+ }

+

+ <number>11</number>

+ <widget class="ConfigureDebugTab" name="debugTab">

+ <customwidget>

+ <class>ConfigureDebugTab</class>

+ <extends>QWidget</extends>

+ <header>configuration/configure_debug_tab.h</header>

+ <container>1</container>

+ </customwidget>

+ <hints>

+ <hint type="sourcelabel">

+ <x>20</x>

+ <y>20</y>

+ </hint>

+ <hint type="destinationlabel">

+ <x>20</x>

+ <y>20</y>

+ </hint>

+ </hints>

+ <hints>

+ <hint type="sourcelabel">

+ <x>20</x>

+ <y>20</y>

+ </hint>

+ <hint type="destinationlabel">

+ <x>20</x>

+ <y>20</y>

+ </hint>

+ </hints>

+ const auto volume_value = static_cast<int>(Settings::values.volume.GetValue());

+ ui->volume_slider->setValue(volume_value);

+ const auto volume = static_cast<u8>(ui->volume_slider->value());

+ Settings::values.volume.SetValue(volume);

+ const auto volume = static_cast<u8>(ui->volume_slider->value());

+ Settings::values.volume.SetValue(volume);

+ <width>448</width>

+ <height>433</height>

+ <widget class="QGroupBox" name="groupBox">

+ <string>Auto</string>

+ <string>Accurate</string>

+ <string>Unsafe</string>

+ <string>We recommend setting accuracy to &quot;Auto&quot;.</string>

+ <width>592</width>

+ <height>503</height>

+ <widget class="QGroupBox" name="groupBox">

+ <widget class="QLabel" name="label">

+ <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;&lt;span style=&quot; font-weight:600;&quot;&gt;For debugging only.&lt;/span&gt;&lt;br/&gt;If you're not sure what these do, keep all of these enabled. &lt;br/&gt;These settings, when disabled, only take effect when CPU Debugging is enabled. &lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>

+ </property>

+ <property name="wordWrap">

+ <bool>false</bool>

+ &lt;div style=&quot;white-space: nowrap&quot;&gt;This optimization speeds up memory accesses by the guest program.&lt;/div&gt;

+ &lt;div style=&quot;white-space: nowrap&quot;&gt;Enabling it inlines accesses to PageTable::pointers into emitted code.&lt;/div&gt;

+ &lt;div style=&quot;white-space: nowrap&quot;&gt;Disabling this forces all memory accesses to go through the Memory::Read/Memory::Write functions.&lt;/div&gt;

+ <property name="text">

+ <string>Enable inline page tables</string>

+ </property>

+ <property name="text">

+ <string>Enable block linking</string>

+ </property>

+ <property name="text">

+ <string>Enable return stack buffer</string>

+ </property>

+ <property name="text">

+ <string>Enable fast dispatcher</string>

+ </property>

+ <property name="text">

+ <string>Enable context elimination</string>

+ </property>

+ <property name="text">

+ <string>Enable constant propagation</string>

+ </property>

+ <property name="text">

+ <string>Enable miscellaneous optimizations</string>

+ </property>

+ &lt;div style=&quot;white-space: nowrap&quot;&gt;When enabled, a misalignment is only triggered when an access crosses a page boundary.&lt;/div&gt;

+ &lt;div style=&quot;white-space: nowrap&quot;&gt;When disabled, a misalignment is triggered on all misaligned accesses.&lt;/div&gt;

+ <property name="text">

+ <string>Enable misalignment check reduction</string>

+ </property>

+ &lt;div style=&quot;white-space: nowrap&quot;&gt;This optimization speeds up memory accesses by the guest program.&lt;/div&gt;

+ &lt;div style=&quot;white-space: nowrap&quot;&gt;Enabling it causes guest memory reads/writes to be done directly into memory and make use of Host's MMU.&lt;/div&gt;

+ &lt;div style=&quot;white-space: nowrap&quot;&gt;Disabling this forces all memory accesses to use Software MMU Emulation.&lt;/div&gt;

+ <property name="text">

+ <string>Enable Host MMU Emulation</string>

+ </property>

+ ui->enable_cpu_debugging->setEnabled(runtime_lock);

+ ui->enable_cpu_debugging->setChecked(Settings::values.cpu_debug_mode.GetValue());

+ Settings::values.cpu_debug_mode = ui->enable_cpu_debugging->isChecked();

+ <height>777</height>

+ <widget class="QCheckBox" name="enable_cpu_debugging">

+ <property name="text">

+ <string>Enable CPU Debugging</string>

+ </property>

+ </widget>

+ </item>

+ <item>

+ <widget class="QCheckBox" name="use_debug_asserts">

+ <property name="text">

+ <string>Enable Debug Asserts</string>

+ </property>

+ </widget>

+ </item>

+ <item>

+ <widget class="QCheckBox" name="use_auto_stub">

+ <property name="text">

+ <string>Enable Auto-Stub</string>

+ </property>

+ </widget>

+ </item>

+ <item>

+ <widget class="QLabel" name="label_5">

+ <property name="font">

+ <font>

+ <italic>true</italic>

+ </font>

+ </property>

+ <property name="text">

+ <string>This will be reset automatically when yuzu closes.</string>

+ </property>

+ <property name="indent">

+ <number>20</number>

+ </property>

+ </widget>

+// Copyright 2021 yuzu Emulator Project

+// Licensed under GPLv2 or any later version

+// Refer to the license.txt file included.

+

+#include "ui_configure_debug_tab.h"

+#include "yuzu/configuration/configure_debug_tab.h"

+

+ConfigureDebugTab::ConfigureDebugTab(QWidget* parent)

+ : QWidget(parent), ui(new Ui::ConfigureDebugTab) {

+ ui->setupUi(this);

+

+ SetConfiguration();

+}

+

+ConfigureDebugTab::~ConfigureDebugTab() = default;

+

+void ConfigureDebugTab::ApplyConfiguration() {

+ ui->debugTab->ApplyConfiguration();

+ ui->cpuDebugTab->ApplyConfiguration();

+}

+

+void ConfigureDebugTab::SetCurrentIndex(int index) {

+ ui->tabWidget->setCurrentIndex(index);

+}

+

+void ConfigureDebugTab::changeEvent(QEvent* event) {

+ if (event->type() == QEvent::LanguageChange) {

+ RetranslateUI();

+ }

+

+ QWidget::changeEvent(event);

+}

+

+void ConfigureDebugTab::RetranslateUI() {

+ ui->retranslateUi(this);

+}

+

+void ConfigureDebugTab::SetConfiguration() {}

+// Copyright 2021 yuzu Emulator Project

+// Licensed under GPLv2 or any later version

+// Refer to the license.txt file included.

+

+#pragma once

+

+#include <memory>

+#include <QWidget>

+

+namespace Ui {

+class ConfigureDebugTab;

+}

+

+class ConfigureDebugTab : public QWidget {

+ Q_OBJECT

+

+public:

+ explicit ConfigureDebugTab(QWidget* parent = nullptr);

+ ~ConfigureDebugTab() override;

+

+ void ApplyConfiguration();

+

+ void SetCurrentIndex(int index);

+

+private:

+ void changeEvent(QEvent* event) override;

+ void RetranslateUI();

+

+ void SetConfiguration();

+

+ std::unique_ptr<Ui::ConfigureDebugTab> ui;

+};

+<?xml version="1.0" encoding="UTF-8"?>

+<ui version="4.0">

+ <class>ConfigureDebugTab</class>

+ <widget class="QWidget" name="ConfigureDebugTab">

+ <property name="geometry">

+ <rect>

+ <x>0</x>

+ <y>0</y>

+ <width>320</width>

+ <height>240</height>

+ </rect>

+ </property>

+ <property name="windowTitle">

+ <string>Form</string>

+ </property>

+ <layout class="QVBoxLayout" name="verticalLayout">

+ <item>

+ <widget class="QTabWidget" name="tabWidget">

+ <property name="currentIndex">

+ <number>1</number>

+ </property>

+ <widget class="ConfigureDebug" name="debugTab">

+ <attribute name="title">

+ <string>General</string>

+ </attribute>

+ </widget>

+ <widget class="ConfigureCpuDebug" name="cpuDebugTab">

+ <attribute name="title">

+ <string>CPU</string>

+ </attribute>

+ </widget>

+ </widget>

+ </item>

+ </layout>

+ </widget>

+ <customwidgets>

+ <customwidget>

+ <class>ConfigureDebug</class>

+ <extends>QWidget</extends>

+ <header>configuration/configure_debug.h</header>

+ <container>1</container>

+ </customwidget>

+ <customwidget>

+ <class>ConfigureCpuDebug</class>

+ <extends>QWidget</extends>

+ <header>configuration/configure_cpu_debug.h</header>

+ <container>1</container>

+ </customwidget>

+ </customwidgets>

+ <resources/>

+ <connections/>

+</ui>

+#include <QTabWidget>

+ connect(ui->tabWidget, &QTabWidget::currentChanged, this,

+ [this]() { ui->debugTab->SetCurrentIndex(0); });

+ {tr("CPU"), {ui->cpuTab}},

+ UpdateBackgroundColorButton(QColor::fromRgb(Settings::values.bg_red.GetValue(),

+ Settings::values.bg_green.GetValue(),

+ Settings::values.bg_blue.GetValue()));

+ Settings::values.bg_red.SetValue(static_cast<u8>(bg_color.red()));

+ Settings::values.bg_green.SetValue(static_cast<u8>(bg_color.green()));

+ Settings::values.bg_blue.SetValue(static_cast<u8>(bg_color.blue()));

+ Settings::values.bg_red.SetValue(static_cast<u8>(bg_color.red()));

+ Settings::values.bg_green.SetValue(static_cast<u8>(bg_color.green()));

+ Settings::values.bg_blue.SetValue(static_cast<u8>(bg_color.blue()));

+ <widget class="QSpinBox" name="mouse_panning_sensitivity">

+ <property name="suffix">

+ <string>%</string>

+ <number>1</number>

+ <number>100</number>

+ <number>100</number>

+#include "applets/qt_controller.h"

+#include "applets/qt_error.h"

+#include "applets/qt_profile_select.h"

+#include "applets/qt_software_keyboard.h"

+#include "applets/qt_web_browser.h"

+ // Disable fps limit toggle when booting a new title

+ Settings::values.disable_fps_limit.SetValue(false);

+

+ const auto instruction_set_suffix = is_64bit ? tr("(64-bit)") : tr("(32-bit)");

+ title_name = tr("%1 %2", "%1 is the title name. %2 indicates if the title is 64-bit or 32-bit")

+ .arg(QString::fromStdString(title_name), instruction_set_suffix)

+ .toStdString();

+ if (Settings::values.disable_fps_limit) {

+ game_fps_label->setText(

+ tr("Game: %1 FPS (Limit off)").arg(results.average_game_fps, 0, 'f', 0));

+ } else {

+ game_fps_label->setText(tr("Game: %1 FPS").arg(results.average_game_fps, 0, 'f', 0));

+ }

+if (YUZU_USE_EXTERNAL_SDL2)

+ target_compile_definitions(yuzu-cmd PRIVATE -DYUZU_USE_EXTERNAL_SDL2)

+ target_include_directories(yuzu-cmd PRIVATE ${PROJECT_BINARY_DIR}/externals/SDL/include)

+endif()

+

+

+

+ ReadSetting("ControlsGeneral", Settings::values.touch_device);

+

+ ReadSetting("System", Settings::values.region_index);

+ ReadSetting("System", Settings::values.sound_index);

+ // Cpu

+ ReadSetting("Cpu", Settings::values.cpu_accuracy);

+ ReadSetting("Cpu", Settings::values.cpu_debug_mode);

+ ReadSetting("Cpu", Settings::values.cpuopt_page_tables);

+ ReadSetting("Cpu", Settings::values.cpuopt_block_linking);

+ ReadSetting("Cpu", Settings::values.cpuopt_return_stack_buffer);

+ ReadSetting("Cpu", Settings::values.cpuopt_fast_dispatcher);

+ ReadSetting("Cpu", Settings::values.cpuopt_context_elimination);

+ ReadSetting("Cpu", Settings::values.cpuopt_const_prop);

+ ReadSetting("Cpu", Settings::values.cpuopt_misc_ir);

+ ReadSetting("Cpu", Settings::values.cpuopt_reduce_misalign_checks);

+ ReadSetting("Cpu", Settings::values.cpuopt_fastmem);

+ ReadSetting("Cpu", Settings::values.cpuopt_unsafe_unfuse_fma);

+ ReadSetting("Cpu", Settings::values.cpuopt_unsafe_reduce_fp_error);

+ ReadSetting("Cpu", Settings::values.cpuopt_unsafe_ignore_standard_fpcr);

+ ReadSetting("Cpu", Settings::values.cpuopt_unsafe_inaccurate_nan);

+ ReadSetting("Cpu", Settings::values.cpuopt_unsafe_fastmem_check);

+

+ ReadSetting("Renderer", Settings::values.use_caches_gc);

+# To use the debug_pad, prepend `debug_pad_` before each button setting above.

+# i.e. debug_pad_button_a=

+

+# Enable debug pad inputs to the guest

+# 0 (default): Disabled, 1: Enabled

+debug_pad_enabled =

+

+# Enables controller motion inputs

+# 0: Disabled, 1 (default): Enabled

+motion_enabled =

+

+# List of Cemuhook UDP servers, delimited by ','.

+# Default: 127.0.0.1:26760

+# Example: 127.0.0.1:26760,123.4.5.67:26761

+udp_input_servers =

+# Enable controlling an axis via a mouse input.

+# 0 (default): Off, 1: On

+mouse_panning =

+

+# Set mouse sensitivity.

+# Default: 1.0

+mouse_panning_sensitivity =

+

+# Emulate an analog control stick from keyboard inputs.

+# 0 (default): Disabled, 1: Enabled

+emulate_analog_keyboard =

+# Enable mouse inputs to the guest

+# 0 (default): Disabled, 1: Enabled

+mouse_enabled =

+# Enable keyboard inputs to the guest

+# 0 (default): Disabled, 1: Enabled

+keyboard_enabled =

+# Adjusts various optimizations.

+# Auto-select mode enables choice unsafe optimizations.

+# Accurate enables only safe optimizations.

+# Unsafe allows any unsafe optimizations.

+# 0 (default): Auto-select, 1: Accurate, 2: Enable unsafe optimizations

+cpu_accuracy =

+

+# Allow disabling safe optimizations.

+# 0 (default): Disabled, 1: Enabled

+cpu_debug_mode =

+

+# Enable unfuse FMA (improve performance on CPUs without FMA)

+# Only enabled if cpu_accuracy is set to Unsafe. Automatically chosen with cpu_accuracy = Auto-select.

+# 0: Disabled, 1 (default): Enabled

+cpuopt_unsafe_unfuse_fma =

+

+# Enable faster FRSQRTE and FRECPE

+# Only enabled if cpu_accuracy is set to Unsafe.

+# 0: Disabled, 1 (default): Enabled

+cpuopt_unsafe_reduce_fp_error =

+

+# Enable faster ASIMD instructions (32 bits only)

+# Only enabled if cpu_accuracy is set to Unsafe. Automatically chosen with cpu_accuracy = Auto-select.

+# 0: Disabled, 1 (default): Enabled

+cpuopt_unsafe_ignore_standard_fpcr =

+

+# Enable inaccurate NaN handling

+# Only enabled if cpu_accuracy is set to Unsafe. Automatically chosen with cpu_accuracy = Auto-select.

+# 0: Disabled, 1 (default): Enabled

+cpuopt_unsafe_inaccurate_nan =

+

+# Disable address space checks (64 bits only)

+# Only enabled if cpu_accuracy is set to Unsafe. Automatically chosen with cpu_accuracy = Auto-select.

+# 0: Disabled, 1 (default): Enabled

+cpuopt_unsafe_fastmem_check =

+

+# 0: Off, 1 (default): On

+# 0: Normal, 1 (default): High, 2: Extreme (Very slow)

+# Inform the guest that GPU operations completed more quickly than they did.

+use_fast_gpu_time =

+# Must be in range of 0-255. Defaults to 0 for all.

+# 100 (default): 100%, 0; mute

+region_index =

+# Sets the sound output mode.

+# 0: Mono, 1 (default): Stereo, 2: Surround

+sound_index =

+

+# Use developer keys

+# 0 (default): Disabled, 1: Enabled

+use_dev_keys =

+

+# Enables verbose reporting services

+reporting_services =

+} // namespace DefaultINI

+#ifdef YUZU_USE_EXTERNAL_SDL2

+// Include this before SDL.h to prevent the external from including a dummy

+#define USING_GENERATED_CONFIG_H

+#include <SDL_config.h>

+

+#else

+ case SDL_SYSWM_TYPE::SDL_SYSWM_WINDOWS:

+ LOG_CRITICAL(Frontend, "Window manager subsystem Windows not compiled");

+ std::exit(EXIT_FAILURE);

+ break;

+#else

+ case SDL_SYSWM_TYPE::SDL_SYSWM_X11:

+ LOG_CRITICAL(Frontend, "Window manager subsystem X11 not compiled");

+ std::exit(EXIT_FAILURE);

+ break;

+#else

+ case SDL_SYSWM_TYPE::SDL_SYSWM_WAYLAND:

+ LOG_CRITICAL(Frontend, "Window manager subsystem Wayland not compiled");

+ std::exit(EXIT_FAILURE);

+ break;