📄 effect_linuxinput.c
字号:
env->fade_length = peff->lpEnvelope->dwFadeTime / 1000;
env->fade_level = (peff->lpEnvelope->dwFadeLevel / 10) * 32;
}
}
/* Gain and Sample Period settings are not supported by the linux
* event system */
if (dwFlags & DIEP_GAIN)
TRACE("Gain requested but no gain functionality present.\n");
if (dwFlags & DIEP_SAMPLEPERIOD)
TRACE("Sample period requested but no sample period functionality present.\n");
if (dwFlags & DIEP_STARTDELAY)
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) {
LPCDIPERIODIC tsp;
if (peff->cbTypeSpecificParams != sizeof(DIPERIODIC))
return DIERR_INVALIDPARAM;
tsp = (LPCDIPERIODIC)(peff->lpvTypeSpecificParams);
This->effect.u.periodic.magnitude = (tsp->dwMagnitude / 10) * 32;
This->effect.u.periodic.offset = (tsp->lOffset / 10) * 32;
This->effect.u.periodic.phase = (tsp->dwPhase / 9) * 8; /* == (/ 36 * 32) */
This->effect.u.periodic.period = tsp->dwPeriod / 1000;
} else if (type == DIEFT_CONSTANTFORCE) {
LPCDICONSTANTFORCE tsp;
if (peff->cbTypeSpecificParams != sizeof(DICONSTANTFORCE))
return DIERR_INVALIDPARAM;
tsp = (LPCDICONSTANTFORCE)(peff->lpvTypeSpecificParams);
This->effect.u.constant.level = (tsp->lMagnitude / 10) * 32;
} else if (type == DIEFT_RAMPFORCE) {
LPCDIRAMPFORCE tsp;
if (peff->cbTypeSpecificParams != sizeof(DIRAMPFORCE))
return DIERR_INVALIDPARAM;
tsp = (LPCDIRAMPFORCE)(peff->lpvTypeSpecificParams);
This->effect.u.ramp.start_level = (tsp->lStart / 10) * 32;
This->effect.u.ramp.end_level = (tsp->lStart / 10) * 32;
} else if (type == DIEFT_CONDITION) {
LPCDICONDITION tsp = (LPCDICONDITION)(peff->lpvTypeSpecificParams);
if (peff->cbTypeSpecificParams == sizeof(DICONDITION)) {
/* One condition block. This needs to be rotated to direction,
* and expanded to separate x and y conditions. */
int i;
double factor[2];
factor[0] = asin((This->effect.direction * 3.0 * M_PI) / 0x7FFF);
factor[1] = acos((This->effect.direction * 3.0 * M_PI) / 0x7FFF);
for (i = 0; i < 2; ++i) {
This->effect.u.condition[i].center = (int)(factor[i] * (tsp->lOffset / 10) * 32);
This->effect.u.condition[i].right_coeff = (int)(factor[i] * (tsp->lPositiveCoefficient / 10) * 32);
This->effect.u.condition[i].left_coeff = (int)(factor[i] * (tsp->lNegativeCoefficient / 10) * 32);
This->effect.u.condition[i].right_saturation = (int)(factor[i] * (tsp->dwPositiveSaturation / 10) * 32);
This->effect.u.condition[i].left_saturation = (int)(factor[i] * (tsp->dwNegativeSaturation / 10) * 32);
This->effect.u.condition[i].deadband = (int)(factor[i] * (tsp->lDeadBand / 10) * 32);
}
} else if (peff->cbTypeSpecificParams == 2 * sizeof(DICONDITION)) {
/* Two condition blocks. Direct parameter copy. */
int i;
for (i = 0; i < 2; ++i) {
This->effect.u.condition[i].center = (tsp[i].lOffset / 10) * 32;
This->effect.u.condition[i].right_coeff = (tsp[i].lPositiveCoefficient / 10) * 32;
This->effect.u.condition[i].left_coeff = (tsp[i].lNegativeCoefficient / 10) * 32;
This->effect.u.condition[i].right_saturation = (tsp[i].dwPositiveSaturation / 10) * 32;
This->effect.u.condition[i].left_saturation = (tsp[i].dwNegativeSaturation / 10) * 32;
This->effect.u.condition[i].deadband = (tsp[i].lDeadBand / 10) * 32;
}
} else {
return DIERR_INVALIDPARAM;
}
} 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 ULONG WINAPI LinuxInputEffectImpl_Release(
LPDIRECTINPUTEFFECT iface)
{
LinuxInputEffectImpl *This = (LinuxInputEffectImpl *)iface;
ULONG ref = InterlockedDecrement(&(This->ref));
if (ref == 0)
HeapFree(GetProcessHeap(), 0, This);
return ref;
}
static HRESULT WINAPI LinuxInputEffectImpl_Stop(
LPDIRECTINPUTEFFECT iface)
{
struct input_event event;
LinuxInputEffectImpl *This = (LinuxInputEffectImpl *)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 = (LinuxInputEffectImpl *)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;
}
/******************************************************************************
* LinuxInputEffect
*/
HRESULT linuxinput_create_effect(
int* fd,
REFGUID rguid,
LPDIRECTINPUTEFFECT* peff)
{
LinuxInputEffectImpl* newEffect = HeapAlloc(GetProcessHeap(),
HEAP_ZERO_MEMORY, sizeof(LinuxInputEffectImpl));
DWORD type = _typeFromGUID(rguid);
newEffect->lpVtbl = &LinuxInputEffectVtbl;
newEffect->ref = 1;
memcpy(&(newEffect->guid), rguid, sizeof(*rguid));
newEffect->fd = fd;
/* 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.\n");
HeapFree(GetProcessHeap(), 0, newEffect);
return DIERR_INVALIDPARAM;
}
/* mark as non-uploaded */
newEffect->effect.id = -1;
*peff = (LPDIRECTINPUTEFFECT)newEffect;
TRACE("Creating linux input system effect (%p) with guid %s\n",
*peff, _dump_dinput_GUID(rguid));
return DI_OK;
}
HRESULT linuxinput_get_info_A(
int fd,
REFGUID rguid,
LPDIEFFECTINFOA info)
{
DWORD type = _typeFromGUID(rguid);
TRACE("(%d, %s, %p) type=%ld\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((char*)&(info->tszName), _dump_dinput_GUID(rguid));
return DI_OK;
}
HRESULT linuxinput_get_info_W(
int fd,
REFGUID rguid,
LPDIEFFECTINFOW info)
{
DWORD type = _typeFromGUID(rguid);
TRACE("(%d, %s, %p) type=%ld\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,
(WCHAR*)&(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 */
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -