piwalker/dolphin
1
0
Fork 0
mirror of https://github.com/dolphin-emu/dolphin.git synced 2025-07-21 05:09:34 -06:00
Code Issues Packages Projects Releases Wiki Activity

Reformat all the things. Have fun with merge conflicts.

Browse Source
This commit is contained in:
Pierre Bourdon
2016-06-24 10:43:46 +02:00
parent 2115e8a4a6
commit 3570c7f03a
1116 changed files with 187405 additions and 180344 deletions
Download Patch File Download Diff File Expand all files Collapse all files

51
Source/Core/InputCommon/ControllerInterface/DInput/DInput.cpp
View File

@ -16,50 +16,47 @@ namespace ciface
{
namespace DInput
{
BOOL CALLBACK DIEnumDeviceObjectsCallback(LPCDIDEVICEOBJECTINSTANCE lpddoi, LPVOID pvRef)
{
((std::list<DIDEVICEOBJECTINSTANCE>*)pvRef)->push_back(*lpddoi);
return DIENUM_CONTINUE;
((std::list<DIDEVICEOBJECTINSTANCE>*)pvRef)->push_back(*lpddoi);
return DIENUM_CONTINUE;
}
BOOL CALLBACK DIEnumDevicesCallback(LPCDIDEVICEINSTANCE lpddi, LPVOID pvRef)
{
((std::list<DIDEVICEINSTANCE>*)pvRef)->push_back(*lpddi);
return DIENUM_CONTINUE;
((std::list<DIDEVICEINSTANCE>*)pvRef)->push_back(*lpddi);
return DIENUM_CONTINUE;
}
std::string GetDeviceName(const LPDIRECTINPUTDEVICE8 device)
{
DIPROPSTRING str = {};
str.diph.dwSize = sizeof(str);
str.diph.dwHeaderSize = sizeof(str.diph);
str.diph.dwHow = DIPH_DEVICE;
DIPROPSTRING str = {};
str.diph.dwSize = sizeof(str);
str.diph.dwHeaderSize = sizeof(str.diph);
str.diph.dwHow = DIPH_DEVICE;
std::string result;
if (SUCCEEDED(device->GetProperty(DIPROP_PRODUCTNAME, &str.diph)))
{
result = StripSpaces(UTF16ToUTF8(str.wsz));
}
std::string result;
if (SUCCEEDED(device->GetProperty(DIPROP_PRODUCTNAME, &str.diph)))
{
result = StripSpaces(UTF16ToUTF8(str.wsz));
}
return result;
return result;
}
void Init(std::vector<Core::Device*>& devices, HWND hwnd)
{
IDirectInput8* idi8;
if (FAILED(DirectInput8Create(GetModuleHandle(nullptr), DIRECTINPUT_VERSION,
IID_IDirectInput8, (LPVOID*)&idi8, nullptr)))
{
return;
}
IDirectInput8* idi8;
if (FAILED(DirectInput8Create(GetModuleHandle(nullptr), DIRECTINPUT_VERSION, IID_IDirectInput8,
(LPVOID*)&idi8, nullptr)))
{
return;
}
InitKeyboardMouse(idi8, devices, hwnd);
InitJoystick(idi8, devices, hwnd);
idi8->Release();
}
InitKeyboardMouse(idi8, devices, hwnd);
InitJoystick(idi8, devices, hwnd);
idi8->Release();
}
}
}

6
Source/Core/InputCommon/ControllerInterface/DInput/DInput.h
View File

@ -9,20 +9,18 @@
#include <list>
#include <windows.h>
#include "InputCommon/ControllerInterface/Device.h"
#include "InputCommon/ControllerInterface/DInput/DInput8.h"
#include "InputCommon/ControllerInterface/Device.h"
namespace ciface
{
namespace DInput
{
//BOOL CALLBACK DIEnumEffectsCallback(LPCDIEFFECTINFO pdei, LPVOID pvRef);
// BOOL CALLBACK DIEnumEffectsCallback(LPCDIEFFECTINFO pdei, LPVOID pvRef);
BOOL CALLBACK DIEnumDeviceObjectsCallback(LPCDIDEVICEOBJECTINSTANCE lpddoi, LPVOID pvRef);
BOOL CALLBACK DIEnumDevicesCallback(LPCDIDEVICEINSTANCE lpddi, LPVOID pvRef);
std::string GetDeviceName(const LPDIRECTINPUTDEVICE8 device);
void Init(std::vector<Core::Device*>& devices, HWND hwnd);
}
}

370
Source/Core/InputCommon/ControllerInterface/DInput/DInputJoystick.cpp
View File

