mirror of
https://github.com/reactos/reactos.git
synced 2024-10-30 11:35:58 +00:00
939 lines
31 KiB
C
939 lines
31 KiB
C
/* DirectInput Linux Event Device Effect
|
|
*
|
|
* Copyright 2005 Daniel Remenak
|
|
*
|
|
* Thanks to Google's Summer of Code Program (2005)
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
* License as published by the Free Software Foundation; either
|
|
* version 2.1 of the License, or (at your option) any later version.
|
|
*
|
|
* This library is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
* License along with this library; if not, write to the Free Software
|
|
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
|
|
*/
|
|
|
|
#include "config.h"
|
|
|
|
#ifdef HAVE_STRUCT_FF_EFFECT_DIRECTION
|
|
|
|
#include <stdarg.h>
|
|
#include <string.h>
|
|
#ifdef HAVE_LINUX_INPUT_H
|
|
# include <linux/input.h>
|
|
# undef SW_MAX
|
|
#endif
|
|
#include <limits.h>
|
|
#include <errno.h>
|
|
#ifdef HAVE_UNISTD_H
|
|
# include <unistd.h>
|
|
#endif
|
|
#include <math.h>
|
|
#include "wine/debug.h"
|
|
#include "wine/unicode.h"
|
|
#include "windef.h"
|
|
#include "winbase.h"
|
|
#include "winerror.h"
|
|
#include "dinput.h"
|
|
|
|
#include "device_private.h"
|
|
#include "joystick_private.h"
|
|
|
|
WINE_DEFAULT_DEBUG_CHANNEL(dinput);
|
|
|
|
static const IDirectInputEffectVtbl LinuxInputEffectVtbl;
|
|
typedef struct LinuxInputEffectImpl LinuxInputEffectImpl;
|
|
struct LinuxInputEffectImpl
|
|
{
|
|
IDirectInputEffect IDirectInputEffect_iface;
|
|
LONG ref;
|
|
GUID guid;
|
|
|
|
struct ff_effect effect; /* Effect data */
|
|
int gain; /* Effect gain */
|
|
BOOL first_axis_is_x;
|
|
int* fd; /* Parent device */
|
|
struct list *entry; /* Entry into the parent's list of effects */
|
|
};
|
|
|
|
static inline LinuxInputEffectImpl *impl_from_IDirectInputEffect(IDirectInputEffect *iface)
|
|
{
|
|
return CONTAINING_RECORD(iface, LinuxInputEffectImpl, IDirectInputEffect_iface);
|
|
}
|
|
|
|
static double ff_effect_direction_to_rad(unsigned int dir)
|
|
{
|
|
return (dir & 0xffff) * M_PI / 0x8000;
|
|
}
|
|
|
|
static void ff_dump_effect(struct ff_effect *effect)
|
|
{
|
|
const char *type = "(Unknown)", *length = "INFINITE";
|
|
struct ff_envelope *env = NULL;
|
|
double angle;
|
|
#define FE(x) case x: type = #x; break
|
|
switch (effect->type)
|
|
{
|
|
FE(FF_RUMBLE);
|
|
FE(FF_PERIODIC);
|
|
FE(FF_CONSTANT);
|
|
FE(FF_SPRING);
|
|
FE(FF_FRICTION);
|
|
FE(FF_DAMPER);
|
|
FE(FF_INERTIA);
|
|
FE(FF_RAMP);
|
|
}
|
|
#undef FE
|
|
|
|
/* rotate so 0 points right */
|
|
angle = 360 - ff_effect_direction_to_rad(effect->direction + 0xc000) * 180 / M_PI;
|
|
|
|
if (effect->replay.length)
|
|
length = wine_dbg_sprintf("%u ms", effect->replay.length);
|
|
|
|
TRACE("type 0x%x %s, id %d, direction 0x%x (source angle %.2f), time length %s, start delay %u ms\n",
|
|
effect->type, type, effect->id, effect->direction, angle, length, effect->replay.delay);
|
|
if (effect->trigger.button || effect->trigger.interval)
|
|
TRACE(" -> trigger button %u, re-trigger interval %u ms\n",
|
|
effect->trigger.button, effect->trigger.interval);
|
|
|
|
if (effect->type == FF_PERIODIC)
|
|
{
|
|
struct ff_periodic_effect *per = &effect->u.periodic;
|
|
const char *wave = "(Unknown)";
|
|
#define FE(x) case x: wave = #x; break
|
|
switch (per->waveform)
|
|
{
|
|
FE(FF_SQUARE);
|
|
FE(FF_TRIANGLE);
|
|
FE(FF_SINE);
|
|
FE(FF_SAW_UP);
|
|
FE(FF_SAW_DOWN);
|
|
FE(FF_CUSTOM);
|
|
}
|
|
#undef FE
|
|
angle = ff_effect_direction_to_rad(per->phase) * 180 / M_PI;
|
|
TRACE(" -> waveform 0x%x %s, period %u ms, magnitude %d, offset %d, phase 0x%x (angle %.2f), custom len %d\n",
|
|
per->waveform, wave, per->period, per->magnitude, per->offset, per->phase, angle, per->custom_len);
|
|
env = &per->envelope;
|
|
}
|
|
else if (effect->type == FF_CONSTANT)
|
|
{
|
|
struct ff_constant_effect *cons = &effect->u.constant;
|
|
TRACE(" -> level %d\n", cons->level);
|
|
env = &cons->envelope;
|
|
}
|
|
else if (effect->type == FF_RAMP)
|
|
{
|
|
struct ff_ramp_effect *ramp = &effect->u.ramp;
|
|
TRACE(" -> start/end level %d/%d\n", ramp->start_level, ramp->end_level);
|
|
env = &ramp->envelope;
|
|
}
|
|
else if (effect->type == FF_RUMBLE)
|
|
{
|
|
struct ff_rumble_effect *rumble = &effect->u.rumble;
|
|
TRACE(" -> strong/weak magnitude %u/%u\n", rumble->strong_magnitude, rumble->weak_magnitude);
|
|
}
|
|
else if (effect->type == FF_SPRING || effect->type == FF_FRICTION ||
|
|
effect->type == FF_DAMPER || effect->type == FF_INERTIA)
|
|
{
|
|
struct ff_condition_effect *cond = effect->u.condition;
|
|
int i;
|
|
for (i = 0; i < 2; i++)
|
|
{
|
|
/* format numbers here to make them align correctly */
|
|
TRACE(" -> [%d] right/left saturation %5u/%5u, right/left coefficient %5d/%5d,"
|
|
" deadband %5u, center %5d\n", i, cond[i].right_saturation, cond[i].left_saturation,
|
|
cond[i].right_coeff, cond[i].left_coeff, cond[i].deadband, cond[i].center);
|
|
}
|
|
}
|
|
|
|
if (env)
|
|
TRACE(" -> envelope attack length(ms)/level %u/%u, fade length(ms)/level %u/%u\n",
|
|
env->attack_length, env->attack_level, env->fade_length, env->fade_level);
|
|
}
|
|
|
|
/******************************************************************************
|
|
* LinuxInputEffectImpl
|
|
*/
|
|
|
|
static ULONG WINAPI LinuxInputEffectImpl_AddRef(
|
|
LPDIRECTINPUTEFFECT iface)
|
|
{
|
|
LinuxInputEffectImpl *This = impl_from_IDirectInputEffect(iface);
|
|
ULONG ref = InterlockedIncrement(&This->ref);
|
|
TRACE( "(%p) ref %d\n", This, ref );
|
|
return ref;
|
|
}
|
|
|
|
static HRESULT WINAPI LinuxInputEffectImpl_Download(
|
|
LPDIRECTINPUTEFFECT iface)
|
|
{
|
|
LinuxInputEffectImpl *This = impl_from_IDirectInputEffect(iface);
|
|
int ret, old_effect_id;
|
|
|
|
TRACE("(this=%p)\n", This);
|
|
ff_dump_effect(&This->effect);
|
|
|
|
old_effect_id = This->effect.id;
|
|
if (ioctl(*(This->fd), EVIOCSFF, &This->effect) != -1)
|
|
return DI_OK;
|
|
|
|
/* Linux kernel < 3.14 has a bug that incorrectly assigns an effect ID even
|
|
* on error, restore it here if that is the case. */
|
|
This->effect.id = old_effect_id;
|
|
|
|
switch (errno)
|
|
{
|
|
case EINVAL:
|
|
ret = DIERR_INVALIDPARAM;
|
|
break;
|
|
case ENOSPC:
|
|
ret = DIERR_DEVICEFULL;
|
|
break;
|
|
case ENOMEM:
|
|
ret = DIERR_OUTOFMEMORY;
|
|
break;
|
|
default:
|
|
ret = DIERR_INPUTLOST;
|
|
break;
|
|
}
|
|
TRACE("Could not upload effect to fd %d, errno %d \"%s\", returning 0x%x.\n",
|
|
*This->fd, errno, strerror(errno), ret);
|
|
return ret;
|
|
}
|
|
|
|
static HRESULT WINAPI LinuxInputEffectImpl_Escape(
|
|
LPDIRECTINPUTEFFECT iface,
|
|
LPDIEFFESCAPE pesc)
|
|
{
|
|
WARN("(this=%p,%p): invalid: no hardware-specific escape codes in this"
|
|
" driver!\n", iface, pesc);
|
|
|
|
return DI_OK;
|
|
}
|
|
|
|
static HRESULT WINAPI LinuxInputEffectImpl_GetEffectGuid(
|
|
LPDIRECTINPUTEFFECT iface,
|
|
LPGUID pguid)
|
|
{
|
|
LinuxInputEffectImpl *This = impl_from_IDirectInputEffect(iface);
|
|
|
|
TRACE("(this=%p,%p)\n", This, pguid);
|
|
|
|
*pguid = This->guid;
|
|
|
|
return DI_OK;
|
|
}
|
|
|
|
static HRESULT WINAPI LinuxInputEffectImpl_GetEffectStatus(
|
|
LPDIRECTINPUTEFFECT iface,
|
|
LPDWORD pdwFlags)
|
|
{
|
|
LinuxInputEffectImpl *This = impl_from_IDirectInputEffect(iface);
|
|
|
|
TRACE("(this=%p,%p)\n", This, pdwFlags);
|
|
|
|
if (!pdwFlags)
|
|
return E_POINTER;
|
|
|
|
if (This->effect.id == -1)
|
|
return DIERR_NOTDOWNLOADED;
|
|
|
|
/* linux sends the effect status through an event.
|
|
* that event is trapped by our parent joystick driver
|
|
* and there is no clean way to pass it back to us. */
|
|
FIXME("Not enough information to provide a status.\n");
|
|
|
|
(*pdwFlags) = 0;
|
|
|
|
return DI_OK;
|
|
}
|
|
|
|
static HRESULT WINAPI LinuxInputEffectImpl_GetParameters(
|
|
LPDIRECTINPUTEFFECT iface,
|
|
LPDIEFFECT peff,
|
|
DWORD dwFlags)
|
|
{
|
|
HRESULT diErr = DI_OK;
|
|
LinuxInputEffectImpl *This = impl_from_IDirectInputEffect(iface);
|
|
TRACE("(this=%p,%p,%d)\n", This, peff, dwFlags);
|
|
|
|
/* Major conversion factors are:
|
|
* times: millisecond (linux) -> microsecond (windows) (x * 1000)
|
|
* forces: scale 0x7FFF (linux) -> scale 10000 (windows) approx ((x / 33) * 10)
|
|
* angles: scale 0x7FFF (linux) -> scale 35999 (windows) approx ((x / 33) * 36)
|
|
* angle bases: 0 -> -y (down) (linux) -> 0 -> +x (right) (windows)
|
|
*/
|
|
|
|
if (dwFlags & DIEP_AXES) {
|
|
if (peff->cAxes < 2 /* linuxinput effects always use 2 axes, x and y */)
|
|
diErr = DIERR_MOREDATA;
|
|
peff->cAxes = 2;
|
|
if (diErr)
|
|
return diErr;
|
|
else {
|
|
peff->rgdwAxes[0] = DIJOFS_X;
|
|
peff->rgdwAxes[1] = DIJOFS_Y;
|
|
}
|
|
}
|
|
|
|
if (dwFlags & DIEP_DIRECTION) {
|
|
if (peff->cAxes < 2)
|
|
diErr = DIERR_MOREDATA;
|
|
peff->cAxes = 2;
|
|
if (diErr)
|
|
return diErr;
|
|
else {
|
|
if (peff->dwFlags & DIEFF_CARTESIAN) {
|
|
/* rotate so 0 points right */
|
|
double angle = ff_effect_direction_to_rad(This->effect.direction + 0xc000);
|
|
peff->rglDirection[0] = sin(angle) * 1000;
|
|
peff->rglDirection[1] = -cos(angle) * 1000;
|
|
} else {
|
|
/* Polar and spherical coordinates are the same for two or less
|
|
* axes.
|
|
* Note that we also use this case if NO flags are marked.
|
|
* According to MSDN, we should return the direction in the
|
|
* format that it was specified in, if no flags are marked.
|
|
*/
|
|
peff->rglDirection[0] = (This->effect.direction / 33) * 36 + 9000;
|
|
if (peff->rglDirection[0] > 35999)
|
|
peff->rglDirection[0] -= 35999;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (dwFlags & DIEP_DURATION)
|
|
{
|
|
if (!This->effect.replay.length) /* infinite for the linux driver */
|
|
peff->dwDuration = INFINITE;
|
|
else
|
|
peff->dwDuration = (DWORD)This->effect.replay.length * 1000;
|
|
}
|
|
|
|
if (dwFlags & DIEP_ENVELOPE) {
|
|
struct ff_envelope* env;
|
|
if (This->effect.type == FF_CONSTANT) env = &This->effect.u.constant.envelope;
|
|
else if (This->effect.type == FF_PERIODIC) env = &This->effect.u.periodic.envelope;
|
|
else if (This->effect.type == FF_RAMP) env = &This->effect.u.ramp.envelope;
|
|
else env = NULL;
|
|
if (env == NULL) {
|
|
peff->lpEnvelope = NULL;
|
|
} else if (peff->lpEnvelope == NULL) {
|
|
return DIERR_INVALIDPARAM;
|
|
} else {
|
|
peff->lpEnvelope->dwAttackLevel = (env->attack_level / 33) * 10;
|
|
peff->lpEnvelope->dwAttackTime = env->attack_length * 1000;
|
|
peff->lpEnvelope->dwFadeLevel = (env->fade_level / 33) * 10;
|
|
peff->lpEnvelope->dwFadeTime = env->fade_length * 1000;
|
|
}
|
|
}
|
|
|
|
if (dwFlags & DIEP_GAIN) {
|
|
peff->dwGain = This->gain * 10000 / 0xFFFF;
|
|
}
|
|
|
|
if (dwFlags & DIEP_SAMPLEPERIOD) {
|
|
/* the linux input ff driver has no support for setting
|
|
* the playback sample period. 0 means default. */
|
|
peff->dwSamplePeriod = 0;
|
|
}
|
|
|
|
if ((dwFlags & DIEP_STARTDELAY) && peff->dwSize > sizeof(DIEFFECT_DX5))
|
|
peff->dwStartDelay = This->effect.replay.delay * 1000;
|
|
|
|
if (dwFlags & DIEP_TRIGGERBUTTON) {
|
|
FIXME("LinuxInput button mapping needs redoing; for now, assuming we're using an actual joystick.\n");
|
|
peff->dwTriggerButton = DIJOFS_BUTTON(This->effect.trigger.button - BTN_JOYSTICK);
|
|
}
|
|
|
|
if (dwFlags & DIEP_TRIGGERREPEATINTERVAL) {
|
|
peff->dwTriggerRepeatInterval = This->effect.trigger.interval * 1000;
|
|
}
|
|
|
|
if (dwFlags & DIEP_TYPESPECIFICPARAMS) {
|
|
DWORD expectedsize = 0;
|
|
if (This->effect.type == FF_PERIODIC) {
|
|
expectedsize = sizeof(DIPERIODIC);
|
|
} else if (This->effect.type == FF_CONSTANT) {
|
|
expectedsize = sizeof(DICONSTANTFORCE);
|
|
} else if (This->effect.type == FF_SPRING
|
|
|| This->effect.type == FF_FRICTION
|
|
|| This->effect.type == FF_INERTIA
|
|
|| This->effect.type == FF_DAMPER) {
|
|
expectedsize = sizeof(DICONDITION) * 2;
|
|
} else if (This->effect.type == FF_RAMP) {
|
|
expectedsize = sizeof(DIRAMPFORCE);
|
|
}
|
|
if (expectedsize > peff->cbTypeSpecificParams)
|
|
diErr = DIERR_MOREDATA;
|
|
peff->cbTypeSpecificParams = expectedsize;
|
|
if (diErr)
|
|
return diErr;
|
|
else {
|
|
if (This->effect.type == FF_PERIODIC) {
|
|
LPDIPERIODIC tsp = peff->lpvTypeSpecificParams;
|
|
tsp->dwMagnitude = (This->effect.u.periodic.magnitude / 33) * 10;
|
|
tsp->lOffset = (This->effect.u.periodic.offset / 33) * 10;
|
|
tsp->dwPhase = (This->effect.u.periodic.phase / 33) * 36;
|
|
tsp->dwPeriod = (This->effect.u.periodic.period * 1000);
|
|
} else if (This->effect.type == FF_CONSTANT) {
|
|
LPDICONSTANTFORCE tsp = peff->lpvTypeSpecificParams;
|
|
tsp->lMagnitude = (This->effect.u.constant.level / 33) * 10;
|
|
} else if (This->effect.type == FF_SPRING
|
|
|| This->effect.type == FF_FRICTION
|
|
|| This->effect.type == FF_INERTIA
|
|
|| This->effect.type == FF_DAMPER) {
|
|
LPDICONDITION tsp = peff->lpvTypeSpecificParams;
|
|
int i;
|
|
for (i = 0; i < 2; ++i) {
|
|
tsp[i].lOffset = (This->effect.u.condition[i].center / 33) * 10;
|
|
tsp[i].lPositiveCoefficient = (This->effect.u.condition[i].right_coeff / 33) * 10;
|
|
tsp[i].lNegativeCoefficient = (This->effect.u.condition[i].left_coeff / 33) * 10;
|
|
tsp[i].dwPositiveSaturation = (This->effect.u.condition[i].right_saturation / 33) * 10;
|
|
tsp[i].dwNegativeSaturation = (This->effect.u.condition[i].left_saturation / 33) * 10;
|
|
tsp[i].lDeadBand = (This->effect.u.condition[i].deadband / 33) * 10;
|
|
}
|
|
} else if (This->effect.type == FF_RAMP) {
|
|
LPDIRAMPFORCE tsp = peff->lpvTypeSpecificParams;
|
|
tsp->lStart = (This->effect.u.ramp.start_level / 33) * 10;
|
|
tsp->lEnd = (This->effect.u.ramp.end_level / 33) * 10;
|
|
}
|
|
}
|
|
}
|
|
|
|
return diErr;
|
|
}
|
|
|
|
static HRESULT WINAPI LinuxInputEffectImpl_Initialize(
|
|
LPDIRECTINPUTEFFECT iface,
|
|
HINSTANCE hinst,
|
|
DWORD dwVersion,
|
|
REFGUID rguid)
|
|
{
|
|
FIXME("(this=%p,%p,%d,%s): stub!\n",
|
|
iface, hinst, dwVersion, debugstr_guid(rguid));
|
|
|
|
return DI_OK;
|
|
}
|
|
|
|
static HRESULT WINAPI LinuxInputEffectImpl_QueryInterface(
|
|
LPDIRECTINPUTEFFECT iface,
|
|
REFIID riid,
|
|
void **ppvObject)
|
|
{
|
|
LinuxInputEffectImpl *This = impl_from_IDirectInputEffect(iface);
|
|
|
|
TRACE("(this=%p,%s,%p)\n", This, debugstr_guid(riid), ppvObject);
|
|
|
|
if (IsEqualGUID(&IID_IUnknown, riid) ||
|
|
IsEqualGUID(&IID_IDirectInputEffect, riid)) {
|
|
LinuxInputEffectImpl_AddRef(iface);
|
|
*ppvObject = This;
|
|
return 0;
|
|
}
|
|
|
|
TRACE("Unsupported interface!\n");
|
|
return E_FAIL;
|
|
}
|
|
|
|
static HRESULT WINAPI LinuxInputEffectImpl_Start(
|
|
LPDIRECTINPUTEFFECT iface,
|
|
DWORD dwIterations,
|
|
DWORD dwFlags)
|
|
{
|
|
struct input_event event;
|
|
LinuxInputEffectImpl *This = impl_from_IDirectInputEffect(iface);
|
|
|
|
TRACE("(this=%p,%d,%d)\n", This, dwIterations, dwFlags);
|
|
|
|
if (!(dwFlags & DIES_NODOWNLOAD)) {
|
|
/* Download the effect if necessary */
|
|
if (This->effect.id == -1) {
|
|
HRESULT res = LinuxInputEffectImpl_Download(iface);
|
|
if (res != DI_OK)
|
|
return res;
|
|
}
|
|
}
|
|
|
|
if (dwFlags & DIES_SOLO) {
|
|
FIXME("Solo mode requested: should be stopping all effects here!\n");
|
|
}
|
|
|
|
event.type = EV_FF;
|
|
event.code = This->effect.id;
|
|
event.value = min( dwIterations, INT_MAX );
|
|
if (write(*(This->fd), &event, sizeof(event)) == -1) {
|
|
FIXME("Unable to write event. Assuming device disconnected.\n");
|
|
return DIERR_INPUTLOST;
|
|
}
|
|
|
|
return DI_OK;
|
|
}
|
|
|
|
static HRESULT WINAPI LinuxInputEffectImpl_SetParameters(
|
|
LPDIRECTINPUTEFFECT iface,
|
|
LPCDIEFFECT peff,
|
|
DWORD dwFlags)
|
|
{
|
|
LinuxInputEffectImpl *This = impl_from_IDirectInputEffect(iface);
|
|
DWORD type = typeFromGUID(&This->guid);
|
|
HRESULT retval = DI_OK;
|
|
|
|
TRACE("(this=%p,%p,%d)\n", This, peff, dwFlags);
|
|
|
|
dump_DIEFFECT(peff, &This->guid, dwFlags);
|
|
|
|
if ((dwFlags & ~DIEP_NORESTART & ~DIEP_NODOWNLOAD & ~DIEP_START) == 0) {
|
|
/* set everything */
|
|
dwFlags = DIEP_AXES | DIEP_DIRECTION | DIEP_DURATION | DIEP_ENVELOPE |
|
|
DIEP_GAIN | DIEP_SAMPLEPERIOD | DIEP_STARTDELAY | DIEP_TRIGGERBUTTON |
|
|
DIEP_TRIGGERREPEATINTERVAL | DIEP_TYPESPECIFICPARAMS;
|
|
}
|
|
|
|
if (dwFlags & DIEP_AXES) {
|
|
/* the linux input effect system only supports one or two axes */
|
|
if (peff->cAxes > 2)
|
|
return DIERR_INVALIDPARAM;
|
|
else if (peff->cAxes < 1)
|
|
return DIERR_INCOMPLETEEFFECT;
|
|
This->first_axis_is_x = peff->rgdwAxes[0] == DIJOFS_X;
|
|
}
|
|
|
|
/* some of this may look funky, but it's 'cause the linux driver and directx have
|
|
* different opinions about which way direction "0" is. directx has 0 along the x
|
|
* axis (left), linux has it along the y axis (down). */
|
|
if (dwFlags & DIEP_DIRECTION) {
|
|
if (peff->cAxes == 1) {
|
|
if (peff->dwFlags & DIEFF_CARTESIAN) {
|
|
if (dwFlags & DIEP_AXES) {
|
|
if (peff->rgdwAxes[0] == DIJOFS_X && peff->rglDirection[0] >= 0)
|
|
This->effect.direction = 0x4000;
|
|
else if (peff->rgdwAxes[0] == DIJOFS_X && peff->rglDirection[0] < 0)
|
|
This->effect.direction = 0xC000;
|
|
else if (peff->rgdwAxes[0] == DIJOFS_Y && peff->rglDirection[0] >= 0)
|
|
This->effect.direction = 0;
|
|
else if (peff->rgdwAxes[0] == DIJOFS_Y && peff->rglDirection[0] < 0)
|
|
This->effect.direction = 0x8000;
|
|
}
|
|
} else {
|
|
/* one-axis effects must use cartesian coords */
|
|
return DIERR_INVALIDPARAM;
|
|
}
|
|
}
|
|
/* two axes */
|
|
else
|
|
{
|
|
if (peff->dwFlags & DIEFF_CARTESIAN)
|
|
{
|
|
LONG x, y;
|
|
if (This->first_axis_is_x)
|
|
{
|
|
x = peff->rglDirection[0];
|
|
y = peff->rglDirection[1];
|
|
}
|
|
else
|
|
{
|
|
x = peff->rglDirection[1];
|
|
y = peff->rglDirection[0];
|
|
}
|
|
This->effect.direction = (unsigned int)((M_PI / 2 + atan2(y, x)) * 0x8000 / M_PI);
|
|
}
|
|
else
|
|
{
|
|
/* Polar and spherical are the same for 2 axes */
|
|
/* Precision is important here, so we do double math with exact constants */
|
|
This->effect.direction = (unsigned int)(((double)peff->rglDirection[0] / 18000) * 0x8000);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (dwFlags & DIEP_DURATION)
|
|
{
|
|
if (peff->dwDuration == INFINITE)
|
|
This->effect.replay.length = 0; /* infinite for the linux driver */
|
|
else if(peff->dwDuration > 1000)
|
|
This->effect.replay.length = peff->dwDuration / 1000;
|
|
else
|
|
This->effect.replay.length = 1;
|
|
}
|
|
|
|
if (dwFlags & DIEP_ENVELOPE)
|
|
{
|
|
struct ff_envelope* env;
|
|
if (This->effect.type == FF_CONSTANT)
|
|
env = &This->effect.u.constant.envelope;
|
|
else if (This->effect.type == FF_PERIODIC)
|
|
env = &This->effect.u.periodic.envelope;
|
|
else if (This->effect.type == FF_RAMP)
|
|
env = &This->effect.u.ramp.envelope;
|
|
else
|
|
env = NULL;
|
|
|
|
/* copy the envelope if it is present and the linux effect supports it */
|
|
if (peff->lpEnvelope && env)
|
|
{
|
|
env->attack_length = peff->lpEnvelope->dwAttackTime / 1000;
|
|
env->attack_level = (peff->lpEnvelope->dwAttackLevel / 10) * 32;
|
|
env->fade_length = peff->lpEnvelope->dwFadeTime / 1000;
|
|
env->fade_level = (peff->lpEnvelope->dwFadeLevel / 10) * 32;
|
|
}
|
|
/* if the dinput envelope is NULL we will clear the linux envelope */
|
|
else if (env)
|
|
{
|
|
env->attack_length = 0;
|
|
env->attack_level = 0;
|
|
env->fade_length = 0;
|
|
env->fade_level = 0;
|
|
}
|
|
else if(peff->lpEnvelope)
|
|
{
|
|
if(peff->lpEnvelope->dwAttackTime || peff->lpEnvelope->dwAttackLevel ||
|
|
peff->lpEnvelope->dwFadeTime || peff->lpEnvelope->dwFadeLevel)
|
|
WARN("Ignoring dinput envelope not supported in the linux effect\n");
|
|
}
|
|
}
|
|
|
|
/* Gain and Sample Period settings are not supported by the linux
|
|
* event system */
|
|
if (dwFlags & DIEP_GAIN) {
|
|
This->gain = 0xFFFF * peff->dwGain / 10000;
|
|
TRACE("Effect gain requested but no effect gain functionality present.\n");
|
|
}
|
|
|
|
if (dwFlags & DIEP_SAMPLEPERIOD)
|
|
TRACE("Sample period requested but no sample period functionality present.\n");
|
|
|
|
if (dwFlags & DIEP_STARTDELAY)
|
|
if ((dwFlags & DIEP_STARTDELAY) && peff->dwSize > sizeof(DIEFFECT_DX5))
|
|
This->effect.replay.delay = peff->dwStartDelay / 1000;
|
|
|
|
if (dwFlags & DIEP_TRIGGERBUTTON) {
|
|
if (peff->dwTriggerButton != -1) {
|
|
FIXME("Linuxinput button mapping needs redoing, assuming we're using a joystick.\n");
|
|
FIXME("Trigger button translation not yet implemented!\n");
|
|
}
|
|
This->effect.trigger.button = 0;
|
|
}
|
|
|
|
if (dwFlags & DIEP_TRIGGERREPEATINTERVAL)
|
|
This->effect.trigger.interval = peff->dwTriggerRepeatInterval / 1000;
|
|
|
|
if (dwFlags & DIEP_TYPESPECIFICPARAMS)
|
|
{
|
|
if (!(peff->lpvTypeSpecificParams))
|
|
return DIERR_INCOMPLETEEFFECT;
|
|
|
|
if (type == DIEFT_PERIODIC)
|
|
{
|
|
DIPERIODIC *tsp;
|
|
if (peff->cbTypeSpecificParams != sizeof(DIPERIODIC))
|
|
return DIERR_INVALIDPARAM;
|
|
tsp = peff->lpvTypeSpecificParams;
|
|
|
|
This->effect.u.periodic.magnitude = (tsp->dwMagnitude / 10) * 32;
|
|
This->effect.u.periodic.offset = (tsp->lOffset / 10) * 32;
|
|
/* phase ranges from 0 - 35999 in dinput and 0 - 65535 on Linux */
|
|
This->effect.u.periodic.phase = (tsp->dwPhase / 36) * 65;
|
|
/* dinput uses microseconds, Linux uses milliseconds */
|
|
if (tsp->dwPeriod <= 1000)
|
|
This->effect.u.periodic.period = 1;
|
|
else
|
|
This->effect.u.periodic.period = tsp->dwPeriod / 1000;
|
|
}
|
|
else if (type == DIEFT_CONSTANTFORCE)
|
|
{
|
|
LPCDICONSTANTFORCE tsp;
|
|
if (peff->cbTypeSpecificParams != sizeof(DICONSTANTFORCE))
|
|
return DIERR_INVALIDPARAM;
|
|
tsp = peff->lpvTypeSpecificParams;
|
|
This->effect.u.constant.level = (max(min(tsp->lMagnitude, 10000), -10000) / 10) * 32;
|
|
} else if (type == DIEFT_RAMPFORCE) {
|
|
LPCDIRAMPFORCE tsp;
|
|
if (peff->cbTypeSpecificParams != sizeof(DIRAMPFORCE))
|
|
return DIERR_INVALIDPARAM;
|
|
tsp = peff->lpvTypeSpecificParams;
|
|
This->effect.u.ramp.start_level = (tsp->lStart / 10) * 32;
|
|
This->effect.u.ramp.end_level = (tsp->lEnd / 10) * 32;
|
|
}
|
|
else if (type == DIEFT_CONDITION)
|
|
{
|
|
DICONDITION *tsp = peff->lpvTypeSpecificParams;
|
|
struct ff_condition_effect *cond = This->effect.u.condition;
|
|
int i, j, sources;
|
|
double factor[2];
|
|
|
|
if (peff->cbTypeSpecificParams == sizeof(DICONDITION))
|
|
{
|
|
/* One condition block. This needs to be rotated to direction,
|
|
* and expanded to separate x and y conditions. Ensures 0 points right */
|
|
double angle = ff_effect_direction_to_rad(This->effect.direction + 0xc000);
|
|
factor[0] = sin(angle);
|
|
factor[1] = -cos(angle);
|
|
sources = 1;
|
|
}
|
|
else if (peff->cbTypeSpecificParams == 2 * sizeof(DICONDITION))
|
|
{
|
|
/* Direct parameter copy without changes */
|
|
factor[0] = factor[1] = 1;
|
|
sources = 2;
|
|
}
|
|
else
|
|
return DIERR_INVALIDPARAM;
|
|
|
|
for (i = j = 0; i < 2; ++i)
|
|
{
|
|
cond[i].center = (int)(factor[i] * (tsp[j].lOffset / 10) * 32);
|
|
cond[i].right_coeff = (int)(factor[i] * (tsp[j].lPositiveCoefficient / 10) * 32);
|
|
cond[i].left_coeff = (int)(factor[i] * (tsp[j].lNegativeCoefficient / 10) * 32);
|
|
cond[i].right_saturation = (int)(factor[i] * (tsp[j].dwPositiveSaturation / 10) * 65);
|
|
cond[i].left_saturation = (int)(factor[i] * (tsp[j].dwNegativeSaturation / 10) * 65);
|
|
cond[i].deadband = (int)(factor[i] * (tsp[j].lDeadBand / 10) * 32);
|
|
if (sources == 2)
|
|
j++;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
FIXME("Custom force types are not supported\n");
|
|
return DIERR_INVALIDPARAM;
|
|
}
|
|
}
|
|
|
|
if (!(dwFlags & DIEP_NODOWNLOAD))
|
|
retval = LinuxInputEffectImpl_Download(iface);
|
|
if (retval != DI_OK)
|
|
return DI_DOWNLOADSKIPPED;
|
|
|
|
if (dwFlags & DIEP_NORESTART)
|
|
TRACE("DIEP_NORESTART: not handled (we have no control of that).\n");
|
|
|
|
if (dwFlags & DIEP_START)
|
|
retval = LinuxInputEffectImpl_Start(iface, 1, 0);
|
|
if (retval != DI_OK)
|
|
return retval;
|
|
|
|
return DI_OK;
|
|
}
|
|
|
|
static HRESULT WINAPI LinuxInputEffectImpl_Stop(
|
|
LPDIRECTINPUTEFFECT iface)
|
|
{
|
|
struct input_event event;
|
|
LinuxInputEffectImpl *This = impl_from_IDirectInputEffect(iface);
|
|
|
|
TRACE("(this=%p)\n", This);
|
|
|
|
event.type = EV_FF;
|
|
event.code = This->effect.id;
|
|
event.value = 0;
|
|
/* we don't care about the success or failure of this call */
|
|
write(*(This->fd), &event, sizeof(event));
|
|
|
|
return DI_OK;
|
|
}
|
|
|
|
static HRESULT WINAPI LinuxInputEffectImpl_Unload(
|
|
LPDIRECTINPUTEFFECT iface)
|
|
{
|
|
LinuxInputEffectImpl *This = impl_from_IDirectInputEffect(iface);
|
|
TRACE("(this=%p)\n", This);
|
|
|
|
/* Erase the downloaded effect */
|
|
if (ioctl(*(This->fd), EVIOCRMFF, This->effect.id) == -1)
|
|
return DIERR_INVALIDPARAM;
|
|
|
|
/* Mark the effect as deallocated */
|
|
This->effect.id = -1;
|
|
|
|
return DI_OK;
|
|
}
|
|
|
|
static ULONG WINAPI LinuxInputEffectImpl_Release(LPDIRECTINPUTEFFECT iface)
|
|
{
|
|
LinuxInputEffectImpl *This = impl_from_IDirectInputEffect(iface);
|
|
ULONG ref = InterlockedDecrement(&(This->ref));
|
|
|
|
TRACE( "(%p) ref %d\n", This, ref );
|
|
|
|
if (ref == 0)
|
|
{
|
|
LinuxInputEffectImpl_Stop(iface);
|
|
LinuxInputEffectImpl_Unload(iface);
|
|
list_remove(This->entry);
|
|
HeapFree(GetProcessHeap(), 0, LIST_ENTRY(This->entry, effect_list_item, entry));
|
|
HeapFree(GetProcessHeap(), 0, This);
|
|
}
|
|
return ref;
|
|
}
|
|
|
|
/******************************************************************************
|
|
* LinuxInputEffect
|
|
*/
|
|
|
|
DECLSPEC_HIDDEN HRESULT linuxinput_create_effect(
|
|
int* fd,
|
|
REFGUID rguid,
|
|
struct list *parent_list_entry,
|
|
LPDIRECTINPUTEFFECT* peff)
|
|
{
|
|
LinuxInputEffectImpl* newEffect = HeapAlloc(GetProcessHeap(),
|
|
HEAP_ZERO_MEMORY, sizeof(LinuxInputEffectImpl));
|
|
DWORD type = typeFromGUID(rguid);
|
|
|
|
newEffect->IDirectInputEffect_iface.lpVtbl = &LinuxInputEffectVtbl;
|
|
newEffect->ref = 1;
|
|
newEffect->guid = *rguid;
|
|
newEffect->fd = fd;
|
|
newEffect->gain = 0xFFFF;
|
|
|
|
/* set the type. this cannot be changed over the effect's life. */
|
|
switch (type) {
|
|
case DIEFT_PERIODIC:
|
|
newEffect->effect.type = FF_PERIODIC;
|
|
if (IsEqualGUID(rguid, &GUID_Sine)) {
|
|
newEffect->effect.u.periodic.waveform = FF_SINE;
|
|
} else if (IsEqualGUID(rguid, &GUID_Triangle)) {
|
|
newEffect->effect.u.periodic.waveform = FF_TRIANGLE;
|
|
} else if (IsEqualGUID(rguid, &GUID_Square)) {
|
|
newEffect->effect.u.periodic.waveform = FF_SQUARE;
|
|
} else if (IsEqualGUID(rguid, &GUID_SawtoothUp)) {
|
|
newEffect->effect.u.periodic.waveform = FF_SAW_UP;
|
|
} else if (IsEqualGUID(rguid, &GUID_SawtoothDown)) {
|
|
newEffect->effect.u.periodic.waveform = FF_SAW_DOWN;
|
|
}
|
|
break;
|
|
case DIEFT_CONSTANTFORCE:
|
|
newEffect->effect.type = FF_CONSTANT;
|
|
break;
|
|
case DIEFT_RAMPFORCE:
|
|
newEffect->effect.type = FF_RAMP;
|
|
break;
|
|
case DIEFT_CONDITION:
|
|
if (IsEqualGUID(rguid, &GUID_Spring)) {
|
|
newEffect->effect.type = FF_SPRING;
|
|
} else if (IsEqualGUID(rguid, &GUID_Friction)) {
|
|
newEffect->effect.type = FF_FRICTION;
|
|
} else if (IsEqualGUID(rguid, &GUID_Inertia)) {
|
|
newEffect->effect.type = FF_INERTIA;
|
|
} else if (IsEqualGUID(rguid, &GUID_Damper)) {
|
|
newEffect->effect.type = FF_DAMPER;
|
|
}
|
|
break;
|
|
case DIEFT_CUSTOMFORCE:
|
|
FIXME("Custom forces are not supported.\n");
|
|
HeapFree(GetProcessHeap(), 0, newEffect);
|
|
return DIERR_INVALIDPARAM;
|
|
default:
|
|
FIXME("Unknown force type 0x%x.\n", type);
|
|
HeapFree(GetProcessHeap(), 0, newEffect);
|
|
return DIERR_INVALIDPARAM;
|
|
}
|
|
|
|
/* mark as non-uploaded */
|
|
newEffect->effect.id = -1;
|
|
|
|
newEffect->entry = parent_list_entry;
|
|
|
|
*peff = &newEffect->IDirectInputEffect_iface;
|
|
|
|
TRACE("Creating linux input system effect (%p) with guid %s\n",
|
|
*peff, _dump_dinput_GUID(rguid));
|
|
|
|
return DI_OK;
|
|
}
|
|
|
|
DECLSPEC_HIDDEN HRESULT linuxinput_get_info_A(
|
|
int fd,
|
|
REFGUID rguid,
|
|
LPDIEFFECTINFOA info)
|
|
{
|
|
DWORD type = typeFromGUID(rguid);
|
|
|
|
TRACE("(%d, %s, %p) type=%d\n", fd, _dump_dinput_GUID(rguid), info, type);
|
|
|
|
if (!info) return E_POINTER;
|
|
|
|
if (info->dwSize != sizeof(DIEFFECTINFOA)) return DIERR_INVALIDPARAM;
|
|
|
|
info->guid = *rguid;
|
|
|
|
info->dwEffType = type;
|
|
/* the event device API does not support querying for all these things
|
|
* therefore we assume that we have support for them
|
|
* that's not as dangerous as it sounds, since drivers are allowed to
|
|
* ignore parameters they claim to support anyway */
|
|
info->dwEffType |= DIEFT_DEADBAND | DIEFT_FFATTACK | DIEFT_FFFADE
|
|
| DIEFT_POSNEGCOEFFICIENTS | DIEFT_POSNEGSATURATION
|
|
| DIEFT_SATURATION | DIEFT_STARTDELAY;
|
|
|
|
/* again, assume we have support for everything */
|
|
info->dwStaticParams = DIEP_ALLPARAMS;
|
|
info->dwDynamicParams = info->dwStaticParams;
|
|
|
|
/* yes, this is windows behavior (print the GUID_Name for name) */
|
|
strcpy(info->tszName, _dump_dinput_GUID(rguid));
|
|
|
|
return DI_OK;
|
|
}
|
|
|
|
DECLSPEC_HIDDEN HRESULT linuxinput_get_info_W(
|
|
int fd,
|
|
REFGUID rguid,
|
|
LPDIEFFECTINFOW info)
|
|
{
|
|
DWORD type = typeFromGUID(rguid);
|
|
|
|
TRACE("(%d, %s, %p) type=%d\n", fd, _dump_dinput_GUID(rguid), info, type);
|
|
|
|
if (!info) return E_POINTER;
|
|
|
|
if (info->dwSize != sizeof(DIEFFECTINFOW)) return DIERR_INVALIDPARAM;
|
|
|
|
info->guid = *rguid;
|
|
|
|
info->dwEffType = type;
|
|
/* the event device API does not support querying for all these things
|
|
* therefore we assume that we have support for them
|
|
* that's not as dangerous as it sounds, since drivers are allowed to
|
|
* ignore parameters they claim to support anyway */
|
|
info->dwEffType |= DIEFT_DEADBAND | DIEFT_FFATTACK | DIEFT_FFFADE
|
|
| DIEFT_POSNEGCOEFFICIENTS | DIEFT_POSNEGSATURATION
|
|
| DIEFT_SATURATION | DIEFT_STARTDELAY;
|
|
|
|
/* again, assume we have support for everything */
|
|
info->dwStaticParams = DIEP_ALLPARAMS;
|
|
info->dwDynamicParams = info->dwStaticParams;
|
|
|
|
/* yes, this is windows behavior (print the GUID_Name for name) */
|
|
MultiByteToWideChar(CP_ACP, 0, _dump_dinput_GUID(rguid), -1,
|
|
info->tszName, MAX_PATH);
|
|
|
|
return DI_OK;
|
|
}
|
|
|
|
static const IDirectInputEffectVtbl LinuxInputEffectVtbl = {
|
|
LinuxInputEffectImpl_QueryInterface,
|
|
LinuxInputEffectImpl_AddRef,
|
|
LinuxInputEffectImpl_Release,
|
|
LinuxInputEffectImpl_Initialize,
|
|
LinuxInputEffectImpl_GetEffectGuid,
|
|
LinuxInputEffectImpl_GetParameters,
|
|
LinuxInputEffectImpl_SetParameters,
|
|
LinuxInputEffectImpl_Start,
|
|
LinuxInputEffectImpl_Stop,
|
|
LinuxInputEffectImpl_GetEffectStatus,
|
|
LinuxInputEffectImpl_Download,
|
|
LinuxInputEffectImpl_Unload,
|
|
LinuxInputEffectImpl_Escape
|
|
};
|
|
|
|
#endif /* HAVE_STRUCT_FF_EFFECT_DIRECTION */
|