OrdinaryMagician/vkdoom_m
OrdinaryMagician/vkdoom_m
1
Fork 0
Code Activity

Revert "Gamepad Improvements"

Browse source 
This reverts commit 2a5cce543b.
This commit is contained in:
Marcus Minhorst 2025-07-06 19:06:59 -04:00 • committed by Ricardo Luís Vaz Silva
commit 0f72a671fc
16 changed files with 215 additions and 1613 deletions
Download patch file Download diff file Expand all files Collapse all files

112
src/common/platform/posix/cocoa/i_joystick.cpp
View file

@ -94,23 +94,15 @@ public:
virtual EJoyAxis GetAxisMap(int axis);
virtual const char* GetAxisName(int axis);
virtual float GetAxisScale(int axis);
float GetAxisDigitalThreshold(int axis);
EJoyCurve GetAxisResponseCurve(int axis);
float GetAxisResponseCurvePoint(int axis, int point);
virtual void SetAxisDeadZone(int axis, float deadZone);
virtual void SetAxisMap(int axis, EJoyAxis gameAxis);
virtual void SetAxisScale(int axis, float scale);
void SetAxisDigitalThreshold(int axis, float threshold);
void SetAxisResponseCurve(int axis, EJoyCurve preset);
void SetAxisResponseCurvePoint(int axis, int point, float value);
virtual bool IsSensitivityDefault();
virtual bool IsAxisDeadZoneDefault(int axis);
virtual bool IsAxisMapDefault(int axis);
virtual bool IsAxisScaleDefault(int axis);
bool IsAxisDigitalThresholdDefault(int axis);
bool IsAxisResponseCurveDefault(int axis);
virtual bool GetEnabled();
virtual void SetEnabled(bool enabled);
@ -154,11 +146,6 @@ private:
float defaultDeadZone;
float sensitivity;
float defaultSensitivity;
float digitalThreshold;
float defaultDigitalThreshold;
EJoyCurve responseCurvePreset;
EJoyCurve defaultResponseCurvePreset;
CubicBezier responseCurve;
EJoyAxis gameAxis;
EJoyAxis defaultGameAxis;
@ -190,6 +177,10 @@ private:
io_object_t m_notification;
static const float DEFAULT_DEADZONE;
static const float DEFAULT_SENSITIVITY;
void ProcessAxes();
bool ProcessAxis (const IOHIDEventStruct& event);
bool ProcessButton(const IOHIDEventStruct& event);
@ -209,6 +200,10 @@ private:
};
const float IOKitJoystick::DEFAULT_DEADZONE = 0.25f;
const float IOKitJoystick::DEFAULT_SENSITIVITY = 1.0f;
IOHIDDeviceInterface** CreateDeviceInterface(const io_object_t device)
{
IOCFPlugInInterface** plugInInterface = NULL;
@ -291,7 +286,7 @@ IOHIDQueueInterface** CreateDeviceQueue(IOHIDDeviceInterface** const interface)
IOKitJoystick::IOKitJoystick(const io_object_t device)
: m_interface(CreateDeviceInterface(device))
, m_queue(CreateDeviceQueue(m_interface))
, m_sensitivity(JOYSENSITIVITY_DEFAULT)
, m_sensitivity(DEFAULT_SENSITIVITY)
, m_enabled(true)
, m_useAxesPolling(true)
, m_notification(0)
@ -391,21 +386,6 @@ float IOKitJoystick::GetAxisScale(int axis)
return IS_AXIS_VALID ? m_axes[axis].sensitivity : 0.0f;
}
float IOKitJoystick::GetAxisDigitalThreshold(int axis)
{
return IS_AXIS_VALID ? m_axes[axis].digitalThreshold : JOYTHRESH_DEFAULT;
}
EJoyCurve IOKitJoystick::GetAxisResponseCurve(int axis)
{
return IS_AXIS_VALID ? m_axes[axis].responseCurvePreset : JOYCURVE_DEFAULT;
}
float IOKitJoystick::GetAxisResponseCurvePoint(int axis, int point)
{
return ( IS_AXIS_VALID && unsigned(point) < 4 )? m_axes[axis].responseCurve.pts[point] : 0;
}
void IOKitJoystick::SetAxisDeadZone(int axis, float deadZone)
{
if (IS_AXIS_VALID)
@ -432,37 +412,10 @@ void IOKitJoystick::SetAxisScale(int axis, float scale)
}
}
void IOKitJoystick::SetAxisDigitalThreshold(int axis, float threshold)
{
if (IS_AXIS_VALID)
{
m_axes[axis].digitalThreshold = threshold;
}
}
void IOKitJoystick::SetAxisResponseCurve(int axis, EJoyCurve preset)
{
if (IS_AXIS_VALID)
{
if (preset >= NUM_JOYCURVE || preset < JOYCURVE_CUSTOM) return;
m_axes[axis].responseCurvePreset = preset;
if (preset == JOYCURVE_CUSTOM) return;
m_axes[axis].responseCurve = JOYCURVE[preset];
}
}
void IOKitJoystick::SetAxisResponseCurvePoint(int axis, int point, float value)
{
if (IS_AXIS_VALID && unsigned(point) < 4)
{
m_axes[axis].responseCurvePreset = JOYCURVE_CUSTOM;
m_axes[axis].responseCurve.pts[point] = value;
}
}
bool IOKitJoystick::IsSensitivityDefault()
{
return JOYSENSITIVITY_DEFAULT == m_sensitivity;
return DEFAULT_SENSITIVITY == m_sensitivity;
}
bool IOKitJoystick::IsAxisDeadZoneDefault(int axis)
@ -486,19 +439,7 @@ bool IOKitJoystick::IsAxisScaleDefault(int axis)
: true;
}
bool IOKitJoystick::IsAxisDigitalThresholdDefault(int axis)
{
return IS_AXIS_VALID
? (m_axes[axis].digitalThreshold == m_axes[axis].defaultDigitalThreshold)
: true;
}
bool IOKitJoystick::IsAxisResponseCurveDefault(int axis)
{
return IS_AXIS_VALID
? m_axes[axis].responseCurvePreset == m_axes[axis].defaultResponseCurvePreset
: true;
}
bool IOKitJoystick::GetEnabled()
{
@ -513,18 +454,15 @@ void IOKitJoystick::SetEnabled(bool enabled)
void IOKitJoystick::SetDefaultConfig()
{
m_sensitivity = JOYSENSITIVITY_DEFAULT;
m_sensitivity = DEFAULT_SENSITIVITY;
const size_t axisCount = m_axes.Size();
for (size_t i = 0; i < axisCount; ++i)
{
m_axes[i].deadZone = JOYDEADZONE_DEFAULT;
m_axes[i].sensitivity = JOYSENSITIVITY_DEFAULT;
m_axes[i].deadZone = DEFAULT_DEADZONE;
m_axes[i].sensitivity = DEFAULT_SENSITIVITY;
m_axes[i].gameAxis = JOYAXIS_None;
m_axes[i].digitalThreshold = JOYTHRESH_DEFAULT;
m_axes[i].responseCurvePreset = JOYCURVE_DEFAULT;
m_axes[i].responseCurve = JOYCURVE[JOYCURVE_DEFAULT];
}
// Two axes? Horizontal is yaw and vertical is forward.
@ -532,10 +470,7 @@ void IOKitJoystick::SetDefaultConfig()
if (2 == axisCount)
{
m_axes[0].gameAxis = JOYAXIS_Yaw;
m_axes[0].digitalThreshold = JOYTHRESH_STICK_X;
m_axes[1].gameAxis = JOYAXIS_Forward;
m_axes[1].digitalThreshold = JOYTHRESH_STICK_Y;
}
// Three axes? First two are movement, third is yaw.
@ -543,13 +478,8 @@ void IOKitJoystick::SetDefaultConfig()
else if (axisCount >= 3)
{
m_axes[0].gameAxis = JOYAXIS_Side;
m_axes[0].digitalThreshold = JOYTHRESH_STICK_X;
m_axes[1].gameAxis = JOYAXIS_Forward;
m_axes[1].digitalThreshold = JOYTHRESH_STICK_Y;
m_axes[2].gameAxis = JOYAXIS_Yaw;
m_axes[2].digitalThreshold = JOYTHRESH_STICK_X;
// Four axes? First two are movement, last two are looking around.
@ -557,14 +487,12 @@ void IOKitJoystick::SetDefaultConfig()
{
m_axes[3].gameAxis = JOYAXIS_Pitch;
// ??? m_axes[3].sensitivity = 0.75f;
m_axes[3].digitalThreshold = JOYTHRESH_STICK_Y;
// Five axes? Use the fifth one for moving up and down.
if (axisCount >= 5)
{
m_axes[4].gameAxis = JOYAXIS_Up;
m_axes[4].digitalThreshold = JOYTHRESH_STICK_Y;
}
}
}
@ -576,11 +504,9 @@ void IOKitJoystick::SetDefaultConfig()
for (size_t i = 0; i < axisCount; ++i)
{
m_axes[i].defaultDeadZone = m_axes[i].deadZone;
m_axes[i].defaultSensitivity = m_axes[i].sensitivity;
m_axes[i].defaultGameAxis = m_axes[i].gameAxis;
m_axes[i].defaultDigitalThreshold = m_axes[i].digitalThreshold;
m_axes[i].defaultResponseCurvePreset = m_axes[i].responseCurvePreset;
m_axes[i].defaultDeadZone = m_axes[i].deadZone;
m_axes[i].defaultSensitivity = m_axes[i].sensitivity;
m_axes[i].defaultGameAxis = m_axes[i].gameAxis;
}
}
@ -676,9 +602,8 @@ void IOKitJoystick::ProcessAxes()
const double scaledValue = scaledMin +
(event.value - axis.minValue) * (scaledMax - scaledMin) / (axis.maxValue - axis.minValue);
const double filteredValue = Joy_RemoveDeadZone(scaledValue, axis.deadZone, NULL);
const double smoothedValue = Joy_ApplyResponseCurveBezier(axis.responseCurve, filteredValue);
axis.value = static_cast<float>(smoothedValue * m_sensitivity * axis.sensitivity);
axis.value = static_cast<float>(filteredValue * m_sensitivity * axis.sensitivity);
}
else
{
@ -710,9 +635,8 @@ bool IOKitJoystick::ProcessAxis(const IOHIDEventStruct& event)
const double scaledValue = scaledMin +
(event.value - axis.minValue) * (scaledMax - scaledMin) / (axis.maxValue - axis.minValue);
const double filteredValue = Joy_RemoveDeadZone(scaledValue, axis.deadZone, NULL);
const double smoothedValue = Joy_ApplyResponseCurveBezier(axis.responseCurve, filteredValue);
axis.value = static_cast<float>(smoothedValue * m_sensitivity * axis.sensitivity);
axis.value = static_cast<float>(filteredValue * m_sensitivity * axis.sensitivity);
return true;
}

250
src/common/platform/posix/sdl/i_input.cpp
View file