@ -14,268 +14,270 @@ namespace ciface
{
namespace DInput
{
#define DATA_BUFFER_SIZE 32
void InitJoystick(IDirectInput8* const idi8, std::vector<Core::Device*>& devices, HWND hwnd)
{
std::list<DIDEVICEINSTANCE> joysticks;
idi8->EnumDevices(DI8DEVCLASS_GAMECTRL, DIEnumDevicesCallback, (LPVOID)&joysticks, DIEDFL_ATTACHEDONLY);
std::list<DIDEVICEINSTANCE> joysticks;
idi8->EnumDevices(DI8DEVCLASS_GAMECTRL, DIEnumDevicesCallback, (LPVOID)&joysticks,
DIEDFL_ATTACHEDONLY);
// this is used to number the joysticks
// multiple joysticks with the same name shall get unique ids starting at 0
std::map< std::basic_string<TCHAR>, int> name_counts;
// this is used to number the joysticks
// multiple joysticks with the same name shall get unique ids starting at 0
std::map<std::basic_string<TCHAR>, int> name_counts;
std::vector<DWORD> xinput_guids;
GetXInputGUIDS(&xinput_guids);
std::vector<DWORD> xinput_guids;
GetXInputGUIDS(&xinput_guids);
for (DIDEVICEINSTANCE& joystick : joysticks)
{
// skip XInput Devices
if (std::find(xinput_guids.begin(), xinput_guids.end(), joystick.guidProduct.Data1) != xinput_guids.end())
{
continue;
}
for (DIDEVICEINSTANCE& joystick : joysticks)
{
// skip XInput Devices
if (std::find(xinput_guids.begin(), xinput_guids.end(), joystick.guidProduct.Data1) !=
xinput_guids.end())
{
continue;
}
LPDIRECTINPUTDEVICE8 js_device;
if (SUCCEEDED(idi8->CreateDevice(joystick.guidInstance, &js_device, nullptr)))
{
if (SUCCEEDED(js_device->SetDataFormat(&c_dfDIJoystick)))
{
if (FAILED(js_device->SetCooperativeLevel(GetAncestor(hwnd, GA_ROOT), DISCL_BACKGROUND | DISCL_EXCLUSIVE)))
{
//PanicAlert("SetCooperativeLevel(DISCL_EXCLUSIVE) failed!");
// fall back to non-exclusive mode, with no rumble
if (FAILED(js_device->SetCooperativeLevel(nullptr, DISCL_BACKGROUND | DISCL_NONEXCLUSIVE)))
{
//PanicAlert("SetCooperativeLevel failed!");
js_device->Release();
continue;
}
}
LPDIRECTINPUTDEVICE8 js_device;
if (SUCCEEDED(idi8->CreateDevice(joystick.guidInstance, &js_device, nullptr)))
{
if (SUCCEEDED(js_device->SetDataFormat(&c_dfDIJoystick)))
{
if (FAILED(js_device->SetCooperativeLevel(GetAncestor(hwnd, GA_ROOT),
DISCL_BACKGROUND | DISCL_EXCLUSIVE)))
{
// PanicAlert("SetCooperativeLevel(DISCL_EXCLUSIVE) failed!");
// fall back to non-exclusive mode, with no rumble
if (FAILED(
js_device->SetCooperativeLevel(nullptr, DISCL_BACKGROUND | DISCL_NONEXCLUSIVE)))
{
// PanicAlert("SetCooperativeLevel failed!");
js_device->Release();
continue;
}
}
Joystick* js = new Joystick(/*&*i, */js_device, name_counts[joystick.tszInstanceName]++);
// only add if it has some inputs/outputs
if (js->Inputs().size() || js->Outputs().size())
devices.push_back(js);
else
delete js;
}
else
{
//PanicAlert("SetDataFormat failed!");
js_device->Release();
}
}
}
Joystick* js = new Joystick(/*&*i, */ js_device, name_counts[joystick.tszInstanceName]++);
// only add if it has some inputs/outputs
if (js->Inputs().size() || js->Outputs().size())
devices.push_back(js);
else
delete js;
}
else
{
// PanicAlert("SetDataFormat failed!");
js_device->Release();
}
}
}
}
Joystick::Joystick( /*const LPCDIDEVICEINSTANCE lpddi, */const LPDIRECTINPUTDEVICE8 device, const unsigned int index )
: m_device(device)
, m_index(index)
//, m_name(TStringToString(lpddi->tszInstanceName))
Joystick::Joystick(/*const LPCDIDEVICEINSTANCE lpddi, */ const LPDIRECTINPUTDEVICE8 device,
const unsigned int index)
: m_device(device), m_index(index)
//, m_name(TStringToString(lpddi->tszInstanceName))
{
// seems this needs to be done before GetCapabilities
// polled or buffered data
DIPROPDWORD dipdw;
dipdw.diph.dwSize = sizeof(DIPROPDWORD);
dipdw.diph.dwHeaderSize = sizeof(DIPROPHEADER);
dipdw.diph.dwObj = 0;
dipdw.diph.dwHow = DIPH_DEVICE;
dipdw.dwData = DATA_BUFFER_SIZE;
// set the buffer size,
// if we can't set the property, we can't use buffered data
m_buffered = SUCCEEDED(m_device->SetProperty(DIPROP_BUFFERSIZE, &dipdw.diph));
// seems this needs to be done before GetCapabilities
// polled or buffered data
DIPROPDWORD dipdw;
dipdw.diph.dwSize = sizeof(DIPROPDWORD);
dipdw.diph.dwHeaderSize = sizeof(DIPROPHEADER);
dipdw.diph.dwObj = 0;
dipdw.diph.dwHow = DIPH_DEVICE;
dipdw.dwData = DATA_BUFFER_SIZE;
// set the buffer size,
// if we can't set the property, we can't use buffered data
m_buffered = SUCCEEDED(m_device->SetProperty(DIPROP_BUFFERSIZE, &dipdw.diph));
// seems this needs to be done after SetProperty of buffer size
m_device->Acquire();
// seems this needs to be done after SetProperty of buffer size
m_device->Acquire();
// get joystick caps
DIDEVCAPS js_caps;
js_caps.dwSize = sizeof(js_caps);
if (FAILED(m_device->GetCapabilities(&js_caps)))
return;
// get joystick caps
DIDEVCAPS js_caps;
js_caps.dwSize = sizeof(js_caps);
if (FAILED(m_device->GetCapabilities(&js_caps)))
return;
// max of 32 buttons and 4 hats / the limit of the data format I am using
js_caps.dwButtons = std::min((DWORD)32, js_caps.dwButtons);
js_caps.dwPOVs = std::min((DWORD)4, js_caps.dwPOVs);
// max of 32 buttons and 4 hats / the limit of the data format I am using
js_caps.dwButtons = std::min((DWORD)32, js_caps.dwButtons);
js_caps.dwPOVs = std::min((DWORD)4, js_caps.dwPOVs);
//m_must_poll = (js_caps.dwFlags & DIDC_POLLEDDATAFORMAT) != 0;
// m_must_poll = (js_caps.dwFlags & DIDC_POLLEDDATAFORMAT) != 0;
// buttons
for (u8 i = 0; i != js_caps.dwButtons; ++i)
AddInput(new Button(i, m_state_in.rgbButtons[i]));
// buttons
for (u8 i = 0; i != js_caps.dwButtons; ++i)
AddInput(new Button(i, m_state_in.rgbButtons[i]));
// hats
for (u8 i = 0; i != js_caps.dwPOVs; ++i)
{
// each hat gets 4 input instances associated with it, (up down left right)
for (u8 d = 0; d != 4; ++d)
AddInput(new Hat(i, m_state_in.rgdwPOV[i], d));
}
// hats
for (u8 i = 0; i != js_caps.dwPOVs; ++i)
{
// each hat gets 4 input instances associated with it, (up down left right)
for (u8 d = 0; d != 4; ++d)
AddInput(new Hat(i, m_state_in.rgdwPOV[i], d));
}
// get up to 6 axes and 2 sliders
DIPROPRANGE range;
range.diph.dwSize = sizeof(range);
range.diph.dwHeaderSize = sizeof(range.diph);
range.diph.dwHow = DIPH_BYOFFSET;
// screw EnumObjects, just go through all the axis offsets and try to GetProperty
// this should be more foolproof, less code, and probably faster
for (unsigned int offset = 0; offset < DIJOFS_BUTTON(0) / sizeof(LONG); ++offset)
{
range.diph.dwObj = offset * sizeof(LONG);
// try to set some nice power of 2 values (128) to match the GameCube controls
range.lMin = -(1 << 7);
range.lMax = (1 << 7);
m_device->SetProperty(DIPROP_RANGE, &range.diph);
// but I guess not all devices support setting range
// so I getproperty right afterward incase it didn't set.
// This also checks that the axis is present
if (SUCCEEDED(m_device->GetProperty(DIPROP_RANGE, &range.diph)))
{
const LONG base = (range.lMin + range.lMax) / 2;
const LONG& ax = (&m_state_in.lX)[offset];
// get up to 6 axes and 2 sliders
DIPROPRANGE range;
range.diph.dwSize = sizeof(range);
range.diph.dwHeaderSize = sizeof(range.diph);
range.diph.dwHow = DIPH_BYOFFSET;
// screw EnumObjects, just go through all the axis offsets and try to GetProperty
// this should be more foolproof, less code, and probably faster
for (unsigned int offset = 0; offset < DIJOFS_BUTTON(0) / sizeof(LONG); ++offset)
{
range.diph.dwObj = offset * sizeof(LONG);
// try to set some nice power of 2 values (128) to match the GameCube controls
range.lMin = -(1 << 7);
range.lMax = (1 << 7);
m_device->SetProperty(DIPROP_RANGE, &range.diph);
// but I guess not all devices support setting range
// so I getproperty right afterward incase it didn't set.
// This also checks that the axis is present
if (SUCCEEDED(m_device->GetProperty(DIPROP_RANGE, &range.diph)))
{
const LONG base = (range.lMin + range.lMax) / 2;
const LONG& ax = (&m_state_in.lX)[offset];
// each axis gets a negative and a positive input instance associated with it
AddAnalogInputs(new Axis(offset, ax, base, range.lMin-base),
new Axis(offset, ax, base, range.lMax-base));
}
}
// each axis gets a negative and a positive input instance associated with it
AddAnalogInputs(new Axis(offset, ax, base, range.lMin - base),
new Axis(offset, ax, base, range.lMax - base));
}
}
// force feedback
std::list<DIDEVICEOBJECTINSTANCE> objects;
if (SUCCEEDED(m_device->EnumObjects(DIEnumDeviceObjectsCallback, (LPVOID)&objects, DIDFT_AXIS)))
{
InitForceFeedback(m_device, (int)objects.size());
}
// force feedback
std::list<DIDEVICEOBJECTINSTANCE> objects;
if (SUCCEEDED(m_device->EnumObjects(DIEnumDeviceObjectsCallback, (LPVOID)&objects, DIDFT_AXIS)))
{
InitForceFeedback(m_device, (int)objects.size());
}
ZeroMemory(&m_state_in, sizeof(m_state_in));
// set hats to center
memset(m_state_in.rgdwPOV, 0xFF, sizeof(m_state_in.rgdwPOV));
ZeroMemory(&m_state_in, sizeof(m_state_in));
// set hats to center
memset(m_state_in.rgdwPOV, 0xFF, sizeof(m_state_in.rgdwPOV));
}
Joystick::~Joystick()
{
m_device->Unacquire();
m_device->Release();
m_device->Unacquire();
m_device->Release();
}
std::string Joystick::GetName() const
{
return GetDeviceName(m_device);
return GetDeviceName(m_device);
}
int Joystick::GetId() const
{
return m_index;
return m_index;
}
std::string Joystick::GetSource() const
{
return DINPUT_SOURCE_NAME;
return DINPUT_SOURCE_NAME;
}
// update IO
void Joystick::UpdateInput()
{
HRESULT hr = 0;
HRESULT hr = 0;
// just always poll,
// MSDN says if this isn't needed it doesn't do anything
m_device->Poll();
// just always poll,
// MSDN says if this isn't needed it doesn't do anything
m_device->Poll();
if (m_buffered)
{
DIDEVICEOBJECTDATA evtbuf[DATA_BUFFER_SIZE];
DWORD numevents = DATA_BUFFER_SIZE;
hr = m_device->GetDeviceData(sizeof(*evtbuf), evtbuf, &numevents, 0);
if (m_buffered)
{
DIDEVICEOBJECTDATA evtbuf[DATA_BUFFER_SIZE];
DWORD numevents = DATA_BUFFER_SIZE;
hr = m_device->GetDeviceData(sizeof(*evtbuf), evtbuf, &numevents, 0);
if (SUCCEEDED(hr))
{
for (LPDIDEVICEOBJECTDATA evt = evtbuf; evt != (evtbuf + numevents); ++evt)
{
// all the buttons are at the end of the data format
// they are bytes rather than longs
if (evt->dwOfs < DIJOFS_BUTTON(0))
*(DWORD*)(((BYTE*)&m_state_in) + evt->dwOfs) = evt->dwData;
else
((BYTE*)&m_state_in)[evt->dwOfs] = (BYTE)evt->dwData;
}
if (SUCCEEDED(hr))
{
for (LPDIDEVICEOBJECTDATA evt = evtbuf; evt != (evtbuf + numevents); ++evt)
{
// all the buttons are at the end of the data format
// they are bytes rather than longs
if (evt->dwOfs < DIJOFS_BUTTON(0))
*(DWORD*)(((BYTE*)&m_state_in) + evt->dwOfs) = evt->dwData;
else
((BYTE*)&m_state_in)[evt->dwOfs] = (BYTE)evt->dwData;
}
// seems like this needs to be done maybe...
if (DI_BUFFEROVERFLOW == hr)
hr = m_device->GetDeviceState(sizeof(m_state_in), &m_state_in);
}
}
else
{
hr = m_device->GetDeviceState(sizeof(m_state_in), &m_state_in);
}
// seems like this needs to be done maybe...
if (DI_BUFFEROVERFLOW == hr)
hr = m_device->GetDeviceState(sizeof(m_state_in), &m_state_in);
}
}
else
{
hr = m_device->GetDeviceState(sizeof(m_state_in), &m_state_in);
}
// try reacquire if input lost
if (DIERR_INPUTLOST == hr || DIERR_NOTACQUIRED == hr)
m_device->Acquire();
// try reacquire if input lost
if (DIERR_INPUTLOST == hr || DIERR_NOTACQUIRED == hr)
m_device->Acquire();
}
// get name
std::string Joystick::Button::GetName() const
{
std::ostringstream ss;
ss << "Button " << (int)m_index;
return ss.str();
std::ostringstream ss;
ss << "Button " << (int)m_index;
return ss.str();
}
std::string Joystick::Axis::GetName() const
{
std::ostringstream ss;
// axis
if (m_index < 6)
{
ss << "Axis " << (char)('X' + (m_index % 3));
if (m_index > 2)
ss << 'r';
}
// slider
else
{
ss << "Slider " << (int)(m_index - 6);
}
std::ostringstream ss;
// axis
if (m_index < 6)
{
ss << "Axis " << (char)('X' + (m_index % 3));
if (m_index > 2)
ss << 'r';
}
// slider
else
{
ss << "Slider " << (int)(m_index - 6);
}
ss << (m_range < 0 ? '-' : '+');
return ss.str();
ss << (m_range < 0 ? '-' : '+');
return ss.str();
}
std::string Joystick::Hat::GetName() const
{
static char tmpstr[] = "Hat . .";
tmpstr[4] = (char)('0' + m_index);
tmpstr[6] = "NESW"[m_direction];
return tmpstr;
static char tmpstr[] = "Hat . .";
tmpstr[4] = (char)('0' + m_index);
tmpstr[6] = "NESW"[m_direction];
return tmpstr;
}
// get / set state
ControlState Joystick::Axis::GetState() const
{
return std::max(0.0, ControlState(m_axis - m_base) / m_range);
return std::max(0.0, ControlState(m_axis - m_base) / m_range);
}
ControlState Joystick::Button::GetState() const
{
return ControlState(m_button > 0);
return ControlState(m_button > 0);
}
ControlState Joystick::Hat::GetState() const
{
// can this func be simplified ?
// hat centered code from MSDN
if (0xFFFF == LOWORD(m_hat))
return 0;
return (abs((int)(m_hat / 4500 - m_direction * 2 + 8) % 8 - 4) > 2);
}
// can this func be simplified ?
// hat centered code from MSDN
if (0xFFFF == LOWORD(m_hat))
return 0;
return (abs((int)(m_hat / 4500 - m_direction * 2 + 8) % 8 - 4) > 2);
}
}
}

