Buffer Cache: Address Feedback.

core,common,yuzu qt: Add CPU accuracy option 'Auto'

src/CMakeLists.txt

@@ -82,6 +82,7 @@ else()
         -Werror=missing-declarations
         -Werror=missing-field-initializers
         -Werror=reorder
+        -Werror=sign-compare
         -Werror=switch
         -Werror=uninitialized
         -Werror=unused-function

src/audio_core/CMakeLists.txt

@@ -51,9 +51,6 @@ if (NOT MSVC)
     target_compile_options(audio_core PRIVATE
         -Werror=conversion
         -Werror=ignored-qualifiers
-        -Werror=implicit-fallthrough
-        -Werror=reorder
-        -Werror=sign-compare
         -Werror=shadow
         -Werror=unused-parameter
         -Werror=unused-variable

src/audio_core/audio_out.cpp

@@ -30,7 +30,8 @@ StreamPtr AudioOut::OpenStream(Core::Timing::CoreTiming& core_timing, u32 sample
                                u32 num_channels, std::string&& name,
                                Stream::ReleaseCallback&& release_callback) {
     if (!sink) {
-        sink = CreateSinkFromID(Settings::values.sink_id, Settings::values.audio_device_id);
+        sink = CreateSinkFromID(Settings::values.sink_id.GetValue(),
+                                Settings::values.audio_device_id.GetValue());
     }
 
     return std::make_shared<Stream>(

src/audio_core/audio_renderer.cpp

@@ -29,10 +29,9 @@ namespace {
                                        (static_cast<float>(r_channel) * r_mix_amount)));
 }
 
-[[nodiscard]] static constexpr std::tuple<s16, s16> Mix6To2(s16 fl_channel, s16 fr_channel,
-                                                            s16 fc_channel,
-                                                            [[maybe_unused]] s16 lf_channel,
-                                                            s16 bl_channel, s16 br_channel) {
+[[maybe_unused, nodiscard]] static constexpr std::tuple<s16, s16> Mix6To2(
+    s16 fl_channel, s16 fr_channel, s16 fc_channel, [[maybe_unused]] s16 lf_channel, s16 bl_channel,
+    s16 br_channel) {
     // Front channels are mixed 36.94%, Center channels are mixed to be 26.12% & the back channels
     // are mixed to be 36.94%
 
@@ -57,11 +56,11 @@ namespace {
     const std::array<float_le, 4>& coeff) {
     const auto left =
         static_cast<float>(fl_channel) * coeff[0] + static_cast<float>(fc_channel) * coeff[1] +
-        static_cast<float>(lf_channel) * coeff[2] + static_cast<float>(bl_channel) * coeff[0];
+        static_cast<float>(lf_channel) * coeff[2] + static_cast<float>(bl_channel) * coeff[3];
 
     const auto right =
         static_cast<float>(fr_channel) * coeff[0] + static_cast<float>(fc_channel) * coeff[1] +
-        static_cast<float>(lf_channel) * coeff[2] + static_cast<float>(br_channel) * coeff[0];
+        static_cast<float>(lf_channel) * coeff[2] + static_cast<float>(br_channel) * coeff[3];
 
     return {ClampToS16(static_cast<s32>(left)), ClampToS16(static_cast<s32>(right))};
 }
@@ -241,7 +240,7 @@ void AudioRenderer::QueueMixedBuffer(Buffer::Tag tag) {
         const auto channel_count = buffer_offsets.size();
         const auto& final_mix = mix_context.GetFinalMixInfo();
         const auto& in_params = final_mix.GetInParams();
-        std::vector<s32*> mix_buffers(channel_count);
+        std::vector<std::span<s32>> mix_buffers(channel_count);
         for (std::size_t i = 0; i < channel_count; i++) {
             mix_buffers[i] =
                 command_generator.GetMixBuffer(in_params.buffer_offset + buffer_offsets[i]);
@@ -294,18 +293,11 @@ void AudioRenderer::QueueMixedBuffer(Buffer::Tag tag) {
                     buffer[i * stream_channel_count + 0] = Mix2To1(fl_sample, fr_sample);
                 } else if (stream_channel_count == 2) {
                     // Mix all channels into 2 channels
-                    if (sink_context.HasDownMixingCoefficients()) {
-                        const auto [left, right] = Mix6To2WithCoefficients(
-                            fl_sample, fr_sample, fc_sample, lf_sample, bl_sample, br_sample,
-                            sink_context.GetDownmixCoefficients());
-                        buffer[i * stream_channel_count + 0] = left;
-                        buffer[i * stream_channel_count + 1] = right;
-                    } else {
-                        const auto [left, right] = Mix6To2(fl_sample, fr_sample, fc_sample,
-                                                           lf_sample, bl_sample, br_sample);
-                        buffer[i * stream_channel_count + 0] = left;
-                        buffer[i * stream_channel_count + 1] = right;
-                    }
+                    const auto [left, right] = Mix6To2WithCoefficients(
+                        fl_sample, fr_sample, fc_sample, lf_sample, bl_sample, br_sample,
+                        sink_context.GetDownmixCoefficients());
+                    buffer[i * stream_channel_count + 0] = left;
+                    buffer[i * stream_channel_count + 1] = right;
                 } else if (stream_channel_count == 6) {
                     // Pass through
                     buffer[i * stream_channel_count + 0] = fl_sample;

src/audio_core/command_generator.cpp

@@ -31,7 +31,7 @@ constexpr std::array<f32, AudioCommon::I3DL2REVERB_TAPS> EARLY_GAIN{
     0.72867f, 0.69794f, 0.5464f,  0.24563f, 0.45214f, 0.44042f};
 
 template <std::size_t N>
-void ApplyMix(s32* output, const s32* input, s32 gain, s32 sample_count) {
+void ApplyMix(std::span<s32> output, std::span<const s32> input, s32 gain, s32 sample_count) {
     for (std::size_t i = 0; i < static_cast<std::size_t>(sample_count); i += N) {
         for (std::size_t j = 0; j < N; j++) {
             output[i + j] +=
@@ -40,7 +40,8 @@ void ApplyMix(s32* output, const s32* input, s32 gain, s32 sample_count) {
     }
 }
 
-s32 ApplyMixRamp(s32* output, const s32* input, float gain, float delta, s32 sample_count) {
+s32 ApplyMixRamp(std::span<s32> output, std::span<const s32> input, float gain, float delta,
+                 s32 sample_count) {
     s32 x = 0;
     for (s32 i = 0; i < sample_count; i++) {
         x = static_cast<s32>(static_cast<float>(input[i]) * gain);
@@ -50,20 +51,22 @@ s32 ApplyMixRamp(s32* output, const s32* input, float gain, float delta, s32 sam
     return x;
 }
 
-void ApplyGain(s32* output, const s32* input, s32 gain, s32 delta, s32 sample_count) {
+void ApplyGain(std::span<s32> output, std::span<const s32> input, s32 gain, s32 delta,
+               s32 sample_count) {
     for (s32 i = 0; i < sample_count; i++) {
         output[i] = static_cast<s32>((static_cast<s64>(input[i]) * gain + 0x4000) >> 15);
         gain += delta;
     }
 }
 
-void ApplyGainWithoutDelta(s32* output, const s32* input, s32 gain, s32 sample_count) {
+void ApplyGainWithoutDelta(std::span<s32> output, std::span<const s32> input, s32 gain,
+                           s32 sample_count) {
     for (s32 i = 0; i < sample_count; i++) {
         output[i] = static_cast<s32>((static_cast<s64>(input[i]) * gain + 0x4000) >> 15);
     }
 }
 
-s32 ApplyMixDepop(s32* output, s32 first_sample, s32 delta, s32 sample_count) {
+s32 ApplyMixDepop(std::span<s32> output, s32 first_sample, s32 delta, s32 sample_count) {
     const bool positive = first_sample > 0;
     auto final_sample = std::abs(first_sample);
     for (s32 i = 0; i < sample_count; i++) {
@@ -128,10 +131,10 @@ constexpr std::array<std::size_t, 20> REVERB_TAP_INDEX_6CH{4, 0, 0, 1, 1, 1, 1,
                                                            1, 1, 1, 0, 0, 0, 0, 3, 3, 3};
 
 template <std::size_t CHANNEL_COUNT>
-void ApplyReverbGeneric(I3dl2ReverbState& state,
-                        const std::array<const s32*, AudioCommon::MAX_CHANNEL_COUNT>& input,
-                        const std::array<s32*, AudioCommon::MAX_CHANNEL_COUNT>& output,
-                        s32 sample_count) {
+void ApplyReverbGeneric(
+    I3dl2ReverbState& state,
+    const std::array<std::span<const s32>, AudioCommon::MAX_CHANNEL_COUNT>& input,
+    const std::array<std::span<s32>, AudioCommon::MAX_CHANNEL_COUNT>& output, s32 sample_count) {
 
     auto GetTapLookup = []() {
         if constexpr (CHANNEL_COUNT == 1) {
@@ -400,7 +403,10 @@ void CommandGenerator::GenerateDataSourceCommand(ServerVoiceInfo& voice_info, Vo
         }
     } else {
         switch (in_params.sample_format) {
+        case SampleFormat::Pcm8:
         case SampleFormat::Pcm16:
+        case SampleFormat::Pcm32:
+        case SampleFormat::PcmFloat:
             DecodeFromWaveBuffers(voice_info, GetChannelMixBuffer(channel), dsp_state, channel,
                                   worker_params.sample_rate, worker_params.sample_count,
                                   in_params.node_id);
@@ -454,8 +460,8 @@ void CommandGenerator::GenerateBiquadFilterCommand([[maybe_unused]] s32 mix_buff
                   "input_mix_buffer={}, output_mix_buffer={}",
                   node_id, input_offset, output_offset);
     }
-    const auto* input = GetMixBuffer(input_offset);
-    auto* output = GetMixBuffer(output_offset);
+    std::span<const s32> input = GetMixBuffer(input_offset);
+    std::span<s32> output = GetMixBuffer(output_offset);
 
     // Biquad filter parameters
     const auto [n0, n1, n2] = params.numerator;
@@ -548,8 +554,8 @@ void CommandGenerator::GenerateI3dl2ReverbEffectCommand(s32 mix_buffer_offset, E
         return;
     }
 
-    std::array<const s32*, AudioCommon::MAX_CHANNEL_COUNT> input{};
-    std::array<s32*, AudioCommon::MAX_CHANNEL_COUNT> output{};
+    std::array<std::span<const s32>, AudioCommon::MAX_CHANNEL_COUNT> input{};
+    std::array<std::span<s32>, AudioCommon::MAX_CHANNEL_COUNT> output{};
 
     const auto status = params.status;
     for (s32 i = 0; i < channel_count; i++) {
@@ -584,7 +590,8 @@ void CommandGenerator::GenerateI3dl2ReverbEffectCommand(s32 mix_buffer_offset, E
         for (s32 i = 0; i < channel_count; i++) {
             // Only copy if the buffer input and output do not match!
             if ((mix_buffer_offset + params.input[i]) != (mix_buffer_offset + params.output[i])) {
-                std::memcpy(output[i], input[i], worker_params.sample_count * sizeof(s32));
+                std::memcpy(output[i].data(), input[i].data(),
+                            worker_params.sample_count * sizeof(s32));
             }
         }
     }
@@ -600,8 +607,8 @@ void CommandGenerator::GenerateBiquadFilterEffectCommand(s32 mix_buffer_offset,
     for (s32 i = 0; i < channel_count; i++) {
         // TODO(ogniK): Actually implement biquad filter
         if (params.input[i] != params.output[i]) {
-            const auto* input = GetMixBuffer(mix_buffer_offset + params.input[i]);
-            auto* output = GetMixBuffer(mix_buffer_offset + params.output[i]);
+            std::span<const s32> input = GetMixBuffer(mix_buffer_offset + params.input[i]);
+            std::span<s32> output = GetMixBuffer(mix_buffer_offset + params.output[i]);
             ApplyMix<1>(output, input, 32768, worker_params.sample_count);
         }
     }
@@ -640,14 +647,15 @@ void CommandGenerator::GenerateAuxCommand(s32 mix_buffer_offset, EffectBase* inf
 
                 if (samples_read != static_cast<int>(worker_params.sample_count) &&
                     samples_read <= params.sample_count) {
-                    std::memset(GetMixBuffer(output_index), 0, params.sample_count - samples_read);
+                    std::memset(GetMixBuffer(output_index).data(), 0,
+                                params.sample_count - samples_read);
                 }
             } else {
                 AuxInfoDSP empty{};
                 memory.WriteBlock(aux->GetSendInfo(), &empty, sizeof(AuxInfoDSP));
                 memory.WriteBlock(aux->GetRecvInfo(), &empty, sizeof(AuxInfoDSP));
                 if (output_index != input_index) {
-                    std::memcpy(GetMixBuffer(output_index), GetMixBuffer(input_index),
+                    std::memcpy(GetMixBuffer(output_index).data(), GetMixBuffer(input_index).data(),
                                 worker_params.sample_count * sizeof(s32));
                 }
             }
@@ -665,7 +673,7 @@ ServerSplitterDestinationData* CommandGenerator::GetDestinationData(s32 splitter
 }
 
 s32 CommandGenerator::WriteAuxBuffer(AuxInfoDSP& dsp_info, VAddr send_buffer, u32 max_samples,
-                                     const s32* data, u32 sample_count, u32 write_offset,
+                                     std::span<const s32> data, u32 sample_count, u32 write_offset,
                                      u32 write_count) {
     if (max_samples == 0) {
         return 0;
@@ -675,14 +683,14 @@ s32 CommandGenerator::WriteAuxBuffer(AuxInfoDSP& dsp_info, VAddr send_buffer, u3
         return 0;
     }
 
-    std::size_t data_offset{};
+    s32 data_offset{};
     u32 remaining = sample_count;
     while (remaining > 0) {
         // Get position in buffer
         const auto base = send_buffer + (offset * sizeof(u32));
         const auto samples_to_grab = std::min(max_samples - offset, remaining);
         // Write to output
-        memory.WriteBlock(base, (data + data_offset), samples_to_grab * sizeof(u32));
+        memory.WriteBlock(base, (data.data() + data_offset), samples_to_grab * sizeof(u32));
         offset = (offset + samples_to_grab) % max_samples;
         remaining -= samples_to_grab;
         data_offset += samples_to_grab;
@@ -695,7 +703,7 @@ s32 CommandGenerator::WriteAuxBuffer(AuxInfoDSP& dsp_info, VAddr send_buffer, u3
 }
 
 s32 CommandGenerator::ReadAuxBuffer(AuxInfoDSP& recv_info, VAddr recv_buffer, u32 max_samples,
-                                    s32* out_data, u32 sample_count, u32 read_offset,
+                                    std::span<s32> out_data, u32 sample_count, u32 read_offset,
                                     u32 read_count) {
     if (max_samples == 0) {
         return 0;
@@ -707,15 +715,16 @@ s32 CommandGenerator::ReadAuxBuffer(AuxInfoDSP& recv_info, VAddr recv_buffer, u3
     }
 
     u32 remaining = sample_count;
+    s32 data_offset{};
     while (remaining > 0) {
         const auto base = recv_buffer + (offset * sizeof(u32));
         const auto samples_to_grab = std::min(max_samples - offset, remaining);
         std::vector<s32> buffer(samples_to_grab);
         memory.ReadBlock(base, buffer.data(), buffer.size() * sizeof(u32));
-        std::memcpy(out_data, buffer.data(), buffer.size() * sizeof(u32));
-        out_data += samples_to_grab;
+        std::memcpy(out_data.data() + data_offset, buffer.data(), buffer.size() * sizeof(u32));
         offset = (offset + samples_to_grab) % max_samples;
         remaining -= samples_to_grab;
+        data_offset += samples_to_grab;
     }
 
     if (read_count != 0) {
@@ -962,8 +971,8 @@ void CommandGenerator::GenerateMixCommand(std::size_t output_offset, std::size_t
                   node_id, input_offset, output_offset, volume);
     }
 
-    auto* output = GetMixBuffer(output_offset);
-    const auto* input = GetMixBuffer(input_offset);
+    std::span<s32> output = GetMixBuffer(output_offset);
+    std::span<const s32> input = GetMixBuffer(input_offset);
 
     const s32 gain = static_cast<s32>(volume * 32768.0f);
     // Mix with loop unrolling
@@ -1003,9 +1012,10 @@ void CommandGenerator::GenerateFinalMixCommand() {
     }
 }
 
-s32 CommandGenerator::DecodePcm16(ServerVoiceInfo& voice_info, VoiceState& dsp_state,
-                                  s32 sample_start_offset, s32 sample_end_offset, s32 sample_count,
-                                  s32 channel, std::size_t mix_offset) {
+template <typename T>
+s32 CommandGenerator::DecodePcm(ServerVoiceInfo& voice_info, VoiceState& dsp_state,
+                                s32 sample_start_offset, s32 sample_end_offset, s32 sample_count,
+                                s32 channel, std::size_t mix_offset) {
     const auto& in_params = voice_info.GetInParams();
     const auto& wave_buffer = in_params.wave_buffer[dsp_state.wave_buffer_index];
     if (wave_buffer.buffer_address == 0) {
@@ -1019,24 +1029,37 @@ s32 CommandGenerator::DecodePcm16(ServerVoiceInfo& voice_info, VoiceState& dsp_s
     }
     const auto samples_remaining = (sample_end_offset - sample_start_offset) - dsp_state.offset;
     const auto start_offset =
-        ((dsp_state.offset + sample_start_offset) * in_params.channel_count) * sizeof(s16);
+        ((dsp_state.offset + sample_start_offset) * in_params.channel_count) * sizeof(T);
     const auto buffer_pos = wave_buffer.buffer_address + start_offset;
     const auto samples_processed = std::min(sample_count, samples_remaining);
 
-    if (in_params.channel_count == 1) {
-        std::vector<s16> buffer(samples_processed);
-        memory.ReadBlock(buffer_pos, buffer.data(), buffer.size() * sizeof(s16));
-        for (std::size_t i = 0; i < buffer.size(); i++) {
-            sample_buffer[mix_offset + i] = buffer[i];
-        }
-    } else {
-        const auto channel_count = in_params.channel_count;
-        std::vector<s16> buffer(samples_processed * channel_count);
-        memory.ReadBlock(buffer_pos, buffer.data(), buffer.size() * sizeof(s16));
+    const auto channel_count = in_params.channel_count;
+    std::vector<T> buffer(samples_processed * channel_count);
+    memory.ReadBlock(buffer_pos, buffer.data(), buffer.size() * sizeof(T));
 
+    if constexpr (std::is_floating_point_v<T>) {
+        for (std::size_t i = 0; i < static_cast<std::size_t>(samples_processed); i++) {
+            sample_buffer[mix_offset + i] = static_cast<s32>(buffer[i * channel_count + channel] *
+                                                             std::numeric_limits<s16>::max());
+        }
+    } else if constexpr (sizeof(T) == 1) {
+        for (std::size_t i = 0; i < static_cast<std::size_t>(samples_processed); i++) {
+            sample_buffer[mix_offset + i] =
+                static_cast<s32>(static_cast<f32>(buffer[i * channel_count + channel] /
+                                                  std::numeric_limits<s8>::max()) *
+                                 std::numeric_limits<s16>::max());
+        }
+    } else if constexpr (sizeof(T) == 2) {
         for (std::size_t i = 0; i < static_cast<std::size_t>(samples_processed); i++) {
             sample_buffer[mix_offset + i] = buffer[i * channel_count + channel];
         }
+    } else {
+        for (std::size_t i = 0; i < static_cast<std::size_t>(samples_processed); i++) {
+            sample_buffer[mix_offset + i] =
+                static_cast<s32>(static_cast<f32>(buffer[i * channel_count + channel] /
+                                                  std::numeric_limits<s32>::max()) *
+                                 std::numeric_limits<s16>::max());
+        }
     }
 
     return samples_processed;
@@ -1155,12 +1178,14 @@ s32 CommandGenerator::DecodeAdpcm(ServerVoiceInfo& voice_info, VoiceState& dsp_s
     return samples_processed;
 }
 
-s32* CommandGenerator::GetMixBuffer(std::size_t index) {
-    return mix_buffer.data() + (index * worker_params.sample_count);
+std::span<s32> CommandGenerator::GetMixBuffer(std::size_t index) {
+    return std::span<s32>(mix_buffer.data() + (index * worker_params.sample_count),
+                          worker_params.sample_count);
 }
 
-const s32* CommandGenerator::GetMixBuffer(std::size_t index) const {
-    return mix_buffer.data() + (index * worker_params.sample_count);
+std::span<const s32> CommandGenerator::GetMixBuffer(std::size_t index) const {
+    return std::span<const s32>(mix_buffer.data() + (index * worker_params.sample_count),
+                                worker_params.sample_count);
 }
 
 std::size_t CommandGenerator::GetMixChannelBufferOffset(s32 channel) const {
@@ -1171,15 +1196,15 @@ std::size_t CommandGenerator::GetTotalMixBufferCount() const {
     return worker_params.mix_buffer_count + AudioCommon::MAX_CHANNEL_COUNT;
 }
 
-s32* CommandGenerator::GetChannelMixBuffer(s32 channel) {
+std::span<s32> CommandGenerator::GetChannelMixBuffer(s32 channel) {
     return GetMixBuffer(worker_params.mix_buffer_count + channel);
 }
 
-const s32* CommandGenerator::GetChannelMixBuffer(s32 channel) const {
+std::span<const s32> CommandGenerator::GetChannelMixBuffer(s32 channel) const {
     return GetMixBuffer(worker_params.mix_buffer_count + channel);
 }
 
-void CommandGenerator::DecodeFromWaveBuffers(ServerVoiceInfo& voice_info, s32* output,
+void CommandGenerator::DecodeFromWaveBuffers(ServerVoiceInfo& voice_info, std::span<s32> output,
                                              VoiceState& dsp_state, s32 channel,
                                              s32 target_sample_rate, s32 sample_count,
                                              s32 node_id) {
@@ -1191,7 +1216,7 @@ void CommandGenerator::DecodeFromWaveBuffers(ServerVoiceInfo& voice_info, s32* o
                   node_id, channel, in_params.sample_format, sample_count, in_params.sample_rate,
                   in_params.mix_id, in_params.splitter_info_id);
     }
-    ASSERT_OR_EXECUTE(output != nullptr, { return; });
+    ASSERT_OR_EXECUTE(output.data() != nullptr, { return; });
 
     const auto resample_rate = static_cast<s32>(
         static_cast<float>(in_params.sample_rate) / static_cast<float>(target_sample_rate) *
@@ -1208,6 +1233,7 @@ void CommandGenerator::DecodeFromWaveBuffers(ServerVoiceInfo& voice_info, s32* o
     }
 
     std::size_t temp_mix_offset{};
+    s32 samples_output{};
     auto samples_remaining = sample_count;
     while (samples_remaining > 0) {
         const auto samples_to_output = std::min(samples_remaining, min_required_samples);
@@ -1249,10 +1275,25 @@ void CommandGenerator::DecodeFromWaveBuffers(ServerVoiceInfo& voice_info, s32* o
 
             s32 samples_decoded{0};
             switch (in_params.sample_format) {
+            case SampleFormat::Pcm8:
+                samples_decoded =
+                    DecodePcm<s8>(voice_info, dsp_state, samples_offset_start, samples_offset_end,
+                                  samples_to_read - samples_read, channel, temp_mix_offset);
+                break;
             case SampleFormat::Pcm16:
                 samples_decoded =
-                    DecodePcm16(voice_info, dsp_state, samples_offset_start, samples_offset_end,
-                                samples_to_read - samples_read, channel, temp_mix_offset);
+                    DecodePcm<s16>(voice_info, dsp_state, samples_offset_start, samples_offset_end,
+                                   samples_to_read - samples_read, channel, temp_mix_offset);
+                break;
+            case SampleFormat::Pcm32:
+                samples_decoded =
+                    DecodePcm<s32>(voice_info, dsp_state, samples_offset_start, samples_offset_end,
+                                   samples_to_read - samples_read, channel, temp_mix_offset);
+                break;
+            case SampleFormat::PcmFloat:
+                samples_decoded =
+                    DecodePcm<f32>(voice_info, dsp_state, samples_offset_start, samples_offset_end,
+                                   samples_to_read - samples_read, channel, temp_mix_offset);
                 break;
             case SampleFormat::Adpcm:
                 samples_decoded =
@@ -1296,20 +1337,21 @@ void CommandGenerator::DecodeFromWaveBuffers(ServerVoiceInfo& voice_info, s32* o
 
         if (in_params.behavior_flags.is_pitch_and_src_skipped.Value()) {
             // No need to resample
-            std::memcpy(output, sample_buffer.data(), samples_read * sizeof(s32));
+            std::memcpy(output.data() + samples_output, sample_buffer.data(),
+                        samples_read * sizeof(s32));
         } else {
             std::fill(sample_buffer.begin() + temp_mix_offset,
                       sample_buffer.begin() + temp_mix_offset + (samples_to_read - samples_read),
                       0);
-            AudioCore::Resample(output, sample_buffer.data(), resample_rate, dsp_state.fraction,
-                                samples_to_output);
+            AudioCore::Resample(output.data() + samples_output, sample_buffer.data(), resample_rate,
+                                dsp_state.fraction, samples_to_output);
             // Resample
             for (std::size_t i = 0; i < AudioCommon::MAX_SAMPLE_HISTORY; i++) {
                 dsp_state.sample_history[i] = sample_buffer[samples_to_read + i];
             }
         }
-        output += samples_to_output;
         samples_remaining -= samples_to_output;
+        samples_output += samples_to_output;
     }
 }
 

src/audio_core/command_generator.h

@@ -5,6 +5,7 @@
 #pragma once
 
 #include <array>
+#include <span>
 #include "audio_core/common.h"
 #include "audio_core/voice_context.h"
 #include "common/common_types.h"
@@ -41,10 +42,10 @@ public:
     void PreCommand();
     void PostCommand();
 
-    [[nodiscard]] s32* GetChannelMixBuffer(s32 channel);
-    [[nodiscard]] const s32* GetChannelMixBuffer(s32 channel) const;
-    [[nodiscard]] s32* GetMixBuffer(std::size_t index);
-    [[nodiscard]] const s32* GetMixBuffer(std::size_t index) const;
+    [[nodiscard]] std::span<s32> GetChannelMixBuffer(s32 channel);
+    [[nodiscard]] std::span<const s32> GetChannelMixBuffer(s32 channel) const;
+    [[nodiscard]] std::span<s32> GetMixBuffer(std::size_t index);
+    [[nodiscard]] std::span<const s32> GetMixBuffer(std::size_t index) const;
     [[nodiscard]] std::size_t GetMixChannelBufferOffset(s32 channel) const;
 
     [[nodiscard]] std::size_t GetTotalMixBufferCount() const;
@@ -77,21 +78,24 @@ private:
     void GenerateAuxCommand(s32 mix_buffer_offset, EffectBase* info, bool enabled);
     [[nodiscard]] ServerSplitterDestinationData* GetDestinationData(s32 splitter_id, s32 index);
 
-    s32 WriteAuxBuffer(AuxInfoDSP& dsp_info, VAddr send_buffer, u32 max_samples, const s32* data,
-                       u32 sample_count, u32 write_offset, u32 write_count);
-    s32 ReadAuxBuffer(AuxInfoDSP& recv_info, VAddr recv_buffer, u32 max_samples, s32* out_data,
-                      u32 sample_count, u32 read_offset, u32 read_count);
+    s32 WriteAuxBuffer(AuxInfoDSP& dsp_info, VAddr send_buffer, u32 max_samples,
+                       std::span<const s32> data, u32 sample_count, u32 write_offset,
+                       u32 write_count);
+    s32 ReadAuxBuffer(AuxInfoDSP& recv_info, VAddr recv_buffer, u32 max_samples,
+                      std::span<s32> out_data, u32 sample_count, u32 read_offset, u32 read_count);
 
     void InitializeI3dl2Reverb(I3dl2ReverbParams& info, I3dl2ReverbState& state,
                                std::vector<u8>& work_buffer);
     void UpdateI3dl2Reverb(I3dl2ReverbParams& info, I3dl2ReverbState& state, bool should_clear);
     // DSP Code
-    s32 DecodePcm16(ServerVoiceInfo& voice_info, VoiceState& dsp_state, s32 sample_start_offset,
-                    s32 sample_end_offset, s32 sample_count, s32 channel, std::size_t mix_offset);
+    template <typename T>
+    s32 DecodePcm(ServerVoiceInfo& voice_info, VoiceState& dsp_state, s32 sample_start_offset,
+                  s32 sample_end_offset, s32 sample_count, s32 channel, std::size_t mix_offset);
     s32 DecodeAdpcm(ServerVoiceInfo& voice_info, VoiceState& dsp_state, s32 sample_start_offset,
                     s32 sample_end_offset, s32 sample_count, s32 channel, std::size_t mix_offset);
-    void DecodeFromWaveBuffers(ServerVoiceInfo& voice_info, s32* output, VoiceState& dsp_state,
-                               s32 channel, s32 target_sample_rate, s32 sample_count, s32 node_id);
+    void DecodeFromWaveBuffers(ServerVoiceInfo& voice_info, std::span<s32> output,
+                               VoiceState& dsp_state, s32 channel, s32 target_sample_rate,
+                               s32 sample_count, s32 node_id);
 
     AudioCommon::AudioRendererParameter& worker_params;
     VoiceContext& voice_context;

src/audio_core/sink_context.cpp

@@ -15,10 +15,17 @@ std::size_t SinkContext::GetCount() const {
 void SinkContext::UpdateMainSink(const SinkInfo::InParams& in) {
     ASSERT(in.type == SinkTypes::Device);
 
-    has_downmix_coefs = in.device.down_matrix_enabled;
-    if (has_downmix_coefs) {
+    if (in.device.down_matrix_enabled) {
         downmix_coefficients = in.device.down_matrix_coef;
+    } else {
+        downmix_coefficients = {
+            1.0f,   // front
+            0.707f, // center
+            0.0f,   // lfe
+            0.707f, // back
+        };
     }
+
     in_use = in.in_use;
     use_count = in.device.input_count;
     buffers = in.device.input;
@@ -34,10 +41,6 @@ std::vector<u8> SinkContext::OutputBuffers() const {
     return buffer_ret;
 }
 
-bool SinkContext::HasDownMixingCoefficients() const {
-    return has_downmix_coefs;
-}
-
 const DownmixCoefficients& SinkContext::GetDownmixCoefficients() const {
     return downmix_coefficients;
 }

src/audio_core/sink_context.h

@@ -84,7 +84,6 @@ public:
     [[nodiscard]] bool InUse() const;
     [[nodiscard]] std::vector<u8> OutputBuffers() const;
 
-    [[nodiscard]] bool HasDownMixingCoefficients() const;
     [[nodiscard]] const DownmixCoefficients& GetDownmixCoefficients() const;
 
 private:
@@ -92,7 +91,6 @@ private:
     s32 use_count{};
     std::array<u8, AudioCommon::MAX_CHANNEL_COUNT> buffers{};
     std::size_t sink_count{};
-    bool has_downmix_coefs{false};
     DownmixCoefficients downmix_coefficients{};
 };
 } // namespace AudioCore

src/common/CMakeLists.txt

@@ -180,7 +180,6 @@ add_library(common STATIC
     thread.cpp
     thread.h
     thread_queue_list.h
-    thread_worker.cpp
     thread_worker.h
     threadsafe_queue.h
     time_zone.cpp
@@ -188,6 +187,7 @@ add_library(common STATIC
     tiny_mt.h
     tree.h
     uint128.h
+    unique_function.h
     uuid.cpp
     uuid.h
     vector_math.h

src/common/fs/file.cpp

@@ -306,9 +306,9 @@ bool IOFile::Flush() const {
     errno = 0;
 
 #ifdef _WIN32
-    const auto flush_result = std::fflush(file) == 0 && _commit(fileno(file)) == 0;
+    const auto flush_result = std::fflush(file) == 0;
 #else
-    const auto flush_result = std::fflush(file) == 0 && fsync(fileno(file)) == 0;
+    const auto flush_result = std::fflush(file) == 0;
 #endif
 
     if (!flush_result) {
@@ -320,6 +320,28 @@ bool IOFile::Flush() const {
     return flush_result;
 }
 
+bool IOFile::Commit() const {
+    if (!IsOpen()) {
+        return false;
+    }
+
+    errno = 0;
+
+#ifdef _WIN32
+    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;
+#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());
+    }
+
+    return commit_result;
+}
+
 bool IOFile::SetSize(u64 size) const {
     if (!IsOpen()) {
         return false;
@@ -347,6 +369,9 @@ u64 IOFile::GetSize() const {
         return 0;
     }
 
+    // Flush any unwritten buffered data into the file prior to retrieving the file size.
+    std::fflush(file);
+
     std::error_code ec;
 
     const auto file_size = fs::file_size(file_path, ec);

src/common/fs/file.h

@@ -396,12 +396,21 @@ public:
     [[nodiscard]] size_t WriteString(std::span<const char> string) const;
 
     /**
-     * Attempts to flush any unwritten buffered data into the file and flush the file into the disk.
+     * 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.
+     */
+    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.

src/common/logging/backend.cpp

@@ -171,19 +171,22 @@ FileBackend::FileBackend(const std::filesystem::path& filename) {
 FileBackend::~FileBackend() = default;
 
 void FileBackend::Write(const Entry& entry) {
-    using namespace Common::Literals;
-    // prevent logs from going over the maximum size (in case its spamming and the user doesn't
-    // know)
-    constexpr std::size_t MAX_BYTES_WRITTEN = 100_MiB;
-    constexpr std::size_t MAX_BYTES_WRITTEN_EXTENDED = 1_GiB;
-
     if (!file->IsOpen()) {
         return;
     }
 
-    if (Settings::values.extended_logging && bytes_written > MAX_BYTES_WRITTEN_EXTENDED) {
-        return;
-    } else if (!Settings::values.extended_logging && bytes_written > MAX_BYTES_WRITTEN) {
+    using namespace Common::Literals;
+    // Prevent logs from exceeding a set maximum size in the event that log entries are spammed.
+    constexpr std::size_t MAX_BYTES_WRITTEN = 100_MiB;
+    constexpr std::size_t MAX_BYTES_WRITTEN_EXTENDED = 1_GiB;
+
+    const bool write_limit_exceeded =
+        bytes_written > MAX_BYTES_WRITTEN_EXTENDED ||
+        (bytes_written > MAX_BYTES_WRITTEN && !Settings::values.extended_logging);
+
+    // Close the file after the write limit is exceeded.
+    if (write_limit_exceeded) {
+        file->Close();
         return;
     }
 

src/common/settings.cpp

@@ -41,7 +41,7 @@ void LogSettings() {
     LOG_INFO(Config, "yuzu Configuration:");
     log_setting("Controls_UseDockedMode", values.use_docked_mode.GetValue());
     log_setting("System_RngSeed", values.rng_seed.GetValue().value_or(0));
-    log_setting("System_CurrentUser", values.current_user);
+    log_setting("System_CurrentUser", values.current_user.GetValue());
     log_setting("System_LanguageIndex", values.language_index.GetValue());
     log_setting("System_RegionIndex", values.region_index.GetValue());
     log_setting("System_TimeZoneIndex", values.time_zone_index.GetValue());
@@ -61,18 +61,18 @@ void LogSettings() {
     log_setting("Renderer_UseAsynchronousShaders", values.use_asynchronous_shaders.GetValue());
     log_setting("Renderer_UseGarbageCollection", values.use_caches_gc.GetValue());
     log_setting("Renderer_AnisotropicFilteringLevel", values.max_anisotropy.GetValue());
-    log_setting("Audio_OutputEngine", values.sink_id);
+    log_setting("Audio_OutputEngine", values.sink_id.GetValue());
     log_setting("Audio_EnableAudioStretching", values.enable_audio_stretching.GetValue());
-    log_setting("Audio_OutputDevice", values.audio_device_id);
-    log_setting("DataStorage_UseVirtualSd", values.use_virtual_sd);
+    log_setting("Audio_OutputDevice", values.audio_device_id.GetValue());
+    log_setting("DataStorage_UseVirtualSd", values.use_virtual_sd.GetValue());
     log_path("DataStorage_CacheDir", Common::FS::GetYuzuPath(Common::FS::YuzuPath::CacheDir));
     log_path("DataStorage_ConfigDir", Common::FS::GetYuzuPath(Common::FS::YuzuPath::ConfigDir));
     log_path("DataStorage_LoadDir", Common::FS::GetYuzuPath(Common::FS::YuzuPath::LoadDir));
     log_path("DataStorage_NANDDir", Common::FS::GetYuzuPath(Common::FS::YuzuPath::NANDDir));
     log_path("DataStorage_SDMCDir", Common::FS::GetYuzuPath(Common::FS::YuzuPath::SDMCDir));
-    log_setting("Debugging_ProgramArgs", values.program_args);
-    log_setting("Services_BCATBackend", values.bcat_backend);
-    log_setting("Services_BCATBoxcatLocal", values.bcat_boxcat_local);
+    log_setting("Debugging_ProgramArgs", values.program_args.GetValue());
+    log_setting("Services_BCATBackend", values.bcat_backend.GetValue());
+    log_setting("Services_BCATBoxcatLocal", values.bcat_boxcat_local.GetValue());
 }
 
 bool IsConfiguringGlobal() {
@@ -93,8 +93,8 @@ bool IsGPULevelHigh() {
 }
 
 bool IsFastmemEnabled() {
-    if (values.cpu_accuracy.GetValue() == CPUAccuracy::DebugMode) {
-        return values.cpuopt_fastmem;
+    if (values.cpu_debug_mode) {
+        return static_cast<bool>(values.cpuopt_fastmem);
     }
     return true;
 }

src/common/settings.h

@@ -10,10 +10,12 @@
 #include <map>
 #include <optional>
 #include <string>
+#include <utility>
 #include <vector>
 
 #include "common/common_types.h"
 #include "common/settings_input.h"
+#include "input_common/udp/client.h"
 
 namespace Settings {
 
@@ -29,73 +31,240 @@ enum class GPUAccuracy : u32 {
 };
 
 enum class CPUAccuracy : u32 {
-    Accurate = 0,
-    Unsafe = 1,
-    DebugMode = 2,
+    Auto = 0,
+    Accurate = 1,
+    Unsafe = 2,
 };
 
+/** The BasicSetting class is a simple resource manager. It defines a label and default value
+ * alongside the actual value of the setting for simpler and less-error prone use with frontend
+ * configurations. Setting a default value and label is required, though subclasses may deviate from
+ * this requirement.
+ */
 template <typename Type>
-class Setting final {
+class BasicSetting {
+protected:
+    BasicSetting() = default;
+
+    /**
+     * Only sets the setting to the given initializer, leaving the other members to their default
+     * initializers.
+     *
+     * @param global_val Initial value of the setting
+     */
+    explicit BasicSetting(const Type& global_val) : global{global_val} {}
+
 public:
-    Setting() = default;
-    explicit Setting(Type val) : global{val} {}
-    ~Setting() = default;
-    void SetGlobal(bool to_global) {
-        use_global = to_global;
-    }
-    bool UsingGlobal() const {
-        return use_global;
-    }
-    Type GetValue(bool need_global = false) const {
-        if (use_global || need_global) {
-            return global;
-        }
-        return local;
-    }
-    void SetValue(const Type& value) {
-        if (use_global) {
-            global = value;
-        } else {
-            local = value;
-        }
+    /**
+     * Sets a default value, label, and setting value.
+     *
+     * @param default_val Intial value of the setting, and default value of the setting
+     * @param name Label for the setting
+     */
+    explicit BasicSetting(const Type& default_val, const std::string& name)
+        : default_value{default_val}, global{default_val}, label{name} {}
+    ~BasicSetting() = default;
+
+    /**
+     *  Returns a reference to the setting's value.
+     *
+     * @returns A reference to the setting
+     */
+    [[nodiscard]] const Type& GetValue() const {
+        return global;
     }
 
-private:
-    bool use_global = true;
-    Type global{};
-    Type local{};
+    /**
+     * Sets the setting to the given value.
+     *
+     * @param value The desired value
+     */
+    void SetValue(const Type& value) {
+        Type temp{value};
+        std::swap(global, temp);
+    }
+
+    /**
+     * Returns the value that this setting was created with.
+     *
+     * @returns A reference to the default value
+     */
+    [[nodiscard]] const Type& GetDefault() const {
+        return default_value;
+    }
+
+    /**
+     * Returns the label this setting was created with.
+     *
+     * @returns A reference to the label
+     */
+    [[nodiscard]] const std::string& GetLabel() const {
+        return label;
+    }
+
+    /**
+     * Assigns a value to the setting.
+     *
+     * @param value The desired setting value
+     *
+     * @returns A reference to the setting
+     */
+    const Type& operator=(const Type& value) {
+        Type temp{value};
+        std::swap(global, temp);
+        return global;
+    }
+
+    /**
+     * Returns a reference to the setting.
+     *
+     * @returns A reference to the setting
+     */
+    explicit operator const Type&() const {
+        return global;
+    }
+
+protected:
+    const Type default_value{}; ///< The default value
+    Type global{};              ///< The setting
+    const std::string label{};  ///< The setting's label
 };
 
 /**
- * The InputSetting class allows for getting a reference to either the global or local members.
+ * The Setting class is a slightly more complex version of the BasicSetting class. This adds a
+ * custom setting to switch to when a guest application specifically requires it. The effect is that
+ * other components of the emulator can access the setting's intended value without any need for the
+ * component to ask whether the custom or global setting is needed at the moment.
+ *
+ * By default, the global setting is used.
+ *
+ * Like the BasicSetting, this requires setting a default value and label to use.
+ */
+template <typename Type>
+class Setting final : public BasicSetting<Type> {
+public:
+    /**
+     * Sets a default value, label, and setting value.
+     *
+     * @param default_val Intial value of the setting, and default value of the setting
+     * @param name Label for the setting
+     */
+    explicit Setting(const Type& default_val, const std::string& name)
+        : BasicSetting<Type>(default_val, name) {}
+    ~Setting() = default;
+
+    /**
+     * Tells this setting to represent either the global or custom setting when other member
+     * functions are used.
+     *
+     * @param to_global Whether to use the global or custom setting.
+     */
+    void SetGlobal(bool to_global) {
+        use_global = to_global;
+    }
+
+    /**
+     * Returns whether this setting is using the global setting or not.
+     *
+     * @returns The global state
+     */
+    [[nodiscard]] bool UsingGlobal() const {
+        return use_global;
+    }
+
+    /**
+     * Returns either the global or custom setting depending on the values of this setting's global
+     * state or if the global value was specifically requested.
+     *
+     * @param need_global Request global value regardless of setting's state; defaults to false
+     *
+     * @returns The required value of the setting
+     */
+    [[nodiscard]] const Type& GetValue(bool need_global = false) const {
+        if (use_global || need_global) {
+            return this->global;
+        }
+        return custom;
+    }
+
+    /**
+     * Sets the current setting value depending on the global state.
+     *
+     * @param value The new value
+     */
+    void SetValue(const Type& value) {
+        Type temp{value};
+        if (use_global) {
+            std::swap(this->global, temp);
+        } else {
+            std::swap(custom, temp);
+        }
+    }
+
+    /**
+     * Assigns the current setting value depending on the global state.
+     *
+     * @param value The new value
+     *
+     * @returns A reference to the current setting value
+     */
+    const Type& operator=(const Type& value) {
+        Type temp{value};
+        if (use_global) {
+            std::swap(this->global, temp);
+            return this->global;
+        }
+        std::swap(custom, temp);
+        return custom;
+    }
+
+    /**
+     * Returns the current setting value depending on the global state.
+     *
+     * @returns A reference to the current setting value
+     */
+    explicit operator const Type&() const {
+        if (use_global) {
+            return this->global;
+        }
+        return custom;
+    }
+
+private:
+    bool use_global{true}; ///< The setting's global state
+    Type custom{};         ///< The custom value of the setting
+};
+
+/**
+ * The InputSetting class allows for getting a reference to either the global or custom members.
  * This is required as we cannot easily modify the values of user-defined types within containers
  * using the SetValue() member function found in the Setting class. The primary purpose of this
- * class is to store an array of 10 PlayerInput structs for both the global and local (per-game)
- * setting and allows for easily accessing and modifying both settings.
+ * class is to store an array of 10 PlayerInput structs for both the global and custom setting and
+ * allows for easily accessing and modifying both settings.
  */
 template <typename Type>
 class InputSetting final {
 public:
     InputSetting() = default;
-    explicit InputSetting(Type val) : global{val} {}
+    explicit InputSetting(Type val) : BasicSetting<Type>(val) {}
     ~InputSetting() = default;
     void SetGlobal(bool to_global) {
         use_global = to_global;
     }
-    bool UsingGlobal() const {
+    [[nodiscard]] bool UsingGlobal() const {
         return use_global;
     }
-    Type& GetValue(bool need_global = false) {
+    [[nodiscard]] Type& GetValue(bool need_global = false) {
         if (use_global || need_global) {
             return global;
         }
-        return local;
+        return custom;
     }
 
 private:
-    bool use_global = true;
-    Type global{};
-    Type local{};
+    bool use_global{true}; ///< The setting's global state
+    Type global{};         ///< The setting
+    Type custom{};         ///< The custom setting value
 };
 
 struct TouchFromButtonMap {
@@ -105,144 +274,158 @@ struct TouchFromButtonMap {
 
 struct Values {
     // Audio
-    std::string audio_device_id;
-    std::string sink_id;
-    bool audio_muted;
-    Setting<bool> enable_audio_stretching;
-    Setting<float> volume;
+    BasicSetting<std::string> audio_device_id{"auto", "output_device"};
+    BasicSetting<std::string> sink_id{"auto", "output_engine"};
+    BasicSetting<bool> audio_muted{false, "audio_muted"};
+    Setting<bool> enable_audio_stretching{true, "enable_audio_stretching"};
+    Setting<float> volume{1.0f, "volume"};
 
     // Core
-    Setting<bool> use_multi_core;
+    Setting<bool> use_multi_core{true, "use_multi_core"};
 
     // Cpu
-    Setting<CPUAccuracy> cpu_accuracy;
+    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"};
 
-    bool cpuopt_page_tables;
-    bool cpuopt_block_linking;
-    bool cpuopt_return_stack_buffer;
-    bool cpuopt_fast_dispatcher;
-    bool cpuopt_context_elimination;
-    bool cpuopt_const_prop;
-    bool cpuopt_misc_ir;
-    bool cpuopt_reduce_misalign_checks;
-    bool cpuopt_fastmem;
+    BasicSetting<bool> cpuopt_page_tables{true, "cpuopt_page_tables"};
+    BasicSetting<bool> cpuopt_block_linking{true, "cpuopt_block_linking"};
+    BasicSetting<bool> cpuopt_return_stack_buffer{true, "cpuopt_return_stack_buffer"};
+    BasicSetting<bool> cpuopt_fast_dispatcher{true, "cpuopt_fast_dispatcher"};
+    BasicSetting<bool> cpuopt_context_elimination{true, "cpuopt_context_elimination"};
+    BasicSetting<bool> cpuopt_const_prop{true, "cpuopt_const_prop"};
+    BasicSetting<bool> cpuopt_misc_ir{true, "cpuopt_misc_ir"};
+    BasicSetting<bool> cpuopt_reduce_misalign_checks{true, "cpuopt_reduce_misalign_checks"};
+    BasicSetting<bool> cpuopt_fastmem{true, "cpuopt_fastmem"};
 
-    Setting<bool> cpuopt_unsafe_unfuse_fma;
-    Setting<bool> cpuopt_unsafe_reduce_fp_error;
-    Setting<bool> cpuopt_unsafe_ignore_standard_fpcr;
-    Setting<bool> cpuopt_unsafe_inaccurate_nan;
-    Setting<bool> cpuopt_unsafe_fastmem_check;
+    Setting<bool> cpuopt_unsafe_unfuse_fma{true, "cpuopt_unsafe_unfuse_fma"};
+    Setting<bool> cpuopt_unsafe_reduce_fp_error{true, "cpuopt_unsafe_reduce_fp_error"};
+    Setting<bool> cpuopt_unsafe_ignore_standard_fpcr{true, "cpuopt_unsafe_ignore_standard_fpcr"};
+    Setting<bool> cpuopt_unsafe_inaccurate_nan{true, "cpuopt_unsafe_inaccurate_nan"};
+    Setting<bool> cpuopt_unsafe_fastmem_check{true, "cpuopt_unsafe_fastmem_check"};
 
     // Renderer
-    Setting<RendererBackend> renderer_backend;
-    bool renderer_debug;
-    Setting<int> vulkan_device;
+    Setting<RendererBackend> renderer_backend{RendererBackend::OpenGL, "backend"};
+    BasicSetting<bool> renderer_debug{false, "debug"};
+    Setting<int> vulkan_device{0, "vulkan_device"};
 
-    Setting<u16> resolution_factor{1};
-    Setting<int> fullscreen_mode;
-    Setting<int> aspect_ratio;
-    Setting<int> max_anisotropy;
-    Setting<bool> use_frame_limit;
-    Setting<u16> frame_limit;
-    Setting<bool> use_disk_shader_cache;
-    Setting<GPUAccuracy> gpu_accuracy;
-    Setting<bool> use_asynchronous_gpu_emulation;
-    Setting<bool> use_nvdec_emulation;
-    Setting<bool> accelerate_astc;
-    Setting<bool> use_vsync;
-    Setting<bool> disable_fps_limit;
-    Setting<bool> use_assembly_shaders;
-    Setting<bool> use_asynchronous_shaders;
-    Setting<bool> use_fast_gpu_time;
-    Setting<bool> use_caches_gc;
+    Setting<u16> resolution_factor{1, "resolution_factor"};
+    // *nix platforms may have issues with the borderless windowed fullscreen mode.
+    // Default to exclusive fullscreen on these platforms for now.
+    Setting<int> fullscreen_mode{
+#ifdef _WIN32
+        0,
+#else
+        1,
+#endif
+        "fullscreen_mode"};
+    Setting<int> aspect_ratio{0, "aspect_ratio"};
+    Setting<int> max_anisotropy{0, "max_anisotropy"};
+    Setting<bool> use_frame_limit{true, "use_frame_limit"};
+    Setting<u16> frame_limit{100, "frame_limit"};
+    Setting<bool> use_disk_shader_cache{true, "use_disk_shader_cache"};
+    Setting<GPUAccuracy> gpu_accuracy{GPUAccuracy::High, "gpu_accuracy"};
+    Setting<bool> use_asynchronous_gpu_emulation{true, "use_asynchronous_gpu_emulation"};
+    Setting<bool> use_nvdec_emulation{true, "use_nvdec_emulation"};
+    Setting<bool> accelerate_astc{true, "accelerate_astc"};
+    Setting<bool> use_vsync{true, "use_vsync"};
+    Setting<bool> disable_fps_limit{false, "disable_fps_limit"};
+    Setting<bool> use_assembly_shaders{false, "use_assembly_shaders"};
+    Setting<bool> use_asynchronous_shaders{false, "use_asynchronous_shaders"};
+    Setting<bool> use_fast_gpu_time{true, "use_fast_gpu_time"};
+    Setting<bool> use_caches_gc{false, "use_caches_gc"};
 
-    Setting<float> bg_red;
-    Setting<float> bg_green;
-    Setting<float> bg_blue;
+    Setting<float> bg_red{0.0f, "bg_red"};
+    Setting<float> bg_green{0.0f, "bg_green"};
+    Setting<float> bg_blue{0.0f, "bg_blue"};
 
     // System
-    Setting<std::optional<u32>> rng_seed;
+    Setting<std::optional<u32>> rng_seed{std::optional<u32>(), "rng_seed"};
     // Measured in seconds since epoch
     std::optional<std::chrono::seconds> custom_rtc;
     // Set on game boot, reset on stop. Seconds difference between current time and `custom_rtc`
     std::chrono::seconds custom_rtc_differential;
 
-    s32 current_user;
-    Setting<s32> language_index;
-    Setting<s32> region_index;
-    Setting<s32> time_zone_index;
-    Setting<s32> sound_index;
+    BasicSetting<s32> current_user{0, "current_user"};
+    Setting<s32> language_index{1, "language_index"};
+    Setting<s32> region_index{1, "region_index"};
+    Setting<s32> time_zone_index{0, "time_zone_index"};
+    Setting<s32> sound_index{1, "sound_index"};
 
     // Controls
     InputSetting<std::array<PlayerInput, 10>> players;
 
-    Setting<bool> use_docked_mode;
+    Setting<bool> use_docked_mode{true, "use_docked_mode"};
 
-    Setting<bool> vibration_enabled;
-    Setting<bool> enable_accurate_vibrations;
+    Setting<bool> vibration_enabled{true, "vibration_enabled"};
+    Setting<bool> enable_accurate_vibrations{false, "enable_accurate_vibrations"};
 
-    Setting<bool> motion_enabled;
-    std::string motion_device;
-    std::string udp_input_servers;
+    Setting<bool> motion_enabled{true, "motion_enabled"};
+    BasicSetting<std::string> motion_device{"engine:motion_emu,update_period:100,sensitivity:0.01",
+                                            "motion_device"};
+    BasicSetting<std::string> udp_input_servers{InputCommon::CemuhookUDP::DEFAULT_SRV,
+                                                "udp_input_servers"};
 
-    bool mouse_panning;
-    float mouse_panning_sensitivity;
-    bool mouse_enabled;
+    BasicSetting<bool> mouse_panning{false, "mouse_panning"};
+    BasicSetting<float> mouse_panning_sensitivity{1.0f, "mouse_panning_sensitivity"};
+    BasicSetting<bool> mouse_enabled{false, "mouse_enabled"};
     std::string mouse_device;
     MouseButtonsRaw mouse_buttons;
 
-    bool emulate_analog_keyboard;
-    bool keyboard_enabled;
+    BasicSetting<bool> emulate_analog_keyboard{false, "emulate_analog_keyboard"};
+    BasicSetting<bool> keyboard_enabled{false, "keyboard_enabled"};
     KeyboardKeysRaw keyboard_keys;
     KeyboardModsRaw keyboard_mods;
 
-    bool debug_pad_enabled;
+    BasicSetting<bool> debug_pad_enabled{false, "debug_pad_enabled"};
     ButtonsRaw debug_pad_buttons;
     AnalogsRaw debug_pad_analogs;
 
     TouchscreenInput touchscreen;
 
-    bool use_touch_from_button;
-    std::string touch_device;
-    int touch_from_button_map_index;
+    BasicSetting<bool> use_touch_from_button{false, "use_touch_from_button"};
+    BasicSetting<std::string> touch_device{"min_x:100,min_y:50,max_x:1800,max_y:850",
+                                           "touch_device"};
+    BasicSetting<int> touch_from_button_map_index{0, "touch_from_button_map"};
     std::vector<TouchFromButtonMap> touch_from_button_maps;
 
     std::atomic_bool is_device_reload_pending{true};
 
     // Data Storage
-    bool use_virtual_sd;
-    bool gamecard_inserted;
-    bool gamecard_current_game;
-    std::string gamecard_path;
+    BasicSetting<bool> use_virtual_sd{true, "use_virtual_sd"};
+    BasicSetting<bool> gamecard_inserted{false, "gamecard_inserted"};
+    BasicSetting<bool> gamecard_current_game{false, "gamecard_current_game"};
+    BasicSetting<std::string> gamecard_path{std::string(), "gamecard_path"};
 
     // Debugging
     bool record_frame_times;
-    bool use_gdbstub;
-    u16 gdbstub_port;
-    std::string program_args;
-    bool dump_exefs;
-    bool dump_nso;
-    bool enable_fs_access_log;
-    bool reporting_services;
-    bool quest_flag;
-    bool disable_macro_jit;
-    bool extended_logging;
-    bool use_debug_asserts;
-    bool use_auto_stub;
+    BasicSetting<bool> use_gdbstub{false, "use_gdbstub"};
+    BasicSetting<u16> gdbstub_port{0, "gdbstub_port"};
+    BasicSetting<std::string> program_args{std::string(), "program_args"};
+    BasicSetting<bool> dump_exefs{false, "dump_exefs"};
+    BasicSetting<bool> dump_nso{false, "dump_nso"};
+    BasicSetting<bool> enable_fs_access_log{false, "enable_fs_access_log"};
+    BasicSetting<bool> reporting_services{false, "reporting_services"};
+    BasicSetting<bool> quest_flag{false, "quest_flag"};
+    BasicSetting<bool> disable_macro_jit{false, "disable_macro_jit"};
+    BasicSetting<bool> extended_logging{false, "extended_logging"};
+    BasicSetting<bool> use_debug_asserts{false, "use_debug_asserts"};
+    BasicSetting<bool> use_auto_stub{false, "use_auto_stub"};
 
     // Miscellaneous
-    std::string log_filter;
-    bool use_dev_keys;
+    BasicSetting<std::string> log_filter{"*:Info", "log_filter"};
+    BasicSetting<bool> use_dev_keys{false, "use_dev_keys"};
 
     // Services
-    std::string bcat_backend;
-    bool bcat_boxcat_local;
+    BasicSetting<std::string> bcat_backend{"none", "bcat_backend"};
+    BasicSetting<bool> bcat_boxcat_local{false, "bcat_boxcat_local"};
 
     // WebService
-    bool enable_telemetry;
-    std::string web_api_url;
-    std::string yuzu_username;
-    std::string yuzu_token;
+    BasicSetting<bool> enable_telemetry{true, "enable_telemetry"};
+    BasicSetting<std::string> web_api_url{"https://api.yuzu-emu.org", "web_api_url"};
+    BasicSetting<std::string> yuzu_username{std::string(), "yuzu_username"};
+    BasicSetting<std::string> yuzu_token{std::string(), "yuzu_token"};
 
     // Add-Ons
     std::map<u64, std::vector<std::string>> disabled_addons;

src/common/thread_worker.cpp

@@ -1,58 +0,0 @@
-// Copyright 2020 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include "common/thread.h"
-#include "common/thread_worker.h"
-
-namespace Common {
-
-ThreadWorker::ThreadWorker(std::size_t num_workers, const std::string& name) {
-    for (std::size_t i = 0; i < num_workers; ++i)
-        threads.emplace_back([this, thread_name{std::string{name}}] {
-            Common::SetCurrentThreadName(thread_name.c_str());
-
-            // Wait for first request
-            {
-                std::unique_lock lock{queue_mutex};
-                condition.wait(lock, [this] { return stop || !requests.empty(); });
-            }
-
-            while (true) {
-                std::function<void()> task;
-
-                {
-                    std::unique_lock lock{queue_mutex};
-                    condition.wait(lock, [this] { return stop || !requests.empty(); });
-                    if (stop || requests.empty()) {
-                        return;
-                    }
-                    task = std::move(requests.front());
-                    requests.pop();
-                }
-
-                task();
-            }
-        });
-}
-
-ThreadWorker::~ThreadWorker() {
-    {
-        std::unique_lock lock{queue_mutex};
-        stop = true;
-    }
-    condition.notify_all();
-    for (std::thread& thread : threads) {
-        thread.join();
-    }
-}
-
-void ThreadWorker::QueueWork(std::function<void()>&& work) {
-    {
-        std::unique_lock lock{queue_mutex};
-        requests.emplace(work);
-    }
-    condition.notify_one();
-}
-
-} // namespace Common

src/common/thread_worker.h

@@ -7,24 +7,110 @@
 #include <atomic>
 #include <functional>
 #include <mutex>
+#include <stop_token>
 #include <string>
+#include <thread>
+#include <type_traits>
 #include <vector>
 #include <queue>
 
+#include "common/thread.h"
+#include "common/unique_function.h"
+
 namespace Common {
 
-class ThreadWorker final {
+template <class StateType = void>
+class StatefulThreadWorker {
+    static constexpr bool with_state = !std::is_same_v<StateType, void>;
+
+    struct DummyCallable {
+        int operator()() const noexcept {
+            return 0;
+        }
+    };
+
+    using Task =
+        std::conditional_t<with_state, UniqueFunction<void, StateType*>, UniqueFunction<void>>;
+    using StateMaker = std::conditional_t<with_state, std::function<StateType()>, DummyCallable>;
+
 public:
-    explicit ThreadWorker(std::size_t num_workers, const std::string& name);
-    ~ThreadWorker();
-    void QueueWork(std::function<void()>&& work);
+    explicit StatefulThreadWorker(size_t num_workers, std::string name, StateMaker func = {})
+        : workers_queued{num_workers}, thread_name{std::move(name)} {
+        const auto lambda = [this, func](std::stop_token stop_token) {
+            Common::SetCurrentThreadName(thread_name.c_str());
+            {
+                std::conditional_t<with_state, StateType, int> state{func()};
+                while (!stop_token.stop_requested()) {
+                    Task task;
+                    {
+                        std::unique_lock lock{queue_mutex};
+                        if (requests.empty()) {
+                            wait_condition.notify_all();
+                        }
+                        condition.wait(lock, stop_token, [this] { return !requests.empty(); });
+                        if (stop_token.stop_requested()) {
+                            break;
+                        }
+                        task = std::move(requests.front());
+                        requests.pop();
+                    }
+                    if constexpr (with_state) {
+                        task(&state);
+                    } else {
+                        task();
+                    }
+                    ++work_done;
+                }
+            }
+            ++workers_stopped;
+            wait_condition.notify_all();
+        };
+        threads.reserve(num_workers);
+        for (size_t i = 0; i < num_workers; ++i) {
+            threads.emplace_back(lambda);
+        }
+    }
+
+    StatefulThreadWorker& operator=(const StatefulThreadWorker&) = delete;
+    StatefulThreadWorker(const StatefulThreadWorker&) = delete;
+
+    StatefulThreadWorker& operator=(StatefulThreadWorker&&) = delete;
+    StatefulThreadWorker(StatefulThreadWorker&&) = delete;
+
+    void QueueWork(Task work) {
+        {
+            std::unique_lock lock{queue_mutex};
+            requests.emplace(std::move(work));
+            ++work_scheduled;
+        }
+        condition.notify_one();
+    }
+
+    void WaitForRequests(std::stop_token stop_token = {}) {
+        std::stop_callback callback(stop_token, [this] {
+            for (auto& thread : threads) {
+                thread.request_stop();
+            }
+        });
+        std::unique_lock lock{queue_mutex};
+        wait_condition.wait(lock, [this] {
+            return workers_stopped >= workers_queued || work_done >= work_scheduled;
+        });
+    }
 
 private:
-    std::vector<std::thread> threads;
-    std::queue<std::function<void()>> requests;
+    std::queue<Task> requests;
     std::mutex queue_mutex;
-    std::condition_variable condition;
-    std::atomic_bool stop{};
+    std::condition_variable_any condition;
+    std::condition_variable wait_condition;
+    std::atomic<size_t> work_scheduled{};
+    std::atomic<size_t> work_done{};
+    std::atomic<size_t> workers_stopped{};
+    std::atomic<size_t> workers_queued{};
+    std::string thread_name;
+    std::vector<std::jthread> threads;
 };
 
+using ThreadWorker = StatefulThreadWorker<>;
+
 } // namespace Common

src/common/unique_function.h

@@ -0,0 +1,62 @@
+// Copyright 2021 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include <memory>
+#include <utility>
+
+namespace Common {
+
+/// General purpose function wrapper similar to std::function.
+/// Unlike std::function, the captured values don't have to be copyable.
+/// This class can be moved but not copied.
+template <typename ResultType, typename... Args>
+class UniqueFunction {
+    class CallableBase {
+    public:
+        virtual ~CallableBase() = default;
+        virtual ResultType operator()(Args&&...) = 0;
+    };
+
+    template <typename Functor>
+    class Callable final : public CallableBase {
+    public:
+        Callable(Functor&& functor_) : functor{std::move(functor_)} {}
+        ~Callable() override = default;
+
+        ResultType operator()(Args&&... args) override {
+            return functor(std::forward<Args>(args)...);
+        }
+
+    private:
+        Functor functor;
+    };
+
+public:
+    UniqueFunction() = default;
+
+    template <typename Functor>
+    UniqueFunction(Functor&& functor)
+        : callable{std::make_unique<Callable<Functor>>(std::move(functor))} {}
+
+    UniqueFunction& operator=(UniqueFunction&& rhs) noexcept = default;
+    UniqueFunction(UniqueFunction&& rhs) noexcept = default;
+
+    UniqueFunction& operator=(const UniqueFunction&) = delete;
+    UniqueFunction(const UniqueFunction&) = delete;
+
+    ResultType operator()(Args&&... args) const {
+        return (*callable)(std::forward<Args>(args)...);
+    }
+
+    explicit operator bool() const noexcept {
+        return static_cast<bool>(callable);
+    }
+
+private:
+    std::unique_ptr<CallableBase> callable;
+};
+
+} // namespace Common

src/core/CMakeLists.txt

@@ -667,8 +667,6 @@ else()
     target_compile_options(core PRIVATE
         -Werror=conversion
         -Werror=ignored-qualifiers
-        -Werror=implicit-fallthrough
-        -Werror=sign-compare
         -Werror=shadow
 
         $<$<CXX_COMPILER_ID:GNU>:-Werror=class-memaccess>

src/core/arm/dynarmic/arm_dynarmic_32.cpp

@@ -150,7 +150,7 @@ std::shared_ptr<Dynarmic::A32::Jit> ARM_Dynarmic_32::MakeJit(Common::PageTable*
     config.far_code_offset = 400_MiB;
 
     // Safe optimizations
-    if (Settings::values.cpu_accuracy.GetValue() == Settings::CPUAccuracy::DebugMode) {
+    if (Settings::values.cpu_debug_mode) {
         if (!Settings::values.cpuopt_page_tables) {
             config.page_table = nullptr;
         }
@@ -183,20 +183,28 @@ std::shared_ptr<Dynarmic::A32::Jit> ARM_Dynarmic_32::MakeJit(Common::PageTable*
     // Unsafe optimizations
     if (Settings::values.cpu_accuracy.GetValue() == Settings::CPUAccuracy::Unsafe) {
         config.unsafe_optimizations = true;
-        if (Settings::values.cpuopt_unsafe_unfuse_fma.GetValue()) {
+        if (Settings::values.cpuopt_unsafe_unfuse_fma) {
             config.optimizations |= Dynarmic::OptimizationFlag::Unsafe_UnfuseFMA;
         }
-        if (Settings::values.cpuopt_unsafe_reduce_fp_error.GetValue()) {
+        if (Settings::values.cpuopt_unsafe_reduce_fp_error) {
             config.optimizations |= Dynarmic::OptimizationFlag::Unsafe_ReducedErrorFP;
         }
-        if (Settings::values.cpuopt_unsafe_ignore_standard_fpcr.GetValue()) {
+        if (Settings::values.cpuopt_unsafe_ignore_standard_fpcr) {
             config.optimizations |= Dynarmic::OptimizationFlag::Unsafe_IgnoreStandardFPCRValue;
         }
-        if (Settings::values.cpuopt_unsafe_inaccurate_nan.GetValue()) {
+        if (Settings::values.cpuopt_unsafe_inaccurate_nan) {
             config.optimizations |= Dynarmic::OptimizationFlag::Unsafe_InaccurateNaN;
         }
     }
 
+    // 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;
+    }
+
     return std::make_unique<Dynarmic::A32::Jit>(config);
 }
 

src/core/arm/dynarmic/arm_dynarmic_64.cpp

@@ -190,7 +190,7 @@ std::shared_ptr<Dynarmic::A64::Jit> ARM_Dynarmic_64::MakeJit(Common::PageTable*
     config.far_code_offset = 400_MiB;
 
     // Safe optimizations
-    if (Settings::values.cpu_accuracy.GetValue() == Settings::CPUAccuracy::DebugMode) {
+    if (Settings::values.cpu_debug_mode) {
         if (!Settings::values.cpuopt_page_tables) {
             config.page_table = nullptr;
         }
@@ -223,20 +223,28 @@ std::shared_ptr<Dynarmic::A64::Jit> ARM_Dynarmic_64::MakeJit(Common::PageTable*
     // Unsafe optimizations
     if (Settings::values.cpu_accuracy.GetValue() == Settings::CPUAccuracy::Unsafe) {
         config.unsafe_optimizations = true;
-        if (Settings::values.cpuopt_unsafe_unfuse_fma.GetValue()) {
+        if (Settings::values.cpuopt_unsafe_unfuse_fma) {
             config.optimizations |= Dynarmic::OptimizationFlag::Unsafe_UnfuseFMA;
         }
-        if (Settings::values.cpuopt_unsafe_reduce_fp_error.GetValue()) {
+        if (Settings::values.cpuopt_unsafe_reduce_fp_error) {
             config.optimizations |= Dynarmic::OptimizationFlag::Unsafe_ReducedErrorFP;
         }
-        if (Settings::values.cpuopt_unsafe_inaccurate_nan.GetValue()) {
+        if (Settings::values.cpuopt_unsafe_inaccurate_nan) {
             config.optimizations |= Dynarmic::OptimizationFlag::Unsafe_InaccurateNaN;
         }
-        if (Settings::values.cpuopt_unsafe_fastmem_check.GetValue()) {
+        if (Settings::values.cpuopt_unsafe_fastmem_check) {
             config.fastmem_address_space_bits = 64;
         }
     }
 
+    // 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;
+    }
+
     return std::make_shared<Dynarmic::A64::Jit>(config);
 }
 

src/core/core.cpp

@@ -263,9 +263,9 @@ struct System::Impl {
         if (Settings::values.gamecard_inserted) {
             if (Settings::values.gamecard_current_game) {
                 fs_controller.SetGameCard(GetGameFileFromPath(virtual_filesystem, filepath));
-            } else if (!Settings::values.gamecard_path.empty()) {
-                fs_controller.SetGameCard(
-                    GetGameFileFromPath(virtual_filesystem, Settings::values.gamecard_path));
+            } else if (!Settings::values.gamecard_path.GetValue().empty()) {
+                const auto gamecard_path = Settings::values.gamecard_path.GetValue();
+                fs_controller.SetGameCard(GetGameFileFromPath(virtual_filesystem, gamecard_path));
             }
         }
 

src/core/frontend/applets/profile_select.cpp

@@ -13,7 +13,7 @@ ProfileSelectApplet::~ProfileSelectApplet() = default;
 void DefaultProfileSelectApplet::SelectProfile(
     std::function<void(std::optional<Common::UUID>)> callback) const {
     Service::Account::ProfileManager manager;
-    callback(manager.GetUser(Settings::values.current_user).value_or(Common::UUID{}));
+    callback(manager.GetUser(Settings::values.current_user.GetValue()).value_or(Common::UUID{}));
     LOG_INFO(Service_ACC, "called, selecting current user instead of prompting...");
 }
 

src/core/hle/service/acc/profile_manager.cpp

@@ -48,7 +48,8 @@ ProfileManager::ProfileManager() {
         CreateNewUser(UUID::Generate(), "yuzu");
     }
 
-    auto current = std::clamp<int>(Settings::values.current_user, 0, MAX_USERS - 1);
+    auto current =
+        std::clamp<int>(static_cast<s32>(Settings::values.current_user), 0, MAX_USERS - 1);
 
     // If user index don't exist. Load the first user and change the active user
     if (!UserExistsIndex(current)) {

src/core/hle/service/am/am.cpp

@@ -1443,7 +1443,7 @@ void IApplicationFunctions::PopLaunchParameter(Kernel::HLERequestContext& ctx) {
         params.is_account_selected = 1;
 
         Account::ProfileManager profile_manager{};
-        const auto uuid = profile_manager.GetUser(Settings::values.current_user);
+        const auto uuid = profile_manager.GetUser(static_cast<s32>(Settings::values.current_user));
         ASSERT(uuid);
         params.current_user = uuid->uuid;
 

src/core/hle/service/bcat/module.cpp

@@ -579,7 +579,7 @@ void Module::Interface::CreateDeliveryCacheStorageServiceWithApplicationId(
 std::unique_ptr<Backend> CreateBackendFromSettings([[maybe_unused]] Core::System& system,
                                                    DirectoryGetter getter) {
 #ifdef YUZU_ENABLE_BOXCAT
-    if (Settings::values.bcat_backend == "boxcat") {
+    if (Settings::values.bcat_backend.GetValue() == "boxcat") {
         return std::make_unique<Boxcat>(system.GetAppletManager(), std::move(getter));
     }
 #endif

src/core/hle/service/nifm/nifm.cpp

@@ -179,7 +179,7 @@ private:
         IPC::ResponseBuilder rb{ctx, 3};
         rb.Push(ResultSuccess);
 
-        if (Settings::values.bcat_backend == "none") {
+        if (Settings::values.bcat_backend.GetValue() == "none") {
             rb.PushEnum(RequestState::NotSubmitted);
         } else {
             rb.PushEnum(RequestState::Connected);
@@ -384,7 +384,7 @@ private:
 
         IPC::ResponseBuilder rb{ctx, 3};
         rb.Push(ResultSuccess);
-        if (Settings::values.bcat_backend == "none") {
+        if (Settings::values.bcat_backend.GetValue() == "none") {
             rb.Push<u8>(0);
         } else {
             rb.Push<u8>(1);
@@ -395,7 +395,7 @@ private:
 
         IPC::ResponseBuilder rb{ctx, 3};
         rb.Push(ResultSuccess);
-        if (Settings::values.bcat_backend == "none") {
+        if (Settings::values.bcat_backend.GetValue() == "none") {
             rb.Push<u8>(0);
         } else {
             rb.Push<u8>(1);

src/core/hle/service/set/set.cpp

@@ -160,7 +160,7 @@ void SET::GetQuestFlag(Kernel::HLERequestContext& ctx) {
 
     IPC::ResponseBuilder rb{ctx, 3};
     rb.Push(ResultSuccess);
-    rb.Push(static_cast<u32>(Settings::values.quest_flag));
+    rb.Push(static_cast<u32>(Settings::values.quest_flag.GetValue()));
 }
 
 void SET::GetLanguageCode(Kernel::HLERequestContext& ctx) {

src/core/loader/nro.cpp

@@ -155,8 +155,8 @@ static bool LoadNroImpl(Kernel::KProcess& process, const std::vector<u8>& data)
         codeset.segments[i].size = PageAlignSize(nro_header.segments[i].size);
     }
 
-    if (!Settings::values.program_args.empty()) {
-        const auto arg_data = Settings::values.program_args;
+    if (!Settings::values.program_args.GetValue().empty()) {
+        const auto arg_data = Settings::values.program_args.GetValue();
         codeset.DataSegment().size += NSO_ARGUMENT_DATA_ALLOCATION_SIZE;
         NSOArgumentHeader args_header{
             NSO_ARGUMENT_DATA_ALLOCATION_SIZE, static_cast<u32_le>(arg_data.size()), {}};

src/core/loader/nso.cpp

@@ -104,8 +104,8 @@ std::optional<VAddr> AppLoader_NSO::LoadModule(Kernel::KProcess& process, Core::
         codeset.segments[i].size = nso_header.segments[i].size;
     }
 
-    if (should_pass_arguments && !Settings::values.program_args.empty()) {
-        const auto arg_data{Settings::values.program_args};
+    if (should_pass_arguments && !Settings::values.program_args.GetValue().empty()) {
+        const auto arg_data{Settings::values.program_args.GetValue()};
 
         codeset.DataSegment().size += NSO_ARGUMENT_DATA_ALLOCATION_SIZE;
         NSOArgumentHeader args_header{

src/core/reporter.cpp

@@ -397,7 +397,7 @@ void Reporter::ClearFSAccessLog() const {
 }
 
 bool Reporter::IsReportingEnabled() const {
-    return Settings::values.reporting_services;
+    return Settings::values.reporting_services.GetValue();
 }
 
 } // namespace Core

src/core/telemetry_session.cpp

@@ -135,7 +135,7 @@ u64 RegenerateTelemetryId() {
 
 bool VerifyLogin(const std::string& username, const std::string& token) {
 #ifdef ENABLE_WEB_SERVICE
-    return WebService::VerifyLogin(Settings::values.web_api_url, username, token);
+    return WebService::VerifyLogin(Settings::values.web_api_url.GetValue(), username, token);
 #else
     return false;
 #endif
@@ -152,7 +152,8 @@ TelemetrySession::~TelemetrySession() {
 
 #ifdef ENABLE_WEB_SERVICE
     auto backend = std::make_unique<WebService::TelemetryJson>(
-        Settings::values.web_api_url, Settings::values.yuzu_username, Settings::values.yuzu_token);
+        Settings::values.web_api_url.GetValue(), Settings::values.yuzu_username.GetValue(),
+        Settings::values.yuzu_token.GetValue());
 #else
     auto backend = std::make_unique<Telemetry::NullVisitor>();
 #endif
@@ -212,7 +213,7 @@ void TelemetrySession::AddInitialInfo(Loader::AppLoader& app_loader,
 
     // Log user configuration information
     constexpr auto field_type = Telemetry::FieldType::UserConfig;
-    AddField(field_type, "Audio_SinkId", Settings::values.sink_id);
+    AddField(field_type, "Audio_SinkId", Settings::values.sink_id.GetValue());
     AddField(field_type, "Audio_EnableAudioStretching",
              Settings::values.enable_audio_stretching.GetValue());
     AddField(field_type, "Core_UseMultiCore", Settings::values.use_multi_core.GetValue());
@@ -242,7 +243,8 @@ void TelemetrySession::AddInitialInfo(Loader::AppLoader& app_loader,
 bool TelemetrySession::SubmitTestcase() {
 #ifdef ENABLE_WEB_SERVICE
     auto backend = std::make_unique<WebService::TelemetryJson>(
-        Settings::values.web_api_url, Settings::values.yuzu_username, Settings::values.yuzu_token);
+        Settings::values.web_api_url.GetValue(), Settings::values.yuzu_username.GetValue(),
+        Settings::values.yuzu_token.GetValue());
     field_collection.Accept(*backend);
     return backend->SubmitTestcase();
 #else

src/input_common/CMakeLists.txt

@@ -44,10 +44,7 @@ else()
         -Werror
         -Werror=conversion
         -Werror=ignored-qualifiers
-        -Werror=implicit-fallthrough
-        -Werror=reorder
         -Werror=shadow
-        -Werror=sign-compare
         $<$<CXX_COMPILER_ID:GNU>:-Werror=unused-but-set-parameter>
         $<$<CXX_COMPILER_ID:GNU>:-Werror=unused-but-set-variable>
         -Werror=unused-variable

src/input_common/mouse/mouse_poller.cpp

@@ -84,7 +84,8 @@ public:
         std::lock_guard lock{mutex};
         const auto axis_value =
             static_cast<float>(mouse_input->GetMouseState(button).axis.at(axis));
-        return axis_value * Settings::values.mouse_panning_sensitivity / (100.0f * range);
+        const float sensitivity = Settings::values.mouse_panning_sensitivity.GetValue();
+        return axis_value * sensitivity / (100.0f * range);
     }
 
     std::pair<float, float> GetAnalog(u32 analog_axis_x, u32 analog_axis_y) const {

src/input_common/touch_from_button.cpp

@@ -13,7 +13,7 @@ class TouchFromButtonDevice final : public Input::TouchDevice {
 public:
     TouchFromButtonDevice() {
         const auto button_index =
-            static_cast<std::size_t>(Settings::values.touch_from_button_map_index);
+            static_cast<u64>(Settings::values.touch_from_button_map_index.GetValue());
         const auto& buttons = Settings::values.touch_from_button_maps[button_index].buttons;
 
         for (const auto& config_entry : buttons) {

src/input_common/udp/client.cpp

@@ -201,7 +201,7 @@ bool Client::DeviceConnected(std::size_t pad) const {
 void Client::ReloadSockets() {
     Reset();
 
-    std::stringstream servers_ss(Settings::values.udp_input_servers);
+    std::stringstream servers_ss(static_cast<std::string>(Settings::values.udp_input_servers));
     std::string server_token;
     std::size_t client = 0;
     while (std::getline(servers_ss, server_token, ',')) {
@@ -370,7 +370,7 @@ std::optional<std::size_t> Client::GetUnusedFingerID() const {
 
 void Client::UpdateTouchInput(Response::TouchPad& touch_pad, std::size_t client, std::size_t id) {
     // TODO: Use custom calibration per device
-    const Common::ParamPackage touch_param(Settings::values.touch_device);
+    const Common::ParamPackage touch_param(Settings::values.touch_device.GetValue());
     const u16 min_x = static_cast<u16>(touch_param.Get("min_x", 100));
     const u16 min_y = static_cast<u16>(touch_param.Get("min_y", 50));
     const u16 max_x = static_cast<u16>(touch_param.Get("max_x", 1800));

src/tests/CMakeLists.txt

@@ -5,6 +5,7 @@ add_executable(tests
     common/host_memory.cpp
     common/param_package.cpp
     common/ring_buffer.cpp
+    common/unique_function.cpp
     core/core_timing.cpp
     core/network/network.cpp
     tests.cpp

src/tests/common/unique_function.cpp

@@ -0,0 +1,108 @@
+// Copyright 2021 yuzu Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include <string>
+
+#include <catch2/catch.hpp>
+
+#include "common/unique_function.h"
+
+namespace {
+struct Noisy {
+    Noisy() : state{"Default constructed"} {}
+    Noisy(Noisy&& rhs) noexcept : state{"Move constructed"} {
+        rhs.state = "Moved away";
+    }
+    Noisy& operator=(Noisy&& rhs) noexcept {
+        state = "Move assigned";
+        rhs.state = "Moved away";
+    }
+    Noisy(const Noisy&) : state{"Copied constructed"} {}
+    Noisy& operator=(const Noisy&) {
+        state = "Copied assigned";
+    }
+
+    std::string state;
+};
+} // Anonymous namespace
+
+TEST_CASE("UniqueFunction", "[common]") {
+    SECTION("Capture reference") {
+        int value = 0;
+        Common::UniqueFunction<void> func = [&value] { value = 5; };
+        func();
+        REQUIRE(value == 5);
+    }
+    SECTION("Capture pointer") {
+        int value = 0;
+        int* pointer = &value;
+        Common::UniqueFunction<void> func = [pointer] { *pointer = 5; };
+        func();
+        REQUIRE(value == 5);
+    }
+    SECTION("Move object") {
+        Noisy noisy;
+        REQUIRE(noisy.state == "Default constructed");
+
+        Common::UniqueFunction<void> func = [noisy = std::move(noisy)] {
+            REQUIRE(noisy.state == "Move constructed");
+        };
+        REQUIRE(noisy.state == "Moved away");
+        func();
+    }
+    SECTION("Move construct function") {
+        int value = 0;
+        Common::UniqueFunction<void> func = [&value] { value = 5; };
+        Common::UniqueFunction<void> new_func = std::move(func);
+        new_func();
+        REQUIRE(value == 5);
+    }
+    SECTION("Move assign function") {
+        int value = 0;
+        Common::UniqueFunction<void> func = [&value] { value = 5; };
+        Common::UniqueFunction<void> new_func;
+        new_func = std::move(func);
+        new_func();
+        REQUIRE(value == 5);
+    }
+    SECTION("Default construct then assign function") {
+        int value = 0;
+        Common::UniqueFunction<void> func;
+        func = [&value] { value = 5; };
+        func();
+        REQUIRE(value == 5);
+    }
+    SECTION("Pass arguments") {
+        int result = 0;
+        Common::UniqueFunction<void, int, int> func = [&result](int a, int b) { result = a + b; };
+        func(5, 4);
+        REQUIRE(result == 9);
+    }
+    SECTION("Pass arguments and return value") {
+        Common::UniqueFunction<int, int, int> func = [](int a, int b) { return a + b; };
+        REQUIRE(func(5, 4) == 9);
+    }
+    SECTION("Destructor") {
+        int num_destroyed = 0;
+        struct Foo {
+            Foo(int* num_) : num{num_} {}
+            Foo(Foo&& rhs) : num{std::exchange(rhs.num, nullptr)} {}
+            Foo(const Foo&) = delete;
+
+            ~Foo() {
+                if (num) {
+                    ++*num;
+                }
+            }
+
+            int* num = nullptr;
+        };
+        Foo object{&num_destroyed};
+        {
+            Common::UniqueFunction<void> func = [object = std::move(object)] {};
+            REQUIRE(num_destroyed == 0);
+        }
+        REQUIRE(num_destroyed == 1);
+    }
+}

src/tests/video_core/buffer_base.cpp

@@ -536,7 +536,7 @@ TEST_CASE("BufferBase: Cached write downloads") {
     REQUIRE(rasterizer.Count() == 63);
     buffer.MarkRegionAsGpuModified(c + PAGE, PAGE);
     int num = 0;
-    buffer.ForEachDownloadRange(c, WORD, [&](u64 offset, u64 size) { ++num; });
+    buffer.ForEachDownloadRangeAndClear(c, WORD, [&](u64 offset, u64 size) { ++num; });
     buffer.ForEachUploadRange(c, WORD, [&](u64 offset, u64 size) { ++num; });
     REQUIRE(num == 0);
     REQUIRE(!buffer.IsRegionCpuModified(c + PAGE, PAGE));

src/video_core/buffer_cache/buffer_base.h

@@ -226,19 +226,24 @@ public:
     /// Call 'func' for each CPU modified range and unmark those pages as CPU modified
     template <typename Func>
     void ForEachUploadRange(VAddr query_cpu_range, u64 size, Func&& func) {
-        ForEachModifiedRange<Type::CPU>(query_cpu_range, size, func);
+        ForEachModifiedRange<Type::CPU>(query_cpu_range, size, true, func);
     }
 
     /// Call 'func' for each GPU modified range and unmark those pages as GPU modified
     template <typename Func>
-    void ForEachDownloadRange(VAddr query_cpu_range, u64 size, Func&& func) {
-        ForEachModifiedRange<Type::GPU>(query_cpu_range, size, 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);
     }
 
     /// Call 'func' for each GPU modified range and unmark those pages as GPU modified
     template <typename Func>
     void ForEachDownloadRange(Func&& func) {
-        ForEachModifiedRange<Type::GPU>(cpu_addr, SizeBytes(), func);
+        ForEachModifiedRange<Type::GPU>(cpu_addr, SizeBytes(), true, func);
     }
 
     /// Mark buffer as picked
@@ -415,7 +420,7 @@ private:
      * @param func            Function to call for each turned off region
      */
     template <Type type, typename Func>
-    void ForEachModifiedRange(VAddr query_cpu_range, s64 size, Func&& func) {
+    void ForEachModifiedRange(VAddr query_cpu_range, s64 size, bool clear, Func&& func) {
         static_assert(type != Type::Untracked);
 
         const s64 difference = query_cpu_range - cpu_addr;
@@ -467,7 +472,9 @@ private:
             bits = (bits << left_offset) >> left_offset;
 
             const u64 current_word = state_words[word_index] & bits;
-            state_words[word_index] &= ~bits;
+            if (clear) {
+                state_words[word_index] &= ~bits;
+            }
 
             if constexpr (type == Type::CPU) {
                 const u64 current_bits = untracked_words[word_index] & bits;

src/video_core/buffer_cache/buffer_cache.h

@@ -15,6 +15,7 @@
 #include <vector>
 
 #include <boost/container/small_vector.hpp>
+#include <boost/icl/interval_set.hpp>
 
 #include "common/common_types.h"
 #include "common/div_ceil.h"
@@ -77,6 +78,9 @@ class BufferCache {
     using Runtime = typename P::Runtime;
     using Buffer = typename P::Buffer;
 
+    using IntervalSet = boost::icl::interval_set<VAddr>;
+    using IntervalType = typename IntervalSet::interval_type;
+
     struct Empty {};
 
     struct OverlapResult {
@@ -148,11 +152,14 @@ public:
     /// Return true when there are uncommitted buffers to be downloaded
     [[nodiscard]] bool HasUncommittedFlushes() const noexcept;
 
+    void AccumulateFlushes();
+
     /// Return true when the caller should wait for async downloads
     [[nodiscard]] bool ShouldWaitAsyncFlushes() const noexcept;
 
     /// Commit asynchronous downloads
     void CommitAsyncFlushes();
+    void CommitAsyncFlushesHigh();
 
     /// Pop asynchronous downloads
     void PopAsyncFlushes();
@@ -160,6 +167,9 @@ public:
     /// Return true when a CPU region is modified from the GPU
     [[nodiscard]] bool IsRegionGpuModified(VAddr addr, size_t size);
 
+    /// Return true when a CPU region is modified from the CPU
+    [[nodiscard]] bool IsRegionCpuModified(VAddr addr, size_t size);
+
     std::mutex mutex;
 
 private:
@@ -272,8 +282,6 @@ private:
 
     void DeleteBuffer(BufferId buffer_id);
 
-    void ReplaceBufferDownloads(BufferId old_buffer_id, BufferId new_buffer_id);
-
     void NotifyBufferDeletion();
 
     [[nodiscard]] Binding StorageBufferBinding(GPUVAddr ssbo_addr) const;
@@ -327,9 +335,9 @@ private:
 
     std::vector<BufferId> cached_write_buffer_ids;
 
-    // TODO: This data structure is not optimal and it should be reworked
-    std::vector<BufferId> uncommitted_downloads;
-    std::deque<std::vector<BufferId>> committed_downloads;
+    IntervalSet uncommitted_ranges;
+    IntervalSet common_ranges;
+    std::deque<IntervalSet> committed_ranges;
 
     size_t immediate_buffer_capacity = 0;
     std::unique_ptr<u8[]> immediate_buffer_alloc;
@@ -352,6 +360,7 @@ BufferCache<P>::BufferCache(VideoCore::RasterizerInterface& rasterizer_,
     // Ensure the first slot is used for the null buffer
     void(slot_buffers.insert(runtime, NullBufferParams{}));
     deletion_iterator = slot_buffers.end();
+    common_ranges.clear();
 }
 
 template <class P>
@@ -547,29 +556,30 @@ void BufferCache<P>::FlushCachedWrites() {
 
 template <class P>
 bool BufferCache<P>::HasUncommittedFlushes() const noexcept {
-    return !uncommitted_downloads.empty();
+    return !uncommitted_ranges.empty() || !committed_ranges.empty();
+}
+
+template <class P>
+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));
 }
 
 template <class P>
 bool BufferCache<P>::ShouldWaitAsyncFlushes() const noexcept {
-    return !committed_downloads.empty() && !committed_downloads.front().empty();
+    return false;
 }
 
 template <class P>
-void BufferCache<P>::CommitAsyncFlushes() {
-    // This is intentionally passing the value by copy
-    committed_downloads.push_front(uncommitted_downloads);
-    uncommitted_downloads.clear();
-}
-
-template <class P>
-void BufferCache<P>::PopAsyncFlushes() {
-    if (committed_downloads.empty()) {
-        return;
-    }
-    auto scope_exit_pop_download = detail::ScopeExit([this] { committed_downloads.pop_back(); });
-    const std::span<const BufferId> download_ids = committed_downloads.back();
-    if (download_ids.empty()) {
+void BufferCache<P>::CommitAsyncFlushesHigh() {
+    AccumulateFlushes();
+    if (committed_ranges.empty()) {
         return;
     }
     MICROPROFILE_SCOPE(GPU_DownloadMemory);
@@ -577,20 +587,66 @@ void BufferCache<P>::PopAsyncFlushes() {
     boost::container::small_vector<std::pair<BufferCopy, BufferId>, 1> downloads;
     u64 total_size_bytes = 0;
     u64 largest_copy = 0;
-    for (const BufferId buffer_id : download_ids) {
-        slot_buffers[buffer_id].ForEachDownloadRange([&](u64 range_offset, u64 range_size) {
-            downloads.push_back({
-                BufferCopy{
-                    .src_offset = range_offset,
-                    .dst_offset = total_size_bytes,
-                    .size = range_size,
-                },
-                buffer_id,
+    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;
+                        const IntervalType search_interval{cpu_addr, 1};
+                        auto it = common_ranges.lower_bound(search_interval);
+                        if (it == common_ranges.end()) {
+                            it = common_ranges.begin();
+                        }
+                        while (it != common_ranges.end()) {
+                            VAddr inter_addr_end = it->upper();
+                            VAddr inter_addr = it->lower();
+                            if (inter_addr >= end_address) {
+                                break;
+                            }
+                            if (inter_addr_end <= start_address) {
+                                it++;
+                                continue;
+                            }
+                            if (inter_addr_end > end_address) {
+                                inter_addr_end = end_address;
+                            }
+                            if (inter_addr < start_address) {
+                                inter_addr = start_address;
+                            }
+                            add_download(inter_addr, inter_addr_end);
+                            it++;
+                        }
+                        const IntervalType subtract_interval{start_address, end_address};
+                        common_ranges.subtract(subtract_interval);
+                    });
             });
-            total_size_bytes += range_size;
-            largest_copy = std::max(largest_copy, range_size);
-        });
+        }
     }
+    committed_ranges.clear();
     if (downloads.empty()) {
         return;
     }
@@ -622,6 +678,19 @@ void BufferCache<P>::PopAsyncFlushes() {
     }
 }
 
+template <class P>
+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>::IsRegionGpuModified(VAddr addr, size_t size) {
     const u64 page_end = Common::DivCeil(addr + size, PAGE_SIZE);
@@ -641,6 +710,25 @@ bool BufferCache<P>::IsRegionGpuModified(VAddr addr, size_t size) {
     return false;
 }
 
+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>
 void BufferCache<P>::BindHostIndexBuffer() {
     Buffer& buffer = slot_buffers[index_buffer.buffer_id];
@@ -1010,16 +1098,16 @@ void BufferCache<P>::MarkWrittenBuffer(BufferId buffer_id, VAddr cpu_addr, u32 s
     Buffer& buffer = slot_buffers[buffer_id];
     buffer.MarkRegionAsGpuModified(cpu_addr, size);
 
-    const bool is_accuracy_high = Settings::IsGPULevelHigh();
+    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;
     const bool is_async = Settings::values.use_asynchronous_gpu_emulation.GetValue();
-    if (!is_accuracy_high || !is_async) {
+    if (!is_async && !is_accuracy_high) {
         return;
     }
-    if (std::ranges::find(uncommitted_downloads, buffer_id) != uncommitted_downloads.end()) {
-        // Already inserted
-        return;
-    }
-    uncommitted_downloads.push_back(buffer_id);
+    uncommitted_ranges.add(base_interval);
 }
 
 template <class P>
@@ -1103,7 +1191,6 @@ void BufferCache<P>::JoinOverlap(BufferId new_buffer_id, BufferId overlap_id,
     if (!copies.empty()) {
         runtime.CopyBuffer(slot_buffers[new_buffer_id], overlap, copies);
     }
-    ReplaceBufferDownloads(overlap_id, new_buffer_id);
     DeleteBuffer(overlap_id);
 }
 
@@ -1244,14 +1331,51 @@ void BufferCache<P>::DownloadBufferMemory(Buffer& buffer, VAddr cpu_addr, u64 si
     boost::container::small_vector<BufferCopy, 1> copies;
     u64 total_size_bytes = 0;
     u64 largest_copy = 0;
-    buffer.ForEachDownloadRange(cpu_addr, size, [&](u64 range_offset, u64 range_size) {
-        copies.push_back(BufferCopy{
-            .src_offset = range_offset,
-            .dst_offset = total_size_bytes,
-            .size = range_size,
-        });
-        total_size_bytes += range_size;
-        largest_copy = std::max(largest_copy, range_size);
+    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;
+        const IntervalType search_interval{start_address - range_size, 1};
+        auto it = common_ranges.lower_bound(search_interval);
+        if (it == common_ranges.end()) {
+            it = common_ranges.begin();
+        }
+        while (it != common_ranges.end()) {
+            VAddr inter_addr_end = it->upper();
+            VAddr inter_addr = it->lower();
+            if (inter_addr >= end_address) {
+                break;
+            }
+            if (inter_addr_end <= start_address) {
+                it++;
+                continue;
+            }
+            if (inter_addr_end > end_address) {
+                inter_addr_end = end_address;
+            }
+            if (inter_addr < start_address) {
+                inter_addr = start_address;
+            }
+            add_download(inter_addr, inter_addr_end);
+            it++;
+        }
+        const IntervalType subtract_interval{start_address, end_address};
+        common_ranges.subtract(subtract_interval);
     });
     if (total_size_bytes == 0) {
         return;
@@ -1315,18 +1439,6 @@ void BufferCache<P>::DeleteBuffer(BufferId buffer_id) {
     NotifyBufferDeletion();
 }
 
-template <class P>
-void BufferCache<P>::ReplaceBufferDownloads(BufferId old_buffer_id, BufferId new_buffer_id) {
-    const auto replace = [old_buffer_id, new_buffer_id](std::vector<BufferId>& buffers) {
-        std::ranges::replace(buffers, old_buffer_id, new_buffer_id);
-        if (auto it = std::ranges::find(buffers, new_buffer_id); it != buffers.end()) {
-            buffers.erase(std::remove(it + 1, buffers.end(), new_buffer_id), buffers.end());
-        }
-    };
-    replace(uncommitted_downloads);
-    std::ranges::for_each(committed_downloads, replace);
-}
-
 template <class P>
 void BufferCache<P>::NotifyBufferDeletion() {
     if constexpr (HAS_PERSISTENT_UNIFORM_BUFFER_BINDINGS) {
@@ -1349,15 +1461,9 @@ typename BufferCache<P>::Binding BufferCache<P>::StorageBufferBinding(GPUVAddr s
     if (!cpu_addr || size == 0) {
         return NULL_BINDING;
     }
-    // HACK(Rodrigo): This is the number of bytes bound in host beyond the guest API's range.
-    // It exists due to some games like Astral Chain operate out of bounds.
-    // Binding the whole map range would be technically correct, but games have large maps that make
-    // this approach unaffordable for now.
-    static constexpr u32 arbitrary_extra_bytes = 0xc000;
-    const u32 bytes_to_map_end = static_cast<u32>(gpu_memory.BytesToMapEnd(gpu_addr));
     const Binding binding{
         .cpu_addr = *cpu_addr,
-        .size = std::min(size + arbitrary_extra_bytes, bytes_to_map_end),
+        .size = size,
         .buffer_id = BufferId{},
     };
     return binding;

src/video_core/dma_pusher.cpp

@@ -4,6 +4,7 @@
 
 #include "common/cityhash.h"
 #include "common/microprofile.h"
+#include "common/settings.h"
 #include "core/core.h"
 #include "core/memory.h"
 #include "video_core/dma_pusher.h"
@@ -76,8 +77,13 @@ bool DmaPusher::Step() {
 
         // Push buffer non-empty, read a word
         command_headers.resize(command_list_header.size);
-        gpu.MemoryManager().ReadBlockUnsafe(dma_get, command_headers.data(),
-                                            command_list_header.size * sizeof(u32));
+        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));
+        }
     }
     for (std::size_t index = 0; index < command_headers.size();) {
         const CommandHeader& command_header = command_headers[index];

src/video_core/engines/fermi_2d.cpp

@@ -7,6 +7,10 @@
 #include "video_core/engines/fermi_2d.h"
 #include "video_core/memory_manager.h"
 #include "video_core/rasterizer_interface.h"
+#include "video_core/surface.h"
+
+using VideoCore::Surface::BytesPerBlock;
+using VideoCore::Surface::PixelFormatFromRenderTargetFormat;
 
 namespace Tegra::Engines {
 
@@ -49,7 +53,7 @@ void Fermi2D::Blit() {
     UNIMPLEMENTED_IF_MSG(regs.clip_enable != 0, "Clipped blit enabled");
 
     const auto& args = regs.pixels_from_memory;
-    const Config config{
+    Config config{
         .operation = regs.operation,
         .filter = args.sample_mode.filter,
         .dst_x0 = args.dst_x0,
@@ -61,7 +65,21 @@ void Fermi2D::Blit() {
         .src_x1 = static_cast<s32>((args.du_dx * args.dst_width + args.src_x0) >> 32),
         .src_y1 = static_cast<s32>((args.dv_dy * args.dst_height + args.src_y0) >> 32),
     };
-    if (!rasterizer->AccelerateSurfaceCopy(regs.src, regs.dst, config)) {
+    Surface src = regs.src;
+    const auto bytes_per_pixel = BytesPerBlock(PixelFormatFromRenderTargetFormat(src.format));
+    const auto need_align_to_pitch =
+        src.linear == Tegra::Engines::Fermi2D::MemoryLayout::Pitch &&
+        static_cast<s32>(src.width) == config.src_x1 &&
+        config.src_x1 > static_cast<s32>(src.pitch / bytes_per_pixel) && config.src_x0 > 0;
+    if (need_align_to_pitch) {
+        auto address = src.Address() + config.src_x0 * bytes_per_pixel;
+        src.addr_upper = static_cast<u32>(address >> 32);
+        src.addr_lower = static_cast<u32>(address);
+        src.width -= config.src_x0;
+        config.src_x1 -= config.src_x0;
+        config.src_x0 = 0;
+    }
+    if (!rasterizer->AccelerateSurfaceCopy(src, regs.dst, config)) {
         UNIMPLEMENTED();
     }
 }

src/video_core/fence_manager.h

@@ -8,6 +8,7 @@
 #include <queue>
 
 #include "common/common_types.h"
+#include "common/settings.h"
 #include "core/core.h"
 #include "video_core/delayed_destruction_ring.h"
 #include "video_core/gpu.h"
@@ -53,6 +54,12 @@ public:
         delayed_destruction_ring.Tick();
     }
 
+    // Unlike other fences, this one doesn't
+    void SignalOrdering() {
+        std::scoped_lock lock{buffer_cache.mutex};
+        buffer_cache.AccumulateFlushes();
+    }
+
     void SignalSemaphore(GPUVAddr addr, u32 value) {
         TryReleasePendingFences();
         const bool should_flush = ShouldFlush();

src/video_core/gpu.cpp

@@ -268,11 +268,13 @@ void GPU::CallPullerMethod(const MethodCall& method_call) {
     case BufferMethods::SemaphoreAddressHigh:
     case BufferMethods::SemaphoreAddressLow:
     case BufferMethods::SemaphoreSequence:
-    case BufferMethods::RefCnt:
     case BufferMethods::UnkCacheFlush:
     case BufferMethods::WrcacheFlush:
     case BufferMethods::FenceValue:
         break;
+    case BufferMethods::RefCnt:
+        rasterizer->SignalReference();
+        break;
     case BufferMethods::FenceAction:
         ProcessFenceActionMethod();
         break;

src/video_core/memory_manager.cpp

@@ -69,11 +69,16 @@ void MemoryManager::Unmap(GPUVAddr gpu_addr, std::size_t size) {
     } else {
         UNREACHABLE_MSG("Unmapping non-existent GPU address=0x{:x}", gpu_addr);
     }
-    // Flush and invalidate through the GPU interface, to be asynchronous if possible.
-    const std::optional<VAddr> cpu_addr = GpuToCpuAddress(gpu_addr);
-    ASSERT(cpu_addr);
 
-    rasterizer->UnmapMemory(*cpu_addr, size);
+    const auto submapped_ranges = GetSubmappedRange(gpu_addr, size);
+
+    for (const auto& map : submapped_ranges) {
+        // Flush and invalidate through the GPU interface, to be asynchronous if possible.
+        const std::optional<VAddr> cpu_addr = GpuToCpuAddress(map.first);
+        ASSERT(cpu_addr);
+
+        rasterizer->UnmapMemory(*cpu_addr, map.second);
+    }
 
     UpdateRange(gpu_addr, PageEntry::State::Unmapped, size);
 }
@@ -127,8 +132,14 @@ void MemoryManager::SetPageEntry(GPUVAddr gpu_addr, PageEntry page_entry, std::s
 
     //// Lock the new page
     // TryLockPage(page_entry, size);
+    auto& current_page = page_table[PageEntryIndex(gpu_addr)];
 
-    page_table[PageEntryIndex(gpu_addr)] = page_entry;
+    if ((!current_page.IsValid() && page_entry.IsValid()) ||
+        current_page.ToAddress() != page_entry.ToAddress()) {
+        rasterizer->ModifyGPUMemory(gpu_addr, size);
+    }
+
+    current_page = page_entry;
 }
 
 std::optional<GPUVAddr> MemoryManager::FindFreeRange(std::size_t size, std::size_t align,
@@ -174,6 +185,19 @@ std::optional<VAddr> MemoryManager::GpuToCpuAddress(GPUVAddr gpu_addr) const {
     return page_entry.ToAddress() + (gpu_addr & page_mask);
 }
 
+std::optional<VAddr> MemoryManager::GpuToCpuAddress(GPUVAddr addr, std::size_t size) const {
+    size_t page_index{addr >> page_bits};
+    const size_t page_last{(addr + size + page_size - 1) >> page_bits};
+    while (page_index < page_last) {
+        const auto page_addr{GpuToCpuAddress(page_index << page_bits)};
+        if (page_addr && *page_addr != 0) {
+            return page_addr;
+        }
+        ++page_index;
+    }
+    return std::nullopt;
+}
+
 template <typename T>
 T MemoryManager::Read(GPUVAddr addr) const {
     if (auto page_pointer{GetPointer(addr)}; page_pointer) {
@@ -370,4 +394,79 @@ bool MemoryManager::IsGranularRange(GPUVAddr gpu_addr, std::size_t size) const {
     return page <= Core::Memory::PAGE_SIZE;
 }
 
+bool MemoryManager::IsContinousRange(GPUVAddr gpu_addr, std::size_t size) const {
+    size_t page_index{gpu_addr >> page_bits};
+    const size_t page_last{(gpu_addr + size + page_size - 1) >> page_bits};
+    std::optional<VAddr> old_page_addr{};
+    while (page_index != page_last) {
+        const auto page_addr{GpuToCpuAddress(page_index << page_bits)};
+        if (!page_addr || *page_addr == 0) {
+            return false;
+        }
+        if (old_page_addr) {
+            if (*old_page_addr + page_size != *page_addr) {
+                return false;
+            }
+        }
+        old_page_addr = page_addr;
+        ++page_index;
+    }
+    return true;
+}
+
+bool MemoryManager::IsFullyMappedRange(GPUVAddr gpu_addr, std::size_t size) const {
+    size_t page_index{gpu_addr >> page_bits};
+    const size_t page_last{(gpu_addr + size + page_size - 1) >> page_bits};
+    while (page_index < page_last) {
+        if (!page_table[page_index].IsValid() || page_table[page_index].ToAddress() == 0) {
+            return false;
+        }
+        ++page_index;
+    }
+    return true;
+}
+
+std::vector<std::pair<GPUVAddr, std::size_t>> MemoryManager::GetSubmappedRange(
+    GPUVAddr gpu_addr, std::size_t size) const {
+    std::vector<std::pair<GPUVAddr, std::size_t>> result{};
+    size_t page_index{gpu_addr >> page_bits};
+    size_t remaining_size{size};
+    size_t page_offset{gpu_addr & page_mask};
+    std::optional<std::pair<GPUVAddr, std::size_t>> last_segment{};
+    std::optional<VAddr> old_page_addr{};
+    const auto extend_size = [this, &last_segment, &page_index](std::size_t bytes) {
+        if (!last_segment) {
+            GPUVAddr new_base_addr = page_index << page_bits;
+            last_segment = {new_base_addr, bytes};
+        } else {
+            last_segment->second += bytes;
+        }
+    };
+    const auto split = [this, &last_segment, &result] {
+        if (last_segment) {
+            result.push_back(*last_segment);
+            last_segment = std::nullopt;
+        }
+    };
+    while (remaining_size > 0) {
+        const size_t num_bytes{std::min(page_size - page_offset, remaining_size)};
+        const auto page_addr{GpuToCpuAddress(page_index << page_bits)};
+        if (!page_addr) {
+            split();
+        } else if (old_page_addr) {
+            if (*old_page_addr + page_size != *page_addr) {
+                split();
+            }
+            extend_size(num_bytes);
+        } else {
+            extend_size(num_bytes);
+        }
+        ++page_index;
+        page_offset = 0;
+        remaining_size -= num_bytes;
+    }
+    split();
+    return result;
+}
+
 } // namespace Tegra

src/video_core/memory_manager.h

@@ -76,6 +76,8 @@ public:
 
     [[nodiscard]] std::optional<VAddr> GpuToCpuAddress(GPUVAddr addr) const;
 
+    [[nodiscard]] std::optional<VAddr> GpuToCpuAddress(GPUVAddr addr, std::size_t size) const;
+
     template <typename T>
     [[nodiscard]] T Read(GPUVAddr addr) const;
 
@@ -112,10 +114,28 @@ public:
     void WriteBlockUnsafe(GPUVAddr gpu_dest_addr, const void* src_buffer, std::size_t size);
 
     /**
-     * IsGranularRange checks if a gpu region can be simply read with a pointer.
+     * Checks if a gpu region can be simply read with a pointer.
      */
     [[nodiscard]] bool IsGranularRange(GPUVAddr gpu_addr, std::size_t size) const;
 
+    /**
+     * Checks if a gpu region is mapped by a single range of cpu addresses.
+     */
+    [[nodiscard]] bool IsContinousRange(GPUVAddr gpu_addr, std::size_t size) const;
+
+    /**
+     * Checks if a gpu region is mapped entirely.
+     */
+    [[nodiscard]] bool IsFullyMappedRange(GPUVAddr gpu_addr, std::size_t size) const;
+
+    /**
+     * Returns a vector with all the subranges of cpu addresses mapped beneath.
+     * if the region is continous, a single pair will be returned. If it's unmapped, an empty vector
+     * will be returned;
+     */
+    std::vector<std::pair<GPUVAddr, std::size_t>> GetSubmappedRange(GPUVAddr gpu_addr,
+                                                                    std::size_t size) const;
+
     [[nodiscard]] GPUVAddr Map(VAddr cpu_addr, GPUVAddr gpu_addr, std::size_t size);
     [[nodiscard]] GPUVAddr MapAllocate(VAddr cpu_addr, std::size_t size, std::size_t align);
     [[nodiscard]] GPUVAddr MapAllocate32(VAddr cpu_addr, std::size_t size);

src/video_core/rasterizer_interface.h

@@ -63,6 +63,9 @@ public:
     /// Signal a GPU based syncpoint as a fence
     virtual void SignalSyncPoint(u32 value) = 0;
 
+    /// Signal a GPU based reference as point
+    virtual void SignalReference() = 0;
+
     /// Release all pending fences.
     virtual void ReleaseFences() = 0;
 
@@ -87,6 +90,9 @@ public:
     /// Unmap memory range
     virtual void UnmapMemory(VAddr addr, u64 size) = 0;
 
+    /// Remap GPU memory range. This means underneath backing memory changed
+    virtual void ModifyGPUMemory(GPUVAddr addr, u64 size) = 0;
+
     /// Notify rasterizer that any caches of the specified region should be flushed to Switch memory
     /// and invalidated
     virtual void FlushAndInvalidateRegion(VAddr addr, u64 size) = 0;

src/video_core/renderer_opengl/gl_rasterizer.cpp

@@ -611,6 +611,13 @@ void RasterizerOpenGL::UnmapMemory(VAddr addr, u64 size) {
     shader_cache.OnCPUWrite(addr, size);
 }
 
+void RasterizerOpenGL::ModifyGPUMemory(GPUVAddr addr, u64 size) {
+    {
+        std::scoped_lock lock{texture_cache.mutex};
+        texture_cache.UnmapGPUMemory(addr, size);
+    }
+}
+
 void RasterizerOpenGL::SignalSemaphore(GPUVAddr addr, u32 value) {
     if (!gpu.IsAsync()) {
         gpu_memory.Write<u32>(addr, value);
@@ -627,6 +634,13 @@ void RasterizerOpenGL::SignalSyncPoint(u32 value) {
     fence_manager.SignalSyncPoint(value);
 }
 
+void RasterizerOpenGL::SignalReference() {
+    if (!gpu.IsAsync()) {
+        return;
+    }
+    fence_manager.SignalOrdering();
+}
+
 void RasterizerOpenGL::ReleaseFences() {
     if (!gpu.IsAsync()) {
         return;
@@ -643,6 +657,7 @@ void RasterizerOpenGL::FlushAndInvalidateRegion(VAddr addr, u64 size) {
 
 void RasterizerOpenGL::WaitForIdle() {
     glMemoryBarrier(GL_ALL_BARRIER_BITS);
+    SignalReference();
 }
 
 void RasterizerOpenGL::FragmentBarrier() {

src/video_core/renderer_opengl/gl_rasterizer.h

@@ -80,8 +80,10 @@ public:
     void OnCPUWrite(VAddr addr, u64 size) override;
     void SyncGuestHost() override;
     void UnmapMemory(VAddr addr, u64 size) override;
+    void ModifyGPUMemory(GPUVAddr addr, u64 size) override;
     void SignalSemaphore(GPUVAddr addr, u32 value) override;
     void SignalSyncPoint(u32 value) override;
+    void SignalReference() override;
     void ReleaseFences() override;
     void FlushAndInvalidateRegion(VAddr addr, u64 size) override;
     void WaitForIdle() override;

src/video_core/renderer_opengl/util_shaders.cpp

@@ -261,9 +261,9 @@ void UtilShaders::CopyBC4(Image& dst_image, Image& src_image, std::span<const Im
         glUniform3ui(LOC_SRC_OFFSET, copy.src_offset.x, copy.src_offset.y, copy.src_offset.z);
         glUniform3ui(LOC_DST_OFFSET, copy.dst_offset.x, copy.dst_offset.y, copy.dst_offset.z);
         glBindImageTexture(BINDING_INPUT_IMAGE, src_image.StorageHandle(),
-                           copy.src_subresource.base_level, GL_FALSE, 0, GL_READ_ONLY, GL_RG32UI);
+                           copy.src_subresource.base_level, GL_TRUE, 0, GL_READ_ONLY, GL_RG32UI);
         glBindImageTexture(BINDING_OUTPUT_IMAGE, dst_image.StorageHandle(),
-                           copy.dst_subresource.base_level, GL_FALSE, 0, GL_WRITE_ONLY, GL_RGBA8UI);
+                           copy.dst_subresource.base_level, GL_TRUE, 0, GL_WRITE_ONLY, GL_RGBA8UI);
         glDispatchCompute(copy.extent.width, copy.extent.height, copy.extent.depth);
     }
     program_manager.RestoreGuestCompute();

src/video_core/renderer_vulkan/renderer_vulkan.cpp

@@ -103,7 +103,7 @@ RendererVulkan::RendererVulkan(Core::TelemetrySession& telemetry_session_,
       gpu(gpu_),
       library(OpenLibrary()),
       instance(CreateInstance(library, dld, VK_API_VERSION_1_1, render_window.GetWindowInfo().type,
-                              true, Settings::values.renderer_debug)),
+                              true, Settings::values.renderer_debug.GetValue())),
       debug_callback(Settings::values.renderer_debug ? CreateDebugCallback(instance) : nullptr),
       surface(CreateSurface(instance, render_window)),
       device(CreateDevice(instance, dld, *surface)),

src/video_core/renderer_vulkan/vk_rasterizer.cpp

@@ -557,6 +557,13 @@ void RasterizerVulkan::UnmapMemory(VAddr addr, u64 size) {
     pipeline_cache.OnCPUWrite(addr, size);
 }
 
+void RasterizerVulkan::ModifyGPUMemory(GPUVAddr addr, u64 size) {
+    {
+        std::scoped_lock lock{texture_cache.mutex};
+        texture_cache.UnmapGPUMemory(addr, size);
+    }
+}
+
 void RasterizerVulkan::SignalSemaphore(GPUVAddr addr, u32 value) {
     if (!gpu.IsAsync()) {
         gpu_memory.Write<u32>(addr, value);
@@ -573,6 +580,13 @@ void RasterizerVulkan::SignalSyncPoint(u32 value) {
     fence_manager.SignalSyncPoint(value);
 }
 
+void RasterizerVulkan::SignalReference() {
+    if (!gpu.IsAsync()) {
+        return;
+    }
+    fence_manager.SignalOrdering();
+}
+
 void RasterizerVulkan::ReleaseFences() {
     if (!gpu.IsAsync()) {
         return;
@@ -605,6 +619,7 @@ void RasterizerVulkan::WaitForIdle() {
         cmdbuf.SetEvent(event, flags);
         cmdbuf.WaitEvents(event, flags, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, {}, {}, {});
     });
+    SignalReference();
 }
 
 void RasterizerVulkan::FragmentBarrier() {

src/video_core/renderer_vulkan/vk_rasterizer.h

@@ -72,8 +72,10 @@ public:
     void OnCPUWrite(VAddr addr, u64 size) override;
     void SyncGuestHost() override;
     void UnmapMemory(VAddr addr, u64 size) override;
+    void ModifyGPUMemory(GPUVAddr addr, u64 size) override;
     void SignalSemaphore(GPUVAddr addr, u32 value) override;
     void SignalSyncPoint(u32 value) override;
+    void SignalReference() override;
     void ReleaseFences() override;
     void FlushAndInvalidateRegion(VAddr addr, u64 size) override;
     void WaitForIdle() override;

src/video_core/texture_cache/image_base.cpp

@@ -69,6 +69,9 @@ ImageBase::ImageBase(const ImageInfo& info_, GPUVAddr gpu_addr_, VAddr cpu_addr_
     }
 }
 
+ImageMapView::ImageMapView(GPUVAddr gpu_addr_, VAddr cpu_addr_, size_t size_, ImageId image_id_)
+    : gpu_addr{gpu_addr_}, cpu_addr{cpu_addr_}, size{size_}, image_id{image_id_} {}
+
 std::optional<SubresourceBase> ImageBase::TryFindBase(GPUVAddr other_addr) const noexcept {
     if (other_addr < gpu_addr) {
         // Subresource address can't be lower than the base

src/video_core/texture_cache/image_base.h

@@ -25,12 +25,14 @@ enum class ImageFlagBits : u32 {
     Strong = 1 << 5,      ///< Exists in the image table, the dimensions are can be trusted
     Registered = 1 << 6,  ///< True when the image is registered
     Picked = 1 << 7,      ///< Temporary flag to mark the image as picked
+    Remapped = 1 << 8,    ///< Image has been remapped.
+    Sparse = 1 << 9,      ///< Image has non continous submemory.
 
     // Garbage Collection Flags
-    BadOverlap = 1 << 8, ///< This image overlaps other but doesn't fit, has higher
-                         ///< garbage collection priority
-    Alias = 1 << 9,      ///< This image has aliases and has priority on garbage
-                         ///< collection
+    BadOverlap = 1 << 10, ///< This image overlaps other but doesn't fit, has higher
+                          ///< garbage collection priority
+    Alias = 1 << 11,      ///< This image has aliases and has priority on garbage
+                          ///< collection
 };
 DECLARE_ENUM_FLAG_OPERATORS(ImageFlagBits)
 
@@ -57,6 +59,12 @@ struct ImageBase {
         return cpu_addr < overlap_end && overlap_cpu_addr < cpu_addr_end;
     }
 
+    [[nodiscard]] bool OverlapsGPU(GPUVAddr overlap_gpu_addr, size_t overlap_size) const noexcept {
+        const VAddr overlap_end = overlap_gpu_addr + overlap_size;
+        const GPUVAddr gpu_addr_end = gpu_addr + guest_size_bytes;
+        return gpu_addr < overlap_end && overlap_gpu_addr < gpu_addr_end;
+    }
+
     void CheckBadOverlapState();
     void CheckAliasState();
 
@@ -84,6 +92,29 @@ struct ImageBase {
 
     std::vector<AliasedImage> aliased_images;
     std::vector<ImageId> overlapping_images;
+    ImageMapId map_view_id{};
+};
+
+struct ImageMapView {
+    explicit ImageMapView(GPUVAddr gpu_addr, VAddr cpu_addr, size_t size, ImageId image_id);
+
+    [[nodiscard]] bool Overlaps(VAddr overlap_cpu_addr, size_t overlap_size) const noexcept {
+        const VAddr overlap_end = overlap_cpu_addr + overlap_size;
+        const VAddr cpu_addr_end = cpu_addr + size;
+        return cpu_addr < overlap_end && overlap_cpu_addr < cpu_addr_end;
+    }
+
+    [[nodiscard]] bool OverlapsGPU(GPUVAddr overlap_gpu_addr, size_t overlap_size) const noexcept {
+        const GPUVAddr overlap_end = overlap_gpu_addr + overlap_size;
+        const GPUVAddr gpu_addr_end = gpu_addr + size;
+        return gpu_addr < overlap_end && overlap_gpu_addr < gpu_addr_end;
+    }
+
+    GPUVAddr gpu_addr;
+    VAddr cpu_addr;
+    size_t size;
+    ImageId image_id;
+    bool picked{};
 };
 
 struct ImageAllocBase {

src/video_core/texture_cache/texture_cache.h

@@ -13,6 +13,7 @@
 #include <span>
 #include <type_traits>
 #include <unordered_map>
+#include <unordered_set>
 #include <utility>
 #include <vector>
 
@@ -152,12 +153,13 @@ public:
     /// Remove images in a region
     void UnmapMemory(VAddr cpu_addr, size_t size);
 
+    /// Remove images in a region
+    void UnmapGPUMemory(GPUVAddr gpu_addr, size_t size);
+
     /// Blit an image with the given parameters
     void BlitImage(const Tegra::Engines::Fermi2D::Surface& dst,
                    const Tegra::Engines::Fermi2D::Surface& src,
-                   const Tegra::Engines::Fermi2D::Config& copy,
-                   std::optional<Region2D> src_region_override = {},
-                   std::optional<Region2D> dst_region_override = {});
+                   const Tegra::Engines::Fermi2D::Config& copy);
 
     /// Invalidate the contents of the color buffer index
     /// These contents become unspecified, the cache can assume aggressive optimizations.
@@ -190,7 +192,22 @@ public:
 private:
     /// Iterate over all page indices in a range
     template <typename Func>
-    static void ForEachPage(VAddr addr, size_t size, Func&& func) {
+    static void ForEachCPUPage(VAddr addr, size_t size, Func&& func) {
+        static constexpr bool RETURNS_BOOL = std::is_same_v<std::invoke_result<Func, u64>, bool>;
+        const u64 page_end = (addr + size - 1) >> PAGE_BITS;
+        for (u64 page = addr >> PAGE_BITS; page <= page_end; ++page) {
+            if constexpr (RETURNS_BOOL) {
+                if (func(page)) {
+                    break;
+                }
+            } else {
+                func(page);
+            }
+        }
+    }
+
+    template <typename Func>
+    static void ForEachGPUPage(GPUVAddr addr, size_t size, Func&& func) {
         static constexpr bool RETURNS_BOOL = std::is_same_v<std::invoke_result<Func, u64>, bool>;
         const u64 page_end = (addr + size - 1) >> PAGE_BITS;
         for (u64 page = addr >> PAGE_BITS; page <= page_end; ++page) {
@@ -220,7 +237,7 @@ private:
     FramebufferId GetFramebufferId(const RenderTargets& key);
 
     /// Refresh the contents (pixel data) of an image
-    void RefreshContents(Image& image);
+    void RefreshContents(Image& image, ImageId image_id);
 
     /// Upload data from guest to an image
     template <typename StagingBuffer>
@@ -269,6 +286,16 @@ private:
     template <typename Func>
     void ForEachImageInRegion(VAddr cpu_addr, size_t size, Func&& func);
 
+    template <typename Func>
+    void ForEachImageInRegionGPU(GPUVAddr gpu_addr, size_t size, Func&& func);
+
+    template <typename Func>
+    void ForEachSparseImageInRegion(GPUVAddr gpu_addr, size_t size, Func&& func);
+
+    /// Iterates over all the images in a region calling func
+    template <typename Func>
+    void ForEachSparseSegment(ImageBase& image, Func&& func);
+
     /// Find or create an image view in the given image with the passed parameters
     [[nodiscard]] ImageViewId FindOrEmplaceImageView(ImageId image_id, const ImageViewInfo& info);
 
@@ -279,10 +306,10 @@ private:
     void UnregisterImage(ImageId image);
 
     /// Track CPU reads and writes for image
-    void TrackImage(ImageBase& image);
+    void TrackImage(ImageBase& image, ImageId image_id);
 
     /// Stop tracking CPU reads and writes for image
-    void UntrackImage(ImageBase& image);
+    void UntrackImage(ImageBase& image, ImageId image_id);
 
     /// Delete image from the cache
     void DeleteImage(ImageId image);
@@ -340,7 +367,13 @@ private:
     std::unordered_map<TSCEntry, SamplerId> samplers;
     std::unordered_map<RenderTargets, FramebufferId> framebuffers;
 
-    std::unordered_map<u64, std::vector<ImageId>, IdentityHash<u64>> page_table;
+    std::unordered_map<u64, std::vector<ImageMapId>, IdentityHash<u64>> page_table;
+    std::unordered_map<u64, std::vector<ImageId>, IdentityHash<u64>> gpu_page_table;
+    std::unordered_map<u64, std::vector<ImageId>, IdentityHash<u64>> sparse_page_table;
+
+    std::unordered_map<ImageId, std::vector<ImageViewId>> sparse_views;
+
+    VAddr virtual_invalid_space{};
 
     bool has_deleted_images = false;
     u64 total_used_memory = 0;
@@ -349,6 +382,7 @@ private:
     u64 critical_memory;
 
     SlotVector<Image> slot_images;
+    SlotVector<ImageMapView> slot_map_views;
     SlotVector<ImageView> slot_image_views;
     SlotVector<ImageAlloc> slot_image_allocs;
     SlotVector<Sampler> slot_samplers;
@@ -459,7 +493,7 @@ void TextureCache<P>::RunGarbageCollector() {
                 }
             }
             if (True(image->flags & ImageFlagBits::Tracked)) {
-                UntrackImage(*image);
+                UntrackImage(*image, image_id);
             }
             UnregisterImage(image_id);
             DeleteImage(image_id);
@@ -658,7 +692,9 @@ void TextureCache<P>::WriteMemory(VAddr cpu_addr, size_t size) {
             return;
         }
         image.flags |= ImageFlagBits::CpuModified;
-        UntrackImage(image);
+        if (True(image.flags & ImageFlagBits::Tracked)) {
+            UntrackImage(image, image_id);
+        }
     });
 }
 
@@ -695,19 +731,34 @@ void TextureCache<P>::UnmapMemory(VAddr cpu_addr, size_t size) {
     for (const ImageId id : deleted_images) {
         Image& image = slot_images[id];
         if (True(image.flags & ImageFlagBits::Tracked)) {
-            UntrackImage(image);
+            UntrackImage(image, id);
         }
         UnregisterImage(id);
         DeleteImage(id);
     }
 }
 
+template <class P>
+void TextureCache<P>::UnmapGPUMemory(GPUVAddr gpu_addr, size_t size) {
+    std::vector<ImageId> deleted_images;
+    ForEachImageInRegionGPU(gpu_addr, size,
+                            [&](ImageId id, Image&) { deleted_images.push_back(id); });
+    for (const ImageId id : deleted_images) {
+        Image& image = slot_images[id];
+        if (True(image.flags & ImageFlagBits::Remapped)) {
+            continue;
+        }
+        image.flags |= ImageFlagBits::Remapped;
+        if (True(image.flags & ImageFlagBits::Tracked)) {
+            UntrackImage(image, id);
+        }
+    }
+}
+
 template <class P>
 void TextureCache<P>::BlitImage(const Tegra::Engines::Fermi2D::Surface& dst,
                                 const Tegra::Engines::Fermi2D::Surface& src,
-                                const Tegra::Engines::Fermi2D::Config& copy,
-                                std::optional<Region2D> src_override,
-                                std::optional<Region2D> dst_override) {
+                                const Tegra::Engines::Fermi2D::Config& copy) {
     const BlitImages images = GetBlitImages(dst, src);
     const ImageId dst_id = images.dst_id;
     const ImageId src_id = images.src_id;
@@ -718,47 +769,25 @@ void TextureCache<P>::BlitImage(const Tegra::Engines::Fermi2D::Surface& dst,
     const ImageBase& src_image = slot_images[src_id];
 
     // TODO: Deduplicate
-    const std::optional dst_base = dst_image.TryFindBase(dst.Address());
-    const SubresourceRange dst_range{.base = dst_base.value(), .extent = {1, 1}};
-    const ImageViewInfo dst_view_info(ImageViewType::e2D, images.dst_format, dst_range);
-    const auto [dst_framebuffer_id, dst_view_id] = RenderTargetFromImage(dst_id, dst_view_info);
-    const auto [src_samples_x, src_samples_y] = SamplesLog2(src_image.info.num_samples);
-
-    // out of bounds texture blit checking
-    const bool use_override = src_override.has_value();
-    const s32 src_x0 = copy.src_x0 >> src_samples_x;
-    s32 src_x1 = use_override ? src_override->end.x : copy.src_x1 >> src_samples_x;
-    const s32 src_y0 = copy.src_y0 >> src_samples_y;
-    const s32 src_y1 = copy.src_y1 >> src_samples_y;
-
-    const auto src_width = static_cast<s32>(src_image.info.size.width);
-    const bool width_oob = src_x1 > src_width;
-    const auto width_diff = width_oob ? src_x1 - src_width : 0;
-    if (width_oob) {
-        src_x1 = src_width;
-    }
-
-    const Region2D src_dimensions{
-        Offset2D{.x = src_x0, .y = src_y0},
-        Offset2D{.x = src_x1, .y = src_y1},
-    };
-    const auto src_region = use_override ? *src_override : src_dimensions;
-
     const std::optional src_base = src_image.TryFindBase(src.Address());
     const SubresourceRange src_range{.base = src_base.value(), .extent = {1, 1}};
     const ImageViewInfo src_view_info(ImageViewType::e2D, images.src_format, src_range);
     const auto [src_framebuffer_id, src_view_id] = RenderTargetFromImage(src_id, src_view_info);
-    const auto [dst_samples_x, dst_samples_y] = SamplesLog2(dst_image.info.num_samples);
-
-    const s32 dst_x0 = copy.dst_x0 >> dst_samples_x;
-    const s32 dst_x1 = copy.dst_x1 >> dst_samples_x;
-    const s32 dst_y0 = copy.dst_y0 >> dst_samples_y;
-    const s32 dst_y1 = copy.dst_y1 >> dst_samples_y;
-    const Region2D dst_dimensions{
-        Offset2D{.x = dst_x0, .y = dst_y0},
-        Offset2D{.x = dst_x1 - width_diff, .y = dst_y1},
+    const auto [src_samples_x, src_samples_y] = SamplesLog2(src_image.info.num_samples);
+    const Region2D src_region{
+        Offset2D{.x = copy.src_x0 >> src_samples_x, .y = copy.src_y0 >> src_samples_y},
+        Offset2D{.x = copy.src_x1 >> src_samples_x, .y = copy.src_y1 >> src_samples_y},
+    };
+
+    const std::optional dst_base = dst_image.TryFindBase(dst.Address());
+    const SubresourceRange dst_range{.base = dst_base.value(), .extent = {1, 1}};
+    const ImageViewInfo dst_view_info(ImageViewType::e2D, images.dst_format, dst_range);
+    const auto [dst_framebuffer_id, dst_view_id] = RenderTargetFromImage(dst_id, dst_view_info);
+    const auto [dst_samples_x, dst_samples_y] = SamplesLog2(dst_image.info.num_samples);
+    const Region2D dst_region{
+        Offset2D{.x = copy.dst_x0 >> dst_samples_x, .y = copy.dst_y0 >> dst_samples_y},
+        Offset2D{.x = copy.dst_x1 >> dst_samples_x, .y = copy.dst_y1 >> dst_samples_y},
     };
-    const auto dst_region = use_override ? *dst_override : dst_dimensions;
 
     // Always call this after src_framebuffer_id was queried, as the address might be invalidated.
     Framebuffer* const dst_framebuffer = &slot_framebuffers[dst_framebuffer_id];
@@ -775,21 +804,6 @@ void TextureCache<P>::BlitImage(const Tegra::Engines::Fermi2D::Surface& dst,
         runtime.BlitImage(dst_framebuffer, dst_view, src_view, dst_region, src_region, copy.filter,
                           copy.operation);
     }
-
-    if (width_oob) {
-        // Continue copy of the oob region of the texture on the next row
-        auto oob_src = src;
-        oob_src.height++;
-        const Region2D src_region_override{
-            Offset2D{.x = 0, .y = src_y0 + 1},
-            Offset2D{.x = width_diff, .y = src_y1 + 1},
-        };
-        const Region2D dst_region_override{
-            Offset2D{.x = dst_x1 - width_diff, .y = dst_y0},
-            Offset2D{.x = dst_x1, .y = dst_y1},
-        };
-        BlitImage(dst, oob_src, copy, src_region_override, dst_region_override);
-    }
 }
 
 template <class P>
@@ -833,9 +847,10 @@ typename P::ImageView* TextureCache<P>::TryFindFramebufferImageView(VAddr cpu_ad
     if (it == page_table.end()) {
         return nullptr;
     }
-    const auto& image_ids = it->second;
-    for (const ImageId image_id : image_ids) {
-        const ImageBase& image = slot_images[image_id];
+    const auto& image_map_ids = it->second;
+    for (const ImageMapId map_id : image_map_ids) {
+        const ImageMapView& map = slot_map_views[map_id];
+        const ImageBase& image = slot_images[map.image_id];
         if (image.cpu_addr != cpu_addr) {
             continue;
         }
@@ -915,13 +930,13 @@ bool TextureCache<P>::IsRegionGpuModified(VAddr addr, size_t size) {
 }
 
 template <class P>
-void TextureCache<P>::RefreshContents(Image& image) {
+void TextureCache<P>::RefreshContents(Image& image, ImageId image_id) {
     if (False(image.flags & ImageFlagBits::CpuModified)) {
         // Only upload modified images
         return;
     }
     image.flags &= ~ImageFlagBits::CpuModified;
-    TrackImage(image);
+    TrackImage(image, image_id);
 
     if (image.info.num_samples > 1) {
         LOG_WARNING(HW_GPU, "MSAA image uploads are not implemented");
@@ -958,7 +973,7 @@ void TextureCache<P>::UploadImageContents(Image& image, StagingBuffer& staging)
 
 template <class P>
 ImageViewId TextureCache<P>::FindImageView(const TICEntry& config) {
-    if (!IsValidAddress(gpu_memory, config)) {
+    if (!IsValidEntry(gpu_memory, config)) {
         return NULL_IMAGE_VIEW_ID;
     }
     const auto [pair, is_new] = image_views.try_emplace(config);
@@ -1000,14 +1015,20 @@ ImageId TextureCache<P>::FindOrInsertImage(const ImageInfo& info, GPUVAddr gpu_a
 template <class P>
 ImageId TextureCache<P>::FindImage(const ImageInfo& info, GPUVAddr gpu_addr,
                                    RelaxedOptions options) {
-    const std::optional<VAddr> cpu_addr = gpu_memory.GpuToCpuAddress(gpu_addr);
+    std::optional<VAddr> cpu_addr = gpu_memory.GpuToCpuAddress(gpu_addr);
     if (!cpu_addr) {
-        return ImageId{};
+        cpu_addr = gpu_memory.GpuToCpuAddress(gpu_addr, CalculateGuestSizeInBytes(info));
+        if (!cpu_addr) {
+            return ImageId{};
+        }
     }
     const bool broken_views = runtime.HasBrokenTextureViewFormats();
     const bool native_bgr = runtime.HasNativeBgr();
     ImageId image_id;
     const auto lambda = [&](ImageId existing_image_id, ImageBase& existing_image) {
+        if (True(existing_image.flags & ImageFlagBits::Remapped)) {
+            return false;
+        }
         if (info.type == ImageType::Linear || existing_image.info.type == ImageType::Linear) {
             const bool strict_size = False(options & RelaxedOptions::Size) &&
                                      True(existing_image.flags & ImageFlagBits::Strong);
@@ -1033,7 +1054,16 @@ ImageId TextureCache<P>::FindImage(const ImageInfo& info, GPUVAddr gpu_addr,
 template <class P>
 ImageId TextureCache<P>::InsertImage(const ImageInfo& info, GPUVAddr gpu_addr,
                                      RelaxedOptions options) {
-    const std::optional<VAddr> cpu_addr = gpu_memory.GpuToCpuAddress(gpu_addr);
+    std::optional<VAddr> cpu_addr = gpu_memory.GpuToCpuAddress(gpu_addr);
+    if (!cpu_addr) {
+        const auto size = CalculateGuestSizeInBytes(info);
+        cpu_addr = gpu_memory.GpuToCpuAddress(gpu_addr, size);
+        if (!cpu_addr) {
+            const VAddr fake_addr = ~(1ULL << 40ULL) + virtual_invalid_space;
+            virtual_invalid_space += Common::AlignUp(size, 32);
+            cpu_addr = std::optional<VAddr>(fake_addr);
+        }
+    }
     ASSERT_MSG(cpu_addr, "Tried to insert an image to an invalid gpu_addr=0x{:x}", gpu_addr);
     const ImageId image_id = JoinImages(info, gpu_addr, *cpu_addr);
     const Image& image = slot_images[image_id];
@@ -1053,10 +1083,16 @@ ImageId TextureCache<P>::JoinImages(const ImageInfo& info, GPUVAddr gpu_addr, VA
     const bool broken_views = runtime.HasBrokenTextureViewFormats();
     const bool native_bgr = runtime.HasNativeBgr();
     std::vector<ImageId> overlap_ids;
+    std::unordered_set<ImageId> overlaps_found;
     std::vector<ImageId> left_aliased_ids;
     std::vector<ImageId> right_aliased_ids;
+    std::unordered_set<ImageId> ignore_textures;
     std::vector<ImageId> bad_overlap_ids;
-    ForEachImageInRegion(cpu_addr, size_bytes, [&](ImageId overlap_id, ImageBase& overlap) {
+    const auto region_check = [&](ImageId overlap_id, ImageBase& overlap) {
+        if (True(overlap.flags & ImageFlagBits::Remapped)) {
+            ignore_textures.insert(overlap_id);
+            return;
+        }
         if (info.type == ImageType::Linear) {
             if (info.pitch == overlap.info.pitch && gpu_addr == overlap.gpu_addr) {
                 // Alias linear images with the same pitch
@@ -1064,6 +1100,7 @@ ImageId TextureCache<P>::JoinImages(const ImageInfo& info, GPUVAddr gpu_addr, VA
             }
             return;
         }
+        overlaps_found.insert(overlap_id);
         static constexpr bool strict_size = true;
         const std::optional<OverlapResult> solution = ResolveOverlap(
             new_info, gpu_addr, cpu_addr, overlap, strict_size, broken_views, native_bgr);
@@ -1087,12 +1124,40 @@ ImageId TextureCache<P>::JoinImages(const ImageInfo& info, GPUVAddr gpu_addr, VA
             bad_overlap_ids.push_back(overlap_id);
             overlap.flags |= ImageFlagBits::BadOverlap;
         }
-    });
+    };
+    ForEachImageInRegion(cpu_addr, size_bytes, region_check);
+    const auto region_check_gpu = [&](ImageId overlap_id, ImageBase& overlap) {
+        if (!overlaps_found.contains(overlap_id)) {
+            if (True(overlap.flags & ImageFlagBits::Remapped)) {
+                ignore_textures.insert(overlap_id);
+            }
+            if (overlap.gpu_addr == gpu_addr && overlap.guest_size_bytes == size_bytes) {
+                ignore_textures.insert(overlap_id);
+            }
+        }
+    };
+    ForEachSparseImageInRegion(gpu_addr, size_bytes, region_check_gpu);
     const ImageId new_image_id = slot_images.insert(runtime, new_info, gpu_addr, cpu_addr);
     Image& new_image = slot_images[new_image_id];
 
+    if (!gpu_memory.IsContinousRange(new_image.gpu_addr, new_image.guest_size_bytes)) {
+        new_image.flags |= ImageFlagBits::Sparse;
+    }
+
+    for (const ImageId overlap_id : ignore_textures) {
+        Image& overlap = slot_images[overlap_id];
+        if (True(overlap.flags & ImageFlagBits::GpuModified)) {
+            UNIMPLEMENTED();
+        }
+        if (True(overlap.flags & ImageFlagBits::Tracked)) {
+            UntrackImage(overlap, overlap_id);
+        }
+        UnregisterImage(overlap_id);
+        DeleteImage(overlap_id);
+    }
+
     // TODO: Only upload what we need
-    RefreshContents(new_image);
+    RefreshContents(new_image, new_image_id);
 
     for (const ImageId overlap_id : overlap_ids) {
         Image& overlap = slot_images[overlap_id];
@@ -1104,7 +1169,7 @@ ImageId TextureCache<P>::JoinImages(const ImageInfo& info, GPUVAddr gpu_addr, VA
             runtime.CopyImage(new_image, overlap, copies);
         }
         if (True(overlap.flags & ImageFlagBits::Tracked)) {
-            UntrackImage(overlap);
+            UntrackImage(overlap, overlap_id);
         }
         UnregisterImage(overlap_id);
         DeleteImage(overlap_id);
@@ -1239,7 +1304,8 @@ void TextureCache<P>::ForEachImageInRegion(VAddr cpu_addr, size_t size, Func&& f
     using FuncReturn = typename std::invoke_result<Func, ImageId, Image&>::type;
     static constexpr bool BOOL_BREAK = std::is_same_v<FuncReturn, bool>;
     boost::container::small_vector<ImageId, 32> images;
-    ForEachPage(cpu_addr, size, [this, &images, cpu_addr, size, func](u64 page) {
+    boost::container::small_vector<ImageMapId, 32> maps;
+    ForEachCPUPage(cpu_addr, size, [this, &images, &maps, cpu_addr, size, func](u64 page) {
         const auto it = page_table.find(page);
         if (it == page_table.end()) {
             if constexpr (BOOL_BREAK) {
@@ -1248,12 +1314,63 @@ void TextureCache<P>::ForEachImageInRegion(VAddr cpu_addr, size_t size, Func&& f
                 return;
             }
         }
+        for (const ImageMapId map_id : it->second) {
+            ImageMapView& map = slot_map_views[map_id];
+            if (map.picked) {
+                continue;
+            }
+            if (!map.Overlaps(cpu_addr, size)) {
+                continue;
+            }
+            map.picked = true;
+            maps.push_back(map_id);
+            Image& image = slot_images[map.image_id];
+            if (True(image.flags & ImageFlagBits::Picked)) {
+                continue;
+            }
+            image.flags |= ImageFlagBits::Picked;
+            images.push_back(map.image_id);
+            if constexpr (BOOL_BREAK) {
+                if (func(map.image_id, image)) {
+                    return true;
+                }
+            } else {
+                func(map.image_id, image);
+            }
+        }
+        if constexpr (BOOL_BREAK) {
+            return false;
+        }
+    });
+    for (const ImageId image_id : images) {
+        slot_images[image_id].flags &= ~ImageFlagBits::Picked;
+    }
+    for (const ImageMapId map_id : maps) {
+        slot_map_views[map_id].picked = false;
+    }
+}
+
+template <class P>
+template <typename Func>
+void TextureCache<P>::ForEachImageInRegionGPU(GPUVAddr gpu_addr, size_t size, Func&& func) {
+    using FuncReturn = typename std::invoke_result<Func, ImageId, Image&>::type;
+    static constexpr bool BOOL_BREAK = std::is_same_v<FuncReturn, bool>;
+    boost::container::small_vector<ImageId, 8> images;
+    ForEachGPUPage(gpu_addr, size, [this, &images, gpu_addr, size, func](u64 page) {
+        const auto it = gpu_page_table.find(page);
+        if (it == gpu_page_table.end()) {
+            if constexpr (BOOL_BREAK) {
+                return false;
+            } else {
+                return;
+            }
+        }
         for (const ImageId image_id : it->second) {
             Image& image = slot_images[image_id];
             if (True(image.flags & ImageFlagBits::Picked)) {
                 continue;
             }
-            if (!image.Overlaps(cpu_addr, size)) {
+            if (!image.OverlapsGPU(gpu_addr, size)) {
                 continue;
             }
             image.flags |= ImageFlagBits::Picked;
@@ -1275,6 +1392,69 @@ void TextureCache<P>::ForEachImageInRegion(VAddr cpu_addr, size_t size, Func&& f
     }
 }
 
+template <class P>
+template <typename Func>
+void TextureCache<P>::ForEachSparseImageInRegion(GPUVAddr gpu_addr, size_t size, Func&& func) {
+    using FuncReturn = typename std::invoke_result<Func, ImageId, Image&>::type;
+    static constexpr bool BOOL_BREAK = std::is_same_v<FuncReturn, bool>;
+    boost::container::small_vector<ImageId, 8> images;
+    ForEachGPUPage(gpu_addr, size, [this, &images, gpu_addr, size, func](u64 page) {
+        const auto it = sparse_page_table.find(page);
+        if (it == sparse_page_table.end()) {
+            if constexpr (BOOL_BREAK) {
+                return false;
+            } else {
+                return;
+            }
+        }
+        for (const ImageId image_id : it->second) {
+            Image& image = slot_images[image_id];
+            if (True(image.flags & ImageFlagBits::Picked)) {
+                continue;
+            }
+            if (!image.OverlapsGPU(gpu_addr, size)) {
+                continue;
+            }
+            image.flags |= ImageFlagBits::Picked;
+            images.push_back(image_id);
+            if constexpr (BOOL_BREAK) {
+                if (func(image_id, image)) {
+                    return true;
+                }
+            } else {
+                func(image_id, image);
+            }
+        }
+        if constexpr (BOOL_BREAK) {
+            return false;
+        }
+    });
+    for (const ImageId image_id : images) {
+        slot_images[image_id].flags &= ~ImageFlagBits::Picked;
+    }
+}
+
+template <class P>
+template <typename Func>
+void TextureCache<P>::ForEachSparseSegment(ImageBase& image, Func&& func) {
+    using FuncReturn = typename std::invoke_result<Func, GPUVAddr, VAddr, size_t>::type;
+    static constexpr bool RETURNS_BOOL = std::is_same_v<FuncReturn, bool>;
+    const auto segments = gpu_memory.GetSubmappedRange(image.gpu_addr, image.guest_size_bytes);
+    for (auto& segment : segments) {
+        const auto gpu_addr = segment.first;
+        const auto size = segment.second;
+        std::optional<VAddr> cpu_addr = gpu_memory.GpuToCpuAddress(gpu_addr);
+        ASSERT(cpu_addr);
+        if constexpr (RETURNS_BOOL) {
+            if (func(gpu_addr, *cpu_addr, size)) {
+                break;
+            }
+        } else {
+            func(gpu_addr, *cpu_addr, size);
+        }
+    }
+}
+
 template <class P>
 ImageViewId TextureCache<P>::FindOrEmplaceImageView(ImageId image_id, const ImageViewInfo& info) {
     Image& image = slot_images[image_id];
@@ -1292,8 +1472,6 @@ void TextureCache<P>::RegisterImage(ImageId image_id) {
     ASSERT_MSG(False(image.flags & ImageFlagBits::Registered),
                "Trying to register an already registered image");
     image.flags |= ImageFlagBits::Registered;
-    ForEachPage(image.cpu_addr, image.guest_size_bytes,
-                [this, image_id](u64 page) { page_table[page].push_back(image_id); });
     u64 tentative_size = std::max(image.guest_size_bytes, image.unswizzled_size_bytes);
     if ((IsPixelFormatASTC(image.info.format) &&
          True(image.flags & ImageFlagBits::AcceleratedUpload)) ||
@@ -1301,6 +1479,27 @@ void TextureCache<P>::RegisterImage(ImageId image_id) {
         tentative_size = EstimatedDecompressedSize(tentative_size, image.info.format);
     }
     total_used_memory += Common::AlignUp(tentative_size, 1024);
+    ForEachGPUPage(image.gpu_addr, image.guest_size_bytes,
+                   [this, image_id](u64 page) { gpu_page_table[page].push_back(image_id); });
+    if (False(image.flags & ImageFlagBits::Sparse)) {
+        auto map_id =
+            slot_map_views.insert(image.gpu_addr, image.cpu_addr, image.guest_size_bytes, image_id);
+        ForEachCPUPage(image.cpu_addr, image.guest_size_bytes,
+                       [this, map_id](u64 page) { page_table[page].push_back(map_id); });
+        image.map_view_id = map_id;
+        return;
+    }
+    std::vector<ImageViewId> sparse_maps{};
+    ForEachSparseSegment(
+        image, [this, image_id, &sparse_maps](GPUVAddr gpu_addr, VAddr cpu_addr, size_t size) {
+            auto map_id = slot_map_views.insert(gpu_addr, cpu_addr, size, image_id);
+            ForEachCPUPage(cpu_addr, size,
+                           [this, map_id](u64 page) { page_table[page].push_back(map_id); });
+            sparse_maps.push_back(map_id);
+        });
+    sparse_views.emplace(image_id, std::move(sparse_maps));
+    ForEachGPUPage(image.gpu_addr, image.guest_size_bytes,
+                   [this, image_id](u64 page) { sparse_page_table[page].push_back(image_id); });
 }
 
 template <class P>
@@ -1317,34 +1516,125 @@ void TextureCache<P>::UnregisterImage(ImageId image_id) {
         tentative_size = EstimatedDecompressedSize(tentative_size, image.info.format);
     }
     total_used_memory -= Common::AlignUp(tentative_size, 1024);
-    ForEachPage(image.cpu_addr, image.guest_size_bytes, [this, image_id](u64 page) {
-        const auto page_it = page_table.find(page);
-        if (page_it == page_table.end()) {
-            UNREACHABLE_MSG("Unregistering unregistered page=0x{:x}", page << PAGE_BITS);
-            return;
-        }
-        std::vector<ImageId>& image_ids = page_it->second;
-        const auto vector_it = std::ranges::find(image_ids, image_id);
-        if (vector_it == image_ids.end()) {
-            UNREACHABLE_MSG("Unregistering unregistered image in page=0x{:x}", page << PAGE_BITS);
-            return;
-        }
-        image_ids.erase(vector_it);
+    const auto& clear_page_table =
+        [this, image_id](
+            u64 page,
+            std::unordered_map<u64, std::vector<ImageId>, IdentityHash<u64>>& selected_page_table) {
+            const auto page_it = selected_page_table.find(page);
+            if (page_it == selected_page_table.end()) {
+                UNREACHABLE_MSG("Unregistering unregistered page=0x{:x}", page << PAGE_BITS);
+                return;
+            }
+            std::vector<ImageId>& image_ids = page_it->second;
+            const auto vector_it = std::ranges::find(image_ids, image_id);
+            if (vector_it == image_ids.end()) {
+                UNREACHABLE_MSG("Unregistering unregistered image in page=0x{:x}",
+                                page << PAGE_BITS);
+                return;
+            }
+            image_ids.erase(vector_it);
+        };
+    ForEachGPUPage(image.gpu_addr, image.guest_size_bytes,
+                   [this, &clear_page_table](u64 page) { clear_page_table(page, gpu_page_table); });
+    if (False(image.flags & ImageFlagBits::Sparse)) {
+        const auto map_id = image.map_view_id;
+        ForEachCPUPage(image.cpu_addr, image.guest_size_bytes, [this, map_id](u64 page) {
+            const auto page_it = page_table.find(page);
+            if (page_it == page_table.end()) {
+                UNREACHABLE_MSG("Unregistering unregistered page=0x{:x}", page << PAGE_BITS);
+                return;
+            }
+            std::vector<ImageMapId>& image_map_ids = page_it->second;
+            const auto vector_it = std::ranges::find(image_map_ids, map_id);
+            if (vector_it == image_map_ids.end()) {
+                UNREACHABLE_MSG("Unregistering unregistered image in page=0x{:x}",
+                                page << PAGE_BITS);
+                return;
+            }
+            image_map_ids.erase(vector_it);
+        });
+        slot_map_views.erase(map_id);
+        return;
+    }
+    ForEachGPUPage(image.gpu_addr, image.guest_size_bytes, [this, &clear_page_table](u64 page) {
+        clear_page_table(page, sparse_page_table);
     });
+    auto it = sparse_views.find(image_id);
+    ASSERT(it != sparse_views.end());
+    auto& sparse_maps = it->second;
+    for (auto& map_view_id : sparse_maps) {
+        const auto& map_range = slot_map_views[map_view_id];
+        const VAddr cpu_addr = map_range.cpu_addr;
+        const std::size_t size = map_range.size;
+        ForEachCPUPage(cpu_addr, size, [this, image_id](u64 page) {
+            const auto page_it = page_table.find(page);
+            if (page_it == page_table.end()) {
+                UNREACHABLE_MSG("Unregistering unregistered page=0x{:x}", page << PAGE_BITS);
+                return;
+            }
+            std::vector<ImageMapId>& image_map_ids = page_it->second;
+            auto vector_it = image_map_ids.begin();
+            while (vector_it != image_map_ids.end()) {
+                ImageMapView& map = slot_map_views[*vector_it];
+                if (map.image_id != image_id) {
+                    vector_it++;
+                    continue;
+                }
+                if (!map.picked) {
+                    map.picked = true;
+                }
+                vector_it = image_map_ids.erase(vector_it);
+            }
+        });
+        slot_map_views.erase(map_view_id);
+    }
+    sparse_views.erase(it);
 }
 
 template <class P>
-void TextureCache<P>::TrackImage(ImageBase& image) {
+void TextureCache<P>::TrackImage(ImageBase& image, ImageId image_id) {
     ASSERT(False(image.flags & ImageFlagBits::Tracked));
     image.flags |= ImageFlagBits::Tracked;
-    rasterizer.UpdatePagesCachedCount(image.cpu_addr, image.guest_size_bytes, 1);
+    if (False(image.flags & ImageFlagBits::Sparse)) {
+        rasterizer.UpdatePagesCachedCount(image.cpu_addr, image.guest_size_bytes, 1);
+        return;
+    }
+    if (True(image.flags & ImageFlagBits::Registered)) {
+        auto it = sparse_views.find(image_id);
+        ASSERT(it != sparse_views.end());
+        auto& sparse_maps = it->second;
+        for (auto& map_view_id : sparse_maps) {
+            const auto& map = slot_map_views[map_view_id];
+            const VAddr cpu_addr = map.cpu_addr;
+            const std::size_t size = map.size;
+            rasterizer.UpdatePagesCachedCount(cpu_addr, size, 1);
+        }
+        return;
+    }
+    ForEachSparseSegment(image,
+                         [this]([[maybe_unused]] GPUVAddr gpu_addr, VAddr cpu_addr, size_t size) {
+                             rasterizer.UpdatePagesCachedCount(cpu_addr, size, 1);
+                         });
 }
 
 template <class P>
-void TextureCache<P>::UntrackImage(ImageBase& image) {
+void TextureCache<P>::UntrackImage(ImageBase& image, ImageId image_id) {
     ASSERT(True(image.flags & ImageFlagBits::Tracked));
     image.flags &= ~ImageFlagBits::Tracked;
-    rasterizer.UpdatePagesCachedCount(image.cpu_addr, image.guest_size_bytes, -1);
+    if (False(image.flags & ImageFlagBits::Sparse)) {
+        rasterizer.UpdatePagesCachedCount(image.cpu_addr, image.guest_size_bytes, -1);
+        return;
+    }
+    ASSERT(True(image.flags & ImageFlagBits::Registered));
+    auto it = sparse_views.find(image_id);
+    ASSERT(it != sparse_views.end());
+    auto& sparse_maps = it->second;
+    for (auto& map_view_id : sparse_maps) {
+        const auto& map = slot_map_views[map_view_id];
+        const VAddr cpu_addr = map.cpu_addr;
+        const std::size_t size = map.size;
+        rasterizer.UpdatePagesCachedCount(cpu_addr, size, -1);
+    }
 }
 
 template <class P>
@@ -1486,10 +1776,10 @@ void TextureCache<P>::PrepareImage(ImageId image_id, bool is_modification, bool
     if (invalidate) {
         image.flags &= ~(ImageFlagBits::CpuModified | ImageFlagBits::GpuModified);
         if (False(image.flags & ImageFlagBits::Tracked)) {
-            TrackImage(image);
+            TrackImage(image, image_id);
         }
     } else {
-        RefreshContents(image);
+        RefreshContents(image, image_id);
         SynchronizeAliases(image_id);
     }
     if (is_modification) {

src/video_core/texture_cache/types.h

@@ -16,6 +16,7 @@ constexpr size_t MAX_MIP_LEVELS = 14;
 constexpr SlotId CORRUPT_ID{0xfffffffe};
 
 using ImageId = SlotId;
+using ImageMapId = SlotId;
 using ImageViewId = SlotId;
 using ImageAllocId = SlotId;
 using SamplerId = SlotId;
@@ -132,8 +133,8 @@ struct BufferImageCopy {
 };
 
 struct BufferCopy {
-    size_t src_offset;
-    size_t dst_offset;
+    u64 src_offset;
+    u64 dst_offset;
     size_t size;
 };
 

src/video_core/texture_cache/util.cpp

@@ -664,6 +664,16 @@ LevelArray CalculateMipLevelOffsets(const ImageInfo& info) noexcept {
     return offsets;
 }
 
+LevelArray CalculateMipLevelSizes(const ImageInfo& info) noexcept {
+    const u32 num_levels = info.resources.levels;
+    const LevelInfo level_info = MakeLevelInfo(info);
+    LevelArray sizes{};
+    for (u32 level = 0; level < num_levels; ++level) {
+        sizes[level] = CalculateLevelSize(level_info, level);
+    }
+    return sizes;
+}
+
 std::vector<u32> CalculateSliceOffsets(const ImageInfo& info) {
     ASSERT(info.type == ImageType::e3D);
     std::vector<u32> offsets;
@@ -776,14 +786,20 @@ std::vector<ImageCopy> MakeShrinkImageCopies(const ImageInfo& dst, const ImageIn
     return copies;
 }
 
-bool IsValidAddress(const Tegra::MemoryManager& gpu_memory, const TICEntry& config) {
-    if (config.Address() == 0) {
+bool IsValidEntry(const Tegra::MemoryManager& gpu_memory, const TICEntry& config) {
+    const GPUVAddr address = config.Address();
+    if (address == 0) {
         return false;
     }
-    if (config.Address() > (u64(1) << 48)) {
+    if (address > (1ULL << 48)) {
         return false;
     }
-    return gpu_memory.GpuToCpuAddress(config.Address()).has_value();
+    if (gpu_memory.GpuToCpuAddress(address).has_value()) {
+        return true;
+    }
+    const ImageInfo info{config};
+    const size_t guest_size_bytes = CalculateGuestSizeInBytes(info);
+    return gpu_memory.GpuToCpuAddress(address, guest_size_bytes).has_value();
 }
 
 std::vector<BufferImageCopy> UnswizzleImage(Tegra::MemoryManager& gpu_memory, GPUVAddr gpu_addr,

src/video_core/texture_cache/util.h

@@ -40,6 +40,8 @@ struct OverlapResult {
 
 [[nodiscard]] LevelArray CalculateMipLevelOffsets(const ImageInfo& info) noexcept;
 
+[[nodiscard]] LevelArray CalculateMipLevelSizes(const ImageInfo& info) noexcept;
+
 [[nodiscard]] std::vector<u32> CalculateSliceOffsets(const ImageInfo& info);
 
 [[nodiscard]] std::vector<SubresourceBase> CalculateSliceSubresources(const ImageInfo& info);
@@ -55,7 +57,7 @@ struct OverlapResult {
                                                            const ImageInfo& src,
                                                            SubresourceBase base);
 
-[[nodiscard]] bool IsValidAddress(const Tegra::MemoryManager& gpu_memory, const TICEntry& config);
+[[nodiscard]] bool IsValidEntry(const Tegra::MemoryManager& gpu_memory, const TICEntry& config);
 
 [[nodiscard]] std::vector<BufferImageCopy> UnswizzleImage(Tegra::MemoryManager& gpu_memory,
                                                           GPUVAddr gpu_addr, const ImageInfo& info,

src/yuzu/CMakeLists.txt

@@ -52,6 +52,9 @@ add_executable(yuzu
     configuration/configure_debug_controller.cpp
     configuration/configure_debug_controller.h
     configuration/configure_debug_controller.ui
+    configuration/configure_debug_tab.cpp
+    configuration/configure_debug_tab.h
+    configuration/configure_debug_tab.ui
     configuration/configure_dialog.cpp
     configuration/configure_dialog.h
     configuration/configure_filesystem.cpp

src/yuzu/configuration/config.h

@@ -102,28 +102,75 @@ private:
     void SaveUILayoutValues();
     void SaveWebServiceValues();
 
+    /**
+     * Reads a setting from the qt_config.
+     *
+     * @param name The setting's identifier
+     * @param default_value The value to use when the setting is not already present in the config
+     */
     QVariant ReadSetting(const QString& name) const;
     QVariant ReadSetting(const QString& name, const QVariant& default_value) const;
-    // Templated ReadSettingGlobal functions will also look for the use_global setting and set
-    // both the value and the global state properly
-    template <typename Type>
-    void ReadSettingGlobal(Settings::Setting<Type>& setting, const QString& name);
-    template <typename Type>
-    void ReadSettingGlobal(Settings::Setting<Type>& setting, const QString& name,
-                           const QVariant& default_value);
+
+    /**
+     * Only reads a setting from the qt_config if the current config is a global config, or if the
+     * current config is a custom config and the setting is overriding the global setting. Otherwise
+     * it does nothing.
+     *
+     * @param setting The variable to be modified
+     * @param name The setting's identifier
+     * @param default_value The value to use when the setting is not already present in the config
+     */
     template <typename Type>
     void ReadSettingGlobal(Type& setting, const QString& name, const QVariant& default_value) const;
-    // Templated WriteSettingGlobal functions will also write the global state if needed and will
-    // skip writing the actual setting if it defers to the global value
+
+    /**
+     * Writes a setting to the qt_config.
+     *
+     * @param name The setting's idetentifier
+     * @param value Value of the setting
+     * @param default_value Default of the setting if not present in qt_config
+     * @param use_global Specifies if the custom or global config should be in use, for custom
+     * configs
+     */
     void WriteSetting(const QString& name, const QVariant& value);
     void WriteSetting(const QString& name, const QVariant& value, const QVariant& default_value);
+    void WriteSetting(const QString& name, const QVariant& value, const QVariant& default_value,
+                      bool use_global);
+
+    /**
+     * Reads a value from the qt_config and applies it to the setting, using its label and default
+     * value. If the config is a custom config, this will also read the global state of the setting
+     * and apply that information to it.
+     *
+     * @param The setting
+     */
     template <typename Type>
-    void WriteSettingGlobal(const QString& name, const Settings::Setting<Type>& setting);
+    void ReadGlobalSetting(Settings::Setting<Type>& setting);
+
+    /**
+     * Sets a value to the qt_config using the setting's label and default value. If the config is a
+     * custom config, it will apply the global state, and the custom value if needed.
+     *
+     * @param The setting
+     */
     template <typename Type>
-    void WriteSettingGlobal(const QString& name, const Settings::Setting<Type>& setting,
-                            const QVariant& default_value);
-    void WriteSettingGlobal(const QString& name, const QVariant& value, bool use_global,
-                            const QVariant& default_value);
+    void WriteGlobalSetting(const Settings::Setting<Type>& setting);
+
+    /**
+     * Reads a value from the qt_config using the setting's label and default value and applies the
+     * value to the setting.
+     *
+     * @param The setting
+     */
+    template <typename Type>
+    void ReadBasicSetting(Settings::BasicSetting<Type>& setting);
+
+    /** Sets a value from the setting in the qt_config using the setting's label and default value.
+     *
+     * @param The setting
+     */
+    template <typename Type>
+    void WriteBasicSetting(const Settings::BasicSetting<Type>& setting);
 
     ConfigType type;
     std::unique_ptr<QSettings> qt_config;

src/yuzu/configuration/configure.ui

@@ -41,7 +41,7 @@
      <item>
       <widget class="QTabWidget" name="tabWidget">
        <property name="currentIndex">
-        <number>0</number>
+        <number>11</number>
        </property>
        <widget class="ConfigureGeneral" name="generalTab">
         <property name="accessibleName">
@@ -107,14 +107,6 @@
          <string>CPU</string>
         </attribute>
        </widget>
-       <widget class="ConfigureCpuDebug" name="cpuDebugTab">
-        <property name="accessibleName">
-         <string>Debug</string>
-        </property>
-        <attribute name="title">
-         <string>Debug</string>
-        </attribute>
-       </widget>
        <widget class="ConfigureGraphics" name="graphicsTab">
         <property name="accessibleName">
          <string>Graphics</string>
@@ -139,7 +131,7 @@
          <string>Audio</string>
         </attribute>
        </widget>
-       <widget class="ConfigureDebug" name="debugTab">
+       <widget class="ConfigureDebugTab" name="debugTab">
         <property name="accessibleName">
          <string>Debug</string>
         </property>
@@ -207,24 +199,12 @@
    <header>configuration/configure_audio.h</header>
    <container>1</container>
   </customwidget>
-  <customwidget>
-   <class>ConfigureDebug</class>
-   <extends>QWidget</extends>
-   <header>configuration/configure_debug.h</header>
-   <container>1</container>
-  </customwidget>
   <customwidget>
    <class>ConfigureCpu</class>
    <extends>QWidget</extends>
    <header>configuration/configure_cpu.h</header>
    <container>1</container>
   </customwidget>
-  <customwidget>
-   <class>ConfigureCpuDebug</class>
-   <extends>QWidget</extends>
-   <header>configuration/configure_cpu_debug.h</header>
-   <container>1</container>
-  </customwidget>
   <customwidget>
    <class>ConfigureGraphics</class>
    <extends>QWidget</extends>
@@ -267,6 +247,12 @@
    <header>configuration/configure_service.h</header>
    <container>1</container>
   </customwidget>
+  <customwidget>
+   <class>ConfigureDebugTab</class>
+   <extends>QWidget</extends>
+   <header>configuration/configure_debug_tab.h</header>
+   <container>1</container>
+  </customwidget>
  </customwidgets>
  <resources/>
  <connections>
@@ -275,12 +261,32 @@
    <signal>accepted()</signal>
    <receiver>ConfigureDialog</receiver>
    <slot>accept()</slot>
+   <hints>
+    <hint type="sourcelabel">
+     <x>20</x>
+     <y>20</y>
+    </hint>
+    <hint type="destinationlabel">
+     <x>20</x>
+     <y>20</y>
+    </hint>
+   </hints>
   </connection>
   <connection>
    <sender>buttonBox</sender>
    <signal>rejected()</signal>
    <receiver>ConfigureDialog</receiver>
    <slot>reject()</slot>
+   <hints>
+    <hint type="sourcelabel">
+     <x>20</x>
+     <y>20</y>
+    </hint>
+    <hint type="destinationlabel">
+     <x>20</x>
+     <y>20</y>
+    </hint>
+   </hints>
   </connection>
  </connections>
 </ui>

src/yuzu/configuration/configure_audio.cpp

@@ -69,7 +69,7 @@ void ConfigureAudio::SetOutputSinkFromSinkID() {
     [[maybe_unused]] const QSignalBlocker blocker(ui->output_sink_combo_box);
 
     int new_sink_index = 0;
-    const QString sink_id = QString::fromStdString(Settings::values.sink_id);
+    const QString sink_id = QString::fromStdString(Settings::values.sink_id.GetValue());
     for (int index = 0; index < ui->output_sink_combo_box->count(); index++) {
         if (ui->output_sink_combo_box->itemText(index) == sink_id) {
             new_sink_index = index;
@@ -83,7 +83,7 @@ void ConfigureAudio::SetOutputSinkFromSinkID() {
 void ConfigureAudio::SetAudioDeviceFromDeviceID() {
     int new_device_index = -1;
 
-    const QString device_id = QString::fromStdString(Settings::values.audio_device_id);
+    const QString device_id = QString::fromStdString(Settings::values.audio_device_id.GetValue());
     for (int index = 0; index < ui->audio_device_combo_box->count(); index++) {
         if (ui->audio_device_combo_box->itemText(index) == device_id) {
             new_device_index = index;
@@ -106,9 +106,9 @@ void ConfigureAudio::ApplyConfiguration() {
         Settings::values.sink_id =
             ui->output_sink_combo_box->itemText(ui->output_sink_combo_box->currentIndex())
                 .toStdString();
-        Settings::values.audio_device_id =
+        Settings::values.audio_device_id.SetValue(
             ui->audio_device_combo_box->itemText(ui->audio_device_combo_box->currentIndex())
-                .toStdString();
+                .toStdString());
 
         // Guard if during game and set to game-specific value
         if (Settings::values.volume.UsingGlobal()) {

src/yuzu/configuration/configure_cpu.cpp

@@ -20,8 +20,6 @@ ConfigureCpu::ConfigureCpu(QWidget* parent) : QWidget(parent), ui(new Ui::Config
 
     SetConfiguration();
 
-    connect(ui->accuracy, qOverload<int>(&QComboBox::activated), this,
-            &ConfigureCpu::AccuracyUpdated);
     connect(ui->accuracy, qOverload<int>(&QComboBox::currentIndexChanged), this,
             &ConfigureCpu::UpdateGroup);
 }
@@ -58,20 +56,6 @@ void ConfigureCpu::SetConfiguration() {
     UpdateGroup(ui->accuracy->currentIndex());
 }
 
-void ConfigureCpu::AccuracyUpdated(int index) {
-    if (Settings::IsConfiguringGlobal() &&
-        static_cast<Settings::CPUAccuracy>(index) == Settings::CPUAccuracy::DebugMode) {
-        const auto result = QMessageBox::warning(this, tr("Setting CPU to Debug Mode"),
-                                                 tr("CPU Debug Mode is only intended for developer "
-                                                    "use. Are you sure you want to enable this?"),
-                                                 QMessageBox::Yes | QMessageBox::No);
-        if (result == QMessageBox::No) {
-            ui->accuracy->setCurrentIndex(static_cast<int>(Settings::CPUAccuracy::Accurate));
-            UpdateGroup(static_cast<int>(Settings::CPUAccuracy::Accurate));
-        }
-    }
-}
-
 void ConfigureCpu::UpdateGroup(int index) {
     if (!Settings::IsConfiguringGlobal()) {
         index -= ConfigurationShared::USE_GLOBAL_OFFSET;
@@ -134,8 +118,6 @@ void ConfigureCpu::SetupPerGameUI() {
     ConfigurationShared::SetColoredComboBox(
         ui->accuracy, ui->widget_accuracy,
         static_cast<u32>(Settings::values.cpu_accuracy.GetValue(true)));
-    ui->accuracy->removeItem(static_cast<u32>(Settings::CPUAccuracy::DebugMode) +
-                             ConfigurationShared::USE_GLOBAL_OFFSET);
 
     ConfigurationShared::SetColoredTristate(ui->cpuopt_unsafe_unfuse_fma,
                                             Settings::values.cpuopt_unsafe_unfuse_fma,

src/yuzu/configuration/configure_cpu.h

@@ -29,7 +29,6 @@ private:
     void changeEvent(QEvent* event) override;
     void RetranslateUI();
 
-    void AccuracyUpdated(int index);
     void UpdateGroup(int index);
 
     void SetConfiguration();

src/yuzu/configuration/configure_cpu.ui

@@ -6,8 +6,8 @@
    <rect>
     <x>0</x>
     <y>0</y>
-    <width>400</width>
-    <height>321</height>
+    <width>448</width>
+    <height>433</height>
    </rect>
   </property>
   <property name="windowTitle">
@@ -17,7 +17,7 @@
    <item>
     <layout class="QVBoxLayout">
      <item>
-      <widget class="QGroupBox">
+      <widget class="QGroupBox" name="groupBox">
        <property name="title">
         <string>General</string>
        </property>
@@ -34,6 +34,11 @@
            </item>
            <item>
             <widget class="QComboBox" name="accuracy">
+             <item>
+              <property name="text">
+               <string>Auto</string>
+              </property>
+             </item>
              <item>
               <property name="text">
                <string>Accurate</string>
@@ -44,11 +49,6 @@
                <string>Unsafe</string>
               </property>
              </item>
-             <item>
-              <property name="text">
-               <string>Enable Debug Mode</string>
-              </property>
-             </item>
             </widget>
            </item>
           </layout>
@@ -57,7 +57,7 @@
         <item>
          <widget class="QLabel" name="label_recommended_accuracy">
           <property name="text">
-           <string>We recommend setting accuracy to &quot;Accurate&quot;.</string>
+           <string>We recommend setting accuracy to &quot;Auto&quot;.</string>
           </property>
           <property name="wordWrap">
            <bool>false</bool>

src/yuzu/configuration/configure_cpu_debug.cpp

@@ -24,23 +24,26 @@ void ConfigureCpuDebug::SetConfiguration() {
     const bool runtime_lock = !Core::System::GetInstance().IsPoweredOn();
 
     ui->cpuopt_page_tables->setEnabled(runtime_lock);
-    ui->cpuopt_page_tables->setChecked(Settings::values.cpuopt_page_tables);
+    ui->cpuopt_page_tables->setChecked(Settings::values.cpuopt_page_tables.GetValue());
     ui->cpuopt_block_linking->setEnabled(runtime_lock);
-    ui->cpuopt_block_linking->setChecked(Settings::values.cpuopt_block_linking);
+    ui->cpuopt_block_linking->setChecked(Settings::values.cpuopt_block_linking.GetValue());
     ui->cpuopt_return_stack_buffer->setEnabled(runtime_lock);
-    ui->cpuopt_return_stack_buffer->setChecked(Settings::values.cpuopt_return_stack_buffer);
+    ui->cpuopt_return_stack_buffer->setChecked(
+        Settings::values.cpuopt_return_stack_buffer.GetValue());
     ui->cpuopt_fast_dispatcher->setEnabled(runtime_lock);
-    ui->cpuopt_fast_dispatcher->setChecked(Settings::values.cpuopt_fast_dispatcher);
+    ui->cpuopt_fast_dispatcher->setChecked(Settings::values.cpuopt_fast_dispatcher.GetValue());
     ui->cpuopt_context_elimination->setEnabled(runtime_lock);
-    ui->cpuopt_context_elimination->setChecked(Settings::values.cpuopt_context_elimination);
+    ui->cpuopt_context_elimination->setChecked(
+        Settings::values.cpuopt_context_elimination.GetValue());
     ui->cpuopt_const_prop->setEnabled(runtime_lock);
-    ui->cpuopt_const_prop->setChecked(Settings::values.cpuopt_const_prop);
+    ui->cpuopt_const_prop->setChecked(Settings::values.cpuopt_const_prop.GetValue());
     ui->cpuopt_misc_ir->setEnabled(runtime_lock);
-    ui->cpuopt_misc_ir->setChecked(Settings::values.cpuopt_misc_ir);
+    ui->cpuopt_misc_ir->setChecked(Settings::values.cpuopt_misc_ir.GetValue());
     ui->cpuopt_reduce_misalign_checks->setEnabled(runtime_lock);
-    ui->cpuopt_reduce_misalign_checks->setChecked(Settings::values.cpuopt_reduce_misalign_checks);
+    ui->cpuopt_reduce_misalign_checks->setChecked(
+        Settings::values.cpuopt_reduce_misalign_checks.GetValue());
     ui->cpuopt_fastmem->setEnabled(runtime_lock);
-    ui->cpuopt_fastmem->setChecked(Settings::values.cpuopt_fastmem);
+    ui->cpuopt_fastmem->setChecked(Settings::values.cpuopt_fastmem.GetValue());
 }
 
 void ConfigureCpuDebug::ApplyConfiguration() {

src/yuzu/configuration/configure_cpu_debug.h

@@ -6,7 +6,6 @@
 
 #include <memory>
 #include <QWidget>
-#include "common/settings.h"
 
 namespace Ui {
 class ConfigureCpuDebug;

src/yuzu/configuration/configure_cpu_debug.ui

@@ -6,8 +6,8 @@
    <rect>
     <x>0</x>
     <y>0</y>
-    <width>400</width>
-    <height>321</height>
+    <width>592</width>
+    <height>503</height>
    </rect>
   </property>
   <property name="windowTitle">
@@ -17,140 +17,132 @@
    <item>
     <layout class="QVBoxLayout">
      <item>
-      <widget class="QGroupBox">
+      <widget class="QGroupBox" name="groupBox">
        <property name="title">
         <string>Toggle CPU Optimizations</string>
        </property>
        <layout class="QVBoxLayout">
         <item>
-         <widget class="QLabel">
-          <property name="wordWrap">
-            <bool>1</bool>
-          </property>
+         <widget class="QLabel" name="label">
           <property name="text">
-           <string>
-            &lt;div&gt;
-            &lt;b&gt;For debugging only.&lt;/b&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 Accuracy is "Debug Mode".
-            &lt;/div&gt;
-           </string>
+           <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>
           </property>
          </widget>
         </item>
         <item>
          <widget class="QCheckBox" name="cpuopt_page_tables">
-          <property name="text">
-           <string>Enable inline page tables</string>
-          </property>
           <property name="toolTip">
            <string>
-            &lt;div style="white-space: nowrap"&gt;This optimization speeds up memory accesses by the guest program.&lt;/div&gt;
-            &lt;div style="white-space: nowrap"&gt;Enabling it inlines accesses to PageTable::pointers into emitted code.&lt;/div&gt;
-            &lt;div style="white-space: nowrap"&gt;Disabling this forces all memory accesses to go through the Memory::Read/Memory::Write functions.&lt;/div&gt;
+            &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;
            </string>
           </property>
+          <property name="text">
+           <string>Enable inline page tables</string>
+          </property>
          </widget>
         </item>
         <item>
          <widget class="QCheckBox" name="cpuopt_block_linking">
-          <property name="text">
-           <string>Enable block linking</string>
-          </property>
           <property name="toolTip">
            <string>
             &lt;div&gt;This optimization avoids dispatcher lookups by allowing emitted basic blocks to jump directly to other basic blocks if the destination PC is static.&lt;/div&gt;
            </string>
           </property>
+          <property name="text">
+           <string>Enable block linking</string>
+          </property>
          </widget>
         </item>
         <item>
          <widget class="QCheckBox" name="cpuopt_return_stack_buffer">
-          <property name="text">
-           <string>Enable return stack buffer</string>
-          </property>
           <property name="toolTip">
            <string>
             &lt;div&gt;This optimization avoids dispatcher lookups by keeping track potential return addresses of BL instructions. This approximates what happens with a return stack buffer on a real CPU.&lt;/div&gt;
            </string>
           </property>
+          <property name="text">
+           <string>Enable return stack buffer</string>
+          </property>
          </widget>
         </item>
         <item>
          <widget class="QCheckBox" name="cpuopt_fast_dispatcher">
-          <property name="text">
-           <string>Enable fast dispatcher</string>
-          </property>
           <property name="toolTip">
            <string>
             &lt;div&gt;Enable a two-tiered dispatch system. A faster dispatcher written in assembly has a small MRU cache of jump destinations is used first. If that fails, dispatch falls back to the slower C++ dispatcher.&lt;/div&gt;
            </string>
           </property>
+          <property name="text">
+           <string>Enable fast dispatcher</string>
+          </property>
          </widget>
         </item>
         <item>
          <widget class="QCheckBox" name="cpuopt_context_elimination">
-          <property name="text">
-           <string>Enable context elimination</string>
-          </property>
           <property name="toolTip">
            <string>
             &lt;div&gt;Enables an IR optimization that reduces unnecessary accesses to the CPU context structure.&lt;/div&gt;
            </string>
           </property>
+          <property name="text">
+           <string>Enable context elimination</string>
+          </property>
          </widget>
         </item>
         <item>
          <widget class="QCheckBox" name="cpuopt_const_prop">
-          <property name="text">
-           <string>Enable constant propagation</string>
-          </property>
           <property name="toolTip">
            <string>
             &lt;div&gt;Enables IR optimizations that involve constant propagation.&lt;/div&gt;
            </string>
           </property>
+          <property name="text">
+           <string>Enable constant propagation</string>
+          </property>
          </widget>
         </item>
         <item>
          <widget class="QCheckBox" name="cpuopt_misc_ir">
-          <property name="text">
-           <string>Enable miscellaneous optimizations</string>
-          </property>
           <property name="toolTip">
            <string>
             &lt;div&gt;Enables miscellaneous IR optimizations.&lt;/div&gt;
            </string>
           </property>
+          <property name="text">
+           <string>Enable miscellaneous optimizations</string>
+          </property>
          </widget>
         </item>
         <item>
          <widget class="QCheckBox" name="cpuopt_reduce_misalign_checks">
-          <property name="text">
-           <string>Enable misalignment check reduction</string>
-          </property>
           <property name="toolTip">
            <string>
-            &lt;div style="white-space: nowrap"&gt;When enabled, a misalignment is only triggered when an access crosses a page boundary.&lt;/div&gt;
-            &lt;div style="white-space: nowrap"&gt;When disabled, a misalignment is triggered on all misaligned accesses.&lt;/div&gt;
+            &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;
            </string>
           </property>
+          <property name="text">
+           <string>Enable misalignment check reduction</string>
+          </property>
          </widget>
         </item>
         <item>
          <widget class="QCheckBox" name="cpuopt_fastmem">
-          <property name="text">
-           <string>Enable Host MMU Emulation</string>
-          </property>
           <property name="toolTip">
            <string>
-            &lt;div style="white-space: nowrap"&gt;This optimization speeds up memory accesses by the guest program.&lt;/div&gt;
-            &lt;div style="white-space: nowrap"&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="white-space: nowrap"&gt;Disabling this forces all memory accesses to use Software MMU Emulation.&lt;/div&gt;
+            &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;
            </string>
           </property>
+          <property name="text">
+           <string>Enable Host MMU Emulation</string>
+          </property>
          </widget>
         </item>
        </layout>

src/yuzu/configuration/configure_debug.cpp

@@ -31,20 +31,23 @@ void ConfigureDebug::SetConfiguration() {
     const bool runtime_lock = !Core::System::GetInstance().IsPoweredOn();
 
     ui->toggle_console->setEnabled(runtime_lock);
-    ui->toggle_console->setChecked(UISettings::values.show_console);
-    ui->log_filter_edit->setText(QString::fromStdString(Settings::values.log_filter));
-    ui->homebrew_args_edit->setText(QString::fromStdString(Settings::values.program_args));
+    ui->toggle_console->setChecked(UISettings::values.show_console.GetValue());
+    ui->log_filter_edit->setText(QString::fromStdString(Settings::values.log_filter.GetValue()));
+    ui->homebrew_args_edit->setText(
+        QString::fromStdString(Settings::values.program_args.GetValue()));
     ui->fs_access_log->setEnabled(runtime_lock);
-    ui->fs_access_log->setChecked(Settings::values.enable_fs_access_log);
-    ui->reporting_services->setChecked(Settings::values.reporting_services);
-    ui->quest_flag->setChecked(Settings::values.quest_flag);
-    ui->use_debug_asserts->setChecked(Settings::values.use_debug_asserts);
-    ui->use_auto_stub->setChecked(Settings::values.use_auto_stub);
+    ui->fs_access_log->setChecked(Settings::values.enable_fs_access_log.GetValue());
+    ui->reporting_services->setChecked(Settings::values.reporting_services.GetValue());
+    ui->quest_flag->setChecked(Settings::values.quest_flag.GetValue());
+    ui->use_debug_asserts->setChecked(Settings::values.use_debug_asserts.GetValue());
+    ui->use_auto_stub->setChecked(Settings::values.use_auto_stub.GetValue());
     ui->enable_graphics_debugging->setEnabled(runtime_lock);
-    ui->enable_graphics_debugging->setChecked(Settings::values.renderer_debug);
+    ui->enable_graphics_debugging->setChecked(Settings::values.renderer_debug.GetValue());
+    ui->enable_cpu_debugging->setEnabled(runtime_lock);
+    ui->enable_cpu_debugging->setChecked(Settings::values.cpu_debug_mode.GetValue());
     ui->disable_macro_jit->setEnabled(runtime_lock);
-    ui->disable_macro_jit->setChecked(Settings::values.disable_macro_jit);
-    ui->extended_logging->setChecked(Settings::values.extended_logging);
+    ui->disable_macro_jit->setChecked(Settings::values.disable_macro_jit.GetValue());
+    ui->extended_logging->setChecked(Settings::values.extended_logging.GetValue());
 }
 
 void ConfigureDebug::ApplyConfiguration() {
@@ -57,11 +60,12 @@ void ConfigureDebug::ApplyConfiguration() {
     Settings::values.use_debug_asserts = ui->use_debug_asserts->isChecked();
     Settings::values.use_auto_stub = ui->use_auto_stub->isChecked();
     Settings::values.renderer_debug = ui->enable_graphics_debugging->isChecked();
+    Settings::values.cpu_debug_mode = ui->enable_cpu_debugging->isChecked();
     Settings::values.disable_macro_jit = ui->disable_macro_jit->isChecked();
     Settings::values.extended_logging = ui->extended_logging->isChecked();
     Debugger::ToggleConsole();
     Common::Log::Filter filter;
-    filter.ParseFilterString(Settings::values.log_filter);
+    filter.ParseFilterString(Settings::values.log_filter.GetValue());
     Common::Log::SetGlobalFilter(filter);
 }
 

src/yuzu/configuration/configure_debug.ui

@@ -7,7 +7,7 @@
     <x>0</x>
     <y>0</y>
     <width>400</width>
-    <height>486</height>
+    <height>777</height>
    </rect>
   </property>
   <property name="windowTitle">
@@ -192,34 +192,41 @@
         </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>
+       <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>
       </item>
      </layout>
     </widget>

src/yuzu/configuration/configure_debug_tab.cpp

@@ -0,0 +1,38 @@
+// 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() {}

src/yuzu/configuration/configure_debug_tab.h

@@ -0,0 +1,32 @@
+// 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;
+};

src/yuzu/configuration/configure_debug_tab.ui

@@ -0,0 +1,52 @@
+<?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>

src/yuzu/configuration/configure_dialog.cpp

@@ -8,6 +8,7 @@
 #include <QListWidgetItem>
 #include <QPushButton>
 #include <QSignalBlocker>
+#include <QTabWidget>
 #include "common/settings.h"
 #include "core/core.h"
 #include "ui_configure.h"
@@ -32,6 +33,8 @@ ConfigureDialog::ConfigureDialog(QWidget* parent, HotkeyRegistry& registry,
     SetConfiguration();
     PopulateSelectionList();
 
+    connect(ui->tabWidget, &QTabWidget::currentChanged, this,
+            [this]() { ui->debugTab->SetCurrentIndex(0); });
     connect(ui->uiTab, &ConfigureUi::LanguageChanged, this, &ConfigureDialog::OnLanguageChanged);
     connect(ui->selectorList, &QListWidget::itemSelectionChanged, this,
             &ConfigureDialog::UpdateVisibleTabs);
@@ -59,7 +62,6 @@ void ConfigureDialog::ApplyConfiguration() {
     ui->inputTab->ApplyConfiguration();
     ui->hotkeysTab->ApplyConfiguration(registry);
     ui->cpuTab->ApplyConfiguration();
-    ui->cpuDebugTab->ApplyConfiguration();
     ui->graphicsTab->ApplyConfiguration();
     ui->graphicsAdvancedTab->ApplyConfiguration();
     ui->audioTab->ApplyConfiguration();
@@ -102,7 +104,7 @@ void ConfigureDialog::PopulateSelectionList() {
     const std::array<std::pair<QString, QList<QWidget*>>, 6> items{
         {{tr("General"), {ui->generalTab, ui->hotkeysTab, ui->uiTab, ui->webTab, ui->debugTab}},
          {tr("System"), {ui->systemTab, ui->profileManagerTab, ui->serviceTab, ui->filesystemTab}},
-         {tr("CPU"), {ui->cpuTab, ui->cpuDebugTab}},
+         {tr("CPU"), {ui->cpuTab}},
          {tr("Graphics"), {ui->graphicsTab, ui->graphicsAdvancedTab}},
          {tr("Audio"), {ui->audioTab}},
          {tr("Controls"), ui->inputTab->GetSubTabs()}},

src/yuzu/configuration/configure_filesystem.cpp

@@ -43,18 +43,19 @@ void ConfigureFilesystem::setConfiguration() {
         QString::fromStdString(Common::FS::GetYuzuPathString(Common::FS::YuzuPath::NANDDir)));
     ui->sdmc_directory_edit->setText(
         QString::fromStdString(Common::FS::GetYuzuPathString(Common::FS::YuzuPath::SDMCDir)));
-    ui->gamecard_path_edit->setText(QString::fromStdString(Settings::values.gamecard_path));
+    ui->gamecard_path_edit->setText(
+        QString::fromStdString(Settings::values.gamecard_path.GetValue()));
     ui->dump_path_edit->setText(
         QString::fromStdString(Common::FS::GetYuzuPathString(Common::FS::YuzuPath::DumpDir)));
     ui->load_path_edit->setText(
         QString::fromStdString(Common::FS::GetYuzuPathString(Common::FS::YuzuPath::LoadDir)));
 
-    ui->gamecard_inserted->setChecked(Settings::values.gamecard_inserted);
-    ui->gamecard_current_game->setChecked(Settings::values.gamecard_current_game);
-    ui->dump_exefs->setChecked(Settings::values.dump_exefs);
-    ui->dump_nso->setChecked(Settings::values.dump_nso);
+    ui->gamecard_inserted->setChecked(Settings::values.gamecard_inserted.GetValue());
+    ui->gamecard_current_game->setChecked(Settings::values.gamecard_current_game.GetValue());
+    ui->dump_exefs->setChecked(Settings::values.dump_exefs.GetValue());
+    ui->dump_nso->setChecked(Settings::values.dump_nso.GetValue());
 
-    ui->cache_game_list->setChecked(UISettings::values.cache_game_list);
+    ui->cache_game_list->setChecked(UISettings::values.cache_game_list.GetValue());
 
     UpdateEnabledControls();
 }

src/yuzu/configuration/configure_general.cpp

@@ -40,10 +40,10 @@ void ConfigureGeneral::SetConfiguration() {
     ui->use_multi_core->setEnabled(runtime_lock);
     ui->use_multi_core->setChecked(Settings::values.use_multi_core.GetValue());
 
-    ui->toggle_check_exit->setChecked(UISettings::values.confirm_before_closing);
-    ui->toggle_user_on_boot->setChecked(UISettings::values.select_user_on_boot);
-    ui->toggle_background_pause->setChecked(UISettings::values.pause_when_in_background);
-    ui->toggle_hide_mouse->setChecked(UISettings::values.hide_mouse);
+    ui->toggle_check_exit->setChecked(UISettings::values.confirm_before_closing.GetValue());
+    ui->toggle_user_on_boot->setChecked(UISettings::values.select_user_on_boot.GetValue());
+    ui->toggle_background_pause->setChecked(UISettings::values.pause_when_in_background.GetValue());
+    ui->toggle_hide_mouse->setChecked(UISettings::values.hide_mouse.GetValue());
 
     ui->toggle_frame_limit->setChecked(Settings::values.use_frame_limit.GetValue());
     ui->frame_limit->setValue(Settings::values.frame_limit.GetValue());

src/yuzu/configuration/configure_input_advanced.cpp

@@ -148,12 +148,12 @@ void ConfigureInputAdvanced::LoadConfiguration() {
         }
     }
 
-    ui->debug_enabled->setChecked(Settings::values.debug_pad_enabled);
-    ui->mouse_enabled->setChecked(Settings::values.mouse_enabled);
-    ui->keyboard_enabled->setChecked(Settings::values.keyboard_enabled);
-    ui->emulate_analog_keyboard->setChecked(Settings::values.emulate_analog_keyboard);
-    ui->mouse_panning->setChecked(Settings::values.mouse_panning);
-    ui->mouse_panning_sensitivity->setValue(Settings::values.mouse_panning_sensitivity);
+    ui->debug_enabled->setChecked(Settings::values.debug_pad_enabled.GetValue());
+    ui->mouse_enabled->setChecked(Settings::values.mouse_enabled.GetValue());
+    ui->keyboard_enabled->setChecked(Settings::values.keyboard_enabled.GetValue());
+    ui->emulate_analog_keyboard->setChecked(Settings::values.emulate_analog_keyboard.GetValue());
+    ui->mouse_panning->setChecked(Settings::values.mouse_panning.GetValue());
+    ui->mouse_panning_sensitivity->setValue(Settings::values.mouse_panning_sensitivity.GetValue());
     ui->touchscreen_enabled->setChecked(Settings::values.touchscreen.enabled);
 
     UpdateUIEnabled();

src/yuzu/configuration/configure_motion_touch.cpp

@@ -101,15 +101,16 @@ ConfigureMotionTouch::ConfigureMotionTouch(QWidget* parent,
 ConfigureMotionTouch::~ConfigureMotionTouch() = default;
 
 void ConfigureMotionTouch::SetConfiguration() {
-    const Common::ParamPackage motion_param(Settings::values.motion_device);
-    const Common::ParamPackage touch_param(Settings::values.touch_device);
+    const Common::ParamPackage motion_param(Settings::values.motion_device.GetValue());
+    const Common::ParamPackage touch_param(Settings::values.touch_device.GetValue());
 
-    ui->touch_from_button_checkbox->setChecked(Settings::values.use_touch_from_button);
+    ui->touch_from_button_checkbox->setChecked(Settings::values.use_touch_from_button.GetValue());
     touch_from_button_maps = Settings::values.touch_from_button_maps;
     for (const auto& touch_map : touch_from_button_maps) {
         ui->touch_from_button_map->addItem(QString::fromStdString(touch_map.name));
     }
-    ui->touch_from_button_map->setCurrentIndex(Settings::values.touch_from_button_map_index);
+    ui->touch_from_button_map->setCurrentIndex(
+        Settings::values.touch_from_button_map_index.GetValue());
     ui->motion_sensitivity->setValue(motion_param.Get("sensitivity", 0.01f));
 
     min_x = touch_param.Get("min_x", 100);
@@ -124,7 +125,7 @@ void ConfigureMotionTouch::SetConfiguration() {
     udp_server_list_model->setStringList({});
     ui->udp_server_list->setModel(udp_server_list_model);
 
-    std::stringstream ss(Settings::values.udp_input_servers);
+    std::stringstream ss(Settings::values.udp_input_servers.GetValue());
     std::string token;
 
     while (std::getline(ss, token, ',')) {

src/yuzu/configuration/configure_profile_manager.cpp

@@ -166,7 +166,7 @@ void ConfigureProfileManager::PopulateUserList() {
 void ConfigureProfileManager::UpdateCurrentUser() {
     ui->pm_add->setEnabled(profile_manager->GetUserCount() < Service::Account::MAX_USERS);
 
-    const auto& current_user = profile_manager->GetUser(Settings::values.current_user);
+    const auto& current_user = profile_manager->GetUser(Settings::values.current_user.GetValue());
     ASSERT(current_user);
     const auto username = GetAccountUsername(*profile_manager, *current_user);
 
@@ -245,15 +245,18 @@ void ConfigureProfileManager::DeleteUser() {
         this, tr("Confirm Delete"),
         tr("You are about to delete user with name \"%1\". Are you sure?").arg(username));
 
-    if (confirm == QMessageBox::No)
+    if (confirm == QMessageBox::No) {
         return;
+    }
 
-    if (Settings::values.current_user == tree_view->currentIndex().row())
+    if (Settings::values.current_user.GetValue() == tree_view->currentIndex().row()) {
         Settings::values.current_user = 0;
+    }
     UpdateCurrentUser();
 
-    if (!profile_manager->RemoveUser(*uuid))
+    if (!profile_manager->RemoveUser(*uuid)) {
         return;
+    }
 
     item_model->removeRows(tree_view->currentIndex().row(), 1);
     tree_view->clearSelection();

src/yuzu/configuration/configure_service.cpp

@@ -65,7 +65,7 @@ void ConfigureService::RetranslateUi() {
 
 void ConfigureService::SetConfiguration() {
     const int index =
-        ui->bcat_source->findData(QString::fromStdString(Settings::values.bcat_backend));
+        ui->bcat_source->findData(QString::fromStdString(Settings::values.bcat_backend.GetValue()));
     ui->bcat_source->setCurrentIndex(index == -1 ? 0 : index);
 }
 

src/yuzu/configuration/configure_ui.cpp

@@ -113,11 +113,12 @@ void ConfigureUi::SetConfiguration() {
     ui->theme_combobox->setCurrentIndex(ui->theme_combobox->findData(UISettings::values.theme));
     ui->language_combobox->setCurrentIndex(
         ui->language_combobox->findData(UISettings::values.language));
-    ui->show_add_ons->setChecked(UISettings::values.show_add_ons);
+    ui->show_add_ons->setChecked(UISettings::values.show_add_ons.GetValue());
     ui->icon_size_combobox->setCurrentIndex(
-        ui->icon_size_combobox->findData(UISettings::values.icon_size));
+        ui->icon_size_combobox->findData(UISettings::values.icon_size.GetValue()));
 
-    ui->enable_screenshot_save_as->setChecked(UISettings::values.enable_screenshot_save_as);
+    ui->enable_screenshot_save_as->setChecked(
+        UISettings::values.enable_screenshot_save_as.GetValue());
     ui->screenshot_path_edit->setText(QString::fromStdString(
         Common::FS::GetYuzuPathString(Common::FS::YuzuPath::ScreenshotsDir)));
 }
@@ -178,7 +179,7 @@ void ConfigureUi::InitializeRowComboBoxes() {
 
 void ConfigureUi::UpdateFirstRowComboBox(bool init) {
     const int currentIndex =
-        init ? UISettings::values.row_1_text_id
+        init ? UISettings::values.row_1_text_id.GetValue()
              : ui->row_1_text_combobox->findData(ui->row_1_text_combobox->currentData());
 
     ui->row_1_text_combobox->clear();
@@ -197,7 +198,7 @@ void ConfigureUi::UpdateFirstRowComboBox(bool init) {
 
 void ConfigureUi::UpdateSecondRowComboBox(bool init) {
     const int currentIndex =
-        init ? UISettings::values.row_2_text_id
+        init ? UISettings::values.row_2_text_id.GetValue()
              : ui->row_2_text_combobox->findData(ui->row_2_text_combobox->currentData());
 
     ui->row_2_text_combobox->clear();

src/yuzu/configuration/configure_web.cpp

@@ -88,22 +88,22 @@ void ConfigureWeb::SetConfiguration() {
     ui->web_signup_link->setOpenExternalLinks(true);
     ui->web_token_info_link->setOpenExternalLinks(true);
 
-    if (Settings::values.yuzu_username.empty()) {
+    if (Settings::values.yuzu_username.GetValue().empty()) {
         ui->username->setText(tr("Unspecified"));
     } else {
-        ui->username->setText(QString::fromStdString(Settings::values.yuzu_username));
+        ui->username->setText(QString::fromStdString(Settings::values.yuzu_username.GetValue()));
     }
 
-    ui->toggle_telemetry->setChecked(Settings::values.enable_telemetry);
-    ui->edit_token->setText(QString::fromStdString(
-        GenerateDisplayToken(Settings::values.yuzu_username, Settings::values.yuzu_token)));
+    ui->toggle_telemetry->setChecked(Settings::values.enable_telemetry.GetValue());
+    ui->edit_token->setText(QString::fromStdString(GenerateDisplayToken(
+        Settings::values.yuzu_username.GetValue(), Settings::values.yuzu_token.GetValue())));
 
     // Connect after setting the values, to avoid calling OnLoginChanged now
     connect(ui->edit_token, &QLineEdit::textChanged, this, &ConfigureWeb::OnLoginChanged);
 
     user_verified = true;
 
-    ui->toggle_discordrpc->setChecked(UISettings::values.enable_discord_presence);
+    ui->toggle_discordrpc->setChecked(UISettings::values.enable_discord_presence.GetValue());
 }
 
 void ConfigureWeb::ApplyConfiguration() {

src/yuzu/debugger/console.cpp

@@ -15,10 +15,10 @@
 namespace Debugger {
 void ToggleConsole() {
     static bool console_shown = false;
-    if (console_shown == UISettings::values.show_console) {
+    if (console_shown == UISettings::values.show_console.GetValue()) {
         return;
     } else {
-        console_shown = UISettings::values.show_console;
+        console_shown = UISettings::values.show_console.GetValue();
     }
 
 #if defined(_WIN32) && !defined(_DEBUG)

src/yuzu/game_list.cpp

@@ -244,7 +244,8 @@ void GameList::OnUpdateThemedIcons() {
     for (int i = 0; i < item_model->invisibleRootItem()->rowCount(); i++) {
         QStandardItem* child = item_model->invisibleRootItem()->child(i);
 
-        const int icon_size = std::min(static_cast<int>(UISettings::values.icon_size), 64);
+        const int icon_size =
+            std::min(static_cast<int>(UISettings::values.icon_size.GetValue()), 64);
         switch (child->data(GameListItem::TypeRole).value<GameListItemType>()) {
         case GameListItemType::SdmcDir:
             child->setData(

src/yuzu/game_list_p.h

@@ -80,7 +80,7 @@ public:
         setData(qulonglong(program_id), ProgramIdRole);
         setData(game_type, FileTypeRole);
 
-        const u32 size = UISettings::values.icon_size;
+        const u32 size = UISettings::values.icon_size.GetValue();
 
         QPixmap picture;
         if (!picture.loadFromData(picture_data.data(), static_cast<u32>(picture_data.size()))) {
@@ -108,8 +108,8 @@ public:
                 data(TitleRole).toString(),
             }};
 
-            const auto& row1 = row_data.at(UISettings::values.row_1_text_id);
-            const int row2_id = UISettings::values.row_2_text_id;
+            const auto& row1 = row_data.at(UISettings::values.row_1_text_id.GetValue());
+            const int row2_id = UISettings::values.row_2_text_id.GetValue();
 
             if (role == SortRole) {
                 return row1.toLower();
@@ -233,7 +233,8 @@ public:
         UISettings::GameDir* game_dir = &directory;
         setData(QVariant(UISettings::values.game_dirs.indexOf(directory)), GameDirRole);
 
-        const int icon_size = std::min(static_cast<int>(UISettings::values.icon_size), 64);
+        const int icon_size =
+            std::min(static_cast<int>(UISettings::values.icon_size.GetValue()), 64);
         switch (dir_type) {
         case GameListItemType::SdmcDir:
             setData(
@@ -294,7 +295,8 @@ public:
     explicit GameListAddDir() {
         setData(type(), TypeRole);
 
-        const int icon_size = std::min(static_cast<int>(UISettings::values.icon_size), 64);
+        const int icon_size =
+            std::min(static_cast<int>(UISettings::values.icon_size.GetValue()), 64);
         setData(QIcon::fromTheme(QStringLiteral("plus"))
                     .pixmap(icon_size)
                     .scaled(icon_size, icon_size, Qt::IgnoreAspectRatio, Qt::SmoothTransformation),
@@ -316,7 +318,8 @@ public:
     explicit GameListFavorites() {
         setData(type(), TypeRole);
 
-        const int icon_size = std::min(static_cast<int>(UISettings::values.icon_size), 64);
+        const int icon_size =
+            std::min(static_cast<int>(UISettings::values.icon_size.GetValue()), 64);
         setData(QIcon::fromTheme(QStringLiteral("star"))
                     .pixmap(icon_size)
                     .scaled(icon_size, icon_size, Qt::IgnoreAspectRatio, Qt::SmoothTransformation),

src/yuzu/main.cpp

@@ -156,11 +156,13 @@ enum class CalloutFlag : uint32_t {
 };
 
 void GMainWindow::ShowTelemetryCallout() {
-    if (UISettings::values.callout_flags & static_cast<uint32_t>(CalloutFlag::Telemetry)) {
+    if (UISettings::values.callout_flags.GetValue() &
+        static_cast<uint32_t>(CalloutFlag::Telemetry)) {
         return;
     }
 
-    UISettings::values.callout_flags |= static_cast<uint32_t>(CalloutFlag::Telemetry);
+    UISettings::values.callout_flags =
+        UISettings::values.callout_flags.GetValue() | static_cast<uint32_t>(CalloutFlag::Telemetry);
     const QString telemetry_message =
         tr("<a href='https://yuzu-emu.org/help/feature/telemetry/'>Anonymous "
            "data is collected</a> to help improve yuzu. "
@@ -177,7 +179,7 @@ static void InitializeLogging() {
     using namespace Common;
 
     Log::Filter log_filter;
-    log_filter.ParseFilterString(Settings::values.log_filter);
+    log_filter.ParseFilterString(Settings::values.log_filter.GetValue());
     Log::SetGlobalFilter(log_filter);
 
     const auto log_dir = FS::GetYuzuPath(FS::YuzuPath::LogDir);
@@ -216,7 +218,7 @@ GMainWindow::GMainWindow()
     default_theme_paths = QIcon::themeSearchPaths();
     UpdateUITheme();
 
-    SetDiscordEnabled(UISettings::values.enable_discord_presence);
+    SetDiscordEnabled(UISettings::values.enable_discord_presence.GetValue());
     discord_rpc->Update();
 
     RegisterMetaTypes();
@@ -1060,23 +1062,24 @@ void GMainWindow::RestoreUIState() {
     render_window->restoreGeometry(UISettings::values.renderwindow_geometry);
 #if MICROPROFILE_ENABLED
     microProfileDialog->restoreGeometry(UISettings::values.microprofile_geometry);
-    microProfileDialog->setVisible(UISettings::values.microprofile_visible);
+    microProfileDialog->setVisible(UISettings::values.microprofile_visible.GetValue());
 #endif
 
     game_list->LoadInterfaceLayout();
 
-    ui.action_Single_Window_Mode->setChecked(UISettings::values.single_window_mode);
+    ui.action_Single_Window_Mode->setChecked(UISettings::values.single_window_mode.GetValue());
     ToggleWindowMode();
 
-    ui.action_Fullscreen->setChecked(UISettings::values.fullscreen);
+    ui.action_Fullscreen->setChecked(UISettings::values.fullscreen.GetValue());
 
-    ui.action_Display_Dock_Widget_Headers->setChecked(UISettings::values.display_titlebar);
+    ui.action_Display_Dock_Widget_Headers->setChecked(
+        UISettings::values.display_titlebar.GetValue());
     OnDisplayTitleBars(ui.action_Display_Dock_Widget_Headers->isChecked());
 
-    ui.action_Show_Filter_Bar->setChecked(UISettings::values.show_filter_bar);
+    ui.action_Show_Filter_Bar->setChecked(UISettings::values.show_filter_bar.GetValue());
     game_list->SetFilterVisible(ui.action_Show_Filter_Bar->isChecked());
 
-    ui.action_Show_Status_Bar->setChecked(UISettings::values.show_status_bar);
+    ui.action_Show_Status_Bar->setChecked(UISettings::values.show_status_bar.GetValue());
     statusBar()->setVisible(ui.action_Show_Status_Bar->isChecked());
     Debugger::ToggleConsole();
 }
@@ -1243,13 +1246,14 @@ bool GMainWindow::LoadROM(const QString& filename, std::size_t program_index) {
     const Core::System::ResultStatus result{
         system.Load(*render_window, filename.toStdString(), program_index)};
 
-    const auto drd_callout =
-        (UISettings::values.callout_flags & static_cast<u32>(CalloutFlag::DRDDeprecation)) == 0;
+    const auto drd_callout = (UISettings::values.callout_flags.GetValue() &
+                              static_cast<u32>(CalloutFlag::DRDDeprecation)) == 0;
 
     if (result == Core::System::ResultStatus::Success &&
         system.GetAppLoader().GetFileType() == Loader::FileType::DeconstructedRomDirectory &&
         drd_callout) {
-        UISettings::values.callout_flags |= static_cast<u32>(CalloutFlag::DRDDeprecation);
+        UISettings::values.callout_flags = UISettings::values.callout_flags.GetValue() |
+                                           static_cast<u32>(CalloutFlag::DRDDeprecation);
         QMessageBox::warning(
             this, tr("Warning Outdated Game Format"),
             tr("You are using the deconstructed ROM directory format for this game, which is an "
@@ -2453,7 +2457,8 @@ void GMainWindow::ErrorDisplayDisplayError(QString error_code, QString error_tex
 }
 
 void GMainWindow::OnMenuReportCompatibility() {
-    if (!Settings::values.yuzu_token.empty() && !Settings::values.yuzu_username.empty()) {
+    if (!Settings::values.yuzu_token.GetValue().empty() &&
+        !Settings::values.yuzu_username.GetValue().empty()) {
         CompatDB compatdb{this};
         compatdb.exec();
     } else {
@@ -2618,7 +2623,7 @@ void GMainWindow::ResetWindowSize1080() {
 
 void GMainWindow::OnConfigure() {
     const auto old_theme = UISettings::values.theme;
-    const bool old_discord_presence = UISettings::values.enable_discord_presence;
+    const bool old_discord_presence = UISettings::values.enable_discord_presence.GetValue();
 
     ConfigureDialog configure_dialog(this, hotkey_registry, input_subsystem.get());
     connect(&configure_dialog, &ConfigureDialog::LanguageChanged, this,
@@ -2675,8 +2680,8 @@ void GMainWindow::OnConfigure() {
     if (UISettings::values.theme != old_theme) {
         UpdateUITheme();
     }
-    if (UISettings::values.enable_discord_presence != old_discord_presence) {
-        SetDiscordEnabled(UISettings::values.enable_discord_presence);
+    if (UISettings::values.enable_discord_presence.GetValue() != old_discord_presence) {
+        SetDiscordEnabled(UISettings::values.enable_discord_presence.GetValue());
     }
     emit UpdateThemedIcons();
 
@@ -2832,7 +2837,8 @@ void GMainWindow::OnCaptureScreenshot() {
         }
     }
 #endif
-    render_window->CaptureScreenshot(UISettings::values.screenshot_resolution_factor, filename);
+    render_window->CaptureScreenshot(UISettings::values.screenshot_resolution_factor.GetValue(),
+                                     filename);
     OnStartGame();
 }
 

src/yuzu/uisettings.h

@@ -13,6 +13,7 @@
 #include <QStringList>
 #include <QVector>
 #include "common/common_types.h"
+#include "common/settings.h"
 
 namespace UISettings {
 
@@ -48,26 +49,26 @@ struct Values {
     QByteArray gamelist_header_state;
 
     QByteArray microprofile_geometry;
-    bool microprofile_visible;
+    Settings::BasicSetting<bool> microprofile_visible{false, "microProfileDialogVisible"};
 
-    bool single_window_mode;
-    bool fullscreen;
-    bool display_titlebar;
-    bool show_filter_bar;
-    bool show_status_bar;
+    Settings::BasicSetting<bool> single_window_mode{true, "singleWindowMode"};
+    Settings::BasicSetting<bool> fullscreen{false, "fullscreen"};
+    Settings::BasicSetting<bool> display_titlebar{true, "displayTitleBars"};
+    Settings::BasicSetting<bool> show_filter_bar{true, "showFilterBar"};
+    Settings::BasicSetting<bool> show_status_bar{true, "showStatusBar"};
 
-    bool confirm_before_closing;
-    bool first_start;
-    bool pause_when_in_background;
-    bool hide_mouse;
+    Settings::BasicSetting<bool> confirm_before_closing{true, "confirmClose"};
+    Settings::BasicSetting<bool> first_start{true, "firstStart"};
+    Settings::BasicSetting<bool> pause_when_in_background{false, "pauseWhenInBackground"};
+    Settings::BasicSetting<bool> hide_mouse{false, "hideInactiveMouse"};
 
-    bool select_user_on_boot;
+    Settings::BasicSetting<bool> select_user_on_boot{false, "select_user_on_boot"};
 
     // Discord RPC
-    bool enable_discord_presence;
+    Settings::BasicSetting<bool> enable_discord_presence{true, "enable_discord_presence"};
 
-    bool enable_screenshot_save_as;
-    u16 screenshot_resolution_factor;
+    Settings::BasicSetting<bool> enable_screenshot_save_as{true, "enable_screenshot_save_as"};
+    Settings::BasicSetting<u16> screenshot_resolution_factor{0, "screenshot_resolution_factor"};
 
     QString roms_path;
     QString symbols_path;
@@ -83,18 +84,18 @@ struct Values {
     // Shortcut name <Shortcut, context>
     std::vector<Shortcut> shortcuts;
 
-    uint32_t callout_flags;
+    Settings::BasicSetting<uint32_t> callout_flags{0, "calloutFlags"};
 
     // logging
-    bool show_console;
+    Settings::BasicSetting<bool> show_console{false, "showConsole"};
 
     // Game List
-    bool show_add_ons;
-    uint32_t icon_size;
-    uint8_t row_1_text_id;
-    uint8_t row_2_text_id;
+    Settings::BasicSetting<bool> show_add_ons{true, "show_add_ons"};
+    Settings::BasicSetting<uint32_t> icon_size{64, "icon_size"};
+    Settings::BasicSetting<uint8_t> row_1_text_id{3, "row_1_text_id"};
+    Settings::BasicSetting<uint8_t> row_2_text_id{2, "row_2_text_id"};
     std::atomic_bool is_game_list_reload_pending{false};
-    bool cache_game_list;
+    Settings::BasicSetting<bool> cache_game_list{true, "cache_game_list"};
 
     bool configuration_applied;
     bool reset_to_defaults;

src/yuzu_cmd/config.cpp

@@ -241,6 +241,24 @@ static const std::array<int, 8> keyboard_mods{
     SDL_SCANCODE_RCTRL, SDL_SCANCODE_RSHIFT, SDL_SCANCODE_RALT, SDL_SCANCODE_RGUI,
 };
 
+template <>
+void Config::ReadSetting(const std::string& group, Settings::BasicSetting<float>& setting) {
+    setting = sdl2_config->GetReal(group, setting.GetLabel(), setting.GetDefault());
+}
+template <>
+void Config::ReadSetting(const std::string& group, Settings::BasicSetting<std::string>& setting) {
+    setting = sdl2_config->Get(group, setting.GetLabel(), setting.GetDefault());
+}
+template <>
+void Config::ReadSetting(const std::string& group, Settings::BasicSetting<bool>& setting) {
+    setting = sdl2_config->GetBoolean(group, setting.GetLabel(), setting.GetDefault());
+}
+template <typename Type>
+void Config::ReadSetting(const std::string& group, Settings::BasicSetting<Type>& setting) {
+    setting = static_cast<Type>(sdl2_config->GetInteger(group, setting.GetLabel(),
+                                                        static_cast<long>(setting.GetDefault())));
+}
+
 void Config::ReadValues() {
     // Controls
     for (std::size_t p = 0; p < Settings::values.players.GetValue().size(); ++p) {
@@ -264,8 +282,7 @@ void Config::ReadValues() {
         }
     }
 
-    Settings::values.mouse_enabled =
-        sdl2_config->GetBoolean("ControlsGeneral", "mouse_enabled", false);
+    ReadSetting("ControlsGeneral", Settings::values.mouse_enabled);
     for (int i = 0; i < Settings::NativeMouseButton::NumMouseButtons; ++i) {
         std::string default_param = InputCommon::GenerateKeyboardParam(default_mouse_buttons[i]);
         Settings::values.mouse_buttons[i] = sdl2_config->Get(
@@ -275,14 +292,11 @@ void Config::ReadValues() {
             Settings::values.mouse_buttons[i] = default_param;
     }
 
-    Settings::values.motion_device = sdl2_config->Get(
-        "ControlsGeneral", "motion_device", "engine:motion_emu,update_period:100,sensitivity:0.01");
+    ReadSetting("ControlsGeneral", Settings::values.motion_device);
 
-    Settings::values.keyboard_enabled =
-        sdl2_config->GetBoolean("ControlsGeneral", "keyboard_enabled", false);
+    ReadSetting("ControlsGeneral", Settings::values.keyboard_enabled);
 
-    Settings::values.debug_pad_enabled =
-        sdl2_config->GetBoolean("ControlsGeneral", "debug_pad_enabled", false);
+    ReadSetting("ControlsGeneral", Settings::values.debug_pad_enabled);
     for (int i = 0; i < Settings::NativeButton::NumButtons; ++i) {
         std::string default_param = InputCommon::GenerateKeyboardParam(default_buttons[i]);
         Settings::values.debug_pad_buttons[i] = sdl2_config->Get(
@@ -303,12 +317,9 @@ void Config::ReadValues() {
             Settings::values.debug_pad_analogs[i] = default_param;
     }
 
-    Settings::values.vibration_enabled.SetValue(
-        sdl2_config->GetBoolean("ControlsGeneral", "vibration_enabled", true));
-    Settings::values.enable_accurate_vibrations.SetValue(
-        sdl2_config->GetBoolean("ControlsGeneral", "enable_accurate_vibrations", false));
-    Settings::values.motion_enabled.SetValue(
-        sdl2_config->GetBoolean("ControlsGeneral", "motion_enabled", true));
+    ReadSetting("ControlsGeneral", Settings::values.vibration_enabled);
+    ReadSetting("ControlsGeneral", Settings::values.enable_accurate_vibrations);
+    ReadSetting("ControlsGeneral", Settings::values.motion_enabled);
     Settings::values.touchscreen.enabled =
         sdl2_config->GetBoolean("ControlsGeneral", "touch_enabled", true);
     Settings::values.touchscreen.rotation_angle =
@@ -349,13 +360,11 @@ void Config::ReadValues() {
             Settings::TouchFromButtonMap{"default", {}});
         num_touch_from_button_maps = 1;
     }
-    Settings::values.use_touch_from_button =
-        sdl2_config->GetBoolean("ControlsGeneral", "use_touch_from_button", false);
-    Settings::values.touch_from_button_map_index =
-        std::clamp(Settings::values.touch_from_button_map_index, 0, num_touch_from_button_maps - 1);
+    ReadSetting("ControlsGeneral", Settings::values.use_touch_from_button);
+    Settings::values.touch_from_button_map_index = std::clamp(
+        Settings::values.touch_from_button_map_index.GetValue(), 0, num_touch_from_button_maps - 1);
 
-    Settings::values.udp_input_servers =
-        sdl2_config->Get("Controls", "udp_input_address", InputCommon::CemuhookUDP::DEFAULT_SRV);
+    ReadSetting("ControlsGeneral", Settings::values.udp_input_servers);
 
     std::transform(keyboard_keys.begin(), keyboard_keys.end(),
                    Settings::values.keyboard_keys.begin(), InputCommon::GenerateKeyboardParam);
@@ -367,8 +376,7 @@ void Config::ReadValues() {
                    Settings::values.keyboard_mods.begin(), InputCommon::GenerateKeyboardParam);
 
     // Data Storage
-    Settings::values.use_virtual_sd =
-        sdl2_config->GetBoolean("Data Storage", "use_virtual_sd", true);
+    ReadSetting("Data Storage", Settings::values.use_virtual_sd);
     FS::SetYuzuPath(FS::YuzuPath::NANDDir,
                     sdl2_config->Get("Data Storage", "nand_directory",
                                      FS::GetYuzuPathString(FS::YuzuPath::NANDDir)));
@@ -381,18 +389,16 @@ void Config::ReadValues() {
     FS::SetYuzuPath(FS::YuzuPath::DumpDir,
                     sdl2_config->Get("Data Storage", "dump_directory",
                                      FS::GetYuzuPathString(FS::YuzuPath::DumpDir)));
-    Settings::values.gamecard_inserted =
-        sdl2_config->GetBoolean("Data Storage", "gamecard_inserted", false);
-    Settings::values.gamecard_current_game =
-        sdl2_config->GetBoolean("Data Storage", "gamecard_current_game", false);
-    Settings::values.gamecard_path = sdl2_config->Get("Data Storage", "gamecard_path", "");
+    ReadSetting("Data Storage", Settings::values.gamecard_inserted);
+    ReadSetting("Data Storage", Settings::values.gamecard_current_game);
+    ReadSetting("Data Storage", Settings::values.gamecard_path);
 
     // System
-    Settings::values.use_docked_mode.SetValue(
-        sdl2_config->GetBoolean("System", "use_docked_mode", true));
+    ReadSetting("System", Settings::values.use_docked_mode);
 
-    Settings::values.current_user = std::clamp<int>(
-        sdl2_config->GetInteger("System", "current_user", 0), 0, Service::Account::MAX_USERS - 1);
+    ReadSetting("System", Settings::values.current_user);
+    Settings::values.current_user = std::clamp<int>(Settings::values.current_user.GetValue(), 0,
+                                                    Service::Account::MAX_USERS - 1);
 
     const auto rng_seed_enabled = sdl2_config->GetBoolean("System", "rng_seed_enabled", false);
     if (rng_seed_enabled) {
@@ -409,89 +415,60 @@ void Config::ReadValues() {
         Settings::values.custom_rtc = std::nullopt;
     }
 
-    Settings::values.language_index.SetValue(
-        sdl2_config->GetInteger("System", "language_index", 1));
-    Settings::values.time_zone_index.SetValue(
-        sdl2_config->GetInteger("System", "time_zone_index", 0));
+    ReadSetting("System", Settings::values.language_index);
+    ReadSetting("System", Settings::values.time_zone_index);
 
     // Core
-    Settings::values.use_multi_core.SetValue(
-        sdl2_config->GetBoolean("Core", "use_multi_core", true));
+    ReadSetting("Core", Settings::values.use_multi_core);
 
     // Renderer
-    const int renderer_backend = sdl2_config->GetInteger(
-        "Renderer", "backend", static_cast<int>(Settings::RendererBackend::OpenGL));
-    Settings::values.renderer_backend.SetValue(
-        static_cast<Settings::RendererBackend>(renderer_backend));
-    Settings::values.renderer_debug = sdl2_config->GetBoolean("Renderer", "debug", false);
-    Settings::values.vulkan_device.SetValue(
-        sdl2_config->GetInteger("Renderer", "vulkan_device", 0));
+    ReadSetting("Renderer", Settings::values.renderer_backend);
+    ReadSetting("Renderer", Settings::values.renderer_debug);
+    ReadSetting("Renderer", Settings::values.vulkan_device);
 
-    Settings::values.aspect_ratio.SetValue(
-        static_cast<int>(sdl2_config->GetInteger("Renderer", "aspect_ratio", 0)));
-    Settings::values.max_anisotropy.SetValue(
-        static_cast<int>(sdl2_config->GetInteger("Renderer", "max_anisotropy", 0)));
-    Settings::values.use_frame_limit.SetValue(
-        sdl2_config->GetBoolean("Renderer", "use_frame_limit", true));
-    Settings::values.frame_limit.SetValue(
-        static_cast<u16>(sdl2_config->GetInteger("Renderer", "frame_limit", 100)));
-    Settings::values.use_disk_shader_cache.SetValue(
-        sdl2_config->GetBoolean("Renderer", "use_disk_shader_cache", false));
-    const int gpu_accuracy_level = sdl2_config->GetInteger("Renderer", "gpu_accuracy", 1);
-    Settings::values.gpu_accuracy.SetValue(static_cast<Settings::GPUAccuracy>(gpu_accuracy_level));
-    Settings::values.use_asynchronous_gpu_emulation.SetValue(
-        sdl2_config->GetBoolean("Renderer", "use_asynchronous_gpu_emulation", true));
-    Settings::values.use_vsync.SetValue(
-        static_cast<u16>(sdl2_config->GetInteger("Renderer", "use_vsync", 1)));
-    Settings::values.disable_fps_limit.SetValue(
-        sdl2_config->GetBoolean("Renderer", "disable_fps_limit", false));
-    Settings::values.use_assembly_shaders.SetValue(
-        sdl2_config->GetBoolean("Renderer", "use_assembly_shaders", true));
-    Settings::values.use_asynchronous_shaders.SetValue(
-        sdl2_config->GetBoolean("Renderer", "use_asynchronous_shaders", false));
-    Settings::values.use_nvdec_emulation.SetValue(
-        sdl2_config->GetBoolean("Renderer", "use_nvdec_emulation", true));
-    Settings::values.accelerate_astc.SetValue(
-        sdl2_config->GetBoolean("Renderer", "accelerate_astc", true));
-    Settings::values.use_fast_gpu_time.SetValue(
-        sdl2_config->GetBoolean("Renderer", "use_fast_gpu_time", true));
+    ReadSetting("Renderer", Settings::values.aspect_ratio);
+    ReadSetting("Renderer", Settings::values.max_anisotropy);
+    ReadSetting("Renderer", Settings::values.use_frame_limit);
+    ReadSetting("Renderer", Settings::values.frame_limit);
+    ReadSetting("Renderer", Settings::values.use_disk_shader_cache);
+    ReadSetting("Renderer", Settings::values.gpu_accuracy);
+    ReadSetting("Renderer", Settings::values.use_asynchronous_gpu_emulation);
+    ReadSetting("Renderer", Settings::values.use_vsync);
+    ReadSetting("Renderer", Settings::values.disable_fps_limit);
+    ReadSetting("Renderer", Settings::values.use_assembly_shaders);
+    ReadSetting("Renderer", Settings::values.use_asynchronous_shaders);
+    ReadSetting("Renderer", Settings::values.use_nvdec_emulation);
+    ReadSetting("Renderer", Settings::values.accelerate_astc);
+    ReadSetting("Renderer", Settings::values.use_fast_gpu_time);
 
-    Settings::values.bg_red.SetValue(
-        static_cast<float>(sdl2_config->GetReal("Renderer", "bg_red", 0.0)));
-    Settings::values.bg_green.SetValue(
-        static_cast<float>(sdl2_config->GetReal("Renderer", "bg_green", 0.0)));
-    Settings::values.bg_blue.SetValue(
-        static_cast<float>(sdl2_config->GetReal("Renderer", "bg_blue", 0.0)));
+    ReadSetting("Renderer", Settings::values.bg_red);
+    ReadSetting("Renderer", Settings::values.bg_green);
+    ReadSetting("Renderer", Settings::values.bg_blue);
 
     // Audio
-    Settings::values.sink_id = sdl2_config->Get("Audio", "output_engine", "auto");
-    Settings::values.enable_audio_stretching.SetValue(
-        sdl2_config->GetBoolean("Audio", "enable_audio_stretching", true));
-    Settings::values.audio_device_id = sdl2_config->Get("Audio", "output_device", "auto");
-    Settings::values.volume.SetValue(
-        static_cast<float>(sdl2_config->GetReal("Audio", "volume", 1)));
+    ReadSetting("Audio", Settings::values.sink_id);
+    ReadSetting("Audio", Settings::values.enable_audio_stretching);
+    ReadSetting("Audio", Settings::values.audio_device_id);
+    ReadSetting("Audio", Settings::values.volume);
 
     // Miscellaneous
-    Settings::values.log_filter = sdl2_config->Get("Miscellaneous", "log_filter", "*:Trace");
-    Settings::values.use_dev_keys = sdl2_config->GetBoolean("Miscellaneous", "use_dev_keys", false);
+    // log_filter has a different default here than from common
+    Settings::values.log_filter =
+        sdl2_config->Get("Miscellaneous", Settings::values.log_filter.GetLabel(), "*:Trace");
+    ReadSetting("Miscellaneous", Settings::values.use_dev_keys);
 
     // Debugging
     Settings::values.record_frame_times =
         sdl2_config->GetBoolean("Debugging", "record_frame_times", false);
-    Settings::values.program_args = sdl2_config->Get("Debugging", "program_args", "");
-    Settings::values.dump_exefs = sdl2_config->GetBoolean("Debugging", "dump_exefs", false);
-    Settings::values.dump_nso = sdl2_config->GetBoolean("Debugging", "dump_nso", false);
-    Settings::values.enable_fs_access_log =
-        sdl2_config->GetBoolean("Debugging", "enable_fs_access_log", false);
-    Settings::values.reporting_services =
-        sdl2_config->GetBoolean("Debugging", "reporting_services", false);
-    Settings::values.quest_flag = sdl2_config->GetBoolean("Debugging", "quest_flag", false);
-    Settings::values.use_debug_asserts =
-        sdl2_config->GetBoolean("Debugging", "use_debug_asserts", false);
-    Settings::values.use_auto_stub = sdl2_config->GetBoolean("Debugging", "use_auto_stub", false);
-
-    Settings::values.disable_macro_jit =
-        sdl2_config->GetBoolean("Debugging", "disable_macro_jit", false);
+    ReadSetting("Debugging", Settings::values.program_args);
+    ReadSetting("Debugging", Settings::values.dump_exefs);
+    ReadSetting("Debugging", Settings::values.dump_nso);
+    ReadSetting("Debugging", Settings::values.enable_fs_access_log);
+    ReadSetting("Debugging", Settings::values.reporting_services);
+    ReadSetting("Debugging", Settings::values.quest_flag);
+    ReadSetting("Debugging", Settings::values.use_debug_asserts);
+    ReadSetting("Debugging", Settings::values.use_auto_stub);
+    ReadSetting("Debugging", Settings::values.disable_macro_jit);
 
     const auto title_list = sdl2_config->Get("AddOns", "title_ids", "");
     std::stringstream ss(title_list);
@@ -511,17 +488,14 @@ void Config::ReadValues() {
     }
 
     // Web Service
-    Settings::values.enable_telemetry =
-        sdl2_config->GetBoolean("WebService", "enable_telemetry", true);
-    Settings::values.web_api_url =
-        sdl2_config->Get("WebService", "web_api_url", "https://api.yuzu-emu.org");
-    Settings::values.yuzu_username = sdl2_config->Get("WebService", "yuzu_username", "");
-    Settings::values.yuzu_token = sdl2_config->Get("WebService", "yuzu_token", "");
+    ReadSetting("WebService", Settings::values.enable_telemetry);
+    ReadSetting("WebService", Settings::values.web_api_url);
+    ReadSetting("WebService", Settings::values.yuzu_username);
+    ReadSetting("WebService", Settings::values.yuzu_token);
 
     // Services
-    Settings::values.bcat_backend = sdl2_config->Get("Services", "bcat_backend", "none");
-    Settings::values.bcat_boxcat_local =
-        sdl2_config->GetBoolean("Services", "bcat_boxcat_local", false);
+    ReadSetting("Services", Settings::values.bcat_backend);
+    ReadSetting("Services", Settings::values.bcat_boxcat_local);
 }
 
 void Config::Reload() {

src/yuzu_cmd/config.h

@@ -8,6 +8,8 @@
 #include <memory>
 #include <string>
 
+#include "common/settings.h"
+
 class INIReader;
 
 class Config {
@@ -22,4 +24,14 @@ public:
     ~Config();
 
     void Reload();
+
+private:
+    /**
+     * Applies a value read from the sdl2_config to a BasicSetting.
+     *
+     * @param group The name of the INI group
+     * @param setting The yuzu setting to modify
+     */
+    template <typename Type>
+    void ReadSetting(const std::string& group, Settings::BasicSetting<Type>& setting);
 };

src/yuzu_cmd/yuzu.cpp

@@ -78,7 +78,7 @@ static void InitializeLogging() {
     using namespace Common;
 
     Log::Filter log_filter(Log::Level::Debug);
-    log_filter.ParseFilterString(Settings::values.log_filter);
+    log_filter.ParseFilterString(static_cast<std::string>(Settings::values.log_filter));
     Log::SetGlobalFilter(log_filter);
 
     Log::AddBackend(std::make_unique<Log::ColorConsoleBackend>());