segatools/idzio/xi.c

200 lines
5.3 KiB
C
Raw Normal View History

2019-05-04 00:36:23 +00:00
#include <windows.h>
#include <xinput.h>
#include <math.h>
2019-05-04 22:47:34 +00:00
#include <assert.h>
2019-05-04 00:36:23 +00:00
#include <stdbool.h>
#include <stdint.h>
2019-05-04 22:47:34 +00:00
#include "idzio/backend.h"
#include "idzio/config.h"
2019-05-04 00:36:23 +00:00
#include "idzio/idzio.h"
#include "idzio/shifter.h"
2019-05-04 22:47:34 +00:00
#include "idzio/xi.h"
2019-05-04 00:36:23 +00:00
2019-05-04 22:47:34 +00:00
#include "util/dprintf.h"
2019-05-04 00:36:23 +00:00
2019-05-04 22:47:34 +00:00
static void idz_xi_jvs_read_buttons(uint8_t *gamebtn_out);
static void idz_xi_jvs_read_shifter(uint8_t *gear);
static void idz_xi_jvs_read_analogs(struct idz_io_analog_state *out);
static HRESULT idz_xi_config_apply(const struct idz_xi_config *cfg);
2019-05-04 22:47:34 +00:00
static const struct idz_io_backend idz_xi_backend = {
.jvs_read_buttons = idz_xi_jvs_read_buttons,
.jvs_read_shifter = idz_xi_jvs_read_shifter,
.jvs_read_analogs = idz_xi_jvs_read_analogs,
};
static bool idz_xi_single_stick_steering;
static bool idz_xi_linear_steering;
HRESULT idz_xi_init(const struct idz_xi_config *cfg, const struct idz_io_backend **backend)
2019-05-04 00:36:23 +00:00
{
HRESULT hr;
assert(cfg != NULL);
2019-05-04 22:47:34 +00:00
assert(backend != NULL);
hr = idz_xi_config_apply(cfg);
if (FAILED(hr)) {
return hr;
}
dprintf("XInput: Using XInput controller\n");
2019-05-04 22:47:34 +00:00
*backend = &idz_xi_backend;
2019-05-04 00:36:23 +00:00
return S_OK;
}
static HRESULT idz_xi_config_apply(const struct idz_xi_config *cfg)
{
dprintf("XInput: --- Begin configuration ---\n");
dprintf("XInput: Single Stick Steering : %i\n", cfg->single_stick_steering);
dprintf("XInput: Linear Steering . . . : %i\n", cfg->linear_steering);
dprintf("XInput: --- End configuration ---\n");
idz_xi_single_stick_steering = cfg->single_stick_steering;
idz_xi_linear_steering = cfg->linear_steering;
return S_OK;
}
2019-05-04 22:47:34 +00:00
static void idz_xi_jvs_read_buttons(uint8_t *gamebtn_out)
2019-05-04 00:36:23 +00:00
{
uint8_t gamebtn;
XINPUT_STATE xi;
WORD xb;
2019-05-04 22:47:34 +00:00
assert(gamebtn_out != NULL);
2019-05-04 00:36:23 +00:00
2019-05-04 22:47:34 +00:00
gamebtn = 0;
2019-05-04 00:36:23 +00:00
memset(&xi, 0, sizeof(xi));
XInputGetState(0, &xi);
xb = xi.Gamepad.wButtons;
if (xb & XINPUT_GAMEPAD_DPAD_UP) {
gamebtn |= IDZ_IO_GAMEBTN_UP;
}
if (xb & XINPUT_GAMEPAD_DPAD_DOWN) {
gamebtn |= IDZ_IO_GAMEBTN_DOWN;
}
if (xb & XINPUT_GAMEPAD_DPAD_LEFT) {
gamebtn |= IDZ_IO_GAMEBTN_LEFT;
}
if (xb & XINPUT_GAMEPAD_DPAD_RIGHT) {
gamebtn |= IDZ_IO_GAMEBTN_RIGHT;
}
if (xb & (XINPUT_GAMEPAD_START | XINPUT_GAMEPAD_A)) {
2019-05-04 00:36:23 +00:00
gamebtn |= IDZ_IO_GAMEBTN_START;
}
if (xb & (XINPUT_GAMEPAD_BACK | XINPUT_GAMEPAD_B)) {
2019-05-04 00:36:23 +00:00
gamebtn |= IDZ_IO_GAMEBTN_VIEW_CHANGE;
}
*gamebtn_out = gamebtn;
}
2019-05-04 22:47:34 +00:00
static void idz_xi_jvs_read_shifter(uint8_t *gear)
2019-05-04 00:36:23 +00:00
{
bool shift_dn;
bool shift_up;
2019-05-04 00:36:23 +00:00
XINPUT_STATE xi;
WORD xb;
2019-05-04 22:47:34 +00:00
assert(gear != NULL);
2019-05-04 00:36:23 +00:00
memset(&xi, 0, sizeof(xi));
XInputGetState(0, &xi);
xb = xi.Gamepad.wButtons;
if (xb & XINPUT_GAMEPAD_START) {
/* Reset to Neutral when start is pressed */
idz_shifter_reset();
2019-05-04 00:36:23 +00:00
}
shift_dn = xb & (XINPUT_GAMEPAD_Y | XINPUT_GAMEPAD_LEFT_SHOULDER);
shift_up = xb & (XINPUT_GAMEPAD_X | XINPUT_GAMEPAD_RIGHT_SHOULDER);
2019-05-04 00:36:23 +00:00
idz_shifter_update(shift_dn, shift_up);
2019-05-04 00:36:23 +00:00
*gear = idz_shifter_current_gear();
2019-05-04 00:36:23 +00:00
}
static int apply_non_linear_transform(int value, int deadzone_center) {
const int max_input = 32767;
const double power_factor = 3.0;
// Apply deadzone only after passing the center threshold
if (abs(value) < deadzone_center) {
return 0;
}
// Scale the value to the range [-1.0, 1.0]
double scaled_value = (abs(value) - deadzone_center) / (double)(max_input - deadzone_center);
// Apply a non-linear transform (cubing in this case) and preserve the sign
double signed_value = copysign(pow(scaled_value, power_factor), value);
// Scale the value back to the range [-32770, 32767]
int transformed_value = (int)(signed_value * max_input);
// Clamp the value to the range [-32767, 32767]
transformed_value = (transformed_value > max_input) ? max_input : transformed_value;
transformed_value = (transformed_value < -max_input) ? -max_input : transformed_value;
return transformed_value;
}
2019-05-04 22:47:34 +00:00
static void idz_xi_jvs_read_analogs(struct idz_io_analog_state *out)
2019-05-04 00:36:23 +00:00
{
XINPUT_STATE xi;
int left;
int right;
2019-05-04 22:47:34 +00:00
assert(out != NULL);
2019-05-04 00:36:23 +00:00
memset(&xi, 0, sizeof(xi));
XInputGetState(0, &xi);
left = xi.Gamepad.sThumbLX;
right = xi.Gamepad.sThumbRX;
if (!idz_xi_linear_steering) {
// Apply non-linear transform for both sticks
left = apply_non_linear_transform(left, XINPUT_GAMEPAD_LEFT_THUMB_DEADZONE);
right = apply_non_linear_transform(right, XINPUT_GAMEPAD_RIGHT_THUMB_DEADZONE);
2019-05-04 00:36:23 +00:00
} else {
if (left < -XINPUT_GAMEPAD_LEFT_THUMB_DEADZONE) {
left += XINPUT_GAMEPAD_LEFT_THUMB_DEADZONE;
} else if (left > XINPUT_GAMEPAD_LEFT_THUMB_DEADZONE) {
left -= XINPUT_GAMEPAD_LEFT_THUMB_DEADZONE;
} else {
left = 0;
}
if (right < -XINPUT_GAMEPAD_RIGHT_THUMB_DEADZONE) {
right += XINPUT_GAMEPAD_RIGHT_THUMB_DEADZONE;
} else if (right > XINPUT_GAMEPAD_RIGHT_THUMB_DEADZONE) {
right -= XINPUT_GAMEPAD_RIGHT_THUMB_DEADZONE;
} else {
right = 0;
}
2019-05-04 00:36:23 +00:00
}
if(idz_xi_single_stick_steering) {
out->wheel = left;
} else {
out->wheel = (left + right) / 2;
}
2019-05-04 00:36:23 +00:00
out->accel = xi.Gamepad.bRightTrigger << 8;
out->brake = xi.Gamepad.bLeftTrigger << 8;
}