mirror of
https://github.com/dolphin-emu/dolphin.git
synced 2024-11-15 22:09:19 -07:00
3e69d066f5
The SDL backend crashes when you close a joystick after SDL_Quit has been called. Some backends don't need to be shutdown and re-initialized everytime, we can just ask to enumerate devices again.
369 lines
9.1 KiB
C++
369 lines
9.1 KiB
C++
// Copyright 2010 Dolphin Emulator Project
|
|
// Licensed under GPLv2+
|
|
// Refer to the license.txt file included.
|
|
|
|
#include <mutex>
|
|
|
|
#include "Common/Thread.h"
|
|
#include "InputCommon/ControllerInterface/ControllerInterface.h"
|
|
|
|
#ifdef CIFACE_USE_XINPUT
|
|
#include "InputCommon/ControllerInterface/XInput/XInput.h"
|
|
#endif
|
|
#ifdef CIFACE_USE_DINPUT
|
|
#include "InputCommon/ControllerInterface/DInput/DInput.h"
|
|
#endif
|
|
#ifdef CIFACE_USE_XLIB
|
|
#include "InputCommon/ControllerInterface/Xlib/XInput2.h"
|
|
#endif
|
|
#ifdef CIFACE_USE_OSX
|
|
#include "InputCommon/ControllerInterface/OSX/OSX.h"
|
|
#include "InputCommon/ControllerInterface/Quartz/Quartz.h"
|
|
#endif
|
|
#ifdef CIFACE_USE_SDL
|
|
#include "InputCommon/ControllerInterface/SDL/SDL.h"
|
|
#endif
|
|
#ifdef CIFACE_USE_ANDROID
|
|
#include "InputCommon/ControllerInterface/Android/Android.h"
|
|
#endif
|
|
#ifdef CIFACE_USE_EVDEV
|
|
#include "InputCommon/ControllerInterface/evdev/evdev.h"
|
|
#endif
|
|
#ifdef CIFACE_USE_PIPES
|
|
#include "InputCommon/ControllerInterface/Pipes/Pipes.h"
|
|
#endif
|
|
|
|
using namespace ciface::ExpressionParser;
|
|
|
|
namespace
|
|
{
|
|
const ControlState INPUT_DETECT_THRESHOLD = 0.55;
|
|
}
|
|
|
|
ControllerInterface g_controller_interface;
|
|
|
|
//
|
|
// Init
|
|
//
|
|
// Detect devices and inputs outputs / will make refresh function later
|
|
//
|
|
void ControllerInterface::Initialize(void* const hwnd)
|
|
{
|
|
if (m_is_init)
|
|
return;
|
|
|
|
m_hwnd = hwnd;
|
|
|
|
#ifdef CIFACE_USE_DINPUT
|
|
// nothing needed
|
|
#endif
|
|
#ifdef CIFACE_USE_XINPUT
|
|
ciface::XInput::Init();
|
|
#endif
|
|
#ifdef CIFACE_USE_XLIB
|
|
// nothing needed
|
|
#endif
|
|
#ifdef CIFACE_USE_OSX
|
|
ciface::OSX::Init(hwnd);
|
|
// nothing needed for Quartz
|
|
#endif
|
|
#ifdef CIFACE_USE_SDL
|
|
ciface::SDL::Init();
|
|
#endif
|
|
#ifdef CIFACE_USE_ANDROID
|
|
// nothing needed
|
|
#endif
|
|
#ifdef CIFACE_USE_EVDEV
|
|
ciface::evdev::Init();
|
|
#endif
|
|
#ifdef CIFACE_USE_PIPES
|
|
// nothing needed
|
|
#endif
|
|
|
|
m_is_init = true;
|
|
RefreshDevices();
|
|
}
|
|
|
|
void ControllerInterface::RefreshDevices()
|
|
{
|
|
if (!m_is_init)
|
|
return;
|
|
|
|
{
|
|
std::lock_guard<std::mutex> lk(m_devices_mutex);
|
|
m_devices.clear();
|
|
}
|
|
|
|
#ifdef CIFACE_USE_DINPUT
|
|
ciface::DInput::PopulateDevices(reinterpret_cast<HWND>(m_hwnd));
|
|
#endif
|
|
#ifdef CIFACE_USE_XINPUT
|
|
ciface::XInput::PopulateDevices();
|
|
#endif
|
|
#ifdef CIFACE_USE_XLIB
|
|
ciface::XInput2::PopulateDevices(m_hwnd);
|
|
#endif
|
|
#ifdef CIFACE_USE_OSX
|
|
ciface::OSX::PopulateDevices(m_hwnd);
|
|
ciface::Quartz::PopulateDevices(m_hwnd);
|
|
#endif
|
|
#ifdef CIFACE_USE_SDL
|
|
ciface::SDL::PopulateDevices();
|
|
#endif
|
|
#ifdef CIFACE_USE_ANDROID
|
|
ciface::Android::PopulateDevices();
|
|
#endif
|
|
#ifdef CIFACE_USE_EVDEV
|
|
ciface::evdev::PopulateDevices();
|
|
#endif
|
|
#ifdef CIFACE_USE_PIPES
|
|
ciface::Pipes::PopulateDevices();
|
|
#endif
|
|
}
|
|
|
|
//
|
|
// DeInit
|
|
//
|
|
// Remove all devices/ call library cleanup functions
|
|
//
|
|
void ControllerInterface::Shutdown()
|
|
{
|
|
if (!m_is_init)
|
|
return;
|
|
|
|
{
|
|
std::lock_guard<std::mutex> lk(m_devices_mutex);
|
|
|
|
for (const auto& d : m_devices)
|
|
{
|
|
// Set outputs to ZERO before destroying device
|
|
for (ciface::Core::Device::Output* o : d->Outputs())
|
|
o->SetState(0);
|
|
}
|
|
|
|
m_devices.clear();
|
|
}
|
|
|
|
#ifdef CIFACE_USE_XINPUT
|
|
ciface::XInput::DeInit();
|
|
#endif
|
|
#ifdef CIFACE_USE_DINPUT
|
|
// nothing needed
|
|
#endif
|
|
#ifdef CIFACE_USE_XLIB
|
|
// nothing needed
|
|
#endif
|
|
#ifdef CIFACE_USE_OSX
|
|
ciface::OSX::DeInit();
|
|
ciface::Quartz::DeInit();
|
|
#endif
|
|
#ifdef CIFACE_USE_SDL
|
|
// TODO: there seems to be some sort of memory leak with SDL, quit isn't freeing everything up
|
|
SDL_Quit();
|
|
#endif
|
|
#ifdef CIFACE_USE_ANDROID
|
|
// nothing needed
|
|
#endif
|
|
#ifdef CIFACE_USE_EVDEV
|
|
ciface::evdev::Shutdown();
|
|
#endif
|
|
|
|
m_is_init = false;
|
|
}
|
|
|
|
void ControllerInterface::AddDevice(std::shared_ptr<ciface::Core::Device> device)
|
|
{
|
|
std::lock_guard<std::mutex> lk(m_devices_mutex);
|
|
// Try to find an ID for this device
|
|
int id = 0;
|
|
while (true)
|
|
{
|
|
const auto it = std::find_if(m_devices.begin(), m_devices.end(), [&device, &id](const auto& d) {
|
|
return d->GetSource() == device->GetSource() && d->GetName() == device->GetName() &&
|
|
d->GetId() == id;
|
|
});
|
|
if (it == m_devices.end()) // no device with the same name with this ID, so we can use it
|
|
break;
|
|
else
|
|
id++;
|
|
}
|
|
device->SetId(id);
|
|
m_devices.emplace_back(std::move(device));
|
|
}
|
|
|
|
void ControllerInterface::RemoveDevice(std::function<bool(const ciface::Core::Device*)> callback)
|
|
{
|
|
std::lock_guard<std::mutex> lk(m_devices_mutex);
|
|
m_devices.erase(std::remove_if(m_devices.begin(), m_devices.end(),
|
|
[&callback](const auto& dev) { return callback(dev.get()); }),
|
|
m_devices.end());
|
|
}
|
|
|
|
//
|
|
// UpdateInput
|
|
//
|
|
// Update input for all devices
|
|
//
|
|
void ControllerInterface::UpdateInput()
|
|
{
|
|
// Don't block the UI or CPU thread (to avoid a short but noticeable frame drop)
|
|
if (m_devices_mutex.try_lock())
|
|
{
|
|
std::lock_guard<std::mutex> lk(m_devices_mutex, std::adopt_lock);
|
|
for (const auto& d : m_devices)
|
|
d->UpdateInput();
|
|
}
|
|
}
|
|
|
|
//
|
|
// RegisterHotplugCallback
|
|
//
|
|
// Register a callback to be called from the input backends' hotplug thread
|
|
// when there is a new device
|
|
//
|
|
void ControllerInterface::RegisterHotplugCallback(std::function<void()> callback)
|
|
{
|
|
m_hotplug_callbacks.emplace_back(std::move(callback));
|
|
}
|
|
|
|
//
|
|
// InvokeHotplugCallbacks
|
|
//
|
|
// Invoke all callbacks that were registered
|
|
//
|
|
void ControllerInterface::InvokeHotplugCallbacks() const
|
|
{
|
|
for (const auto& callback : m_hotplug_callbacks)
|
|
callback();
|
|
}
|
|
|
|
//
|
|
// InputReference :: State
|
|
//
|
|
// Gets the state of an input reference
|
|
// override function for ControlReference::State ...
|
|
//
|
|
ControlState ControllerInterface::InputReference::State(const ControlState ignore)
|
|
{
|
|
if (parsed_expression)
|
|
return parsed_expression->GetValue() * range;
|
|
else
|
|
return 0.0;
|
|
}
|
|
|
|
//
|
|
// OutputReference :: State
|
|
//
|
|
// Set the state of all binded outputs
|
|
// overrides ControlReference::State .. combined them so I could make the GUI simple / inputs ==
|
|
// same as outputs one list
|
|
// I was lazy and it works so watever
|
|
//
|
|
ControlState ControllerInterface::OutputReference::State(const ControlState state)
|
|
{
|
|
if (parsed_expression)
|
|
parsed_expression->SetValue(state);
|
|
return 0.0;
|
|
}
|
|
|
|
//
|
|
// UpdateReference
|
|
//
|
|
// Updates a controlreference's binded devices/controls
|
|
// need to call this to re-parse a control reference's expression after changing it
|
|
//
|
|
void ControllerInterface::UpdateReference(ControllerInterface::ControlReference* ref,
|
|
const ciface::Core::DeviceQualifier& default_device) const
|
|
{
|
|
delete ref->parsed_expression;
|
|
ref->parsed_expression = nullptr;
|
|
|
|
ControlFinder finder(*this, default_device, ref->is_input);
|
|
ref->parse_error = ParseExpression(ref->expression, finder, &ref->parsed_expression);
|
|
}
|
|
|
|
//
|
|
// InputReference :: Detect
|
|
//
|
|
// Wait for input on all binded devices
|
|
// supports not detecting inputs that were held down at the time of Detect start,
|
|
// which is useful for those crazy flightsticks that have certain buttons that are always held down
|
|
// or some crazy axes or something
|
|
// upon input, return pointer to detected Control
|
|
// else return nullptr
|
|
//
|
|
ciface::Core::Device::Control*
|
|
ControllerInterface::InputReference::Detect(const unsigned int ms,
|
|
ciface::Core::Device* const device)
|
|
{
|
|
unsigned int time = 0;
|
|
std::vector<bool> states(device->Inputs().size());
|
|
|
|
if (device->Inputs().size() == 0)
|
|
return nullptr;
|
|
|
|
// get starting state of all inputs,
|
|
// so we can ignore those that were activated at time of Detect start
|
|
std::vector<ciface::Core::Device::Input *>::const_iterator i = device->Inputs().begin(),
|
|
e = device->Inputs().end();
|
|
for (std::vector<bool>::iterator state = states.begin(); i != e; ++i)
|
|
*state++ = ((*i)->GetState() > (1 - INPUT_DETECT_THRESHOLD));
|
|
|
|
while (time < ms)
|
|
{
|
|
device->UpdateInput();
|
|
i = device->Inputs().begin();
|
|
for (std::vector<bool>::iterator state = states.begin(); i != e; ++i, ++state)
|
|
{
|
|
// detected an input
|
|
if ((*i)->IsDetectable() && (*i)->GetState() > INPUT_DETECT_THRESHOLD)
|
|
{
|
|
// input was released at some point during Detect call
|
|
// return the detected input
|
|
if (false == *state)
|
|
return *i;
|
|
}
|
|
else if ((*i)->GetState() < (1 - INPUT_DETECT_THRESHOLD))
|
|
{
|
|
*state = false;
|
|
}
|
|
}
|
|
Common::SleepCurrentThread(10);
|
|
time += 10;
|
|
}
|
|
|
|
// no input was detected
|
|
return nullptr;
|
|
}
|
|
|
|
//
|
|
// OutputReference :: Detect
|
|
//
|
|
// Totally different from the inputReference detect / I have them combined so it was simpler to make
|
|
// the GUI.
|
|
// The GUI doesn't know the difference between an input and an output / it's odd but I was lazy and
|
|
// it was easy
|
|
//
|
|
// set all binded outputs to <range> power for x milliseconds return false
|
|
//
|
|
ciface::Core::Device::Control*
|
|
ControllerInterface::OutputReference::Detect(const unsigned int ms,
|
|
ciface::Core::Device* const device)
|
|
{
|
|
// ignore device
|
|
|
|
// don't hang if we don't even have any controls mapped
|
|
if (BoundCount() > 0)
|
|
{
|
|
State(1);
|
|
unsigned int slept = 0;
|
|
|
|
// this loop is to make stuff like flashing keyboard LEDs work
|
|
while (ms > (slept += 10))
|
|
Common::SleepCurrentThread(10);
|
|
|
|
State(0);
|
|
}
|
|
return nullptr;
|
|
}
|