93
Source/Core/InputCommon/ControllerInterface/DInput/DInputJoystick.h
View File

@ -11,64 +11,71 @@ namespace ciface
{
namespace DInput
{
void InitJoystick(IDirectInput8* const idi8, std::vector<Core::Device*>& devices, HWND hwnd);
class Joystick : public ForceFeedback::ForceFeedbackDevice
{
private:
class Button : public Input
{
public:
Button(u8 index, const BYTE& button) : m_button(button), m_index(index) {}
std::string GetName() const override;
ControlState GetState() const override;
private:
const BYTE& m_button;
const u8 m_index;
};
class Button : public Input
{
public:
Button(u8 index, const BYTE& button) : m_button(button), m_index(index) {}
std::string GetName() const override;
ControlState GetState() const override;
class Axis : public Input
{
public:
Axis(u8 index, const LONG& axis, LONG base, LONG range) : m_axis(axis), m_base(base), m_range(range), m_index(index) {}
std::string GetName() const override;
ControlState GetState() const override;
private:
const LONG& m_axis;
const LONG m_base, m_range;
const u8 m_index;
};
private:
const BYTE& m_button;
const u8 m_index;
};
class Hat : public Input
{
public:
Hat(u8 index, const DWORD& hat, u8 direction) : m_hat(hat), m_direction(direction), m_index(index) {}
std::string GetName() const override;
ControlState GetState() const override;
private:
const DWORD& m_hat;
const u8 m_index, m_direction;
};
class Axis : public Input
{
public:
Axis(u8 index, const LONG& axis, LONG base, LONG range)
: m_axis(axis), m_base(base), m_range(range), m_index(index)
{
}
std::string GetName() const override;
ControlState GetState() const override;
private:
const LONG& m_axis;
const LONG m_base, m_range;
const u8 m_index;
};
class Hat : public Input
{
public:
Hat(u8 index, const DWORD& hat, u8 direction)
: m_hat(hat), m_direction(direction), m_index(index)
{
}
std::string GetName() const override;
ControlState GetState() const override;
private:
const DWORD& m_hat;
const u8 m_index, m_direction;
};
public:
void UpdateInput() override;
void UpdateInput() override;
Joystick(const LPDIRECTINPUTDEVICE8 device, const unsigned int index);
~Joystick();
Joystick(const LPDIRECTINPUTDEVICE8 device, const unsigned int index);
~Joystick();
std::string GetName() const override;
int GetId() const override;
std::string GetSource() const override;
std::string GetName() const override;
int GetId() const override;
std::string GetSource() const override;
private:
const LPDIRECTINPUTDEVICE8 m_device;
const unsigned int m_index;
const LPDIRECTINPUTDEVICE8 m_device;
const unsigned int m_index;
DIJOYSTATE m_state_in;
DIJOYSTATE m_state_in;
bool m_buffered;
bool m_buffered;
};
}
}

302
Source/Core/InputCommon/ControllerInterface/DInput/DInputKeyboardMouse.cpp
View File

