Update gc_adapter.cpp

GCC11.2 complains cannot find 'libusb.h' during a fresh build

src/common/settings.h

@@ -606,7 +606,6 @@ struct Values {
     BasicSetting<bool> dump_exefs{false, "dump_exefs"};
     BasicSetting<bool> dump_nso{false, "dump_nso"};
     BasicSetting<bool> dump_shaders{false, "dump_shaders"};
-    BasicSetting<bool> dump_macros{false, "dump_macros"};
     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"};

src/core/hid/input_converter.cpp

@@ -327,7 +327,7 @@ void SanitizeStick(Common::Input::AnalogStatus& analog_x, Common::Input::AnalogS
     raw_y += properties_y.offset;
 
     // Apply X scale correction from offset
-    if (std::abs(properties_x.offset) < 0.75f) {
+    if (std::abs(properties_x.offset) < 0.5f) {
         if (raw_x > 0) {
             raw_x /= 1 + properties_x.offset;
         } else {
@@ -336,7 +336,7 @@ void SanitizeStick(Common::Input::AnalogStatus& analog_x, Common::Input::AnalogS
     }
 
     // Apply Y scale correction from offset
-    if (std::abs(properties_y.offset) < 0.75f) {
+    if (std::abs(properties_y.offset) < 0.5f) {
         if (raw_y > 0) {
             raw_y /= 1 + properties_y.offset;
         } else {

src/core/hle/result.h

@@ -153,48 +153,6 @@ constexpr ResultCode ResultSuccess(0);
  */
 constexpr ResultCode ResultUnknown(UINT32_MAX);
 
-/**
- * A ResultRange defines an inclusive range of error descriptions within an error module.
- * This can be used to check whether the description of a given ResultCode falls within the range.
- * The conversion function returns a ResultCode with its description set to description_start.
- *
- * An example of how it could be used:
- * \code
- * constexpr ResultRange ResultCommonError{ErrorModule::Common, 0, 9999};
- *
- * ResultCode Example(int value) {
- *     const ResultCode result = OtherExample(value);
- *
- *     // This will only evaluate to true if result.module is ErrorModule::Common and
- *     // result.description is in between 0 and 9999 inclusive.
- *     if (ResultCommonError.Includes(result)) {
- *         // This returns ResultCode{ErrorModule::Common, 0};
- *         return ResultCommonError;
- *     }
- *
- *     return ResultSuccess;
- * }
- * \endcode
- */
-class ResultRange {
-public:
-    consteval ResultRange(ErrorModule module, u32 description_start, u32 description_end_)
-        : code{module, description_start}, description_end{description_end_} {}
-
-    [[nodiscard]] constexpr operator ResultCode() const {
-        return code;
-    }
-
-    [[nodiscard]] constexpr bool Includes(ResultCode other) const {
-        return code.module == other.module && code.description <= other.description &&
-               other.description <= description_end;
-    }
-
-private:
-    ResultCode code;
-    u32 description_end;
-};
-
 /**
  * This is an optional value type. It holds a `ResultCode` and, if that code is ResultSuccess, it
  * also holds a result of type `T`. If the code is an error code (not ResultSuccess), then trying
@@ -232,8 +190,6 @@ public:
 
     constexpr ResultVal(ResultCode code) : expected{Common::Unexpected(code)} {}
 
-    constexpr ResultVal(ResultRange range) : expected{Common::Unexpected(range)} {}
-
     template <typename U>
     constexpr ResultVal(U&& val) : expected{std::forward<U>(val)} {}
 
@@ -319,7 +275,7 @@ public:
     }
 
 private:
-    // TODO (Morph): Replace this with C++23 std::expected.
+    // TODO: Replace this with std::expected once it is standardized in the STL.
     Common::Expected<T, ResultCode> expected;
 };
 

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

@@ -3,9 +3,7 @@
 
 #include <algorithm>
 #include <array>
-#include <chrono>
 #include <cstring>
-
 #include "common/assert.h"
 #include "common/bit_field.h"
 #include "common/common_types.h"
@@ -531,14 +529,6 @@ void Controller_NPad::OnMotionUpdate(const Core::Timing::CoreTiming& core_timing
         auto& sixaxis_left_lifo_state = controller.sixaxis_left_lifo_state;
         auto& sixaxis_right_lifo_state = controller.sixaxis_right_lifo_state;
 
-        // Clear previous state
-        sixaxis_fullkey_state = {};
-        sixaxis_handheld_state = {};
-        sixaxis_dual_left_state = {};
-        sixaxis_dual_right_state = {};
-        sixaxis_left_lifo_state = {};
-        sixaxis_right_lifo_state = {};
-
         if (controller.sixaxis_sensor_enabled && Settings::values.motion_enabled.GetValue()) {
             controller.sixaxis_at_rest = true;
             for (std::size_t e = 0; e < motion_state.size(); ++e) {
@@ -547,55 +537,69 @@ void Controller_NPad::OnMotionUpdate(const Core::Timing::CoreTiming& core_timing
             }
         }
 
-        const auto set_motion_state = [&](SixAxisSensorState& state,
-                                          const Core::HID::ControllerMotion& hid_state) {
-            using namespace std::literals::chrono_literals;
-            static constexpr SixAxisSensorState default_motion_state = {
-                .delta_time = std::chrono::nanoseconds(5ms).count(),
-                .accel = {0, 0, -1.0f},
-                .orientation =
-                    {
-                        Common::Vec3f{1.0f, 0, 0},
-                        Common::Vec3f{0, 1.0f, 0},
-                        Common::Vec3f{0, 0, 1.0f},
-                    },
-                .attribute = {1},
-            };
-            if (!controller.sixaxis_sensor_enabled) {
-                state = default_motion_state;
-                return;
-            }
-            if (!Settings::values.motion_enabled.GetValue()) {
-                state = default_motion_state;
-                return;
-            }
-            state.attribute.is_connected.Assign(1);
-            state.delta_time = std::chrono::nanoseconds(5ms).count();
-            state.accel = hid_state.accel;
-            state.gyro = hid_state.gyro;
-            state.rotation = hid_state.rotation;
-            state.orientation = hid_state.orientation;
-        };
-
         switch (controller_type) {
         case Core::HID::NpadStyleIndex::None:
             UNREACHABLE();
             break;
         case Core::HID::NpadStyleIndex::ProController:
-            set_motion_state(sixaxis_fullkey_state, motion_state[0]);
+            sixaxis_fullkey_state.attribute.raw = 0;
+            if (controller.sixaxis_sensor_enabled) {
+                sixaxis_fullkey_state.attribute.is_connected.Assign(1);
+                sixaxis_fullkey_state.accel = motion_state[0].accel;
+                sixaxis_fullkey_state.gyro = motion_state[0].gyro;
+                sixaxis_fullkey_state.rotation = motion_state[0].rotation;
+                sixaxis_fullkey_state.orientation = motion_state[0].orientation;
+            }
             break;
         case Core::HID::NpadStyleIndex::Handheld:
-            set_motion_state(sixaxis_handheld_state, motion_state[0]);
+            sixaxis_handheld_state.attribute.raw = 0;
+            if (controller.sixaxis_sensor_enabled) {
+                sixaxis_handheld_state.attribute.is_connected.Assign(1);
+                sixaxis_handheld_state.accel = motion_state[0].accel;
+                sixaxis_handheld_state.gyro = motion_state[0].gyro;
+                sixaxis_handheld_state.rotation = motion_state[0].rotation;
+                sixaxis_handheld_state.orientation = motion_state[0].orientation;
+            }
             break;
         case Core::HID::NpadStyleIndex::JoyconDual:
-            set_motion_state(sixaxis_dual_left_state, motion_state[0]);
-            set_motion_state(sixaxis_dual_right_state, motion_state[1]);
+            sixaxis_dual_left_state.attribute.raw = 0;
+            sixaxis_dual_right_state.attribute.raw = 0;
+            if (controller.sixaxis_sensor_enabled) {
+                // Set motion for the left joycon
+                sixaxis_dual_left_state.attribute.is_connected.Assign(1);
+                sixaxis_dual_left_state.accel = motion_state[0].accel;
+                sixaxis_dual_left_state.gyro = motion_state[0].gyro;
+                sixaxis_dual_left_state.rotation = motion_state[0].rotation;
+                sixaxis_dual_left_state.orientation = motion_state[0].orientation;
+            }
+            if (controller.sixaxis_sensor_enabled) {
+                // Set motion for the right joycon
+                sixaxis_dual_right_state.attribute.is_connected.Assign(1);
+                sixaxis_dual_right_state.accel = motion_state[1].accel;
+                sixaxis_dual_right_state.gyro = motion_state[1].gyro;
+                sixaxis_dual_right_state.rotation = motion_state[1].rotation;
+                sixaxis_dual_right_state.orientation = motion_state[1].orientation;
+            }
             break;
         case Core::HID::NpadStyleIndex::JoyconLeft:
-            set_motion_state(sixaxis_left_lifo_state, motion_state[0]);
+            sixaxis_left_lifo_state.attribute.raw = 0;
+            if (controller.sixaxis_sensor_enabled) {
+                sixaxis_left_lifo_state.attribute.is_connected.Assign(1);
+                sixaxis_left_lifo_state.accel = motion_state[0].accel;
+                sixaxis_left_lifo_state.gyro = motion_state[0].gyro;
+                sixaxis_left_lifo_state.rotation = motion_state[0].rotation;
+                sixaxis_left_lifo_state.orientation = motion_state[0].orientation;
+            }
             break;
         case Core::HID::NpadStyleIndex::JoyconRight:
-            set_motion_state(sixaxis_right_lifo_state, motion_state[1]);
+            sixaxis_right_lifo_state.attribute.raw = 0;
+            if (controller.sixaxis_sensor_enabled) {
+                sixaxis_right_lifo_state.attribute.is_connected.Assign(1);
+                sixaxis_right_lifo_state.accel = motion_state[1].accel;
+                sixaxis_right_lifo_state.gyro = motion_state[1].gyro;
+                sixaxis_right_lifo_state.rotation = motion_state[1].rotation;
+                sixaxis_right_lifo_state.orientation = motion_state[1].orientation;
+            }
             break;
         default:
             break;

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

@@ -37,7 +37,8 @@ namespace Service::HID {
 // Period time is obtained by measuring the number of samples in a second on HW using a homebrew
 constexpr auto pad_update_ns = std::chrono::nanoseconds{4 * 1000 * 1000};            // (4ms, 250Hz)
 constexpr auto mouse_keyboard_update_ns = std::chrono::nanoseconds{8 * 1000 * 1000}; // (8ms, 125Hz)
-constexpr auto motion_update_ns = std::chrono::nanoseconds{5 * 1000 * 1000};         // (5ms, 200Hz)
+// TODO: Correct update rate for motion is 5ms. Check why some games don't behave at that speed
+constexpr auto motion_update_ns = std::chrono::nanoseconds{10 * 1000 * 1000}; // (10ms, 100Hz)
 
 IAppletResource::IAppletResource(Core::System& system_,
                                  KernelHelpers::ServiceContext& service_context_)

src/input_common/drivers/gc_adapter.cpp

@@ -2,7 +2,7 @@
 // SPDX-License-Identifier: GPL-2.0-or-later
 
 #include <fmt/format.h>
-#include <libusb.h>
+#include <libusb-1.0/libusb.h>
 
 #include "common/logging/log.h"
 #include "common/param_package.h"

src/input_common/input_poller.cpp

@@ -732,7 +732,7 @@ std::unique_ptr<Common::Input::InputDevice> InputFactory::CreateHatButtonDevice(
 std::unique_ptr<Common::Input::InputDevice> InputFactory::CreateStickDevice(
     const Common::ParamPackage& params) {
     const auto deadzone = std::clamp(params.Get("deadzone", 0.15f), 0.0f, 1.0f);
-    const auto range = std::clamp(params.Get("range", 0.95f), 0.25f, 1.50f);
+    const auto range = std::clamp(params.Get("range", 1.0f), 0.25f, 1.50f);
     const auto threshold = std::clamp(params.Get("threshold", 0.5f), 0.0f, 1.0f);
     const PadIdentifier identifier = {
         .guid = Common::UUID{params.Get("guid", "")},

src/video_core/engines/maxwell_3d.cpp

@@ -173,8 +173,6 @@ void Maxwell3D::ProcessMethodCall(u32 method, u32 argument, u32 nonshadow_argume
     case MAXWELL3D_REG_INDEX(shadow_ram_control):
         shadow_state.shadow_ram_control = static_cast<Regs::ShadowRamControl>(nonshadow_argument);
         return;
-    case MAXWELL3D_REG_INDEX(macros.upload_address):
-        return macro_engine->ClearCode(regs.macros.upload_address);
     case MAXWELL3D_REG_INDEX(macros.data):
         return macro_engine->AddCode(regs.macros.upload_address, argument);
     case MAXWELL3D_REG_INDEX(macros.bind):

src/video_core/engines/maxwell_dma.cpp

@@ -134,8 +134,7 @@ void MaxwellDMA::CopyBlockLinearToPitch() {
 
     // Deswizzle the input and copy it over.
     UNIMPLEMENTED_IF(regs.launch_dma.remap_enable != 0);
-    const u32 bytes_per_pixel =
-        regs.launch_dma.remap_enable ? regs.pitch_out / regs.line_length_in : 1;
+    const u32 bytes_per_pixel = regs.pitch_out / regs.line_length_in;
     const Parameters& src_params = regs.src_params;
     const u32 width = src_params.width;
     const u32 height = src_params.height;
@@ -167,8 +166,7 @@ void MaxwellDMA::CopyPitchToBlockLinear() {
     UNIMPLEMENTED_IF(regs.launch_dma.remap_enable != 0);
 
     const auto& dst_params = regs.dst_params;
-    const u32 bytes_per_pixel =
-        regs.launch_dma.remap_enable ? regs.pitch_in / regs.line_length_in : 1;
+    const u32 bytes_per_pixel = regs.pitch_in / regs.line_length_in;
     const u32 width = dst_params.width;
     const u32 height = dst_params.height;
     const u32 depth = dst_params.depth;
@@ -212,8 +210,7 @@ void MaxwellDMA::CopyPitchToBlockLinear() {
 }
 
 void MaxwellDMA::FastCopyBlockLinearToPitch() {
-    const u32 bytes_per_pixel =
-        regs.launch_dma.remap_enable ? regs.pitch_out / regs.line_length_in : 1;
+    const u32 bytes_per_pixel = regs.pitch_out / regs.line_length_in;
     const size_t src_size = GOB_SIZE;
     const size_t dst_size = static_cast<size_t>(regs.pitch_out) * regs.line_count;
     u32 pos_x = regs.src_params.origin.x;

src/video_core/macro/macro.cpp

@@ -2,15 +2,11 @@
 // SPDX-License-Identifier: GPL-2.0-or-later
 
 #include <cstring>
-#include <fstream>
 #include <optional>
-#include <span>
 
 #include <boost/container_hash/hash.hpp>
 
 #include "common/assert.h"
-#include "common/fs/fs.h"
-#include "common/fs/path_util.h"
 #include "common/settings.h"
 #include "video_core/macro/macro.h"
 #include "video_core/macro/macro_hle.h"
@@ -19,23 +15,6 @@
 
 namespace Tegra {
 
-static void Dump(u64 hash, std::span<const u32> code) {
-    const auto base_dir{Common::FS::GetYuzuPath(Common::FS::YuzuPath::DumpDir)};
-    const auto macro_dir{base_dir / "macros"};
-    if (!Common::FS::CreateDir(base_dir) || !Common::FS::CreateDir(macro_dir)) {
-        LOG_ERROR(Common_Filesystem, "Failed to create macro dump directories");
-        return;
-    }
-    const auto name{macro_dir / fmt::format("{:016x}.macro", hash)};
-    std::fstream macro_file(name, std::ios::out | std::ios::binary);
-    if (!macro_file) {
-        LOG_ERROR(Common_Filesystem, "Unable to open or create file at {}",
-                  Common::FS::PathToUTF8String(name));
-        return;
-    }
-    macro_file.write(reinterpret_cast<const char*>(code.data()), code.size_bytes());
-}
-
 MacroEngine::MacroEngine(Engines::Maxwell3D& maxwell3d)
     : hle_macros{std::make_unique<Tegra::HLEMacro>(maxwell3d)} {}
 
@@ -45,11 +24,6 @@ void MacroEngine::AddCode(u32 method, u32 data) {
     uploaded_macro_code[method].push_back(data);
 }
 
-void MacroEngine::ClearCode(u32 method) {
-    macro_cache.erase(method);
-    uploaded_macro_code.erase(method);
-}
-
 void MacroEngine::Execute(u32 method, const std::vector<u32>& parameters) {
     auto compiled_macro = macro_cache.find(method);
     if (compiled_macro != macro_cache.end()) {
@@ -80,9 +54,6 @@ void MacroEngine::Execute(u32 method, const std::vector<u32>& parameters) {
         if (!mid_method.has_value()) {
             cache_info.lle_program = Compile(macro_code->second);
             cache_info.hash = boost::hash_value(macro_code->second);
-            if (Settings::values.dump_macros) {
-                Dump(cache_info.hash, macro_code->second);
-            }
         } else {
             const auto& macro_cached = uploaded_macro_code[mid_method.value()];
             const auto rebased_method = method - mid_method.value();
@@ -92,9 +63,6 @@ void MacroEngine::Execute(u32 method, const std::vector<u32>& parameters) {
                         code.size() * sizeof(u32));
             cache_info.hash = boost::hash_value(code);
             cache_info.lle_program = Compile(code);
-            if (Settings::values.dump_macros) {
-                Dump(cache_info.hash, code);
-            }
         }
 
         if (auto hle_program = hle_macros->GetHLEProgram(cache_info.hash)) {

src/video_core/macro/macro.h

@@ -117,9 +117,6 @@ public:
     // Store the uploaded macro code to compile them when they're called.
     void AddCode(u32 method, u32 data);
 
-    // Clear the code associated with a method.
-    void ClearCode(u32 method);
-
     // Compiles the macro if its not in the cache, and executes the compiled macro
     void Execute(u32 method, const std::vector<u32>& parameters);
 

src/video_core/macro/macro_jit_x64.cpp

@@ -23,8 +23,7 @@ MICROPROFILE_DEFINE(MacroJitExecute, "GPU", "Execute macro JIT", MP_RGB(255, 255
 namespace Tegra {
 namespace {
 constexpr Xbyak::Reg64 STATE = Xbyak::util::rbx;
-constexpr Xbyak::Reg32 RESULT = Xbyak::util::r10d;
-constexpr Xbyak::Reg64 MAX_PARAMETER = Xbyak::util::r11;
+constexpr Xbyak::Reg32 RESULT = Xbyak::util::ebp;
 constexpr Xbyak::Reg64 PARAMETERS = Xbyak::util::r12;
 constexpr Xbyak::Reg32 METHOD_ADDRESS = Xbyak::util::r14d;
 constexpr Xbyak::Reg64 BRANCH_HOLDER = Xbyak::util::r15;
@@ -32,7 +31,6 @@ constexpr Xbyak::Reg64 BRANCH_HOLDER = Xbyak::util::r15;
 constexpr std::bitset<32> PERSISTENT_REGISTERS = Common::X64::BuildRegSet({
     STATE,
     RESULT,
-    MAX_PARAMETER,
     PARAMETERS,
     METHOD_ADDRESS,
     BRANCH_HOLDER,
@@ -82,7 +80,7 @@ private:
         u32 carry_flag{};
     };
     static_assert(offsetof(JITState, maxwell3d) == 0, "Maxwell3D is not at 0x0");
-    using ProgramType = void (*)(JITState*, const u32*, const u32*);
+    using ProgramType = void (*)(JITState*, const u32*);
 
     struct OptimizerState {
         bool can_skip_carry{};
@@ -114,7 +112,7 @@ void MacroJITx64Impl::Execute(const std::vector<u32>& parameters, u32 method) {
     JITState state{};
     state.maxwell3d = &maxwell3d;
     state.registers = {};
-    program(&state, parameters.data(), parameters.data() + parameters.size());
+    program(&state, parameters.data());
 }
 
 void MacroJITx64Impl::Compile_ALU(Macro::Opcode opcode) {
@@ -490,7 +488,6 @@ void MacroJITx64Impl::Compile() {
     // JIT state
     mov(STATE, Common::X64::ABI_PARAM1);
     mov(PARAMETERS, Common::X64::ABI_PARAM2);
-    mov(MAX_PARAMETER, Common::X64::ABI_PARAM3);
     xor_(RESULT, RESULT);
     xor_(METHOD_ADDRESS, METHOD_ADDRESS);
     xor_(BRANCH_HOLDER, BRANCH_HOLDER);
@@ -601,22 +598,7 @@ bool MacroJITx64Impl::Compile_NextInstruction() {
     return true;
 }
 
-static void WarnInvalidParameter(uintptr_t parameter, uintptr_t max_parameter) {
-    LOG_CRITICAL(HW_GPU,
-                 "Macro JIT: invalid parameter access 0x{:x} (0x{:x} is the last parameter)",
-                 parameter, max_parameter - sizeof(u32));
-}
-
 Xbyak::Reg32 MacroJITx64Impl::Compile_FetchParameter() {
-    Xbyak::Label parameter_ok{};
-    cmp(PARAMETERS, MAX_PARAMETER);
-    jb(parameter_ok, T_NEAR);
-    Common::X64::ABI_PushRegistersAndAdjustStack(*this, PersistentCallerSavedRegs(), 0);
-    mov(Common::X64::ABI_PARAM1, PARAMETERS);
-    mov(Common::X64::ABI_PARAM2, MAX_PARAMETER);
-    Common::X64::CallFarFunction(*this, &WarnInvalidParameter);
-    Common::X64::ABI_PopRegistersAndAdjustStack(*this, PersistentCallerSavedRegs(), 0);
-    L(parameter_ok);
     mov(eax, dword[PARAMETERS]);
     add(PARAMETERS, sizeof(u32));
     return eax;

src/video_core/renderer_opengl/gl_rasterizer.cpp

@@ -563,11 +563,12 @@ void RasterizerOpenGL::SyncViewport() {
         flags[Dirty::FrontFace] = false;
 
         GLenum mode = MaxwellToGL::FrontFace(regs.front_face);
-        bool flip_faces = true;
-        if (regs.screen_y_control.triangle_rast_flip != 0) {
+        bool flip_faces = false;
+        if (regs.screen_y_control.triangle_rast_flip != 0 &&
+            regs.viewport_transform[0].scale_y < 0.0f) {
             flip_faces = !flip_faces;
         }
-        if (regs.viewport_transform[0].scale_y < 0.0f) {
+        if (regs.viewport_transform[0].scale_z < 0.0f) {
             flip_faces = !flip_faces;
         }
         if (flip_faces) {

src/yuzu/configuration/configure_debug.cpp

@@ -53,8 +53,6 @@ void ConfigureDebug::SetConfiguration() {
     ui->enable_nsight_aftermath->setChecked(Settings::values.enable_nsight_aftermath.GetValue());
     ui->dump_shaders->setEnabled(runtime_lock);
     ui->dump_shaders->setChecked(Settings::values.dump_shaders.GetValue());
-    ui->dump_macros->setEnabled(runtime_lock);
-    ui->dump_macros->setChecked(Settings::values.dump_macros.GetValue());
     ui->disable_macro_jit->setEnabled(runtime_lock);
     ui->disable_macro_jit->setChecked(Settings::values.disable_macro_jit.GetValue());
     ui->disable_loop_safety_checks->setEnabled(runtime_lock);
@@ -85,7 +83,6 @@ void ConfigureDebug::ApplyConfiguration() {
     Settings::values.cpu_debug_mode = ui->enable_cpu_debugging->isChecked();
     Settings::values.enable_nsight_aftermath = ui->enable_nsight_aftermath->isChecked();
     Settings::values.dump_shaders = ui->dump_shaders->isChecked();
-    Settings::values.dump_macros = ui->dump_macros->isChecked();
     Settings::values.disable_shader_loop_safety_checks =
         ui->disable_loop_safety_checks->isChecked();
     Settings::values.disable_macro_jit = ui->disable_macro_jit->isChecked();

src/yuzu/configuration/configure_debug.ui

@@ -118,19 +118,6 @@
         </property>
        </widget>
       </item>
-      <item row="0" column="2">
-       <widget class="QCheckBox" name="dump_macros">
-        <property name="enabled">
-         <bool>true</bool>
-        </property>
-        <property name="toolTip">
-         <string>When checked, it will dump all the macro programs of the GPU</string>
-        </property>
-        <property name="text">
-         <string>Dump Maxwell Macros</string>
-        </property>
-       </widget>
-      </item>
       <item row="0" column="1">
        <widget class="QCheckBox" name="disable_macro_jit">
         <property name="enabled">

src/yuzu/configuration/configure_input_player.cpp

@@ -520,28 +520,7 @@ ConfigureInputPlayer::ConfigureInputPlayer(QWidget* parent, std::size_t player_i
                         QMenu context_menu;
                         Common::ParamPackage param = emulated_controller->GetStickParam(analog_id);
                         context_menu.addAction(tr("Clear"), [&] {
-                            if (param.Get("engine", "") != "analog_from_button") {
-                                emulated_controller->SetStickParam(analog_id, {});
-                                for (auto button : analog_map_buttons[analog_id]) {
-                                    button->setText(tr("[not set]"));
-                                }
-                                return;
-                            }
-                            switch (sub_button_id) {
-                            case 0:
-                                param.Erase("up");
-                                break;
-                            case 1:
-                                param.Erase("down");
-                                break;
-                            case 2:
-                                param.Erase("left");
-                                break;
-                            case 3:
-                                param.Erase("right");
-                                break;
-                            }
-                            emulated_controller->SetStickParam(analog_id, param);
+                            emulated_controller->SetStickParam(analog_id, {});
                             analog_map_buttons[analog_id][sub_button_id]->setText(tr("[not set]"));
                         });
                         context_menu.addAction(tr("Center axis"), [&] {
@@ -1009,7 +988,7 @@ void ConfigureInputPlayer::UpdateUI() {
             slider_value = static_cast<int>(param.Get("deadzone", 0.15f) * 100);
             deadzone_label->setText(tr("Deadzone: %1%").arg(slider_value));
             deadzone_slider->setValue(slider_value);
-            range_spinbox->setValue(static_cast<int>(param.Get("range", 0.95f) * 100));
+            range_spinbox->setValue(static_cast<int>(param.Get("range", 1.0f) * 100));
         } else {
             slider_value = static_cast<int>(param.Get("modifier_scale", 0.5f) * 100);
             modifier_label->setText(tr("Modifier Range: %1%").arg(slider_value));

src/yuzu/configuration/configure_input_player.ui

@@ -754,13 +754,13 @@
                       <string>%</string>
                      </property>
                      <property name="minimum">
-                      <number>25</number>
+                      <number>50</number>
                      </property>
                      <property name="maximum">
                       <number>150</number>
                      </property>
                      <property name="value">
-                      <number>95</number>
+                      <number>100</number>
                      </property>
                     </widget>
                    </item>
@@ -2985,13 +2985,13 @@
                       <string>%</string>
                      </property>
                      <property name="minimum">
-                      <number>25</number>
+                      <number>50</number>
                      </property>
                      <property name="maximum">
                       <number>150</number>
                      </property>
                      <property name="value">
-                      <number>95</number>
+                      <number>100</number>
                      </property>
                     </widget>
                    </item>

src/yuzu/configuration/configure_network.cpp

@@ -26,15 +26,7 @@ void ConfigureNetwork::ApplyConfiguration() {
     Settings::values.network_interface = ui->network_interface->currentText().toStdString();
 }
 
-void ConfigureNetwork::changeEvent(QEvent* event) {
-    if (event->type() == QEvent::LanguageChange) {
-        RetranslateUI();
-    }
-
-    QWidget::changeEvent(event);
-}
-
-void ConfigureNetwork::RetranslateUI() {
+void ConfigureNetwork::RetranslateUi() {
     ui->retranslateUi(this);
 }
 

src/yuzu/configuration/configure_network.h

@@ -18,10 +18,9 @@ public:
     ~ConfigureNetwork() override;
 
     void ApplyConfiguration();
+    void RetranslateUi();
 
 private:
-    void changeEvent(QEvent*) override;
-    void RetranslateUI();
     void SetConfiguration();
 
     std::unique_ptr<Ui::ConfigureNetwork> ui;