@ -31,14 +31,11 @@
**
*/
#include <SDL.h>
#include <SDL_events.h>
#include "i_input.h"
#include "c_cvars.h"
#include "dobject.h"
#include "m_argv.h"
#include "m_joy.h"
#include "v_video.h"
#include "d_eventbase.h"
#include "d_gui.h"
#include "c_buttons.h"
#include "c_console.h"
@ -50,147 +47,88 @@
#include "engineerrors.h"
#include "i_interface.h"
static void I_CheckGUICapture ();
static void I_CheckNativeMouse ();
bool GUICapture;
static bool NativeMouse = true;
CVAR (Bool, use_mouse, true, CVAR_ARCHIVE|CVAR_GLOBALCONFIG)
extern int WaitingForKey;
static const SDL_Keycode DIKToKeySym[256] =
{
SDLK_UNKNOWN, SDLK_ESCAPE, SDLK_1, SDLK_2,
SDLK_3, SDLK_4, SDLK_5, SDLK_6,
SDLK_7, SDLK_8, SDLK_9, SDLK_0,
SDLK_MINUS, SDLK_EQUALS, SDLK_BACKSPACE, SDLK_TAB,
SDLK_q, SDLK_w, SDLK_e, SDLK_r,
SDLK_t, SDLK_y, SDLK_u, SDLK_i,
SDLK_o, SDLK_p, SDLK_LEFTBRACKET, SDLK_RIGHTBRACKET,
SDLK_RETURN, SDLK_LCTRL, SDLK_a, SDLK_s,
SDLK_d, SDLK_f, SDLK_g, SDLK_h,
SDLK_j, SDLK_k, SDLK_l, SDLK_SEMICOLON,
SDLK_QUOTE, SDLK_BACKQUOTE, SDLK_LSHIFT, SDLK_BACKSLASH,
SDLK_z, SDLK_x, SDLK_c, SDLK_v,
SDLK_b, SDLK_n, SDLK_m, SDLK_COMMA,
SDLK_PERIOD, SDLK_SLASH, SDLK_RSHIFT, SDLK_KP_MULTIPLY,
SDLK_LALT, SDLK_SPACE, SDLK_CAPSLOCK, SDLK_F1,
SDLK_F2, SDLK_F3, SDLK_F4, SDLK_F5,
SDLK_F6, SDLK_F7, SDLK_F8, SDLK_F9,
SDLK_F10, SDLK_NUMLOCKCLEAR, SDLK_SCROLLLOCK, SDLK_KP_7,
SDLK_KP_8, SDLK_KP_9, SDLK_KP_MINUS, SDLK_KP_4,
SDLK_KP_5, SDLK_KP_6, SDLK_KP_PLUS, SDLK_KP_1,
SDLK_KP_2, SDLK_KP_3, SDLK_KP_0, SDLK_KP_PERIOD,
SDLK_UNKNOWN, SDLK_UNKNOWN, SDLK_UNKNOWN, SDLK_F11,
SDLK_F12, SDLK_UNKNOWN, SDLK_UNKNOWN, SDLK_UNKNOWN,
SDLK_UNKNOWN, SDLK_UNKNOWN, SDLK_UNKNOWN, SDLK_UNKNOWN,
SDLK_UNKNOWN, SDLK_UNKNOWN, SDLK_UNKNOWN, SDLK_UNKNOWN,
SDLK_F13, SDLK_F14, SDLK_F15, SDLK_F16,
SDLK_F17, SDLK_F18, SDLK_F19, SDLK_F20,
SDLK_F21, SDLK_F22, SDLK_F23, SDLK_F24,
SDLK_UNKNOWN, SDLK_UNKNOWN, SDLK_UNKNOWN, SDLK_UNKNOWN,
SDLK_UNKNOWN, SDLK_UNKNOWN, SDLK_UNKNOWN, SDLK_UNKNOWN,
SDLK_UNKNOWN, SDLK_UNKNOWN, SDLK_UNKNOWN, SDLK_UNKNOWN,
SDLK_UNKNOWN, SDLK_UNKNOWN, SDLK_UNKNOWN, SDLK_UNKNOWN,
SDLK_UNKNOWN, SDLK_UNKNOWN, SDLK_UNKNOWN, SDLK_UNKNOWN,
SDLK_UNKNOWN, SDLK_UNKNOWN, SDLK_UNKNOWN, SDLK_UNKNOWN,
SDLK_UNKNOWN, SDLK_UNKNOWN, SDLK_UNKNOWN, SDLK_UNKNOWN,
SDLK_UNKNOWN, SDLK_KP_EQUALS, SDLK_UNKNOWN, SDLK_UNKNOWN,
SDLK_UNKNOWN, SDLK_AT, SDLK_COLON, SDLK_UNKNOWN,
SDLK_UNKNOWN, SDLK_UNKNOWN, SDLK_UNKNOWN, SDLK_UNKNOWN,
SDLK_UNKNOWN, SDLK_UNKNOWN, SDLK_UNKNOWN, SDLK_UNKNOWN,
SDLK_KP_ENTER, SDLK_RCTRL, SDLK_UNKNOWN, SDLK_UNKNOWN,
SDLK_UNKNOWN, SDLK_UNKNOWN, SDLK_UNKNOWN, SDLK_UNKNOWN,
SDLK_UNKNOWN, SDLK_UNKNOWN, SDLK_UNKNOWN, SDLK_UNKNOWN,
SDLK_UNKNOWN, SDLK_UNKNOWN, SDLK_UNKNOWN, SDLK_UNKNOWN,
SDLK_UNKNOWN, SDLK_UNKNOWN, SDLK_UNKNOWN, SDLK_UNKNOWN,
SDLK_UNKNOWN, SDLK_UNKNOWN, SDLK_UNKNOWN, SDLK_KP_COMMA,
SDLK_UNKNOWN, SDLK_KP_DIVIDE, SDLK_UNKNOWN, SDLK_SYSREQ,
SDLK_RALT, SDLK_UNKNOWN, SDLK_UNKNOWN, SDLK_UNKNOWN,
SDLK_UNKNOWN, SDLK_UNKNOWN, SDLK_UNKNOWN, SDLK_UNKNOWN,
SDLK_UNKNOWN, SDLK_UNKNOWN, SDLK_UNKNOWN, SDLK_UNKNOWN,
SDLK_UNKNOWN, SDLK_PAUSE, SDLK_UNKNOWN, SDLK_HOME,
SDLK_UP, SDLK_PAGEUP, SDLK_UNKNOWN, SDLK_LEFT,
SDLK_UNKNOWN, SDLK_RIGHT, SDLK_UNKNOWN, SDLK_END,
SDLK_DOWN, SDLK_PAGEDOWN, SDLK_INSERT, SDLK_DELETE,
SDLK_UNKNOWN, SDLK_UNKNOWN, SDLK_UNKNOWN, SDLK_UNKNOWN,
SDLK_UNKNOWN, SDLK_UNKNOWN, SDLK_UNKNOWN, SDLK_LGUI,
SDLK_RGUI, SDLK_MENU, SDLK_POWER, SDLK_SLEEP,
SDLK_UNKNOWN, SDLK_UNKNOWN, SDLK_UNKNOWN, SDLK_UNKNOWN,
SDLK_UNKNOWN, SDLK_AC_SEARCH, SDLK_AC_BOOKMARKS, SDLK_AC_REFRESH,
SDLK_AC_STOP, SDLK_AC_FORWARD, SDLK_AC_BACK, SDLK_COMPUTER,
SDLK_MAIL, SDLK_MEDIASELECT, SDLK_UNKNOWN, SDLK_UNKNOWN,
SDLK_UNKNOWN, SDLK_UNKNOWN, SDLK_UNKNOWN, SDLK_UNKNOWN,
SDLK_UNKNOWN, SDLK_UNKNOWN, SDLK_UNKNOWN, SDLK_UNKNOWN,
SDLK_UNKNOWN, SDLK_UNKNOWN, SDLK_UNKNOWN, SDLK_UNKNOWN,
SDLK_UNKNOWN, SDLK_UNKNOWN, SDLK_UNKNOWN, SDLK_UNKNOWN
0, SDLK_ESCAPE, SDLK_1, SDLK_2, SDLK_3, SDLK_4, SDLK_5, SDLK_6,
SDLK_7, SDLK_8, SDLK_9, SDLK_0,SDLK_MINUS, SDLK_EQUALS, SDLK_BACKSPACE, SDLK_TAB,
SDLK_q, SDLK_w, SDLK_e, SDLK_r, SDLK_t, SDLK_y, SDLK_u, SDLK_i,
SDLK_o, SDLK_p, SDLK_LEFTBRACKET, SDLK_RIGHTBRACKET, SDLK_RETURN, SDLK_LCTRL, SDLK_a, SDLK_s,
SDLK_d, SDLK_f, SDLK_g, SDLK_h, SDLK_j, SDLK_k, SDLK_l, SDLK_SEMICOLON,
SDLK_QUOTE, SDLK_BACKQUOTE, SDLK_LSHIFT, SDLK_BACKSLASH, SDLK_z, SDLK_x, SDLK_c, SDLK_v,
SDLK_b, SDLK_n, SDLK_m, SDLK_COMMA, SDLK_PERIOD, SDLK_SLASH, SDLK_RSHIFT, SDLK_KP_MULTIPLY,
SDLK_LALT, SDLK_SPACE, SDLK_CAPSLOCK, SDLK_F1, SDLK_F2, SDLK_F3, SDLK_F4, SDLK_F5,
SDLK_F6, SDLK_F7, SDLK_F8, SDLK_F9, SDLK_F10, SDLK_NUMLOCKCLEAR, SDLK_SCROLLLOCK, SDLK_KP_7,
SDLK_KP_8, SDLK_KP_9, SDLK_KP_MINUS, SDLK_KP_4, SDLK_KP_5, SDLK_KP_6, SDLK_KP_PLUS, SDLK_KP_1,
SDLK_KP_2, SDLK_KP_3, SDLK_KP_0, SDLK_KP_PERIOD, 0, 0, 0, SDLK_F11,
SDLK_F12, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, SDLK_F13, SDLK_F14, SDLK_F15, SDLK_F16,
SDLK_F17, SDLK_F18, SDLK_F19, SDLK_F20, SDLK_F21, SDLK_F22, SDLK_F23, SDLK_F24,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, SDLK_KP_EQUALS, 0, 0,
0, SDLK_AT, SDLK_COLON, 0, 0, 0, 0, 0,
0, 0, 0, 0, SDLK_KP_ENTER, SDLK_RCTRL, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, SDLK_KP_COMMA, 0, SDLK_KP_DIVIDE, 0, SDLK_SYSREQ,
SDLK_RALT, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, SDLK_PAUSE, 0, SDLK_HOME,
SDLK_UP, SDLK_PAGEUP, 0, SDLK_LEFT, 0, SDLK_RIGHT, 0, SDLK_END,
SDLK_DOWN, SDLK_PAGEDOWN, SDLK_INSERT, SDLK_DELETE, 0, 0, 0, 0,
0, 0, 0, SDLK_LGUI, SDLK_RGUI, SDLK_MENU, SDLK_POWER, SDLK_SLEEP,
0, 0, 0, 0, 0, SDLK_AC_SEARCH, SDLK_AC_BOOKMARKS, SDLK_AC_REFRESH,
SDLK_AC_STOP, SDLK_AC_FORWARD, SDLK_AC_BACK, SDLK_COMPUTER, SDLK_MAIL, SDLK_MEDIASELECT, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0
};
static const SDL_Scancode DIKToKeyScan[256] =
{
SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_ESCAPE, SDL_SCANCODE_1, SDL_SCANCODE_2,
SDL_SCANCODE_3, SDL_SCANCODE_4, SDL_SCANCODE_5, SDL_SCANCODE_6,
SDL_SCANCODE_7, SDL_SCANCODE_8, SDL_SCANCODE_9, SDL_SCANCODE_0,
SDL_SCANCODE_MINUS, SDL_SCANCODE_EQUALS, SDL_SCANCODE_BACKSPACE, SDL_SCANCODE_TAB,
SDL_SCANCODE_Q, SDL_SCANCODE_W, SDL_SCANCODE_E, SDL_SCANCODE_R,
SDL_SCANCODE_T, SDL_SCANCODE_Y, SDL_SCANCODE_U, SDL_SCANCODE_I,
SDL_SCANCODE_O, SDL_SCANCODE_P, SDL_SCANCODE_LEFTBRACKET, SDL_SCANCODE_RIGHTBRACKET,
SDL_SCANCODE_RETURN, SDL_SCANCODE_LCTRL, SDL_SCANCODE_A, SDL_SCANCODE_S,
SDL_SCANCODE_D, SDL_SCANCODE_F, SDL_SCANCODE_G, SDL_SCANCODE_H,
SDL_SCANCODE_J, SDL_SCANCODE_K, SDL_SCANCODE_L, SDL_SCANCODE_SEMICOLON,
SDL_SCANCODE_APOSTROPHE, SDL_SCANCODE_GRAVE, SDL_SCANCODE_LSHIFT, SDL_SCANCODE_BACKSLASH,
SDL_SCANCODE_Z, SDL_SCANCODE_X, SDL_SCANCODE_C, SDL_SCANCODE_V,
SDL_SCANCODE_B, SDL_SCANCODE_N, SDL_SCANCODE_M, SDL_SCANCODE_COMMA,
SDL_SCANCODE_PERIOD, SDL_SCANCODE_SLASH, SDL_SCANCODE_RSHIFT, SDL_SCANCODE_KP_MULTIPLY,
SDL_SCANCODE_LALT, SDL_SCANCODE_SPACE, SDL_SCANCODE_CAPSLOCK, SDL_SCANCODE_F1,
SDL_SCANCODE_F2, SDL_SCANCODE_F3, SDL_SCANCODE_F4, SDL_SCANCODE_F5,
SDL_SCANCODE_F6, SDL_SCANCODE_F7, SDL_SCANCODE_F8, SDL_SCANCODE_F9,
SDL_SCANCODE_F10, SDL_SCANCODE_NUMLOCKCLEAR, SDL_SCANCODE_SCROLLLOCK, SDL_SCANCODE_KP_7,
SDL_SCANCODE_KP_8, SDL_SCANCODE_KP_9, SDL_SCANCODE_KP_MINUS, SDL_SCANCODE_KP_4,
SDL_SCANCODE_KP_5, SDL_SCANCODE_KP_6, SDL_SCANCODE_KP_PLUS, SDL_SCANCODE_KP_1,
SDL_SCANCODE_KP_2, SDL_SCANCODE_KP_3, SDL_SCANCODE_KP_0, SDL_SCANCODE_KP_PERIOD,
SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_F11,
SDL_SCANCODE_F12, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN,
SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN,
SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN,
SDL_SCANCODE_F13, SDL_SCANCODE_F14, SDL_SCANCODE_F15, SDL_SCANCODE_F16,
SDL_SCANCODE_F17, SDL_SCANCODE_F18, SDL_SCANCODE_F19, SDL_SCANCODE_F20,
SDL_SCANCODE_F21, SDL_SCANCODE_F22, SDL_SCANCODE_F23, SDL_SCANCODE_F24,
SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN,
SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN,
SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN,
SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN,
SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN,
SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN,
SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN,
SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_KP_EQUALS, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN,
SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN,
SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN,
SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN,
SDL_SCANCODE_KP_ENTER, SDL_SCANCODE_RCTRL, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN,
SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN,
SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN,
SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN,
SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN,
SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_KP_COMMA,
SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_KP_DIVIDE, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_SYSREQ,
SDL_SCANCODE_RALT, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN,
SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN,
SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN,
SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_PAUSE, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_HOME,
SDL_SCANCODE_UP, SDL_SCANCODE_PAGEUP, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_LEFT,
SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_RIGHT, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_END,
SDL_SCANCODE_DOWN, SDL_SCANCODE_PAGEDOWN, SDL_SCANCODE_INSERT, SDL_SCANCODE_DELETE,
SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN,
SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_LGUI,
SDL_SCANCODE_RGUI, SDL_SCANCODE_MENU, SDL_SCANCODE_POWER, SDL_SCANCODE_SLEEP,
SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN,
SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_AC_SEARCH, SDL_SCANCODE_AC_BOOKMARKS, SDL_SCANCODE_AC_REFRESH,
SDL_SCANCODE_AC_STOP, SDL_SCANCODE_AC_FORWARD, SDL_SCANCODE_AC_BACK, SDL_SCANCODE_COMPUTER,
SDL_SCANCODE_MAIL, SDL_SCANCODE_MEDIASELECT, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN,
SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN,
SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN,
SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN,
SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN
SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_ESCAPE, SDL_SCANCODE_1, SDL_SCANCODE_2, SDL_SCANCODE_3, SDL_SCANCODE_4, SDL_SCANCODE_5, SDL_SCANCODE_6,
SDL_SCANCODE_7, SDL_SCANCODE_8, SDL_SCANCODE_9, SDL_SCANCODE_0 ,SDL_SCANCODE_MINUS, SDL_SCANCODE_EQUALS, SDL_SCANCODE_BACKSPACE, SDL_SCANCODE_TAB,
SDL_SCANCODE_Q, SDL_SCANCODE_W, SDL_SCANCODE_E, SDL_SCANCODE_R, SDL_SCANCODE_T, SDL_SCANCODE_Y, SDL_SCANCODE_U, SDL_SCANCODE_I,
SDL_SCANCODE_O, SDL_SCANCODE_P, SDL_SCANCODE_LEFTBRACKET, SDL_SCANCODE_RIGHTBRACKET, SDL_SCANCODE_RETURN, SDL_SCANCODE_LCTRL, SDL_SCANCODE_A, SDL_SCANCODE_S,
SDL_SCANCODE_D, SDL_SCANCODE_F, SDL_SCANCODE_G, SDL_SCANCODE_H, SDL_SCANCODE_J, SDL_SCANCODE_K, SDL_SCANCODE_L, SDL_SCANCODE_SEMICOLON,
SDL_SCANCODE_APOSTROPHE, SDL_SCANCODE_GRAVE, SDL_SCANCODE_LSHIFT, SDL_SCANCODE_BACKSLASH, SDL_SCANCODE_Z, SDL_SCANCODE_X, SDL_SCANCODE_C, SDL_SCANCODE_V,
SDL_SCANCODE_B, SDL_SCANCODE_N, SDL_SCANCODE_M, SDL_SCANCODE_COMMA, SDL_SCANCODE_PERIOD, SDL_SCANCODE_SLASH, SDL_SCANCODE_RSHIFT, SDL_SCANCODE_KP_MULTIPLY,
SDL_SCANCODE_LALT, SDL_SCANCODE_SPACE, SDL_SCANCODE_CAPSLOCK, SDL_SCANCODE_F1, SDL_SCANCODE_F2, SDL_SCANCODE_F3, SDL_SCANCODE_F4, SDL_SCANCODE_F5,
SDL_SCANCODE_F6, SDL_SCANCODE_F7, SDL_SCANCODE_F8, SDL_SCANCODE_F9, SDL_SCANCODE_F10, SDL_SCANCODE_NUMLOCKCLEAR, SDL_SCANCODE_SCROLLLOCK, SDL_SCANCODE_KP_7,
SDL_SCANCODE_KP_8, SDL_SCANCODE_KP_9, SDL_SCANCODE_KP_MINUS, SDL_SCANCODE_KP_4, SDL_SCANCODE_KP_5, SDL_SCANCODE_KP_6, SDL_SCANCODE_KP_PLUS, SDL_SCANCODE_KP_1,
SDL_SCANCODE_KP_2, SDL_SCANCODE_KP_3, SDL_SCANCODE_KP_0, SDL_SCANCODE_KP_PERIOD, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_F11,
SDL_SCANCODE_F12, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN,
SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_F13, SDL_SCANCODE_F14, SDL_SCANCODE_F15, SDL_SCANCODE_F16,
SDL_SCANCODE_F17, SDL_SCANCODE_F18, SDL_SCANCODE_F19, SDL_SCANCODE_F20, SDL_SCANCODE_F21, SDL_SCANCODE_F22, SDL_SCANCODE_F23, SDL_SCANCODE_F24,
SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN,
SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN,
SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN,
SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_KP_EQUALS, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN,
SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN,
SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_KP_ENTER, SDL_SCANCODE_RCTRL, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN,
SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN,
SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN,
SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_KP_COMMA, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_KP_DIVIDE, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_SYSREQ,
SDL_SCANCODE_RALT, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN,
SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_PAUSE, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_HOME,
SDL_SCANCODE_UP, SDL_SCANCODE_PAGEUP, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_LEFT, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_RIGHT, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_END,
SDL_SCANCODE_DOWN, SDL_SCANCODE_PAGEDOWN, SDL_SCANCODE_INSERT, SDL_SCANCODE_DELETE, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN,
SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_LGUI, SDL_SCANCODE_RGUI, SDL_SCANCODE_MENU, SDL_SCANCODE_POWER, SDL_SCANCODE_SLEEP,
SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_AC_SEARCH, SDL_SCANCODE_AC_BOOKMARKS, SDL_SCANCODE_AC_REFRESH,
SDL_SCANCODE_AC_STOP, SDL_SCANCODE_AC_FORWARD, SDL_SCANCODE_AC_BACK, SDL_SCANCODE_COMPUTER, SDL_SCANCODE_MAIL, SDL_SCANCODE_MEDIASELECT, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN,
SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN,
SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN
};
static TMap<SDL_Keycode, uint8_t> InitKeySymMap ()
@ -525,60 +463,14 @@ void MessagePump (const SDL_Event &sev)
case SDL_JOYBUTTONDOWN:
case SDL_JOYBUTTONUP:
if (SDL_GameControllerFromInstanceID(sev.jdevice.which))
break; // let SDL_CONTROLLERBUTTON* handle this
event.type = sev.type == SDL_JOYBUTTONDOWN ? EV_KeyDown : EV_KeyUp;
event.data1 = KEY_FIRSTJOYBUTTON + sev.jbutton.button;
if(event.data1 != 0)
I_JoyConsumeEvent(sev.jdevice.which, &event);
break;
case SDL_CONTROLLERBUTTONDOWN:
case SDL_CONTROLLERBUTTONUP:
event.type = sev.type == SDL_CONTROLLERBUTTONDOWN ? EV_KeyDown : EV_KeyUp;
switch (sev.cbutton.button)
{
case SDL_CONTROLLER_BUTTON_A: event.data1 = KEY_PAD_A; break;
case SDL_CONTROLLER_BUTTON_B: event.data1 = KEY_PAD_B; break;
case SDL_CONTROLLER_BUTTON_X: event.data1 = KEY_PAD_X; break;
case SDL_CONTROLLER_BUTTON_Y: event.data1 = KEY_PAD_Y; break;
case SDL_CONTROLLER_BUTTON_BACK: event.data1 = KEY_PAD_BACK; break;
case SDL_CONTROLLER_BUTTON_GUIDE: event.data1 = KEY_PAD_GUIDE; break;
case SDL_CONTROLLER_BUTTON_START: event.data1 = KEY_PAD_START; break;
case SDL_CONTROLLER_BUTTON_LEFTSTICK: event.data1 = KEY_PAD_LTHUMB; break;
case SDL_CONTROLLER_BUTTON_RIGHTSTICK: event.data1 = KEY_PAD_RTHUMB; break;
case SDL_CONTROLLER_BUTTON_LEFTSHOULDER: event.data1 = KEY_PAD_LSHOULDER; break;
case SDL_CONTROLLER_BUTTON_RIGHTSHOULDER: event.data1 = KEY_PAD_RSHOULDER; break;
case SDL_CONTROLLER_BUTTON_DPAD_UP: event.data1 = KEY_PAD_DPAD_UP; break;
case SDL_CONTROLLER_BUTTON_DPAD_DOWN: event.data1 = KEY_PAD_DPAD_DOWN; break;
case SDL_CONTROLLER_BUTTON_DPAD_LEFT: event.data1 = KEY_PAD_DPAD_LEFT; break;
case SDL_CONTROLLER_BUTTON_DPAD_RIGHT: event.data1 = KEY_PAD_DPAD_RIGHT; break;
case SDL_CONTROLLER_BUTTON_MISC1: event.data1 = KEY_PAD_MISC1; break;
case SDL_CONTROLLER_BUTTON_PADDLE1: event.data1 = KEY_PAD_PADDLE1; break;
case SDL_CONTROLLER_BUTTON_PADDLE2: event.data1 = KEY_PAD_PADDLE2; break;
case SDL_CONTROLLER_BUTTON_PADDLE3: event.data1 = KEY_PAD_PADDLE3; break;
case SDL_CONTROLLER_BUTTON_PADDLE4: event.data1 = KEY_PAD_PADDLE4; break;
case SDL_CONTROLLER_BUTTON_TOUCHPAD: event.data1 = KEY_PAD_TOUCHPAD; break;
default: event.data1 = 0;
}
if(event.data1 != 0)
I_JoyConsumeEvent(sev.cbutton.which, &event);
D_PostEvent(&event);
break;
case SDL_JOYDEVICEADDED:
case SDL_CONTROLLERDEVICEADDED:
if (sev.type == SDL_JOYDEVICEADDED && SDL_IsGameController(sev.jdevice.which)) // DeviceIndex Here
break; // skip double event
I_UpdateDeviceList();
event.type = EV_DeviceChange;
D_PostEvent (&event);
break;
case SDL_JOYDEVICEREMOVED:
case SDL_CONTROLLERDEVICEREMOVED:
case SDL_CONTROLLERDEVICEREMAPPED:
if (sev.type == SDL_JOYDEVICEREMOVED && SDL_GameControllerFromInstanceID(sev.jdevice.which))
break; // skip double event
I_UpdateDeviceList();
event.type = EV_DeviceChange;
D_PostEvent (&event);