@ -7,27 +7,25 @@
#include "InputCommon/ControllerInterface/DInput/DInput.h"
#include "InputCommon/ControllerInterface/DInput/DInputKeyboardMouse.h"
// (lower would be more sensitive) user can lower sensitivity by setting range
// seems decent here ( at 8 ), I don't think anyone would need more sensitive than this
// and user can lower it much farther than they would want to with the range
#define MOUSE_AXIS_SENSITIVITY 8
// (lower would be more sensitive) user can lower sensitivity by setting range
// seems decent here ( at 8 ), I don't think anyone would need more sensitive than this
// and user can lower it much farther than they would want to with the range
#define MOUSE_AXIS_SENSITIVITY 8
// if input hasn't been received for this many ms, mouse input will be skipped
// otherwise it is just some crazy value
#define DROP_INPUT_TIME 250
// if input hasn't been received for this many ms, mouse input will be skipped
// otherwise it is just some crazy value
#define DROP_INPUT_TIME 250
namespace ciface
{
namespace DInput
{
static const struct
{
const BYTE code;
const char* const name;
} named_keys[] =
{
#include "InputCommon/ControllerInterface/DInput/NamedKeys.h" // NOLINT
const BYTE code;
const char* const name;
} named_keys[] = {
#include "InputCommon/ControllerInterface/DInput/NamedKeys.h" // NOLINT
};
// lil silly
@ -35,223 +33,225 @@ static HWND m_hwnd;
void InitKeyboardMouse(IDirectInput8* const idi8, std::vector<Core::Device*>& devices, HWND _hwnd)
{
m_hwnd = _hwnd;
m_hwnd = _hwnd;
// mouse and keyboard are a combined device, to allow shift+click and stuff
// if that's dumb, I will make a VirtualDevice class that just uses ranges of inputs/outputs from other devices
// so there can be a separated Keyboard and mouse, as well as combined KeyboardMouse
// mouse and keyboard are a combined device, to allow shift+click and stuff
// if that's dumb, I will make a VirtualDevice class that just uses ranges of inputs/outputs from
// other devices
// so there can be a separated Keyboard and mouse, as well as combined KeyboardMouse
LPDIRECTINPUTDEVICE8 kb_device = nullptr;
LPDIRECTINPUTDEVICE8 mo_device = nullptr;
LPDIRECTINPUTDEVICE8 kb_device = nullptr;
LPDIRECTINPUTDEVICE8 mo_device = nullptr;
if (SUCCEEDED(idi8->CreateDevice( GUID_SysKeyboard, &kb_device, nullptr)))
{
if (SUCCEEDED(kb_device->SetDataFormat(&c_dfDIKeyboard)))
{
if (SUCCEEDED(kb_device->SetCooperativeLevel(nullptr, DISCL_BACKGROUND | DISCL_NONEXCLUSIVE)))
{
if (SUCCEEDED(idi8->CreateDevice( GUID_SysMouse, &mo_device, nullptr )))
{
if (SUCCEEDED(mo_device->SetDataFormat(&c_dfDIMouse2)))
{
if (SUCCEEDED(mo_device->SetCooperativeLevel(nullptr, DISCL_BACKGROUND | DISCL_NONEXCLUSIVE)))
{
devices.push_back(new KeyboardMouse(kb_device, mo_device));
return;
}
}
}
}
}
}
if (SUCCEEDED(idi8->CreateDevice(GUID_SysKeyboard, &kb_device, nullptr)))
{
if (SUCCEEDED(kb_device->SetDataFormat(&c_dfDIKeyboard)))
{
if (SUCCEEDED(kb_device->SetCooperativeLevel(nullptr, DISCL_BACKGROUND | DISCL_NONEXCLUSIVE)))
{
if (SUCCEEDED(idi8->CreateDevice(GUID_SysMouse, &mo_device, nullptr)))
{
if (SUCCEEDED(mo_device->SetDataFormat(&c_dfDIMouse2)))
{
if (SUCCEEDED(
mo_device->SetCooperativeLevel(nullptr, DISCL_BACKGROUND | DISCL_NONEXCLUSIVE)))
{
devices.push_back(new KeyboardMouse(kb_device, mo_device));
return;
}
}
}
}
}
}
if (kb_device)
kb_device->Release();
if (mo_device)
mo_device->Release();
if (kb_device)
kb_device->Release();
if (mo_device)
mo_device->Release();
}
KeyboardMouse::~KeyboardMouse()
{
// kb
m_kb_device->Unacquire();
m_kb_device->Release();
// mouse
m_mo_device->Unacquire();
m_mo_device->Release();
// kb
m_kb_device->Unacquire();
m_kb_device->Release();
// mouse
m_mo_device->Unacquire();
m_mo_device->Release();
}
KeyboardMouse::KeyboardMouse(const LPDIRECTINPUTDEVICE8 kb_device, const LPDIRECTINPUTDEVICE8 mo_device)
: m_kb_device(kb_device)
, m_mo_device(mo_device)
KeyboardMouse::KeyboardMouse(const LPDIRECTINPUTDEVICE8 kb_device,
const LPDIRECTINPUTDEVICE8 mo_device)
: m_kb_device(kb_device), m_mo_device(mo_device)
{
m_kb_device->Acquire();
m_mo_device->Acquire();
m_kb_device->Acquire();
m_mo_device->Acquire();
m_last_update = GetTickCount();
m_last_update = GetTickCount();
ZeroMemory(&m_state_in, sizeof(m_state_in));
ZeroMemory(&m_state_in, sizeof(m_state_in));
// KEYBOARD
// add keys
for (u8 i = 0; i < sizeof(named_keys)/sizeof(*named_keys); ++i)
AddInput(new Key(i, m_state_in.keyboard[named_keys[i].code]));
// KEYBOARD
// add keys
for (u8 i = 0; i < sizeof(named_keys) / sizeof(*named_keys); ++i)
AddInput(new Key(i, m_state_in.keyboard[named_keys[i].code]));
// MOUSE
// get caps
DIDEVCAPS mouse_caps;
ZeroMemory( &mouse_caps, sizeof(mouse_caps) );
mouse_caps.dwSize = sizeof(mouse_caps);
m_mo_device->GetCapabilities(&mouse_caps);
// mouse buttons
for (u8 i = 0; i < mouse_caps.dwButtons; ++i)
AddInput(new Button(i, m_state_in.mouse.rgbButtons[i]));
// mouse axes
for (unsigned int i = 0; i < mouse_caps.dwAxes; ++i)
{
const LONG& ax = (&m_state_in.mouse.lX)[i];
// MOUSE
// get caps
DIDEVCAPS mouse_caps;
ZeroMemory(&mouse_caps, sizeof(mouse_caps));
mouse_caps.dwSize = sizeof(mouse_caps);
m_mo_device->GetCapabilities(&mouse_caps);
// mouse buttons
for (u8 i = 0; i < mouse_caps.dwButtons; ++i)
AddInput(new Button(i, m_state_in.mouse.rgbButtons[i]));
// mouse axes
for (unsigned int i = 0; i < mouse_caps.dwAxes; ++i)
{
const LONG& ax = (&m_state_in.mouse.lX)[i];
// each axis gets a negative and a positive input instance associated with it
AddInput(new Axis(i, ax, (2==i) ? -1 : -MOUSE_AXIS_SENSITIVITY));
AddInput(new Axis(i, ax, -(2==i) ? 1 : MOUSE_AXIS_SENSITIVITY));
}
// cursor, with a hax for-loop
for (unsigned int i=0; i<4; ++i)
AddInput(new Cursor(!!(i&2), (&m_state_in.cursor.x)[i/2], !!(i&1)));
// each axis gets a negative and a positive input instance associated with it
AddInput(new Axis(i, ax, (2 == i) ? -1 : -MOUSE_AXIS_SENSITIVITY));
AddInput(new Axis(i, ax, -(2 == i) ? 1 : MOUSE_AXIS_SENSITIVITY));
}
// cursor, with a hax for-loop
for (unsigned int i = 0; i < 4; ++i)
AddInput(new Cursor(!!(i & 2), (&m_state_in.cursor.x)[i / 2], !!(i & 1)));
}
void GetMousePos(ControlState* const x, ControlState* const y)
{
POINT point = { 1, 1 };
GetCursorPos(&point);
// Get the cursor position relative to the upper left corner of the current window (separate or render to main)
HWND hwnd = WindowFromPoint(point);
DWORD processId;
GetWindowThreadProcessId(hwnd, &processId);
if (processId == GetCurrentProcessId())
{
ScreenToClient(hwnd, &point);
POINT point = {1, 1};
GetCursorPos(&point);
// Get the cursor position relative to the upper left corner of the current window (separate or
// render to main)
HWND hwnd = WindowFromPoint(point);
DWORD processId;
GetWindowThreadProcessId(hwnd, &processId);
if (processId == GetCurrentProcessId())
{
ScreenToClient(hwnd, &point);
// Get the size of the current window. (In my case Rect.top and Rect.left was zero.)
RECT rect;
GetClientRect(hwnd, &rect);
// Width and height is the size of the rendering window
unsigned int win_width = rect.right - rect.left;
unsigned int win_height = rect.bottom - rect.top;
// Get the size of the current window. (In my case Rect.top and Rect.left was zero.)
RECT rect;
GetClientRect(hwnd, &rect);
// Width and height is the size of the rendering window
unsigned int win_width = rect.right - rect.left;
unsigned int win_height = rect.bottom - rect.top;
// Return the mouse position as a range from -1 to 1
*x = (ControlState)point.x / (ControlState)win_width * 2 - 1;
*y = (ControlState)point.y / (ControlState)win_height * 2 - 1;
}
else
{
*x = (ControlState)1;
*y = (ControlState)1;
}
// Return the mouse position as a range from -1 to 1
*x = (ControlState)point.x / (ControlState)win_width * 2 - 1;
*y = (ControlState)point.y / (ControlState)win_height * 2 - 1;
}
else
{
*x = (ControlState)1;
*y = (ControlState)1;
}
}
void KeyboardMouse::UpdateInput()
{
DIMOUSESTATE2 tmp_mouse;
DIMOUSESTATE2 tmp_mouse;
// if mouse position hasn't been updated in a short while, skip a dev state
DWORD cur_time = GetTickCount();
if (cur_time - m_last_update > DROP_INPUT_TIME)
{
// set axes to zero
ZeroMemory(&m_state_in.mouse, sizeof(m_state_in.mouse));
// skip this input state
m_mo_device->GetDeviceState(sizeof(tmp_mouse), &tmp_mouse);
}
// if mouse position hasn't been updated in a short while, skip a dev state
DWORD cur_time = GetTickCount();
if (cur_time - m_last_update > DROP_INPUT_TIME)
{
// set axes to zero
ZeroMemory(&m_state_in.mouse, sizeof(m_state_in.mouse));
// skip this input state
m_mo_device->GetDeviceState(sizeof(tmp_mouse), &tmp_mouse);
}
m_last_update = cur_time;
m_last_update = cur_time;
HRESULT kb_hr = m_kb_device->GetDeviceState(sizeof(m_state_in.keyboard), &m_state_in.keyboard);
HRESULT mo_hr = m_mo_device->GetDeviceState(sizeof(tmp_mouse), &tmp_mouse);
HRESULT kb_hr = m_kb_device->GetDeviceState(sizeof(m_state_in.keyboard), &m_state_in.keyboard);
HRESULT mo_hr = m_mo_device->GetDeviceState(sizeof(tmp_mouse), &tmp_mouse);
if (DIERR_INPUTLOST == kb_hr || DIERR_NOTACQUIRED == kb_hr)
m_kb_device->Acquire();
if (DIERR_INPUTLOST == kb_hr || DIERR_NOTACQUIRED == kb_hr)
m_kb_device->Acquire();
if (DIERR_INPUTLOST == mo_hr || DIERR_NOTACQUIRED == mo_hr)
m_mo_device->Acquire();
if (DIERR_INPUTLOST == mo_hr || DIERR_NOTACQUIRED == mo_hr)
m_mo_device->Acquire();
if (SUCCEEDED(kb_hr) && SUCCEEDED(mo_hr))
{
// need to smooth out the axes, otherwise it doesn't work for shit
for (unsigned int i = 0; i < 3; ++i)
((&m_state_in.mouse.lX)[i] += (&tmp_mouse.lX)[i]) /= 2;
if (SUCCEEDED(kb_hr) && SUCCEEDED(mo_hr))
{
// need to smooth out the axes, otherwise it doesn't work for shit
for (unsigned int i = 0; i < 3; ++i)
((&m_state_in.mouse.lX)[i] += (&tmp_mouse.lX)[i]) /= 2;
// copy over the buttons
memcpy(m_state_in.mouse.rgbButtons, tmp_mouse.rgbButtons, sizeof(m_state_in.mouse.rgbButtons));
// copy over the buttons
memcpy(m_state_in.mouse.rgbButtons, tmp_mouse.rgbButtons, sizeof(m_state_in.mouse.rgbButtons));
// update mouse cursor
GetMousePos(&m_state_in.cursor.x, &m_state_in.cursor.y);
}
// update mouse cursor
GetMousePos(&m_state_in.cursor.x, &m_state_in.cursor.y);
}
}
std::string KeyboardMouse::GetName() const
{
return "Keyboard Mouse";
return "Keyboard Mouse";
}
int KeyboardMouse::GetId() const
{
// should this be -1, idk
return 0;
// should this be -1, idk
return 0;
}
std::string KeyboardMouse::GetSource() const
{
return DINPUT_SOURCE_NAME;
return DINPUT_SOURCE_NAME;
}
// names
std::string KeyboardMouse::Key::GetName() const
{
return named_keys[m_index].name;
return named_keys[m_index].name;
}
std::string KeyboardMouse::Button::GetName() const
{
return std::string("Click ") + char('0' + m_index);
return std::string("Click ") + char('0' + m_index);
}
std::string KeyboardMouse::Axis::GetName() const
{
static char tmpstr[] = "Axis ..";
tmpstr[5] = (char)('X' + m_index);
tmpstr[6] = (m_range<0 ? '-' : '+');
return tmpstr;
static char tmpstr[] = "Axis ..";
tmpstr[5] = (char)('X' + m_index);
tmpstr[6] = (m_range < 0 ? '-' : '+');
return tmpstr;
}
std::string KeyboardMouse::Cursor::GetName() const
{
static char tmpstr[] = "Cursor ..";
tmpstr[7] = (char)('X' + m_index);
tmpstr[8] = (m_positive ? '+' : '-');
return tmpstr;
static char tmpstr[] = "Cursor ..";
tmpstr[7] = (char)('X' + m_index);
tmpstr[8] = (m_positive ? '+' : '-');
return tmpstr;
}
// get/set state
ControlState KeyboardMouse::Key::GetState() const
{
return (m_key != 0);
return (m_key != 0);
}
ControlState KeyboardMouse::Button::GetState() const
{
return (m_button != 0);
return (m_button != 0);
}
ControlState KeyboardMouse::Axis::GetState() const
{
return std::max(0.0, ControlState(m_axis) / m_range);
return std::max(0.0, ControlState(m_axis) / m_range);
}
ControlState KeyboardMouse::Cursor::GetState() const
{
return std::max(0.0, ControlState(m_axis) / (m_positive ? 1.0 : -1.0));
}
return std::max(0.0, ControlState(m_axis) / (m_positive ? 1.0 : -1.0));
}
}
}

