diff --git a/Core/Config.cpp b/Core/Config.cpp index cecb2ba988..8114467109 100644 --- a/Core/Config.cpp +++ b/Core/Config.cpp @@ -1033,6 +1033,11 @@ static const ConfigSetting controlSettings[] = { ConfigSetting("AnalogIsCircular", SETTING(g_Config, bAnalogIsCircular), false, CfgFlag::PER_GAME), ConfigSetting("AnalogAutoRotSpeed", SETTING(g_Config, fAnalogAutoRotSpeed), 8.0f, CfgFlag::PER_GAME), + // Advanced analog deadzone settings. + ConfigSetting("AnalogDeadzoneShape", SETTING(g_Config, iAnalogDeadzoneShape), 1, CfgFlag::PER_GAME), // Default 1 (Square) matches legacy max-norm behavior + ConfigSetting("AnalogAxialDeadzone", SETTING(g_Config, fAnalogAxialDeadzone), 0.0f, CfgFlag::PER_GAME), + ConfigSetting("AnalogResponseCurve", SETTING(g_Config, iAnalogResponseCurve), 0, CfgFlag::PER_GAME), + ConfigSetting("AnalogLimiterDeadzone", SETTING(g_Config, fAnalogLimiterDeadzone), 0.6f, CfgFlag::DEFAULT), ConfigSetting("AnalogTriggerThreshold", SETTING(g_Config, fAnalogTriggerThreshold), 0.75f, CfgFlag::DEFAULT), ConfigSetting("AnalogStickThreshold", SETTING(g_Config, fAnalogStickThreshold), 0.75f, CfgFlag::DEFAULT), diff --git a/Core/Config.h b/Core/Config.h index 0ab8353c9f..08648c2d5f 100644 --- a/Core/Config.h +++ b/Core/Config.h @@ -515,6 +515,15 @@ public: // Auto rotation speed float fAnalogAutoRotSpeed; + // Advanced analog deadzone settings (Steam Input-style). + // Deadzone shape: 0 = Circle, 1 = Square (default, matches legacy max-norm), 2 = Cross + int iAnalogDeadzoneShape; + // Cross-shaped axial anti-deadzone. Boosts small off-axis values past this threshold, + // making the output skip the zone near each cardinal axis to prevent axis snapping. + float fAnalogAxialDeadzone; + // Response curve type: 0 = Linear, 1 = Aggressive, 2 = Relaxed, 3 = Wide + int iAnalogResponseCurve; + // Sets up how much the analog limiter button restricts digital->analog input. float fAnalogLimiterDeadzone; diff --git a/Core/ControlMapper.cpp b/Core/ControlMapper.cpp index 4553d50bbd..bc57961e6b 100644 --- a/Core/ControlMapper.cpp +++ b/Core/ControlMapper.cpp @@ -106,28 +106,66 @@ static bool IsSignedAxis(int axis) { } } +// Apply a response curve to a 0-1 magnitude value. +static float ApplyResponseCurve(float v, int curveType) { + switch (curveType) { + case 1: // Aggressive - fast response, reaches high output quickly + return sqrtf(v); + case 2: // Relaxed - more range devoted to fine/slow movement + return v * v; + case 3: // Wide - even more precision at low end + return v * v * v; + default: // Linear (0) - 1:1 mapping + return v; + } +} + +// Apply axial anti-deadzone to a single axis value. +// For non-zero inputs, boosts the output to at least the threshold value. +// This makes the output "skip" the zone near each axis, preventing the stick +// from lingering in the near-cardinal region. Pure cardinal (0.0) is still reachable. +static float ApplyAxialAntiDeadzone(float v, float antiDZ) { + if (antiDZ <= 0.0f || v == 0.0f) + return v; + float sign = v >= 0.0f ? 1.0f : -1.0f; + float absV = fabsf(v); + // Remap (0, 1] -> [antiDZ, 1]: any non-zero input jumps past the anti-deadzone threshold. + float remapped = antiDZ + absV * (1.0f - antiDZ); + return sign * Clamp(remapped, 0.0f, 1.0f); +} + // This is applied on the circular radius, not directly on the axes. -// TODO: Share logic with tilt? +// Adds a response curve stage on top of the legacy inner-deadzone + sensitivity processing. static float MapAxisValue(float v) { const float deadzone = g_Config.fAnalogDeadzone; const float invDeadzone = g_Config.fAnalogInverseDeadzone; const float sensitivity = g_Config.fAnalogSensitivity; + const int responseCurve = g_Config.iAnalogResponseCurve; const float sign = v >= 0.0f ? 1.0f : -1.0f; - // Apply deadzone. - v = Clamp((fabsf(v) - deadzone) / (1.0f - deadzone), 0.0f, 1.0f); + float absV = fabsf(v); - // Apply sensitivity and inverse deadzone. - if (v != 0.0f) { - v = Clamp(invDeadzone + v * (sensitivity - invDeadzone), 0.0f, 1.0f); + // Stage 1: Apply inner deadzone and rescale to [0, 1]. + absV = Clamp((absV - deadzone) / (1.0f - deadzone), 0.0f, 1.0f); + + // Stage 2: Apply sensitivity (legacy, matches prior behavior when response curve is Linear). + if (absV != 0.0f) { + absV = Clamp(invDeadzone + absV * (sensitivity - invDeadzone), 0.0f, 1.0f); } - return sign * v; + // Stage 3: Apply response curve. + if (absV != 0.0f) { + absV = ApplyResponseCurve(absV, responseCurve); + } + + return sign * Clamp(absV, 0.0f, 1.0f); } void ConvertAnalogStick(float x, float y, float *outX, float *outY) { const bool isCircular = g_Config.bAnalogIsCircular; + const int deadzoneShape = g_Config.iAnalogDeadzoneShape; + const float axialDZ = g_Config.fAnalogAxialDeadzone; float norm = std::max(fabsf(x), fabsf(y)); if (norm == 0.0f) { @@ -136,17 +174,30 @@ void ConvertAnalogStick(float x, float y, float *outX, float *outY) { return; } - if (isCircular) { + if (isCircular || deadzoneShape == 0) { + // Circle shape or legacy circular mode: use Euclidean norm. float newNorm = sqrtf(x * x + y * y); float factor = newNorm / norm; x *= factor; y *= factor; norm = newNorm; } + // deadzoneShape == 1 (Square) uses max norm (the default path, no conversion needed). + // deadzoneShape == 2 (Cross) also uses max norm for the radial processing. float mappedNorm = MapAxisValue(norm); *outX = Clamp(x / norm * mappedNorm, -1.0f, 1.0f); *outY = Clamp(y / norm * mappedNorm, -1.0f, 1.0f); + + // Final stage: Apply cross-shaped axial anti-deadzone. + // This boosts small non-zero axis values past the threshold, making the output + // "skip" the zone near each cardinal axis. This prevents the stick from lingering + // near cardinals and opens up the full diagonal range. + // Pure cardinals (0.0 on an axis) are still reachable. + if (deadzoneShape == 2 && axialDZ > 0.0f) { + *outX = ApplyAxialAntiDeadzone(*outX, axialDZ); + *outY = ApplyAxialAntiDeadzone(*outY, axialDZ); + } } void ControlMapper::SetPSPAxis(int device, int stick, char axis, float value) { diff --git a/UI/ControlMappingScreen.cpp b/UI/ControlMappingScreen.cpp index 48f2a771e6..c9d5516541 100644 --- a/UI/ControlMappingScreen.cpp +++ b/UI/ControlMappingScreen.cpp @@ -551,9 +551,27 @@ void AnalogCalibrationScreen::CreateSettingsViews(UI::ViewGroup *scrollContents) scrollContents->Add(new PopupSliderChoiceFloat(&g_Config.fAnalogDeadzone, 0.0f, 0.5f, 0.15f, co->T("Deadzone radius"), 0.01f, screenManager(), "/ 1.0")); scrollContents->Add(new PopupSliderChoiceFloat(&g_Config.fAnalogInverseDeadzone, 0.0f, 1.0f, 0.0f, co->T("Low end radius"), 0.01f, screenManager(), "/ 1.0")); scrollContents->Add(new PopupSliderChoiceFloat(&g_Config.fAnalogSensitivity, 0.0f, 2.0f, 1.1f, co->T("Sensitivity (scale)", "Sensitivity"), 0.01f, screenManager(), "x")); - // TODO: This should probably be a slider. - scrollContents->Add(new CheckBox(&g_Config.bAnalogIsCircular, co->T("Circular stick input"))); + // Legacy circular toggle. Disabled when deadzone shape is set to Circle, since that already provides circular behavior. + CheckBox *circularCheck = scrollContents->Add(new CheckBox(&g_Config.bAnalogIsCircular, co->T("Circular stick input"))); + circularCheck->SetEnabledFunc([] { + return g_Config.iAnalogDeadzoneShape != 0; // Disabled when shape is Circle (redundant) + }); scrollContents->Add(new PopupSliderChoiceFloat(&g_Config.fAnalogAutoRotSpeed, 0.1f, 20.0f, 8.0f, co->T("Auto-rotation speed"), 1.0f, screenManager())); + + // Advanced deadzone settings (Steam Input-style). + scrollContents->Add(new ItemHeader(co->T("Advanced Deadzone Settings"))); + + static const char *deadzoneShapes[] = { "Circle", "Square", "Cross" }; + scrollContents->Add(new PopupMultiChoice(&g_Config.iAnalogDeadzoneShape, co->T("Deadzone shape"), deadzoneShapes, 0, ARRAY_SIZE(deadzoneShapes), I18NCat::CONTROLS, screenManager())); + + PopupSliderChoiceFloat *axialDZ = scrollContents->Add(new PopupSliderChoiceFloat(&g_Config.fAnalogAxialDeadzone, 0.0f, 0.5f, 0.0f, co->T("Axial anti-deadzone"), 0.01f, screenManager(), "/ 1.0")); + axialDZ->SetEnabledFunc([] { + return g_Config.iAnalogDeadzoneShape == 2; // Only enabled for Cross shape + }); + + static const char *responseCurves[] = { "Linear", "Aggressive", "Relaxed", "Wide" }; + scrollContents->Add(new PopupMultiChoice(&g_Config.iAnalogResponseCurve, co->T("Response curve"), responseCurves, 0, ARRAY_SIZE(responseCurves), I18NCat::CONTROLS, screenManager())); + scrollContents->Add(new Choice(co->T("Reset to defaults")))->OnClick.Handle(this, &AnalogCalibrationScreen::OnResetToDefaults); } @@ -576,6 +594,10 @@ void AnalogCalibrationScreen::OnResetToDefaults(UI::EventParams &e) { g_Config.fAnalogSensitivity = 1.1f; g_Config.bAnalogIsCircular = false; g_Config.fAnalogAutoRotSpeed = 8.0f; + // Advanced settings + g_Config.iAnalogDeadzoneShape = 1; // Square (matches legacy default) + g_Config.fAnalogAxialDeadzone = 0.0f; + g_Config.iAnalogResponseCurve = 0; } class Backplate : public UI::InertView { diff --git a/UI/JoystickHistoryView.cpp b/UI/JoystickHistoryView.cpp index a7794ed3b5..72f171a29b 100644 --- a/UI/JoystickHistoryView.cpp +++ b/UI/JoystickHistoryView.cpp @@ -1,10 +1,13 @@ #include +#include #include "UI/JoystickHistoryView.h" +#include "Common/Math/math_util.h" #include "Common/UI/Context.h" #include "Common/UI/UI.h" +#include "Core/Config.h" #include "Core/ControlMapper.h" void JoystickHistoryView::Draw(UIContext &dc) { @@ -20,6 +23,22 @@ void JoystickHistoryView::Draw(UIContext &dc) { dc.Flush(); dc.BeginNoTex(); dc.Draw()->RectOutline(bounds_.centerX() - minRadius, bounds_.centerY() - minRadius, minRadius * 2.0f, minRadius * 2.0f, 0x80FFFFFF); + + // Draw cross-shaped deadzone strip outlines on the raw input view (untextured geometry). + if (type_ == StickHistoryViewType::INPUT) { + float cx = bounds_.centerX(); + float cy = bounds_.centerY(); + + // Cross-shaped (axial) deadzone strips. + if (g_Config.iAnalogDeadzoneShape == 2 && g_Config.fAnalogAxialDeadzone > 0.0f) { + float axialW = g_Config.fAnalogAxialDeadzone * minRadius; + // Vertical strip (X axis deadzone — zeroes X when |x| < threshold). + dc.Draw()->RectOutline(cx - axialW, cy - minRadius, axialW * 2.0f, minRadius * 2.0f, 0x604488FF); + // Horizontal strip (Y axis deadzone — zeroes Y when |y| < threshold). + dc.Draw()->RectOutline(cx - minRadius, cy - axialW, minRadius * 2.0f, axialW * 2.0f, 0x604488FF); + } + } + dc.Flush(); dc.Begin();