GlosSI/SteamTarget/VirtualControllerThread.cpp

/*
Copyright 2018-2019 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<PFN_VIGEM_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;
}