135
Source/Core/InputCommon/ControllerInterface/DInput/DInputKeyboardMouse.h
View File

@ -6,93 +6,98 @@
#include <windows.h>
#include "InputCommon/ControllerInterface/Device.h"
#include "InputCommon/ControllerInterface/DInput/DInput8.h"
#include "InputCommon/ControllerInterface/Device.h"
namespace ciface
{
namespace DInput
{
void InitKeyboardMouse(IDirectInput8* const idi8, std::vector<Core::Device*>& devices, HWND _hwnd);
class KeyboardMouse : public Core::Device
{
private:
struct State
{
BYTE keyboard[256];
DIMOUSESTATE2 mouse;
struct
{
ControlState x, y;
} cursor;
};
struct State
{
BYTE keyboard[256];
DIMOUSESTATE2 mouse;
struct
{
ControlState x, y;
} cursor;
};
class Key : public Input
{
public:
Key(u8 index, const BYTE& key) : m_key(key), m_index(index) {}
std::string GetName() const override;
ControlState GetState() const override;
private:
const BYTE& m_key;
const u8 m_index;
};
class Key : public Input
{
public:
Key(u8 index, const BYTE& key) : m_key(key), m_index(index) {}
std::string GetName() const override;
ControlState GetState() const override;
class Button : public Input
{
public:
Button(u8 index, const BYTE& button) : m_button(button), m_index(index) {}
std::string GetName() const override;
ControlState GetState() const override;
private:
const BYTE& m_button;
const u8 m_index;
};
private:
const BYTE& m_key;
const u8 m_index;
};
class Axis : public Input
{
public:
Axis(u8 index, const LONG& axis, LONG range) : m_axis(axis), m_range(range), m_index(index) {}
std::string GetName() const override;
ControlState GetState() const override;
private:
const LONG& m_axis;
const LONG m_range;
const u8 m_index;
};
class Button : public Input
{
public:
Button(u8 index, const BYTE& button) : m_button(button), m_index(index) {}
std::string GetName() const override;
ControlState GetState() const override;
class Cursor : public Input
{
public:
Cursor(u8 index, const ControlState& axis, const bool positive) : m_axis(axis), m_index(index), m_positive(positive) {}
std::string GetName() const override;
bool IsDetectable() override { return false; }
ControlState GetState() const override;
private:
const ControlState& m_axis;
const u8 m_index;
const bool m_positive;
};
private:
const BYTE& m_button;
const u8 m_index;
};
class Axis : public Input
{
public:
Axis(u8 index, const LONG& axis, LONG range) : m_axis(axis), m_range(range), m_index(index) {}
std::string GetName() const override;
ControlState GetState() const override;
private:
const LONG& m_axis;
const LONG m_range;
const u8 m_index;
};
class Cursor : public Input
{
public:
Cursor(u8 index, const ControlState& axis, const bool positive)
: m_axis(axis), m_index(index), m_positive(positive)
{
}
std::string GetName() const override;
bool IsDetectable() override { return false; }
ControlState GetState() const override;
private:
const ControlState& m_axis;
const u8 m_index;
const bool m_positive;
};
public:
void UpdateInput() override;
void UpdateInput() override;
KeyboardMouse(const LPDIRECTINPUTDEVICE8 kb_device, const LPDIRECTINPUTDEVICE8 mo_device);
~KeyboardMouse();
KeyboardMouse(const LPDIRECTINPUTDEVICE8 kb_device, const LPDIRECTINPUTDEVICE8 mo_device);
~KeyboardMouse();
std::string GetName() const override;
int GetId() const override;
std::string GetSource() const override;
std::string GetName() const override;
int GetId() const override;
std::string GetSource() const override;
private:
const LPDIRECTINPUTDEVICE8 m_kb_device;
const LPDIRECTINPUTDEVICE8 m_mo_device;
const LPDIRECTINPUTDEVICE8 m_kb_device;
const LPDIRECTINPUTDEVICE8 m_mo_device;
DWORD m_last_update;
State m_state_in;
DWORD m_last_update;
State m_state_in;
};
}
}