13
src/common/platform/posix/sdl/i_input.h
View file

@ -1,13 +0,0 @@
#ifndef I_INPUT_H
#define I_INPUT_H
#include "d_eventbase.h"
extern int WaitingForKey;
static void I_CheckGUICapture ();
static void I_CheckNativeMouse ();
void I_JoyConsumeEvent(int instanceID, event_t * event);
#endif

384
src/common/platform/posix/sdl/i_joystick.cpp
View file

@ -31,80 +31,47 @@
**
*/
#include <SDL.h>
#include <SDL_gamecontroller.h>
#include <cstdlib>
#include "basics.h"
#include "cmdlib.h"
#include "d_eventbase.h"
#include "i_input.h"
#include "m_joy.h"
#include "keydef.h"
#define DEFAULT_DEADZONE 0.25f;
// Very small deadzone so that floating point magic doesn't happen
#define MIN_DEADZONE 0.000001f
class SDLInputJoystick: public IJoystickConfig
{
public:
SDLInputJoystick(int DeviceIndex) :
DeviceIndex(DeviceIndex),
InstanceID(SDL_JoystickGetDeviceInstanceID(DeviceIndex)),
Multiplier(JOYSENSITIVITY_DEFAULT),
Enabled(true),
SettingsChanged(false)
SDLInputJoystick(int DeviceIndex) : DeviceIndex(DeviceIndex), Multiplier(1.0f) , Enabled(true)
{
if (SDL_IsGameController(DeviceIndex))
Device = SDL_JoystickOpen(DeviceIndex);
if(Device != NULL)
{
Mapping = SDL_GameControllerOpen(DeviceIndex);
Device = NULL;
NumAxes = SDL_JoystickNumAxes(Device);
NumHats = SDL_JoystickNumHats(Device);
DefaultAxes = DefaultControllerAxes;
DefaultAxesCount = sizeof(DefaultControllerAxes) / sizeof(DefaultAxisConfig);
if(Mapping != NULL)
{
NumAxes = SDL_CONTROLLER_AXIS_MAX;
NumHats = 0;
SetDefaultConfig();
}
SetDefaultConfig();
}
else
{
Device = SDL_JoystickOpen(DeviceIndex);
Mapping = NULL;
DefaultAxes = DefaultJoystickAxes;
DefaultAxesCount = sizeof(DefaultJoystickAxes) / sizeof(DefaultAxisConfig);
if(Device != NULL)
{
NumAxes = SDL_JoystickNumAxes(Device);
NumHats = SDL_JoystickNumHats(Device);
SetDefaultConfig();
}
}
M_LoadJoystickConfig(this);
}
~SDLInputJoystick()
{
if(IsValid() && SettingsChanged)
if(Device != NULL)
M_SaveJoystickConfig(this);
if (Mapping)
SDL_GameControllerClose(Mapping);
if (Device)
SDL_JoystickClose(Device);
SDL_JoystickClose(Device);
}
bool IsValid() const
{
return Device != NULL || Mapping != NULL;
return Device != NULL;
}
FString GetName()
{
return (Mapping)
? SDL_GameControllerName(Mapping)
: SDL_JoystickName(Device);
return SDL_JoystickName(Device);
}
float GetSensitivity()
{
@ -112,7 +79,6 @@ public:
}
void SetSensitivity(float scale)
{
SettingsChanged = true;
Multiplier = scale;
}
@ -136,145 +102,58 @@ public:
{
return Axes[axis].Multiplier;
}
float GetAxisDigitalThreshold(int axis)
{
return Axes[axis].DigitalThreshold;
}
EJoyCurve GetAxisResponseCurve(int axis)
{
return Axes[axis].ResponseCurvePreset;
}
float GetAxisResponseCurvePoint(int axis, int point)
{
return unsigned(point) < 4
? Axes[axis].ResponseCurve.pts[point]
: 0;
};
void SetAxisDeadZone(int axis, float zone)
{
SettingsChanged = true;
Axes[axis].DeadZone = clamp(zone, 0.f, 1.f);
Axes[axis].DeadZone = clamp(zone, MIN_DEADZONE, 1.f);
}
void SetAxisMap(int axis, EJoyAxis gameaxis)
{
SettingsChanged = true;
Axes[axis].GameAxis = gameaxis;
}
void SetAxisScale(int axis, float scale)
{
SettingsChanged = true;
Axes[axis].Multiplier = scale;
}
void SetAxisDigitalThreshold(int axis, float threshold)
{
SettingsChanged = true;
Axes[axis].DigitalThreshold = threshold;
}
void SetAxisResponseCurve(int axis, EJoyCurve preset)
{
if (preset >= NUM_JOYCURVE || preset < JOYCURVE_CUSTOM) return;
SettingsChanged = true;
Axes[axis].ResponseCurvePreset = preset;
if (preset == JOYCURVE_CUSTOM) return;
Axes[axis].ResponseCurve = JOYCURVE[preset];
}
void SetAxisResponseCurvePoint(int axis, int point, float value)
{
if (unsigned(point) < 4)
{
SettingsChanged = true;
Axes[axis].ResponseCurvePreset = JOYCURVE_CUSTOM;
Axes[axis].ResponseCurve.pts[point] = value;
}
}
// Used by the saver to not save properties that are at their defaults.
bool IsSensitivityDefault()
{
return Multiplier == JOYSENSITIVITY_DEFAULT;
return Multiplier == 1.0f;
}
bool IsAxisDeadZoneDefault(int axis)
{
if(axis >= DefaultAxesCount)
return Axes[axis].DeadZone == JOYDEADZONE_DEFAULT;
return Axes[axis].DeadZone == DefaultAxes[axis].DeadZone;
return Axes[axis].DeadZone <= MIN_DEADZONE;
}
bool IsAxisMapDefault(int axis)
{
if(axis >= DefaultAxesCount)
if(axis >= 5)
return Axes[axis].GameAxis == JOYAXIS_None;
return Axes[axis].GameAxis == DefaultAxes[axis].GameAxis;
return Axes[axis].GameAxis == DefaultAxes[axis];
}
bool IsAxisScaleDefault(int axis)
{
if(axis >= DefaultAxesCount)
return Axes[axis].Multiplier == JOYSENSITIVITY_DEFAULT;
return Axes[axis].Multiplier == DefaultAxes[axis].Multiplier;
}
bool IsAxisDigitalThresholdDefault(int axis)
{
if(axis >= DefaultAxesCount)
return Axes[axis].DigitalThreshold == JOYTHRESH_DEFAULT;
return Axes[axis].DigitalThreshold == DefaultAxes[axis].DigitalThreshold;
}
bool IsAxisResponseCurveDefault(int axis)
{
if(axis >= DefaultAxesCount)
return Axes[axis].ResponseCurvePreset == JOYCURVE_DEFAULT;
return Axes[axis].ResponseCurvePreset == DefaultAxes[axis].ResponseCurvePreset;
return Axes[axis].Multiplier == 1.0f;
}
void SetDefaultConfig()
{
if (Axes.size() == 0)
{
for(int i = 0;i < GetNumAxes();i++)
{
Axes.Push({});
}
}
for(int i = 0;i < GetNumAxes();i++)
{
if (Mapping) {
switch(i) {
case SDL_CONTROLLER_AXIS_LEFTX: Axes[i].Name = "Left Stick X"; break;
case SDL_CONTROLLER_AXIS_LEFTY: Axes[i].Name = "Left Stick Y"; break;
case SDL_CONTROLLER_AXIS_RIGHTX: Axes[i].Name = "Right Stick X"; break;
case SDL_CONTROLLER_AXIS_RIGHTY: Axes[i].Name = "Right Stick Y"; break;
case SDL_CONTROLLER_AXIS_TRIGGERLEFT: Axes[i].Name = "Left Trigger"; break;
case SDL_CONTROLLER_AXIS_TRIGGERRIGHT: Axes[i].Name = "Right Trigger"; break;
default: Axes[i].Name.Format("Axis %d", i+1); break;
}
} else {
if(i < NumAxes)
Axes[i].Name.Format("Axis %d", i+1);
else
Axes[i].Name.Format("Hat %d (%c)", (i-NumAxes)/2 + 1, (i-NumAxes)%2 == 0 ? 'x' : 'y');
}
Axes[i].Value = 0.0;
Axes[i].ButtonValue = 0;
if (i < DefaultAxesCount)
{
Axes[i].GameAxis = DefaultAxes[i].GameAxis;
Axes[i].DeadZone = DefaultAxes[i].DeadZone;
Axes[i].Multiplier = DefaultAxes[i].Multiplier;
Axes[i].DigitalThreshold = DefaultAxes[i].DigitalThreshold;
Axes[i].ResponseCurvePreset = DefaultAxes[i].ResponseCurvePreset;
Axes[i].ResponseCurve = JOYCURVE[DefaultAxes[i].ResponseCurvePreset];
}
AxisInfo info;
if(i < NumAxes)
info.Name.Format("Axis %d", i+1);
else
{
Axes[i].GameAxis = JOYAXIS_None;
Axes[i].DeadZone = JOYDEADZONE_DEFAULT;
Axes[i].Multiplier = JOYSENSITIVITY_DEFAULT;
Axes[i].DigitalThreshold = JOYTHRESH_DEFAULT;
Axes[i].ResponseCurvePreset = JOYCURVE_DEFAULT;
Axes[i].ResponseCurve = JOYCURVE[JOYCURVE_DEFAULT];
}
info.Name.Format("Hat %d (%c)", (i-NumAxes)/2 + 1, (i-NumAxes)%2 == 0 ? 'x' : 'y');
info.DeadZone = DEFAULT_DEADZONE;
info.Multiplier = 1.0f;
info.Value = 0.0;
info.ButtonValue = 0;
if(i >= 5)
info.GameAxis = JOYAXIS_None;
else
info.GameAxis = DefaultAxes[i];
Axes.Push(info);
}
}
@ -282,10 +161,9 @@ public:
{
return Enabled;
}
void SetEnabled(bool enabled)
{
SettingsChanged = true;
Enabled = enabled;
}
@ -310,101 +188,63 @@ public:
}
}
void ProcessInput() {
void ProcessInput()
{
uint8_t buttonstate;
if (Mapping)
for (int i = 0; i < NumAxes; ++i)
{
// GameController API available
buttonstate = 0;
auto lastTriggerL = Axes[SDL_CONTROLLER_AXIS_TRIGGERLEFT].Value > Axes[SDL_CONTROLLER_AXIS_TRIGGERLEFT].DigitalThreshold;
auto lastTriggerR = Axes[SDL_CONTROLLER_AXIS_TRIGGERRIGHT].Value > Axes[SDL_CONTROLLER_AXIS_TRIGGERRIGHT].DigitalThreshold;
Axes[i].Value = SDL_JoystickGetAxis(Device, i)/32767.0;
Axes[i].Value = Joy_RemoveDeadZone(Axes[i].Value, Axes[i].DeadZone, &buttonstate);
for (auto i = 0; i < SDL_CONTROLLER_AXIS_MAX && i < NumAxes; ++i)
// Map button to axis
// X and Y are handled differently so if we have 2 or more axes then we'll use that code instead.
if (NumAxes == 1 || (i >= 2 && i < NUM_JOYAXISBUTTONS))
{
buttonstate = 0;
Axes[i].Value = SDL_GameControllerGetAxis(Mapping, static_cast<SDL_GameControllerAxis>(i))/32767.0;
Axes[i].Value = Joy_RemoveDeadZone(Axes[i].Value, Axes[i].DeadZone, &buttonstate);
Axes[i].Value = Joy_ApplyResponseCurveBezier(Axes[i].ResponseCurve, Axes[i].Value);
Joy_GenerateButtonEvents(Axes[i].ButtonValue, buttonstate, 2, KEY_JOYAXIS1PLUS + i*2);
Axes[i].ButtonValue = buttonstate;
}
}
auto currTriggerL = Axes[SDL_CONTROLLER_AXIS_TRIGGERLEFT].Value > Axes[SDL_CONTROLLER_AXIS_TRIGGERLEFT].DigitalThreshold;
auto currTriggerR = Axes[SDL_CONTROLLER_AXIS_TRIGGERRIGHT].Value > Axes[SDL_CONTROLLER_AXIS_TRIGGERRIGHT].DigitalThreshold;
if (lastTriggerL != currTriggerL) Joy_GenerateButtonEvent(currTriggerL, KEY_PAD_LTRIGGER);
if (lastTriggerR != currTriggerR) Joy_GenerateButtonEvent(currTriggerR, KEY_PAD_RTRIGGER);
// todo: right stick
buttonstate = Joy_XYAxesToButtons(
abs(Axes[0].Value) < Axes[0].DigitalThreshold ? 0 : Axes[0].Value,
abs(Axes[1].Value) < Axes[1].DigitalThreshold ? 0 : Axes[1].Value
);
if(NumAxes > 1)
{
buttonstate = Joy_XYAxesToButtons(Axes[0].Value, Axes[1].Value);
Joy_GenerateButtonEvents(Axes[0].ButtonValue, buttonstate, 4, KEY_JOYAXIS1PLUS);
Axes[0].ButtonValue = buttonstate;
}
else
// Map POV hats to buttons and axes. Why axes? Well apparently I have
// a gamepad where the left control stick is a POV hat (instead of the
// d-pad like you would expect, no that's pressure sensitive). Also
// KDE's joystick dialog maps them to axes as well.
for (int i = 0; i < NumHats; ++i)
{
// Joystick API fallback
AxisInfo &x = Axes[NumAxes + i*2];
AxisInfo &y = Axes[NumAxes + i*2 + 1];
for (int i = 0; i < NumAxes; ++i)
buttonstate = SDL_JoystickGetHat(Device, i);
// If we're going to assume that we can pass SDL's value into
// Joy_GenerateButtonEvents then we might as well assume the format here.
if(buttonstate & 0x1) // Up
y.Value = -1.0;
else if(buttonstate & 0x4) // Down
y.Value = 1.0;
else
y.Value = 0.0;
if(buttonstate & 0x2) // Left
x.Value = 1.0;
else if(buttonstate & 0x8) // Right
x.Value = -1.0;
else
x.Value = 0.0;
if(i < 4)
{
buttonstate = 0;
Axes[i].Value = SDL_JoystickGetAxis(Device, i)/32767.0;
Axes[i].Value = Joy_RemoveDeadZone(Axes[i].Value, Axes[i].DeadZone, &buttonstate);
Axes[i].Value = Joy_ApplyResponseCurveBezier(Axes[i].ResponseCurve, Axes[i].Value);
// Map button to axis
// X and Y are handled differently so if we have 2 or more axes then we'll use that code instead.
if (NumAxes == 1 || (i >= 2 && i < NUM_JOYAXISBUTTONS))
{
Joy_GenerateButtonEvents(Axes[i].ButtonValue, buttonstate, 2, KEY_JOYAXIS1PLUS + i*2);
Axes[i].ButtonValue = buttonstate;
}
}
if(NumAxes > 1)
{
buttonstate = Joy_XYAxesToButtons(
abs(Axes[0].Value) < Axes[0].DigitalThreshold ? 0 : Axes[0].Value,
abs(Axes[1].Value) < Axes[1].DigitalThreshold ? 0 : Axes[1].Value
);
Joy_GenerateButtonEvents(Axes[0].ButtonValue, buttonstate, 4, KEY_JOYAXIS1PLUS);
Axes[0].ButtonValue = buttonstate;
}
// Map POV hats to buttons and axes. Why axes? Well apparently I have
// a gamepad where the left control stick is a POV hat (instead of the
// d-pad like you would expect, no that's pressure sensitive). Also
// KDE's joystick dialog maps them to axes as well.
for (int i = 0; i < NumHats; ++i)
{
AxisInfo &x = Axes[NumAxes + i*2];
AxisInfo &y = Axes[NumAxes + i*2 + 1];
buttonstate = SDL_JoystickGetHat(Device, i);
// If we're going to assume that we can pass SDL's value into
// Joy_GenerateButtonEvents then we might as well assume the format here.
if(buttonstate & 0x1) // Up
y.Value = -1.0;
else if(buttonstate & 0x4) // Down
y.Value = 1.0;
else
y.Value = 0.0;
if(buttonstate & 0x2) // Left
x.Value = 1.0;
else if(buttonstate & 0x8) // Right
x.Value = -1.0;
else
x.Value = 0.0;
if(i < 4)
{
Joy_GenerateButtonEvents(x.ButtonValue, buttonstate, 4, KEY_JOYPOV1_UP + i*4);
x.ButtonValue = buttonstate;
}
Joy_GenerateButtonEvents(x.ButtonValue, buttonstate, 4, KEY_JOYPOV1_UP + i*4);
x.ButtonValue = buttonstate;
}
}
}
@ -415,66 +255,33 @@ protected:
FString Name;
float DeadZone;
float Multiplier;
float DigitalThreshold;
EJoyCurve ResponseCurvePreset;
CubicBezier ResponseCurve;
EJoyAxis GameAxis;
double Value;
uint8_t ButtonValue;
};
struct DefaultAxisConfig
{
float DeadZone;
EJoyAxis GameAxis;
float Multiplier;
float DigitalThreshold;
EJoyCurve ResponseCurvePreset;
};
static const DefaultAxisConfig DefaultJoystickAxes[5];
static const DefaultAxisConfig DefaultControllerAxes[6];
const DefaultAxisConfig * DefaultAxes;
int DefaultAxesCount;
static const EJoyAxis DefaultAxes[5];
int DeviceIndex;
int InstanceID;
SDL_Joystick *Device;
SDL_GameController *Mapping;
float Multiplier;
bool Enabled;
TArray<AxisInfo> Axes;
int NumAxes;
int NumHats;
bool SettingsChanged;
friend class SDLInputJoystickManager;
};
// [Nash 4 Feb 2024] seems like on Linux, the third axis is actually the Left Trigger, resulting in the player uncontrollably looking upwards.
const SDLInputJoystick::DefaultAxisConfig SDLInputJoystick::DefaultJoystickAxes[5] = {
{JOYDEADZONE_DEFAULT, JOYAXIS_Side, JOYSENSITIVITY_DEFAULT, JOYTHRESH_STICK_X, JOYCURVE_DEFAULT},
{JOYDEADZONE_DEFAULT, JOYAXIS_Forward, JOYSENSITIVITY_DEFAULT, JOYTHRESH_STICK_Y, JOYCURVE_DEFAULT},
{JOYDEADZONE_DEFAULT, JOYAXIS_None, JOYSENSITIVITY_DEFAULT, JOYTHRESH_DEFAULT, JOYCURVE_DEFAULT},
{JOYDEADZONE_DEFAULT, JOYAXIS_Yaw, JOYSENSITIVITY_DEFAULT, JOYTHRESH_STICK_X, JOYCURVE_DEFAULT},
{JOYDEADZONE_DEFAULT, JOYAXIS_Pitch, JOYSENSITIVITY_DEFAULT, JOYTHRESH_STICK_Y, JOYCURVE_DEFAULT}
};
// Defaults if we have access to the GameController API for this device
const SDLInputJoystick::DefaultAxisConfig SDLInputJoystick::DefaultControllerAxes[6] = {
{JOYDEADZONE_DEFAULT, JOYAXIS_Side, JOYSENSITIVITY_DEFAULT, JOYTHRESH_STICK_X, JOYCURVE_DEFAULT},
{JOYDEADZONE_DEFAULT, JOYAXIS_Forward, JOYSENSITIVITY_DEFAULT, JOYTHRESH_STICK_Y, JOYCURVE_DEFAULT},
{JOYDEADZONE_DEFAULT, JOYAXIS_Yaw, JOYSENSITIVITY_DEFAULT, JOYTHRESH_STICK_X, JOYCURVE_DEFAULT},
{JOYDEADZONE_DEFAULT, JOYAXIS_Pitch, JOYSENSITIVITY_DEFAULT, JOYTHRESH_STICK_Y, JOYCURVE_DEFAULT},
{JOYDEADZONE_DEFAULT, JOYAXIS_None, JOYSENSITIVITY_DEFAULT, JOYTHRESH_TRIGGER, JOYCURVE_DEFAULT},
{JOYDEADZONE_DEFAULT, JOYAXIS_None, JOYSENSITIVITY_DEFAULT, JOYTHRESH_TRIGGER, JOYCURVE_DEFAULT},
};
const EJoyAxis SDLInputJoystick::DefaultAxes[5] = {JOYAXIS_Side, JOYAXIS_Forward, JOYAXIS_None, JOYAXIS_Yaw, JOYAXIS_Pitch};
class SDLInputJoystickManager
{
public:
SDLInputJoystickManager()
{
UpdateDeviceList();
this->UpdateDeviceList();
}
void UpdateDeviceList()
@ -511,19 +318,6 @@ public:
if(Joysticks[i]->Enabled) Joysticks[i]->ProcessInput();
}
bool IsJoystickEnabled(int instanceID)
{
for(unsigned int i = 0; i < Joysticks.Size(); i++)
{
if (Joysticks[i]->InstanceID != instanceID)
{
continue;
}
return Joysticks[i]->Enabled;
}
return false;
}
protected:
TDeletingArray<SDLInputJoystick *> Joysticks;
};
@ -532,7 +326,7 @@ static SDLInputJoystickManager *JoystickManager;
void I_StartupJoysticks()
{
#ifndef NO_SDL_JOYSTICK
if(SDL_InitSubSystem(SDL_INIT_JOYSTICK | SDL_INIT_GAMECONTROLLER) >= 0)
if(SDL_InitSubSystem(SDL_INIT_JOYSTICK) >= 0)
JoystickManager = new SDLInputJoystickManager();
#endif
}
@ -541,7 +335,7 @@ void I_ShutdownInput()
if(JoystickManager)
{
delete JoystickManager;
SDL_QuitSubSystem(SDL_INIT_JOYSTICK | SDL_INIT_GAMECONTROLLER);
SDL_QuitSubSystem(SDL_INIT_JOYSTICK);
}
}
@ -571,16 +365,6 @@ void I_ProcessJoysticks()
JoystickManager->ProcessInput();
}
void I_JoyConsumeEvent(int instanceID, event_t * event)
{
if (event->type == EV_KeyDown)
{
bool okay = use_joystick && JoystickManager && JoystickManager->IsJoystickEnabled(instanceID);
if (!okay) return;
}
D_PostEvent(event);
}
IJoystickConfig *I_UpdateDeviceList()
{
JoystickManager->UpdateDeviceList();

168
src/common/platform/win32/i_dijoy.cpp
View file

@ -146,6 +146,7 @@ public:
// MACROS ------------------------------------------------------------------
#define DEFAULT_DEADZONE 0.25f
// TYPES -------------------------------------------------------------------
@ -169,23 +170,15 @@ public:
EJoyAxis GetAxisMap(int axis);
const char *GetAxisName(int axis);
float GetAxisScale(int axis);
float GetAxisDigitalThreshold(int axis);
EJoyCurve GetAxisResponseCurve(int axis);
float GetAxisResponseCurvePoint(int axis, int point);
void SetAxisDeadZone(int axis, float deadzone);
void SetAxisMap(int axis, EJoyAxis gameaxis);
void SetAxisScale(int axis, float scale);
void SetAxisDigitalThreshold(int axis, float threshold);
void SetAxisResponseCurve(int axis, EJoyCurve preset);
void SetAxisResponseCurvePoint(int axis, int point, float value);
bool IsSensitivityDefault();
bool IsAxisDeadZoneDefault(int axis);
bool IsAxisMapDefault(int axis);
bool IsAxisScaleDefault(int axis);
bool IsAxisDigitalThresholdDefault(int axis);
bool IsAxisResponseCurveDefault(int axis);
bool GetEnabled();
void SetEnabled(bool enabled);
@ -208,9 +201,6 @@ protected:
float Value;
float DeadZone, DefaultDeadZone;
float Multiplier, DefaultMultiplier;
float DigitalThreshold, DefaultDigitalThreshold;
EJoyCurve ResponseCurvePreset, DefaultResponseCurvePreset;
CubicBezier ResponseCurve;
EJoyAxis GameAxis, DefaultGameAxis;
uint8_t ButtonValue;
};
@ -464,21 +454,16 @@ void FDInputJoystick::ProcessInput()
axisval = (value - info->Min) * 2.0 / (info->Max - info->Min) - 1.0;
// Cancel out dead zone
axisval = Joy_RemoveDeadZone(axisval, info->DeadZone, &buttonstate);
axisval = Joy_ApplyResponseCurveBezier(info->ResponseCurve, axisval);
info->Value = float(axisval);
if (i < NUM_JOYAXISBUTTONS && (i > 2 || Axes.Size() == 1))
{
if (abs(axisval) < info->DigitalThreshold) buttonstate = 0;
Joy_GenerateButtonEvents(info->ButtonValue, buttonstate, 2, KEY_JOYAXIS1PLUS + i*2);
}
else if (i == 1)
{
// Since we sorted the axes, we know that the first two are definitely X and Y.
// They are probably a single stick, so use angular position to determine buttons.
buttonstate = Joy_XYAxesToButtons(
(abs(Axes[0].Value) < Axes[0].DigitalThreshold) ? 0 : Axes[0].Value,
(abs(axisval) < info->DigitalThreshold) ? 0 : axisval
);
buttonstate = Joy_XYAxesToButtons(Axes[0].Value, axisval);
Joy_GenerateButtonEvents(info->ButtonValue, buttonstate, 4, KEY_JOYAXIS1PLUS);
}
info->ButtonValue = buttonstate;
@ -776,54 +761,38 @@ void FDInputJoystick::SetDefaultConfig()
{
unsigned i;
Multiplier = JOYSENSITIVITY_DEFAULT;
Multiplier = 1;
for (i = 0; i < Axes.Size(); ++i)
{
Axes[i].DeadZone = JOYDEADZONE_DEFAULT;
Axes[i].Multiplier = JOYSENSITIVITY_DEFAULT;
Axes[i].DeadZone = DEFAULT_DEADZONE;
Axes[i].Multiplier = 1;
Axes[i].GameAxis = JOYAXIS_None;
Axes[i].DigitalThreshold = JOYTHRESH_DEFAULT;
Axes[i].ResponseCurvePreset = JOYCURVE_DEFAULT;
Axes[i].ResponseCurve = JOYCURVE[JOYCURVE_DEFAULT];
}
// Triggers on a 360 controller have a much smaller deadzone.
if (Axes.Size() == 5 && Axes[4].Guid == GUID_ZAxis)
{
Axes[4].DeadZone = 30 / 256.f;
Axes[4].DigitalThreshold = JOYTHRESH_TRIGGER;
}
// Two axes? Horizontal is yaw and vertical is forward.
if (Axes.Size() == 2)
{
Axes[0].GameAxis = JOYAXIS_Yaw;
Axes[0].DigitalThreshold = JOYTHRESH_STICK_X;
Axes[1].GameAxis = JOYAXIS_Forward;
Axes[1].DigitalThreshold = JOYTHRESH_STICK_Y;
}
// Three axes? First two are movement, third is yaw.
else if (Axes.Size() >= 3)
{
Axes[0].GameAxis = JOYAXIS_Side;
Axes[0].DigitalThreshold = JOYTHRESH_STICK_X;
Axes[1].GameAxis = JOYAXIS_Forward;
Axes[1].DigitalThreshold = JOYTHRESH_STICK_Y;
Axes[2].GameAxis = JOYAXIS_Yaw;
Axes[2].DigitalThreshold = JOYTHRESH_STICK_X;
// Four axes? First two are movement, last two are looking around.
if (Axes.Size() >= 4)
{
Axes[3].GameAxis = JOYAXIS_Pitch;
// Axes[3].Multiplier = 0.75f;
Axes[3].DigitalThreshold = JOYTHRESH_STICK_Y;
Axes[3].GameAxis = JOYAXIS_Pitch; Axes[3].Multiplier = 0.75f;
// Five axes? Use the fifth one for moving up and down.
if (Axes.Size() >= 5)
{
Axes[4].GameAxis = JOYAXIS_Up;
Axes[4].DigitalThreshold = JOYTHRESH_STICK_Y;
}
}
}
@ -836,8 +805,6 @@ void FDInputJoystick::SetDefaultConfig()
Axes[i].DefaultDeadZone = Axes[i].DeadZone;
Axes[i].DefaultMultiplier = Axes[i].Multiplier;
Axes[i].DefaultGameAxis = Axes[i].GameAxis;
Axes[i].DefaultDigitalThreshold = Axes[i].DigitalThreshold;
Axes[i].DefaultResponseCurvePreset = Axes[i].ResponseCurvePreset;
}
}
@ -882,7 +849,7 @@ void FDInputJoystick::SetSensitivity(float scale)
bool FDInputJoystick::IsSensitivityDefault()
{
return Multiplier == JOYSENSITIVITY_DEFAULT;
return Multiplier == 1;
}
//===========================================================================
@ -956,51 +923,6 @@ float FDInputJoystick::GetAxisScale(int axis)
return Axes[axis].Multiplier;
}
//===========================================================================
//
// FDInputJoystick :: GetAxisDigitalThreshold
//
//===========================================================================
float FDInputJoystick::GetAxisDigitalThreshold(int axis)
{
if (unsigned(axis) >= Axes.Size())
{
return JOYTHRESH_DEFAULT;
}
return Axes[axis].DigitalThreshold;
}
//===========================================================================
//
// FDInputJoystick :: GetAxisResponseCurve
//
//===========================================================================
EJoyCurve FDInputJoystick::GetAxisResponseCurve(int axis)
{
if (unsigned(axis) >= Axes.Size())
{
return JOYCURVE_DEFAULT;
}
return Axes[axis].ResponseCurvePreset;
}
//===========================================================================
//
// FDInputJoystick :: GetAxisResponseCurvePoint
//
//===========================================================================
float FDInputJoystick::GetAxisResponseCurvePoint(int axis, int point)
{
if (unsigned(axis) >= Axes.Size() || unsigned(point) >= 4)
{
return 0;
}
return Axes[axis].ResponseCurve.pts[point];
}
//===========================================================================
//
// FDInputJoystick :: SetAxisDeadZone
@ -1043,52 +965,6 @@ void FDInputJoystick::SetAxisScale(int axis, float scale)
}
}
//===========================================================================
//
// FDInputJoystick :: SetAxisDigitalThreshold
//
//===========================================================================
void FDInputJoystick::SetAxisDigitalThreshold(int axis, float threshold)
{
if (unsigned(axis) < Axes.Size())
{
Axes[axis].DigitalThreshold = threshold;
}
}
//===========================================================================
//
// FDInputJoystick :: SetAxisResponseCurve
//
//===========================================================================
void FDInputJoystick::SetAxisResponseCurve(int axis, EJoyCurve preset)
{
if (unsigned(axis) < Axes.Size())
{
if (preset >= NUM_JOYCURVE || preset < JOYCURVE_CUSTOM) return;
Axes[axis].ResponseCurvePreset = preset;
if (preset == JOYCURVE_CUSTOM) return;
Axes[axis].ResponseCurve = JOYCURVE[preset];
}
}
//===========================================================================
//
// FDInputJoystick :: SetAxisResponseCurvePoint
//
//===========================================================================
void FDInputJoystick::SetAxisResponseCurvePoint(int axis, int point, float value)
{
if (unsigned(axis) < Axes.Size() && unsigned(point) < 4)
{
Axes[axis].ResponseCurvePreset = JOYCURVE_CUSTOM;
Axes[axis].ResponseCurve.pts[point] = value;
}
}
//===========================================================================
//
// FDInputJoystick :: IsAxisDeadZoneDefault
@ -1119,36 +995,6 @@ bool FDInputJoystick::IsAxisScaleDefault(int axis)
return true;
}
//===========================================================================
//
// FDInputJoystick :: IsAxisDigitalThresholdDefault
//
//===========================================================================
bool FDInputJoystick::IsAxisDigitalThresholdDefault(int axis)
{
if (unsigned(axis) < Axes.Size())
{
return Axes[axis].DigitalThreshold == Axes[axis].DefaultDigitalThreshold;
}
return true;
}
//===========================================================================
//
// FDInputJoystick :: IsAxisResponseCurveDefault
//
//===========================================================================
bool FDInputJoystick::IsAxisResponseCurveDefault(int axis)
{
if (unsigned(axis) < Axes.Size())
{
return Axes[axis].ResponseCurvePreset == Axes[axis].DefaultResponseCurvePreset;
}
return true;
}
//===========================================================================
//
// FDInputJoystick :: GetEnabled

