mirror of
https://github.com/hrydgard/ppsspp.git
synced 2024-10-08 03:13:25 +00:00
d30d75ab38
A user reported stuttering after the periodic checks, and devices failing until unplug/replug. Presumably, this is caused by poor drivers reacting badly to periodic DirectInput queries, so less queries should help.
376 lines
10 KiB
C++
376 lines
10 KiB
C++
// Copyright (c) 2012- PPSSPP Project.
|
|
|
|
// This program is free software: you can redistribute it and/or modify
|
|
// it under the terms of the GNU General Public License as published by
|
|
// the Free Software Foundation, version 2.0 or later versions.
|
|
|
|
// This program 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 General Public License 2.0 for more details.
|
|
|
|
// A copy of the GPL 2.0 should have been included with the program.
|
|
// If not, see http://www.gnu.org/licenses/
|
|
|
|
// Official git repository and contact information can be found at
|
|
// https://github.com/hrydgard/ppsspp and http://www.ppsspp.org/.
|
|
|
|
#include "stdafx.h"
|
|
#include <limits.h>
|
|
#include <algorithm>
|
|
#include <mmsystem.h>
|
|
|
|
#include "Core/HLE/sceCtrl.h"
|
|
#include "DinputDevice.h"
|
|
#include "Core/Config.h"
|
|
#include "input/input_state.h"
|
|
#include "base/NativeApp.h"
|
|
#include "input/keycodes.h"
|
|
#include "Core/Reporting.h"
|
|
#include "Xinput.h"
|
|
#pragma comment(lib,"dinput8.lib")
|
|
|
|
#ifdef min
|
|
#undef min
|
|
#undef max
|
|
#endif
|
|
|
|
//initialize static members of DinputDevice
|
|
unsigned int DinputDevice::pInstances = 0;
|
|
LPDIRECTINPUT8 DinputDevice::pDI = NULL;
|
|
std::vector<DIDEVICEINSTANCE> DinputDevice::devices;
|
|
bool DinputDevice::needsCheck_ = true;
|
|
|
|
// In order from 0. There can be 128, but most controllers do not have that many.
|
|
static const int dinput_buttons[] = {
|
|
NKCODE_BUTTON_1,
|
|
NKCODE_BUTTON_2,
|
|
NKCODE_BUTTON_3,
|
|
NKCODE_BUTTON_4,
|
|
NKCODE_BUTTON_5,
|
|
NKCODE_BUTTON_6,
|
|
NKCODE_BUTTON_7,
|
|
NKCODE_BUTTON_8,
|
|
NKCODE_BUTTON_9,
|
|
NKCODE_BUTTON_10,
|
|
NKCODE_BUTTON_11,
|
|
NKCODE_BUTTON_12,
|
|
NKCODE_BUTTON_13,
|
|
NKCODE_BUTTON_14,
|
|
NKCODE_BUTTON_15,
|
|
NKCODE_BUTTON_16,
|
|
};
|
|
|
|
static float NormalizedDeadzoneFilter(short value);
|
|
|
|
#define DIFF (JOY_POVRIGHT - JOY_POVFORWARD) / 2
|
|
#define JOY_POVFORWARD_RIGHT JOY_POVFORWARD + DIFF
|
|
#define JOY_POVRIGHT_BACKWARD JOY_POVRIGHT + DIFF
|
|
#define JOY_POVBACKWARD_LEFT JOY_POVBACKWARD + DIFF
|
|
#define JOY_POVLEFT_FORWARD JOY_POVLEFT + DIFF
|
|
|
|
struct XINPUT_DEVICE_NODE {
|
|
DWORD dwVidPid;
|
|
XINPUT_DEVICE_NODE* pNext;
|
|
};
|
|
XINPUT_DEVICE_NODE* g_pXInputDeviceList = NULL;
|
|
|
|
bool IsXInputDevice( const GUID* pGuidProductFromDirectInput ) {
|
|
XINPUT_DEVICE_NODE* pNode = g_pXInputDeviceList;
|
|
while( pNode )
|
|
{
|
|
if( pNode->dwVidPid == pGuidProductFromDirectInput->Data1 )
|
|
return true;
|
|
pNode = pNode->pNext;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
LPDIRECTINPUT8 DinputDevice::getPDI()
|
|
{
|
|
if (pDI == NULL)
|
|
{
|
|
if (FAILED(DirectInput8Create(GetModuleHandle(NULL), DIRECTINPUT_VERSION, IID_IDirectInput8, (void**)&pDI, NULL)))
|
|
{
|
|
pDI = NULL;
|
|
}
|
|
}
|
|
return pDI;
|
|
}
|
|
|
|
BOOL CALLBACK DinputDevice::DevicesCallback(
|
|
LPCDIDEVICEINSTANCE lpddi,
|
|
LPVOID pvRef
|
|
)
|
|
{
|
|
//check if a device with the same Instance guid is already saved
|
|
auto res = std::find_if(devices.begin(), devices.end(),
|
|
[lpddi](const DIDEVICEINSTANCE &to_consider){
|
|
return lpddi->guidInstance == to_consider.guidInstance;
|
|
});
|
|
if (res == devices.end()) //not yet in the devices list
|
|
{
|
|
// Ignore if device supports XInput
|
|
if (!IsXInputDevice(&lpddi->guidProduct)) {
|
|
devices.push_back(*lpddi);
|
|
}
|
|
}
|
|
return DIENUM_CONTINUE;
|
|
}
|
|
|
|
void DinputDevice::getDevices(bool refresh)
|
|
{
|
|
if (refresh)
|
|
{
|
|
getPDI()->EnumDevices(DI8DEVCLASS_GAMECTRL, &DinputDevice::DevicesCallback, NULL, DIEDFL_ATTACHEDONLY);
|
|
}
|
|
}
|
|
|
|
DinputDevice::DinputDevice(int devnum) {
|
|
pInstances++;
|
|
pDevNum = devnum;
|
|
pJoystick = NULL;
|
|
memset(lastButtons_, 0, sizeof(lastButtons_));
|
|
memset(lastPOV_, 0, sizeof(lastPOV_));
|
|
last_lX_ = 0;
|
|
last_lY_ = 0;
|
|
last_lZ_ = 0;
|
|
last_lRx_ = 0;
|
|
last_lRy_ = 0;
|
|
last_lRz_ = 0;
|
|
|
|
if (getPDI() == NULL)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (devnum >= MAX_NUM_PADS)
|
|
{
|
|
return;
|
|
}
|
|
|
|
getDevices(false);
|
|
if ( (devnum >= (int)devices.size()) || FAILED(getPDI()->CreateDevice(devices.at(devnum).guidInstance, &pJoystick, NULL)))
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (FAILED(pJoystick->SetDataFormat(&c_dfDIJoystick2))) {
|
|
pJoystick->Release();
|
|
pJoystick = NULL;
|
|
return;
|
|
}
|
|
|
|
DIPROPRANGE diprg;
|
|
diprg.diph.dwSize = sizeof(DIPROPRANGE);
|
|
diprg.diph.dwHeaderSize = sizeof(DIPROPHEADER);
|
|
diprg.diph.dwHow = DIPH_DEVICE;
|
|
diprg.diph.dwObj = 0;
|
|
diprg.lMin = -10000;
|
|
diprg.lMax = 10000;
|
|
|
|
analog = FAILED(pJoystick->SetProperty(DIPROP_RANGE, &diprg.diph)) ? false : true;
|
|
|
|
// Other devices suffer if the deadzone is not set.
|
|
// TODO: The dead zone will be made configurable in the Control dialog.
|
|
DIPROPDWORD dipw;
|
|
dipw.diph.dwSize = sizeof(DIPROPDWORD);
|
|
dipw.diph.dwHeaderSize = sizeof(DIPROPHEADER);
|
|
dipw.diph.dwHow = DIPH_DEVICE;
|
|
dipw.diph.dwObj = 0;
|
|
// dwData 10000 is deadzone(0% - 100%), multiply by config scalar
|
|
dipw.dwData = (int)(g_Config.fDInputAnalogDeadzone * 10000);
|
|
|
|
analog |= FAILED(pJoystick->SetProperty(DIPROP_DEADZONE, &dipw.diph)) ? false : true;
|
|
}
|
|
|
|
DinputDevice::~DinputDevice() {
|
|
if (pJoystick) {
|
|
pJoystick->Release();
|
|
pJoystick = NULL;
|
|
}
|
|
|
|
pInstances--;
|
|
|
|
//the whole instance counter is obviously highly thread-unsafe
|
|
//but I don't think creation and destruction operations will be
|
|
//happening at the same time and other values like pDI are
|
|
//unsafe as well anyway
|
|
if (pInstances == 0 && pDI) {
|
|
pDI->Release();
|
|
pDI = NULL;
|
|
}
|
|
}
|
|
|
|
void SendNativeAxis(int deviceId, short value, short &lastValue, int axisId) {
|
|
if (value == lastValue)
|
|
return;
|
|
|
|
AxisInput axis;
|
|
axis.deviceId = deviceId;
|
|
axis.axisId = axisId;
|
|
axis.value = (float)value / 10000.0f; // Convert axis to normalised float
|
|
NativeAxis(axis);
|
|
|
|
lastValue = value;
|
|
}
|
|
|
|
inline float Signs(short val) {
|
|
return (0 < val) - (val < 0);
|
|
}
|
|
|
|
inline float LinearMaps(short val, short a0, short a1, short b0, short b1) {
|
|
return b0 + (((val - a0) * (b1 - b0)) / (a1 - a0));
|
|
}
|
|
|
|
int DinputDevice::UpdateState() {
|
|
if (!pJoystick) return -1;
|
|
|
|
DIJOYSTATE2 js;
|
|
|
|
if (FAILED(pJoystick->Poll())) {
|
|
if(pJoystick->Acquire() == DIERR_INPUTLOST)
|
|
return -1;
|
|
}
|
|
|
|
if(FAILED(pJoystick->GetDeviceState(sizeof(DIJOYSTATE2), &js)))
|
|
return -1;
|
|
|
|
ApplyButtons(js);
|
|
|
|
if (analog) {
|
|
AxisInput axis;
|
|
axis.deviceId = DEVICE_ID_PAD_0 + pDevNum;
|
|
|
|
// Circle to Square mapping, cribbed from XInputDevice
|
|
float sx = js.lX;
|
|
float sy = js.lY;
|
|
float scaleFactor = sqrtf((sx * sx + sy * sy) / std::max(sx * sx, sy * sy));
|
|
js.lX = (short)(sx * scaleFactor);
|
|
js.lY = (short)(sy * scaleFactor);
|
|
|
|
// Linear range mapping (used to invert deadzones)
|
|
float dz = g_Config.fDInputAnalogDeadzone;
|
|
int idzm = g_Config.iDInputAnalogInverseMode;
|
|
float idz = g_Config.fDInputAnalogInverseDeadzone;
|
|
float md = std::max(dz, idz);
|
|
float st = g_Config.fDInputAnalogSensitivity;
|
|
|
|
float magnitude = sqrtf(js.lX * js.lX + js.lY * js.lY);
|
|
if (magnitude > dz * 10000.0f) {
|
|
if (idzm == 1)
|
|
{
|
|
short xSign = Signs(js.lX);
|
|
if (xSign != 0.0f) {
|
|
js.lX = LinearMaps(js.lX, xSign * (short)(dz * 10000), xSign * 10000, xSign * (short)(md * 10000), xSign * 10000 * st);
|
|
}
|
|
}
|
|
else if (idzm == 2)
|
|
{
|
|
short ySign = Signs(js.lY);
|
|
if (ySign != 0.0f) {
|
|
js.lY = LinearMaps(js.lY, ySign * (short)(dz * 10000.0f), ySign * 10000, ySign * (short)(md * 10000.0f), ySign * 10000 * st);
|
|
}
|
|
}
|
|
else if (idzm == 3)
|
|
{
|
|
float xNorm = (float)js.lX / magnitude;
|
|
float yNorm = (float)js.lY / magnitude;
|
|
float mapMag = LinearMaps(magnitude, dz * 10000.0f, 10000.0f, md * 10000.0f, 10000.0f * st);
|
|
js.lX = (short)(xNorm * mapMag);
|
|
js.lY = (short)(yNorm * mapMag);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
js.lX = 0;
|
|
js.lY = 0;
|
|
}
|
|
|
|
js.lX = (short)std::min(10000.0f, std::max((float)js.lX, -10000.0f));
|
|
js.lY = (short)std::min(10000.0f, std::max((float)js.lY, -10000.0f));
|
|
|
|
SendNativeAxis(DEVICE_ID_PAD_0 + pDevNum, js.lX, last_lX_, JOYSTICK_AXIS_X);
|
|
SendNativeAxis(DEVICE_ID_PAD_0 + pDevNum, js.lY, last_lY_, JOYSTICK_AXIS_Y);
|
|
SendNativeAxis(DEVICE_ID_PAD_0 + pDevNum, js.lZ, last_lZ_, JOYSTICK_AXIS_Z);
|
|
SendNativeAxis(DEVICE_ID_PAD_0 + pDevNum, js.lRx, last_lRx_, JOYSTICK_AXIS_RX);
|
|
SendNativeAxis(DEVICE_ID_PAD_0 + pDevNum, js.lRy, last_lRy_, JOYSTICK_AXIS_RY);
|
|
SendNativeAxis(DEVICE_ID_PAD_0 + pDevNum, js.lRz, last_lRz_, JOYSTICK_AXIS_RZ);
|
|
}
|
|
|
|
//check if the values have changed from last time and skip polling the rest of the dinput devices if they did
|
|
//this doesn't seem to quite work if only the axis have changed
|
|
if ((memcmp(js.rgbButtons, pPrevState.rgbButtons, sizeof(BYTE) * 128) != 0)
|
|
|| (memcmp(js.rgdwPOV, pPrevState.rgdwPOV, sizeof(DWORD) * 4) != 0)
|
|
|| js.lVX != 0 || js.lVY != 0 || js.lVZ != 0 || js.lVRx != 0 || js.lVRy != 0 || js.lVRz != 0)
|
|
{
|
|
pPrevState = js;
|
|
return UPDATESTATE_SKIP_PAD;
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
void DinputDevice::ApplyButtons(DIJOYSTATE2 &state) {
|
|
BYTE *buttons = state.rgbButtons;
|
|
u32 downMask = 0x80;
|
|
|
|
for (int i = 0; i < ARRAY_SIZE(dinput_buttons); ++i) {
|
|
if (state.rgbButtons[i] == lastButtons_[i]) {
|
|
continue;
|
|
}
|
|
|
|
bool down = (state.rgbButtons[i] & downMask) == downMask;
|
|
KeyInput key;
|
|
key.deviceId = DEVICE_ID_PAD_0 + pDevNum;
|
|
key.flags = down ? KEY_DOWN : KEY_UP;
|
|
key.keyCode = dinput_buttons[i];
|
|
NativeKey(key);
|
|
|
|
lastButtons_[i] = state.rgbButtons[i];
|
|
}
|
|
|
|
// Now the POV hat, which can technically go in any degree but usually does not.
|
|
if (LOWORD(state.rgdwPOV[0]) != lastPOV_[0]) {
|
|
KeyInput dpad[4];
|
|
for (int i = 0; i < 4; ++i) {
|
|
dpad[i].deviceId = DEVICE_ID_PAD_0 + pDevNum;
|
|
dpad[i].flags = KEY_UP;
|
|
}
|
|
dpad[0].keyCode = NKCODE_DPAD_UP;
|
|
dpad[1].keyCode = NKCODE_DPAD_LEFT;
|
|
dpad[2].keyCode = NKCODE_DPAD_DOWN;
|
|
dpad[3].keyCode = NKCODE_DPAD_RIGHT;
|
|
|
|
if (LOWORD(state.rgdwPOV[0]) != JOY_POVCENTERED) {
|
|
// These are the edges, so we use or.
|
|
if (state.rgdwPOV[0] >= JOY_POVLEFT_FORWARD || state.rgdwPOV[0] <= JOY_POVFORWARD_RIGHT) {
|
|
dpad[0].flags = KEY_DOWN;
|
|
}
|
|
if (state.rgdwPOV[0] >= JOY_POVBACKWARD_LEFT && state.rgdwPOV[0] <= JOY_POVLEFT_FORWARD) {
|
|
dpad[1].flags = KEY_DOWN;
|
|
}
|
|
if (state.rgdwPOV[0] >= JOY_POVRIGHT_BACKWARD && state.rgdwPOV[0] <= JOY_POVBACKWARD_LEFT) {
|
|
dpad[2].flags = KEY_DOWN;
|
|
}
|
|
if (state.rgdwPOV[0] >= JOY_POVFORWARD_RIGHT && state.rgdwPOV[0] <= JOY_POVRIGHT_BACKWARD) {
|
|
dpad[3].flags = KEY_DOWN;
|
|
}
|
|
}
|
|
|
|
NativeKey(dpad[0]);
|
|
NativeKey(dpad[1]);
|
|
NativeKey(dpad[2]);
|
|
NativeKey(dpad[3]);
|
|
|
|
lastPOV_[0] = LOWORD(state.rgdwPOV[0]);
|
|
}
|
|
}
|
|
|
|
size_t DinputDevice::getNumPads()
|
|
{
|
|
getDevices(needsCheck_);
|
|
needsCheck_ = false;
|
|
return devices.size();
|
|
}
|