181
Source/Core/InputCommon/ControllerInterface/DInput/NamedKeys.h
View File

@ -2,147 +2,40 @@
// Licensed under GPLv2+
// Refer to the license.txt file included.
{ DIK_A, "A" },
{ DIK_B, "B" },
{ DIK_C, "C" },
{ DIK_D, "D" },
{ DIK_E, "E" },
{ DIK_F, "F" },
{ DIK_G, "G" },
{ DIK_H, "H" },
{ DIK_I, "I" },
{ DIK_J, "J" },
{ DIK_K, "K" },
{ DIK_L, "L" },
{ DIK_M, "M" },
{ DIK_N, "N" },
{ DIK_O, "O" },
{ DIK_P, "P" },
{ DIK_Q, "Q" },
{ DIK_R, "R" },
{ DIK_S, "S" },
{ DIK_T, "T" },
{ DIK_U, "U" },
{ DIK_V, "V" },
{ DIK_W, "W" },
{ DIK_X, "X" },
{ DIK_Y, "Y" },
{ DIK_Z, "Z" },
{ DIK_0, "0" },
{ DIK_1, "1" },
{ DIK_2, "2" },
{ DIK_3, "3" },
{ DIK_4, "4" },
{ DIK_5, "5" },
{ DIK_6, "6" },
{ DIK_7, "7" },
{ DIK_8, "8" },
{ DIK_9, "9" },
{ DIK_UP, "UP" },
{ DIK_DOWN, "DOWN" },
{ DIK_LEFT, "LEFT" },
{ DIK_RIGHT, "RIGHT" },
{ DIK_ABNT_C1, "ABNT_C1" },
{ DIK_ABNT_C2, "ABNT_C2" },
{ DIK_ADD, "ADD" },
{ DIK_APOSTROPHE, "APOSTROPHE" },
{ DIK_APPS, "APPS" },
{ DIK_AT, "AT" },
{ DIK_AX, "AX" },
{ DIK_BACK, "BACK" },
{ DIK_BACKSLASH, "BACKSLASH" },
{ DIK_CALCULATOR, "CALCULATOR" },
{ DIK_CAPITAL, "CAPITAL" },
{ DIK_COLON, "COLON" },
{ DIK_COMMA, "COMMA" },
{ DIK_CONVERT, "CONVERT" },
{ DIK_DECIMAL, "DECIMAL" },
{ DIK_DELETE, "DELETE" },
{ DIK_DIVIDE, "DIVIDE" },
{ DIK_EQUALS, "EQUALS" },
{ DIK_ESCAPE, "ESCAPE" },
{ DIK_F1, "F1" },
{ DIK_F2, "F2" },
{ DIK_F3, "F3" },
{ DIK_F4, "F4" },
{ DIK_F5, "F5" },
{ DIK_F6, "F6" },
{ DIK_F7, "F7" },
{ DIK_F8, "F8" },
{ DIK_F9, "F9" },
{ DIK_F10, "F10" },
{ DIK_F11, "F11" },
{ DIK_F12, "F12" },
{ DIK_F13, "F13" },
{ DIK_F14, "F14" },
{ DIK_F15, "F15" },
{ DIK_GRAVE, "GRAVE" },
{ DIK_HOME, "HOME" },
{ DIK_END, "END" },
{ DIK_INSERT, "INSERT" },
{ DIK_KANA, "KANA" },
{ DIK_KANJI, "KANJI" },
{ DIK_MAIL, "MAIL" },
{ DIK_MEDIASELECT, "MEDIASELECT" },
{ DIK_MEDIASTOP, "MEDIASTOP" },
{ DIK_MINUS, "MINUS" },
{ DIK_MULTIPLY, "MULTIPLY" },
{ DIK_MUTE, "MUTE" },
{ DIK_MYCOMPUTER, "MYCOMPUTER" },
{ DIK_NEXTTRACK, "NEXTTRACK" },
{ DIK_NOCONVERT, "NOCONVERT" },
{ DIK_NUMLOCK, "NUMLOCK" },
{ DIK_NUMPAD0, "NUMPAD0" },
{ DIK_NUMPAD1, "NUMPAD1" },
{ DIK_NUMPAD2, "NUMPAD2" },
{ DIK_NUMPAD3, "NUMPAD3" },
{ DIK_NUMPAD4, "NUMPAD4" },
{ DIK_NUMPAD5, "NUMPAD5" },
{ DIK_NUMPAD6, "NUMPAD6" },
{ DIK_NUMPAD7, "NUMPAD7" },
{ DIK_NUMPAD8, "NUMPAD8" },
{ DIK_NUMPAD9, "NUMPAD9" },
{ DIK_NUMPADCOMMA, "NUMPADCOMMA" },
{ DIK_NUMPADENTER, "NUMPADENTER" },
{ DIK_NUMPADEQUALS, "NUMPADEQUALS" },
{ DIK_OEM_102, "OEM_102" },
{ DIK_PAUSE, "PAUSE" },
{ DIK_PERIOD, "PERIOD" },
{ DIK_PLAYPAUSE, "PLAYPAUSE" },
{ DIK_POWER, "POWER" },
{ DIK_PREVTRACK, "PREVTRACK" },
{ DIK_PRIOR, "PRIOR" },
{ DIK_NEXT, "NEXT" },
{ DIK_RETURN, "RETURN" },
{ DIK_LBRACKET, "LBRACKET" },
{ DIK_RBRACKET, "RBRACKET" },
{ DIK_LCONTROL, "LCONTROL" },
{ DIK_RCONTROL, "RCONTROL" },
{ DIK_LMENU, "LMENU" },
{ DIK_RMENU, "RMENU" },
{ DIK_LSHIFT, "LSHIFT" },
{ DIK_RSHIFT, "RSHIFT" },
{ DIK_LWIN, "LWIN" },
{ DIK_RWIN, "RWIN" },
{ DIK_SCROLL, "SCROLL" },
{ DIK_SEMICOLON, "SEMICOLON" },
{ DIK_SLASH, "SLASH" },
{ DIK_SLEEP, "SLEEP" },
{ DIK_SPACE, "SPACE" },
{ DIK_STOP, "STOP" },
{ DIK_SUBTRACT, "SUBTRACT" },
{ DIK_SYSRQ, "SYSRQ" },
{ DIK_TAB, "TAB" },
{ DIK_UNDERLINE, "UNDERLINE" },
{ DIK_UNLABELED, "UNLABELED" },
{ DIK_VOLUMEDOWN, "VOLUMEDOWN" },
{ DIK_VOLUMEUP, "VOLUMEUP" },
{ DIK_WAKE, "WAKE" },
{ DIK_WEBBACK, "WEBBACK" },
{ DIK_WEBFAVORITES, "WEBFAVORITES" },
{ DIK_WEBFORWARD, "WEBFORWARD" },
{ DIK_WEBHOME, "WEBHOME" },
{ DIK_WEBREFRESH, "WEBREFRESH" },
{ DIK_WEBSEARCH, "WEBSEARCH" },
{ DIK_WEBSTOP, "WEBSTOP" },
{ DIK_YEN, "YEN" },
{DIK_A, "A"}, {DIK_B, "B"}, {DIK_C, "C"}, {DIK_D, "D"}, {DIK_E, "E"}, {DIK_F, "F"}, {DIK_G, "G"},
{DIK_H, "H"}, {DIK_I, "I"}, {DIK_J, "J"}, {DIK_K, "K"}, {DIK_L, "L"}, {DIK_M, "M"},
{DIK_N, "N"}, {DIK_O, "O"}, {DIK_P, "P"}, {DIK_Q, "Q"}, {DIK_R, "R"}, {DIK_S, "S"},
{DIK_T, "T"}, {DIK_U, "U"}, {DIK_V, "V"}, {DIK_W, "W"}, {DIK_X, "X"}, {DIK_Y, "Y"},
{DIK_Z, "Z"}, {DIK_0, "0"}, {DIK_1, "1"}, {DIK_2, "2"}, {DIK_3, "3"}, {DIK_4, "4"},
{DIK_5, "5"}, {DIK_6, "6"}, {DIK_7, "7"}, {DIK_8, "8"}, {DIK_9, "9"}, {DIK_UP, "UP"},
{DIK_DOWN, "DOWN"}, {DIK_LEFT, "LEFT"}, {DIK_RIGHT, "RIGHT"}, {DIK_ABNT_C1, "ABNT_C1"},
{DIK_ABNT_C2, "ABNT_C2"}, {DIK_ADD, "ADD"}, {DIK_APOSTROPHE, "APOSTROPHE"}, {DIK_APPS, "APPS"},
{DIK_AT, "AT"}, {DIK_AX, "AX"}, {DIK_BACK, "BACK"}, {DIK_BACKSLASH, "BACKSLASH"},
{DIK_CALCULATOR, "CALCULATOR"}, {DIK_CAPITAL, "CAPITAL"}, {DIK_COLON, "COLON"},
{DIK_COMMA, "COMMA"}, {DIK_CONVERT, "CONVERT"}, {DIK_DECIMAL, "DECIMAL"},
{DIK_DELETE, "DELETE"}, {DIK_DIVIDE, "DIVIDE"}, {DIK_EQUALS, "EQUALS"}, {DIK_ESCAPE, "ESCAPE"},
{DIK_F1, "F1"}, {DIK_F2, "F2"}, {DIK_F3, "F3"}, {DIK_F4, "F4"}, {DIK_F5, "F5"}, {DIK_F6, "F6"},
{DIK_F7, "F7"}, {DIK_F8, "F8"}, {DIK_F9, "F9"}, {DIK_F10, "F10"}, {DIK_F11, "F11"},
{DIK_F12, "F12"}, {DIK_F13, "F13"}, {DIK_F14, "F14"}, {DIK_F15, "F15"}, {DIK_GRAVE, "GRAVE"},
{DIK_HOME, "HOME"}, {DIK_END, "END"}, {DIK_INSERT, "INSERT"}, {DIK_KANA, "KANA"},
{DIK_KANJI, "KANJI"}, {DIK_MAIL, "MAIL"}, {DIK_MEDIASELECT, "MEDIASELECT"},
{DIK_MEDIASTOP, "MEDIASTOP"}, {DIK_MINUS, "MINUS"}, {DIK_MULTIPLY, "MULTIPLY"},
{DIK_MUTE, "MUTE"}, {DIK_MYCOMPUTER, "MYCOMPUTER"}, {DIK_NEXTTRACK, "NEXTTRACK"},
{DIK_NOCONVERT, "NOCONVERT"}, {DIK_NUMLOCK, "NUMLOCK"}, {DIK_NUMPAD0, "NUMPAD0"},
{DIK_NUMPAD1, "NUMPAD1"}, {DIK_NUMPAD2, "NUMPAD2"}, {DIK_NUMPAD3, "NUMPAD3"},
{DIK_NUMPAD4, "NUMPAD4"}, {DIK_NUMPAD5, "NUMPAD5"}, {DIK_NUMPAD6, "NUMPAD6"},
{DIK_NUMPAD7, "NUMPAD7"}, {DIK_NUMPAD8, "NUMPAD8"}, {DIK_NUMPAD9, "NUMPAD9"},
{DIK_NUMPADCOMMA, "NUMPADCOMMA"}, {DIK_NUMPADENTER, "NUMPADENTER"},
{DIK_NUMPADEQUALS, "NUMPADEQUALS"}, {DIK_OEM_102, "OEM_102"}, {DIK_PAUSE, "PAUSE"},
{DIK_PERIOD, "PERIOD"}, {DIK_PLAYPAUSE, "PLAYPAUSE"}, {DIK_POWER, "POWER"},
{DIK_PREVTRACK, "PREVTRACK"}, {DIK_PRIOR, "PRIOR"}, {DIK_NEXT, "NEXT"}, {DIK_RETURN, "RETURN"},
{DIK_LBRACKET, "LBRACKET"}, {DIK_RBRACKET, "RBRACKET"}, {DIK_LCONTROL, "LCONTROL"},
{DIK_RCONTROL, "RCONTROL"}, {DIK_LMENU, "LMENU"}, {DIK_RMENU, "RMENU"}, {DIK_LSHIFT, "LSHIFT"},
{DIK_RSHIFT, "RSHIFT"}, {DIK_LWIN, "LWIN"}, {DIK_RWIN, "RWIN"}, {DIK_SCROLL, "SCROLL"},
{DIK_SEMICOLON, "SEMICOLON"}, {DIK_SLASH, "SLASH"}, {DIK_SLEEP, "SLEEP"}, {DIK_SPACE, "SPACE"},
{DIK_STOP, "STOP"}, {DIK_SUBTRACT, "SUBTRACT"}, {DIK_SYSRQ, "SYSRQ"}, {DIK_TAB, "TAB"},
{DIK_UNDERLINE, "UNDERLINE"}, {DIK_UNLABELED, "UNLABELED"}, {DIK_VOLUMEDOWN, "VOLUMEDOWN"},
{DIK_VOLUMEUP, "VOLUMEUP"}, {DIK_WAKE, "WAKE"}, {DIK_WEBBACK, "WEBBACK"},
{DIK_WEBFAVORITES, "WEBFAVORITES"}, {DIK_WEBFORWARD, "WEBFORWARD"}, {DIK_WEBHOME, "WEBHOME"},
{DIK_WEBREFRESH, "WEBREFRESH"}, {DIK_WEBSEARCH, "WEBSEARCH"}, {DIK_WEBSTOP, "WEBSTOP"},
{DIK_YEN, "YEN"},

