GlosSI-fork/SteamTarget/VirtualControllerThread.cpp

/*
Copyright 2016 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"
//

VirtualControllerThread::VirtualControllerThread()
{
	driver = vigem_alloc();

	if (!VIGEM_SUCCESS(vigem_connect(driver)))
	{
		std::cout << "Error initializing ViGem!" << std::endl;
		MessageBoxW(NULL, L"Error initializing ViGem!", L"GloSC-SteamTarget", MB_OK);
		bShouldRun = false;
	}

	for (int i = 0; i < XUSER_MAX_COUNT; i++)
	{
		vtX360[i] = vigem_target_x360_alloc();
	}

	seven = IsWindows7OrGreater() != IsWindows8OrGreater();
}


VirtualControllerThread::~VirtualControllerThread()
{
	if (controllerThread.joinable())
		controllerThread.join();
	vigem_disconnect(driver);
}

void VirtualControllerThread::run()
{
	bShouldRun = true;
	controllerThread = std::thread(&VirtualControllerThread::controllerLoop, this);
}

void VirtualControllerThread::stop()
{
	bShouldRun = false;
	for (int i = 0; i < XUSER_MAX_COUNT; i++)
	{
		vigem_target_remove(driver, vtX360[i]);
	}
}


bool VirtualControllerThread::isRunning()
{
	return bShouldRun;
}

void VirtualControllerThread::controllerLoop()
{
	DWORD result;
	DWORD result2;
	sf::Clock waitForHookTimer;
	while (bShouldRun)
	{
		sfClock.restart();

		// We have to retrieve the XInputGetState function by loading it via GetProcAdress
		// otherwise the M$ compiler 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 (XGetState == nullptr && waitForHookTimer.getElapsedTime().asSeconds() > 1)
		{
			HMODULE xinputmod = nullptr;

			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;
					}
				}
			}

			XInputGetState_t realXgstate = reinterpret_cast<XInputGetState_t>(GetProcAddress(xinputmod, "XInputGetState"));

			std::cout << "realXgstate: " << std::hex << realXgstate << "\n";
			for (int i = 0; i < 5; i++)
			{
				valveHookBytes[i] = *reinterpret_cast<uint8_t*>(reinterpret_cast<uint64_t>(*realXgstate) + i);
			}

			XGetState = realXgstate;
			controllerCount = 1;
		}

		if (XGetState != nullptr)
		{
			for (int i = 0; i < XUSER_MAX_COUNT; i++)
			{
				////////
				XINPUT_STATE state = { 0 };
				result = XInputGetStateWrapper(i, &state);
				XINPUT_STATE state2 = { 0 };
				result2 = callRealXinputGetState(i, &state2);

				if (result == ERROR_SUCCESS)
				{
					if ( (result2 != ERROR_SUCCESS) == seven )
					{
						// 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(vtX360[i], 0x28de); //Valve SteamController VID
						vigem_target_set_pid(vtX360[i], 0x1102); //Valve SteamController PID

						int vigem_res = vigem_target_add(driver, vtX360[i]);
						if (vigem_res == VIGEM_ERROR_TARGET_UNINITIALIZED)
						{
							vtX360[i] = vigem_target_x360_alloc();
						}
						if (vigem_res == VIGEM_ERROR_NONE)
						{
							std::cout << "Plugged in controller " << vigem_target_get_index(vtX360[i]) << std::endl;
							vigem_target_x360_register_notification(driver, vtX360[i], reinterpret_cast<PVIGEM_X360_NOTIFICATION>(&VirtualControllerThread::controllerCallback));
						}
					}

					if (vtX360[i] != nullptr)
						vigem_target_x360_update(driver, vtX360[i], *reinterpret_cast<XUSB_REPORT*>(&state.Gamepad));
				}
				else
				{
					if (VIGEM_SUCCESS(vigem_target_remove(driver, vtX360[i])))
					{
						std::cout << "Unplugged controller " << vigem_target_get_index(vtX360[i]) << std::endl;
					}
				}
			}
		}

		tickTime = sfClock.getElapsedTime().asMicroseconds();
		if (tickTime < delay)
		{
			std::this_thread::sleep_for(std::chrono::microseconds(delay - tickTime));
		}

	}
}

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 ret;
	DWORD dwOldProtect, dwBkup;

	BYTE* Address = reinterpret_cast<BYTE*>(XGetState);
	VirtualProtect(Address, opPatchLenght, PAGE_EXECUTE_READWRITE, &dwOldProtect);		//Change permissions of memory..
	for (DWORD i = 0; i < opPatchLenght; i++)											//unpatch Valve's hook
	{
		*(Address + i) = realBytes[i];
	}

	ret = XGetState(dwUserIndex, pState);												//Cal REAL XInputGetState...

	for (int i = 0; i < opPatchLenght; i++)												//repatch Valve's hook
	{
		*(Address + i) = valveHookBytes[i];
	}
	VirtualProtect(Address, opPatchLenght, dwOldProtect, &dwBkup);						//Revert permission change...

	return ret;
}