mirror of
https://github.com/cemu-project/Cemu.git
synced 2026-07-29 06:59:19 -05:00
028b3f7992
* Refactor spinlock to meet Lockable requirements * Input: Refactor button code and make it thread-safe
335 lines
8.6 KiB
C++
335 lines
8.6 KiB
C++
#include "input/api/DirectInput/DirectInputController.h"
|
|
#include "gui/guiWrapper.h"
|
|
|
|
DirectInputController::DirectInputController(const GUID& guid)
|
|
: base_type(StringFromGUID(guid), fmt::format("[{}]", StringFromGUID(guid))),
|
|
m_guid{ guid }
|
|
{
|
|
|
|
}
|
|
|
|
DirectInputController::DirectInputController(const GUID& guid, std::string_view display_name)
|
|
: base_type(StringFromGUID(guid), display_name), m_guid(guid)
|
|
{
|
|
}
|
|
|
|
DirectInputController::~DirectInputController()
|
|
{
|
|
if (m_effect)
|
|
m_effect->Release();
|
|
|
|
if (m_device)
|
|
{
|
|
m_device->Unacquire();
|
|
|
|
// TODO: test if really needed
|
|
// workaround for gamecube controllers crash on release?
|
|
bool should_release_device = true;
|
|
if (m_product_guid == GUID{}) {
|
|
DIDEVICEINSTANCE info{};
|
|
info.dwSize = sizeof(DIDEVICEINSTANCE);
|
|
if (SUCCEEDED(m_device->GetDeviceInfo(&info)))
|
|
{
|
|
m_product_guid = info.guidProduct;
|
|
}
|
|
}
|
|
|
|
// info.guidProduct = {18440079-0000-0000-0000-504944564944}
|
|
constexpr GUID kGameCubeController = { 0x18440079, 0, 0, {0,0,0x50,0x49,0x44,0x56,0x49,0x44} };
|
|
if (kGameCubeController == m_product_guid)
|
|
should_release_device = false;
|
|
|
|
if (should_release_device)
|
|
m_device->Release();
|
|
}
|
|
}
|
|
|
|
void DirectInputController::save(pugi::xml_node& node)
|
|
{
|
|
base_type::save(node);
|
|
|
|
node.append_child("product_guid").append_child(pugi::node_pcdata).set_value(
|
|
fmt::format("{}", StringFromGUID(m_product_guid)).c_str());
|
|
}
|
|
|
|
void DirectInputController::load(const pugi::xml_node& node)
|
|
{
|
|
base_type::load(node);
|
|
|
|
if (const auto value = node.child("product_guid")) {
|
|
if (GUIDFromString(value.child_value(), m_product_guid) && m_product_guid != GUID{} && !is_connected())
|
|
{
|
|
// test if another controller with the same product guid is connectable and replace
|
|
for(const auto& c : m_provider->get_controllers())
|
|
{
|
|
if(const auto ptr = std::dynamic_pointer_cast<DirectInputController>(c))
|
|
{
|
|
if (ptr->is_connected() && ptr->get_product_guid() == m_product_guid)
|
|
{
|
|
const auto tmp_guid = m_guid;
|
|
m_guid = ptr->get_guid();
|
|
if (connect())
|
|
break;
|
|
|
|
// couldn't connect
|
|
m_guid = tmp_guid;
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
bool DirectInputController::connect()
|
|
{
|
|
if (is_connected())
|
|
return true;
|
|
|
|
m_effect = nullptr;
|
|
|
|
std::scoped_lock lock(m_mutex);
|
|
HRESULT hr = m_provider->get_dinput()->CreateDevice(m_guid, &m_device, nullptr);
|
|
if (FAILED(hr) || m_device == nullptr)
|
|
return false;
|
|
|
|
DIDEVICEINSTANCE idi{};
|
|
idi.dwSize = sizeof(DIDEVICEINSTANCE);
|
|
if (SUCCEEDED(m_device->GetDeviceInfo(&idi)))
|
|
{
|
|
// overwrite guid name with "real" display name
|
|
m_display_name = boost::nowide::narrow(idi.tszProductName);
|
|
}
|
|
|
|
// set data format
|
|
if (FAILED(m_device->SetDataFormat(m_provider->get_data_format())))
|
|
{
|
|
SAFE_RELEASE(m_device);
|
|
return false;
|
|
}
|
|
|
|
HWND hwndMainWindow = gui_getWindowInfo().window_main.hwnd;
|
|
|
|
// set access
|
|
if (FAILED(m_device->SetCooperativeLevel(hwndMainWindow, DISCL_BACKGROUND | DISCL_EXCLUSIVE)))
|
|
{
|
|
if (FAILED(m_device->SetCooperativeLevel(hwndMainWindow, DISCL_BACKGROUND | DISCL_NONEXCLUSIVE)))
|
|
{
|
|
SAFE_RELEASE(m_device);
|
|
return false;
|
|
}
|
|
// rumble can only be used with exclusive access
|
|
}
|
|
else
|
|
{
|
|
GUID guid_effect = GUID_NULL;
|
|
// check if constant force is supported
|
|
HRESULT result = m_device->EnumEffects([](LPCDIEFFECTINFOW eff, LPVOID guid) -> BOOL
|
|
{
|
|
*(GUID*)guid = eff->guid;
|
|
return DIENUM_STOP;
|
|
}, &guid_effect, DIEFT_CONSTANTFORCE);
|
|
|
|
if (SUCCEEDED(result) && guid_effect != GUID_NULL)
|
|
{
|
|
DWORD dwAxes[2] = { DIJOFS_X, DIJOFS_Y };
|
|
LONG lDirection[2] = { 1, 0 };
|
|
|
|
DICONSTANTFORCE constant_force = { DI_FFNOMINALMAX }; // DI_FFNOMINALMAX -> should be max normally?!
|
|
|
|
DIEFFECT effect{};
|
|
effect.dwSize = sizeof(DIEFFECT);
|
|
effect.dwFlags = DIEFF_CARTESIAN | DIEFF_OBJECTOFFSETS;
|
|
effect.dwDuration = INFINITE; // DI_SECONDS;
|
|
effect.dwGain = DI_FFNOMINALMAX; // No scaling
|
|
effect.dwTriggerButton = DIEB_NOTRIGGER; // Not a button response DIEB_NOTRIGGER DIJOFS_BUTTON0
|
|
effect.cAxes = 2;
|
|
effect.rgdwAxes = dwAxes;
|
|
effect.rglDirection = lDirection;
|
|
effect.cbTypeSpecificParams = sizeof(DICONSTANTFORCE);
|
|
effect.lpvTypeSpecificParams = &constant_force;
|
|
m_device->CreateEffect(guid_effect, &effect, &m_effect, nullptr);
|
|
}
|
|
}
|
|
|
|
DIDEVICEINSTANCE info{};
|
|
info.dwSize = sizeof(DIDEVICEINSTANCE);
|
|
if (SUCCEEDED(m_device->GetDeviceInfo(&info)))
|
|
{
|
|
m_product_guid = info.guidProduct;
|
|
}
|
|
|
|
std::fill(m_min_axis.begin(), m_min_axis.end(), 0);
|
|
std::fill(m_max_axis.begin(), m_max_axis.end(), std::numeric_limits<uint16>::max());
|
|
m_device->EnumObjects(
|
|
[](LPCDIDEVICEOBJECTINSTANCE lpddoi, LPVOID pvRef) -> BOOL
|
|
{
|
|
auto* thisptr = (DirectInputController*)pvRef;
|
|
|
|
const auto instance = DIDFT_GETINSTANCE(lpddoi->dwType);
|
|
// some tools may use state.rglSlider properties, so they have 8 instead of 6 axis
|
|
if(instance >= thisptr->m_min_axis.size())
|
|
{
|
|
return DIENUM_CONTINUE;
|
|
}
|
|
|
|
DIPROPRANGE range{};
|
|
range.diph.dwSize = sizeof(range);
|
|
range.diph.dwHeaderSize = sizeof(range.diph);
|
|
range.diph.dwHow = DIPH_BYID;
|
|
range.diph.dwObj = lpddoi->dwType;
|
|
if (thisptr->m_device->GetProperty(DIPROP_RANGE, &range.diph) == DI_OK)
|
|
{
|
|
thisptr->m_min_axis[instance] = range.lMin;
|
|
thisptr->m_max_axis[instance] = range.lMax;
|
|
}
|
|
|
|
return DIENUM_CONTINUE;
|
|
}, this, DIDFT_AXIS);
|
|
|
|
m_device->Acquire();
|
|
return true;
|
|
}
|
|
|
|
bool DirectInputController::is_connected()
|
|
{
|
|
std::shared_lock lock(m_mutex);
|
|
return m_device != nullptr;
|
|
}
|
|
|
|
bool DirectInputController::has_rumble()
|
|
{
|
|
return m_effect != nullptr;
|
|
}
|
|
|
|
void DirectInputController::start_rumble()
|
|
{
|
|
if (!has_rumble())
|
|
return;
|
|
}
|
|
|
|
void DirectInputController::stop_rumble()
|
|
{
|
|
if (!has_rumble())
|
|
return;
|
|
}
|
|
|
|
std::string DirectInputController::get_button_name(uint64 button) const
|
|
{
|
|
switch(button)
|
|
{
|
|
case kAxisXP: return "X+";
|
|
case kAxisYP: return "Y+";
|
|
|
|
case kAxisXN: return "X-";
|
|
case kAxisYN: return "Y-";
|
|
|
|
case kRotationXP: return "RX+";
|
|
case kRotationYP: return "RY+";
|
|
|
|
case kRotationXN: return "RX-";
|
|
case kRotationYN: return "RY-";
|
|
|
|
case kTriggerXP: return "Z+";
|
|
case kTriggerYP: return "RZ+";
|
|
|
|
case kTriggerXN: return "Z-";
|
|
case kTriggerYN: return "RZ-";
|
|
}
|
|
|
|
return base_type::get_button_name(button);
|
|
}
|
|
|
|
ControllerState DirectInputController::raw_state()
|
|
{
|
|
ControllerState result{};
|
|
if (!is_connected())
|
|
return result;
|
|
HRESULT hr = m_device->Poll();
|
|
if (FAILED(hr))
|
|
{
|
|
if (hr == DIERR_INPUTLOST || hr == DIERR_NOTACQUIRED)
|
|
{
|
|
result.last_state = hr;
|
|
m_device->Acquire();
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
DIJOYSTATE state{};
|
|
hr = m_device->GetDeviceState(sizeof(state), &state);
|
|
if (FAILED(hr))
|
|
{
|
|
if (hr == DIERR_INPUTLOST || hr == DIERR_NOTACQUIRED)
|
|
{
|
|
result.last_state = hr;
|
|
m_device->Acquire();
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
result.last_state = hr;
|
|
|
|
// buttons
|
|
for (size_t i = 0; i < std::size(state.rgbButtons); ++i)
|
|
{
|
|
if (HAS_BIT(state.rgbButtons[i], 7))
|
|
result.buttons.SetButtonState(i, true);
|
|
}
|
|
|
|
// axis
|
|
constexpr float kThreshold = 0.001f;
|
|
float v = (float(state.lX - m_min_axis[0]) / float(m_max_axis[0] - m_min_axis[0])) * 2.0f - 1.0f;
|
|
if (std::abs(v) >= kThreshold)
|
|
result.axis.x = v;
|
|
|
|
v = (float(state.lY - m_min_axis[1]) / float(m_max_axis[1] - m_min_axis[1])) * 2.0f - 1.0f;
|
|
if (std::abs(v) >= kThreshold)
|
|
result.axis.y = -v;
|
|
|
|
// Right Stick
|
|
v = (float(state.lRx - m_min_axis[3]) / float(m_max_axis[3] - m_min_axis[3])) * 2.0f - 1.0f;
|
|
if (std::abs(v) >= kThreshold)
|
|
result.rotation.x = v;
|
|
|
|
v = (float(state.lRy - m_min_axis[4]) / float(m_max_axis[4] - m_min_axis[4])) * 2.0f - 1.0f;
|
|
if (std::abs(v) >= kThreshold)
|
|
result.rotation.y = -v;
|
|
|
|
// Trigger
|
|
v = (float(state.lZ - m_min_axis[2]) / float(m_max_axis[2] - m_min_axis[2])) * 2.0f - 1.0f;
|
|
if (std::abs(v) >= kThreshold)
|
|
result.trigger.x = v;
|
|
|
|
v = (float(state.lRz - m_min_axis[5]) / float(m_max_axis[5] - m_min_axis[5])) * 2.0f - 1.0f;
|
|
if (std::abs(v) >= kThreshold)
|
|
result.trigger.y = -v;
|
|
|
|
// dpad
|
|
const auto pov = state.rgdwPOV[0];
|
|
if (pov != static_cast<DWORD>(-1))
|
|
{
|
|
switch (pov)
|
|
{
|
|
case 0: result.buttons.SetButtonState(kButtonUp, true);
|
|
break;
|
|
case 4500: result.buttons.SetButtonState(kButtonUp, true); // up + right
|
|
case 9000: result.buttons.SetButtonState(kButtonRight, true);
|
|
break;
|
|
case 13500: result.buttons.SetButtonState(kButtonRight, true); // right + down
|
|
case 18000: result.buttons.SetButtonState(kButtonDown, true);
|
|
break;
|
|
case 22500: result.buttons.SetButtonState(kButtonDown, true); // down + left
|
|
case 27000: result.buttons.SetButtonState(kButtonLeft, true);
|
|
break;
|
|
case 31500: result.buttons.SetButtonState(kButtonLeft, true); // left + up
|
|
result.buttons.SetButtonState(kButtonUp, true); // left + up
|
|
break;
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|