179
Source/Core/InputCommon/ControllerInterface/DInput/XInputFilter.cpp
View File

@ -5,118 +5,127 @@
// This function is contained in a separate file because WbemIdl.h pulls in files which break on
// /Zc:strictStrings, so this compilation unit is compiled without /Zc:strictStrings.
#include <vector>
#include <WbemIdl.h>
#include <Windows.h>
#include <vector>
#define SAFE_RELEASE(p) { if (p) { (p)->Release(); (p)=nullptr; } }
#define SAFE_RELEASE(p) \
{ \
if (p) \
{ \
(p)->Release(); \
(p) = nullptr; \
} \
}
namespace ciface
{
namespace DInput
{
//-----------------------------------------------------------------------------
// Modified some MSDN code to get all the XInput device GUID.Data1 values in a vector,
// faster than checking all the devices for each DirectInput device, like MSDN says to do
//-----------------------------------------------------------------------------
void GetXInputGUIDS(std::vector<DWORD>* guids)
{
IWbemLocator* pIWbemLocator = nullptr;
IEnumWbemClassObject* pEnumDevices = nullptr;
IWbemClassObject* pDevices[20] = {0};
IWbemServices* pIWbemServices = nullptr;
BSTR bstrNamespace = nullptr;
BSTR bstrDeviceID = nullptr;
BSTR bstrClassName = nullptr;
DWORD uReturned = 0;
VARIANT var;
HRESULT hr;
IWbemLocator* pIWbemLocator = nullptr;
IEnumWbemClassObject* pEnumDevices = nullptr;
IWbemClassObject* pDevices[20] = {0};
IWbemServices* pIWbemServices = nullptr;
BSTR bstrNamespace = nullptr;
BSTR bstrDeviceID = nullptr;
BSTR bstrClassName = nullptr;
DWORD uReturned = 0;
VARIANT var;
HRESULT hr;
// CoInit if needed
hr = CoInitialize(nullptr);
bool bCleanupCOM = SUCCEEDED(hr);
// CoInit if needed
hr = CoInitialize(nullptr);
bool bCleanupCOM = SUCCEEDED(hr);
// Create WMI
hr = CoCreateInstance(__uuidof(WbemLocator),
nullptr,
CLSCTX_INPROC_SERVER,
__uuidof(IWbemLocator),
(LPVOID*) &pIWbemLocator);
if (FAILED(hr) || pIWbemLocator == nullptr)
goto LCleanup;
// Create WMI
hr = CoCreateInstance(__uuidof(WbemLocator), nullptr, CLSCTX_INPROC_SERVER,
__uuidof(IWbemLocator), (LPVOID*)&pIWbemLocator);
if (FAILED(hr) || pIWbemLocator == nullptr)
goto LCleanup;
bstrNamespace = SysAllocString(L"\\\\.\\root\\cimv2"); if (bstrNamespace == nullptr) goto LCleanup;
bstrClassName = SysAllocString(L"Win32_PNPEntity"); if (bstrClassName == nullptr) goto LCleanup;
bstrDeviceID = SysAllocString(L"DeviceID"); if (bstrDeviceID == nullptr) goto LCleanup;
bstrNamespace = SysAllocString(L"\\\\.\\root\\cimv2");
if (bstrNamespace == nullptr)
goto LCleanup;
bstrClassName = SysAllocString(L"Win32_PNPEntity");
if (bstrClassName == nullptr)
goto LCleanup;
bstrDeviceID = SysAllocString(L"DeviceID");
if (bstrDeviceID == nullptr)
goto LCleanup;
// Connect to WMI
hr = pIWbemLocator->ConnectServer(bstrNamespace, nullptr, nullptr, 0L, 0L, nullptr, nullptr, &pIWbemServices);
if (FAILED(hr) || pIWbemServices == nullptr)
goto LCleanup;
// Connect to WMI
hr = pIWbemLocator->ConnectServer(bstrNamespace, nullptr, nullptr, 0L, 0L, nullptr, nullptr,
&pIWbemServices);
if (FAILED(hr) || pIWbemServices == nullptr)
goto LCleanup;
// Switch security level to IMPERSONATE.
CoSetProxyBlanket(pIWbemServices, RPC_C_AUTHN_WINNT, RPC_C_AUTHZ_NONE, nullptr,
RPC_C_AUTHN_LEVEL_CALL, RPC_C_IMP_LEVEL_IMPERSONATE, nullptr, EOAC_NONE);
// Switch security level to IMPERSONATE.
CoSetProxyBlanket(pIWbemServices, RPC_C_AUTHN_WINNT, RPC_C_AUTHZ_NONE, nullptr,
RPC_C_AUTHN_LEVEL_CALL, RPC_C_IMP_LEVEL_IMPERSONATE, nullptr, EOAC_NONE);
hr = pIWbemServices->CreateInstanceEnum(bstrClassName, 0, nullptr, &pEnumDevices);
if (FAILED(hr) || pEnumDevices == nullptr)
goto LCleanup;
hr = pIWbemServices->CreateInstanceEnum(bstrClassName, 0, nullptr, &pEnumDevices);
if (FAILED(hr) || pEnumDevices == nullptr)
goto LCleanup;
// Loop over all devices
while (true)
{
// Get 20 at a time
hr = pEnumDevices->Next(10000, 20, pDevices, &uReturned);
if (FAILED(hr) || uReturned == 0)
break;
// Loop over all devices
while (true)
{
// Get 20 at a time
hr = pEnumDevices->Next(10000, 20, pDevices, &uReturned);
if (FAILED(hr) || uReturned == 0)
break;
for (UINT iDevice = 0; iDevice < uReturned; ++iDevice)
{
// For each device, get its device ID
hr = pDevices[iDevice]->Get(bstrDeviceID, 0L, &var, nullptr, nullptr);
if (SUCCEEDED(hr) && var.vt == VT_BSTR && var.bstrVal != nullptr)
{
// Check if the device ID contains "IG_". If it does, then it's an XInput device
// This information can not be found from DirectInput
if (wcsstr(var.bstrVal, L"IG_"))
{
// If it does, then get the VID/PID from var.bstrVal
DWORD dwPid = 0, dwVid = 0;
WCHAR* strVid = wcsstr(var.bstrVal, L"VID_");
if (strVid && swscanf(strVid, L"VID_%4X", &dwVid) != 1)
dwVid = 0;
WCHAR* strPid = wcsstr(var.bstrVal, L"PID_");
if (strPid && swscanf(strPid, L"PID_%4X", &dwPid) != 1)
dwPid = 0;
for (UINT iDevice = 0; iDevice < uReturned; ++iDevice)
{
// For each device, get its device ID
hr = pDevices[iDevice]->Get(bstrDeviceID, 0L, &var, nullptr, nullptr);
if (SUCCEEDED(hr) && var.vt == VT_BSTR && var.bstrVal != nullptr)
{
// Check if the device ID contains "IG_". If it does, then it's an XInput device
// This information can not be found from DirectInput
if (wcsstr(var.bstrVal, L"IG_"))
{
// If it does, then get the VID/PID from var.bstrVal
DWORD dwPid = 0, dwVid = 0;
WCHAR* strVid = wcsstr(var.bstrVal, L"VID_");
if (strVid && swscanf(strVid, L"VID_%4X", &dwVid) != 1)
dwVid = 0;
WCHAR* strPid = wcsstr(var.bstrVal, L"PID_");
if (strPid && swscanf(strPid, L"PID_%4X", &dwPid) != 1)
dwPid = 0;
// Compare the VID/PID to the DInput device
DWORD dwVidPid = MAKELONG(dwVid, dwPid);
guids->push_back(dwVidPid);
//bIsXinputDevice = true;
}
}
SAFE_RELEASE(pDevices[iDevice]);
}
}
// Compare the VID/PID to the DInput device
DWORD dwVidPid = MAKELONG(dwVid, dwPid);
guids->push_back(dwVidPid);
// bIsXinputDevice = true;
}
}
SAFE_RELEASE(pDevices[iDevice]);
}
}
LCleanup:
if (bstrNamespace)
SysFreeString(bstrNamespace);
if (bstrDeviceID)
SysFreeString(bstrDeviceID);
if (bstrClassName)
SysFreeString(bstrClassName);
for (UINT iDevice = 0; iDevice < 20; iDevice++)
SAFE_RELEASE(pDevices[iDevice]);
SAFE_RELEASE(pEnumDevices);
SAFE_RELEASE(pIWbemLocator);
SAFE_RELEASE(pIWbemServices);
if (bstrNamespace)
SysFreeString(bstrNamespace);
if (bstrDeviceID)
SysFreeString(bstrDeviceID);
if (bstrClassName)
SysFreeString(bstrClassName);
for (UINT iDevice = 0; iDevice < 20; iDevice++)
SAFE_RELEASE(pDevices[iDevice]);
SAFE_RELEASE(pEnumDevices);
SAFE_RELEASE(pIWbemLocator);
SAFE_RELEASE(pIWbemServices);
if (bCleanupCOM)
CoUninitialize();
if (bCleanupCOM)
CoUninitialize();
}
}
}

4
Source/Core/InputCommon/ControllerInterface/DInput/XInputFilter.h
View File

@ -4,15 +4,13 @@
#pragma once
#include <vector>
#include <Windows.h>
#include <vector>
namespace ciface
{
namespace DInput
{
void GetXInputGUIDS(std::vector<DWORD>* guids);
}
}