void GameSurface::OnMouseMoveEvent(const SDL_Event& event)
{
auto& e = reinterpret_cast<const SDL_MouseMotionEvent&>(event);
Position position;
position.X = e.x;
position.Y = e.y;
if (e.state == SDL_BUTTON_LEFT)
{
auto gemPosition = CalculateGemPosition(m_selectedGem);
if (m_selectedGem != k_noGem
&& (SDL_abs(gemPosition.X - position.X) > GemSurface::WIDTH / 2
|| SDL_abs(gemPosition.Y - position.Y) > GemSurface::HEIGHT / 2))
{
gemPosition.X = position.X - gemPosition.X;
gemPosition.Y = position.Y - gemPosition.Y;
m_gems[m_selectedGem].SetOffset(gemPosition);
m_gems[m_selectedGem].SetDragging(true);
}
}
for (auto& child : m_gems)
{
child.SetHover(false);
if (child.Contains(position))
{
child.SetHover(true);
}
}
}
bool GameSurface::AreContiguous(std::uint8_t first, std::uint8_t second) const
{
if (first == second)
return false;
if (first / COLUMNS == second / COLUMNS)
return first + 1 == second || first - 1 == second;
else
return SDL_abs(first - second) == COLUMNS;
}
int
SDL_PrivateJoystickAxis(SDL_Joystick * joystick, Uint8 axis, Sint16 value)
{
int posted;
/* Make sure we're not getting garbage or duplicate events */
if (axis >= joystick->naxes) {
return 0;
}
if (!joystick->axes[axis].has_initial_value) {
joystick->axes[axis].initial_value = value;
joystick->axes[axis].value = value;
joystick->axes[axis].zero = value;
joystick->axes[axis].has_initial_value = SDL_TRUE;
}
if (value == joystick->axes[axis].value) {
return 0;
}
if (!joystick->axes[axis].sent_initial_value) {
/* Make sure we don't send motion until there's real activity on this axis */
const int MAX_ALLOWED_JITTER = SDL_JOYSTICK_AXIS_MAX / 80; /* ShanWan PS3 controller needed 96 */
if (SDL_abs(value - joystick->axes[axis].value) <= MAX_ALLOWED_JITTER) {
return 0;
}
joystick->axes[axis].sent_initial_value = SDL_TRUE;
joystick->axes[axis].value = value; /* Just so we pass the check above */
SDL_PrivateJoystickAxis(joystick, axis, joystick->axes[axis].initial_value);
}
/* We ignore events if we don't have keyboard focus, except for centering
* events.
*/
if (SDL_PrivateJoystickShouldIgnoreEvent()) {
if ((value > joystick->axes[axis].zero && value >= joystick->axes[axis].value) ||
(value < joystick->axes[axis].zero && value <= joystick->axes[axis].value)) {
return 0;
}
}
/* Update internal joystick state */
joystick->axes[axis].value = value;
/* Post the event, if desired */
posted = 0;
#if !SDL_EVENTS_DISABLED
if (SDL_GetEventState(SDL_JOYAXISMOTION) == SDL_ENABLE) {
SDL_Event event;
event.type = SDL_JOYAXISMOTION;
event.jaxis.which = joystick->instance_id;
event.jaxis.axis = axis;
event.jaxis.value = value;
posted = SDL_PushEvent(&event) == 1;
}
#endif /* !SDL_EVENTS_DISABLED */
return (posted);
}
/* eloParsePacket
*/
int
eloParsePacket(unsigned char *mousebuf, int *dx, int *dy, int *button_state)
{
static int elo_button = 0;
static int last_x = 0;
static int last_y = 0;
int x, y;
/* Check if we have a touch packet */
if (mousebuf[1] != ELO_TOUCH_BYTE) {
return 0;
}
x = ((mousebuf[4] << 8) | mousebuf[3]);
y = ((mousebuf[6] << 8) | mousebuf[5]);
if ((SDL_abs(x - last_x) > ELO_SNAP_SIZE)
|| (SDL_abs(y - last_y) > ELO_SNAP_SIZE)) {
*dx = ((mousebuf[4] << 8) | mousebuf[3]);
*dy = ((mousebuf[6] << 8) | mousebuf[5]);
} else {
*dx = last_x;
*dy = last_y;
}
last_x = *dx;
last_y = *dy;
if ((mousebuf[2] & 0x07) == ELO_BTN_PRESS) {
elo_button = 1;
}
if ((mousebuf[2] & 0x07) == ELO_BTN_RELEASE) {
elo_button = 0;
}
*button_state = elo_button;
return 1;
}
void C_GamepadManager::RepairAppositeStickComponent( int* pstickComponent )
{
// スティックが遊び値以内の場合
if ( SDL_abs( ( *pstickComponent ) ) < s_STICK_DEAD_ZONE )
{
( *pstickComponent ) = 0;
}
else
{
// スティックが最大値を超過だった場合
if ( ( *pstickComponent ) > s_STICK_PUSH_MAX )
{
( *pstickComponent ) = s_STICK_PUSH_MAX;
}
// スティックが最小値未満だった場合
else if ( ( *pstickComponent ) < s_STICK_PUSH_MINI )
{
( *pstickComponent ) = s_STICK_PUSH_MINI;
}
}
}
/*
* Creates the FFEFFECT from a SDL_HapticEffect.
*/
static int
SDL_SYS_ToFFEFFECT(SDL_Haptic * haptic, FFEFFECT * dest, SDL_HapticEffect * src)
{
int i;
FFCONSTANTFORCE *constant = NULL;
FFPERIODIC *periodic = NULL;
FFCONDITION *condition = NULL; /* Actually an array of conditions - one per axis. */
FFRAMPFORCE *ramp = NULL;
FFCUSTOMFORCE *custom = NULL;
FFENVELOPE *envelope = NULL;
SDL_HapticConstant *hap_constant = NULL;
SDL_HapticPeriodic *hap_periodic = NULL;
SDL_HapticCondition *hap_condition = NULL;
SDL_HapticRamp *hap_ramp = NULL;
SDL_HapticCustom *hap_custom = NULL;
DWORD *axes = NULL;
/* Set global stuff. */
SDL_memset(dest, 0, sizeof(FFEFFECT));
dest->dwSize = sizeof(FFEFFECT); /* Set the structure size. */
dest->dwSamplePeriod = 0; /* Not used by us. */
dest->dwGain = 10000; /* Gain is set globally, not locally. */
dest->dwFlags = FFEFF_OBJECTOFFSETS; /* Seems obligatory. */
/* Envelope. */
envelope = SDL_malloc(sizeof(FFENVELOPE));
if (envelope == NULL) {
return SDL_OutOfMemory();
}
SDL_memset(envelope, 0, sizeof(FFENVELOPE));
dest->lpEnvelope = envelope;
envelope->dwSize = sizeof(FFENVELOPE); /* Always should be this. */
/* Axes. */
dest->cAxes = haptic->naxes;
if (dest->cAxes > 0) {
axes = SDL_malloc(sizeof(DWORD) * dest->cAxes);
if (axes == NULL) {
return SDL_OutOfMemory();
}
axes[0] = haptic->hwdata->axes[0]; /* Always at least one axis. */
if (dest->cAxes > 1) {
axes[1] = haptic->hwdata->axes[1];
}
if (dest->cAxes > 2) {
axes[2] = haptic->hwdata->axes[2];
}
dest->rgdwAxes = axes;
}
/* The big type handling switch, even bigger then Linux's version. */
switch (src->type) {
case SDL_HAPTIC_CONSTANT:
hap_constant = &src->constant;
constant = SDL_malloc(sizeof(FFCONSTANTFORCE));
if (constant == NULL) {
return SDL_OutOfMemory();
}
SDL_memset(constant, 0, sizeof(FFCONSTANTFORCE));
/* Specifics */
constant->lMagnitude = CONVERT(hap_constant->level);
dest->cbTypeSpecificParams = sizeof(FFCONSTANTFORCE);
dest->lpvTypeSpecificParams = constant;
/* Generics */
dest->dwDuration = hap_constant->length * 1000; /* In microseconds. */
dest->dwTriggerButton = FFGetTriggerButton(hap_constant->button);
dest->dwTriggerRepeatInterval = hap_constant->interval;
dest->dwStartDelay = hap_constant->delay * 1000; /* In microseconds. */
/* Direction. */
if (SDL_SYS_SetDirection(dest, &hap_constant->direction, dest->cAxes)
< 0) {
return -1;
}
/* Envelope */
if ((hap_constant->attack_length == 0)
&& (hap_constant->fade_length == 0)) {
SDL_free(envelope);
dest->lpEnvelope = NULL;
} else {
envelope->dwAttackLevel = CCONVERT(hap_constant->attack_level);
envelope->dwAttackTime = hap_constant->attack_length * 1000;
envelope->dwFadeLevel = CCONVERT(hap_constant->fade_level);
envelope->dwFadeTime = hap_constant->fade_length * 1000;
}
break;
case SDL_HAPTIC_SINE:
/* !!! FIXME: put this back when we have more bits in 2.1 */
/* case SDL_HAPTIC_SQUARE: */
case SDL_HAPTIC_TRIANGLE:
case SDL_HAPTIC_SAWTOOTHUP:
case SDL_HAPTIC_SAWTOOTHDOWN:
hap_periodic = &src->periodic;
periodic = SDL_malloc(sizeof(FFPERIODIC));
if (periodic == NULL) {
return SDL_OutOfMemory();
}
SDL_memset(periodic, 0, sizeof(FFPERIODIC));
/* Specifics */
periodic->dwMagnitude = CONVERT(SDL_abs(hap_periodic->magnitude));
periodic->lOffset = CONVERT(hap_periodic->offset);
periodic->dwPhase =
(hap_periodic->phase + (hap_periodic->magnitude < 0 ? 18000 : 0)) % 36000;
periodic->dwPeriod = hap_periodic->period * 1000;
dest->cbTypeSpecificParams = sizeof(FFPERIODIC);
dest->lpvTypeSpecificParams = periodic;
/* Generics */
dest->dwDuration = hap_periodic->length * 1000; /* In microseconds. */
dest->dwTriggerButton = FFGetTriggerButton(hap_periodic->button);
dest->dwTriggerRepeatInterval = hap_periodic->interval;
dest->dwStartDelay = hap_periodic->delay * 1000; /* In microseconds. */
/* Direction. */
if (SDL_SYS_SetDirection(dest, &hap_periodic->direction, dest->cAxes)
< 0) {
return -1;
}
/* Envelope */
if ((hap_periodic->attack_length == 0)
&& (hap_periodic->fade_length == 0)) {
SDL_free(envelope);
dest->lpEnvelope = NULL;
} else {
envelope->dwAttackLevel = CCONVERT(hap_periodic->attack_level);
envelope->dwAttackTime = hap_periodic->attack_length * 1000;
envelope->dwFadeLevel = CCONVERT(hap_periodic->fade_level);
envelope->dwFadeTime = hap_periodic->fade_length * 1000;
}
break;
case SDL_HAPTIC_SPRING:
case SDL_HAPTIC_DAMPER:
case SDL_HAPTIC_INERTIA:
case SDL_HAPTIC_FRICTION:
hap_condition = &src->condition;
if (dest->cAxes > 0) {
condition = SDL_malloc(sizeof(FFCONDITION) * dest->cAxes);
if (condition == NULL) {
return SDL_OutOfMemory();
}
SDL_memset(condition, 0, sizeof(FFCONDITION));
/* Specifics */
for (i = 0; i < dest->cAxes; i++) {
condition[i].lOffset = CONVERT(hap_condition->center[i]);
condition[i].lPositiveCoefficient =
CONVERT(hap_condition->right_coeff[i]);
condition[i].lNegativeCoefficient =
CONVERT(hap_condition->left_coeff[i]);
condition[i].dwPositiveSaturation =
CCONVERT(hap_condition->right_sat[i] / 2);
condition[i].dwNegativeSaturation =
CCONVERT(hap_condition->left_sat[i] / 2);
condition[i].lDeadBand = CCONVERT(hap_condition->deadband[i] / 2);
}
}
dest->cbTypeSpecificParams = sizeof(FFCONDITION) * dest->cAxes;
dest->lpvTypeSpecificParams = condition;
/* Generics */
dest->dwDuration = hap_condition->length * 1000; /* In microseconds. */
dest->dwTriggerButton = FFGetTriggerButton(hap_condition->button);
dest->dwTriggerRepeatInterval = hap_condition->interval;
dest->dwStartDelay = hap_condition->delay * 1000; /* In microseconds. */
/* Direction. */
if (SDL_SYS_SetDirection(dest, &hap_condition->direction, dest->cAxes)
< 0) {
return -1;
}
/* Envelope - Not actually supported by most CONDITION implementations. */
SDL_free(dest->lpEnvelope);
dest->lpEnvelope = NULL;
break;
case SDL_HAPTIC_RAMP:
hap_ramp = &src->ramp;
ramp = SDL_malloc(sizeof(FFRAMPFORCE));
if (ramp == NULL) {
return SDL_OutOfMemory();
}
SDL_memset(ramp, 0, sizeof(FFRAMPFORCE));
/* Specifics */
ramp->lStart = CONVERT(hap_ramp->start);
ramp->lEnd = CONVERT(hap_ramp->end);
dest->cbTypeSpecificParams = sizeof(FFRAMPFORCE);
dest->lpvTypeSpecificParams = ramp;
/* Generics */
dest->dwDuration = hap_ramp->length * 1000; /* In microseconds. */
dest->dwTriggerButton = FFGetTriggerButton(hap_ramp->button);
dest->dwTriggerRepeatInterval = hap_ramp->interval;
dest->dwStartDelay = hap_ramp->delay * 1000; /* In microseconds. */
/* Direction. */
if (SDL_SYS_SetDirection(dest, &hap_ramp->direction, dest->cAxes) < 0) {
return -1;
}
/* Envelope */
if ((hap_ramp->attack_length == 0) && (hap_ramp->fade_length == 0)) {
SDL_free(envelope);
dest->lpEnvelope = NULL;
} else {
envelope->dwAttackLevel = CCONVERT(hap_ramp->attack_level);
envelope->dwAttackTime = hap_ramp->attack_length * 1000;
envelope->dwFadeLevel = CCONVERT(hap_ramp->fade_level);
envelope->dwFadeTime = hap_ramp->fade_length * 1000;
}
break;
case SDL_HAPTIC_CUSTOM:
hap_custom = &src->custom;
custom = SDL_malloc(sizeof(FFCUSTOMFORCE));
if (custom == NULL) {
return SDL_OutOfMemory();
}
SDL_memset(custom, 0, sizeof(FFCUSTOMFORCE));
/* Specifics */
custom->cChannels = hap_custom->channels;
custom->dwSamplePeriod = hap_custom->period * 1000;
custom->cSamples = hap_custom->samples;
custom->rglForceData =
SDL_malloc(sizeof(LONG) * custom->cSamples * custom->cChannels);
for (i = 0; i < hap_custom->samples * hap_custom->channels; i++) { /* Copy data. */
custom->rglForceData[i] = CCONVERT(hap_custom->data[i]);
}
dest->cbTypeSpecificParams = sizeof(FFCUSTOMFORCE);
dest->lpvTypeSpecificParams = custom;
/* Generics */
dest->dwDuration = hap_custom->length * 1000; /* In microseconds. */
dest->dwTriggerButton = FFGetTriggerButton(hap_custom->button);
dest->dwTriggerRepeatInterval = hap_custom->interval;
dest->dwStartDelay = hap_custom->delay * 1000; /* In microseconds. */
/* Direction. */
if (SDL_SYS_SetDirection(dest, &hap_custom->direction, dest->cAxes) <
0) {
return -1;
}
/* Envelope */
if ((hap_custom->attack_length == 0)
&& (hap_custom->fade_length == 0)) {
SDL_free(envelope);
dest->lpEnvelope = NULL;
} else {
envelope->dwAttackLevel = CCONVERT(hap_custom->attack_level);
envelope->dwAttackTime = hap_custom->attack_length * 1000;
envelope->dwFadeLevel = CCONVERT(hap_custom->fade_level);
envelope->dwFadeTime = hap_custom->fade_length * 1000;
}
break;
default:
return SDL_SetError("Haptic: Unknown effect type.");
}
return 0;
}
int
SDL_SendMouseButton(SDL_Window * window, SDL_MouseID mouseID, Uint8 state, Uint8 button)
{
SDL_Mouse *mouse = SDL_GetMouse();
int posted;
Uint32 type;
Uint32 buttonstate = mouse->buttonstate;
SDL_MouseClickState *clickstate = GetMouseClickState(mouse, button);
Uint8 click_count;
/* Figure out which event to perform */
switch (state) {
case SDL_PRESSED:
type = SDL_MOUSEBUTTONDOWN;
buttonstate |= SDL_BUTTON(button);
break;
case SDL_RELEASED:
type = SDL_MOUSEBUTTONUP;
buttonstate &= ~SDL_BUTTON(button);
break;
default:
/* Invalid state -- bail */
return 0;
}
/* We do this after calculating buttonstate so button presses gain focus */
if (window && state == SDL_PRESSED) {
SDL_UpdateMouseFocus(window, mouse->x, mouse->y, buttonstate);
}
if (buttonstate == mouse->buttonstate) {
/* Ignore this event, no state change */
return 0;
}
mouse->buttonstate = buttonstate;
if (clickstate) {
if (state == SDL_PRESSED) {
Uint32 now = SDL_GetTicks();
if (SDL_TICKS_PASSED(now, clickstate->last_timestamp + SDL_double_click_time) ||
SDL_abs(mouse->x - clickstate->last_x) > SDL_double_click_radius ||
SDL_abs(mouse->y - clickstate->last_y) > SDL_double_click_radius) {
clickstate->click_count = 0;
}
clickstate->last_timestamp = now;
clickstate->last_x = mouse->x;
clickstate->last_y = mouse->y;
if (clickstate->click_count < 255) {
++clickstate->click_count;
}
}
click_count = clickstate->click_count;
} else {
click_count = 1;
}
/* Post the event, if desired */
posted = 0;
if (SDL_GetEventState(type) == SDL_ENABLE) {
SDL_Event event;
event.type = type;
event.button.windowID = mouse->focus ? mouse->focus->id : 0;
event.button.which = mouseID;
event.button.state = state;
event.button.button = button;
event.button.clicks = click_count;
event.button.x = mouse->x;
event.button.y = mouse->y;
posted = (SDL_PushEvent(&event) > 0);
}
/* We do this after dispatching event so button releases can lose focus */
if (window && state == SDL_RELEASED) {
SDL_UpdateMouseFocus(window, mouse->x, mouse->y, buttonstate);
}
return posted;
}
static int
SDL_PrivateSendMouseButton(SDL_Window * window, SDL_MouseID mouseID, Uint8 state, Uint8 button, int clicks)
{
SDL_Mouse *mouse = SDL_GetMouse();
int posted;
Uint32 type;
Uint32 buttonstate = mouse->buttonstate;
/* SDL_HINT_MOUSE_TOUCH_EVENTS: controlling whether mouse events should generate synthetic touch events */
if (mouse->mouse_touch_events) {
if (mouseID != SDL_TOUCH_MOUSEID && button == SDL_BUTTON_LEFT) {
if (state == SDL_PRESSED) {
track_mouse_down = SDL_TRUE;
} else {
track_mouse_down = SDL_FALSE;
}
if (window) {
float fx = (float)mouse->x / (float)window->w;
float fy = (float)mouse->y / (float)window->h;
SDL_SendTouch(SDL_MOUSE_TOUCHID, 0, track_mouse_down, fx, fy, 1.0f);
}
}
}
/* Figure out which event to perform */
switch (state) {
case SDL_PRESSED:
type = SDL_MOUSEBUTTONDOWN;
buttonstate |= SDL_BUTTON(button);
break;
case SDL_RELEASED:
type = SDL_MOUSEBUTTONUP;
buttonstate &= ~SDL_BUTTON(button);
break;
default:
/* Invalid state -- bail */
return 0;
}
/* We do this after calculating buttonstate so button presses gain focus */
if (window && state == SDL_PRESSED) {
SDL_UpdateMouseFocus(window, mouse->x, mouse->y, buttonstate);
}
if (buttonstate == mouse->buttonstate) {
/* Ignore this event, no state change */
return 0;
}
mouse->buttonstate = buttonstate;
if (clicks < 0) {
SDL_MouseClickState *clickstate = GetMouseClickState(mouse, button);
if (clickstate) {
if (state == SDL_PRESSED) {
Uint32 now = SDL_GetTicks();
if (SDL_TICKS_PASSED(now, clickstate->last_timestamp + mouse->double_click_time) ||
SDL_abs(mouse->x - clickstate->last_x) > mouse->double_click_radius ||
SDL_abs(mouse->y - clickstate->last_y) > mouse->double_click_radius) {
clickstate->click_count = 0;
}
clickstate->last_timestamp = now;
clickstate->last_x = mouse->x;
clickstate->last_y = mouse->y;
if (clickstate->click_count < 255) {
++clickstate->click_count;
}
}
clicks = clickstate->click_count;
} else {
clicks = 1;
}
}
/* Post the event, if desired */
posted = 0;
if (SDL_GetEventState(type) == SDL_ENABLE) {
SDL_Event event;
event.type = type;
event.button.windowID = mouse->focus ? mouse->focus->id : 0;
event.button.which = mouseID;
event.button.state = state;
event.button.button = button;
event.button.clicks = (Uint8) SDL_min(clicks, 255);
event.button.x = mouse->x;
event.button.y = mouse->y;
posted = (SDL_PushEvent(&event) > 0);
}
/* We do this after dispatching event so button releases can lose focus */
if (window && state == SDL_RELEASED) {
SDL_UpdateMouseFocus(window, mouse->x, mouse->y, buttonstate);
}
return posted;
}
static void setEffect(DirectInputEffect *dinputEffect, const DIEFFECT *di_eff)
{
uint32_t i;
switch (dinputEffect->real_type)
{
case SDL_HAPTIC_CONSTANT:
{
DICONSTANTFORCE *di_constant = (DICONSTANTFORCE *)di_eff->typeSpecificParams;
if (dinputEffect->effect.type == SDL_HAPTIC_SINE)
{
SDL_HapticPeriodic *periodic = &dinputEffect->effect.periodic;
if (di_constant)
periodic->magnitude = CONVERT(di_constant->magnitude);
periodic->length = CONVERT_LENGTH(di_eff->duration);
// printf("Constant as Sine: %d, %d\n", periodic->length, periodic->magnitude);
}
else
{
SDL_HapticConstant *constant = &dinputEffect->effect.constant;
if (di_constant)
constant->level = CONVERT(di_constant->magnitude);
constant->length = CONVERT_LENGTH(di_eff->duration);
constant->direction.type = SDL_HAPTIC_POLAR; //di_eff->flags shows that POLAR is used (0x20)
for (i = 0; i < di_eff->cAxes; ++i)
constant->direction.dir[i] = di_eff->rglDirection[i];
// printf("Constant: %d %d %d, %X\n", constant->length, constant->level, di_eff->cAxes, di_eff->flags);
}
} break;
case SDL_HAPTIC_SINE:
{
DIPERIODIC *di_periodic = (DIPERIODIC *)di_eff->typeSpecificParams;
SDL_HapticPeriodic *periodic = &dinputEffect->effect.periodic;
if (di_periodic)
{
periodic->magnitude = CONVERT(di_periodic->magnitude);
periodic->offset = CONVERT(di_periodic->offset);
periodic->period = (uint16_t)CONVERT_LENGTH(di_periodic->period);
periodic->phase = di_periodic->phase;
}
periodic->length = CONVERT_LENGTH(di_eff->duration);
if (di_eff->envelope)
setEnvelope(&periodic->attack_length, &periodic->attack_level, &periodic->fade_length, &periodic->fade_level, di_eff->envelope);
// printf("Square as Sine: %d\n", periodic->magnitude);
} break;
case SDL_HAPTIC_SPRING:
{
/* Deadband always 0, Coeff and Saturation always the same */
if (dinputEffect->effect.type == SDL_HAPTIC_SPRING)
{
/* Is it OK? I can't test it! */
SDL_HapticCondition *condition = &dinputEffect->effect.condition;
for (i = 0; i < di_eff->cAxes; ++i)
{
DICONDITION *di_condition = (DICONDITION *)di_eff->typeSpecificParams + i;
condition->center[i] = CONVERT(di_condition->lOffset);
condition->right_coeff[i] = CONVERT(di_condition->lPositiveCoefficient);
condition->left_coeff[i] = CONVERT(di_condition->lNegativeCoefficient);
condition->right_sat[i] = CONVERT(di_condition->dwPositiveSaturation);
condition->left_sat[i] = CONVERT(di_condition->dwNegativeSaturation);
condition->deadband[i] = CONVERT(di_condition->lDeadBand);
// printf("Spring[%d]: %d %d %d %d %d %d\n", i, condition->center[i], condition->right_coeff[i], condition->left_coeff[i], condition->right_sat[i], condition->left_sat[i], condition->deadband[i]);
}
condition->length = CONVERT_LENGTH(di_eff->duration);
}
else if (dinputEffect->effect.type == SDL_HAPTIC_CONSTANT && di_eff->cAxes)
{
/* Simulate Spring with Constant - this probably works bad :D */
SDL_HapticConstant *constant = &dinputEffect->effect.constant;
DICONDITION *di_condition = (DICONDITION *)di_eff->typeSpecificParams;
int32_t axis = *dinputEffect->xAxis * 20000 / 65535 - 10000;
int32_t force;
if (*dinputEffect->xAxis > 0)
force = di_condition->lPositiveCoefficient * (axis - di_condition->lOffset);
else
force = di_condition->lNegativeCoefficient * (axis - di_condition->lOffset);
constant->direction.type = SDL_HAPTIC_CARTESIAN;
constant->direction.dir[0] = (force == 0) ? 0 : (force < 0 ? -1 : 1);
constant->attack_level = SDL_abs(force / 3052);
constant->attack_length = (uint16_t)CONVERT_LENGTH(di_eff->duration);
// printf("Spring as Constant: coeffP: %d, coeffN: %d, offset: %d, xAxis: %d, force: %d, attack: %d\n", di_condition->lPositiveCoefficient, di_condition->lNegativeCoefficient, di_condition->lOffset, axis, force, force / 3052);
}
} break;
}
}