160
src/common/platform/win32/i_rawps2.cpp
View file

@ -48,6 +48,7 @@
// MACROS ------------------------------------------------------------------
#define DEFAULT_DEADZONE 0.25f
#define STATUS_SWITCH_TIME 3
#define VID_PLAY_COM 0x0b43
@ -103,23 +104,15 @@ public:
EJoyAxis GetAxisMap(int axis);
const char *GetAxisName(int axis);
float GetAxisScale(int axis);
float GetAxisDigitalThreshold(int axis);
EJoyCurve GetAxisResponseCurve(int axis);
float GetAxisResponseCurvePoint(int axis, int point);
void SetAxisDeadZone(int axis, float deadzone);
void SetAxisMap(int axis, EJoyAxis gameaxis);
void SetAxisScale(int axis, float scale);
void SetAxisDigitalThreshold(int axis, float threshold);
void SetAxisResponseCurve(int axis, EJoyCurve preset);
void SetAxisResponseCurvePoint(int axis, int point, float value);
bool IsSensitivityDefault();
bool IsAxisDeadZoneDefault(int axis);
bool IsAxisMapDefault(int axis);
bool IsAxisScaleDefault(int axis);
bool IsAxisDigitalThresholdDefault(int axis);
bool IsAxisResponseCurveDefault(int axis);
bool GetEnabled();
void SetEnabled(bool enabled);
@ -137,9 +130,6 @@ protected:
float Value;
float DeadZone;
float Multiplier;
float DigitalThreshold;
EJoyCurve ResponseCurvePreset;
CubicBezier ResponseCurve;
EJoyAxis GameAxis;
uint8_t ButtonValue;
};
@ -147,8 +137,6 @@ protected:
{
EJoyAxis GameAxis;
float Multiplier;
float DigitalThreshold;
EJoyCurve ResponseCurvePreset;
};
enum
{
@ -369,11 +357,11 @@ static const char *AxisNames[] =
FRawPS2Controller::DefaultAxisConfig FRawPS2Controller::DefaultAxes[NUM_AXES] =
{
// Game axis, multiplier, digital threshold, response curve A, response curve B
{ JOYAXIS_Side, JOYSENSITIVITY_DEFAULT, JOYTHRESH_STICK_X, JOYCURVE_DEFAULT }, // ThumbLX
{ JOYAXIS_Forward, JOYSENSITIVITY_DEFAULT, JOYTHRESH_STICK_Y, JOYCURVE_DEFAULT }, // ThumbLY
{ JOYAXIS_Yaw, JOYSENSITIVITY_DEFAULT, JOYTHRESH_STICK_X, JOYCURVE_DEFAULT }, // ThumbRX
{ JOYAXIS_Pitch, JOYSENSITIVITY_DEFAULT, JOYTHRESH_STICK_Y, JOYCURVE_DEFAULT }, // ThumbRY
// Game axis, multiplier
{ JOYAXIS_Side, 1 }, // ThumbLX
{ JOYAXIS_Forward, 1 }, // ThumbLY
{ JOYAXIS_Yaw, 1 }, // ThumbRX
{ JOYAXIS_Pitch, 0.75 }, // ThumbRY
};
// CODE --------------------------------------------------------------------
@ -564,16 +552,11 @@ void FRawPS2Controller::ProcessThumbstick(int value1, AxisInfo *axis1, int value
axisval2 = value2 * (2.0 / 255) - 1.0;
axisval1 = Joy_RemoveDeadZone(axisval1, axis1->DeadZone, NULL);
axisval2 = Joy_RemoveDeadZone(axisval2, axis2->DeadZone, NULL);
axisval1 = Joy_ApplyResponseCurveBezier(axis1->ResponseCurve, axisval1);
axisval2 = Joy_ApplyResponseCurveBezier(axis2->ResponseCurve, axisval2);
axis1->Value = float(axisval1);
axis2->Value = float(axisval2);
// We store all four buttons in the first axis and ignore the second.
buttonstate = Joy_XYAxesToButtons(
(abs(axisval1) < axis1->DigitalThreshold) ? 0 : axisval1,
(abs(axisval2) < axis2->DigitalThreshold) ? 0 : axisval2
);
buttonstate = Joy_XYAxesToButtons(axisval1, axisval2);
Joy_GenerateButtonEvents(axis1->ButtonValue, buttonstate, 4, base);
axis1->ButtonValue = buttonstate;
}
@ -661,10 +644,10 @@ void FRawPS2Controller::AddAxes(float axes[NUM_JOYAXIS])
void FRawPS2Controller::SetDefaultConfig()
{
Multiplier = JOYSENSITIVITY_DEFAULT;
Multiplier = 1;
for (int i = 0; i < NUM_AXES; ++i)
{
Axes[i].DeadZone = JOYDEADZONE_DEFAULT;
Axes[i].DeadZone = DEFAULT_DEADZONE;
Axes[i].GameAxis = DefaultAxes[i].GameAxis;
Axes[i].Multiplier = DefaultAxes[i].Multiplier;
}
@ -729,7 +712,7 @@ void FRawPS2Controller::SetSensitivity(float scale)
bool FRawPS2Controller::IsSensitivityDefault()
{
return Multiplier == JOYSENSITIVITY_DEFAULT;
return Multiplier == 1;
}
//==========================================================================
@ -803,51 +786,6 @@ float FRawPS2Controller::GetAxisScale(int axis)
return 0;
}
//==========================================================================
//
// FRawPS2Controller :: GetAxisDigitalThreshold
//
//==========================================================================
float FRawPS2Controller::GetAxisDigitalThreshold(int axis)
{
if (unsigned(axis) < NUM_AXES)
{
return Axes[axis].DigitalThreshold;
}
return JOYTHRESH_DEFAULT;
}
//==========================================================================
//
// FRawPS2Controller :: GetAxisResponseCurve
//
//==========================================================================
EJoyCurve FRawPS2Controller::GetAxisResponseCurve(int axis)
{
if (unsigned(axis) < NUM_AXES)
{
return Axes[axis].ResponseCurvePreset;
}
return JOYCURVE_DEFAULT;
}
//==========================================================================
//
// FRawPS2Controller :: GetAxisResponseCurvePoint
//
//==========================================================================
float FRawPS2Controller::GetAxisResponseCurvePoint(int axis, int point)
{
if (unsigned(axis) < NUM_AXES && unsigned(point) < 4)
{
return Axes[axis].ResponseCurve.pts[point];
}
return 0;
}
//==========================================================================
//
// FRawPS2Controller :: SetAxisDeadZone
@ -890,52 +828,6 @@ void FRawPS2Controller::SetAxisScale(int axis, float scale)
}
}
//==========================================================================
//
// FRawPS2Controller :: SetAxisDigitalThreshold
//
//==========================================================================
void FRawPS2Controller::SetAxisDigitalThreshold(int axis, float threshold)
{
if (unsigned(axis) < NUM_AXES)
{
Axes[axis].DigitalThreshold = threshold;
}
}
//==========================================================================
//
// FRawPS2Controller :: SetAxisResponseCurve
//
//==========================================================================
void FRawPS2Controller::SetAxisResponseCurve(int axis, EJoyCurve preset)
{
if (unsigned(axis) < NUM_AXES)
{
if (preset >= NUM_JOYCURVE || preset < JOYCURVE_CUSTOM) return;
Axes[axis].ResponseCurvePreset = preset;
if (preset == JOYCURVE_CUSTOM) return;
Axes[axis].ResponseCurve = JOYCURVE[preset];
}
}
//==========================================================================
//
// FRawPS2Controller :: SetAxisResponseCurvePoint
//
//==========================================================================
void FRawPS2Controller::SetAxisResponseCurvePoint(int axis, int point, float value)
{
if (unsigned(axis) < NUM_AXES && unsigned(point) < 4)
{
Axes[axis].ResponseCurvePreset = JOYCURVE_CUSTOM;
Axes[axis].ResponseCurve.pts[point] = value;
}
}
//===========================================================================
//
// FRawPS2Controller :: IsAxisDeadZoneDefault
@ -946,7 +838,7 @@ bool FRawPS2Controller::IsAxisDeadZoneDefault(int axis)
{
if (unsigned(axis) < NUM_AXES)
{
return Axes[axis].DeadZone == JOYDEADZONE_DEFAULT;
return Axes[axis].DeadZone == DEFAULT_DEADZONE;
}
return true;
}
@ -966,36 +858,6 @@ bool FRawPS2Controller::IsAxisScaleDefault(int axis)
return true;
}
//===========================================================================
//
// FRawPS2Controller :: IsAxisDigitalThresholdDefault
//
//===========================================================================
bool FRawPS2Controller::IsAxisDigitalThresholdDefault(int axis)
{
if (unsigned(axis) < NUM_AXES)
{
return Axes[axis].DigitalThreshold == DefaultAxes[axis].DigitalThreshold;
}
return true;
}
//===========================================================================
//
// FRawPS2Controller :: IsAxisResponseCurveDefault
//
//===========================================================================
bool FRawPS2Controller::IsAxisResponseCurveDefault(int axis)
{
if (unsigned(axis) < NUM_AXES)
{
return Axes[axis].ResponseCurvePreset == DefaultAxes[axis].ResponseCurvePreset;
}
return true;
}
//===========================================================================
//
// FRawPS2Controller :: GetEnabled

