ShuriZma
/
dolphin
mirror of https://github.com/dolphin-emu/dolphin.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #11009 from shuffle2/device-notify 

ciface/win32 and WGInput bug fixes
This commit is contained in:
Mai 2022-09-01 00:27:55 -04:00 committed by GitHub
parent 11281b5cef cd407abe34
commit 50550cf978
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
2 changed files with 354 additions and 511 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

610
Source/Core/InputCommon/ControllerInterface/WGInput/WGInput.cpp
View File

@ -4,41 +4,32 @@
#include "InputCommon/ControllerInterface/WGInput/WGInput.h"
#include <array>
#include <map>
#include <string_view>
// For CoGetApartmentType
#include <objbase.h>
#pragma comment(lib, "ole32")
// NOTE: winrt translates com failures to c++ exceptions, so we must use try/catch in this file to
// prevent possible errors from escaping and terminating Dolphin.
#include <winrt/base.h>
#include <winrt/windows.devices.haptics.h>
#include <winrt/windows.devices.power.h>
#include <winrt/windows.foundation.collections.h>
#include <winrt/windows.gaming.input.h>
#include <winrt/windows.system.power.h>
#pragma comment(lib, "windowsapp")
#include <fmt/format.h>
#include <roapi.h>
#include <windows.gaming.input.h>
#include <wrl.h>
#include "Common/DynamicLibrary.h"
#include "Common/HRWrap.h"
#include "Common/Logging/Log.h"
#include "Common/StringUtil.h"
#include "InputCommon/ControllerInterface/ControllerInterface.h"
using PIsApiSetImplemented = BOOL(APIENTRY*)(PCSTR Contract);
using PRoInitialize = decltype(&RoInitialize);
using PRoUninitialize = decltype(&RoUninitialize);
using PRoGetActivationFactory = decltype(&RoGetActivationFactory);
using PWindowsCreateStringReference = decltype(&WindowsCreateStringReference);
using PWindowsGetStringRawBuffer = decltype(&WindowsGetStringRawBuffer);
namespace WGI = ABI::Windows::Gaming::Input;
using ABI::Windows::Foundation::Collections::IVectorView;
using Microsoft::WRL::ComPtr;
namespace
{
bool g_runtime_initialized = false;
bool g_runtime_needs_deinit = false;
PRoInitialize g_RoInitialize_address = nullptr;
PRoUninitialize g_RoUninitialize_address = nullptr;
PRoGetActivationFactory g_RoGetActivationFactory_address = nullptr;
PWindowsCreateStringReference g_WindowsCreateStringReference_address = nullptr;
PWindowsGetStringRawBuffer g_WindowsGetStringRawBuffer_address = nullptr;
} // namespace
namespace WGI = winrt::Windows::Gaming::Input;
namespace Haptics = winrt::Windows::Devices::Haptics;
using winrt::Windows::Foundation::Collections::IVectorView;
namespace ciface::WGInput
{
@ -47,7 +38,7 @@ static constexpr std::string_view SOURCE_NAME = "WGInput";
// These names correspond to the values of the GameControllerButtonLabel enum.
// "None" is not used.
// There are some overlapping names assuming no device exposes both
// GameControllerButtonLabel_XboxLeftBumper and GameControllerButtonLabel_LeftBumper.
// GameControllerButtonLabel::XboxLeftBumper and GameControllerButtonLabel::LeftBumper.
// If needed we can prepend "Xbox" to relevant input names on conflict in the future.
static constexpr std::array wgi_button_names = {
"None", "Back", "Start", "Menu", "View", "Pad N",
@ -90,7 +81,7 @@ static constexpr MemberName<WGI::GamepadVibration, double> gamepad_motor_names[]
class Device : public Core::Device
{
public:
Device(std::string name, ComPtr<WGI::IRawGameController> raw_controller, WGI::IGamepad* gamepad)
Device(std::string name, WGI::RawGameController raw_controller, WGI::Gamepad gamepad)
: m_name(std::move(name)), m_raw_controller(raw_controller), m_gamepad(gamepad)
{
// Buttons:
@ -121,20 +112,27 @@ public:
const bool use_raw_controller_axes = !m_gamepad;
if (use_raw_controller_axes)
{
try
{
// Axes:
INT32 axis_count = 0;
if (SUCCEEDED(m_raw_controller->get_AxisCount(&axis_count)))
m_axes.resize(axis_count);
m_axes.resize(m_raw_controller.AxisCount());
u32 i = 0;
for (auto& axis : m_axes)
{
// AddAnalogInputs adds additional "FullAnalogSurface" Inputs.
AddAnalogInputs(new IndexedAxis(&axis, 0.5, +0.5, i), new IndexedAxis(&axis, 0.5, -0.5, i));
AddAnalogInputs(new IndexedAxis(&axis, 0.5, +0.5, i),
new IndexedAxis(&axis, 0.5, -0.5, i));
++i;
}
}
catch (winrt::hresult_error)
{
// If AxisCount failed, m_axes will remain zero-sized; nothing to do.
ERROR_LOG_FMT(CONTROLLERINTERFACE, "WGInput: Error populating axes");
}
}
// Apparently some devices (e.g. DS4) provide the IGameController interface
// but expose the dpad only on a switch (IRawGameController interface).
@ -144,51 +142,54 @@ public:
// Switches (Hats):
if (use_raw_controller_switches)
{
INT32 switch_count = 0;
if (SUCCEEDED(m_raw_controller->get_SwitchCount(&switch_count)))
m_switches.resize(switch_count);
try
{
m_switches.resize(m_raw_controller.SwitchCount());
// Accumulate switch kinds first, to ensure no inputs are added if there is any error.
std::vector<WGI::GameControllerSwitchKind> switch_kinds;
for (u32 i = 0; i < m_switches.size(); i++)
switch_kinds.push_back(m_raw_controller.GetSwitchKind(i));
u32 i = 0;
for (auto& swtch : m_switches)
{
using gcsp = WGI::GameControllerSwitchPosition;
WGI::GameControllerSwitchKind switch_kind;
m_raw_controller->GetSwitchKind(i, &switch_kind);
AddInput(new IndexedSwitch(&swtch, i, gcsp::Up));
AddInput(new IndexedSwitch(&swtch, i, gcsp::Down));
AddInput(new IndexedSwitch(&swtch, i, gcsp::GameControllerSwitchPosition_Up));
AddInput(new IndexedSwitch(&swtch, i, gcsp::GameControllerSwitchPosition_Down));
if (switch_kind != WGI::GameControllerSwitchKind_TwoWay)
if (switch_kinds[i] != WGI::GameControllerSwitchKind::TwoWay)
{
// If it's not a "two-way" switch (up/down only) then add the left/right inputs.
AddInput(new IndexedSwitch(&swtch, i, gcsp::GameControllerSwitchPosition_Left));
AddInput(new IndexedSwitch(&swtch, i, gcsp::GameControllerSwitchPosition_Right));
AddInput(new IndexedSwitch(&swtch, i, gcsp::Left));
AddInput(new IndexedSwitch(&swtch, i, gcsp::Right));
}
++i;
}
}
catch (winrt::hresult_error)
{
// Safe as no inputs will have been added.
m_switches.clear();
ERROR_LOG_FMT(CONTROLLERINTERFACE, "WGInput: Error populating switches");
}
}
// Haptics:
PopulateHaptics();
// Battery:
if (SUCCEEDED(m_raw_controller->QueryInterface(&m_controller_battery)) && m_controller_battery)
{
// It seems many controllers provide IGameControllerBatteryInfo with no battery info.
if (UpdateBatteryLevel())
AddInput(new Battery(&m_battery_level));
else
m_controller_battery = nullptr;
}
}
int GetSortPriority() const override { return -1; }
const WGI::RawGameController GetRawGameController() const { return m_raw_controller; }
private:
// `boolean` comes from Windows API. (typedef of unsigned char)
using ButtonValueType = boolean;
using ButtonValueType = u8;
class Button : public Input
{
@ -312,7 +313,7 @@ private:
public:
IndexedSwitch(const WGI::GameControllerSwitchPosition* swtch, u32 index,
WGI::GameControllerSwitchPosition direction)
: m_switch(*swtch), m_index(index), m_direction(direction)
: m_switch(*swtch), m_index(index), m_direction(static_cast<int32_t>(direction))
{
}
std::string GetName() const override
@ -321,20 +322,20 @@ private:
}
ControlState GetState() const override
{
if (m_switch == WGI::GameControllerSwitchPosition_Center)
if (m_switch == WGI::GameControllerSwitchPosition::Center)
return 0.0;
// All of the "inbetween" states (e.g. Up-Right) are one-off from the four cardinal
// directions. This tests that the current switch state value is within 1 of the desired
// state.
const auto direction_diff = std::abs(m_switch - m_direction);
const auto direction_diff = std::abs(static_cast<int32_t>(m_switch) - m_direction);
return ControlState(direction_diff <= 1 || direction_diff == 7);
}
private:
const WGI::GameControllerSwitchPosition& m_switch;
const u32 m_index;
const WGI::GameControllerSwitchPosition m_direction;
const int32_t m_direction;
};
class Battery : public Input
@ -355,9 +356,8 @@ private:
class SimpleHaptics : public Output
{
public:
SimpleHaptics(ComPtr<ABI::Windows::Devices::Haptics::ISimpleHapticsController> haptics,
ComPtr<ABI::Windows::Devices::Haptics::ISimpleHapticsControllerFeedback> feedback,
u32 haptics_index)
SimpleHaptics(Haptics::SimpleHapticsController haptics,
Haptics::SimpleHapticsControllerFeedback feedback, u32 haptics_index)
: m_haptics(haptics), m_feedback(feedback), m_haptics_index(haptics_index)
{
}
@ -369,18 +369,25 @@ private:
m_current_state = state;
try
{
if (state)
m_haptics->SendHapticFeedbackWithIntensity(m_feedback.Get(), state);
m_haptics.SendHapticFeedback(m_feedback, state);
else
m_haptics->StopFeedback();
m_haptics.StopFeedback();
}
catch (winrt::hresult_error)
{
// Ignore
}
}
protected:
u32 GetHapticsIndex() const { return m_haptics_index; }
private:
ComPtr<ABI::Windows::Devices::Haptics::ISimpleHapticsController> m_haptics;
ComPtr<ABI::Windows::Devices::Haptics::ISimpleHapticsControllerFeedback> m_feedback;
Haptics::SimpleHapticsController m_haptics;
Haptics::SimpleHapticsControllerFeedback m_feedback;
const u32 m_haptics_index;
ControlState m_current_state = 0;
};
@ -388,9 +395,9 @@ private:
class NamedFeedback final : public SimpleHaptics
{
public:
NamedFeedback(ComPtr<ABI::Windows::Devices::Haptics::ISimpleHapticsController> haptics,
ComPtr<ABI::Windows::Devices::Haptics::ISimpleHapticsControllerFeedback> feedback,
u32 haptics_index, std::string_view feedback_name)
NamedFeedback(Haptics::SimpleHapticsController haptics,
Haptics::SimpleHapticsControllerFeedback feedback, u32 haptics_index,
std::string_view feedback_name)
: SimpleHaptics(haptics, feedback, haptics_index), m_feedback_name(feedback_name)
{
}
@ -404,91 +411,77 @@ private:
};
void PopulateButtons()
{
try
{
// Using RawGameController for buttons because it gives us a nice array instead of a bitmask.
INT32 button_count = 0;
if (SUCCEEDED(m_raw_controller->get_ButtonCount(&button_count)))
m_buttons.resize(button_count);
m_buttons.resize(m_raw_controller.ButtonCount());
u32 i = 0;
for (auto& button : m_buttons)
for (const auto& button : m_buttons)
{
WGI::GameControllerButtonLabel lbl = WGI::GameControllerButtonLabel_None;
m_raw_controller->GetButtonLabel(i, &lbl);
WGI::GameControllerButtonLabel lbl{WGI::GameControllerButtonLabel::None};
try
{
lbl = m_raw_controller.GetButtonLabel(i);
}
catch (winrt::hresult_error)
{
lbl = WGI::GameControllerButtonLabel::None;
}
if (lbl != WGI::GameControllerButtonLabel_None && lbl < wgi_button_names.size())
AddInput(new NamedButton(&button, wgi_button_names[lbl]));
const int32_t button_name_idx = static_cast<int32_t>(lbl);
if (lbl != WGI::GameControllerButtonLabel::None &&
button_name_idx < wgi_button_names.size())
AddInput(new NamedButton(&button, wgi_button_names[button_name_idx]));
else
AddInput(new IndexedButton(&button, i));
++i;
}
}
catch (winrt::hresult_error)
{
// If ButtonCount failed, m_buttons will be zero-sized.
ERROR_LOG_FMT(CONTROLLERINTERFACE, "WGInput: Error populating buttons");
}
}
void PopulateHaptics()
{
WGI::IRawGameController2* rgc2 = nullptr;
if (FAILED(m_raw_controller->QueryInterface(&rgc2)) || !rgc2)
return;
static const std::map<uint16_t, std::string> waveform_name_map{
{Haptics::KnownSimpleHapticsControllerWaveforms::Click(), "Click"},
{Haptics::KnownSimpleHapticsControllerWaveforms::BuzzContinuous(), "Buzz"},
{Haptics::KnownSimpleHapticsControllerWaveforms::RumbleContinuous(), "Rumble"},
};
IVectorView<ABI::Windows::Devices::Haptics::SimpleHapticsController*>* haptics = nullptr;
if (FAILED(rgc2->get_SimpleHapticsControllers(&haptics)) || !haptics)
return;
unsigned int haptic_count = 0;
if (FAILED(haptics->get_Size(&haptic_count)))
return;
for (unsigned int h = 0; h != haptic_count; ++h)
try
{
ComPtr<ABI::Windows::Devices::Haptics::ISimpleHapticsController> haptic;
if (FAILED(haptics->GetAt(h, &haptic)))
continue;
IVectorView<ABI::Windows::Devices::Haptics::SimpleHapticsControllerFeedback*>* feedbacks =
nullptr;
if (FAILED(haptic->get_SupportedFeedback(&feedbacks)) || !feedbacks)
continue;
unsigned int feedback_count = 0;
if (FAILED(haptics->get_Size(&feedback_count)))
continue;
for (unsigned int f = 0; f != feedback_count; ++f)
// SimpleHapticsControllers is available from Windows 1709.
u32 haptics_index = 0;
for (auto haptics_controller : m_raw_controller.SimpleHapticsControllers())
{
ComPtr<ABI::Windows::Devices::Haptics::ISimpleHapticsControllerFeedback> feedback;
if (FAILED(feedbacks->GetAt(f, &feedback)))
continue;
UINT16 waveform = 0;
if (FAILED(feedback->get_Waveform(&waveform)))
continue;
std::string_view waveform_name{};
// Haptic Usage Page from HID spec.
switch (waveform)
for (Haptics::SimpleHapticsControllerFeedback feedback :
haptics_controller.SupportedFeedback())
{
case 0x1003:
waveform_name = "Click";
break;
case 0x1004:
waveform_name = "Buzz";
break;
case 0x1005:
waveform_name = "Rumble";
break;
}
if (!waveform_name.data())
const uint16_t waveform = feedback.Waveform();
auto waveform_name_it = waveform_name_map.find(waveform);
if (waveform_name_it == waveform_name_map.end())
{
WARN_LOG_FMT(CONTROLLERINTERFACE, "WGInput: Unknown haptics feedback waveform: 0x{:04x}.",
waveform);
WARN_LOG_FMT(CONTROLLERINTERFACE,
"WGInput: Unhandled haptics feedback waveform: 0x{:04x}.", waveform);
continue;
}
AddOutput(new NamedFeedback(haptic, feedback, h, waveform_name));
AddOutput(new NamedFeedback(haptics_controller, feedback, haptics_index,
waveform_name_it->second));
}
++haptics_index;
}
}
catch (winrt::hresult_error)
{
// Don't need to cleanup any state. It's OK if some outputs were added.
ERROR_LOG_FMT(CONTROLLERINTERFACE, "WGInput: Error populating haptics");
}
}
@ -499,60 +492,80 @@ private:
void UpdateInput() override
{
// IRawGameController:
const auto button_count = UINT32(m_buttons.size());
const auto switch_count = UINT32(m_switches.size());
const auto axis_count = UINT32(m_axes.size());
UINT64 timestamp = 0;
const HRESULT raw_result = m_raw_controller->GetCurrentReading(
button_count, m_buttons.data(), switch_count, m_switches.data(), axis_count, m_axes.data(),
&timestamp);
if (FAILED(raw_result))
static_assert(sizeof(bool) == sizeof(ButtonValueType));
// This cludge is needed to workaround GetCurrentReading wanting array_view<bool>, while
// using std::vector<bool> would create a bit-packed array, which isn't wanted. So, we keep
// vector<u8> and view it as array<bool>.
auto buttons =
winrt::array_view<bool>(reinterpret_cast<winrt::array_view<bool>::pointer>(&m_buttons[0]),
static_cast<winrt::array_view<bool>::size_type>(m_buttons.size()));
try
{
m_raw_controller.GetCurrentReading(buttons, m_switches, m_axes);
}
catch (winrt::hresult_error error)
{
ERROR_LOG_FMT(CONTROLLERINTERFACE,
"WGInput: IRawGameController::GetCurrentReading failed: {}",
Common::HRWrap(raw_result));
"WGInput: IRawGameController::GetCurrentReading failed: {:x}", error.code());
}
// IGamepad:
if (m_gamepad)
{
const HRESULT gamepad_result = m_gamepad->GetCurrentReading(&m_gamepad_reading);
if (FAILED(gamepad_result))
try
{
ERROR_LOG_FMT(CONTROLLERINTERFACE, "WGInput: IGamepad::GetCurrentReading failed: {}",
Common::HRWrap(gamepad_result));
m_gamepad_reading = m_gamepad.GetCurrentReading();
}
catch (winrt::hresult_error error)
{
ERROR_LOG_FMT(CONTROLLERINTERFACE, "WGInput: IGamepad::GetCurrentReading failed: {:x}",
error.code());
}
}
// IGameControllerBatteryInfo:
if (m_controller_battery && !UpdateBatteryLevel())
{
if (!UpdateBatteryLevel())
DEBUG_LOG_FMT(CONTROLLERINTERFACE, "WGInput: UpdateBatteryLevel failed.");
}
}
void UpdateMotors() { m_gamepad->put_Vibration(m_state_out); }
void UpdateMotors()
{
try
{
m_gamepad.Vibration(m_state_out);
}
catch (winrt::hresult_error)
{
// Ignore
}
}
bool UpdateBatteryLevel()
{
ABI::Windows::Devices::Power::IBatteryReport* report = nullptr;
if (FAILED(m_controller_battery->TryGetBatteryReport(&report)) || !report)
try
{
const winrt::Windows::Devices::Power::BatteryReport report =
m_raw_controller.TryGetBatteryReport();
if (!report)
return false;
using ABI::Windows::System::Power::BatteryStatus;
BatteryStatus status;
if (FAILED(report->get_Status(&status)))
return false;
// TryGetBatteryReport causes a memleak of 0x58 bytes each time it is called, up to at
// least Windows 21H2. A hack to fix the memleak is recorded here for posterity.
// auto report_ = *(uintptr_t***)&report;
// auto rc = &report_[0x40 / 8][0x30 / 8];
// if (*rc == 2)
// (*rc)--;
using winrt::Windows::System::Power::BatteryStatus;
const BatteryStatus status = report.Status();
switch (status)
{
case BatteryStatus::BatteryStatus_NotPresent:
case BatteryStatus::NotPresent:
m_battery_level = 0;
return true;
case BatteryStatus::BatteryStatus_Idle:
case BatteryStatus::BatteryStatus_Charging:
case BatteryStatus::Idle:
case BatteryStatus::Charging:
m_battery_level = BATTERY_INPUT_MAX_VALUE;
return true;
@ -560,156 +573,140 @@ private:
break;
}
ABI::Windows::Foundation::IReference<int>*i_remaining = nullptr, *i_full = nullptr;
int remaining_value = 0;
int full_value = 0;
if (report && SUCCEEDED(report->get_RemainingCapacityInMilliwattHours(&i_remaining)) &&
i_remaining && SUCCEEDED(i_remaining->get_Value(&remaining_value)) &&
SUCCEEDED(report->get_FullChargeCapacityInMilliwattHours(&i_full)) && i_full &&
SUCCEEDED(i_full->get_Value(&full_value)))
{
const int32_t full_value = report.FullChargeCapacityInMilliwattHours().GetInt32();
const int32_t remaining_value = report.RemainingCapacityInMilliwattHours().GetInt32();
m_battery_level = BATTERY_INPUT_MAX_VALUE * remaining_value / full_value;
return true;
}
catch (winrt::hresult_error)
{
return false;
}
}
const std::string m_name;
ComPtr<WGI::IRawGameController> const m_raw_controller;
const WGI::RawGameController m_raw_controller;
std::vector<ButtonValueType> m_buttons;
std::vector<WGI::GameControllerSwitchPosition> m_switches;
std::vector<double> m_axes;
WGI::IGamepad* m_gamepad = nullptr;
WGI::Gamepad m_gamepad = nullptr;
WGI::GamepadReading m_gamepad_reading{};
WGI::GamepadVibration m_state_out{};
WGI::IGameControllerBatteryInfo* m_controller_battery = nullptr;
ControlState m_battery_level = 0;
};
static bool LoadFunctionPointers()
{
static Common::DynamicLibrary winrt_l1_1_0_handle;
static Common::DynamicLibrary winrt_string_l1_1_0_handle;
if (!winrt_l1_1_0_handle.IsOpen() && !winrt_string_l1_1_0_handle.IsOpen())
{
Common::DynamicLibrary kernelBase("KernelBase.dll");
if (!kernelBase.IsOpen())
return false;
static thread_local bool s_initialized_winrt;
static winrt::event_token s_event_added, s_event_removed;
void* const IsApiSetImplemented_address = kernelBase.GetSymbolAddress("IsApiSetImplemented");
if (!IsApiSetImplemented_address)
return false;
if (!static_cast<PIsApiSetImplemented>(IsApiSetImplemented_address)(
"api-ms-win-core-winrt-l1-1-0"))
static bool COMIsInitialized()
{
return false;
}
if (!static_cast<PIsApiSetImplemented>(IsApiSetImplemented_address)(
"api-ms-win-core-winrt-string-l1-1-0"))
{
return false;
APTTYPE apt_type{};
APTTYPEQUALIFIER apt_qualifier{};
return CoGetApartmentType(&apt_type, &apt_qualifier) == S_OK;
}
winrt_l1_1_0_handle.Open("api-ms-win-core-winrt-l1-1-0.dll");
winrt_string_l1_1_0_handle.Open("api-ms-win-core-winrt-string-l1-1-0.dll");
static void AddDevice(const WGI::RawGameController& raw_game_controller)
{
// Get user-facing device name if available. Otherwise generate a name from vid/pid.
std::string device_name;
try
{
device_name = StripWhitespace(WStringToUTF8(raw_game_controller.DisplayName().c_str()));
if (device_name.empty())
{
const u16 vid = raw_game_controller.HardwareVendorId();
const u16 pid = raw_game_controller.HardwareProductId();
device_name = fmt::format("Device_{:04x}:{:04x}", vid, pid);
INFO_LOG_FMT(CONTROLLERINTERFACE, "WGInput: Empty device name, using {}", device_name);
}
}
catch (winrt::hresult_error)
{
device_name = "Device";
ERROR_LOG_FMT(CONTROLLERINTERFACE, "WGInput: Failed to get device name, using {}", device_name);
}
if (!winrt_l1_1_0_handle.IsOpen() || !winrt_string_l1_1_0_handle.IsOpen())
return false;
try
{
WGI::Gamepad gamepad = WGI::Gamepad::FromGameController(raw_game_controller);
// Note that gamepad may be nullptr here. The Device class will deal with this.
auto dev = std::make_shared<Device>(std::move(device_name), raw_game_controller, gamepad);
g_RoInitialize_address =
static_cast<PRoInitialize>(winrt_l1_1_0_handle.GetSymbolAddress("RoInitialize"));
if (!g_RoInitialize_address)
return false;
g_RoUninitialize_address =
static_cast<PRoUninitialize>(winrt_l1_1_0_handle.GetSymbolAddress("RoUninitialize"));
if (!g_RoUninitialize_address)
return false;
g_RoGetActivationFactory_address = static_cast<PRoGetActivationFactory>(
winrt_l1_1_0_handle.GetSymbolAddress("RoGetActivationFactory"));
if (!g_RoGetActivationFactory_address)
return false;
g_WindowsCreateStringReference_address = static_cast<PWindowsCreateStringReference>(
winrt_string_l1_1_0_handle.GetSymbolAddress("WindowsCreateStringReference"));
if (!g_WindowsCreateStringReference_address)
return false;
g_WindowsGetStringRawBuffer_address = static_cast<PWindowsGetStringRawBuffer>(
winrt_string_l1_1_0_handle.GetSymbolAddress("WindowsGetStringRawBuffer"));
if (!g_WindowsGetStringRawBuffer_address)
return false;
return true;
// Only add if it has some inputs/outputs.
if (dev->Inputs().size() || dev->Outputs().size())
g_controller_interface.AddDevice(std::move(dev));
}
catch (winrt::hresult_error)
{
ERROR_LOG_FMT(CONTROLLERINTERFACE, "WGInput: Failed to add device {}", device_name);
}
}
static void RemoveDevice(const WGI::RawGameController& raw_game_controller)
{
g_controller_interface.RemoveDevice([&](const auto* dev) {
if (dev->GetSource() != SOURCE_NAME)
return false;
return static_cast<const Device*>(dev)->GetRawGameController() == raw_game_controller;
});
}
#pragma warning(push)
// 'winrt::impl::implements_delegate<winrt::Windows::Foundation::EventHandler<winrt::Windows::Gaming::Input::RawGameController>,H>':
// class has virtual functions, but its non-trivial destructor is not virtual; instances of this
// class may not be destructed correctly
// (H is the lambda)
#pragma warning(disable : 4265)
void Init()
{
if (g_runtime_initialized)
return;
if (!LoadFunctionPointers())
if (!COMIsInitialized())
{
ERROR_LOG_FMT(CONTROLLERINTERFACE, "WGInput: System lacks support, skipping init.");
return;
// NOTE: Devices in g_controller_interface should only be accessed by threads that have had
// winrt (com) initialized.
winrt::init_apartment();
s_initialized_winrt = true;
}
const HRESULT hr = g_RoInitialize_address(RO_INIT_MULTITHREADED);
switch (hr)
try
{
case S_OK:
g_runtime_initialized = true;
g_runtime_needs_deinit = true;
break;
// These events will be invoked from WGI-managed threadpool.
s_event_added = WGI::RawGameController::RawGameControllerAdded(
[](auto&&, const WGI::RawGameController raw_game_controller) {
RemoveDevice(raw_game_controller);
AddDevice(raw_game_controller);
});
case S_FALSE:
case RPC_E_CHANGED_MODE:
g_runtime_initialized = true;
break;
default:
ERROR_LOG_FMT(CONTROLLERINTERFACE, "WGInput: RoInitialize failed: {}", Common::HRWrap(hr));
break;
s_event_removed = WGI::RawGameController::RawGameControllerRemoved(
[](auto&&, const WGI::RawGameController raw_game_controller) {
RemoveDevice(raw_game_controller);
});
}
catch (winrt::hresult_error)
{
ERROR_LOG_FMT(CONTROLLERINTERFACE, "WGInput: Failed to register event handlers");
}
}
#pragma warning(pop)
void DeInit()
{
if (!g_runtime_initialized)
return;
WGI::RawGameController::RawGameControllerAdded(s_event_added);
WGI::RawGameController::RawGameControllerRemoved(s_event_removed);
if (g_runtime_needs_deinit)
if (s_initialized_winrt)
{
g_RoUninitialize_address();
g_runtime_needs_deinit = false;
winrt::uninit_apartment();
s_initialized_winrt = false;
}
g_runtime_initialized = false;
}
template <unsigned int size>
static HRESULT WindowsCreateStringReferenceAutoSizeWrapper(wchar_t const (&source_string)[size],
HSTRING_HEADER* hstring_header,
HSTRING* hstring)
{
return g_WindowsCreateStringReference_address(source_string, size - 1, hstring_header, hstring);
}
void PopulateDevices()
{
if (!g_runtime_initialized)
return;
g_controller_interface.RemoveDevice(
[](const auto* dev) { return dev->GetSource() == SOURCE_NAME; });
// WGI Interfaces to potentially use:
// Gamepad: Buttons, 2x Sticks and 2x Triggers, 4x Vibration Motors
// RawGameController: Buttons, Switches (Hats), Axes, Haptics
@ -719,95 +716,22 @@ void PopulateDevices()
// RacingWheel: Buttons, Clutch, Handbrake, PatternShifterGear, Throttle, Wheel, WheelMotor
// UINavigationController: Directions, Scrolling, etc.
HSTRING_HEADER header_raw_game_controller;
HSTRING hstr_raw_game_controller;
HRESULT hr;
if (FAILED(hr = WindowsCreateStringReferenceAutoSizeWrapper(
L"Windows.Gaming.Input.RawGameController", &header_raw_game_controller,
&hstr_raw_game_controller)))
{
ERROR_LOG_FMT(CONTROLLERINTERFACE, "WGInput: Failed to create string reference: {}",
Common::HRWrap(hr));
return;
}
// RawGameController available from Windows 15063.
// properties added in 1709: DisplayName, NonRoamableId, SimpleHapticsControllers
HSTRING_HEADER header_gamepad;
HSTRING hstr_gamepad;
if (FAILED(hr = WindowsCreateStringReferenceAutoSizeWrapper(L"Windows.Gaming.Input.Gamepad",
&header_gamepad, &hstr_gamepad)))
try
{
ERROR_LOG_FMT(CONTROLLERINTERFACE, "WGInput: Failed to create string reference: {}",
Common::HRWrap(hr));
return;
}
ComPtr<WGI::IRawGameControllerStatics> raw_stats;
if (FAILED(hr = g_RoGetActivationFactory_address(
hstr_raw_game_controller, __uuidof(WGI::IRawGameControllerStatics), &raw_stats)))
for (const WGI::RawGameController& raw_game_controller :
WGI::RawGameController::RawGameControllers())
{
ERROR_LOG_FMT(CONTROLLERINTERFACE, "WGInput: Failed to get IRawGameControllerStatics: {}",
Common::HRWrap(hr));
return;
}
ComPtr<WGI::IGamepadStatics2> gamepad_stats;
if (FAILED(hr = g_RoGetActivationFactory_address(hstr_gamepad, __uuidof(WGI::IGamepadStatics2),
&gamepad_stats)))
{
ERROR_LOG_FMT(CONTROLLERINTERFACE, "WGInput: Failed to get IGamepadStatics2: {}",
Common::HRWrap(hr));
return;
}
IVectorView<WGI::RawGameController*>* raw_controllers;
if (FAILED(hr = raw_stats->get_RawGameControllers(&raw_controllers)))
{
ERROR_LOG_FMT(CONTROLLERINTERFACE, "WGInput: get_RawGameControllers failed: {}",
Common::HRWrap(hr));
return;
}
unsigned int raw_count = 0;
raw_controllers->get_Size(&raw_count);
for (unsigned i = 0; i != raw_count; ++i)
{
ComPtr<WGI::IRawGameController> raw_controller;
if (SUCCEEDED(raw_controllers->GetAt(i, &raw_controller)) && raw_controller)
{
std::string device_name;
// Attempt to get the controller's name.
WGI::IRawGameController2* rgc2 = nullptr;
if (SUCCEEDED(hr = raw_controller->QueryInterface(&rgc2)) && rgc2)
{
HSTRING hstr = {};
if (SUCCEEDED(hr = rgc2->get_DisplayName(&hstr)) && hstr)
{
device_name =
StripWhitespace(WStringToUTF8(g_WindowsGetStringRawBuffer_address(hstr, nullptr)));
RemoveDevice(raw_game_controller);
AddDevice(raw_game_controller);
}
}
if (device_name.empty())
catch (winrt::hresult_error)
{
ERROR_LOG_FMT(CONTROLLERINTERFACE, "WGInput: Failed to get device name: {}",
Common::HRWrap(hr));
// Set a default name if we couldn't query the name or it was empty.
device_name = "Device";
}
WGI::IGameController* gamecontroller = nullptr;
WGI::IGamepad* gamepad = nullptr;
if (SUCCEEDED(raw_controller->QueryInterface(&gamecontroller)) && gamecontroller)
gamepad_stats->FromGameController(gamecontroller, &gamepad);
// Note that gamepad may be nullptr here. The Device class will deal with this.
auto dev = std::make_shared<Device>(std::move(device_name), raw_controller, gamepad);
// Only add if it has some inputs/outputs.
if (dev->Inputs().size() || dev->Outputs().size())
g_controller_interface.AddDevice(std::move(dev));
}
// Only reach here if RawGameControllers() failed
ERROR_LOG_FMT(CONTROLLERINTERFACE, "WGInput: PopulateDevices failed");
}
}

151
Source/Core/InputCommon/ControllerInterface/Win32/Win32.cpp
View File

@ -3,35 +3,38 @@
#include "InputCommon/ControllerInterface/Win32/Win32.h"
#include <windows.h>
#include <Windows.h>
#include <cfgmgr32.h>
// must be before hidclass
#include <initguid.h>
#include <hidclass.h>
#include <array>
#include <future>
#include <mutex>
#include <thread>
#include "Common/Flag.h"
#include "Common/HRWrap.h"
#include "Common/Logging/Log.h"
#include "Common/ScopeGuard.h"
#include "Common/Thread.h"
#include "InputCommon/ControllerInterface/DInput/DInput.h"
#include "InputCommon/ControllerInterface/WGInput/WGInput.h"
#include "InputCommon/ControllerInterface/XInput/XInput.h"
constexpr UINT WM_DOLPHIN_STOP = WM_USER;
#pragma comment(lib, "OneCoreUAP.Lib")
// Dolphin's render window
static HWND s_hwnd;
// Windows messaging window (hidden)
static HWND s_message_window;
static std::thread s_thread;
static std::mutex s_populate_mutex;
// TODO is this really needed?
static Common::Flag s_first_populate_devices_asked;
static HCMNOTIFICATION s_notify_handle;
static LRESULT CALLBACK WindowProc(HWND hwnd, UINT message, WPARAM wparam, LPARAM lparam)
_Pre_satisfies_(EventDataSize >= sizeof(CM_NOTIFY_EVENT_DATA)) static DWORD CALLBACK
OnDevicesChanged(_In_ HCMNOTIFICATION hNotify, _In_opt_ PVOID Context,
_In_ CM_NOTIFY_ACTION Action,
_In_reads_bytes_(EventDataSize) PCM_NOTIFY_EVENT_DATA EventData,
_In_ DWORD EventDataSize)
{
if (message == WM_INPUT_DEVICE_CHANGE)
if (Action == CM_NOTIFY_ACTION_DEVICEINTERFACEARRIVAL ||
Action == CM_NOTIFY_ACTION_DEVICEINTERFACEREMOVAL)
{
// Windows automatically sends this message before we ask for it and before we are "ready" to
// listen for it.
@ -43,147 +46,63 @@ static LRESULT CALLBACK WindowProc(HWND hwnd, UINT message, WPARAM wparam, LPARA
g_controller_interface.PlatformPopulateDevices([] {
ciface::DInput::PopulateDevices(s_hwnd);
ciface::XInput::PopulateDevices();
ciface::WGInput::PopulateDevices();
});
}
}
return DefWindowProc(hwnd, message, wparam, lparam);
return ERROR_SUCCESS;
}
void ciface::Win32::Init(void* hwnd)
{
s_hwnd = static_cast<HWND>(hwnd);
XInput::Init();
WGInput::Init();
std::promise<HWND> message_window_promise;
s_thread = std::thread([&message_window_promise] {
Common::SetCurrentThreadName("ciface::Win32 Message Loop");
HWND message_window = nullptr;
Common::ScopeGuard promise_guard([&] { message_window_promise.set_value(message_window); });
HRESULT hr = CoInitializeEx(nullptr, COINIT_APARTMENTTHREADED);
if (FAILED(hr))
CM_NOTIFY_FILTER notify_filter{.cbSize = sizeof(notify_filter),
.FilterType = CM_NOTIFY_FILTER_TYPE_DEVICEINTERFACE,
.u{.DeviceInterface{.ClassGuid = GUID_DEVINTERFACE_HID}}};
const CONFIGRET cfg_rv =
CM_Register_Notification(&notify_filter, nullptr, OnDevicesChanged, &s_notify_handle);
if (cfg_rv != CR_SUCCESS)
{
ERROR_LOG_FMT(CONTROLLERINTERFACE, "CoInitializeEx failed: {}", Common::HRWrap(hr));
return;
ERROR_LOG_FMT(CONTROLLERINTERFACE, "CM_Register_Notification failed: {:x}", cfg_rv);
}
Common::ScopeGuard uninit([] { CoUninitialize(); });
const auto window_name = TEXT("DolphinWin32ControllerInterface");
WNDCLASSEX window_class_info{};
window_class_info.cbSize = sizeof(window_class_info);
window_class_info.lpfnWndProc = WindowProc;
window_class_info.hInstance = GetModuleHandle(nullptr);
window_class_info.lpszClassName = window_name;
ATOM window_class = RegisterClassEx(&window_class_info);
if (!window_class)
{
NOTICE_LOG_FMT(CONTROLLERINTERFACE, "RegisterClassEx failed: {}",
Common::HRWrap(GetLastError()));
return;
}
Common::ScopeGuard unregister([&window_class] {
if (!UnregisterClass(MAKEINTATOM(window_class), GetModuleHandle(nullptr)))
ERROR_LOG_FMT(CONTROLLERINTERFACE, "UnregisterClass failed: {}",
Common::HRWrap(GetLastError()));
});
message_window = CreateWindowEx(0, window_name, nullptr, 0, 0, 0, 0, 0, HWND_MESSAGE, nullptr,
nullptr, nullptr);
promise_guard.Exit();
if (!message_window)
{
ERROR_LOG_FMT(CONTROLLERINTERFACE, "CreateWindowEx failed: {}",
Common::HRWrap(GetLastError()));
return;
}
Common::ScopeGuard destroy([&] {
if (!DestroyWindow(message_window))
ERROR_LOG_FMT(CONTROLLERINTERFACE, "DestroyWindow failed: {}",
Common::HRWrap(GetLastError()));
});
std::array<RAWINPUTDEVICE, 2> devices;
// game pad devices
devices[0].usUsagePage = 0x01;
devices[0].usUsage = 0x05;
devices[0].dwFlags = RIDEV_DEVNOTIFY;
devices[0].hwndTarget = message_window;
// joystick devices
devices[1].usUsagePage = 0x01;
devices[1].usUsage = 0x04;
devices[1].dwFlags = RIDEV_DEVNOTIFY;
devices[1].hwndTarget = message_window;
if (!RegisterRawInputDevices(devices.data(), static_cast<UINT>(devices.size()),
static_cast<UINT>(sizeof(decltype(devices)::value_type))))
{
ERROR_LOG_FMT(CONTROLLERINTERFACE, "RegisterRawInputDevices failed: {}", GetLastError());
return;
}
MSG msg;
while (GetMessage(&msg, nullptr, 0, 0) > 0)
{
TranslateMessage(&msg);
DispatchMessage(&msg);
if (msg.message == WM_DOLPHIN_STOP)
break;
}
});
s_message_window = message_window_promise.get_future().get();
}
void ciface::Win32::PopulateDevices(void* hwnd)
{
if (s_thread.joinable())
{
s_hwnd = static_cast<HWND>(hwnd);
// To avoid blocking this thread until the async population has finished, directly do it here
// (we need the DInput Keyboard and Mouse "default" device to always be added without any wait).
std::lock_guard lk_population(s_populate_mutex);
s_first_populate_devices_asked.Set();
ciface::DInput::PopulateDevices(s_hwnd);
ciface::XInput::PopulateDevices();
ciface::WGInput::PopulateDevices();
}
else
{
ERROR_LOG_FMT(CONTROLLERINTERFACE,
"win32 asked to populate devices, but device thread isn't running");
}
}
void ciface::Win32::ChangeWindow(void* hwnd)
{
if (s_thread.joinable()) // "Has init?"
{
s_hwnd = static_cast<HWND>(hwnd);
std::lock_guard lk_population(s_populate_mutex);
ciface::DInput::ChangeWindow(s_hwnd);
}
}
void ciface::Win32::DeInit()
{
NOTICE_LOG_FMT(CONTROLLERINTERFACE, "win32 DeInit");
if (s_thread.joinable())
{
PostMessage(s_message_window, WM_DOLPHIN_STOP, 0, 0);
s_thread.join();
s_message_window = nullptr;
s_first_populate_devices_asked.Clear();
DInput::DeInit();
}
s_hwnd = nullptr;
if (s_notify_handle)
{
const CONFIGRET cfg_rv = CM_Unregister_Notification(s_notify_handle);
if (cfg_rv != CR_SUCCESS)
{
ERROR_LOG_FMT(CONTROLLERINTERFACE, "CM_Unregister_Notification failed: {:x}", cfg_rv);
}
s_notify_handle = nullptr;
}
XInput::DeInit();
WGInput::DeInit();
}