mirror of
https://github.com/Thracky/GlosSI.git
synced 2024-11-19 03:25:29 +00:00
219 lines
7.0 KiB
C++
219 lines
7.0 KiB
C++
/*
|
|
Copyright 2018 Peter Repukat - FlatspotSoftware
|
|
|
|
Licensed under the Apache License, Version 2.0 (the "License");
|
|
you may not use this file except in compliance with the License.
|
|
You may obtain a copy of the License at
|
|
|
|
http://www.apache.org/licenses/LICENSE-2.0
|
|
|
|
Unless required by applicable law or agreed to in writing, software
|
|
distributed under the License is distributed on an "AS IS" BASIS,
|
|
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
See the License for the specific language governing permissions and
|
|
limitations under the License.
|
|
*/
|
|
#include "VirtualControllerThread.h"
|
|
|
|
|
|
#include "../common/loguru.hpp"
|
|
|
|
|
|
VirtualControllerThread::VirtualControllerThread(const int delay)
|
|
{
|
|
driver_ = vigem_alloc();
|
|
|
|
if (!VIGEM_SUCCESS(vigem_connect(driver_)))
|
|
{
|
|
LOG_F(ERROR, "initializing ViGem!");
|
|
MessageBoxW(NULL, L"Error initializing ViGem!", L"GloSC-SteamTarget", MB_OK);
|
|
b_should_run_ = false;
|
|
}
|
|
|
|
for (auto & target : vt_x360_)
|
|
{
|
|
target = vigem_target_x360_alloc();
|
|
}
|
|
|
|
seven_ = IsWindows7OrGreater() != IsWindows8OrGreater();
|
|
delay_ = delay;
|
|
}
|
|
|
|
|
|
VirtualControllerThread::~VirtualControllerThread()
|
|
{
|
|
if (controller_thread_.joinable())
|
|
controller_thread_.join();
|
|
vigem_disconnect(driver_);
|
|
}
|
|
|
|
void VirtualControllerThread::run()
|
|
{
|
|
b_should_run_ = true;
|
|
controller_thread_ = std::thread(&VirtualControllerThread::controllerLoop, this);
|
|
}
|
|
|
|
void VirtualControllerThread::stop()
|
|
{
|
|
b_should_run_ = false;
|
|
for (auto & target : vt_x360_)
|
|
{
|
|
vigem_target_remove(driver_, target);
|
|
}
|
|
}
|
|
|
|
|
|
bool VirtualControllerThread::isRunning() const
|
|
{
|
|
return b_should_run_;
|
|
}
|
|
|
|
void VirtualControllerThread::controllerLoop()
|
|
{
|
|
sf::Clock waitForHookTimer;
|
|
while (b_should_run_)
|
|
{
|
|
sf_clock_.restart();
|
|
|
|
// We have to retrieve the XInputGetState function by loading it via GetProcAdress
|
|
// otherwise we get calls to a jumptable, jumping to the real function
|
|
// We can't have this if we wan't to dynamically unpatch and repatch Valve's XInput hook
|
|
// Also wait a second, jut to be sure Steam has done it's hooking thing...
|
|
if (x_get_state_ == nullptr && waitForHookTimer.getElapsedTime().asSeconds() > 1)
|
|
{
|
|
HMODULE xinputmod = nullptr;
|
|
|
|
const HANDLE hProcess = GetCurrentProcess();
|
|
HMODULE hMods[1024];
|
|
DWORD cbNeeded;
|
|
EnumProcessModules(hProcess, hMods, sizeof(hMods), &cbNeeded);
|
|
for (int i = 0; i < (cbNeeded / sizeof(HMODULE)); i++)
|
|
{
|
|
TCHAR szModName[MAX_PATH];
|
|
|
|
if (GetModuleBaseName(hProcess, hMods[i], szModName,
|
|
sizeof(szModName) / sizeof(TCHAR)))
|
|
{
|
|
std::wstring name(&szModName[0]);
|
|
auto& f = std::use_facet<std::ctype<wchar_t>>(std::locale());
|
|
f.tolower(&name[0], &name[0] + name.size());
|
|
if (name.find(std::wstring(L"xinput")) != std::wstring::npos)
|
|
{
|
|
xinputmod = hMods[i];
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
const XInputGetState_t realXgstate = reinterpret_cast<XInputGetState_t>(GetProcAddress(xinputmod, "XInputGetState"));
|
|
|
|
//std::cout << "realXgstate: " << std::hex << realXgstate << "\n";
|
|
for (int i = 0; i < 5; i++)
|
|
{
|
|
valve_hook_bytes_[i] = *reinterpret_cast<uint8_t*>(reinterpret_cast<uint64_t>(*realXgstate) + i);
|
|
}
|
|
|
|
x_get_state_ = realXgstate;
|
|
controller_count_ = 1;
|
|
}
|
|
|
|
if (x_get_state_ != nullptr)
|
|
{
|
|
for (int i = 0; i < XUSER_MAX_COUNT; i++)
|
|
{
|
|
////////
|
|
|
|
//Call the hooked, as well as the 'real' XInputGetState function to determine if a controller is real of 'fake' (from Steam)
|
|
XINPUT_STATE state = { 0 };
|
|
const DWORD result = XInputGetStateWrapper(i, &state);
|
|
XINPUT_STATE state2 = { 0 };
|
|
const DWORD result2 = callRealXinputGetState(i, &state2);
|
|
|
|
if (result == ERROR_SUCCESS)
|
|
{
|
|
if ( (result2 != ERROR_SUCCESS) == seven_ ) //for whatever reason, the second call also returns true on win7, false (as it should(?)) otherwise.
|
|
{
|
|
// By using VID and PID of Valve's SteamController, Steam doesn't give us ANOTHER "fake" XInput device
|
|
// Leading to endless pain and suffering.
|
|
// Or really, leading to pluggin in one virtual controller after another and mirroring inputs
|
|
// Also annoying the shit out of the user when they open the overlay as steam prompts to setup new XInput devices
|
|
// Also avoiding any fake inputs from Valve's default controllerprofile
|
|
// -> Leading to endless pain and suffering
|
|
vigem_target_set_vid(vt_x360_[i], 0x28de); //Valve SteamController VID
|
|
vigem_target_set_pid(vt_x360_[i], 0x1102); //Valve SteamController PID
|
|
|
|
const int vigem_res = vigem_target_add(driver_, vt_x360_[i]);
|
|
if (vigem_res == VIGEM_ERROR_TARGET_UNINITIALIZED)
|
|
{
|
|
vt_x360_[i] = vigem_target_x360_alloc();
|
|
}
|
|
if (vigem_res == VIGEM_ERROR_NONE)
|
|
{
|
|
LOG_F(INFO, "Plugged in controller %d", vigem_target_get_index(vt_x360_[i]));
|
|
vigem_target_x360_register_notification(driver_, vt_x360_[i],
|
|
reinterpret_cast<PVIGEM_X360_NOTIFICATION>(&VirtualControllerThread::
|
|
controllerCallback));
|
|
}
|
|
}
|
|
|
|
if (vt_x360_[i] != nullptr)
|
|
vigem_target_x360_update(driver_, vt_x360_[i], *reinterpret_cast<XUSB_REPORT*>(&state.Gamepad));
|
|
}
|
|
else
|
|
{
|
|
if (VIGEM_SUCCESS(vigem_target_remove(driver_, vt_x360_[i])))
|
|
{
|
|
LOG_F(INFO, "Unplugged controller %d", vigem_target_get_index(vt_x360_[i]));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
tick_time_ = sf_clock_.getElapsedTime().asMicroseconds();
|
|
if (tick_time_ < delay_)
|
|
{
|
|
std::this_thread::sleep_for(std::chrono::microseconds(delay_ - tick_time_));
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
void VirtualControllerThread::controllerCallback(PVIGEM_CLIENT client, PVIGEM_TARGET Target, UCHAR LargeMotor, UCHAR SmallMotor, UCHAR LedNumber)
|
|
{
|
|
XINPUT_VIBRATION vibration;
|
|
ZeroMemory(&vibration, sizeof(XINPUT_VIBRATION));
|
|
vibration.wLeftMotorSpeed = LargeMotor * 0xff; //Controllers only use 1 byte, XInput-API uses two, ViGEm also only uses one, like the hardware does, so we have to multiply
|
|
vibration.wRightMotorSpeed = SmallMotor * 0xff; //Yeah yeah I do know about bitshifting and the multiplication not being 100% correct...
|
|
|
|
XInputSetState(vigem_target_get_index(Target)-1, &vibration);
|
|
}
|
|
|
|
DWORD VirtualControllerThread::XInputGetStateWrapper(DWORD dwUserIndex, XINPUT_STATE* pState)
|
|
{
|
|
return XInputGetState(dwUserIndex, pState);
|
|
}
|
|
|
|
DWORD VirtualControllerThread::callRealXinputGetState(DWORD dwUserIndex, XINPUT_STATE* pState)
|
|
{
|
|
DWORD dwOldProtect, dwBkup;
|
|
|
|
auto* Address = reinterpret_cast<BYTE*>(x_get_state_);
|
|
VirtualProtect(Address, op_patch_lenght, PAGE_EXECUTE_READWRITE, &dwOldProtect); //Change permissions of memory..
|
|
for (DWORD i = 0; i < op_patch_lenght; i++) //unpatch Valve's hook
|
|
{
|
|
*(Address + i) = real_bytes[i];
|
|
}
|
|
|
|
const DWORD ret = x_get_state_(dwUserIndex, pState); //Cal REAL XInputGetState...
|
|
|
|
for (int i = 0; i < op_patch_lenght; i++) //repatch Valve's hook
|
|
{
|
|
*(Address + i) = valve_hook_bytes_[i];
|
|
}
|
|
VirtualProtect(Address, op_patch_lenght, dwOldProtect, &dwBkup); //Revert permission change...
|
|
|
|
return ret;
|
|
}
|
|
|
|
|