167
src/common/platform/win32/i_xinput.cpp
View file

@ -94,23 +94,15 @@ public:
EJoyAxis GetAxisMap(int axis);
const char *GetAxisName(int axis);
float GetAxisScale(int axis);
float GetAxisDigitalThreshold(int axis);
EJoyCurve GetAxisResponseCurve(int axis);
float GetAxisResponseCurvePoint(int axis, int point);
void SetAxisDeadZone(int axis, float deadzone);
void SetAxisMap(int axis, EJoyAxis gameaxis);
void SetAxisScale(int axis, float scale);
void SetAxisDigitalThreshold(int axis, float threshold);
void SetAxisResponseCurve(int axis, EJoyCurve preset);
void SetAxisResponseCurvePoint(int axis, int point, float value);
bool IsSensitivityDefault();
bool IsAxisDeadZoneDefault(int axis);
bool IsAxisMapDefault(int axis);
bool IsAxisScaleDefault(int axis);
bool IsAxisDigitalThresholdDefault(int axis);
bool IsAxisResponseCurveDefault(int axis);
bool GetEnabled();
void SetEnabled(bool enabled);
@ -130,17 +122,12 @@ protected:
float Multiplier;
EJoyAxis GameAxis;
uint8_t ButtonValue;
float DigitalThreshold;
EJoyCurve ResponseCurvePreset;
CubicBezier ResponseCurve;
};
struct DefaultAxisConfig
{
float DeadZone;
EJoyAxis GameAxis;
float Multiplier;
float DigitalThreshold;
EJoyCurve ResponseCurvePreset;
};
enum
{
@ -224,13 +211,13 @@ static const char *AxisNames[] =
FXInputController::DefaultAxisConfig FXInputController::DefaultAxes[NUM_AXES] =
{
// Dead zone, game axis, multiplier, digitalthreshold, curveA, curveB
{ XINPUT_GAMEPAD_LEFT_THUMB_DEADZONE / 32768.f, JOYAXIS_Side, JOYSENSITIVITY_DEFAULT, JOYTHRESH_STICK_X, JOYCURVE_DEFAULT }, // ThumbLX
{ XINPUT_GAMEPAD_LEFT_THUMB_DEADZONE / 32768.f, JOYAXIS_Forward, JOYSENSITIVITY_DEFAULT, JOYTHRESH_STICK_Y, JOYCURVE_DEFAULT }, // ThumbLY
{ XINPUT_GAMEPAD_RIGHT_THUMB_DEADZONE / 32768.f, JOYAXIS_Yaw, JOYSENSITIVITY_DEFAULT, JOYTHRESH_STICK_X, JOYCURVE_DEFAULT }, // ThumbRX
{ XINPUT_GAMEPAD_RIGHT_THUMB_DEADZONE / 32768.f, JOYAXIS_Pitch, JOYSENSITIVITY_DEFAULT, JOYTHRESH_STICK_Y, JOYCURVE_DEFAULT }, // ThumbRY
{ XINPUT_GAMEPAD_TRIGGER_THRESHOLD / 256.f, JOYAXIS_None, JOYSENSITIVITY_DEFAULT, JOYTHRESH_TRIGGER, JOYCURVE_DEFAULT }, // LeftTrigger
{ XINPUT_GAMEPAD_TRIGGER_THRESHOLD / 256.f, JOYAXIS_None, JOYSENSITIVITY_DEFAULT, JOYTHRESH_TRIGGER, JOYCURVE_DEFAULT } // RightTrigger
// Dead zone, game axis, multiplier
{ XINPUT_GAMEPAD_LEFT_THUMB_DEADZONE / 32768.f, JOYAXIS_Side, 1 }, // ThumbLX
{ XINPUT_GAMEPAD_LEFT_THUMB_DEADZONE / 32768.f, JOYAXIS_Forward, 1 }, // ThumbLY
{ XINPUT_GAMEPAD_RIGHT_THUMB_DEADZONE / 32768.f, JOYAXIS_Yaw, 1 }, // ThumbRX
{ XINPUT_GAMEPAD_RIGHT_THUMB_DEADZONE / 32768.f, JOYAXIS_Pitch, 0.75 }, // ThumbRY
{ XINPUT_GAMEPAD_TRIGGER_THRESHOLD / 256.f, JOYAXIS_None, 0 }, // LeftTrigger
{ XINPUT_GAMEPAD_TRIGGER_THRESHOLD / 256.f, JOYAXIS_None, 0 } // RightTrigger
};
// CODE --------------------------------------------------------------------
@ -340,16 +327,11 @@ void FXInputController::ProcessThumbstick(int value1, AxisInfo *axis1,
axisval2 = (value2 - SHRT_MIN) * 2.0 / 65536 - 1.0;
axisval1 = Joy_RemoveDeadZone(axisval1, axis1->DeadZone, NULL);
axisval2 = Joy_RemoveDeadZone(axisval2, axis2->DeadZone, NULL);
axisval1 = Joy_ApplyResponseCurveBezier(axis1->ResponseCurve, axisval1);
axisval2 = Joy_ApplyResponseCurveBezier(axis2->ResponseCurve, axisval2);
axis1->Value = float(axisval1);
axis2->Value = float(axisval2);
// We store all four buttons in the first axis and ignore the second.
buttonstate = Joy_XYAxesToButtons(
abs(axisval1) < axis1->DigitalThreshold ? 0: axisval1,
abs(axisval2) < axis2->DigitalThreshold ? 0: axisval2
);
buttonstate = Joy_XYAxesToButtons(axisval1, axisval2);
Joy_GenerateButtonEvents(axis1->ButtonValue, buttonstate, 4, base);
axis1->ButtonValue = buttonstate;
}
@ -369,11 +351,6 @@ void FXInputController::ProcessTrigger(int value, AxisInfo *axis, int base)
double axisval;
axisval = Joy_RemoveDeadZone(value / 256.0, axis->DeadZone, &buttonstate);
axisval = Joy_ApplyResponseCurveBezier(axis->ResponseCurve, axisval);
// TODO: probably just put this into Joy_RemoveDeadZone
if (abs(axisval) < axis->DigitalThreshold) buttonstate = 0;
Joy_GenerateButtonEvents(axis->ButtonValue, buttonstate, 1, base);
axis->ButtonValue = buttonstate;
axis->Value = float(axisval);
@ -454,15 +431,12 @@ void FXInputController::AddAxes(float axes[NUM_JOYAXIS])
void FXInputController::SetDefaultConfig()
{
Multiplier = JOYSENSITIVITY_DEFAULT;
Multiplier = 1;
for (int i = 0; i < NUM_AXES; ++i)
{
Axes[i].DeadZone = DefaultAxes[i].DeadZone;
Axes[i].GameAxis = DefaultAxes[i].GameAxis;
Axes[i].Multiplier = DefaultAxes[i].Multiplier;
Axes[i].DigitalThreshold = DefaultAxes[i].DigitalThreshold;
Axes[i].ResponseCurve = JOYCURVE[DefaultAxes[i].ResponseCurvePreset];
Axes[i].ResponseCurvePreset = DefaultAxes[i].ResponseCurvePreset;
}
}
@ -520,7 +494,7 @@ void FXInputController::SetSensitivity(float scale)
bool FXInputController::IsSensitivityDefault()
{
return Multiplier == JOYSENSITIVITY_DEFAULT;
return Multiplier == 1;
}
//==========================================================================
@ -591,51 +565,6 @@ float FXInputController::GetAxisScale(int axis)
{
return Axes[axis].Multiplier;
}
return JOYSENSITIVITY_DEFAULT;
}
//==========================================================================
//
// FXInputController :: GetAxisDigitalThreshold
//
//==========================================================================
float FXInputController::GetAxisDigitalThreshold(int axis)
{
if (unsigned(axis) < NUM_AXES)
{
return Axes[axis].DigitalThreshold;
}
return JOYTHRESH_DEFAULT;
}
//==========================================================================
//
// FXInputController :: GetAxisResponseCurve
//
//==========================================================================
EJoyCurve FXInputController::GetAxisResponseCurve(int axis)
{
if (unsigned(axis) < NUM_AXES)
{
return Axes[axis].ResponseCurvePreset;
}
return JOYCURVE_DEFAULT;
}
//==========================================================================
//
// FXInputController :: GetAxisResponseCurvePoint
//
//==========================================================================
float FXInputController::GetAxisResponseCurvePoint(int axis, int point)
{
if (unsigned(axis) < NUM_AXES && unsigned(point) < 4)
{
return Axes[axis].ResponseCurve.pts[point];
}
return 0;
}
@ -681,52 +610,6 @@ void FXInputController::SetAxisScale(int axis, float scale)
}
}
//==========================================================================
//
// FXInputController :: SetAxisDigitalThreshold
//
//==========================================================================
void FXInputController::SetAxisDigitalThreshold(int axis, float threshold)
{
if (unsigned(axis) < NUM_AXES)
{
Axes[axis].DigitalThreshold = threshold;
}
}
//==========================================================================
//
// FXInputController :: SetAxisResponseCurve
//
//==========================================================================
void FXInputController::SetAxisResponseCurve(int axis, EJoyCurve preset)
{
if (unsigned(axis) < NUM_AXES)
{
if (preset >= NUM_JOYCURVE || preset < JOYCURVE_CUSTOM) return;
Axes[axis].ResponseCurvePreset = preset;
if (preset == JOYCURVE_CUSTOM) return;
Axes[axis].ResponseCurve = JOYCURVE[preset];
}
}
//==========================================================================
//
// FXInputController :: SetAxisResponseCurvePoint
//
//==========================================================================
void FXInputController::SetAxisResponseCurvePoint(int axis, int point, float value)
{
if (unsigned(axis) < NUM_AXES && unsigned(point) < 4)
{
Axes[axis].ResponseCurvePreset = JOYCURVE_CUSTOM;
Axes[axis].ResponseCurve.pts[point] = value;
}
}
//===========================================================================
//
// FXInputController :: IsAxisDeadZoneDefault
@ -757,36 +640,6 @@ bool FXInputController::IsAxisScaleDefault(int axis)
return true;
}
//===========================================================================
//
// FXInputController :: IsAxisDigitalThresholdDefault
//
//===========================================================================
bool FXInputController::IsAxisDigitalThresholdDefault(int axis)
{
if (unsigned(axis) < NUM_AXES)
{
return Axes[axis].DigitalThreshold == DefaultAxes[axis].DigitalThreshold;
}
return true;
}
//===========================================================================
//
// FXInputController :: IsAxisResponseCurveDefault
//
//===========================================================================
bool FXInputController::IsAxisResponseCurveDefault(int axis)
{
if (unsigned(axis) < NUM_AXES)
{
return Axes[axis].ResponseCurvePreset == DefaultAxes[axis].ResponseCurvePreset;
}
return true;
}
//===========================================================================
//
// FXInputController :: GetEnabled