mirror of https://github.com/PCSX2/pcsx2.git
444 lines
13 KiB
C++
444 lines
13 KiB
C++
#include "global.h"
|
|
#include "VKey.h"
|
|
#include "DirectInput.h"
|
|
#include <dinput.h>
|
|
#include "InputManager.h"
|
|
#include "DeviceEnumerator.h"
|
|
|
|
|
|
inline static u16 flipShort(u16 s) {
|
|
return (s>>8) | (s<<8);
|
|
}
|
|
|
|
inline static u32 flipLong(u32 l) {
|
|
return (((u32)flipShort((u16)l))<<16) | flipShort((u16)(l>>16));
|
|
}
|
|
|
|
static void GUIDtoString(wchar_t *data, const GUID *pg) {
|
|
wsprintfW(data, L"%08X-%04X-%04X-%04X-%04X%08X",
|
|
pg->Data1, (u32)pg->Data2, (u32)pg->Data3,
|
|
flipShort(((u16*)pg->Data4)[0]),
|
|
flipShort(((u16*)pg->Data4)[1]),
|
|
flipLong(((u32*)pg->Data4)[1]));
|
|
}
|
|
|
|
static int StringToGUID(GUID *pg, wchar_t *dataw) {
|
|
char data[100];
|
|
if (wcslen(dataw) > 50) return 0;
|
|
int w = 0;
|
|
while (dataw[w]) {
|
|
data[w] = (char) dataw[w];
|
|
w++;
|
|
}
|
|
data[w] = 0;
|
|
u32 temp[5];
|
|
sscanf(data, "%08X-%04X-%04X-%04X-%04X%08X",
|
|
&pg->Data1, temp, temp+1,
|
|
temp+2, temp+3, temp+4);
|
|
pg->Data2 = (u16) temp[0];
|
|
pg->Data3 = (u16) temp[1];
|
|
((u16*)pg->Data4)[0] = flipShort((u16)temp[2]);
|
|
((u16*)pg->Data4)[1] = flipShort((u16)temp[3]);
|
|
((u32*)pg->Data4)[1] = flipLong(temp[4]);
|
|
return 1;
|
|
}
|
|
|
|
|
|
struct DI8Effect {
|
|
IDirectInputEffect *die;
|
|
int scale;
|
|
};
|
|
|
|
BOOL CALLBACK EnumDeviceObjectsCallback (LPCDIDEVICEOBJECTINSTANCE lpddoi, LPVOID pvRef);
|
|
BOOL CALLBACK EnumEffectsCallback(LPCDIEFFECTINFOW pdei, LPVOID pvRef);
|
|
class DirectInputDevice : public Device {
|
|
public:
|
|
DI8Effect *diEffects;
|
|
|
|
IDirectInputDevice8 *did;
|
|
DirectInputDevice(DeviceType type, IDirectInputDevice8* did, wchar_t *displayName, wchar_t *instanceID, wchar_t *productID) : Device(DI, type, displayName, instanceID, productID) {
|
|
int i;
|
|
diEffects = 0;
|
|
this->did = did;
|
|
did->EnumEffects(EnumEffectsCallback, this, DIEFT_ALL);
|
|
did->EnumObjects(EnumDeviceObjectsCallback, this, DIDFT_ALL);
|
|
DIOBJECTDATAFORMAT *formats = (DIOBJECTDATAFORMAT*)malloc(sizeof(DIOBJECTDATAFORMAT) * numPhysicalControls);
|
|
for (i=0; i<numPhysicalControls; i++) {
|
|
formats[i].pguid = 0;
|
|
formats[i].dwType = physicalControls[i].type | DIDFT_MAKEINSTANCE(physicalControls[i].id);
|
|
formats[i].dwOfs = 4*i;
|
|
formats[i].dwFlags = 0;
|
|
}
|
|
DIDATAFORMAT format;
|
|
format.dwSize = sizeof(format);
|
|
format.dwDataSize = 4 * numPhysicalControls;
|
|
format.dwObjSize = sizeof(DIOBJECTDATAFORMAT);
|
|
format.dwFlags = 0;
|
|
format.dwNumObjs = numPhysicalControls;
|
|
format.rgodf = formats;
|
|
int res = did->SetDataFormat(&format);
|
|
for (i=0; i<numPhysicalControls; i++) {
|
|
if (physicalControls[i].type == ABSAXIS) {
|
|
DIPROPRANGE prop;
|
|
prop.diph.dwHeaderSize = sizeof(DIPROPHEADER);
|
|
prop.diph.dwSize = sizeof(DIPROPRANGE);
|
|
prop.diph.dwObj = formats[i].dwType;
|
|
prop.diph.dwHow = DIPH_BYID;
|
|
prop.lMin = -FULLY_DOWN;
|
|
prop.lMax = FULLY_DOWN;
|
|
did->SetProperty(DIPROP_RANGE, &prop.diph);
|
|
|
|
// May do something like this again, if there's any need.
|
|
/*
|
|
if (FAILED(DI->did->SetProperty(DIPROP_RANGE, &prop.diph))) {
|
|
if (FAILED(DI->did->GetProperty(DIPROP_RANGE, &prop.diph))) {
|
|
// ????
|
|
DI->objects[i].min = prop.lMin;
|
|
DI->objects[i].max = prop.lMax;
|
|
continue;
|
|
}
|
|
}
|
|
DI->objects[i].min = prop.lMin;
|
|
DI->objects[i].max = prop.lMax;
|
|
//*/
|
|
}
|
|
}
|
|
free(formats);
|
|
}
|
|
|
|
void SetEffect(ForceFeedbackBinding *binding, unsigned char force) {
|
|
unsigned int index = binding - pads[0].ffBindings;
|
|
if (index >= (unsigned int)pads[0].numFFBindings) {
|
|
index = pads[0].numFFBindings + (binding - pads[1].ffBindings);
|
|
}
|
|
IDirectInputEffect *die = diEffects[index].die;
|
|
if (die) {
|
|
DIEFFECT dieffect;
|
|
memset(&dieffect, 0, sizeof(dieffect));
|
|
union {
|
|
DIPERIODIC periodic;
|
|
DIRAMPFORCE ramp;
|
|
DICONSTANTFORCE constant;
|
|
};
|
|
|
|
//cf.lMagnitude = 0;
|
|
//memset(&dieffect, 0, sizeof(dieffect));
|
|
dieffect.dwSize = sizeof(dieffect);
|
|
//dieffect.lpEnvelope = 0;
|
|
dieffect.dwStartDelay = 0;
|
|
dieffect.lpvTypeSpecificParams = &periodic;
|
|
int magnitude = abs((int)((force*10000*(__int64)diEffects[index].scale)/BASE_SENSITIVITY/255));
|
|
if (magnitude > 10000) magnitude = 10000;
|
|
int type = ffEffectTypes[binding->effectIndex].type;
|
|
if (type == EFFECT_CONSTANT) {
|
|
dieffect.cbTypeSpecificParams = sizeof(DICONSTANTFORCE);
|
|
constant.lMagnitude = magnitude;
|
|
}
|
|
else if (type == EFFECT_PERIODIC) {
|
|
dieffect.cbTypeSpecificParams = sizeof(DIPERIODIC);
|
|
periodic.dwMagnitude = 0;
|
|
periodic.lOffset = magnitude;
|
|
periodic.dwPhase = 0;
|
|
periodic.dwPeriod = 2000000;
|
|
}
|
|
else if (type == EFFECT_RAMP) {
|
|
dieffect.cbTypeSpecificParams = sizeof(DIRAMPFORCE);
|
|
ramp.lEnd = ramp.lStart = magnitude;
|
|
}
|
|
dieffect.dwFlags = DIEFF_CARTESIAN | DIEFF_OBJECTIDS;
|
|
dieffect.dwDuration = 2000000;
|
|
die->SetParameters(&dieffect, DIEP_TYPESPECIFICPARAMS | DIEP_START);
|
|
}
|
|
}
|
|
|
|
int Activate(void *d) {
|
|
int i, j;
|
|
if (active) Deactivate();
|
|
InitInfo *info = (InitInfo*)d;
|
|
// Note: Have to use hWndTop to properly hide cursor for mouse device.
|
|
if (type == OTHER) {
|
|
did->SetCooperativeLevel(info->hWndTop, DISCL_BACKGROUND | DISCL_EXCLUSIVE);
|
|
}
|
|
else if (type == KEYBOARD) {
|
|
did->SetCooperativeLevel(info->hWndTop, DISCL_FOREGROUND);
|
|
}
|
|
else {
|
|
did->SetCooperativeLevel(info->hWndTop, DISCL_FOREGROUND | DISCL_EXCLUSIVE);
|
|
}
|
|
if (did->Acquire() != DI_OK) {
|
|
return 0;
|
|
}
|
|
AllocState();
|
|
diEffects = (DI8Effect*) calloc(pads[0].numFFBindings + pads[1].numFFBindings, sizeof(DI8Effect));
|
|
for (i=0; i<pads[0].numFFBindings + pads[1].numFFBindings; i++) {
|
|
ForceFeedbackBinding *b = 0;
|
|
if (i >= pads[0].numFFBindings) {
|
|
b = &pads[1].ffBindings[i-pads[0].numFFBindings];
|
|
}
|
|
else
|
|
b = &pads[0].ffBindings[i];
|
|
ForceFeedbackEffectType *eff = ffEffectTypes + b->effectIndex;
|
|
GUID guid;
|
|
if (!StringToGUID(&guid, eff->effectID)) continue;
|
|
|
|
DIEFFECT dieffect;
|
|
memset(&dieffect, 0, sizeof(dieffect));
|
|
dieffect.dwSize = sizeof(dieffect);
|
|
dieffect.dwFlags = DIEFF_CARTESIAN | DIEFF_OBJECTIDS;
|
|
dieffect.dwDuration = 2000000;
|
|
dieffect.dwGain = 10000;
|
|
dieffect.dwTriggerButton = DIEB_NOTRIGGER;
|
|
union {
|
|
DIPERIODIC pediodic;
|
|
DIRAMPFORCE ramp;
|
|
DICONSTANTFORCE constant;
|
|
} stuff = {0,0,0,0};
|
|
|
|
if (eff->type == EFFECT_CONSTANT) {
|
|
dieffect.cbTypeSpecificParams = sizeof(DICONSTANTFORCE);
|
|
}
|
|
else if (eff->type == EFFECT_PERIODIC) {
|
|
dieffect.cbTypeSpecificParams = sizeof(DIPERIODIC);
|
|
}
|
|
else if (eff->type == EFFECT_RAMP) {
|
|
dieffect.cbTypeSpecificParams = sizeof(DIRAMPFORCE);
|
|
}
|
|
dieffect.lpvTypeSpecificParams = &stuff;
|
|
|
|
int maxForce = 0;
|
|
int numAxes = 0;
|
|
int *axes = (int*) malloc(sizeof(int) * 3 * numFFAxes);
|
|
DWORD *axisIDs = (DWORD*)(axes + numFFAxes);
|
|
LONG *dirList = (LONG*)(axisIDs + numFFAxes);
|
|
dieffect.rgdwAxes = axisIDs;
|
|
dieffect.rglDirection = dirList;
|
|
for (j=0; j<numFFAxes; j++) {
|
|
if (b->axes[j].force) {
|
|
int force = abs(b->axes[j].force);
|
|
if (force > maxForce) {
|
|
maxForce = force;
|
|
}
|
|
axes[numAxes] = j;
|
|
axisIDs[numAxes] = ffAxes[j].id;
|
|
dirList[numAxes] = b->axes[j].force;
|
|
numAxes++;
|
|
}
|
|
}
|
|
if (!numAxes) {
|
|
free(axes);
|
|
continue;
|
|
}
|
|
dieffect.cAxes = numAxes;
|
|
diEffects[i].scale = maxForce;
|
|
if (!SUCCEEDED(did->CreateEffect(guid, &dieffect, &diEffects[i].die, 0))) {
|
|
diEffects[i].die = 0;
|
|
diEffects[i].scale = 0;
|
|
}
|
|
|
|
free(axes);
|
|
axes = 0;
|
|
}
|
|
active = 1;
|
|
return 1;
|
|
}
|
|
|
|
int Update() {
|
|
if (!active) return 0;
|
|
if (numPhysicalControls) {
|
|
HRESULT res = did->Poll();
|
|
// ??
|
|
if ((res != DI_OK && res != DI_NOEFFECT) ||
|
|
DI_OK != did->GetDeviceState(4*numPhysicalControls, physicalControlState)) {
|
|
Deactivate();
|
|
return 0;
|
|
}
|
|
for (int i=0; i<numPhysicalControls; i++) {
|
|
if (physicalControls[i].type & RELAXIS) {
|
|
physicalControlState[i] *= (FULLY_DOWN/3);
|
|
}
|
|
else if (physicalControls[i].type & BUTTON) {
|
|
physicalControlState[i] = (physicalControlState[i]&0x80) * FULLY_DOWN / 128;
|
|
}
|
|
}
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
void Deactivate() {
|
|
FreeState();
|
|
if (diEffects) {
|
|
for (int i=0; i<pads[0].numFFBindings + pads[1].numFFBindings; i++) {
|
|
if (diEffects[i].die) {
|
|
diEffects[i].die->Stop();
|
|
diEffects[i].die->Release();
|
|
diEffects[i].die = 0;
|
|
}
|
|
}
|
|
free(diEffects);
|
|
diEffects = 0;
|
|
}
|
|
if (active) {
|
|
did->Unacquire();
|
|
active = 0;
|
|
}
|
|
}
|
|
|
|
~DirectInputDevice() {
|
|
did->Release();
|
|
}
|
|
};
|
|
|
|
BOOL CALLBACK EnumEffectsCallback(LPCDIEFFECTINFOW pdei, LPVOID pvRef) {
|
|
DirectInputDevice * did = (DirectInputDevice*) pvRef;
|
|
EffectType type;
|
|
int diType = DIEFT_GETTYPE(pdei->dwEffType);
|
|
if (diType == DIEFT_CONSTANTFORCE) {
|
|
type = EFFECT_CONSTANT;
|
|
}
|
|
else if (diType == DIEFT_RAMPFORCE) {
|
|
type = EFFECT_RAMP;
|
|
}
|
|
else if (diType == DIEFT_PERIODIC) {
|
|
type = EFFECT_PERIODIC;
|
|
}
|
|
else {
|
|
return DIENUM_CONTINUE;
|
|
}
|
|
wchar_t guidString[50];
|
|
GUIDtoString(guidString, &pdei->guid);
|
|
did->AddFFEffectType(pdei->tszName, guidString, type);
|
|
|
|
return DIENUM_CONTINUE;
|
|
}
|
|
|
|
BOOL CALLBACK EnumDeviceObjectsCallback (LPCDIDEVICEOBJECTINSTANCE lpddoi, LPVOID pvRef) {
|
|
DirectInputDevice * did = (DirectInputDevice*) pvRef;
|
|
if (lpddoi->dwType & DIDFT_FFACTUATOR) {
|
|
did->AddFFAxis(lpddoi->tszName, lpddoi->dwType);
|
|
/*
|
|
void * t = realloc(DI->actuators, sizeof(DIActuator) * (DI->numActuators+1));
|
|
if (t) {
|
|
DI->actuators = (DIActuator*) t;
|
|
int i = DI->numActuators;
|
|
while (i > 0 && (lpddoi->dwType & 0xFFFF00) < (DI->actuators[i-1].id & 0xFFFF00)) {
|
|
DI->actuators[i] = DI->actuators[i-1];
|
|
i--;
|
|
}
|
|
DI->actuators[i].maxForce = lpddoi->dwFFMaxForce;
|
|
DI->actuators[i].id = lpddoi->dwType;
|
|
DI->numActuators++;
|
|
}
|
|
//*/
|
|
}
|
|
|
|
ControlType type;
|
|
|
|
if (lpddoi->dwType & DIDFT_POV)
|
|
type = POV;
|
|
else if (lpddoi->dwType & DIDFT_ABSAXIS)
|
|
type = ABSAXIS;
|
|
else if (lpddoi->dwType & DIDFT_RELAXIS)
|
|
type = RELAXIS;
|
|
else if (lpddoi->dwType & DIDFT_PSHBUTTON)
|
|
type = PSHBTN;
|
|
else if (lpddoi->dwType & DIDFT_TGLBUTTON)
|
|
type = TGLBTN;
|
|
else
|
|
return DIENUM_CONTINUE;
|
|
// If too many objects, ignore extra buttons.
|
|
if ((did->numPhysicalControls > 255 && DIDFT_GETINSTANCE(lpddoi->dwType) > 255) && (type & (DIDFT_PSHBUTTON | DIDFT_TGLBUTTON))) {
|
|
int i;
|
|
for (i = did->numPhysicalControls-1; i>did->numPhysicalControls-4; i--) {
|
|
if (!lpddoi->tszName[0]) break;
|
|
const wchar_t *s1 = lpddoi->tszName;
|
|
const wchar_t *s2 = did->physicalControls[i].name;
|
|
while (*s1 && *s1 == *s2) {
|
|
s1++;
|
|
s2++;
|
|
}
|
|
// If perfect match with one of last 4 names, break.
|
|
if (!*s1 && !*s2) break;
|
|
|
|
while (s1 != lpddoi->tszName && (s1[-1] >= '0' && s1[-1] <= '9')) s1--;
|
|
int check = 0;
|
|
while (*s1 >= '0' && *s1 <= '9') {
|
|
check = check*10 + *s1 - '0';
|
|
s1++;
|
|
}
|
|
while (*s2 >= '0' && *s2 <= '9') {
|
|
s2++;
|
|
}
|
|
// If perfect match other than final number > 30, then break.
|
|
// takes care of "button xx" case without causing issues with F keys.
|
|
if (!*s1 && !*s2 && check > 30) break;
|
|
}
|
|
if (i != did->numPhysicalControls-4) {
|
|
return DIENUM_CONTINUE;
|
|
}
|
|
}
|
|
|
|
int vkey = 0;
|
|
if (lpddoi->tszName[0] && did->type == KEYBOARD) {
|
|
for (u32 i = 0; i<256; i++) {
|
|
wchar_t *t = GetVKStringW((u8)i);
|
|
if (!wcsicmp(lpddoi->tszName, t)) {
|
|
vkey = i;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
did->AddPhysicalControl(type, DIDFT_GETINSTANCE(lpddoi->dwType), vkey, lpddoi->tszName);
|
|
return DIENUM_CONTINUE;
|
|
}
|
|
|
|
struct CreationInfo {
|
|
LPDIRECTINPUT8 lpDI8;
|
|
int count;
|
|
};
|
|
|
|
|
|
BOOL CALLBACK EnumCallback (LPCDIDEVICEINSTANCE lpddi, LPVOID pvRef) {
|
|
CreationInfo *ci = (CreationInfo*) pvRef;
|
|
int *count = (int*) pvRef;
|
|
const wchar_t *name;
|
|
wchar_t temp[40];
|
|
if (lpddi->tszInstanceName[0]) {
|
|
name = lpddi->tszInstanceName;
|
|
}
|
|
else if (lpddi->tszProductName[0]) {
|
|
name = lpddi->tszProductName;
|
|
}
|
|
else {
|
|
wsprintfW (temp, L"Device %i", ci->count);
|
|
name = temp;
|
|
}
|
|
ci->count++;
|
|
wchar_t *fullName = (wchar_t *) malloc((wcslen(name) + 4) * sizeof(wchar_t));
|
|
wsprintf(fullName, L"DX %s", name);
|
|
wchar_t instanceID[100];
|
|
wchar_t productID[100];
|
|
GUIDtoString(instanceID, &lpddi->guidInstance);
|
|
GUIDtoString(productID, &lpddi->guidProduct);
|
|
DeviceType type = OTHER;
|
|
if ((lpddi->dwDevType & 0xFF) == DI8DEVTYPE_KEYBOARD) {
|
|
type = KEYBOARD;
|
|
}
|
|
else if ((lpddi->dwDevType & 0xFF) == DI8DEVTYPE_MOUSE) {
|
|
type = MOUSE;
|
|
}
|
|
IDirectInputDevice8 *did;
|
|
if (DI_OK == ci->lpDI8->CreateDevice(lpddi->guidInstance, &did, 0)) {
|
|
dm->AddDevice(new DirectInputDevice(type, did, fullName, instanceID, productID));
|
|
}
|
|
free(fullName);
|
|
return DIENUM_CONTINUE;
|
|
}
|
|
|
|
void EnumDirectInputDevices() {
|
|
CreationInfo ci = {0,0};
|
|
if (FAILED(DirectInput8Create(hInst, 0x800, IID_IDirectInput8, (void**) &ci.lpDI8, 0))) return;
|
|
ci.lpDI8->EnumDevices(DI8DEVCLASS_ALL, EnumCallback, &ci, DIEDFL_ATTACHEDONLY);
|
|
ci.lpDI8->Release();
|
|
}
|
|
|