├── .gitignore ├── LICENSE ├── README.md ├── dinput8wrapper.sln └── dinput8wrapper ├── CDirectInput8.h ├── CDirectInput8A.h ├── CDirectInput8Globals.h ├── CDirectInput8W.h ├── CDirectInputDeviceGamepad8.h ├── CDirectInputDeviceGamepad8A.h ├── CDirectInputDeviceGamepad8W.h ├── CDirectInputDeviceKeyboard8.h ├── CDirectInputDeviceKeyboard8A.h ├── CDirectInputDeviceKeyboard8W.h ├── CDirectInputDeviceMouse8.h ├── CDirectInputDeviceMouse8A.h ├── CDirectInputDeviceMouse8W.h ├── Resource.rc ├── dinput8.def ├── dinput8.h ├── dinput8wrapper.vcxproj ├── dinput8wrapper.vcxproj.filters ├── dllmain.cpp ├── dllmain.h ├── hid.h ├── pch.cpp └── resource.h /.gitignore: -------------------------------------------------------------------------------- 1 | # User-specific files 2 | *.rsuser 3 | *.suo 4 | *.user 5 | *.userosscache 6 | *.sln.docstates 7 | 8 | # Visual Studio 2015/2017 cache/options directory 9 | .vs/ 10 | .vs/ 11 | 12 | # Build results 13 | [Dd]ebug/ 14 | [Dd]ebugPublic/ 15 | [Rr]elease/ 16 | [Rr]eleases/ 17 | x64/ 18 | x86/ 19 | [Ww][Ii][Nn]32/ 20 | [Aa][Rr][Mm]/ 21 | [Aa][Rr][Mm]64/ 22 | bld/ 23 | [Bb]in/ 24 | [Oo]bj/ 25 | [Ll]og/ 26 | [Ll]ogs/ 27 | 28 | # Visual Studio 2017 auto generated files 29 | Generated\ Files/ 30 | 31 | # Files built by Visual Studio 32 | *_i.c 33 | *_p.c 34 | *_h.h 35 | *.ilk 36 | *.meta 37 | *.obj 38 | *.iobj 39 | *.pch 40 | *.pdb 41 | *.ipdb 42 | *.pgc 43 | *.pgd 44 | *.rsp 45 | *.sbr 46 | *.tlb 47 | *.tli 48 | *.tlh 49 | *.tmp 50 | *.tmp_proj 51 | *_wpftmp.csproj 52 | *.log 53 | *.vspscc 54 | *.vssscc 55 | .builds 56 | *.pidb 57 | *.svclog 58 | *.scc 59 | 60 | # Visual C++ cache files 61 | ipch/ 62 | *.aps 63 | *.ncb 64 | *.opendb 65 | *.opensdf 66 | *.sdf 67 | *.cachefile 68 | *.VC.db 69 | *.VC.VC.opendb 70 | 71 | # Visual Studio profiler 72 | *.psess 73 | *.vsp 74 | *.vspx 75 | *.sap 76 | 77 | # Visual Studio code coverage results 78 | *.coverage 79 | *.coveragexml -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | MIT License 2 | 3 | Copyright (c) 2020 geeky 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 | SOFTWARE. 22 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # dinput8wrapper 2 | This is a DirectInput 8 (dinput8.dll) Wrapper, which internally uses Raw-Input instead of DirectInput. 3 | 4 | Initially created to have a different way to fix the frame stuttering caused by regular EnumDevices()-calls in "Kane & Lynch: Dead Men" 5 | Other workarounds are listed here: https://www.pcgamingwiki.com/wiki/Kane_%26_Lynch:_Dead_Men#Stuttering 6 | 7 | ### Whats the issue? 8 | Dependending on the number and type of physical/virtual "USB HID"-devices on the system the EnumDevices()-call can take a few ms to return. Games sometimes call this function regularly in the main thread to check if a new gamepad is attached/detached, which will then cause regular frame stuttering due to the pauses caused by EnumDevices(). 9 | This wrapper returns a fixed keyboard-device and a fixed mouse-device in EnumDevices() and does not do any real device enumeration. 10 | 11 | ## Current state: 12 | * Only supports Keyboard and Mouse (gamepad-support in progress) 13 | * Does only implement a small subset of the DirectInput8-Interfaces (may not work with all games using DirectInput8) 14 | * 32-bit only (Is there any DirectInput8-game that requires x64?) 15 | 16 | ## How to use / Installation 17 | * Copy the dinput8.dll (see https://github.com/geeky/dinput8wrapper/releases) to the folder where your game has its main executable 18 | * Hope that the game will load it instead of the original dinput8.dll from the windows-system32-folder \ 19 | (Its a bad idea to override the original dinput8.dll!) 20 | 21 | ## Compile yourself 22 | * This repository includes a Visual Studio Solution. 23 | * Currently compiled with VS2022 Community Edition \ 24 | https://visualstudio.microsoft.com/vs/preview/vs2022/ \ 25 | "Desktop development with C++" should be selected in the installer 26 | -------------------------------------------------------------------------------- /dinput8wrapper.sln: -------------------------------------------------------------------------------- 1 |  2 | Microsoft Visual Studio Solution File, Format Version 12.00 3 | # Visual Studio Version 16 4 | VisualStudioVersion = 16.0.30105.148 5 | MinimumVisualStudioVersion = 10.0.40219.1 6 | Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "dinput8wrapper", "dinput8wrapper\dinput8wrapper.vcxproj", "{2A4F4487-E283-4B63-805B-C5014CFB3685}" 7 | EndProject 8 | Global 9 | GlobalSection(SolutionConfigurationPlatforms) = preSolution 10 | Debug|x86 = Debug|x86 11 | EndGlobalSection 12 | GlobalSection(ProjectConfigurationPlatforms) = postSolution 13 | {2A4F4487-E283-4B63-805B-C5014CFB3685}.Debug|x86.ActiveCfg = Debug|Win32 14 | {2A4F4487-E283-4B63-805B-C5014CFB3685}.Debug|x86.Build.0 = Debug|Win32 15 | EndGlobalSection 16 | GlobalSection(SolutionProperties) = preSolution 17 | HideSolutionNode = FALSE 18 | EndGlobalSection 19 | GlobalSection(ExtensibilityGlobals) = postSolution 20 | SolutionGuid = {17811442-D27B-473E-94D2-93D2E0C5064F} 21 | EndGlobalSection 22 | EndGlobal 23 | -------------------------------------------------------------------------------- /dinput8wrapper/CDirectInput8.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | class CDirectInput8 4 | { 5 | private: 6 | ULONG refCount; 7 | 8 | public: 9 | 10 | 11 | CDirectInput8() 12 | { 13 | refCount = 1; 14 | 15 | DWORD threadId; 16 | HANDLE hThread; 17 | 18 | hThread = CreateThread(NULL, 0, ThreadProc, NULL, 0, &threadId); 19 | if (hThread == NULL) 20 | { 21 | MessageBoxA(NULL, "CreateThread() failed", "dinput8.dll", MB_OK); 22 | return; 23 | } 24 | } 25 | 26 | static DWORD WINAPI ThreadProc(LPVOID lpParameter) 27 | { 28 | WNDCLASSEXA wcex; 29 | ZeroMemory(&wcex, sizeof(WNDCLASSEXA)); 30 | wcex.cbSize = sizeof(WNDCLASSEXA); 31 | wcex.style = CS_HREDRAW | CS_VREDRAW; 32 | wcex.lpfnWndProc = MainWndProc; 33 | wcex.hInstance = DllHModule; 34 | wcex.hIcon = LoadIconA(NULL, IDI_APPLICATION); 35 | wcex.hCursor = LoadCursorA(NULL, IDC_ARROW); 36 | wcex.hbrBackground = (HBRUSH)GetStockObject(WHITE_BRUSH); 37 | wcex.lpszClassName = "CDirectInput8"; 38 | 39 | if (!RegisterClassExA(&wcex)) 40 | { 41 | MessageBoxA(NULL, "RegisterClassExA() failed", "dinput8.dll", MB_OK); 42 | return 0; 43 | } 44 | 45 | HWND hWnd = CreateWindowExA(WS_EX_CLIENTEDGE, "CDirectInput8", "dinput8.dll", WS_OVERLAPPEDWINDOW, 1920, 10, 400, 400, NULL, NULL, DllHModule, NULL); 46 | if (hWnd == NULL) 47 | { 48 | MessageBoxA(NULL, "CreateWindowExA() failed", "dinput8.dll", MB_OK); 49 | return 0; 50 | } 51 | 52 | ShowWindow(hWnd, SW_HIDE); 53 | UpdateWindow(hWnd); 54 | 55 | MSG msg; 56 | while (GetMessage(&msg, NULL, 0, 0) > 0) 57 | { 58 | TranslateMessage(&msg); 59 | DispatchMessage(&msg); 60 | } 61 | 62 | return msg.wParam; 63 | } 64 | 65 | static LRESULT HandleWMInput(LPARAM lParam) 66 | { 67 | UINT dwSize = 0; 68 | 69 | GetRawInputData((HRAWINPUT)lParam, RID_INPUT, NULL, &dwSize, sizeof(RAWINPUTHEADER)); 70 | LPBYTE lpb = new BYTE[dwSize]; 71 | if (lpb == NULL) 72 | { 73 | return 0; 74 | } 75 | 76 | if (GetRawInputData((HRAWINPUT)lParam, RID_INPUT, lpb, &dwSize, sizeof(RAWINPUTHEADER)) != dwSize) 77 | { 78 | diGlobalsInstance->LogA("GetRawInputData does not return correct size!", __FILE__, __LINE__); 79 | return 0; 80 | } 81 | 82 | RAWINPUT* raw = (RAWINPUT*)lpb; 83 | 84 | diGlobalsInstance->HandleRawInput(raw); 85 | 86 | delete[] lpb; 87 | return 0; 88 | } 89 | 90 | static LRESULT CALLBACK MainWndProc(HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam) 91 | { 92 | if (Msg == WM_CREATE) 93 | { 94 | RAWINPUTDEVICE Rid[4] = { 0 }; 95 | int ridLength = 2; 96 | 97 | // 98 | Rid[0].usUsagePage = HID_USAGE_PAGE_GENERIC; 99 | Rid[0].usUsage = HID_USAGE_GENERIC_MOUSE; 100 | Rid[0].dwFlags = 0; 101 | Rid[0].hwndTarget = hWnd; 102 | 103 | Rid[1].usUsagePage = HID_USAGE_PAGE_GENERIC; 104 | Rid[1].usUsage = HID_USAGE_GENERIC_KEYBOARD; 105 | Rid[1].dwFlags = 0; 106 | Rid[1].hwndTarget = hWnd; 107 | 108 | if (diGlobalsInstance->enableGamepadSupport) 109 | { 110 | ridLength = 4; 111 | 112 | Rid[2].usUsagePage = HID_USAGE_PAGE_GENERIC; 113 | Rid[2].usUsage = HID_USAGE_GENERIC_JOYSTICK; 114 | Rid[2].dwFlags = RIDEV_DEVNOTIFY; 115 | Rid[2].hwndTarget = hWnd; 116 | 117 | Rid[3].usUsagePage = HID_USAGE_PAGE_GENERIC; 118 | Rid[3].usUsage = HID_USAGE_GENERIC_GAMEPAD; 119 | Rid[3].dwFlags = RIDEV_DEVNOTIFY; 120 | Rid[3].hwndTarget = hWnd; 121 | } 122 | 123 | if (RegisterRawInputDevices(Rid, ridLength, sizeof(Rid[0])) == FALSE) { 124 | MessageBoxA(NULL, "RegisterRawInputDevices() failed!", "dinput8.dll", MB_OK | MB_ICONEXCLAMATION); 125 | //registration failed. Call GetLastError for the cause of the error 126 | } 127 | } 128 | else if (Msg == WM_INPUT) 129 | { 130 | return HandleWMInput(lParam); 131 | } 132 | else if (Msg == WM_INPUT_DEVICE_CHANGE) 133 | { 134 | diGlobalsInstance->CheckRawInputDevices(); 135 | } 136 | 137 | return DefWindowProcA(hWnd, Msg, wParam, lParam); 138 | } 139 | 140 | HRESULT STDMETHODCALLTYPE Base_QueryInterface(GUID* riid, LPVOID* ppvObj) 141 | { 142 | MessageBoxA(NULL, "QueryInterface()", "XXXX", MB_OK); 143 | 144 | return S_OK; 145 | } 146 | 147 | ULONG __stdcall Base_AddRef() 148 | { 149 | diGlobalsInstance->LogA("CDirectInput8->AddRef()", __FILE__, __LINE__); 150 | refCount++; 151 | 152 | return refCount; 153 | } 154 | 155 | ULONG __stdcall Base_Release() 156 | { 157 | diGlobalsInstance->LogA("CDirectInput8->Release()", __FILE__, __LINE__); 158 | 159 | refCount--; 160 | 161 | return refCount; 162 | } 163 | 164 | HRESULT STDMETHODCALLTYPE Base_GetDeviceStatus(GUID* rguidInstance) 165 | { 166 | MessageBoxA(NULL, "GetDeviceStatus", "input8.dll", MB_OK); 167 | 168 | return S_OK; 169 | } 170 | 171 | HRESULT STDMETHODCALLTYPE Base_RunControlPanel(HWND hwndOwner, DWORD dwFlags) 172 | { 173 | MessageBoxA(NULL, "RunControlPanel", "input8.dll", MB_OK); 174 | 175 | return S_OK; 176 | } 177 | 178 | HRESULT STDMETHODCALLTYPE Base_Initialize(HINSTANCE hinst, DWORD dwVersion) 179 | { 180 | MessageBoxA(NULL, "Initialize", "input8.dll", MB_OK); 181 | 182 | return S_OK; 183 | } 184 | }; -------------------------------------------------------------------------------- /dinput8wrapper/CDirectInput8A.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | class CDirectInput8A : public IDirectInput8A, public CDirectInput8 4 | { 5 | private: 6 | CDirectInputDeviceMouse8A* mouseDevice; 7 | CDirectInputDeviceKeyboard8A* keyboardDevice; 8 | CDirectInputDeviceGamepad8A* gamepadDevice; 9 | 10 | DIDEVICEINSTANCEA mouseDeviceInfo = {}; 11 | DIDEVICEINSTANCEA keyboardDeviceInfo = {}; 12 | DIDEVICEINSTANCEA gamepadDeviceInfo = {}; 13 | 14 | public: 15 | 16 | 17 | CDirectInput8A() : CDirectInput8() 18 | { 19 | mouseDevice= new CDirectInputDeviceMouse8A(); 20 | keyboardDevice=new CDirectInputDeviceKeyboard8A(); 21 | gamepadDevice = new CDirectInputDeviceGamepad8A(); 22 | } 23 | 24 | virtual HRESULT STDMETHODCALLTYPE QueryInterface(GUID* riid, LPVOID* ppvObj) 25 | { 26 | return Base_QueryInterface(riid, ppvObj); 27 | } 28 | 29 | virtual ULONG __stdcall AddRef() 30 | { 31 | return Base_AddRef(); 32 | } 33 | 34 | virtual ULONG __stdcall Release() 35 | { 36 | return Base_Release(); 37 | } 38 | 39 | virtual HRESULT STDMETHODCALLTYPE GetDeviceStatus(GUID* rguidInstance) 40 | { 41 | return Base_GetDeviceStatus(rguidInstance); 42 | } 43 | 44 | virtual HRESULT STDMETHODCALLTYPE RunControlPanel(HWND hwndOwner, DWORD dwFlags) 45 | { 46 | return Base_RunControlPanel(hwndOwner, dwFlags); 47 | } 48 | 49 | virtual HRESULT STDMETHODCALLTYPE Initialize(HINSTANCE hinst, DWORD dwVersion) 50 | { 51 | return Base_Initialize(hinst, dwVersion); 52 | } 53 | 54 | 55 | virtual HRESULT STDMETHODCALLTYPE CreateDevice(GUID* rguid, LPDIRECTINPUTDEVICE8A* lplpDirectInputDevice, LPUNKNOWN pUnkOuter) 56 | { 57 | if (IsEqualIID(GUID_SysMouse, *rguid)) 58 | { 59 | diGlobalsInstance->LogA("CreateDevice() for GUID_SysMouse",__FILE__,__LINE__); 60 | 61 | *lplpDirectInputDevice = mouseDevice; 62 | return DI_OK; 63 | } 64 | else if (IsEqualIID(GUID_SysKeyboard, *rguid)) 65 | { 66 | diGlobalsInstance->LogA("CreateDevice() for GUID_SysKeyboard",__FILE__,__LINE__); 67 | 68 | *lplpDirectInputDevice = keyboardDevice; 69 | return DI_OK; 70 | } 71 | else if ((diGlobalsInstance->enableGamepadSupport) && (IsEqualIID(GUID_Xbox360Controller, *rguid))) 72 | { 73 | diGlobalsInstance->LogA("CreateDevice() for GUID_Xbox360Controller", __FILE__, __LINE__); 74 | 75 | *lplpDirectInputDevice = gamepadDevice; 76 | return DI_OK; 77 | } 78 | 79 | diGlobalsInstance->LogA("CreateDevice() for rguid = %x-%x-%x-%x",__FILE__,__LINE__, rguid->Data1, rguid->Data2, rguid->Data3, rguid->Data4); 80 | return E_ABORT; 81 | } 82 | 83 | virtual HRESULT STDMETHODCALLTYPE EnumDevices(DWORD dwDevType, LPDIENUMDEVICESCALLBACKA lpCallback, LPVOID pvRef, DWORD dwFlags) 84 | { 85 | //diGlobalsInstance->LogA("EnumDevices() for dwDevType=%x, dwFlags=%x", __FILE__, __LINE__, dwDevType, dwFlags); 86 | 87 | if ((dwDevType == DI8DEVCLASS_ALL) || (dwDevType == DI8DEVCLASS_POINTER) || (dwDevType == DI8DEVTYPE_MOUSE)) 88 | { 89 | diGlobalsInstance->LogA("EnumDevices: Returning Mouse-Device", __FILE__, __LINE__); 90 | 91 | mouseDevice->GetDeviceInfo(&mouseDeviceInfo); 92 | if (lpCallback(&mouseDeviceInfo, pvRef) == DIENUM_STOP) 93 | { 94 | diGlobalsInstance->LogA("EnumDevices stopped (due to DIENUM_STOP)",__FILE__,__LINE__); 95 | return DI_OK; 96 | } 97 | } 98 | 99 | if ((dwDevType == DI8DEVCLASS_ALL) || (dwDevType == DI8DEVCLASS_KEYBOARD)) 100 | { 101 | diGlobalsInstance->LogA("EnumDevices: Returning Keyboard-Device", __FILE__, __LINE__); 102 | 103 | keyboardDevice->GetDeviceInfo(&keyboardDeviceInfo); 104 | if (lpCallback(&keyboardDeviceInfo, pvRef) == DIENUM_STOP) 105 | { 106 | diGlobalsInstance->LogA("EnumDevices stopped (due to DIENUM_STOP)", __FILE__, __LINE__); 107 | return DI_OK; 108 | } 109 | } 110 | 111 | if (diGlobalsInstance->enableGamepadSupport) 112 | { 113 | if ((dwDevType == DI8DEVCLASS_ALL) || (dwDevType == DI8DEVCLASS_GAMECTRL)) 114 | { 115 | diGlobalsInstance->LogA("EnumDevices: Returning Gamepad-Device", __FILE__, __LINE__); 116 | 117 | gamepadDevice->GetDeviceInfo(&gamepadDeviceInfo); 118 | if (lpCallback(&gamepadDeviceInfo, pvRef) == DIENUM_STOP) 119 | { 120 | diGlobalsInstance->LogA("EnumDevices stopped (due to DIENUM_STOP)", __FILE__, __LINE__); 121 | return DI_OK; 122 | } 123 | } 124 | } 125 | 126 | return DI_OK; 127 | } 128 | 129 | virtual HRESULT STDMETHODCALLTYPE FindDevice(GUID* rguid, LPCSTR pszName, LPGUID pguidInstance) 130 | { 131 | MessageBoxA(NULL, "FindDevice", "input8.dll", MB_OK); 132 | 133 | return S_OK; 134 | } 135 | 136 | virtual HRESULT STDMETHODCALLTYPE EnumDevicesBySemantics(LPCSTR ptszUserName, LPDIACTIONFORMATA lpdiActionFormat, LPDIENUMDEVICESBYSEMANTICSCBA lpCallback, LPVOID pvRef, DWORD dwFlags) 137 | { 138 | MessageBoxA(NULL, "EnumDevicesBySemantics", "input8.dll", MB_OK); 139 | 140 | return S_OK; 141 | } 142 | 143 | virtual HRESULT STDMETHODCALLTYPE ConfigureDevices(LPDICONFIGUREDEVICESCALLBACK lpdiCallback, LPDICONFIGUREDEVICESPARAMSA lpdiCDParams, DWORD dwFlags, LPVOID pvRefData) 144 | { 145 | MessageBoxA(NULL, "ConfigureDevices", "input8.dll", MB_OK); 146 | 147 | return S_OK; 148 | } 149 | }; -------------------------------------------------------------------------------- /dinput8wrapper/CDirectInput8Globals.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | class CDirectInput8Globals 4 | { 5 | private: 6 | DWORD dikMapping[256]; 7 | const wchar_t* dikNames[256]; 8 | CRITICAL_SECTION critSect; 9 | 10 | public: 11 | 12 | bool enableGamepadSupport = false; 13 | 14 | // Sequence number for keyboard actions 15 | DWORD dwSequence; 16 | 17 | // Has the game the keyboard acquired? 18 | bool keyboardAcquired = false; 19 | 20 | // Key-States received via WM_INPUT / Raw-Input 21 | BYTE keyStates[256]; 22 | 23 | // Key-States actually sent to the game 24 | BYTE gameKeyStates[256]; 25 | 26 | // Mouse-State for GetDeviceData() / GetDeviceState() 27 | DIMOUSESTATE* mouseStateDeviceData = new DIMOUSESTATE(); 28 | DIMOUSESTATE* mouseStateDeviceDataGame = new DIMOUSESTATE(); 29 | 30 | HANDLE mouseEventHandle = NULL; 31 | 32 | DIJOYSTATE2* gamepadState = new DIJOYSTATE2(); 33 | 34 | void LogA(LPCSTR LogLine, LPCTSTR file, int line, ...) 35 | { 36 | int flen = strlen(file) - 1; 37 | 38 | while ((file[flen] != '/') && (file[flen] != '\\')) 39 | { 40 | flen--; 41 | } 42 | flen++; 43 | LPCTSTR filePtr = file + flen; 44 | 45 | va_list args; 46 | va_start(args, line); 47 | char tmp2[4096]; 48 | wvsprintfA(tmp2, LogLine, args); 49 | va_end(args); 50 | 51 | char tmp[4096]; 52 | StringCbPrintfA(tmp, 4096, "[dinput8][%s:%u] %s\r\n",filePtr,line,tmp2); 53 | OutputDebugStringA(tmp); 54 | } 55 | 56 | CDirectInput8Globals() 57 | { 58 | InitializeCriticalSection(&critSect); 59 | 60 | ZeroMemory(keyStates, sizeof(keyStates)); 61 | ZeroMemory(gameKeyStates, sizeof(gameKeyStates)); 62 | ZeroMemory(mouseStateDeviceData, sizeof(DIMOUSESTATE)); 63 | ZeroMemory(mouseStateDeviceDataGame, sizeof(DIMOUSESTATE)); 64 | ZeroMemory(gamepadState, sizeof(DIJOYSTATE2)); 65 | 66 | dwSequence = 1; 67 | 68 | // DIK-Mapping: 69 | { 70 | ZeroMemory(dikMapping, sizeof(dikMapping)); 71 | // 0xFF = Ignore 72 | dikMapping[VK_LBUTTON] = 0xFF; 73 | dikMapping[VK_RBUTTON] = 0xFF; 74 | dikMapping[VK_MBUTTON] = 0xFF; 75 | dikMapping[VK_OEM_1] = 0xFF; 76 | dikMapping[VK_OEM_2] = 0xFF; 77 | 78 | dikMapping[VK_SHIFT] = DIK_LSHIFT; 79 | dikMapping[VK_CONTROL] = DIK_LCONTROL; 80 | dikMapping[VK_MENU] = DIK_LMENU; 81 | 82 | dikMapping[VK_OEM_PLUS] = DIK_ADD; 83 | dikMapping[VK_OEM_COMMA] = DIK_COMMA; 84 | dikMapping[VK_OEM_MINUS] = DIK_MINUS; 85 | dikMapping[VK_OEM_PERIOD] = DIK_PERIOD; 86 | 87 | dikMapping[VK_LMENU] = DIK_LMENU; // Alt Left 88 | dikMapping[VK_RMENU] = DIK_RMENU; // Alt Right 89 | dikMapping[VK_BACK] = DIK_BACK; 90 | dikMapping[VK_TAB] = DIK_TAB; 91 | dikMapping[VK_RETURN] = DIK_RETURN; 92 | dikMapping[VK_LSHIFT] = DIK_LSHIFT; 93 | dikMapping[VK_RSHIFT] = DIK_RSHIFT; 94 | dikMapping[VK_LCONTROL] = DIK_LCONTROL; 95 | dikMapping[VK_RCONTROL] = DIK_RCONTROL; 96 | dikMapping[VK_PAUSE] = DIK_PAUSE; 97 | dikMapping[VK_CAPITAL] = DIK_CAPITAL; 98 | dikMapping[VK_ESCAPE] = DIK_ESCAPE; 99 | dikMapping[VK_SPACE] = DIK_SPACE; 100 | dikMapping[VK_PRIOR] = DIK_PRIOR; // Page-Up 101 | dikMapping[VK_NEXT] = DIK_NEXT; // Page-Down 102 | dikMapping[VK_END] = DIK_END; 103 | dikMapping[VK_HOME] = DIK_HOME; 104 | dikMapping[VK_LEFT] = DIK_LEFT; 105 | dikMapping[VK_UP] = DIK_UP; 106 | dikMapping[VK_RIGHT] = DIK_RIGHT; 107 | dikMapping[VK_DOWN] = DIK_DOWN; 108 | dikMapping[VK_INSERT] = DIK_INSERT; 109 | dikMapping[VK_DELETE] = DIK_DELETE; 110 | dikMapping[0x30] = DIK_0; 111 | dikMapping[0x31] = DIK_1; 112 | dikMapping[0x32] = DIK_2; 113 | dikMapping[0x33] = DIK_3; 114 | dikMapping[0x34] = DIK_4; 115 | dikMapping[0x35] = DIK_5; 116 | dikMapping[0x36] = DIK_6; 117 | dikMapping[0x37] = DIK_7; 118 | dikMapping[0x38] = DIK_8; 119 | dikMapping[0x39] = DIK_9; 120 | 121 | dikMapping[0x41] = DIK_A; 122 | dikMapping[0x42] = DIK_B; 123 | dikMapping[0x43] = DIK_C; 124 | dikMapping[0x44] = DIK_D; 125 | dikMapping[0x45] = DIK_E; 126 | dikMapping[0x46] = DIK_F; 127 | dikMapping[0x47] = DIK_G; 128 | dikMapping[0x48] = DIK_H; 129 | dikMapping[0x49] = DIK_I; 130 | dikMapping[0x4A] = DIK_J; 131 | dikMapping[0x4B] = DIK_K; 132 | dikMapping[0x4C] = DIK_L; 133 | dikMapping[0x4D] = DIK_M; 134 | dikMapping[0x4E] = DIK_N; 135 | dikMapping[0x4F] = DIK_O; 136 | dikMapping[0x50] = DIK_P; 137 | dikMapping[0x51] = DIK_Q; 138 | dikMapping[0x52] = DIK_R; 139 | dikMapping[0x53] = DIK_S; 140 | dikMapping[0x54] = DIK_T; 141 | dikMapping[0x55] = DIK_U; 142 | dikMapping[0x56] = DIK_V; 143 | dikMapping[0x57] = DIK_W; 144 | dikMapping[0x58] = DIK_X; 145 | dikMapping[0x59] = DIK_Y; 146 | dikMapping[0x5A] = DIK_Z; 147 | 148 | dikMapping[VK_LWIN] = DIK_LWIN; 149 | dikMapping[VK_RWIN] = DIK_RWIN; 150 | 151 | dikMapping[VK_NUMPAD0] = DIK_NUMPAD0; 152 | dikMapping[VK_NUMPAD1] = DIK_NUMPAD1; 153 | dikMapping[VK_NUMPAD2] = DIK_NUMPAD2; 154 | dikMapping[VK_NUMPAD3] = DIK_NUMPAD3; 155 | dikMapping[VK_NUMPAD4] = DIK_NUMPAD4; 156 | dikMapping[VK_NUMPAD5] = DIK_NUMPAD5; 157 | dikMapping[VK_NUMPAD6] = DIK_NUMPAD6; 158 | dikMapping[VK_NUMPAD7] = DIK_NUMPAD7; 159 | dikMapping[VK_NUMPAD8] = DIK_NUMPAD8; 160 | dikMapping[VK_NUMPAD9] = DIK_NUMPAD9; 161 | 162 | dikMapping[VK_MULTIPLY] = DIK_MULTIPLY; 163 | dikMapping[VK_ADD] = DIK_ADD; 164 | //dikMapping[VK_SEPARATOR] = DIK_PI; 165 | dikMapping[VK_SUBTRACT] = DIK_SUBTRACT; 166 | dikMapping[VK_DECIMAL] = DIK_DECIMAL; 167 | dikMapping[VK_DIVIDE] = DIK_DIVIDE; 168 | 169 | dikMapping[VK_F1] = DIK_F1; 170 | dikMapping[VK_F2] = DIK_F2; 171 | dikMapping[VK_F3] = DIK_F3; 172 | dikMapping[VK_F4] = DIK_F4; 173 | dikMapping[VK_F5] = DIK_F5; 174 | dikMapping[VK_F6] = DIK_F6; 175 | dikMapping[VK_F7] = DIK_F7; 176 | dikMapping[VK_F8] = DIK_F8; 177 | dikMapping[VK_F9] = DIK_F9; 178 | dikMapping[VK_F10] = DIK_F10; 179 | dikMapping[VK_F11] = DIK_F11; 180 | dikMapping[VK_F12] = DIK_F12; 181 | 182 | dikMapping[VK_NUMLOCK] = DIK_NUMLOCK; 183 | } 184 | 185 | // DIK-Names: 186 | { 187 | ZeroMemory(dikNames, sizeof(dikNames)); 188 | 189 | dikNames[DIK_ADD] = L"+"; 190 | dikNames[DIK_COMMA] = L","; 191 | dikNames[DIK_MINUS] = L"-"; 192 | dikNames[DIK_PERIOD] = L"."; 193 | 194 | dikNames[DIK_LMENU] = L"Left-Alt"; // Alt Left 195 | dikNames[DIK_RMENU] = L"Right-Alt"; // Alt Right 196 | dikNames[DIK_BACK] = L"Backspace"; 197 | dikNames[DIK_TAB] = L"Tabulator"; 198 | dikNames[DIK_RETURN] = L"Return"; 199 | dikNames[DIK_LSHIFT] = L"Left-Shift"; 200 | dikNames[DIK_RSHIFT] = L"Right-Shift"; 201 | dikNames[DIK_LCONTROL] = L"Left-CTRL"; 202 | dikNames[DIK_RCONTROL] = L"Right-CTRL"; 203 | dikNames[DIK_PAUSE] = L"Pause"; 204 | dikNames[DIK_CAPITAL] = L"Caps"; 205 | dikNames[DIK_ESCAPE] = L"ESC"; 206 | dikNames[DIK_SPACE] = L"Space"; 207 | dikNames[DIK_PRIOR] = L"PageUp"; // Page-Up 208 | dikNames[DIK_NEXT] = L"PageDown"; // Page-Down 209 | dikNames[DIK_END] = L"End"; 210 | dikNames[DIK_HOME] = L"Home"; 211 | dikNames[DIK_LEFT] = L"Left"; 212 | dikNames[DIK_UP] = L"Up"; 213 | dikNames[DIK_RIGHT] = L"Right"; 214 | dikNames[DIK_DOWN] = L"Down"; 215 | dikNames[DIK_INSERT] = L"Ins"; 216 | dikNames[DIK_DELETE] = L"Del"; 217 | dikNames[DIK_0] = L"0"; 218 | dikNames[DIK_1] = L"1"; 219 | dikNames[DIK_2] = L"2"; 220 | dikNames[DIK_3] = L"3"; 221 | dikNames[DIK_4] = L"4"; 222 | dikNames[DIK_5] = L"5"; 223 | dikNames[DIK_6] = L"6"; 224 | dikNames[DIK_7] = L"7"; 225 | dikNames[DIK_8] = L"8"; 226 | dikNames[DIK_9] = L"9"; 227 | 228 | dikNames[DIK_A] = L"A"; 229 | dikNames[DIK_B] = L"B"; 230 | dikNames[DIK_C] = L"C"; 231 | dikNames[DIK_D] = L"D"; 232 | dikNames[DIK_E] = L"E"; 233 | dikNames[DIK_F] = L"F"; 234 | dikNames[DIK_G] = L"G"; 235 | dikNames[DIK_H] = L"H"; 236 | dikNames[DIK_I] = L"I"; 237 | dikNames[DIK_J] = L"J"; 238 | dikNames[DIK_K] = L"K"; 239 | dikNames[DIK_L] = L"L"; 240 | dikNames[DIK_M] = L"M"; 241 | dikNames[DIK_N] = L"N"; 242 | dikNames[DIK_O] = L"O"; 243 | dikNames[DIK_P] = L"P"; 244 | dikNames[DIK_Q] = L"Q"; 245 | dikNames[DIK_R] = L"R"; 246 | dikNames[DIK_S] = L"S"; 247 | dikNames[DIK_T] = L"T"; 248 | dikNames[DIK_U] = L"U"; 249 | dikNames[DIK_V] = L"V"; 250 | dikNames[DIK_W] = L"W"; 251 | dikNames[DIK_X] = L"X"; 252 | dikNames[DIK_Y] = L"Y"; 253 | dikNames[DIK_Z] = L"Z"; 254 | 255 | dikNames[DIK_LWIN] = L"Windows-Key (Left)"; 256 | dikNames[DIK_RWIN] = L"Windows-Key (Right)"; 257 | 258 | dikNames[DIK_NUMPAD0] = L"0 (Numpad)"; 259 | dikNames[DIK_NUMPAD1] = L"1 (Numpad)"; 260 | dikNames[DIK_NUMPAD2] = L"2 (Numpad)"; 261 | dikNames[DIK_NUMPAD3] = L"3 (Numpad)"; 262 | dikNames[DIK_NUMPAD4] = L"4 (Numpad)"; 263 | dikNames[DIK_NUMPAD5] = L"5 (Numpad)"; 264 | dikNames[DIK_NUMPAD6] = L"6 (Numpad)"; 265 | dikNames[DIK_NUMPAD7] = L"7 (Numpad)"; 266 | dikNames[DIK_NUMPAD8] = L"8 (Numpad)"; 267 | dikNames[DIK_NUMPAD9] = L"9 (Numpad)"; 268 | 269 | dikNames[DIK_MULTIPLY] = L"*"; 270 | dikNames[DIK_ADD] = L"+"; 271 | dikNames[DIK_SUBTRACT] = L"-"; 272 | dikNames[DIK_DECIMAL] = L","; 273 | dikNames[DIK_DIVIDE] = L"/"; 274 | 275 | dikNames[DIK_F1] = L"F1"; 276 | dikNames[DIK_F2] = L"F2"; 277 | dikNames[DIK_F3] = L"F3"; 278 | dikNames[DIK_F4] = L"F4"; 279 | dikNames[DIK_F5] = L"F5"; 280 | dikNames[DIK_F6] = L"F6"; 281 | dikNames[DIK_F7] = L"F7"; 282 | dikNames[DIK_F8] = L"F8"; 283 | dikNames[DIK_F9] = L"F9"; 284 | dikNames[DIK_F10] = L"F10"; 285 | dikNames[DIK_F11] = L"F11"; 286 | dikNames[DIK_F12] = L"F12"; 287 | 288 | dikNames[DIK_NUMLOCK] = L"NumLock"; 289 | } 290 | } 291 | 292 | void GetKeyNameW(DWORD dik, wchar_t* keyName) 293 | { 294 | const wchar_t* keyNameMapped = dikNames[dik]; 295 | 296 | if (keyNameMapped) 297 | { 298 | lstrcpyW(keyName, keyNameMapped); 299 | } 300 | else 301 | { 302 | wsprintfW(keyName, L"Unknown key 0x%x", dik); 303 | } 304 | } 305 | 306 | void GetKeyNameA(DWORD dik, char* keyName) 307 | { 308 | wchar_t keyNameW[4096]; 309 | 310 | GetKeyNameW(dik, keyNameW); 311 | ToAnsi(keyNameW, keyName); 312 | 313 | //this->LogA("GetKeyNameA(dik: %i): %s", __FILE__, __LINE__, dik, keyName); 314 | } 315 | 316 | void ToAnsi(wchar_t* inputString, char* outputString) 317 | { 318 | WideCharToMultiByte(CP_ACP, 0, inputString, -1, outputString, 4096, NULL, NULL); 319 | } 320 | 321 | void Lock() 322 | { 323 | EnterCriticalSection(&critSect); 324 | } 325 | 326 | void Unlock() 327 | { 328 | LeaveCriticalSection(&critSect); 329 | } 330 | 331 | void CheckRawInputDevices() 332 | { 333 | // TODO: Check for new rawinput devices 334 | } 335 | 336 | void HandleRawInput(RAWINPUT* raw) 337 | { 338 | Lock(); 339 | { 340 | if (raw->header.dwType == RIM_TYPEMOUSE) 341 | { 342 | if ((raw->data.mouse.usFlags & MOUSE_MOVE_ABSOLUTE)) 343 | { 344 | LogA("IsAbsoluteMouse - not handled yet", __FILE__, __LINE__); 345 | } 346 | else 347 | { 348 | mouseStateDeviceData->lX += raw->data.mouse.lLastX; 349 | mouseStateDeviceData->lY += raw->data.mouse.lLastY; 350 | 351 | //this->LogA("MouseMove2: %i / %i", __FILE__, __LINE__, raw->data.mouse.lLastX, raw->data.mouse.lLastY); 352 | 353 | if (raw->data.mouse.usButtonFlags & RI_MOUSE_WHEEL) 354 | { 355 | short mouseWheelDelta = (short)raw->data.mouse.usButtonData; 356 | mouseStateDeviceData->lZ += mouseWheelDelta; 357 | } 358 | 359 | if (raw->data.mouse.usButtonFlags & RI_MOUSE_LEFT_BUTTON_DOWN) 360 | { 361 | mouseStateDeviceData->rgbButtons[0] = 0x80; 362 | } 363 | if (raw->data.mouse.usButtonFlags & RI_MOUSE_LEFT_BUTTON_UP) 364 | { 365 | mouseStateDeviceData->rgbButtons[0] = 0x00; 366 | } 367 | 368 | if (raw->data.mouse.usButtonFlags & RI_MOUSE_RIGHT_BUTTON_DOWN) 369 | { 370 | mouseStateDeviceData->rgbButtons[1] = 0x80; 371 | } 372 | if (raw->data.mouse.usButtonFlags & RI_MOUSE_RIGHT_BUTTON_UP) 373 | { 374 | mouseStateDeviceData->rgbButtons[1] = 0x00; 375 | } 376 | 377 | if (raw->data.mouse.usButtonFlags & RI_MOUSE_MIDDLE_BUTTON_DOWN) 378 | { 379 | mouseStateDeviceData->rgbButtons[2] = 0x80; 380 | } 381 | if (raw->data.mouse.usButtonFlags & RI_MOUSE_MIDDLE_BUTTON_UP) 382 | { 383 | mouseStateDeviceData->rgbButtons[2] = 0x00; 384 | } 385 | } 386 | 387 | if (this->mouseEventHandle) 388 | { 389 | ResetEvent(this->mouseEventHandle); 390 | } 391 | } 392 | else if (raw->header.dwType == RIM_TYPEKEYBOARD) 393 | { 394 | DWORD keyMapped = dikMapping[raw->data.keyboard.VKey]; 395 | if (keyMapped == 0x00) 396 | { 397 | LogA("VirtualKeyCode %x unhandled", __FILE__, __LINE__, raw->data.keyboard.VKey); 398 | } 399 | else if (keyMapped == 0xFF) 400 | { 401 | // 0xFF = Intentionally ignore this key 402 | 403 | LogA("VirtualKeyCode % x ignored", __FILE__, __LINE__, raw->data.keyboard.VKey); 404 | } 405 | else 406 | { 407 | DWORD dwData = ((raw->data.keyboard.Flags & RI_KEY_BREAK) > 0) ? 0 : 0x80; 408 | keyStates[keyMapped] = (BYTE)dwData; 409 | } 410 | } 411 | else if ((raw->header.dwType == RIM_TYPEHID) && (this->enableGamepadSupport)) // Gamepads/Joysticks 412 | { 413 | UINT preparsedDataBufferSize = 0; 414 | if (GetRawInputDeviceInfo(raw->header.hDevice, RIDI_PREPARSEDDATA, NULL, &preparsedDataBufferSize) != 0) 415 | { 416 | LogA("GetRawInputDeviceInfo() with RIDI_PREPARSEDDATA failed!", __FILE__, __LINE__, raw->data.keyboard.VKey); 417 | } 418 | 419 | PHIDP_PREPARSED_DATA preparsedDataBuffer = (PHIDP_PREPARSED_DATA)malloc(preparsedDataBufferSize); 420 | if (GetRawInputDeviceInfo(raw->header.hDevice, RIDI_PREPARSEDDATA, preparsedDataBuffer, &preparsedDataBufferSize) >= 0) 421 | { 422 | HIDP_CAPS* caps = new HIDP_CAPS(); 423 | NTSTATUS rv = HidP_GetCaps(preparsedDataBuffer, caps); 424 | if (rv == HIDP_STATUS_SUCCESS) 425 | { 426 | 427 | char tmp[1024]; 428 | wsprintfA(tmp, "usagePageA: %i (%x)\r\n", caps->UsagePage, caps->UsagePage); 429 | OutputDebugStringA(tmp); 430 | 431 | if (true) 432 | { 433 | HIDP_BUTTON_CAPS* buttonCaps = new HIDP_BUTTON_CAPS[caps->NumberInputButtonCaps]; 434 | USHORT ButtonCapsLength = caps->NumberInputButtonCaps; 435 | NTSTATUS rv2 = HidP_GetButtonCaps(HidP_Input, buttonCaps, &ButtonCapsLength, preparsedDataBuffer); 436 | if (rv == HIDP_STATUS_SUCCESS) 437 | { 438 | for (int buttonCapIndex = 0; buttonCapIndex < caps->NumberInputButtonCaps; buttonCapIndex++) 439 | { 440 | char tmp[1024]; 441 | wsprintfA(tmp, "usagePageB: %i\r\n", buttonCaps[buttonCapIndex].UsagePage); 442 | OutputDebugStringA(tmp); 443 | 444 | for (DWORD hidInputIndex = 0; hidInputIndex < raw->data.hid.dwCount; hidInputIndex++) 445 | { 446 | PCHAR hidReportPtr = (PCHAR)&raw->data.hid.bRawData[0]; 447 | hidReportPtr += (hidInputIndex * raw->data.hid.dwSizeHid); 448 | 449 | ULONG usageLength = 0; 450 | NTSTATUS guResult = HidP_GetUsages(HidP_Input, buttonCaps->UsagePage, 0, NULL, &usageLength, preparsedDataBuffer, hidReportPtr, raw->data.hid.dwSizeHid); 451 | if (guResult == HIDP_STATUS_BUFFER_TOO_SMALL) 452 | { 453 | USAGE* usages = new USAGE[usageLength]; 454 | 455 | NTSTATUS guResult = HidP_GetUsages(HidP_Input, buttonCaps->UsagePage, 0, usages, &usageLength, preparsedDataBuffer, hidReportPtr, raw->data.hid.dwSizeHid); 456 | if (guResult == HIDP_STATUS_SUCCESS) 457 | { 458 | for (ULONG usageIndex = 0; usageIndex <= usageLength; usageIndex++) 459 | { 460 | 461 | if (buttonCaps->UsagePage == 0x09) // Gamepad 462 | { 463 | if (usages[usageIndex] == 0x01) // A 464 | { 465 | 466 | } 467 | } 468 | 469 | LogA("Button pressed: %i (usagePage: %i)", __FILE__, __LINE__, usages[usageIndex], buttonCaps->UsagePage); 470 | } 471 | } 472 | else if (guResult == HIDP_STATUS_INVALID_REPORT_LENGTH) 473 | { 474 | LogA("HidP_GetUsages() failed with HIDP_STATUS_INVALID_REPORT_LENGTH", __FILE__, __LINE__); 475 | } 476 | else if (guResult == HIDP_STATUS_INVALID_REPORT_TYPE) 477 | { 478 | LogA("HidP_GetUsages() failed with HIDP_STATUS_INVALID_REPORT_TYPE", __FILE__, __LINE__); 479 | } 480 | else if (guResult == HIDP_STATUS_BUFFER_TOO_SMALL) 481 | { 482 | LogA("HidP_GetUsages() failed with HIDP_STATUS_BUFFER_TOO_SMALL", __FILE__, __LINE__); 483 | } 484 | else if (guResult == HIDP_STATUS_INCOMPATIBLE_REPORT_ID) 485 | { 486 | LogA("HidP_GetUsages() failed with HIDP_STATUS_INCOMPATIBLE_REPORT_ID", __FILE__, __LINE__); 487 | } 488 | else if (guResult == HIDP_STATUS_INVALID_PREPARSED_DATA) 489 | { 490 | LogA("HidP_GetUsages() failed with HIDP_STATUS_INVALID_PREPARSED_DATA", __FILE__, __LINE__); 491 | } 492 | else if (guResult == HIDP_STATUS_USAGE_NOT_FOUND) 493 | { 494 | LogA("HidP_GetUsages() failed with HIDP_STATUS_USAGE_NOT_FOUND", __FILE__, __LINE__); 495 | } 496 | else { 497 | LogA("HidP_GetUsages() failed with unknown return value: %x", __FILE__, __LINE__, guResult); 498 | } 499 | 500 | delete usages; 501 | } 502 | } 503 | } 504 | } 505 | else { 506 | LogA("HidP_GetButtonCaps() failed", __FILE__, __LINE__); 507 | 508 | } 509 | } 510 | } 511 | else if (rv == HIDP_STATUS_INVALID_PREPARSED_DATA) 512 | { 513 | LogA("HidP_GetButtonCaps() failed with HIDP_STATUS_INVALID_PREPARSED_DATA", __FILE__, __LINE__); 514 | } 515 | else { 516 | LogA("HidP_GetButtonCaps() failed with rv: %x", __FILE__, __LINE__, rv); 517 | } 518 | } 519 | else { 520 | LogA("GetRawInputDeviceInfo() failed", __FILE__, __LINE__); 521 | } 522 | } 523 | else 524 | { 525 | LogA("Unhandled raw->header.dwType: %x", __FILE__, __LINE__, raw->header.dwType); 526 | } 527 | } 528 | Unlock(); 529 | } 530 | }; 531 | 532 | static CDirectInput8Globals* diGlobalsInstance= new CDirectInput8Globals(); -------------------------------------------------------------------------------- /dinput8wrapper/CDirectInput8W.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | class CDirectInput8W : public IDirectInput8W, public CDirectInput8 4 | { 5 | private: 6 | CDirectInputDeviceMouse8W* mouseDevice; 7 | CDirectInputDeviceKeyboard8W* keyboardDevice; 8 | CDirectInputDeviceGamepad8W* gamepadDevice; 9 | 10 | DIDEVICEINSTANCEW mouseDeviceInfo = {}; 11 | DIDEVICEINSTANCEW keyboardDeviceInfo = {}; 12 | DIDEVICEINSTANCEW gamepadDeviceInfo = {}; 13 | 14 | public: 15 | 16 | 17 | CDirectInput8W() : CDirectInput8() 18 | { 19 | mouseDevice = new CDirectInputDeviceMouse8W(); 20 | keyboardDevice = new CDirectInputDeviceKeyboard8W(); 21 | gamepadDevice = new CDirectInputDeviceGamepad8W(); 22 | } 23 | 24 | virtual HRESULT STDMETHODCALLTYPE QueryInterface(GUID* riid, LPVOID* ppvObj) 25 | { 26 | return Base_QueryInterface(riid, ppvObj); 27 | } 28 | 29 | virtual ULONG __stdcall AddRef() 30 | { 31 | return Base_AddRef(); 32 | } 33 | 34 | virtual ULONG __stdcall Release() 35 | { 36 | return Base_Release(); 37 | } 38 | 39 | virtual HRESULT STDMETHODCALLTYPE GetDeviceStatus(GUID* rguidInstance) 40 | { 41 | return Base_GetDeviceStatus(rguidInstance); 42 | } 43 | 44 | virtual HRESULT STDMETHODCALLTYPE RunControlPanel(HWND hwndOwner, DWORD dwFlags) 45 | { 46 | return Base_RunControlPanel(hwndOwner, dwFlags); 47 | } 48 | 49 | virtual HRESULT STDMETHODCALLTYPE Initialize(HINSTANCE hinst, DWORD dwVersion) 50 | { 51 | return Base_Initialize(hinst, dwVersion); 52 | } 53 | 54 | /*** IDirectInput8W methods ***/ 55 | virtual HRESULT STDMETHODCALLTYPE CreateDevice(GUID* rguid, LPDIRECTINPUTDEVICE8W* lplpDirectInputDevice, LPUNKNOWN pUnkOuter) 56 | { 57 | if (IsEqualIID(GUID_SysMouse, *rguid)) 58 | { 59 | diGlobalsInstance->LogA("CreateDevice() for GUID_SysMouse", __FILE__, __LINE__); 60 | 61 | *lplpDirectInputDevice = mouseDevice; 62 | return DI_OK; 63 | } 64 | else if (IsEqualIID(GUID_SysKeyboard, *rguid)) 65 | { 66 | diGlobalsInstance->LogA("CreateDevice() for GUID_SysKeyboard", __FILE__, __LINE__); 67 | 68 | *lplpDirectInputDevice = keyboardDevice; 69 | return DI_OK; 70 | } 71 | else if ((diGlobalsInstance->enableGamepadSupport) && (IsEqualIID(GUID_Xbox360Controller, *rguid))) 72 | { 73 | diGlobalsInstance->LogA("CreateDevice() for GUID_Xbox360Controller", __FILE__, __LINE__); 74 | 75 | *lplpDirectInputDevice = gamepadDevice; 76 | return DI_OK; 77 | } 78 | 79 | diGlobalsInstance->LogA("CreateDevice() for rguid=%x-%x-%x-%x", __FILE__, __LINE__, rguid->Data1, rguid->Data2, rguid->Data3, rguid->Data4); 80 | 81 | return E_ABORT; 82 | } 83 | 84 | virtual HRESULT STDMETHODCALLTYPE EnumDevices(DWORD dwDevType, LPDIENUMDEVICESCALLBACKW lpCallback, LPVOID pvRef, DWORD dwFlags) 85 | { 86 | diGlobalsInstance->LogA("EnumDevices() for dwDevType=0x%x, dwFlags=0x0", __FILE__, __LINE__, dwDevType, dwFlags); 87 | 88 | if ((dwDevType == DI8DEVCLASS_ALL) || (dwDevType == DI8DEVCLASS_POINTER) || (dwDevType == DI8DEVTYPE_MOUSE)) 89 | { 90 | diGlobalsInstance->LogA("EnumDevices: Returning Mouse-Device", __FILE__, __LINE__); 91 | 92 | mouseDevice->GetDeviceInfo(&mouseDeviceInfo); 93 | if (lpCallback(&mouseDeviceInfo, pvRef) == DIENUM_STOP) 94 | { 95 | diGlobalsInstance->LogA("EnumDevices stopped (due to DIENUM_STOP)", __FILE__, __LINE__); 96 | return DI_OK; 97 | } 98 | } 99 | 100 | if ((dwDevType == DI8DEVCLASS_ALL) || (dwDevType == DI8DEVCLASS_KEYBOARD)) 101 | { 102 | diGlobalsInstance->LogA("EnumDevices: Returning Keyboard-Device", __FILE__, __LINE__); 103 | 104 | keyboardDevice->GetDeviceInfo(&keyboardDeviceInfo); 105 | if (lpCallback(&keyboardDeviceInfo, pvRef) == DIENUM_STOP) 106 | { 107 | diGlobalsInstance->LogA("EnumDevices stopped (due to DIENUM_STOP)", __FILE__, __LINE__); 108 | return DI_OK; 109 | } 110 | } 111 | 112 | if (diGlobalsInstance->enableGamepadSupport) 113 | { 114 | if ((dwDevType == DI8DEVCLASS_ALL) || (dwDevType == DI8DEVCLASS_GAMECTRL)) 115 | { 116 | diGlobalsInstance->LogA("EnumDevices: Returning Gamepad-Device", __FILE__, __LINE__); 117 | 118 | gamepadDevice->GetDeviceInfo(&gamepadDeviceInfo); 119 | if (lpCallback(&gamepadDeviceInfo, pvRef) == DIENUM_STOP) 120 | { 121 | diGlobalsInstance->LogA("EnumDevices stopped (due to DIENUM_STOP)", __FILE__, __LINE__); 122 | return DI_OK; 123 | } 124 | } 125 | } 126 | 127 | return DI_OK; 128 | } 129 | 130 | virtual HRESULT STDMETHODCALLTYPE FindDevice(GUID* rguid, LPCWSTR pszName, LPGUID pguidInstance) 131 | { 132 | MessageBoxA(NULL, "FindDevice", "input8.dll", MB_OK); 133 | 134 | return S_OK; 135 | } 136 | 137 | virtual HRESULT STDMETHODCALLTYPE EnumDevicesBySemantics(LPCWSTR ptszUserName, LPDIACTIONFORMATW lpdiActionFormat, LPDIENUMDEVICESBYSEMANTICSCBW lpCallback, LPVOID pvRef, DWORD dwFlags) 138 | { 139 | MessageBoxA(NULL, "EnumDevicesBySemantics", "input8.dll", MB_OK); 140 | 141 | return S_OK; 142 | } 143 | 144 | virtual HRESULT STDMETHODCALLTYPE ConfigureDevices(LPDICONFIGUREDEVICESCALLBACK lpdiCallback, LPDICONFIGUREDEVICESPARAMSW lpdiCDParams, DWORD dwFlags, LPVOID pvRefData) 145 | { 146 | MessageBoxA(NULL, "ConfigureDevices", "input8.dll", MB_OK); 147 | 148 | return S_OK; 149 | } 150 | }; -------------------------------------------------------------------------------- /dinput8wrapper/CDirectInputDeviceGamepad8.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | class CDirectInputDeviceGamepad8 4 | { 5 | public: 6 | DIDATAFORMAT dataFormat; 7 | ULONG refCount; 8 | DWORD dwDevType; 9 | bool isAcquired; 10 | 11 | CDirectInputDeviceGamepad8() 12 | { 13 | refCount = 1; 14 | isAcquired = false; 15 | } 16 | 17 | virtual HRESULT STDMETHODCALLTYPE Base_QueryInterface(GUID* riid, LPVOID* ppvObj) 18 | { 19 | diGlobalsInstance->LogA("GamepadDevice->QueryInterface()", __FILE__, __LINE__); 20 | 21 | return S_OK; 22 | }; 23 | 24 | virtual ULONG __stdcall Base_AddRef() 25 | { 26 | diGlobalsInstance->LogA("GamepadDevice->AddRef()", __FILE__, __LINE__); 27 | refCount++; 28 | 29 | return refCount; 30 | } 31 | 32 | virtual ULONG __stdcall Base_Release() 33 | { 34 | diGlobalsInstance->LogA("GamepadDevice->Release()", __FILE__, __LINE__); 35 | 36 | refCount--; 37 | 38 | return refCount; 39 | } 40 | 41 | 42 | virtual HRESULT STDMETHODCALLTYPE Base_GetCapabilities(LPDIDEVCAPS lpDIDevCaps) { 43 | diGlobalsInstance->LogA("GamepadDevice->GetCapabilities()", __FILE__, __LINE__); 44 | 45 | lpDIDevCaps->dwFlags = DIDC_ATTACHED | DIDC_EMULATED; 46 | lpDIDevCaps->dwDevType = this->dwDevType; 47 | lpDIDevCaps->dwAxes = 5; 48 | lpDIDevCaps->dwButtons = 10; 49 | lpDIDevCaps->dwPOVs = 1; 50 | lpDIDevCaps->dwFFSamplePeriod = 0; 51 | lpDIDevCaps->dwFFMinTimeResolution = 0; 52 | lpDIDevCaps->dwFirmwareRevision = 0; 53 | lpDIDevCaps->dwHardwareRevision = 0; 54 | lpDIDevCaps->dwFFDriverVersion = 0; 55 | 56 | return DI_OK; 57 | } 58 | 59 | virtual HRESULT STDMETHODCALLTYPE Base_GetProperty(GUID* rguidProp, LPDIPROPHEADER pdiph) { 60 | diGlobalsInstance->LogA("GamepadDevice->GetProperty()", __FILE__, __LINE__); 61 | 62 | return E_NOTIMPL; 63 | } 64 | 65 | virtual HRESULT STDMETHODCALLTYPE Base_SetProperty(GUID* rguidProp, LPCDIPROPHEADER pdiph) { 66 | diGlobalsInstance->LogA("GamepadDevice->SetProperty()", __FILE__, __LINE__); 67 | 68 | return E_NOTIMPL; 69 | } 70 | 71 | virtual HRESULT STDMETHODCALLTYPE Base_Acquire() { 72 | diGlobalsInstance->LogA("GamepadDevice->Acquire()", __FILE__, __LINE__); 73 | 74 | this->isAcquired = true; 75 | 76 | return DI_OK; 77 | } 78 | 79 | virtual HRESULT STDMETHODCALLTYPE Base_Unacquire() { 80 | diGlobalsInstance->LogA("GamepadDevice->Unacquire()", __FILE__, __LINE__); 81 | 82 | this->isAcquired = false; 83 | 84 | return DI_OK; 85 | } 86 | 87 | virtual HRESULT STDMETHODCALLTYPE Base_GetDeviceState(DWORD cbData, LPVOID lpvData) { 88 | diGlobalsInstance->LogA("GamepadDevice->GetDeviceState()", __FILE__, __LINE__); 89 | 90 | if (!this->isAcquired) 91 | { 92 | return DIERR_INPUTLOST; 93 | } 94 | 95 | diGlobalsInstance->Lock(); 96 | { 97 | ZeroMemory(lpvData, cbData); 98 | 99 | diGlobalsInstance->gamepadState->lX = 0; 100 | diGlobalsInstance->gamepadState->lY = 0; 101 | diGlobalsInstance->gamepadState->lZ = 0; 102 | diGlobalsInstance->gamepadState->lRx = 0; 103 | diGlobalsInstance->gamepadState->lRy = 0; 104 | diGlobalsInstance->gamepadState->lRz = 0; 105 | diGlobalsInstance->gamepadState->rglSlider[0] = 0; 106 | diGlobalsInstance->gamepadState->rglSlider[1] = 0; 107 | diGlobalsInstance->gamepadState->rgdwPOV[0] = -1; 108 | diGlobalsInstance->gamepadState->rgdwPOV[1] = -1; 109 | diGlobalsInstance->gamepadState->rgdwPOV[2] = -1; 110 | diGlobalsInstance->gamepadState->rgdwPOV[3] = -1; 111 | for (int i = 0; i < 32; i++) 112 | { 113 | diGlobalsInstance->gamepadState->rgbButtons[i] = 0; 114 | } 115 | 116 | if (cbData == sizeof(DIJOYSTATE)) 117 | { 118 | memcpy(lpvData, diGlobalsInstance->gamepadState, sizeof(DIJOYSTATE)); 119 | } 120 | else if (cbData == sizeof(DIJOYSTATE2)) 121 | { 122 | memcpy(lpvData, diGlobalsInstance->gamepadState, sizeof(DIJOYSTATE2)); 123 | } 124 | else { 125 | diGlobalsInstance->LogA("GamepadDevice->GetDeviceState(): Unsupported cbData: %i", __FILE__, __LINE__,cbData); 126 | return DIERR_UNSUPPORTED; 127 | } 128 | } 129 | diGlobalsInstance->Unlock(); 130 | 131 | return DI_OK; 132 | } 133 | 134 | virtual HRESULT STDMETHODCALLTYPE Base_GetDeviceData(DWORD cbObjectData, LPDIDEVICEOBJECTDATA rgdod, LPDWORD pdwInOut, DWORD dwFlags) { 135 | diGlobalsInstance->LogA("GamepadDevice->GetDeviceData()", __FILE__, __LINE__); 136 | 137 | *pdwInOut = 0; 138 | 139 | return DI_OK; 140 | } 141 | 142 | virtual HRESULT STDMETHODCALLTYPE Base_SetDataFormat(LPCDIDATAFORMAT lpdf) 143 | { 144 | diGlobalsInstance->LogA("GamepadDevice->SetDataFormat()", __FILE__, __LINE__); 145 | memcpy(&dataFormat, lpdf, sizeof(DIDATAFORMAT)); 146 | return DI_OK; 147 | } 148 | 149 | virtual HRESULT STDMETHODCALLTYPE Base_SetEventNotification(HANDLE hEvent) 150 | { 151 | diGlobalsInstance->LogA("GamepadDevice->SetEventNotification()", __FILE__, __LINE__); 152 | 153 | return E_NOTIMPL; 154 | } 155 | 156 | virtual HRESULT STDMETHODCALLTYPE Base_SetCooperativeLevel(HWND hwnd, DWORD dwFlags) 157 | { 158 | diGlobalsInstance->LogA("GamepadDevice->SetCooperativeLevel(), dwFlags: %x", __FILE__, __LINE__, dwFlags); 159 | return DI_OK; 160 | } 161 | 162 | virtual HRESULT STDMETHODCALLTYPE Base_RunControlPanel(HWND hwndOwner, DWORD dwFlags) 163 | { 164 | diGlobalsInstance->LogA("GamepadDevice->RunControlPanel()", __FILE__, __LINE__); 165 | 166 | return E_NOTIMPL; 167 | } 168 | 169 | virtual HRESULT STDMETHODCALLTYPE Base_Initialize(HINSTANCE hInst, DWORD dwVersion, GUID* rguid) 170 | { 171 | diGlobalsInstance->LogA("GamepadDevice->Initialize()", __FILE__, __LINE__); 172 | 173 | return DI_OK; 174 | } 175 | 176 | virtual HRESULT STDMETHODCALLTYPE Base_CreateEffect(GUID* rguid, LPCDIEFFECT lpeff, LPDIRECTINPUTEFFECT* ppdeff, LPUNKNOWN punkOuter) 177 | { 178 | diGlobalsInstance->LogA("GamepadDevice->CreateEffect()", __FILE__, __LINE__); 179 | 180 | return E_NOTIMPL; 181 | } 182 | 183 | 184 | virtual HRESULT STDMETHODCALLTYPE Base_GetForceFeedbackState(LPDWORD pdwOut) 185 | { 186 | diGlobalsInstance->LogA("GamepadDevice->GetForceFeedbackState()", __FILE__, __LINE__); 187 | 188 | return E_NOTIMPL; 189 | } 190 | 191 | virtual HRESULT STDMETHODCALLTYPE Base_SendForceFeedbackCommand(DWORD dwFlags) 192 | { 193 | diGlobalsInstance->LogA("GamepadDevice->SendForceFeedbackCommand()", __FILE__, __LINE__); 194 | 195 | return E_NOTIMPL; 196 | } 197 | 198 | virtual HRESULT STDMETHODCALLTYPE Base_EnumCreatedEffectObjects(LPDIENUMCREATEDEFFECTOBJECTSCALLBACK lpCallback, LPVOID pvRef, DWORD fl) 199 | { 200 | diGlobalsInstance->LogA("GamepadDevice->EnumCreatedEffectObjects()", __FILE__, __LINE__); 201 | 202 | return DI_OK; 203 | } 204 | 205 | virtual HRESULT STDMETHODCALLTYPE Base_Escape(LPDIEFFESCAPE pesc) 206 | { 207 | diGlobalsInstance->LogA("GamepadDevice->Escape()", __FILE__, __LINE__); 208 | 209 | return E_NOTIMPL; 210 | } 211 | 212 | virtual HRESULT STDMETHODCALLTYPE Base_Poll() { 213 | //diGlobalsInstance->LogA("GamepadDevice->Poll()", __FILE__, __LINE__); 214 | 215 | return DI_NOEFFECT; 216 | } 217 | 218 | virtual HRESULT STDMETHODCALLTYPE Base_SendDeviceData(DWORD cbObjectData, LPCDIDEVICEOBJECTDATA rgdod, LPDWORD pdwInOut, DWORD fl) { 219 | diGlobalsInstance->LogA("GamepadDevice->SendDeviceData()", __FILE__, __LINE__); 220 | 221 | return E_NOTIMPL; 222 | } 223 | }; -------------------------------------------------------------------------------- /dinput8wrapper/CDirectInputDeviceGamepad8A.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | class CDirectInputDeviceGamepad8A : public CDirectInputDeviceGamepad8, public IDirectInputDevice8A 4 | { 5 | private: 6 | DIDEVICEINSTANCEA* gamepadDeviceInfo; 7 | 8 | public: 9 | 10 | CDirectInputDeviceGamepad8A() : CDirectInputDeviceGamepad8() 11 | { 12 | gamepadDeviceInfo = new DIDEVICEINSTANCEA(); 13 | ZeroMemory(gamepadDeviceInfo, sizeof(DIDEVICEINSTANCEA)); 14 | gamepadDeviceInfo->dwSize = sizeof(DIDEVICEINSTANCEA); 15 | gamepadDeviceInfo->guidInstance = GUID_Xbox360Controller; 16 | gamepadDeviceInfo->guidProduct = GUID_Xbox360Controller; 17 | gamepadDeviceInfo->dwDevType = DIDEVTYPE_HID | DI8DEVTYPE_GAMEPAD | (DI8DEVTYPEGAMEPAD_STANDARD << 8); 18 | gamepadDeviceInfo->wUsage = HID_USAGE_GENERIC_GAMEPAD; 19 | gamepadDeviceInfo->wUsagePage = HID_USAGE_PAGE_GENERIC; 20 | StringCbCopyA(gamepadDeviceInfo->tszInstanceName, 260, "Controller (Gamepad XBox360)"); 21 | StringCbCopyA(gamepadDeviceInfo->tszProductName, 260, "Controller (Gamepad XBox360)"); 22 | 23 | this->dwDevType = gamepadDeviceInfo->dwDevType; 24 | } 25 | 26 | virtual HRESULT STDMETHODCALLTYPE QueryInterface(GUID* riid, LPVOID* ppvObj) 27 | { 28 | return Base_QueryInterface(riid, ppvObj); 29 | }; 30 | 31 | virtual ULONG __stdcall AddRef() 32 | { 33 | return Base_AddRef(); 34 | } 35 | 36 | virtual ULONG __stdcall Release() 37 | { 38 | return Base_Release(); 39 | } 40 | 41 | 42 | virtual HRESULT STDMETHODCALLTYPE GetCapabilities(LPDIDEVCAPS lpDIDevCaps) { 43 | return Base_GetCapabilities(lpDIDevCaps); 44 | } 45 | 46 | virtual HRESULT STDMETHODCALLTYPE GetProperty(GUID* rguidProp, LPDIPROPHEADER pdiph) { 47 | return Base_GetProperty(rguidProp, pdiph); 48 | } 49 | 50 | virtual HRESULT STDMETHODCALLTYPE SetProperty(GUID* rguidProp, LPCDIPROPHEADER pdiph) { 51 | return Base_SetProperty(rguidProp, pdiph); 52 | } 53 | 54 | virtual HRESULT STDMETHODCALLTYPE Acquire() { 55 | return Base_Acquire(); 56 | } 57 | 58 | virtual HRESULT STDMETHODCALLTYPE Unacquire() { 59 | return Base_Unacquire(); 60 | } 61 | 62 | virtual HRESULT STDMETHODCALLTYPE GetDeviceState(DWORD cbData, LPVOID lpvData) { 63 | return Base_GetDeviceState(cbData, lpvData); 64 | } 65 | 66 | virtual HRESULT STDMETHODCALLTYPE GetDeviceData(DWORD cbObjectData, LPDIDEVICEOBJECTDATA rgdod, LPDWORD pdwInOut, DWORD dwFlags) { 67 | return Base_GetDeviceData(cbObjectData, rgdod, pdwInOut, dwFlags); 68 | } 69 | 70 | virtual HRESULT STDMETHODCALLTYPE SetDataFormat(LPCDIDATAFORMAT lpdf) 71 | { 72 | return Base_SetDataFormat(lpdf); 73 | } 74 | 75 | virtual HRESULT STDMETHODCALLTYPE SetEventNotification(HANDLE hEvent) 76 | { 77 | return Base_SetEventNotification(hEvent); 78 | } 79 | 80 | virtual HRESULT STDMETHODCALLTYPE SetCooperativeLevel(HWND hwnd, DWORD dwFlags) 81 | { 82 | return Base_SetCooperativeLevel(hwnd, dwFlags); 83 | } 84 | 85 | virtual HRESULT STDMETHODCALLTYPE RunControlPanel(HWND hwndOwner, DWORD dwFlags) 86 | { 87 | return Base_RunControlPanel(hwndOwner, dwFlags); 88 | } 89 | 90 | virtual HRESULT STDMETHODCALLTYPE Initialize(HINSTANCE hInst, DWORD dwVersion, GUID* rguid) 91 | { 92 | return Base_Initialize(hInst, dwVersion, rguid); 93 | } 94 | 95 | virtual HRESULT STDMETHODCALLTYPE CreateEffect(GUID* rguid, LPCDIEFFECT lpeff, LPDIRECTINPUTEFFECT* ppdeff, LPUNKNOWN punkOuter) 96 | { 97 | return Base_CreateEffect(rguid, lpeff, ppdeff, punkOuter); 98 | } 99 | 100 | virtual HRESULT STDMETHODCALLTYPE GetForceFeedbackState(LPDWORD pdwOut) 101 | { 102 | return Base_GetForceFeedbackState(pdwOut); 103 | } 104 | 105 | virtual HRESULT STDMETHODCALLTYPE SendForceFeedbackCommand(DWORD dwFlags) 106 | { 107 | return Base_SendForceFeedbackCommand(dwFlags); 108 | } 109 | 110 | virtual HRESULT STDMETHODCALLTYPE EnumCreatedEffectObjects(LPDIENUMCREATEDEFFECTOBJECTSCALLBACK lpCallback, LPVOID pvRef, DWORD fl) 111 | { 112 | return Base_EnumCreatedEffectObjects(lpCallback, pvRef, fl); 113 | } 114 | 115 | virtual HRESULT STDMETHODCALLTYPE Escape(LPDIEFFESCAPE pesc) 116 | { 117 | return Base_Escape(pesc); 118 | } 119 | 120 | virtual HRESULT STDMETHODCALLTYPE Poll() { 121 | return Base_Poll(); 122 | } 123 | 124 | virtual HRESULT STDMETHODCALLTYPE SendDeviceData(DWORD cbObjectData, LPCDIDEVICEOBJECTDATA rgdod, LPDWORD pdwInOut, DWORD fl) { 125 | return Base_SendDeviceData(cbObjectData, rgdod, pdwInOut, fl); 126 | } 127 | 128 | 129 | 130 | 131 | 132 | 133 | 134 | 135 | 136 | 137 | 138 | 139 | 140 | 141 | 142 | 143 | 144 | 145 | 146 | 147 | 148 | 149 | 150 | 151 | 152 | 153 | 154 | virtual HRESULT STDMETHODCALLTYPE EnumObjects(LPDIENUMDEVICEOBJECTSCALLBACKA lpCallback, LPVOID pvRef, DWORD dwFlags) { 155 | 156 | diGlobalsInstance->LogA("GamepadDevice->EnumObjects(), dwFlags: %x", __FILE__, __LINE__, dwFlags); 157 | 158 | if ((dwFlags & DIDFT_ABSAXIS) > 0) 159 | { 160 | diGlobalsInstance->LogA(" ->DIDFT_ABSAXIS", __FILE__, __LINE__); 161 | } 162 | if ((dwFlags & DIDFT_ALIAS) > 0) 163 | { 164 | diGlobalsInstance->LogA(" ->DIDFT_ALIAS", __FILE__, __LINE__); 165 | } 166 | if ((dwFlags & DIDFT_ALL) > 0) 167 | { 168 | diGlobalsInstance->LogA(" ->DIDFT_ALL", __FILE__, __LINE__); 169 | } 170 | if ((dwFlags & DIDFT_AXIS) > 0) 171 | { 172 | diGlobalsInstance->LogA(" ->DIDFT_AXIS", __FILE__, __LINE__); 173 | } 174 | if ((dwFlags & DIDFT_BUTTON) > 0) 175 | { 176 | diGlobalsInstance->LogA(" ->DIDFT_BUTTON", __FILE__, __LINE__); 177 | } 178 | if ((dwFlags & DIDFT_COLLECTION) > 0) 179 | { 180 | diGlobalsInstance->LogA(" ->DIDFT_COLLECTION", __FILE__, __LINE__); 181 | } 182 | if ((dwFlags & DIDFT_FFACTUATOR) > 0) 183 | { 184 | diGlobalsInstance->LogA(" ->DIDFT_FFACTUATOR", __FILE__, __LINE__); 185 | } 186 | if ((dwFlags & DIDFT_FFEFFECTTRIGGER) > 0) 187 | { 188 | diGlobalsInstance->LogA(" ->DIDFT_FFEFFECTTRIGGER", __FILE__, __LINE__); 189 | } 190 | if ((dwFlags & DIDFT_NOCOLLECTION) > 0) 191 | { 192 | diGlobalsInstance->LogA(" ->DIDFT_NOCOLLECTION", __FILE__, __LINE__); 193 | } 194 | if ((dwFlags & DIDFT_NODATA) > 0) 195 | { 196 | diGlobalsInstance->LogA(" ->DIDFT_NODATA", __FILE__, __LINE__); 197 | } 198 | if ((dwFlags & DIDFT_OUTPUT) > 0) 199 | { 200 | diGlobalsInstance->LogA(" ->DIDFT_OUTPUT", __FILE__, __LINE__); 201 | } 202 | if ((dwFlags & DIDFT_POV) > 0) 203 | { 204 | diGlobalsInstance->LogA(" ->DIDFT_POV", __FILE__, __LINE__); 205 | } 206 | if ((dwFlags & DIDFT_PSHBUTTON) > 0) 207 | { 208 | diGlobalsInstance->LogA(" ->DIDFT_PSHBUTTON", __FILE__, __LINE__); 209 | } 210 | if ((dwFlags & DIDFT_RELAXIS) > 0) 211 | { 212 | diGlobalsInstance->LogA(" ->DIDFT_RELAXIS", __FILE__, __LINE__); 213 | } 214 | if ((dwFlags & DIDFT_TGLBUTTON) > 0) 215 | { 216 | diGlobalsInstance->LogA(" ->DIDFT_TGLBUTTON", __FILE__, __LINE__); 217 | } 218 | if ((dwFlags & DIDFT_VENDORDEFINED) > 0) 219 | { 220 | diGlobalsInstance->LogA(" ->DIDFT_VENDORDEFINED", __FILE__, __LINE__); 221 | } 222 | 223 | DIDEVICEOBJECTINSTANCEA* someObject = new DIDEVICEOBJECTINSTANCEA(); 224 | ZeroMemory(someObject, sizeof(DIDEVICEOBJECTINSTANCEA)); 225 | someObject->dwSize = sizeof(DIDEVICEOBJECTINSTANCEA); 226 | someObject->guidType = GUID_XAxis; 227 | someObject->dwOfs = 0; 228 | someObject->dwType = DIDFT_ABSAXIS; 229 | someObject->dwFlags = DIDOI_GUIDISUSAGE; 230 | lstrcpyA(someObject->tszName, "X-Axis"); 231 | someObject->dwFFMaxForce = 0; 232 | someObject->dwFFForceResolution = 0; 233 | someObject->wCollectionNumber = 0; 234 | someObject->wDesignatorIndex = 0; 235 | someObject->wUsagePage = 0; 236 | someObject->wUsage = 0; 237 | someObject->dwDimension = 0; 238 | someObject->wExponent = 0; 239 | someObject->wReportId = 0; 240 | 241 | lpCallback(someObject, pvRef); 242 | 243 | return DI_OK; 244 | } 245 | 246 | virtual HRESULT STDMETHODCALLTYPE GetObjectInfo(LPDIDEVICEOBJECTINSTANCEA pdidoi, DWORD dwObj, DWORD dwHow) 247 | { 248 | diGlobalsInstance->LogA("GamepadDevice->GetObjectInfo()", __FILE__, __LINE__); 249 | 250 | return E_NOTIMPL; 251 | } 252 | 253 | virtual HRESULT STDMETHODCALLTYPE GetDeviceInfo(LPDIDEVICEINSTANCEA pdidi) 254 | { 255 | diGlobalsInstance->LogA("GamepadDevice->GetDeviceInfo()", __FILE__, __LINE__); 256 | memcpy(pdidi, gamepadDeviceInfo, sizeof(DIDEVICEINSTANCEA)); 257 | 258 | return DI_OK; 259 | } 260 | 261 | virtual HRESULT STDMETHODCALLTYPE EnumEffects(LPDIENUMEFFECTSCALLBACKA lpCallback, LPVOID pvRef, DWORD dwEffType) 262 | { 263 | diGlobalsInstance->LogA("GamepadDevice->EnumEffects()", __FILE__, __LINE__); 264 | 265 | return DI_OK; 266 | } 267 | 268 | virtual HRESULT STDMETHODCALLTYPE GetEffectInfo(LPDIEFFECTINFOA pdei, GUID* rguid) 269 | { 270 | diGlobalsInstance->LogA("GamepadDevice->GetEffectInfo()", __FILE__, __LINE__); 271 | 272 | return E_NOTIMPL; 273 | } 274 | 275 | virtual HRESULT STDMETHODCALLTYPE EnumEffectsInFile(LPCSTR lpszFileName, LPDIENUMEFFECTSINFILECALLBACK pec, LPVOID pvRef, DWORD dwFlags) 276 | { 277 | diGlobalsInstance->LogA("GamepadDevice->EnumEffectsInFile()", __FILE__, __LINE__); 278 | 279 | return E_NOTIMPL; 280 | } 281 | 282 | virtual HRESULT STDMETHODCALLTYPE WriteEffectToFile(LPCSTR lpszFileName, DWORD dwEntries, LPDIFILEEFFECT rgDiFileEft, DWORD dwFlags) 283 | { 284 | diGlobalsInstance->LogA("GamepadDevice->WriteEffectToFile()", __FILE__, __LINE__); 285 | 286 | return E_NOTIMPL; 287 | } 288 | 289 | virtual HRESULT STDMETHODCALLTYPE BuildActionMap(LPDIACTIONFORMATA lpdiaf, LPCSTR lpszUserName, DWORD dwFlags) 290 | { 291 | diGlobalsInstance->LogA("GamepadDevice->BuildActionMap()", __FILE__, __LINE__); 292 | 293 | return E_NOTIMPL; 294 | } 295 | 296 | virtual HRESULT STDMETHODCALLTYPE SetActionMap(LPDIACTIONFORMATA lpdiaf, LPCSTR lpszUserName, DWORD dwFlags) 297 | { 298 | diGlobalsInstance->LogA("GamepadDevice->SetActionMap()", __FILE__, __LINE__); 299 | 300 | return E_NOTIMPL; 301 | } 302 | 303 | virtual HRESULT STDMETHODCALLTYPE GetImageInfo(LPDIDEVICEIMAGEINFOHEADERA lpdiDevImageInfoHeader) 304 | { 305 | diGlobalsInstance->LogA("GamepadDevice->GetImageInfo()", __FILE__, __LINE__); 306 | 307 | return E_NOTIMPL; 308 | } 309 | }; -------------------------------------------------------------------------------- /dinput8wrapper/CDirectInputDeviceGamepad8W.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | class CDirectInputDeviceGamepad8W : public CDirectInputDeviceGamepad8, public IDirectInputDevice8W 4 | { 5 | private: 6 | DIDEVICEINSTANCEW* gamepadDeviceInfo; 7 | 8 | public: 9 | 10 | CDirectInputDeviceGamepad8W() : CDirectInputDeviceGamepad8() 11 | { 12 | gamepadDeviceInfo = new DIDEVICEINSTANCEW(); 13 | ZeroMemory(gamepadDeviceInfo, sizeof(DIDEVICEINSTANCEA)); 14 | gamepadDeviceInfo->dwSize = sizeof(DIDEVICEINSTANCEA); 15 | gamepadDeviceInfo->guidInstance = GUID_Xbox360Controller; 16 | gamepadDeviceInfo->guidProduct = GUID_Xbox360Controller; 17 | gamepadDeviceInfo->dwDevType = DIDEVTYPE_HID | DI8DEVTYPE_GAMEPAD | (DI8DEVTYPEGAMEPAD_STANDARD << 8); 18 | gamepadDeviceInfo->wUsage = HID_USAGE_GENERIC_GAMEPAD; 19 | gamepadDeviceInfo->wUsagePage = HID_USAGE_PAGE_GENERIC; 20 | StringCbCopyW(gamepadDeviceInfo->tszInstanceName, 260, L"Controller (Gamepad XBox360)"); 21 | StringCbCopyW(gamepadDeviceInfo->tszProductName, 260, L"Controller (Gamepad XBox360)"); 22 | 23 | this->dwDevType = gamepadDeviceInfo->dwDevType; 24 | } 25 | 26 | virtual HRESULT STDMETHODCALLTYPE QueryInterface(GUID* riid, LPVOID* ppvObj) 27 | { 28 | return Base_QueryInterface(riid, ppvObj); 29 | }; 30 | 31 | virtual ULONG __stdcall AddRef() 32 | { 33 | return Base_AddRef(); 34 | } 35 | 36 | virtual ULONG __stdcall Release() 37 | { 38 | return Base_Release(); 39 | } 40 | 41 | 42 | virtual HRESULT STDMETHODCALLTYPE GetCapabilities(LPDIDEVCAPS lpDIDevCaps) { 43 | return Base_GetCapabilities(lpDIDevCaps); 44 | } 45 | 46 | virtual HRESULT STDMETHODCALLTYPE GetProperty(GUID* rguidProp, LPDIPROPHEADER pdiph) { 47 | return Base_GetProperty(rguidProp, pdiph); 48 | } 49 | 50 | virtual HRESULT STDMETHODCALLTYPE SetProperty(GUID* rguidProp, LPCDIPROPHEADER pdiph) { 51 | return Base_SetProperty(rguidProp, pdiph); 52 | } 53 | 54 | virtual HRESULT STDMETHODCALLTYPE Acquire() { 55 | return Base_Acquire(); 56 | } 57 | 58 | virtual HRESULT STDMETHODCALLTYPE Unacquire() { 59 | return Base_Unacquire(); 60 | } 61 | 62 | virtual HRESULT STDMETHODCALLTYPE GetDeviceState(DWORD cbData, LPVOID lpvData) { 63 | return Base_GetDeviceState(cbData, lpvData); 64 | } 65 | 66 | virtual HRESULT STDMETHODCALLTYPE GetDeviceData(DWORD cbObjectData, LPDIDEVICEOBJECTDATA rgdod, LPDWORD pdwInOut, DWORD dwFlags) { 67 | return Base_GetDeviceData(cbObjectData, rgdod, pdwInOut, dwFlags); 68 | } 69 | 70 | virtual HRESULT STDMETHODCALLTYPE SetDataFormat(LPCDIDATAFORMAT lpdf) 71 | { 72 | return Base_SetDataFormat(lpdf); 73 | } 74 | 75 | virtual HRESULT STDMETHODCALLTYPE SetEventNotification(HANDLE hEvent) 76 | { 77 | return Base_SetEventNotification(hEvent); 78 | } 79 | 80 | virtual HRESULT STDMETHODCALLTYPE SetCooperativeLevel(HWND hwnd, DWORD dwFlags) 81 | { 82 | return Base_SetCooperativeLevel(hwnd, dwFlags); 83 | } 84 | 85 | virtual HRESULT STDMETHODCALLTYPE RunControlPanel(HWND hwndOwner, DWORD dwFlags) 86 | { 87 | return Base_RunControlPanel(hwndOwner, dwFlags); 88 | } 89 | 90 | virtual HRESULT STDMETHODCALLTYPE Initialize(HINSTANCE hInst, DWORD dwVersion, GUID* rguid) 91 | { 92 | return Base_Initialize(hInst, dwVersion, rguid); 93 | } 94 | 95 | virtual HRESULT STDMETHODCALLTYPE CreateEffect(GUID* rguid, LPCDIEFFECT lpeff, LPDIRECTINPUTEFFECT* ppdeff, LPUNKNOWN punkOuter) 96 | { 97 | return Base_CreateEffect(rguid, lpeff, ppdeff, punkOuter); 98 | } 99 | 100 | virtual HRESULT STDMETHODCALLTYPE GetForceFeedbackState(LPDWORD pdwOut) 101 | { 102 | return Base_GetForceFeedbackState(pdwOut); 103 | } 104 | 105 | virtual HRESULT STDMETHODCALLTYPE SendForceFeedbackCommand(DWORD dwFlags) 106 | { 107 | return Base_SendForceFeedbackCommand(dwFlags); 108 | } 109 | 110 | virtual HRESULT STDMETHODCALLTYPE EnumCreatedEffectObjects(LPDIENUMCREATEDEFFECTOBJECTSCALLBACK lpCallback, LPVOID pvRef, DWORD fl) 111 | { 112 | return Base_EnumCreatedEffectObjects(lpCallback, pvRef, fl); 113 | } 114 | 115 | virtual HRESULT STDMETHODCALLTYPE Escape(LPDIEFFESCAPE pesc) 116 | { 117 | return Base_Escape(pesc); 118 | } 119 | 120 | virtual HRESULT STDMETHODCALLTYPE Poll() { 121 | return Base_Poll(); 122 | } 123 | 124 | virtual HRESULT STDMETHODCALLTYPE SendDeviceData(DWORD cbObjectData, LPCDIDEVICEOBJECTDATA rgdod, LPDWORD pdwInOut, DWORD fl) { 125 | return Base_SendDeviceData(cbObjectData, rgdod, pdwInOut, fl); 126 | } 127 | 128 | 129 | 130 | 131 | 132 | virtual HRESULT STDMETHODCALLTYPE EnumObjects(LPDIENUMDEVICEOBJECTSCALLBACKW lpCallback, LPVOID pvRef, DWORD dwFlags) { 133 | 134 | diGlobalsInstance->LogA("GamepadDevice->EnumObjects()", __FILE__, __LINE__); 135 | 136 | return DI_OK; 137 | } 138 | 139 | virtual HRESULT STDMETHODCALLTYPE GetObjectInfo(LPDIDEVICEOBJECTINSTANCEW pdidoi, DWORD dwObj, DWORD dwHow) 140 | { 141 | diGlobalsInstance->LogA("GamepadDevice->GetObjectInfo()", __FILE__, __LINE__); 142 | 143 | return E_NOTIMPL; 144 | } 145 | 146 | virtual HRESULT STDMETHODCALLTYPE GetDeviceInfo(LPDIDEVICEINSTANCEW pdidi) 147 | { 148 | diGlobalsInstance->LogA("GamepadDevice->GetDeviceInfo()", __FILE__, __LINE__); 149 | memcpy(pdidi, gamepadDeviceInfo, sizeof(DIDEVICEINSTANCEW)); 150 | 151 | return DI_OK; 152 | } 153 | 154 | virtual HRESULT STDMETHODCALLTYPE EnumEffects(LPDIENUMEFFECTSCALLBACKW lpCallback, LPVOID pvRef, DWORD dwEffType) 155 | { 156 | diGlobalsInstance->LogA("GamepadDevice->EnumEffects()", __FILE__, __LINE__); 157 | 158 | return DI_OK; 159 | } 160 | 161 | virtual HRESULT STDMETHODCALLTYPE GetEffectInfo(LPDIEFFECTINFOW pdei, GUID* rguid) 162 | { 163 | diGlobalsInstance->LogA("GamepadDevice->GetEffectInfo()", __FILE__, __LINE__); 164 | 165 | return E_NOTIMPL; 166 | } 167 | 168 | virtual HRESULT STDMETHODCALLTYPE EnumEffectsInFile(LPCWSTR lpszFileName, LPDIENUMEFFECTSINFILECALLBACK pec, LPVOID pvRef, DWORD dwFlags) 169 | { 170 | diGlobalsInstance->LogA("GamepadDevice->EnumEffectsInFile()", __FILE__, __LINE__); 171 | 172 | return E_NOTIMPL; 173 | } 174 | 175 | virtual HRESULT STDMETHODCALLTYPE WriteEffectToFile(LPCWSTR lpszFileName, DWORD dwEntries, LPDIFILEEFFECT rgDiFileEft, DWORD dwFlags) 176 | { 177 | diGlobalsInstance->LogA("GamepadDevice->WriteEffectToFile()", __FILE__, __LINE__); 178 | 179 | return E_NOTIMPL; 180 | } 181 | 182 | virtual HRESULT STDMETHODCALLTYPE BuildActionMap(LPDIACTIONFORMATW lpdiaf, LPCWSTR lpszUserName, DWORD dwFlags) 183 | { 184 | diGlobalsInstance->LogA("GamepadDevice->BuildActionMap()", __FILE__, __LINE__); 185 | 186 | return E_NOTIMPL; 187 | } 188 | 189 | virtual HRESULT STDMETHODCALLTYPE SetActionMap(LPDIACTIONFORMATW lpdiaf, LPCWSTR lpszUserName, DWORD dwFlags) 190 | { 191 | diGlobalsInstance->LogA("GamepadDevice->SetActionMap()", __FILE__, __LINE__); 192 | 193 | return E_NOTIMPL; 194 | } 195 | 196 | virtual HRESULT STDMETHODCALLTYPE GetImageInfo(LPDIDEVICEIMAGEINFOHEADERW lpdiDevImageInfoHeader) 197 | { 198 | diGlobalsInstance->LogA("GamepadDevice->GetImageInfo()", __FILE__, __LINE__); 199 | 200 | return E_NOTIMPL; 201 | } 202 | }; -------------------------------------------------------------------------------- /dinput8wrapper/CDirectInputDeviceKeyboard8.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | class CDirectInputDeviceKeyboard8 4 | { 5 | public: 6 | 7 | ULONG refCount; 8 | DWORD dwDevType; 9 | 10 | CDirectInputDeviceKeyboard8() 11 | { 12 | refCount = 1; 13 | } 14 | 15 | virtual HRESULT STDMETHODCALLTYPE Base_QueryInterface(GUID* riid, LPVOID* ppvObj) 16 | { 17 | diGlobalsInstance->LogA("KeyboardDevice->QueryInterface()", __FILE__, __LINE__); 18 | 19 | return E_NOINTERFACE; 20 | }; 21 | 22 | virtual ULONG STDMETHODCALLTYPE Base_AddRef() 23 | { 24 | diGlobalsInstance->LogA("KeyboardDevice->AddRef()", __FILE__, __LINE__); 25 | 26 | refCount++; 27 | 28 | return refCount; 29 | } 30 | 31 | virtual ULONG STDMETHODCALLTYPE Base_Release() 32 | { 33 | diGlobalsInstance->LogA("KeyboardDevice->Release()", __FILE__, __LINE__); 34 | 35 | refCount--; 36 | 37 | return refCount; 38 | } 39 | 40 | 41 | virtual HRESULT STDMETHODCALLTYPE Base_GetCapabilities(LPDIDEVCAPS lpDIDevCaps) { 42 | diGlobalsInstance->LogA("KeyboardDevice->GetCapabilities()", __FILE__, __LINE__); 43 | 44 | lpDIDevCaps->dwFlags = DIDC_ATTACHED | DIDC_EMULATED; 45 | lpDIDevCaps->dwDevType = this->dwDevType; 46 | lpDIDevCaps->dwAxes = 0; 47 | lpDIDevCaps->dwButtons = 128; 48 | lpDIDevCaps->dwPOVs = 0; 49 | lpDIDevCaps->dwFFSamplePeriod = 0; 50 | lpDIDevCaps->dwFFMinTimeResolution = 0; 51 | lpDIDevCaps->dwFirmwareRevision = 0; 52 | lpDIDevCaps->dwHardwareRevision = 0; 53 | lpDIDevCaps->dwFFDriverVersion = 0; 54 | 55 | return DI_OK; 56 | } 57 | 58 | virtual HRESULT STDMETHODCALLTYPE Base_GetProperty(GUID* rguidProp, LPDIPROPHEADER pdiph) { 59 | 60 | char tmp[4096]; 61 | 62 | int propId = (int)rguidProp; 63 | 64 | if (propId == 0x14) // // 0x14 = DIPROP_PRODUCTNAME 65 | { 66 | DIPROPSTRING* strProp = (DIPROPSTRING*)pdiph; 67 | 68 | if (pdiph->dwHow == DIPH_DEVICE) 69 | { 70 | lstrcpyW(strProp->wsz, L"Keyboard"); 71 | return DI_OK; 72 | } 73 | else if (pdiph->dwHow == DIPH_BYOFFSET) 74 | { 75 | diGlobalsInstance->GetKeyNameW(pdiph->dwObj, strProp->wsz); 76 | return DI_OK; 77 | } 78 | } 79 | 80 | wsprintfA(tmp, "KeyboardDevice->GetProperty() unhandled guid: %x, dwHow: %x", propId, pdiph->dwHow); 81 | diGlobalsInstance->LogA(tmp, __FILE__, __LINE__); 82 | 83 | return DIERR_UNSUPPORTED; 84 | } 85 | 86 | virtual HRESULT STDMETHODCALLTYPE Base_SetProperty(GUID* rguidProp, LPCDIPROPHEADER pdiph) { 87 | char tmp[4096]; 88 | 89 | if ((int)rguidProp == 0x01) // DIPROP_BUFFERSIZE 90 | { 91 | // Buffer-Size 92 | LPDIPROPDWORD propDword = (LPDIPROPDWORD)pdiph; 93 | 94 | wsprintfA(tmp, "KeyboardDevice->SetProperty(): DI_BUFFERSIZE (dwData=%u)", propDword->dwData); 95 | diGlobalsInstance->LogA(tmp, __FILE__, __LINE__); 96 | 97 | // Currently ignored 98 | 99 | return DI_OK; 100 | } 101 | 102 | wsprintfA(tmp, "KeyboardDevice->SetProperty(): %x", rguidProp); 103 | diGlobalsInstance->LogA(tmp, __FILE__, __LINE__); 104 | 105 | return DIERR_UNSUPPORTED; 106 | } 107 | 108 | virtual HRESULT STDMETHODCALLTYPE Base_Acquire() { 109 | //diGlobalsInstance->LogA("KeyboardDevice->Acquire()", __FILE__, __LINE__); 110 | 111 | diGlobalsInstance->Lock(); 112 | { 113 | diGlobalsInstance->keyboardAcquired = true; 114 | } 115 | diGlobalsInstance->Unlock(); 116 | 117 | return DI_OK; 118 | } 119 | 120 | virtual HRESULT STDMETHODCALLTYPE Base_Unacquire() { 121 | //diGlobalsInstance->LogA("KeyboardDevice->Unacquire()", __FILE__, __LINE__); 122 | 123 | diGlobalsInstance->Lock(); 124 | { 125 | diGlobalsInstance->keyboardAcquired = false; 126 | } 127 | diGlobalsInstance->Unlock(); 128 | 129 | return DI_OK; 130 | } 131 | 132 | virtual HRESULT STDMETHODCALLTYPE Base_GetDeviceState(DWORD cbData, LPVOID lpvData) { 133 | //diGlobalsInstance->LogA("KeyboardDevice->GetDeviceState()", __FILE__, __LINE__); 134 | 135 | if (cbData <= sizeof(diGlobalsInstance->keyStates)) 136 | { 137 | memcpy(lpvData, diGlobalsInstance->keyStates, cbData); 138 | } 139 | else 140 | { 141 | diGlobalsInstance->LogA("KeyboardDevice->GetDeviceState(): cbData too large", __FILE__, __LINE__); 142 | } 143 | 144 | return DI_OK; 145 | } 146 | 147 | virtual HRESULT STDMETHODCALLTYPE Base_GetDeviceData(DWORD cbObjectData, LPDIDEVICEOBJECTDATA rgdod, LPDWORD pdwInOut, DWORD dwFlags) 148 | { 149 | if (cbObjectData != sizeof(DIDEVICEOBJECTDATA)) 150 | { 151 | diGlobalsInstance->LogA("KeyboardDevice->GetDeviceData(): Unexpected cbObjectData", __FILE__, __LINE__); 152 | return DIERR_INVALIDPARAM; 153 | } 154 | 155 | bool peekOnly = false; 156 | 157 | if (dwFlags > 0) 158 | { 159 | char tmp[1024]; 160 | wsprintfA(tmp, "KeyboardDevice->GetDeviceData(): dwFlags=%x", dwFlags); 161 | diGlobalsInstance->LogA(tmp, __FILE__, __LINE__); 162 | } 163 | 164 | int dwOut = 0; 165 | 166 | // Determine timestamp: 167 | __int64 fTime = 0; 168 | GetSystemTimeAsFileTime((FILETIME*)&fTime); 169 | fTime = fTime / 1000; 170 | 171 | diGlobalsInstance->Lock(); 172 | { 173 | if ((*pdwInOut == 0) && (rgdod == NULL)) 174 | { 175 | diGlobalsInstance->LogA("KeyboardDevice->GetDeviceData() checking for overflow", __FILE__, __LINE__); 176 | } 177 | else if ((*pdwInOut == INFINITE) && (rgdod == NULL)) 178 | { 179 | // Flush buffer: 180 | diGlobalsInstance->LogA("KeyboardDevice->GetDeviceData() flushing buffer", __FILE__, __LINE__); 181 | 182 | ZeroMemory(diGlobalsInstance->keyStates, sizeof(diGlobalsInstance->keyStates)); 183 | ZeroMemory(diGlobalsInstance->gameKeyStates, sizeof(diGlobalsInstance->gameKeyStates)); 184 | } 185 | else 186 | { 187 | memset(rgdod, 0, *pdwInOut * sizeof(DIDEVICEOBJECTDATA)); 188 | 189 | for (DWORD i = 0; i < *pdwInOut; i++) 190 | { 191 | // Check if there is a changed key 192 | for (int k = 0; k < 256; k++) 193 | { 194 | if (diGlobalsInstance->keyStates[k] != diGlobalsInstance->gameKeyStates[k]) 195 | { 196 | 197 | rgdod[i].dwData = diGlobalsInstance->keyStates[k]; 198 | rgdod[i].dwOfs = k; 199 | rgdod[i].dwSequence = diGlobalsInstance->dwSequence; 200 | rgdod[i].dwTimeStamp = (DWORD)fTime; 201 | rgdod[i].uAppData = NULL; 202 | 203 | diGlobalsInstance->dwSequence++; 204 | 205 | diGlobalsInstance->gameKeyStates[k] = diGlobalsInstance->keyStates[k]; 206 | 207 | dwOut++; 208 | k = 256; 209 | } 210 | } 211 | } 212 | } 213 | } 214 | diGlobalsInstance->Unlock(); 215 | 216 | *pdwInOut = dwOut; 217 | return DI_OK; 218 | } 219 | 220 | virtual HRESULT STDMETHODCALLTYPE Base_SetDataFormat(LPCDIDATAFORMAT lpdf) 221 | { 222 | diGlobalsInstance->LogA("KeyboardDevice->SetDataFormat()", __FILE__, __LINE__); 223 | return DI_OK; 224 | } 225 | 226 | virtual HRESULT STDMETHODCALLTYPE Base_SetEventNotification(HANDLE hEvent) 227 | { 228 | diGlobalsInstance->LogA("KeyboardDevice->SetEventNotification()", __FILE__, __LINE__); 229 | 230 | return DIERR_INVALIDPARAM; 231 | } 232 | 233 | virtual HRESULT STDMETHODCALLTYPE Base_SetCooperativeLevel(HWND hwnd, DWORD dwFlags) 234 | { 235 | diGlobalsInstance->LogA("KeyboardDevice->SetCooperativeLevel()", __FILE__, __LINE__); 236 | return DI_OK; 237 | } 238 | 239 | virtual HRESULT STDMETHODCALLTYPE Base_RunControlPanel(HWND hwndOwner, DWORD dwFlags) 240 | { 241 | diGlobalsInstance->LogA("KeyboardDevice->RunControlPanel()", __FILE__, __LINE__); 242 | 243 | return DI_OK; 244 | } 245 | 246 | virtual HRESULT STDMETHODCALLTYPE Base_Initialize(HINSTANCE hinst, DWORD dwVersion, GUID* rguid) 247 | { 248 | diGlobalsInstance->LogA("KeyboardDevice->Initialize()", __FILE__, __LINE__); 249 | 250 | return DI_OK; 251 | } 252 | 253 | virtual HRESULT STDMETHODCALLTYPE Base_CreateEffect(GUID* rguid, LPCDIEFFECT lpeff, LPDIRECTINPUTEFFECT* ppdeff, LPUNKNOWN punkOuter) 254 | { 255 | diGlobalsInstance->LogA("KeyboardDevice->CreateEffect()", __FILE__, __LINE__); 256 | 257 | return DIERR_UNSUPPORTED; 258 | } 259 | 260 | virtual HRESULT STDMETHODCALLTYPE Base_GetForceFeedbackState(LPDWORD pdwOut) 261 | { 262 | *pdwOut = DIGFFS_POWEROFF | DIGFFS_EMPTY; 263 | 264 | diGlobalsInstance->LogA("KeyboardDevice->GetForceFeedbackState()", __FILE__, __LINE__); 265 | 266 | return DI_OK; 267 | } 268 | 269 | virtual HRESULT STDMETHODCALLTYPE Base_SendForceFeedbackCommand(DWORD dwFlags) 270 | { 271 | diGlobalsInstance->LogA("KeyboardDevice->SendForceFeedbackCommand()", __FILE__, __LINE__); 272 | 273 | return DI_OK; 274 | } 275 | 276 | virtual HRESULT STDMETHODCALLTYPE Base_EnumCreatedEffectObjects(LPDIENUMCREATEDEFFECTOBJECTSCALLBACK lpCallback, LPVOID pvRef, DWORD fl) 277 | { 278 | diGlobalsInstance->LogA("KeyboardDevice->EnumCreatedEffectObjects()", __FILE__, __LINE__); 279 | 280 | return DI_OK; 281 | } 282 | 283 | virtual HRESULT STDMETHODCALLTYPE Base_Escape(LPDIEFFESCAPE pesc) 284 | { 285 | diGlobalsInstance->LogA("KeyboardDevice->Escape()", __FILE__, __LINE__); 286 | 287 | return DIERR_UNSUPPORTED; 288 | } 289 | 290 | virtual HRESULT STDMETHODCALLTYPE Base_Poll() { 291 | diGlobalsInstance->LogA("KeyboardDevice->Poll()", __FILE__, __LINE__); 292 | 293 | return DIERR_UNSUPPORTED; 294 | } 295 | 296 | virtual HRESULT STDMETHODCALLTYPE Base_SendDeviceData(DWORD cbObjectData, LPCDIDEVICEOBJECTDATA rgdod, LPDWORD pdwInOut, DWORD fl) { 297 | diGlobalsInstance->LogA("KeyboardDevice->SendDeviceData()", __FILE__, __LINE__); 298 | 299 | return DIERR_UNSUPPORTED; 300 | } 301 | }; -------------------------------------------------------------------------------- /dinput8wrapper/CDirectInputDeviceKeyboard8A.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | class CDirectInputDeviceKeyboard8A : public IDirectInputDevice8A, public CDirectInputDeviceKeyboard8 4 | { 5 | private: 6 | DIDEVICEINSTANCEA* keyboardDeviceInfo; 7 | 8 | public: 9 | 10 | CDirectInputDeviceKeyboard8A() : CDirectInputDeviceKeyboard8() 11 | { 12 | keyboardDeviceInfo = new DIDEVICEINSTANCEA(); 13 | ZeroMemory(keyboardDeviceInfo, sizeof(DIDEVICEINSTANCEA)); 14 | keyboardDeviceInfo->dwSize = sizeof(DIDEVICEINSTANCEA); 15 | keyboardDeviceInfo->guidInstance = GUID_SysKeyboard; 16 | keyboardDeviceInfo->guidProduct = GUID_SysKeyboard; 17 | keyboardDeviceInfo->dwDevType = DI8DEVTYPE_KEYBOARD | (DIDEVTYPEKEYBOARD_PCENH << 8); 18 | StringCbCopyA(keyboardDeviceInfo->tszInstanceName, 260, "Keyboard"); 19 | StringCbCopyA(keyboardDeviceInfo->tszProductName, 260, "Keyboard"); 20 | 21 | this->dwDevType = keyboardDeviceInfo->dwDevType; 22 | } 23 | 24 | 25 | virtual HRESULT STDMETHODCALLTYPE QueryInterface(GUID* riid, LPVOID* ppvObj) 26 | { 27 | return Base_QueryInterface(riid, ppvObj); 28 | }; 29 | 30 | virtual ULONG STDMETHODCALLTYPE AddRef() 31 | { 32 | return Base_AddRef(); 33 | } 34 | 35 | virtual ULONG STDMETHODCALLTYPE Release() 36 | { 37 | return Base_Release(); 38 | } 39 | 40 | 41 | virtual HRESULT STDMETHODCALLTYPE GetCapabilities(LPDIDEVCAPS lpDIDevCaps) { 42 | return Base_GetCapabilities(lpDIDevCaps); 43 | } 44 | 45 | virtual HRESULT STDMETHODCALLTYPE GetProperty(GUID* rguidProp, LPDIPROPHEADER pdiph) { 46 | 47 | return Base_GetProperty(rguidProp, pdiph); 48 | } 49 | 50 | virtual HRESULT STDMETHODCALLTYPE SetProperty(GUID* rguidProp, LPCDIPROPHEADER pdiph) { 51 | return Base_SetProperty(rguidProp, pdiph); 52 | } 53 | 54 | virtual HRESULT STDMETHODCALLTYPE Acquire() { 55 | return Base_Acquire(); 56 | } 57 | 58 | virtual HRESULT STDMETHODCALLTYPE Unacquire() { 59 | return Base_Unacquire(); 60 | } 61 | 62 | virtual HRESULT STDMETHODCALLTYPE GetDeviceState(DWORD cbData, LPVOID lpvData) { 63 | return Base_GetDeviceState(cbData, lpvData); 64 | } 65 | 66 | virtual HRESULT STDMETHODCALLTYPE GetDeviceData(DWORD cbObjectData, LPDIDEVICEOBJECTDATA rgdod, LPDWORD pdwInOut, DWORD dwFlags) 67 | { 68 | return Base_GetDeviceData(cbObjectData, rgdod, pdwInOut, dwFlags); 69 | } 70 | 71 | virtual HRESULT STDMETHODCALLTYPE SetDataFormat(LPCDIDATAFORMAT lpdf) 72 | { 73 | return Base_SetDataFormat(lpdf); 74 | } 75 | 76 | virtual HRESULT STDMETHODCALLTYPE SetEventNotification(HANDLE hEvent) 77 | { 78 | return Base_SetEventNotification(hEvent); 79 | } 80 | 81 | virtual HRESULT STDMETHODCALLTYPE SetCooperativeLevel(HWND hwnd, DWORD dwFlags) 82 | { 83 | return Base_SetCooperativeLevel(hwnd, dwFlags); 84 | } 85 | 86 | virtual HRESULT STDMETHODCALLTYPE RunControlPanel(HWND hwndOwner, DWORD dwFlags) 87 | { 88 | return Base_RunControlPanel(hwndOwner, dwFlags); 89 | } 90 | 91 | virtual HRESULT STDMETHODCALLTYPE Initialize(HINSTANCE hinst, DWORD dwVersion, GUID* rguid) 92 | { 93 | return Base_Initialize(hinst, dwVersion, rguid); 94 | } 95 | 96 | virtual HRESULT STDMETHODCALLTYPE CreateEffect(GUID* rguid, LPCDIEFFECT lpeff, LPDIRECTINPUTEFFECT* ppdeff, LPUNKNOWN punkOuter) 97 | { 98 | return Base_CreateEffect(rguid, lpeff, ppdeff, punkOuter); 99 | } 100 | 101 | virtual HRESULT STDMETHODCALLTYPE GetForceFeedbackState(LPDWORD pdwOut) 102 | { 103 | return Base_GetForceFeedbackState(pdwOut); 104 | } 105 | 106 | virtual HRESULT STDMETHODCALLTYPE SendForceFeedbackCommand(DWORD dwFlags) 107 | { 108 | return Base_SendForceFeedbackCommand(dwFlags); 109 | } 110 | 111 | virtual HRESULT STDMETHODCALLTYPE EnumCreatedEffectObjects(LPDIENUMCREATEDEFFECTOBJECTSCALLBACK lpCallback, LPVOID pvRef, DWORD fl) 112 | { 113 | return Base_EnumCreatedEffectObjects(lpCallback, pvRef, fl); 114 | } 115 | 116 | virtual HRESULT STDMETHODCALLTYPE Escape(LPDIEFFESCAPE pesc) 117 | { 118 | return Base_Escape(pesc); 119 | } 120 | 121 | virtual HRESULT STDMETHODCALLTYPE Poll() { 122 | return Base_Poll(); 123 | } 124 | 125 | virtual HRESULT STDMETHODCALLTYPE SendDeviceData(DWORD cbObjectData, LPCDIDEVICEOBJECTDATA rgdod, LPDWORD pdwInOut, DWORD fl) { 126 | return Base_SendDeviceData(cbObjectData, rgdod, pdwInOut, fl); 127 | } 128 | 129 | 130 | 131 | 132 | 133 | 134 | virtual HRESULT STDMETHODCALLTYPE EnumObjects(LPDIENUMDEVICEOBJECTSCALLBACKA lpCallback, LPVOID pvRef, DWORD dwFlags) { 135 | 136 | diGlobalsInstance->LogA("KeyboardDevice->EnumObjects()", __FILE__, __LINE__); 137 | return DI_OK; 138 | } 139 | 140 | virtual HRESULT STDMETHODCALLTYPE GetObjectInfo(LPDIDEVICEOBJECTINSTANCEA pdidoi, DWORD dwObj, DWORD dwHow) 141 | { 142 | diGlobalsInstance->LogA("KeyboardDevice->GetObjectInfo(dwObj: %x, dwHow: %x)", __FILE__, __LINE__,dwObj,dwHow); 143 | 144 | ZeroMemory(pdidoi, sizeof(DIDEVICEOBJECTINSTANCEW)); 145 | 146 | // dwHow: 1, dwObj: 200 147 | 148 | if (dwHow == DIPH_BYOFFSET) 149 | { 150 | pdidoi->dwSize = sizeof(DIDEVICEOBJECTINSTANCEW); 151 | pdidoi->guidType = GUID_Key; 152 | pdidoi->dwOfs = dwObj; 153 | pdidoi->dwType = DIDFT_BUTTON; 154 | diGlobalsInstance->GetKeyNameA(dwObj, pdidoi->tszName); 155 | return DI_OK; 156 | } 157 | 158 | return DIERR_UNSUPPORTED; 159 | } 160 | 161 | virtual HRESULT STDMETHODCALLTYPE GetDeviceInfo(LPDIDEVICEINSTANCEA pdidi) 162 | { 163 | diGlobalsInstance->LogA("KeyboardDevice->GetDeviceInfo()", __FILE__, __LINE__); 164 | memcpy(pdidi, keyboardDeviceInfo, sizeof(DIDEVICEINSTANCEA)); 165 | 166 | return DI_OK; 167 | } 168 | 169 | virtual HRESULT STDMETHODCALLTYPE EnumEffects(LPDIENUMEFFECTSCALLBACKA lpCallback, LPVOID pvRef, DWORD dwEffType) 170 | { 171 | diGlobalsInstance->LogA("KeyboardDevice->EnumEffects()", __FILE__, __LINE__); 172 | 173 | return DI_OK; 174 | } 175 | 176 | virtual HRESULT STDMETHODCALLTYPE GetEffectInfo(LPDIEFFECTINFOA pdei, GUID* rguid) 177 | { 178 | diGlobalsInstance->LogA("KeyboardDevice->GetEffectInfo()", __FILE__, __LINE__); 179 | 180 | return DIERR_UNSUPPORTED; 181 | } 182 | 183 | virtual HRESULT STDMETHODCALLTYPE EnumEffectsInFile(LPCSTR lpszFileName, LPDIENUMEFFECTSINFILECALLBACK pec, LPVOID pvRef, DWORD dwFlags) 184 | { 185 | diGlobalsInstance->LogA("KeyboardDevice->EnumEffectsInFile()", __FILE__, __LINE__); 186 | 187 | return DIERR_UNSUPPORTED; 188 | } 189 | 190 | virtual HRESULT STDMETHODCALLTYPE WriteEffectToFile(LPCSTR lpszFileName, DWORD dwEntries, LPDIFILEEFFECT rgDiFileEft, DWORD dwFlags) 191 | { 192 | diGlobalsInstance->LogA("KeyboardDevice->WriteEffectToFile()", __FILE__, __LINE__); 193 | 194 | return DIERR_UNSUPPORTED; 195 | } 196 | 197 | virtual HRESULT STDMETHODCALLTYPE BuildActionMap(LPDIACTIONFORMATA lpdiaf, LPCSTR lpszUserName, DWORD dwFlags) 198 | { 199 | diGlobalsInstance->LogA("KeyboardDevice->BuildActionMap()", __FILE__, __LINE__); 200 | 201 | return DIERR_UNSUPPORTED; 202 | } 203 | 204 | virtual HRESULT STDMETHODCALLTYPE SetActionMap(LPDIACTIONFORMATA lpdiaf, LPCSTR lpszUserName, DWORD dwFlags) 205 | { 206 | diGlobalsInstance->LogA("KeyboardDevice->SetActionMap()", __FILE__, __LINE__); 207 | 208 | return DIERR_UNSUPPORTED; 209 | } 210 | 211 | virtual HRESULT STDMETHODCALLTYPE GetImageInfo(LPDIDEVICEIMAGEINFOHEADERA lpdiDevImageInfoHeader) 212 | { 213 | diGlobalsInstance->LogA("KeyboardDevice->GetImageInfo()", __FILE__, __LINE__); 214 | 215 | return DIERR_UNSUPPORTED; 216 | } 217 | }; -------------------------------------------------------------------------------- /dinput8wrapper/CDirectInputDeviceKeyboard8W.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | class CDirectInputDeviceKeyboard8W : public IDirectInputDevice8W, public CDirectInputDeviceKeyboard8 4 | { 5 | private: 6 | DIDEVICEINSTANCEW* keyboardDeviceInfo; 7 | 8 | public: 9 | 10 | CDirectInputDeviceKeyboard8W() : CDirectInputDeviceKeyboard8() 11 | { 12 | keyboardDeviceInfo = new DIDEVICEINSTANCEW(); 13 | ZeroMemory(keyboardDeviceInfo, sizeof(DIDEVICEINSTANCEW)); 14 | keyboardDeviceInfo->dwSize = sizeof(DIDEVICEINSTANCEW); 15 | keyboardDeviceInfo->guidInstance = GUID_SysKeyboard; 16 | keyboardDeviceInfo->guidProduct = GUID_SysKeyboard; 17 | keyboardDeviceInfo->dwDevType = DI8DEVTYPE_KEYBOARD | (DIDEVTYPEKEYBOARD_PCENH << 8); 18 | StringCbCopyW(keyboardDeviceInfo->tszInstanceName, 260, L"Keyboard"); 19 | StringCbCopyW(keyboardDeviceInfo->tszProductName, 260, L"Keyboard"); 20 | 21 | this->dwDevType = keyboardDeviceInfo->dwDevType; 22 | } 23 | 24 | 25 | virtual HRESULT STDMETHODCALLTYPE QueryInterface(GUID* riid, LPVOID* ppvObj) 26 | { 27 | return Base_QueryInterface(riid, ppvObj); 28 | }; 29 | 30 | virtual ULONG STDMETHODCALLTYPE AddRef() 31 | { 32 | return Base_AddRef(); 33 | } 34 | 35 | virtual ULONG STDMETHODCALLTYPE Release() 36 | { 37 | return Base_Release(); 38 | } 39 | 40 | 41 | virtual HRESULT STDMETHODCALLTYPE GetCapabilities(LPDIDEVCAPS lpDIDevCaps) { 42 | return Base_GetCapabilities(lpDIDevCaps); 43 | } 44 | 45 | virtual HRESULT STDMETHODCALLTYPE GetProperty(GUID* rguidProp, LPDIPROPHEADER pdiph) { 46 | 47 | return Base_GetProperty(rguidProp, pdiph); 48 | } 49 | 50 | virtual HRESULT STDMETHODCALLTYPE SetProperty(GUID* rguidProp, LPCDIPROPHEADER pdiph) { 51 | return Base_SetProperty(rguidProp, pdiph); 52 | } 53 | 54 | virtual HRESULT STDMETHODCALLTYPE Acquire() { 55 | return Base_Acquire(); 56 | } 57 | 58 | virtual HRESULT STDMETHODCALLTYPE Unacquire() { 59 | return Base_Unacquire(); 60 | } 61 | 62 | virtual HRESULT STDMETHODCALLTYPE GetDeviceState(DWORD cbData, LPVOID lpvData) { 63 | return Base_GetDeviceState(cbData, lpvData); 64 | } 65 | 66 | virtual HRESULT STDMETHODCALLTYPE GetDeviceData(DWORD cbObjectData, LPDIDEVICEOBJECTDATA rgdod, LPDWORD pdwInOut, DWORD dwFlags) 67 | { 68 | return Base_GetDeviceData(cbObjectData, rgdod, pdwInOut, dwFlags); 69 | } 70 | 71 | virtual HRESULT STDMETHODCALLTYPE SetDataFormat(LPCDIDATAFORMAT lpdf) 72 | { 73 | return Base_SetDataFormat(lpdf); 74 | } 75 | 76 | virtual HRESULT STDMETHODCALLTYPE SetEventNotification(HANDLE hEvent) 77 | { 78 | return Base_SetEventNotification(hEvent); 79 | } 80 | 81 | virtual HRESULT STDMETHODCALLTYPE SetCooperativeLevel(HWND hwnd, DWORD dwFlags) 82 | { 83 | return Base_SetCooperativeLevel(hwnd, dwFlags); 84 | } 85 | 86 | virtual HRESULT STDMETHODCALLTYPE RunControlPanel(HWND hwndOwner, DWORD dwFlags) 87 | { 88 | return Base_RunControlPanel(hwndOwner, dwFlags); 89 | } 90 | 91 | virtual HRESULT STDMETHODCALLTYPE Initialize(HINSTANCE hinst, DWORD dwVersion, GUID* rguid) 92 | { 93 | return Base_Initialize(hinst, dwVersion, rguid); 94 | } 95 | 96 | virtual HRESULT STDMETHODCALLTYPE CreateEffect(GUID* rguid, LPCDIEFFECT lpeff, LPDIRECTINPUTEFFECT* ppdeff, LPUNKNOWN punkOuter) 97 | { 98 | return Base_CreateEffect(rguid, lpeff, ppdeff, punkOuter); 99 | } 100 | 101 | virtual HRESULT STDMETHODCALLTYPE GetForceFeedbackState(LPDWORD pdwOut) 102 | { 103 | return Base_GetForceFeedbackState(pdwOut); 104 | } 105 | 106 | virtual HRESULT STDMETHODCALLTYPE SendForceFeedbackCommand(DWORD dwFlags) 107 | { 108 | return Base_SendForceFeedbackCommand(dwFlags); 109 | } 110 | 111 | virtual HRESULT STDMETHODCALLTYPE EnumCreatedEffectObjects(LPDIENUMCREATEDEFFECTOBJECTSCALLBACK lpCallback, LPVOID pvRef, DWORD fl) 112 | { 113 | return Base_EnumCreatedEffectObjects(lpCallback, pvRef, fl); 114 | } 115 | 116 | virtual HRESULT STDMETHODCALLTYPE Escape(LPDIEFFESCAPE pesc) 117 | { 118 | return Base_Escape(pesc); 119 | } 120 | 121 | virtual HRESULT STDMETHODCALLTYPE Poll() { 122 | return Base_Poll(); 123 | } 124 | 125 | virtual HRESULT STDMETHODCALLTYPE SendDeviceData(DWORD cbObjectData, LPCDIDEVICEOBJECTDATA rgdod, LPDWORD pdwInOut, DWORD fl) { 126 | return Base_SendDeviceData(cbObjectData, rgdod, pdwInOut, fl); 127 | } 128 | 129 | 130 | 131 | 132 | 133 | 134 | 135 | 136 | 137 | 138 | 139 | 140 | 141 | 142 | 143 | 144 | 145 | 146 | 147 | 148 | 149 | 150 | 151 | 152 | 153 | 154 | 155 | 156 | 157 | 158 | 159 | 160 | 161 | 162 | 163 | 164 | 165 | 166 | 167 | 168 | 169 | 170 | 171 | 172 | 173 | 174 | 175 | 176 | 177 | 178 | 179 | 180 | 181 | 182 | 183 | 184 | virtual HRESULT STDMETHODCALLTYPE EnumObjects(LPDIENUMDEVICEOBJECTSCALLBACKW lpCallback, LPVOID pvRef, DWORD dwFlags) { 185 | 186 | diGlobalsInstance->LogA("KeyboardDevice->EnumObjects()", __FILE__, __LINE__); 187 | return DI_OK; 188 | } 189 | 190 | virtual HRESULT STDMETHODCALLTYPE GetObjectInfo(LPDIDEVICEOBJECTINSTANCEW pdidoi, DWORD dwObj, DWORD dwHow) 191 | { 192 | diGlobalsInstance->LogA("KeyboardDevice->GetObjectInfo()", __FILE__, __LINE__); 193 | 194 | ZeroMemory(pdidoi, sizeof(DIDEVICEOBJECTINSTANCEW)); 195 | 196 | char tmp[4096]; 197 | wsprintfA(tmp, "dwHow: %i, dwObj: %i \r\n", dwHow, dwObj); 198 | OutputDebugStringA(tmp); 199 | 200 | // dwHow: 1, dwObj: 200 201 | 202 | if (dwHow == DIPH_BYOFFSET) 203 | { 204 | pdidoi->dwSize = sizeof(DIDEVICEOBJECTINSTANCEW); 205 | pdidoi->guidType = GUID_Key; 206 | pdidoi->dwOfs = dwObj; 207 | pdidoi->dwType = DIDFT_BUTTON; 208 | diGlobalsInstance->GetKeyNameW(dwObj, pdidoi->tszName); 209 | return DI_OK; 210 | } 211 | 212 | return DIERR_UNSUPPORTED; 213 | } 214 | 215 | virtual HRESULT STDMETHODCALLTYPE GetDeviceInfo(LPDIDEVICEINSTANCEW pdidi) 216 | { 217 | diGlobalsInstance->LogA("KeyboardDevice->GetDeviceInfo()", __FILE__, __LINE__); 218 | memcpy(pdidi, keyboardDeviceInfo, sizeof(DIDEVICEINSTANCEW)); 219 | 220 | return DI_OK; 221 | } 222 | 223 | virtual HRESULT STDMETHODCALLTYPE EnumEffects(LPDIENUMEFFECTSCALLBACKW lpCallback, LPVOID pvRef, DWORD dwEffType) 224 | { 225 | diGlobalsInstance->LogA("KeyboardDevice->EnumEffects()", __FILE__, __LINE__); 226 | 227 | return DI_OK; 228 | } 229 | 230 | virtual HRESULT STDMETHODCALLTYPE GetEffectInfo(LPDIEFFECTINFOW pdei, GUID* rguid) 231 | { 232 | diGlobalsInstance->LogA("KeyboardDevice->GetEffectInfo()", __FILE__, __LINE__); 233 | 234 | return DIERR_UNSUPPORTED; 235 | } 236 | 237 | virtual HRESULT STDMETHODCALLTYPE EnumEffectsInFile(LPCWSTR lpszFileName, LPDIENUMEFFECTSINFILECALLBACK pec, LPVOID pvRef, DWORD dwFlags) 238 | { 239 | diGlobalsInstance->LogA("KeyboardDevice->EnumEffectsInFile()", __FILE__, __LINE__); 240 | 241 | return DIERR_UNSUPPORTED; 242 | } 243 | 244 | virtual HRESULT STDMETHODCALLTYPE WriteEffectToFile(LPCWSTR lpszFileName, DWORD dwEntries, LPDIFILEEFFECT rgDiFileEft, DWORD dwFlags) 245 | { 246 | diGlobalsInstance->LogA("KeyboardDevice->WriteEffectToFile()", __FILE__, __LINE__); 247 | 248 | return DIERR_UNSUPPORTED; 249 | } 250 | 251 | virtual HRESULT STDMETHODCALLTYPE BuildActionMap(LPDIACTIONFORMATW lpdiaf, LPCWSTR lpszUserName, DWORD dwFlags) 252 | { 253 | diGlobalsInstance->LogA("KeyboardDevice->BuildActionMap()", __FILE__, __LINE__); 254 | 255 | return DIERR_UNSUPPORTED; 256 | } 257 | 258 | virtual HRESULT STDMETHODCALLTYPE SetActionMap(LPDIACTIONFORMATW lpdiaf, LPCWSTR lpszUserName, DWORD dwFlags) 259 | { 260 | diGlobalsInstance->LogA("KeyboardDevice->SetActionMap()", __FILE__, __LINE__); 261 | 262 | return DIERR_UNSUPPORTED; 263 | } 264 | 265 | virtual HRESULT STDMETHODCALLTYPE GetImageInfo(LPDIDEVICEIMAGEINFOHEADERW lpdiDevImageInfoHeader) 266 | { 267 | diGlobalsInstance->LogA("KeyboardDevice->GetImageInfo()", __FILE__, __LINE__); 268 | 269 | return DIERR_UNSUPPORTED; 270 | } 271 | }; -------------------------------------------------------------------------------- /dinput8wrapper/CDirectInputDeviceMouse8.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | class CDirectInputDeviceMouse8 4 | { 5 | private: 6 | DIDATAFORMAT dataFormat; 7 | int refCount; 8 | bool exclusiveMode; 9 | bool isAquired; 10 | HWND hWndForegroundWindow; 11 | 12 | public: 13 | 14 | DWORD dwDevType; 15 | 16 | CDirectInputDeviceMouse8() 17 | { 18 | ZeroMemory(&dataFormat, sizeof(DIDATAFORMAT)); 19 | refCount = 1; 20 | exclusiveMode = false; 21 | isAquired = false; 22 | hWndForegroundWindow = NULL; 23 | } 24 | 25 | HRESULT STDMETHODCALLTYPE Base_QueryInterface(GUID* riid, LPVOID* ppvObj) 26 | { 27 | diGlobalsInstance->LogA("MouseDevice->QueryInterface()", __FILE__, __LINE__); 28 | 29 | return S_OK; 30 | }; 31 | 32 | ULONG __stdcall Base_AddRef() 33 | { 34 | diGlobalsInstance->LogA("MouseDevice->AddRef()", __FILE__, __LINE__); 35 | refCount++; 36 | 37 | return refCount; 38 | } 39 | 40 | ULONG __stdcall Base_Release() 41 | { 42 | diGlobalsInstance->LogA("MouseDevice->Release()", __FILE__, __LINE__); 43 | 44 | refCount--; 45 | 46 | return refCount; 47 | } 48 | 49 | 50 | HRESULT STDMETHODCALLTYPE Base_GetCapabilities(LPDIDEVCAPS lpDIDevCaps) { 51 | diGlobalsInstance->LogA("MouseDevice->GetCapabilities()", __FILE__, __LINE__); 52 | 53 | lpDIDevCaps->dwFlags = DIDC_ATTACHED | DIDC_EMULATED; 54 | lpDIDevCaps->dwDevType = this->dwDevType; 55 | lpDIDevCaps->dwAxes = 3; 56 | lpDIDevCaps->dwButtons = 3; 57 | lpDIDevCaps->dwPOVs = 0; 58 | lpDIDevCaps->dwFFSamplePeriod = 0; 59 | lpDIDevCaps->dwFFMinTimeResolution = 0; 60 | lpDIDevCaps->dwFirmwareRevision = 0; 61 | lpDIDevCaps->dwHardwareRevision = 0; 62 | lpDIDevCaps->dwFFDriverVersion = 0; 63 | 64 | return DI_OK; 65 | } 66 | 67 | HRESULT STDMETHODCALLTYPE Base_GetProperty(GUID* rguidProp, LPDIPROPHEADER pdiph) { 68 | diGlobalsInstance->LogA("MouseDevice->GetProperty()", __FILE__, __LINE__); 69 | 70 | return E_NOTIMPL; 71 | } 72 | 73 | HRESULT STDMETHODCALLTYPE Base_SetProperty(GUID* rguidProp, LPCDIPROPHEADER pdiph) { 74 | diGlobalsInstance->LogA("MouseDevice->SetProperty()", __FILE__, __LINE__); 75 | diGlobalsInstance->LogA("-> dwHow: %x", __FILE__,__LINE__,pdiph->dwHow); 76 | diGlobalsInstance->LogA("-> dwObj: %x", __FILE__, __LINE__, pdiph->dwObj); 77 | 78 | return E_NOTIMPL; 79 | } 80 | 81 | HRESULT STDMETHODCALLTYPE Base_Acquire() { 82 | diGlobalsInstance->LogA("MouseDevice->Acquire()", __FILE__, __LINE__); 83 | 84 | this->hWndForegroundWindow = GetForegroundWindow(); 85 | 86 | this->Base_AcquireInternal(); 87 | this->isAquired = true; 88 | 89 | return DI_OK; 90 | } 91 | 92 | void Base_AcquireInternal() 93 | { 94 | if (!this->isAquired) 95 | { 96 | return; 97 | } 98 | 99 | // Initial mouse capture 100 | // (Or capture lost due to 'ALT+TAB'-ing) 101 | HWND hWndCapture = GetCapture(); 102 | if (hWndCapture != this->hWndForegroundWindow) 103 | { 104 | SetCapture(this->hWndForegroundWindow); 105 | 106 | if (this->exclusiveMode) 107 | { 108 | ShowCursor(false); 109 | } 110 | } 111 | } 112 | 113 | HRESULT STDMETHODCALLTYPE Base_Unacquire() { 114 | diGlobalsInstance->LogA("MouseDevice->Unacquire()", __FILE__, __LINE__); 115 | 116 | ReleaseCapture(); 117 | 118 | if (this->exclusiveMode) 119 | { 120 | ShowCursor(true); 121 | } 122 | 123 | this->isAquired = false; 124 | 125 | return DI_OK; 126 | } 127 | 128 | HRESULT STDMETHODCALLTYPE Base_GetDeviceState(DWORD cbData, LPVOID lpvData) { 129 | diGlobalsInstance->LogA("MouseDevice->GetDeviceState()", __FILE__, __LINE__); 130 | 131 | if (!this->isAquired) 132 | { 133 | diGlobalsInstance->LogA("MouseDevice->GetDeviceState(): DIERR_INPUTLOST", __FILE__, __LINE__); 134 | return DIERR_INPUTLOST; 135 | } 136 | 137 | this->Base_AcquireInternal(); 138 | 139 | diGlobalsInstance->Lock(); 140 | { 141 | // Copy current state to lpvData 142 | memcpy(lpvData, diGlobalsInstance->mouseStateDeviceData, sizeof(DIMOUSESTATE)); 143 | 144 | // Set axis movement to zero: 145 | // (=Mark last movement data as fetched) 146 | diGlobalsInstance->mouseStateDeviceData->lX = 0; 147 | diGlobalsInstance->mouseStateDeviceData->lY = 0; 148 | diGlobalsInstance->mouseStateDeviceData->lZ = 0; 149 | } 150 | diGlobalsInstance->Unlock(); 151 | 152 | return DI_OK; 153 | } 154 | 155 | HRESULT STDMETHODCALLTYPE Base_GetDeviceData(DWORD cbObjectData, LPDIDEVICEOBJECTDATA rgdod, LPDWORD pdwInOut, DWORD dwFlags) { 156 | //diGlobalsInstance->LogA("MouseDevice->GetDeviceData()", __FILE__, __LINE__); 157 | 158 | if (!this->isAquired) 159 | { 160 | diGlobalsInstance->LogA("MouseDevice->GetDeviceData(): DIERR_INPUTLOST", __FILE__, __LINE__); 161 | return DIERR_INPUTLOST; 162 | } 163 | 164 | this->Base_AcquireInternal(); 165 | 166 | if (cbObjectData != sizeof(DIDEVICEOBJECTDATA)) 167 | { 168 | diGlobalsInstance->LogA("MouseDevice->GetDeviceData(): Unexpected cbObjectData", __FILE__, __LINE__); 169 | return DIERR_INVALIDPARAM; 170 | } 171 | 172 | bool peekOnly = false; 173 | 174 | if (dwFlags > 0) 175 | { 176 | char tmp[1024]; 177 | wsprintfA(tmp, "MouseDevice->GetDeviceData(): dwFlags=%x", dwFlags); 178 | diGlobalsInstance->LogA(tmp, __FILE__, __LINE__); 179 | } 180 | 181 | int dwOut = 0; 182 | 183 | // Determine timestamp: 184 | __int64 fTime = 0; 185 | GetSystemTimeAsFileTime((FILETIME*)&fTime); 186 | fTime = fTime / 1000; 187 | 188 | diGlobalsInstance->Lock(); 189 | { 190 | if ((*pdwInOut == 0) && (rgdod == NULL)) 191 | { 192 | diGlobalsInstance->LogA("MouseDevice->GetDeviceData() checking for overflow", __FILE__, __LINE__); 193 | } 194 | else if ((*pdwInOut == INFINITE) && (rgdod == NULL)) 195 | { 196 | // Flush buffer: 197 | diGlobalsInstance->LogA("MouseDevice->GetDeviceData() flushing buffer", __FILE__, __LINE__); 198 | 199 | ZeroMemory(diGlobalsInstance->keyStates, sizeof(diGlobalsInstance->keyStates)); 200 | ZeroMemory(diGlobalsInstance->gameKeyStates, sizeof(diGlobalsInstance->gameKeyStates)); 201 | } 202 | else 203 | { 204 | memset(rgdod, 0, *pdwInOut * sizeof(DIDEVICEOBJECTDATA)); 205 | 206 | if (true) 207 | { 208 | for (DWORD i = 0; i < *pdwInOut; i++) 209 | { 210 | if (diGlobalsInstance->mouseStateDeviceData->lX != 0) 211 | { 212 | //diGlobalsInstance->LogA("MouseDevice->GetDeviceData() sending DIMOFS_X: %i", __FILE__, __LINE__, diGlobalsInstance->mouseStateDeviceData->lX); 213 | 214 | rgdod[i].dwData = diGlobalsInstance->mouseStateDeviceData->lX; 215 | rgdod[i].dwOfs = DIMOFS_X; 216 | rgdod[i].dwSequence = diGlobalsInstance->dwSequence; 217 | rgdod[i].dwTimeStamp = (DWORD)fTime; 218 | rgdod[i].uAppData = NULL; 219 | 220 | diGlobalsInstance->dwSequence++; 221 | diGlobalsInstance->mouseStateDeviceData->lX = 0; 222 | dwOut++; 223 | } 224 | else if (diGlobalsInstance->mouseStateDeviceData->lY != 0) 225 | { 226 | //diGlobalsInstance->LogA("MouseDevice->GetDeviceData() sending DIMOFS_Y: %i", __FILE__, __LINE__, diGlobalsInstance->mouseStateDeviceData->lY); 227 | 228 | rgdod[i].dwData = diGlobalsInstance->mouseStateDeviceData->lY; 229 | rgdod[i].dwOfs = DIMOFS_Y; 230 | rgdod[i].dwSequence = diGlobalsInstance->dwSequence; 231 | rgdod[i].dwTimeStamp = (DWORD)fTime; 232 | rgdod[i].uAppData = NULL; 233 | 234 | diGlobalsInstance->dwSequence++; 235 | diGlobalsInstance->mouseStateDeviceData->lY = 0; 236 | dwOut++; 237 | } 238 | else if (diGlobalsInstance->mouseStateDeviceData->lZ != 0) 239 | { 240 | //diGlobalsInstance->LogA("MouseDevice->GetDeviceData() sending DIMOFS_Z: %i", __FILE__, __LINE__, diGlobalsInstance->mouseStateDeviceData->lZ); 241 | 242 | rgdod[i].dwData = diGlobalsInstance->mouseStateDeviceData->lZ; 243 | rgdod[i].dwOfs = DIMOFS_Z; 244 | rgdod[i].dwSequence = diGlobalsInstance->dwSequence; 245 | rgdod[i].dwTimeStamp = (DWORD)fTime; 246 | rgdod[i].uAppData = NULL; 247 | 248 | diGlobalsInstance->dwSequence++; 249 | diGlobalsInstance->mouseStateDeviceData->lZ = 0; 250 | dwOut++; 251 | } 252 | else if (diGlobalsInstance->mouseStateDeviceData->rgbButtons[0] != diGlobalsInstance->mouseStateDeviceDataGame->rgbButtons[0]) { 253 | //diGlobalsInstance->LogA("MouseDevice->GetDeviceData() sending DIMOFS_BUTTON0: %i", __FILE__, __LINE__, diGlobalsInstance->mouseStateDeviceData->rgbButtons[0]); 254 | 255 | rgdod[i].dwData = diGlobalsInstance->mouseStateDeviceData->rgbButtons[0]; 256 | rgdod[i].dwOfs = DIMOFS_BUTTON0; 257 | rgdod[i].dwSequence = diGlobalsInstance->dwSequence; 258 | rgdod[i].dwTimeStamp = (DWORD)fTime; 259 | rgdod[i].uAppData = NULL; 260 | 261 | diGlobalsInstance->dwSequence++; 262 | diGlobalsInstance->mouseStateDeviceDataGame->rgbButtons[0] = diGlobalsInstance->mouseStateDeviceData->rgbButtons[0]; 263 | dwOut++; 264 | } 265 | else if (diGlobalsInstance->mouseStateDeviceData->rgbButtons[1] != diGlobalsInstance->mouseStateDeviceDataGame->rgbButtons[1]) { 266 | //diGlobalsInstance->LogA("MouseDevice->GetDeviceData() sending DIMOFS_BUTTON1: %i", __FILE__, __LINE__, diGlobalsInstance->mouseStateDeviceData->rgbButtons[1]); 267 | 268 | rgdod[i].dwData = diGlobalsInstance->mouseStateDeviceData->rgbButtons[1]; 269 | rgdod[i].dwOfs = DIMOFS_BUTTON1; 270 | rgdod[i].dwSequence = diGlobalsInstance->dwSequence; 271 | rgdod[i].dwTimeStamp = (DWORD)fTime; 272 | rgdod[i].uAppData = NULL; 273 | 274 | diGlobalsInstance->dwSequence++; 275 | diGlobalsInstance->mouseStateDeviceDataGame->rgbButtons[1] = diGlobalsInstance->mouseStateDeviceData->rgbButtons[1]; 276 | dwOut++; 277 | } 278 | else if (diGlobalsInstance->mouseStateDeviceData->rgbButtons[2] != diGlobalsInstance->mouseStateDeviceDataGame->rgbButtons[2]) { 279 | //diGlobalsInstance->LogA("MouseDevice->GetDeviceData() sending DIMOFS_BUTTON2: %i", __FILE__, __LINE__, diGlobalsInstance->mouseStateDeviceData->rgbButtons[2]); 280 | 281 | rgdod[i].dwData = diGlobalsInstance->mouseStateDeviceData->rgbButtons[2]; 282 | rgdod[i].dwOfs = DIMOFS_BUTTON2; 283 | rgdod[i].dwSequence = diGlobalsInstance->dwSequence; 284 | rgdod[i].dwTimeStamp = (DWORD)fTime; 285 | rgdod[i].uAppData = NULL; 286 | 287 | diGlobalsInstance->dwSequence++; 288 | diGlobalsInstance->mouseStateDeviceDataGame->rgbButtons[2] = diGlobalsInstance->mouseStateDeviceData->rgbButtons[2]; 289 | dwOut++; 290 | } 291 | } 292 | } 293 | } 294 | } 295 | diGlobalsInstance->Unlock(); 296 | 297 | *pdwInOut = dwOut; 298 | return DI_OK; 299 | } 300 | 301 | HRESULT STDMETHODCALLTYPE Base_SetDataFormat(LPCDIDATAFORMAT lpdf) 302 | { 303 | diGlobalsInstance->LogA("MouseDevice->SetDataFormat()", __FILE__, __LINE__); 304 | memcpy(&dataFormat, lpdf, sizeof(DIDATAFORMAT)); 305 | diGlobalsInstance->LogA("- dwFlags: %x", __FILE__, __LINE__,dataFormat.dwFlags); 306 | diGlobalsInstance->LogA("- dwNumObjs: %i", __FILE__, __LINE__, dataFormat.dwNumObjs); 307 | diGlobalsInstance->LogA("- dwSize: %i", __FILE__, __LINE__, dataFormat.dwSize); 308 | diGlobalsInstance->LogA("- dwDataSize: %i", __FILE__, __LINE__, dataFormat.dwDataSize); 309 | diGlobalsInstance->LogA("- dwObjSize: %i", __FILE__, __LINE__, dataFormat.dwObjSize); 310 | return DI_OK; 311 | } 312 | 313 | HRESULT STDMETHODCALLTYPE Base_SetEventNotification(HANDLE hEvent) 314 | { 315 | diGlobalsInstance->LogA("MouseDevice->SetEventNotification(hEvent: %x)", __FILE__, __LINE__,hEvent); 316 | diGlobalsInstance->Lock(); 317 | { 318 | diGlobalsInstance->mouseEventHandle = hEvent; 319 | } 320 | diGlobalsInstance->Unlock(); 321 | 322 | return E_NOTIMPL; 323 | } 324 | 325 | HRESULT STDMETHODCALLTYPE Base_SetCooperativeLevel(HWND hwnd, DWORD dwFlags) 326 | { 327 | diGlobalsInstance->LogA("MouseDevice->SetCooperativeLevel(dwFlags: %x)", __FILE__, __LINE__, dwFlags); 328 | diGlobalsInstance->LogA("-> DISCL_EXCLUSIVE: %i", __FILE__, __LINE__, (dwFlags & DISCL_EXCLUSIVE) ? 1 :0); 329 | diGlobalsInstance->LogA("-> DISCL_BACKGROUND: %i", __FILE__, __LINE__, (dwFlags & DISCL_BACKGROUND) ? 1 :0); 330 | diGlobalsInstance->LogA("-> DISCL_FOREGROUND: %i", __FILE__, __LINE__, (dwFlags & DISCL_FOREGROUND) ? 1 : 0); 331 | diGlobalsInstance->LogA("-> DISCL_NONEXCLUSIVE: %i", __FILE__, __LINE__, (dwFlags & DISCL_NONEXCLUSIVE) ? 1 : 0); 332 | diGlobalsInstance->LogA("-> DISCL_NOWINKEY: %i", __FILE__, __LINE__, (dwFlags & DISCL_NOWINKEY) ? 1 : 0); 333 | 334 | this->exclusiveMode = ((dwFlags & DISCL_EXCLUSIVE) > 0); 335 | 336 | return DI_OK; 337 | } 338 | 339 | HRESULT STDMETHODCALLTYPE Base_RunControlPanel(HWND hwndOwner, DWORD dwFlags) 340 | { 341 | diGlobalsInstance->LogA("MouseDevice->RunControlPanel()", __FILE__, __LINE__); 342 | 343 | return E_NOTIMPL; 344 | } 345 | 346 | HRESULT STDMETHODCALLTYPE Base_Initialize(HINSTANCE hInst, DWORD dwVersion, GUID* rguid) 347 | { 348 | diGlobalsInstance->LogA("MouseDevice->Initialize()", __FILE__, __LINE__); 349 | 350 | return DI_OK; 351 | } 352 | 353 | HRESULT STDMETHODCALLTYPE Base_CreateEffect(GUID* rguid, LPCDIEFFECT lpeff, LPDIRECTINPUTEFFECT* ppdeff, LPUNKNOWN punkOuter) 354 | { 355 | diGlobalsInstance->LogA("MouseDevice->CreateEffect()", __FILE__, __LINE__); 356 | 357 | return E_NOTIMPL; 358 | } 359 | 360 | HRESULT STDMETHODCALLTYPE Base_GetForceFeedbackState(LPDWORD pdwOut) 361 | { 362 | diGlobalsInstance->LogA("MouseDevice->GetForceFeedbackState()", __FILE__, __LINE__); 363 | 364 | return E_NOTIMPL; 365 | } 366 | 367 | HRESULT STDMETHODCALLTYPE Base_SendForceFeedbackCommand(DWORD dwFlags) 368 | { 369 | diGlobalsInstance->LogA("MouseDevice->SendForceFeedbackCommand()", __FILE__, __LINE__); 370 | 371 | return E_NOTIMPL; 372 | } 373 | 374 | HRESULT STDMETHODCALLTYPE Base_EnumCreatedEffectObjects(LPDIENUMCREATEDEFFECTOBJECTSCALLBACK lpCallback, LPVOID pvRef, DWORD fl) 375 | { 376 | diGlobalsInstance->LogA("MouseDevice->EnumCreatedEffectObjects()", __FILE__, __LINE__); 377 | 378 | return E_NOTIMPL; 379 | } 380 | 381 | HRESULT STDMETHODCALLTYPE Base_Escape(LPDIEFFESCAPE pesc) 382 | { 383 | diGlobalsInstance->LogA("MouseDevice->Escape()", __FILE__, __LINE__); 384 | 385 | return E_NOTIMPL; 386 | } 387 | 388 | HRESULT STDMETHODCALLTYPE Base_Poll() { 389 | diGlobalsInstance->LogA("MouseDevice->Poll()", __FILE__, __LINE__); 390 | 391 | return DI_NOEFFECT; 392 | } 393 | 394 | HRESULT STDMETHODCALLTYPE Base_SendDeviceData(DWORD cbObjectData, LPCDIDEVICEOBJECTDATA rgdod, LPDWORD pdwInOut, DWORD fl) { 395 | diGlobalsInstance->LogA("MouseDevice->SendDeviceData() - unhandled", __FILE__, __LINE__); 396 | 397 | return E_NOTIMPL; 398 | } 399 | }; -------------------------------------------------------------------------------- /dinput8wrapper/CDirectInputDeviceMouse8A.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | class CDirectInputDeviceMouse8A : public CDirectInputDeviceMouse8, public IDirectInputDevice8A 4 | { 5 | private: 6 | DIDEVICEINSTANCEA* mouseDeviceInfo; 7 | 8 | public: 9 | 10 | CDirectInputDeviceMouse8A() : CDirectInputDeviceMouse8() 11 | { 12 | mouseDeviceInfo = new DIDEVICEINSTANCEA(); 13 | ZeroMemory(mouseDeviceInfo, sizeof(DIDEVICEINSTANCEA)); 14 | mouseDeviceInfo->dwSize = sizeof(DIDEVICEINSTANCEA); 15 | mouseDeviceInfo->guidInstance = GUID_SysMouse; 16 | mouseDeviceInfo->guidProduct = GUID_SysMouse; 17 | mouseDeviceInfo->dwDevType = DI8DEVTYPE_MOUSE | (DI8DEVTYPEMOUSE_UNKNOWN << 8); 18 | StringCbCopyA(mouseDeviceInfo->tszInstanceName, 260, "Mouse"); 19 | StringCbCopyA(mouseDeviceInfo->tszProductName, 260, "Mouse"); 20 | 21 | this->dwDevType = mouseDeviceInfo->dwDevType; 22 | } 23 | 24 | 25 | 26 | virtual HRESULT STDMETHODCALLTYPE QueryInterface(GUID* riid, LPVOID* ppvObj) 27 | { 28 | return Base_QueryInterface(riid, ppvObj); 29 | }; 30 | 31 | virtual ULONG __stdcall AddRef() 32 | { 33 | return Base_AddRef(); 34 | } 35 | 36 | virtual ULONG __stdcall Release() 37 | { 38 | return Base_Release(); 39 | } 40 | 41 | 42 | virtual HRESULT STDMETHODCALLTYPE GetCapabilities(LPDIDEVCAPS lpDIDevCaps) { 43 | return Base_GetCapabilities(lpDIDevCaps); 44 | } 45 | 46 | virtual HRESULT STDMETHODCALLTYPE GetProperty(GUID* rguidProp, LPDIPROPHEADER pdiph) { 47 | 48 | return Base_GetProperty(rguidProp, pdiph); 49 | } 50 | 51 | virtual HRESULT STDMETHODCALLTYPE SetProperty(GUID* rguidProp, LPCDIPROPHEADER pdiph) { 52 | return Base_SetProperty(rguidProp, pdiph); 53 | } 54 | 55 | virtual HRESULT STDMETHODCALLTYPE Acquire() { 56 | return Base_Acquire(); 57 | } 58 | 59 | virtual HRESULT STDMETHODCALLTYPE Unacquire() { 60 | return Base_Unacquire(); 61 | } 62 | 63 | virtual HRESULT STDMETHODCALLTYPE GetDeviceState(DWORD cbData, LPVOID lpvData) { 64 | return Base_GetDeviceState(cbData, lpvData); 65 | } 66 | 67 | virtual HRESULT STDMETHODCALLTYPE GetDeviceData(DWORD cbObjectData, LPDIDEVICEOBJECTDATA rgdod, LPDWORD pdwInOut, DWORD dwFlags) { 68 | return Base_GetDeviceData(cbObjectData, rgdod, pdwInOut, dwFlags); 69 | } 70 | 71 | virtual HRESULT STDMETHODCALLTYPE SetDataFormat(LPCDIDATAFORMAT lpdf) 72 | { 73 | return Base_SetDataFormat(lpdf); 74 | } 75 | 76 | virtual HRESULT STDMETHODCALLTYPE SetEventNotification(HANDLE hEvent) 77 | { 78 | return Base_SetEventNotification(hEvent); 79 | } 80 | 81 | virtual HRESULT STDMETHODCALLTYPE SetCooperativeLevel(HWND hwnd, DWORD dwFlags) 82 | { 83 | return Base_SetCooperativeLevel(hwnd, dwFlags); 84 | } 85 | 86 | virtual HRESULT STDMETHODCALLTYPE RunControlPanel(HWND hwndOwner, DWORD dwFlags) 87 | { 88 | return Base_RunControlPanel(hwndOwner, dwFlags); 89 | } 90 | 91 | virtual HRESULT STDMETHODCALLTYPE Initialize(HINSTANCE hInst, DWORD dwVersion, GUID* rguid) 92 | { 93 | return Base_Initialize(hInst, dwVersion, rguid); 94 | } 95 | 96 | virtual HRESULT STDMETHODCALLTYPE CreateEffect(GUID* rguid, LPCDIEFFECT lpeff, LPDIRECTINPUTEFFECT* ppdeff, LPUNKNOWN punkOuter) 97 | { 98 | return Base_CreateEffect(rguid, lpeff, ppdeff, punkOuter); 99 | } 100 | 101 | virtual HRESULT STDMETHODCALLTYPE GetForceFeedbackState(LPDWORD pdwOut) 102 | { 103 | return Base_GetForceFeedbackState(pdwOut); 104 | } 105 | 106 | virtual HRESULT STDMETHODCALLTYPE SendForceFeedbackCommand(DWORD dwFlags) 107 | { 108 | return Base_SendForceFeedbackCommand(dwFlags); 109 | } 110 | 111 | virtual HRESULT STDMETHODCALLTYPE EnumCreatedEffectObjects(LPDIENUMCREATEDEFFECTOBJECTSCALLBACK lpCallback, LPVOID pvRef, DWORD fl) 112 | { 113 | return Base_EnumCreatedEffectObjects(lpCallback, pvRef, fl); 114 | } 115 | 116 | virtual HRESULT STDMETHODCALLTYPE Escape(LPDIEFFESCAPE pesc) 117 | { 118 | return Base_Escape(pesc); 119 | } 120 | 121 | virtual HRESULT STDMETHODCALLTYPE Poll() { 122 | return Base_Poll(); 123 | } 124 | 125 | virtual HRESULT STDMETHODCALLTYPE SendDeviceData(DWORD cbObjectData, LPCDIDEVICEOBJECTDATA rgdod, LPDWORD pdwInOut, DWORD fl) { 126 | return Base_SendDeviceData(cbObjectData, rgdod, pdwInOut, fl); 127 | } 128 | 129 | 130 | virtual HRESULT STDMETHODCALLTYPE EnumObjects(LPDIENUMDEVICEOBJECTSCALLBACKA lpCallback, LPVOID pvRef, DWORD dwFlags) { 131 | 132 | diGlobalsInstance->LogA("MouseDevice->EnumObjects()", __FILE__, __LINE__); 133 | 134 | return DI_OK; 135 | } 136 | 137 | virtual HRESULT STDMETHODCALLTYPE GetObjectInfo(LPDIDEVICEOBJECTINSTANCEA pdidoi, DWORD dwObj, DWORD dwHow) 138 | { 139 | diGlobalsInstance->LogA("MouseDevice->GetObjectInfo()", __FILE__, __LINE__); 140 | 141 | return E_NOTIMPL; 142 | } 143 | 144 | virtual HRESULT STDMETHODCALLTYPE GetDeviceInfo(LPDIDEVICEINSTANCEA pdidi) 145 | { 146 | diGlobalsInstance->LogA("MouseDevice->GetDeviceInfo()", __FILE__, __LINE__); 147 | memcpy(pdidi, mouseDeviceInfo, sizeof(DIDEVICEINSTANCEA)); 148 | 149 | return DI_OK; 150 | } 151 | 152 | virtual HRESULT STDMETHODCALLTYPE EnumEffects(LPDIENUMEFFECTSCALLBACKA lpCallback, LPVOID pvRef, DWORD dwEffType) 153 | { 154 | diGlobalsInstance->LogA("MouseDevice->EnumEffects()", __FILE__, __LINE__); 155 | 156 | return DI_OK; 157 | } 158 | 159 | virtual HRESULT STDMETHODCALLTYPE GetEffectInfo(LPDIEFFECTINFOA pdei, GUID* rguid) 160 | { 161 | diGlobalsInstance->LogA("MouseDevice->GetEffectInfo()", __FILE__, __LINE__); 162 | 163 | return E_NOTIMPL; 164 | } 165 | 166 | virtual HRESULT STDMETHODCALLTYPE EnumEffectsInFile(LPCSTR lpszFileName, LPDIENUMEFFECTSINFILECALLBACK pec, LPVOID pvRef, DWORD dwFlags) 167 | { 168 | diGlobalsInstance->LogA("MouseDevice->EnumEffectsInFile()", __FILE__, __LINE__); 169 | 170 | return E_NOTIMPL; 171 | } 172 | 173 | virtual HRESULT STDMETHODCALLTYPE WriteEffectToFile(LPCSTR lpszFileName, DWORD dwEntries, LPDIFILEEFFECT rgDiFileEft, DWORD dwFlags) 174 | { 175 | diGlobalsInstance->LogA("MouseDevice->WriteEffectToFile()", __FILE__, __LINE__); 176 | 177 | return E_NOTIMPL; 178 | } 179 | 180 | virtual HRESULT STDMETHODCALLTYPE BuildActionMap(LPDIACTIONFORMATA lpdiaf, LPCSTR lpszUserName, DWORD dwFlags) 181 | { 182 | diGlobalsInstance->LogA("MouseDevice->BuildActionMap()", __FILE__, __LINE__); 183 | 184 | return E_NOTIMPL; 185 | } 186 | 187 | virtual HRESULT STDMETHODCALLTYPE SetActionMap(LPDIACTIONFORMATA lpdiaf, LPCSTR lpszUserName, DWORD dwFlags) 188 | { 189 | diGlobalsInstance->LogA("MouseDevice->SetActionMap()", __FILE__, __LINE__); 190 | 191 | return E_NOTIMPL; 192 | } 193 | 194 | virtual HRESULT STDMETHODCALLTYPE GetImageInfo(LPDIDEVICEIMAGEINFOHEADERA lpdiDevImageInfoHeader) 195 | { 196 | diGlobalsInstance->LogA("MouseDevice->GetImageInfo()", __FILE__, __LINE__); 197 | 198 | return E_NOTIMPL; 199 | } 200 | }; -------------------------------------------------------------------------------- /dinput8wrapper/CDirectInputDeviceMouse8W.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | class CDirectInputDeviceMouse8W : public CDirectInputDeviceMouse8, public IDirectInputDevice8W 4 | { 5 | private: 6 | DIDEVICEINSTANCEW* mouseDeviceInfo; 7 | 8 | public: 9 | 10 | CDirectInputDeviceMouse8W() : CDirectInputDeviceMouse8() 11 | { 12 | mouseDeviceInfo = new DIDEVICEINSTANCEW(); 13 | ZeroMemory(mouseDeviceInfo, sizeof(DIDEVICEINSTANCEW)); 14 | mouseDeviceInfo->dwSize = sizeof(DIDEVICEINSTANCEW); 15 | mouseDeviceInfo->guidInstance = GUID_SysMouse; 16 | mouseDeviceInfo->guidProduct = GUID_SysMouse; 17 | mouseDeviceInfo->dwDevType = DI8DEVTYPE_MOUSE | (DI8DEVTYPEMOUSE_UNKNOWN << 8); 18 | StringCbCopyW(mouseDeviceInfo->tszInstanceName, 260, L"Mouse"); 19 | StringCbCopyW(mouseDeviceInfo->tszProductName, 260, L"Mouse"); 20 | 21 | this->dwDevType = mouseDeviceInfo->dwDevType; 22 | } 23 | 24 | virtual HRESULT STDMETHODCALLTYPE QueryInterface(GUID* riid, LPVOID* ppvObj) 25 | { 26 | return Base_QueryInterface(riid, ppvObj); 27 | }; 28 | 29 | virtual ULONG __stdcall AddRef() 30 | { 31 | return Base_AddRef(); 32 | } 33 | 34 | virtual ULONG __stdcall Release() 35 | { 36 | return Base_Release(); 37 | } 38 | 39 | 40 | virtual HRESULT STDMETHODCALLTYPE GetCapabilities(LPDIDEVCAPS lpDIDevCaps) { 41 | return Base_GetCapabilities(lpDIDevCaps); 42 | } 43 | 44 | virtual HRESULT STDMETHODCALLTYPE GetProperty(GUID* rguidProp, LPDIPROPHEADER pdiph) { 45 | 46 | return Base_GetProperty(rguidProp, pdiph); 47 | } 48 | 49 | virtual HRESULT STDMETHODCALLTYPE SetProperty(GUID* rguidProp, LPCDIPROPHEADER pdiph) { 50 | return Base_SetProperty(rguidProp, pdiph); 51 | } 52 | 53 | virtual HRESULT STDMETHODCALLTYPE Acquire() { 54 | return Base_Acquire(); 55 | } 56 | 57 | virtual HRESULT STDMETHODCALLTYPE Unacquire() { 58 | return Base_Unacquire(); 59 | } 60 | 61 | virtual HRESULT STDMETHODCALLTYPE GetDeviceState(DWORD cbData, LPVOID lpvData) { 62 | return Base_GetDeviceState(cbData, lpvData); 63 | } 64 | 65 | virtual HRESULT STDMETHODCALLTYPE GetDeviceData(DWORD cbObjectData, LPDIDEVICEOBJECTDATA rgdod, LPDWORD pdwInOut, DWORD dwFlags) { 66 | return Base_GetDeviceData(cbObjectData, rgdod, pdwInOut, dwFlags); 67 | } 68 | 69 | virtual HRESULT STDMETHODCALLTYPE SetDataFormat(LPCDIDATAFORMAT lpdf) 70 | { 71 | return Base_SetDataFormat(lpdf); 72 | } 73 | 74 | virtual HRESULT STDMETHODCALLTYPE SetEventNotification(HANDLE hEvent) 75 | { 76 | return Base_SetEventNotification(hEvent); 77 | } 78 | 79 | virtual HRESULT STDMETHODCALLTYPE SetCooperativeLevel(HWND hwnd, DWORD dwFlags) 80 | { 81 | return Base_SetCooperativeLevel(hwnd, dwFlags); 82 | } 83 | 84 | virtual HRESULT STDMETHODCALLTYPE RunControlPanel(HWND hwndOwner, DWORD dwFlags) 85 | { 86 | return Base_RunControlPanel(hwndOwner, dwFlags); 87 | } 88 | 89 | virtual HRESULT STDMETHODCALLTYPE Initialize(HINSTANCE hInst, DWORD dwVersion, GUID* rguid) 90 | { 91 | return Base_Initialize(hInst, dwVersion, rguid); 92 | } 93 | 94 | virtual HRESULT STDMETHODCALLTYPE CreateEffect(GUID* rguid, LPCDIEFFECT lpeff, LPDIRECTINPUTEFFECT* ppdeff, LPUNKNOWN punkOuter) 95 | { 96 | return Base_CreateEffect(rguid, lpeff, ppdeff, punkOuter); 97 | } 98 | 99 | virtual HRESULT STDMETHODCALLTYPE GetForceFeedbackState(LPDWORD pdwOut) 100 | { 101 | return Base_GetForceFeedbackState(pdwOut); 102 | } 103 | 104 | virtual HRESULT STDMETHODCALLTYPE SendForceFeedbackCommand(DWORD dwFlags) 105 | { 106 | return Base_SendForceFeedbackCommand(dwFlags); 107 | } 108 | 109 | virtual HRESULT STDMETHODCALLTYPE EnumCreatedEffectObjects(LPDIENUMCREATEDEFFECTOBJECTSCALLBACK lpCallback, LPVOID pvRef, DWORD fl) 110 | { 111 | return Base_EnumCreatedEffectObjects(lpCallback, pvRef, fl); 112 | } 113 | 114 | virtual HRESULT STDMETHODCALLTYPE Escape(LPDIEFFESCAPE pesc) 115 | { 116 | return Base_Escape(pesc); 117 | } 118 | 119 | virtual HRESULT STDMETHODCALLTYPE Poll() { 120 | return Base_Poll(); 121 | } 122 | 123 | virtual HRESULT STDMETHODCALLTYPE SendDeviceData(DWORD cbObjectData, LPCDIDEVICEOBJECTDATA rgdod, LPDWORD pdwInOut, DWORD fl) { 124 | return Base_SendDeviceData(cbObjectData, rgdod, pdwInOut, fl); 125 | } 126 | 127 | virtual HRESULT STDMETHODCALLTYPE EnumObjects(LPDIENUMDEVICEOBJECTSCALLBACKW lpCallback, LPVOID pvRef, DWORD dwFlags) { 128 | 129 | diGlobalsInstance->LogA("MouseDevice->EnumObjects()", __FILE__, __LINE__); 130 | 131 | return DI_OK; 132 | } 133 | 134 | virtual HRESULT STDMETHODCALLTYPE GetObjectInfo(LPDIDEVICEOBJECTINSTANCEW pdidoi, DWORD dwObj, DWORD dwHow) 135 | { 136 | diGlobalsInstance->LogA("MouseDevice->GetObjectInfo()", __FILE__, __LINE__); 137 | 138 | return E_NOTIMPL; 139 | } 140 | 141 | virtual HRESULT STDMETHODCALLTYPE GetDeviceInfo(LPDIDEVICEINSTANCEW pdidi) 142 | { 143 | diGlobalsInstance->LogA("MouseDevice->GetDeviceInfo()", __FILE__, __LINE__); 144 | memcpy(pdidi, mouseDeviceInfo, sizeof(DIDEVICEINSTANCEW)); 145 | 146 | return DI_OK; 147 | } 148 | 149 | virtual HRESULT STDMETHODCALLTYPE EnumEffects(LPDIENUMEFFECTSCALLBACKW lpCallback, LPVOID pvRef, DWORD dwEffType) 150 | { 151 | diGlobalsInstance->LogA("MouseDevice->EnumEffects()", __FILE__, __LINE__); 152 | 153 | return DI_OK; 154 | } 155 | 156 | virtual HRESULT STDMETHODCALLTYPE GetEffectInfo(LPDIEFFECTINFOW pdei, GUID* rguid) 157 | { 158 | diGlobalsInstance->LogA("MouseDevice->GetEffectInfo()", __FILE__, __LINE__); 159 | 160 | return E_NOTIMPL; 161 | } 162 | 163 | virtual HRESULT STDMETHODCALLTYPE EnumEffectsInFile(LPCWSTR lpszFileName, LPDIENUMEFFECTSINFILECALLBACK pec, LPVOID pvRef, DWORD dwFlags) 164 | { 165 | diGlobalsInstance->LogA("MouseDevice->EnumEffectsInFile()", __FILE__, __LINE__); 166 | 167 | return E_NOTIMPL; 168 | } 169 | 170 | virtual HRESULT STDMETHODCALLTYPE WriteEffectToFile(LPCWSTR lpszFileName, DWORD dwEntries, LPDIFILEEFFECT rgDiFileEft, DWORD dwFlags) 171 | { 172 | diGlobalsInstance->LogA("MouseDevice->WriteEffectToFile()", __FILE__, __LINE__); 173 | 174 | return E_NOTIMPL; 175 | } 176 | 177 | virtual HRESULT STDMETHODCALLTYPE BuildActionMap(LPDIACTIONFORMATW lpdiaf, LPCWSTR lpszUserName, DWORD dwFlags) 178 | { 179 | diGlobalsInstance->LogA("MouseDevice->BuildActionMap()", __FILE__, __LINE__); 180 | 181 | return E_NOTIMPL; 182 | } 183 | 184 | virtual HRESULT STDMETHODCALLTYPE SetActionMap(LPDIACTIONFORMATW lpdiaf, LPCWSTR lpszUserName, DWORD dwFlags) 185 | { 186 | diGlobalsInstance->LogA("MouseDevice->SetActionMap()", __FILE__, __LINE__); 187 | 188 | return E_NOTIMPL; 189 | } 190 | 191 | virtual HRESULT STDMETHODCALLTYPE GetImageInfo(LPDIDEVICEIMAGEINFOHEADERW lpdiDevImageInfoHeader) 192 | { 193 | diGlobalsInstance->LogA("MouseDevice->GetImageInfo()", __FILE__, __LINE__); 194 | 195 | return E_NOTIMPL; 196 | } 197 | 198 | 199 | }; -------------------------------------------------------------------------------- /dinput8wrapper/Resource.rc: -------------------------------------------------------------------------------- 1 | // Microsoft Visual C++ generated resource script. 2 | // 3 | #include "resource.h" 4 | 5 | #define APSTUDIO_READONLY_SYMBOLS 6 | ///////////////////////////////////////////////////////////////////////////// 7 | // 8 | // Generated from the TEXTINCLUDE 2 resource. 9 | // 10 | #include "winres.h" 11 | 12 | ///////////////////////////////////////////////////////////////////////////// 13 | #undef APSTUDIO_READONLY_SYMBOLS 14 | 15 | ///////////////////////////////////////////////////////////////////////////// 16 | // German (Germany) resources 17 | 18 | #if !defined(AFX_RESOURCE_DLL) || defined(AFX_TARG_DEU) 19 | LANGUAGE LANG_GERMAN, SUBLANG_GERMAN 20 | #pragma code_page(1252) 21 | 22 | #ifdef APSTUDIO_INVOKED 23 | ///////////////////////////////////////////////////////////////////////////// 24 | // 25 | // TEXTINCLUDE 26 | // 27 | 28 | 1 TEXTINCLUDE 29 | BEGIN 30 | "resource.h\0" 31 | END 32 | 33 | 2 TEXTINCLUDE 34 | BEGIN 35 | "#include ""winres.h""\r\n" 36 | "\0" 37 | END 38 | 39 | 3 TEXTINCLUDE 40 | BEGIN 41 | "\r\n" 42 | "\0" 43 | END 44 | 45 | #endif // APSTUDIO_INVOKED 46 | 47 | 48 | ///////////////////////////////////////////////////////////////////////////// 49 | // 50 | // Version 51 | // 52 | 53 | VS_VERSION_INFO VERSIONINFO 54 | FILEVERSION 1,0,0,4 55 | PRODUCTVERSION 1,0,0,4 56 | FILEFLAGSMASK 0x3fL 57 | #ifdef _DEBUG 58 | FILEFLAGS 0x1L 59 | #else 60 | FILEFLAGS 0x0L 61 | #endif 62 | FILEOS 0x40004L 63 | FILETYPE 0x2L 64 | FILESUBTYPE 0x0L 65 | BEGIN 66 | BLOCK "StringFileInfo" 67 | BEGIN 68 | BLOCK "040904b0" 69 | BEGIN 70 | VALUE "CompanyName", "geeky" 71 | VALUE "FileDescription", "DirectInput8-Wrapper - Internally uses Raw-Input" 72 | VALUE "FileVersion", "1.0.0.4" 73 | VALUE "InternalName", "dinput8.dll" 74 | VALUE "LegalCopyright", "Copyright (C) 2020 geeky" 75 | VALUE "OriginalFilename", "dinput8.dll" 76 | VALUE "ProductName", "DirectInput8-Wrapper - Internally uses Raw-Input" 77 | VALUE "ProductVersion", "1.0.0.4" 78 | END 79 | END 80 | BLOCK "VarFileInfo" 81 | BEGIN 82 | VALUE "Translation", 0x409, 1200 83 | END 84 | END 85 | 86 | #endif // German (Germany) resources 87 | ///////////////////////////////////////////////////////////////////////////// 88 | 89 | 90 | 91 | #ifndef APSTUDIO_INVOKED 92 | ///////////////////////////////////////////////////////////////////////////// 93 | // 94 | // Generated from the TEXTINCLUDE 3 resource. 95 | // 96 | 97 | 98 | ///////////////////////////////////////////////////////////////////////////// 99 | #endif // not APSTUDIO_INVOKED 100 | 101 | -------------------------------------------------------------------------------- /dinput8wrapper/dinput8.def: -------------------------------------------------------------------------------- 1 | LIBRARY "dinput8.dll" 2 | 3 | EXPORTS 4 | DirectInput8Create @1 5 | DllCanUnloadNow PRIVATE 6 | DllGetClassObject PRIVATE 7 | DllRegisterServer PRIVATE 8 | DllUnregisterServer PRIVATE 9 | GetdfDIJoystick @6 -------------------------------------------------------------------------------- /dinput8wrapper/dinput8.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #define HID_USAGE_PAGE_GENERIC 0x01 4 | #define HID_USAGE_GENERIC_MOUSE 0x02 5 | #define HID_USAGE_GENERIC_JOYSTICK 0x04 6 | #define HID_USAGE_GENERIC_GAMEPAD 0x05 7 | #define HID_USAGE_GENERIC_KEYBOARD 0x06 8 | 9 | #define DEFINE_GUID2(name, l, w1, w2, b1, b2, b3, b4, b5, b6, b7, b8) \ 10 | const GUID name \ 11 | = { l, w1, w2, { b1, b2, b3, b4, b5, b6, b7, b8 } } 12 | 13 | DEFINE_GUID2(GUID_Key , 0x55728220, 0xD33C, 0x11CF, 0xBF, 0xC7, 0x44, 0x45, 0x53, 0x54, 0x00, 0x00); 14 | DEFINE_GUID2(GUID_SysMouse , 0x6F1D2B60, 0xD5A0, 0x11CF, 0xBF, 0xC7, 0x44, 0x45, 0x53, 0x54, 0x00, 0x00); 15 | DEFINE_GUID2(GUID_SysKeyboard , 0x6F1D2B61, 0xD5A0, 0x11CF, 0xBF, 0xC7, 0x44, 0x45, 0x53, 0x54, 0x00, 0x00); 16 | DEFINE_GUID2(GUID_Xbox360Controller, 0x028E045E, 0x0000, 0x0000, 0x00, 0x00, 0x50, 0x49 ,0x44, 0x56, 0x49, 0x44); 17 | 18 | DEFINE_GUID2(GUID_XAxis , 0xA36D02E0, 0xC9F3, 0x11CF, 0xBF, 0xC7, 0x44, 0x45, 0x53, 0x54, 0x00, 0x00); 19 | 20 | #define DIDOI_GUIDISUSAGE 0x00010000 21 | 22 | #define DIPH_DEVICE 0 23 | #define DIPH_BYOFFSET 1 24 | 25 | #define DIMOFS_X 0x00000000 26 | #define DIMOFS_Y 0x00000004 27 | #define DIMOFS_Z 0x00000008 28 | #define DIMOFS_BUTTON0 0x0000000C 29 | #define DIMOFS_BUTTON1 0x0000000D 30 | #define DIMOFS_BUTTON2 0x0000000E 31 | #define DIMOFS_BUTTON3 0x0000000F 32 | #define DIMOFS_BUTTON4 0x00000010 33 | #define DIMOFS_BUTTON5 0x00000011 34 | #define DIMOFS_BUTTON6 0x00000012 35 | #define DIMOFS_BUTTON7 0x00000013 36 | 37 | #define DIGFFS_POWEROFF 0x00000080 38 | #define DIGFFS_EMPTY 0x00000001 39 | 40 | #define IS_DIPROP(x) (((ULONG_PTR)(x) >> 16) == 0) 41 | 42 | #define MAKEDIPROP(prop) (*(const GUID *)(prop)) 43 | #define DIPROP_BUFFERSIZE MAKEDIPROP(1) 44 | #define DIPROP_AXISMODE MAKEDIPROP(2) 45 | 46 | #define DIPROPAXISMODE_ABS 0 47 | #define DIPROPAXISMODE_REL 1 48 | 49 | #define DIPROP_GRANULARITY MAKEDIPROP(3) 50 | #define DIPROP_RANGE MAKEDIPROP(4) 51 | #define DIPROP_DEADZONE MAKEDIPROP(5) 52 | #define DIPROP_SATURATION MAKEDIPROP(6) 53 | #define DIPROP_FFGAIN MAKEDIPROP(7) 54 | #define DIPROP_FFLOAD MAKEDIPROP(8) 55 | #define DIPROP_AUTOCENTER MAKEDIPROP(9) 56 | 57 | #define DIPROPAUTOCENTER_OFF 0 58 | #define DIPROPAUTOCENTER_ON 1 59 | 60 | #define DIPROP_CALIBRATIONMODE MAKEDIPROP(10) 61 | 62 | #define DIPROPCALIBRATIONMODE_COOKED 0 63 | #define DIPROPCALIBRATIONMODE_RAW 1 64 | 65 | #define DIPROP_CALIBRATION MAKEDIPROP(11) 66 | #define DIPROP_GUIDANDPATH MAKEDIPROP(12) 67 | 68 | #define DIPROP_INSTANCENAME MAKEDIPROP(13) 69 | #define DIPROP_PRODUCTNAME MAKEDIPROP(14) 70 | #define DIPROP_JOYSTICKID MAKEDIPROP(15) 71 | 72 | #define DIPROP_KEYNAME MAKEDIPROP(20) 73 | #define DIPROP_CPOINTS MAKEDIPROP(21) 74 | #define DIPROP_APPDATA MAKEDIPROP(22) 75 | #define DIPROP_SCANCODE MAKEDIPROP(23) 76 | #define DIPROP_VIDPID MAKEDIPROP(24) 77 | #define DIPROP_USERNAME MAKEDIPROP(25) 78 | #define DIPROP_TYPENAME MAKEDIPROP(26) 79 | 80 | #define DIK_ESCAPE 0x01 81 | #define DIK_1 0x02 82 | #define DIK_2 0x03 83 | #define DIK_3 0x04 84 | #define DIK_4 0x05 85 | #define DIK_5 0x06 86 | #define DIK_6 0x07 87 | #define DIK_7 0x08 88 | #define DIK_8 0x09 89 | #define DIK_9 0x0A 90 | #define DIK_0 0x0B 91 | #define DIK_MINUS 0x0C 92 | #define DIK_EQUALS 0x0D 93 | #define DIK_BACK 0x0E 94 | #define DIK_TAB 0x0F 95 | #define DIK_Q 0x10 96 | #define DIK_W 0x11 97 | #define DIK_E 0x12 98 | #define DIK_R 0x13 99 | #define DIK_T 0x14 100 | #define DIK_Y 0x15 101 | #define DIK_U 0x16 102 | #define DIK_I 0x17 103 | #define DIK_O 0x18 104 | #define DIK_P 0x19 105 | #define DIK_LBRACKET 0x1A 106 | #define DIK_RBRACKET 0x1B 107 | #define DIK_RETURN 0x1C 108 | #define DIK_LCONTROL 0x1D 109 | #define DIK_A 0x1E 110 | #define DIK_S 0x1F 111 | #define DIK_D 0x20 112 | #define DIK_F 0x21 113 | #define DIK_G 0x22 114 | #define DIK_H 0x23 115 | #define DIK_J 0x24 116 | #define DIK_K 0x25 117 | #define DIK_L 0x26 118 | #define DIK_SEMICOLON 0x27 119 | #define DIK_APOSTROPHE 0x28 120 | #define DIK_GRAVE 0x29 121 | #define DIK_LSHIFT 0x2A 122 | #define DIK_BACKSLASH 0x2B 123 | #define DIK_Z 0x2C 124 | #define DIK_X 0x2D 125 | #define DIK_C 0x2E 126 | #define DIK_V 0x2F 127 | #define DIK_B 0x30 128 | #define DIK_N 0x31 129 | #define DIK_M 0x32 130 | #define DIK_COMMA 0x33 131 | #define DIK_PERIOD 0x34 132 | #define DIK_SLASH 0x35 133 | #define DIK_RSHIFT 0x36 134 | #define DIK_MULTIPLY 0x37 135 | #define DIK_LMENU 0x38 136 | #define DIK_SPACE 0x39 137 | #define DIK_CAPITAL 0x3A 138 | #define DIK_F1 0x3B 139 | #define DIK_F2 0x3C 140 | #define DIK_F3 0x3D 141 | #define DIK_F4 0x3E 142 | #define DIK_F5 0x3F 143 | #define DIK_F6 0x40 144 | #define DIK_F7 0x41 145 | #define DIK_F8 0x42 146 | #define DIK_F9 0x43 147 | #define DIK_F10 0x44 148 | #define DIK_NUMLOCK 0x45 149 | #define DIK_SCROLL 0x46 150 | #define DIK_NUMPAD7 0x47 151 | #define DIK_NUMPAD8 0x48 152 | #define DIK_NUMPAD9 0x49 153 | #define DIK_SUBTRACT 0x4A 154 | #define DIK_NUMPAD4 0x4B 155 | #define DIK_NUMPAD5 0x4C 156 | #define DIK_NUMPAD6 0x4D 157 | #define DIK_ADD 0x4E 158 | #define DIK_NUMPAD1 0x4F 159 | #define DIK_NUMPAD2 0x50 160 | #define DIK_NUMPAD3 0x51 161 | #define DIK_NUMPAD0 0x52 162 | #define DIK_DECIMAL 0x53 163 | #define DIK_F11 0x57 164 | #define DIK_F12 0x58 165 | #define DIK_F13 0x64 166 | #define DIK_F14 0x65 167 | #define DIK_F15 0x66 168 | #define DIK_KANA 0x70 169 | #define DIK_CONVERT 0x79 170 | #define DIK_NOCONVERT 0x7B 171 | #define DIK_YEN 0x7D 172 | #define DIK_NUMPADEQUALS 0x8D 173 | #define DIK_CIRCUMFLEX 0x90 174 | #define DIK_AT 0x91 175 | #define DIK_COLON 0x92 176 | #define DIK_UNDERLINE 0x93 177 | #define DIK_KANJI 0x94 178 | #define DIK_STOP 0x95 179 | #define DIK_AX 0x96 180 | #define DIK_UNLABELED 0x97 181 | #define DIK_NUMPADENTER 0x9C 182 | #define DIK_RCONTROL 0x9D 183 | #define DIK_NUMPADCOMMA 0xB3 184 | #define DIK_DIVIDE 0xB5 185 | #define DIK_SYSRQ 0xB7 186 | #define DIK_RMENU 0xB8 187 | #define DIK_PAUSE 0xC5 188 | #define DIK_HOME 0xC7 189 | #define DIK_UP 0xC8 190 | #define DIK_PRIOR 0xC9 191 | #define DIK_LEFT 0xCB 192 | #define DIK_RIGHT 0xCD 193 | #define DIK_END 0xCF 194 | #define DIK_DOWN 0xD0 195 | #define DIK_NEXT 0xD1 196 | #define DIK_INSERT 0xD2 197 | #define DIK_DELETE 0xD3 198 | #define DIK_LWIN 0xDB 199 | #define DIK_RWIN 0xDC 200 | #define DIK_APPS 0xDD 201 | #define DIK_POWER 0xDE 202 | #define DIK_SLEEP 0xDF 203 | 204 | #define DI8DEVCLASS_ALL 0x00 205 | #define DI8DEVCLASS_POINTER 0x02 206 | #define DI8DEVCLASS_KEYBOARD 0x03 207 | #define DI8DEVCLASS_GAMECTRL 0x04 208 | #define DIDEVTYPE_HID 0x00010000L 209 | 210 | #define DI8DEVTYPE_MOUSE 0x12 211 | #define DI8DEVTYPE_KEYBOARD 0x13 212 | #define DI8DEVTYPE_JOYSTICK 0x14 213 | #define DI8DEVTYPE_GAMEPAD 0x15 214 | 215 | 216 | 217 | #define DI8DEVTYPEMOUSE_UNKNOWN 1 218 | #define DI8DEVTYPEMOUSE_TRADITIONAL 2 219 | 220 | #define DIDEVTYPEKEYBOARD_PCENH 4 221 | 222 | #define DI8DEVTYPEGAMEPAD_STANDARD 2 223 | 224 | #define DIENUM_STOP 0 225 | #define DIENUM_CONTINUE 1 226 | 227 | #define DI_OK S_OK 228 | #define DIERR_INVALIDPARAM E_INVALIDARG 229 | #define DIERR_UNSUPPORTED E_NOTIMPL 230 | #define DIERR_INPUTLOST 0x8007001E 231 | #define DI_NOEFFECT S_FALSE 232 | 233 | HRESULT WINAPI DirectInput8Create(HINSTANCE hinst, DWORD dwVersion, GUID* riidltf, LPVOID* ppvOut, LPUNKNOWN punkOuter); 234 | 235 | #define DIRECTINPUT_VERSION 0x0800 236 | 237 | #define DIDC_ATTACHED 1 238 | #define DIDC_EMULATED 4 239 | 240 | #define DIDFT_OPTIONAL 0x80000000 241 | #define DIDFT_ABSAXIS 0x00000002 242 | #define DIDFT_ALIAS 0x08000000 243 | #define DIDFT_ALL 0x00000000 244 | #define DIDFT_AXIS 0x00000003 245 | #define DIDFT_BUTTON 0x0000000C 246 | #define DIDFT_COLLECTION 0x00000040 247 | #define DIDFT_ENUMCOLLECTION(n) ((WORD)(n) << 8) 248 | #define DIDFT_FFACTUATOR 0x01000000 249 | #define DIDFT_FFEFFECTTRIGGER 0x02000000 250 | #define DIDFT_NOCOLLECTION 0x00FFFF00 251 | #define DIDFT_NODATA 0x00000080 252 | #define DIDFT_OUTPUT 0x10000000 253 | #define DIDFT_POV 0x00000010 254 | #define DIDFT_PSHBUTTON 0x00000004 255 | #define DIDFT_RELAXIS 0x00000001 256 | #define DIDFT_TGLBUTTON 0x00000008 257 | #define DIDFT_VENDORDEFINED 0x04000000 258 | 259 | #define DISCL_EXCLUSIVE 0x00000001 260 | #define DISCL_NONEXCLUSIVE 0x00000002 261 | #define DISCL_FOREGROUND 0x00000004 262 | #define DISCL_BACKGROUND 0x00000008 263 | #define DISCL_NOWINKEY 0x00000010 264 | 265 | typedef struct DIMOUSESTATE { 266 | LONG lX; 267 | LONG lY; 268 | LONG lZ; 269 | BYTE rgbButtons[4]; 270 | } DIMOUSESTATE, * LPDIMOUSESTATE; 271 | 272 | typedef struct DIJOYSTATE { 273 | LONG lX; 274 | LONG lY; 275 | LONG lZ; 276 | LONG lRx; 277 | LONG lRy; 278 | LONG lRz; 279 | LONG rglSlider[2]; 280 | DWORD rgdwPOV[4]; 281 | BYTE rgbButtons[32]; 282 | } DIJOYSTATE, * LPDIJOYSTATE; 283 | 284 | typedef struct DIJOYSTATE2 { 285 | LONG lX; 286 | LONG lY; 287 | LONG lZ; 288 | LONG lRx; 289 | LONG lRy; 290 | LONG lRz; 291 | LONG rglSlider[2]; 292 | DWORD rgdwPOV[4]; 293 | BYTE rgbButtons[128]; 294 | LONG lVX; 295 | LONG lVY; 296 | LONG lVZ; 297 | LONG lVRx; 298 | LONG lVRy; 299 | LONG lVRz; 300 | LONG rglVSlider[2]; 301 | LONG lAX; 302 | LONG lAY; 303 | LONG lAZ; 304 | LONG lARx; 305 | LONG lARy; 306 | LONG lARz; 307 | LONG rglASlider[2]; 308 | LONG lFX; 309 | LONG lFY; 310 | LONG lFZ; 311 | LONG lFRx; 312 | LONG lFRy; 313 | LONG lFRz; 314 | LONG rglFSlider[2]; 315 | } DIJOYSTATE2, * LPDIJOYSTATE2; 316 | 317 | typedef struct DIDEVCAPS { 318 | DWORD dwSize; 319 | DWORD dwFlags; 320 | DWORD dwDevType; 321 | DWORD dwAxes; 322 | DWORD dwButtons; 323 | DWORD dwPOVs; 324 | DWORD dwFFSamplePeriod; 325 | DWORD dwFFMinTimeResolution; 326 | DWORD dwFirmwareRevision; 327 | DWORD dwHardwareRevision; 328 | DWORD dwFFDriverVersion; 329 | } DIDEVCAPS, * LPDIDEVCAPS; 330 | 331 | typedef struct DIDEVICEOBJECTINSTANCEA { 332 | DWORD dwSize; 333 | GUID guidType; 334 | DWORD dwOfs; 335 | DWORD dwType; 336 | DWORD dwFlags; 337 | CHAR tszName[MAX_PATH]; 338 | DWORD dwFFMaxForce; 339 | DWORD dwFFForceResolution; 340 | WORD wCollectionNumber; 341 | WORD wDesignatorIndex; 342 | WORD wUsagePage; 343 | WORD wUsage; 344 | DWORD dwDimension; 345 | WORD wExponent; 346 | WORD wReportId; 347 | } DIDEVICEOBJECTINSTANCEA, * LPDIDEVICEOBJECTINSTANCEA; 348 | 349 | typedef struct DIDEVICEOBJECTINSTANCEW { 350 | DWORD dwSize; 351 | GUID guidType; 352 | DWORD dwOfs; 353 | DWORD dwType; 354 | DWORD dwFlags; 355 | WCHAR tszName[MAX_PATH]; 356 | DWORD dwFFMaxForce; 357 | DWORD dwFFForceResolution; 358 | WORD wCollectionNumber; 359 | WORD wDesignatorIndex; 360 | WORD wUsagePage; 361 | WORD wUsage; 362 | DWORD dwDimension; 363 | WORD wExponent; 364 | WORD wReportId; 365 | } DIDEVICEOBJECTINSTANCEW, * LPDIDEVICEOBJECTINSTANCEW; 366 | 367 | typedef struct DIPROPHEADER { 368 | DWORD dwSize; 369 | DWORD dwHeaderSize; 370 | DWORD dwObj; 371 | DWORD dwHow; 372 | } DIPROPHEADER, * LPDIPROPHEADER; 373 | typedef const DIPROPHEADER* LPCDIPROPHEADER; 374 | 375 | typedef struct DIPROPDWORD { 376 | DIPROPHEADER diph; 377 | DWORD dwData; 378 | } DIPROPDWORD, * LPDIPROPDWORD; 379 | typedef const DIPROPDWORD* LPCDIPROPDWORD; 380 | 381 | typedef struct DIPROPSTRING { 382 | DIPROPHEADER diph; 383 | WCHAR wsz[MAX_PATH]; 384 | } DIPROPSTRING, * LPDIPROPSTRING; 385 | typedef const DIPROPSTRING* LPCDIPROPSTRING; 386 | 387 | typedef const DIDEVICEOBJECTINSTANCEA* LPCDIDEVICEOBJECTINSTANCEA; 388 | typedef BOOL(FAR PASCAL* LPDIENUMDEVICEOBJECTSCALLBACKA)(LPCDIDEVICEOBJECTINSTANCEA, LPVOID); 389 | 390 | typedef const DIDEVICEOBJECTINSTANCEW* LPCDIDEVICEOBJECTINSTANCEW; 391 | typedef BOOL(FAR PASCAL* LPDIENUMDEVICEOBJECTSCALLBACKW)(LPCDIDEVICEOBJECTINSTANCEW, LPVOID); 392 | 393 | typedef struct DIDEVICEOBJECTDATA { 394 | DWORD dwOfs; 395 | DWORD dwData; 396 | DWORD dwTimeStamp; 397 | DWORD dwSequence; 398 | UINT_PTR uAppData; 399 | } DIDEVICEOBJECTDATA, * LPDIDEVICEOBJECTDATA; 400 | typedef const DIDEVICEOBJECTDATA* LPCDIDEVICEOBJECTDATA; 401 | 402 | typedef struct _DIOBJECTDATAFORMAT { 403 | const GUID* pguid; 404 | DWORD dwOfs; 405 | DWORD dwType; 406 | DWORD dwFlags; 407 | } DIOBJECTDATAFORMAT, * LPDIOBJECTDATAFORMAT; 408 | typedef const DIOBJECTDATAFORMAT* LPCDIOBJECTDATAFORMAT; 409 | 410 | typedef struct _DIDATAFORMAT { 411 | DWORD dwSize; 412 | DWORD dwObjSize; 413 | DWORD dwFlags; 414 | DWORD dwDataSize; 415 | DWORD dwNumObjs; 416 | LPDIOBJECTDATAFORMAT rgodf; 417 | } DIDATAFORMAT, * LPDIDATAFORMAT; 418 | typedef const DIDATAFORMAT* LPCDIDATAFORMAT; 419 | 420 | typedef struct DIDEVICEINSTANCEA { 421 | DWORD dwSize; 422 | GUID guidInstance; 423 | GUID guidProduct; 424 | DWORD dwDevType; 425 | CHAR tszInstanceName[MAX_PATH]; 426 | CHAR tszProductName[MAX_PATH]; 427 | GUID guidFFDriver; 428 | WORD wUsagePage; 429 | WORD wUsage; 430 | } DIDEVICEINSTANCEA, * LPDIDEVICEINSTANCEA; 431 | typedef const DIDEVICEINSTANCEA* LPCDIDEVICEINSTANCEA; 432 | 433 | typedef struct DIDEVICEINSTANCEW { 434 | DWORD dwSize; 435 | GUID guidInstance; 436 | GUID guidProduct; 437 | DWORD dwDevType; 438 | WCHAR tszInstanceName[MAX_PATH]; 439 | WCHAR tszProductName[MAX_PATH]; 440 | GUID guidFFDriver; 441 | WORD wUsagePage; 442 | WORD wUsage; 443 | } DIDEVICEINSTANCEW, * LPDIDEVICEINSTANCEW; 444 | typedef const DIDEVICEINSTANCEW* LPCDIDEVICEINSTANCEW; 445 | 446 | typedef struct DIENVELOPE { 447 | DWORD dwSize; /* sizeof(DIENVELOPE) */ 448 | DWORD dwAttackLevel; 449 | DWORD dwAttackTime; /* Microseconds */ 450 | DWORD dwFadeLevel; 451 | DWORD dwFadeTime; /* Microseconds */ 452 | } DIENVELOPE, * LPDIENVELOPE; 453 | typedef const DIENVELOPE* LPCDIENVELOPE; 454 | 455 | typedef struct DIEFFECT { 456 | DWORD dwSize; /* sizeof(DIEFFECT) */ 457 | DWORD dwFlags; /* DIEFF_* */ 458 | DWORD dwDuration; /* Microseconds */ 459 | DWORD dwSamplePeriod; /* Microseconds */ 460 | DWORD dwGain; 461 | DWORD dwTriggerButton; /* or DIEB_NOTRIGGER */ 462 | DWORD dwTriggerRepeatInterval; /* Microseconds */ 463 | DWORD cAxes; /* Number of axes */ 464 | LPDWORD rgdwAxes; /* Array of axes */ 465 | LPLONG rglDirection; /* Array of directions */ 466 | LPDIENVELOPE lpEnvelope; /* Optional */ 467 | DWORD cbTypeSpecificParams; /* Size of params */ 468 | LPVOID lpvTypeSpecificParams; /* Pointer to params */ 469 | DWORD dwStartDelay; /* Microseconds */ 470 | } DIEFFECT, * LPDIEFFECT; 471 | typedef DIEFFECT DIEFFECT_DX6; 472 | typedef LPDIEFFECT LPDIEFFECT_DX6; 473 | typedef const DIEFFECT* LPCDIEFFECT; 474 | 475 | typedef struct DIEFFESCAPE { 476 | DWORD dwSize; 477 | DWORD dwCommand; 478 | LPVOID lpvInBuffer; 479 | DWORD cbInBuffer; 480 | LPVOID lpvOutBuffer; 481 | DWORD cbOutBuffer; 482 | } DIEFFESCAPE, * LPDIEFFESCAPE; 483 | 484 | DECLARE_INTERFACE(IDirectInputEffect) 485 | { 486 | /*** IUnknown methods ***/ 487 | STDMETHOD(QueryInterface)(GUID* riid, LPVOID * ppvObj) PURE; 488 | STDMETHOD_(ULONG, AddRef)() PURE; 489 | STDMETHOD_(ULONG, Release)() PURE; 490 | 491 | /*** IDirectInputEffect methods ***/ 492 | STDMETHOD(Initialize)(HINSTANCE, DWORD, GUID*) PURE; 493 | STDMETHOD(GetEffectGuid)(LPGUID) PURE; 494 | STDMETHOD(GetParameters)(LPDIEFFECT, DWORD) PURE; 495 | STDMETHOD(SetParameters)(LPCDIEFFECT, DWORD) PURE; 496 | STDMETHOD(Start)(DWORD, DWORD) PURE; 497 | STDMETHOD(Stop)() PURE; 498 | STDMETHOD(GetEffectStatus)(LPDWORD) PURE; 499 | STDMETHOD(Download)() PURE; 500 | STDMETHOD(Unload)() PURE; 501 | STDMETHOD(Escape)(LPDIEFFESCAPE) PURE; 502 | }; 503 | 504 | typedef struct IDirectInputEffect* LPDIRECTINPUTEFFECT; 505 | 506 | typedef struct DIEFFECTINFOA { 507 | DWORD dwSize; 508 | GUID guid; 509 | DWORD dwEffType; 510 | DWORD dwStaticParams; 511 | DWORD dwDynamicParams; 512 | CHAR tszName[MAX_PATH]; 513 | } DIEFFECTINFOA, * LPDIEFFECTINFOA; 514 | 515 | typedef const DIEFFECTINFOA* LPCDIEFFECTINFOA; 516 | typedef BOOL(FAR PASCAL* LPDIENUMEFFECTSCALLBACKA)(LPCDIEFFECTINFOA, LPVOID); 517 | typedef BOOL(FAR PASCAL* LPDIENUMCREATEDEFFECTOBJECTSCALLBACK)(LPDIRECTINPUTEFFECT, LPVOID); 518 | 519 | 520 | typedef struct DIEFFECTINFOW { 521 | DWORD dwSize; 522 | GUID guid; 523 | DWORD dwEffType; 524 | DWORD dwStaticParams; 525 | DWORD dwDynamicParams; 526 | WCHAR tszName[MAX_PATH]; 527 | } DIEFFECTINFOW, * LPDIEFFECTINFOW; 528 | 529 | typedef const DIEFFECTINFOW* LPCDIEFFECTINFOW; 530 | typedef BOOL(FAR PASCAL* LPDIENUMEFFECTSCALLBACKW)(LPCDIEFFECTINFOW, LPVOID); 531 | 532 | typedef struct DIFILEEFFECT { 533 | DWORD dwSize; 534 | GUID GuidEffect; 535 | LPCDIEFFECT lpDiEffect; 536 | CHAR szFriendlyName[MAX_PATH]; 537 | }DIFILEEFFECT, * LPDIFILEEFFECT; 538 | typedef const DIFILEEFFECT* LPCDIFILEEFFECT; 539 | 540 | typedef const DIFILEEFFECT* LPCDIFILEEFFECT; 541 | typedef BOOL(FAR PASCAL* LPDIENUMEFFECTSINFILECALLBACK)(LPCDIFILEEFFECT, LPVOID); 542 | 543 | typedef struct _DIACTIONA { 544 | UINT_PTR uAppData; 545 | DWORD dwSemantic; 546 | OPTIONAL DWORD dwFlags; 547 | OPTIONAL union { 548 | LPCSTR lptszActionName; 549 | UINT uResIdString; 550 | }; 551 | OPTIONAL GUID guidInstance; 552 | OPTIONAL DWORD dwObjID; 553 | OPTIONAL DWORD dwHow; 554 | } DIACTIONA, * LPDIACTIONA; 555 | 556 | typedef struct _DIACTIONW { 557 | UINT_PTR uAppData; 558 | DWORD dwSemantic; 559 | OPTIONAL DWORD dwFlags; 560 | OPTIONAL union { 561 | LPCWSTR lptszActionName; 562 | UINT uResIdString; 563 | }; 564 | OPTIONAL GUID guidInstance; 565 | OPTIONAL DWORD dwObjID; 566 | OPTIONAL DWORD dwHow; 567 | } DIACTIONW, * LPDIACTIONW; 568 | 569 | typedef struct _DIACTIONFORMATA { 570 | DWORD dwSize; 571 | DWORD dwActionSize; 572 | DWORD dwDataSize; 573 | DWORD dwNumActions; 574 | LPDIACTIONA rgoAction; 575 | GUID guidActionMap; 576 | DWORD dwGenre; 577 | DWORD dwBufferSize; 578 | OPTIONAL LONG lAxisMin; 579 | OPTIONAL LONG lAxisMax; 580 | OPTIONAL HINSTANCE hInstString; 581 | FILETIME ftTimeStamp; 582 | DWORD dwCRC; 583 | CHAR tszActionMap[MAX_PATH]; 584 | } DIACTIONFORMATA, * LPDIACTIONFORMATA; 585 | 586 | typedef struct _DIACTIONFORMATW { 587 | DWORD dwSize; 588 | DWORD dwActionSize; 589 | DWORD dwDataSize; 590 | DWORD dwNumActions; 591 | LPDIACTIONW rgoAction; 592 | GUID guidActionMap; 593 | DWORD dwGenre; 594 | DWORD dwBufferSize; 595 | OPTIONAL LONG lAxisMin; 596 | OPTIONAL LONG lAxisMax; 597 | OPTIONAL HINSTANCE hInstString; 598 | FILETIME ftTimeStamp; 599 | DWORD dwCRC; 600 | WCHAR tszActionMap[MAX_PATH]; 601 | } DIACTIONFORMATW, * LPDIACTIONFORMATW; 602 | 603 | typedef struct _DIDEVICEIMAGEINFOA { 604 | CHAR tszImagePath[MAX_PATH]; 605 | DWORD dwFlags; 606 | // These are valid if DIDIFT_OVERLAY is present in dwFlags. 607 | DWORD dwViewID; 608 | RECT rcOverlay; 609 | DWORD dwObjID; 610 | DWORD dwcValidPts; 611 | POINT rgptCalloutLine[5]; 612 | RECT rcCalloutRect; 613 | DWORD dwTextAlign; 614 | } DIDEVICEIMAGEINFOA, * LPDIDEVICEIMAGEINFOA; 615 | 616 | typedef struct _DIDEVICEIMAGEINFOW { 617 | WCHAR tszImagePath[MAX_PATH]; 618 | DWORD dwFlags; 619 | // These are valid if DIDIFT_OVERLAY is present in dwFlags. 620 | DWORD dwViewID; 621 | RECT rcOverlay; 622 | DWORD dwObjID; 623 | DWORD dwcValidPts; 624 | POINT rgptCalloutLine[5]; 625 | RECT rcCalloutRect; 626 | DWORD dwTextAlign; 627 | } DIDEVICEIMAGEINFOW, * LPDIDEVICEIMAGEINFOW; 628 | 629 | typedef struct _DIDEVICEIMAGEINFOHEADERA { 630 | DWORD dwSize; 631 | DWORD dwSizeImageInfo; 632 | DWORD dwcViews; 633 | DWORD dwcButtons; 634 | DWORD dwcAxes; 635 | DWORD dwcPOVs; 636 | DWORD dwBufferSize; 637 | DWORD dwBufferUsed; 638 | LPDIDEVICEIMAGEINFOA lprgImageInfoArray; 639 | } DIDEVICEIMAGEINFOHEADERA, * LPDIDEVICEIMAGEINFOHEADERA; 640 | 641 | typedef struct _DIDEVICEIMAGEINFOHEADERW { 642 | DWORD dwSize; 643 | DWORD dwSizeImageInfo; 644 | DWORD dwcViews; 645 | DWORD dwcButtons; 646 | DWORD dwcAxes; 647 | DWORD dwcPOVs; 648 | DWORD dwBufferSize; 649 | DWORD dwBufferUsed; 650 | LPDIDEVICEIMAGEINFOW lprgImageInfoArray; 651 | } DIDEVICEIMAGEINFOHEADERW, * LPDIDEVICEIMAGEINFOHEADERW; 652 | 653 | #ifndef D3DCOLOR_DEFINED 654 | typedef DWORD D3DCOLOR; 655 | #define D3DCOLOR_DEFINED 656 | #endif 657 | 658 | typedef struct _DICOLORSET { 659 | DWORD dwSize; 660 | D3DCOLOR cTextFore; 661 | D3DCOLOR cTextHighlight; 662 | D3DCOLOR cCalloutLine; 663 | D3DCOLOR cCalloutHighlight; 664 | D3DCOLOR cBorder; 665 | D3DCOLOR cControlFill; 666 | D3DCOLOR cHighlightFill; 667 | D3DCOLOR cAreaFill; 668 | } DICOLORSET, * LPDICOLORSET; 669 | typedef const DICOLORSET* LPCDICOLORSET; 670 | 671 | typedef struct _DICONFIGUREDEVICESPARAMSA { 672 | DWORD dwSize; 673 | DWORD dwcUsers; 674 | LPSTR lptszUserNames; 675 | DWORD dwcFormats; 676 | LPDIACTIONFORMATA lprgFormats; 677 | HWND hwnd; 678 | DICOLORSET dics; 679 | LPUNKNOWN lpUnkDDSTarget; 680 | } DICONFIGUREDEVICESPARAMSA, * LPDICONFIGUREDEVICESPARAMSA; 681 | typedef const DICONFIGUREDEVICESPARAMSA* LPCDICONFIGUREDEVICESPARAMSA; 682 | 683 | typedef struct _DICONFIGUREDEVICESPARAMSW { 684 | DWORD dwSize; 685 | DWORD dwcUsers; 686 | LPWSTR lptszUserNames; 687 | DWORD dwcFormats; 688 | LPDIACTIONFORMATA lprgFormats; 689 | HWND hwnd; 690 | DICOLORSET dics; 691 | LPUNKNOWN lpUnkDDSTarget; 692 | } DICONFIGUREDEVICESPARAMSW, * LPDICONFIGUREDEVICESPARAMSW; 693 | typedef const DICONFIGUREDEVICESPARAMSW* LPCDICONFIGUREDEVICESPARAMSW; 694 | 695 | typedef BOOL(CALLBACK* LPDICONFIGUREDEVICESCALLBACK)(LPUNKNOWN, LPVOID); 696 | 697 | DECLARE_INTERFACE(IDirectInputDevice8A) 698 | { 699 | /*** IUnknown methods ***/ 700 | STDMETHOD_(HRESULT, QueryInterface)(GUID* riid, void** ppvObject) PURE; 701 | STDMETHOD_(ULONG, AddRef)() PURE; 702 | STDMETHOD_(ULONG, Release)() PURE; 703 | 704 | /*** IDirectInputDeviceA methods ***/ 705 | STDMETHOD(GetCapabilities)(LPDIDEVCAPS lpDIDevCaps) PURE; 706 | STDMETHOD(EnumObjects)(LPDIENUMDEVICEOBJECTSCALLBACKA lpCallback, LPVOID pvRef, DWORD dwFlags) PURE; 707 | STDMETHOD(GetProperty)(GUID* rguidProp, LPDIPROPHEADER pdiph) PURE; 708 | STDMETHOD(SetProperty)(GUID* rguidProp, LPCDIPROPHEADER pdiph) PURE; 709 | STDMETHOD(Acquire)() PURE; 710 | STDMETHOD(Unacquire)() PURE; 711 | STDMETHOD(GetDeviceState)(DWORD cbData, LPVOID lpvData) PURE; 712 | STDMETHOD(GetDeviceData)(DWORD cbObjectData, LPDIDEVICEOBJECTDATA rgdod, LPDWORD pdwInOut, DWORD dwFlags) PURE; 713 | STDMETHOD(SetDataFormat)(LPCDIDATAFORMAT lpdf) PURE; 714 | STDMETHOD(SetEventNotification)(HANDLE hEvent) PURE; 715 | STDMETHOD(SetCooperativeLevel)(HWND hwnd, DWORD dwFlags) PURE; 716 | STDMETHOD(GetObjectInfo)(LPDIDEVICEOBJECTINSTANCEA pdidoi, DWORD dwObj, DWORD dwHow) PURE; 717 | STDMETHOD(GetDeviceInfo)(LPDIDEVICEINSTANCEA pdidi) PURE; 718 | STDMETHOD(RunControlPanel)(HWND hwndOwner, DWORD dwFlags) PURE; 719 | STDMETHOD(Initialize)(HINSTANCE hinst, DWORD dwVersion, GUID* rguid) PURE; 720 | 721 | /*** IDirectInputDevice2A methods ***/ 722 | STDMETHOD(CreateEffect)(GUID* rguid, LPCDIEFFECT lpeff, LPDIRECTINPUTEFFECT* ppdeff, LPUNKNOWN punkOuter) PURE; 723 | STDMETHOD(EnumEffects)(LPDIENUMEFFECTSCALLBACKA lpCallback, LPVOID pvRef, DWORD dwEffType) PURE; 724 | STDMETHOD(GetEffectInfo)(LPDIEFFECTINFOA pdei, GUID* rguid) PURE; 725 | STDMETHOD(GetForceFeedbackState)(LPDWORD pdwOut) PURE; 726 | STDMETHOD(SendForceFeedbackCommand)(DWORD dwFlags) PURE; 727 | STDMETHOD(EnumCreatedEffectObjects)(LPDIENUMCREATEDEFFECTOBJECTSCALLBACK lpCallback, LPVOID pvRef, DWORD fl) PURE; 728 | STDMETHOD(Escape)(LPDIEFFESCAPE pesc) PURE; 729 | STDMETHOD(Poll)() PURE; 730 | STDMETHOD(SendDeviceData)(DWORD cbObjectData, LPCDIDEVICEOBJECTDATA rgdod, LPDWORD pdwInOut, DWORD fl) PURE; 731 | /*** IDirectInputDevice7A methods ***/ 732 | STDMETHOD(EnumEffectsInFile)(LPCSTR lpszFileName, LPDIENUMEFFECTSINFILECALLBACK pec, LPVOID pvRef, DWORD dwFlags) PURE; 733 | STDMETHOD(WriteEffectToFile)(LPCSTR lpszFileName, DWORD dwEntries, LPDIFILEEFFECT rgDiFileEft, DWORD dwFlags) PURE; 734 | /*** IDirectInputDevice8A methods ***/ 735 | STDMETHOD(BuildActionMap)(LPDIACTIONFORMATA lpdiaf, LPCSTR lpszUserName, DWORD dwFlags) PURE; 736 | STDMETHOD(SetActionMap)(LPDIACTIONFORMATA lpdiaf, LPCSTR lpszUserName, DWORD dwFlags) PURE; 737 | STDMETHOD(GetImageInfo)(LPDIDEVICEIMAGEINFOHEADERA lpdiDevImageInfoHeader) PURE; 738 | }; 739 | 740 | typedef struct IDirectInputDevice8A* LPDIRECTINPUTDEVICE8A; 741 | 742 | 743 | DECLARE_INTERFACE(IDirectInputDevice8W) 744 | { 745 | /*** IUnknown methods ***/ 746 | STDMETHOD_(HRESULT, QueryInterface)(GUID * riid, void** ppvObject) PURE; 747 | STDMETHOD_(ULONG, AddRef)() PURE; 748 | STDMETHOD_(ULONG, Release)() PURE; 749 | 750 | /*** IDirectInputDeviceA methods ***/ 751 | STDMETHOD(GetCapabilities)(LPDIDEVCAPS lpDIDevCaps) PURE; 752 | STDMETHOD(EnumObjects)(LPDIENUMDEVICEOBJECTSCALLBACKW lpCallback, LPVOID pvRef, DWORD dwFlags) PURE; 753 | STDMETHOD(GetProperty)(GUID * rguidProp, LPDIPROPHEADER pdiph) PURE; 754 | STDMETHOD(SetProperty)(GUID * rguidProp, LPCDIPROPHEADER pdiph) PURE; 755 | STDMETHOD(Acquire)() PURE; 756 | STDMETHOD(Unacquire)() PURE; 757 | STDMETHOD(GetDeviceState)(DWORD cbData, LPVOID lpvData) PURE; 758 | STDMETHOD(GetDeviceData)(DWORD cbObjectData, LPDIDEVICEOBJECTDATA rgdod, LPDWORD pdwInOut, DWORD dwFlags) PURE; 759 | STDMETHOD(SetDataFormat)(LPCDIDATAFORMAT lpdf) PURE; 760 | STDMETHOD(SetEventNotification)(HANDLE hEvent) PURE; 761 | STDMETHOD(SetCooperativeLevel)(HWND hwnd, DWORD dwFlags) PURE; 762 | STDMETHOD(GetObjectInfo)(LPDIDEVICEOBJECTINSTANCEW pdidoi, DWORD dwObj, DWORD dwHow) PURE; 763 | STDMETHOD(GetDeviceInfo)(LPDIDEVICEINSTANCEW pdidi) PURE; 764 | STDMETHOD(RunControlPanel)(HWND hwndOwner, DWORD dwFlags) PURE; 765 | STDMETHOD(Initialize)(HINSTANCE hinst, DWORD dwVersion, GUID * rguid) PURE; 766 | 767 | /*** IDirectInputDevice2A methods ***/ 768 | STDMETHOD(CreateEffect)(GUID * rguid, LPCDIEFFECT lpeff, LPDIRECTINPUTEFFECT * ppdeff, LPUNKNOWN punkOuter) PURE; 769 | STDMETHOD(EnumEffects)(LPDIENUMEFFECTSCALLBACKW lpCallback, LPVOID pvRef, DWORD dwEffType) PURE; 770 | STDMETHOD(GetEffectInfo)(LPDIEFFECTINFOW pdei, GUID * rguid) PURE; 771 | STDMETHOD(GetForceFeedbackState)(LPDWORD pdwOut) PURE; 772 | STDMETHOD(SendForceFeedbackCommand)(DWORD dwFlags) PURE; 773 | STDMETHOD(EnumCreatedEffectObjects)(LPDIENUMCREATEDEFFECTOBJECTSCALLBACK lpCallback, LPVOID pvRef, DWORD fl) PURE; 774 | STDMETHOD(Escape)(LPDIEFFESCAPE pesc) PURE; 775 | STDMETHOD(Poll)() PURE; 776 | STDMETHOD(SendDeviceData)(DWORD cbObjectData, LPCDIDEVICEOBJECTDATA rgdod, LPDWORD pdwInOut, DWORD fl) PURE; 777 | /*** IDirectInputDevice7A methods ***/ 778 | STDMETHOD(EnumEffectsInFile)(LPCWSTR lpszFileName, LPDIENUMEFFECTSINFILECALLBACK pec, LPVOID pvRef, DWORD dwFlags) PURE; 779 | STDMETHOD(WriteEffectToFile)(LPCWSTR lpszFileName, DWORD dwEntries, LPDIFILEEFFECT rgDiFileEft, DWORD dwFlags) PURE; 780 | /*** IDirectInputDevice8A methods ***/ 781 | STDMETHOD(BuildActionMap)(LPDIACTIONFORMATW lpdiaf, LPCWSTR lpszUserName, DWORD dwFlags) PURE; 782 | STDMETHOD(SetActionMap)(LPDIACTIONFORMATW lpdiaf, LPCWSTR lpszUserName, DWORD dwFlags) PURE; 783 | STDMETHOD(GetImageInfo)(LPDIDEVICEIMAGEINFOHEADERW lpdiDevImageInfoHeader) PURE; 784 | }; 785 | 786 | typedef struct IDirectInputDevice8W* LPDIRECTINPUTDEVICE8W; 787 | 788 | typedef BOOL(CALLBACK* LPDIENUMDEVICESCALLBACKA)(LPCDIDEVICEINSTANCEA, LPVOID); 789 | typedef BOOL(CALLBACK* LPDIENUMDEVICESBYSEMANTICSCBA)(LPCDIDEVICEINSTANCEA, LPDIRECTINPUTDEVICE8A, DWORD, DWORD, LPVOID); 790 | 791 | typedef BOOL(CALLBACK* LPDIENUMDEVICESCALLBACKW)(LPCDIDEVICEINSTANCEW, LPVOID); 792 | typedef BOOL(CALLBACK* LPDIENUMDEVICESBYSEMANTICSCBW)(LPCDIDEVICEINSTANCEW, LPDIRECTINPUTDEVICE8W, DWORD, DWORD, LPVOID); 793 | 794 | DECLARE_INTERFACE(IDirectInput8A) 795 | { 796 | /*** IUnknown methods ***/ 797 | STDMETHOD_(HRESULT, QueryInterface)(GUID* riid, void** ppvObject) PURE; 798 | STDMETHOD_(ULONG, AddRef)() PURE; 799 | STDMETHOD_(ULONG, Release)() PURE; 800 | 801 | /*** IDirectInput8A methods ***/ 802 | STDMETHOD(CreateDevice)(GUID* rguid, LPDIRECTINPUTDEVICE8A * lplpDirectInputDevice, LPUNKNOWN pUnkOuter) PURE; 803 | STDMETHOD(EnumDevices)(DWORD dwDevType, LPDIENUMDEVICESCALLBACKA lpCallback, LPVOID pvRef, DWORD dwFlags) PURE; 804 | STDMETHOD(GetDeviceStatus)(GUID* rguidInstance) PURE; 805 | STDMETHOD(RunControlPanel)(HWND hwndOwner, DWORD dwFlags) PURE; 806 | STDMETHOD(Initialize)(HINSTANCE hinst, DWORD dwVersion) PURE; 807 | STDMETHOD(FindDevice)(GUID* rguid, LPCSTR pszName, LPGUID pguidInstance) PURE; 808 | STDMETHOD(EnumDevicesBySemantics)(LPCSTR ptszUserName, LPDIACTIONFORMATA lpdiActionFormat, LPDIENUMDEVICESBYSEMANTICSCBA lpCallback, LPVOID pvRef, DWORD dwFlags) PURE; 809 | STDMETHOD(ConfigureDevices)(LPDICONFIGUREDEVICESCALLBACK lpdiCallback, LPDICONFIGUREDEVICESPARAMSA lpdiCDParams, DWORD dwFlags, LPVOID pvRefData) PURE; 810 | }; 811 | 812 | typedef struct IDirectInput8A* LPDIRECTINPUT8A; 813 | 814 | DECLARE_INTERFACE(IDirectInput8W) 815 | { 816 | /*** IUnknown methods ***/ 817 | STDMETHOD_(HRESULT, QueryInterface)(GUID * riid, void** ppvObject) PURE; 818 | STDMETHOD_(ULONG, AddRef)() PURE; 819 | STDMETHOD_(ULONG, Release)() PURE; 820 | 821 | /*** IDirectInput8A methods ***/ 822 | STDMETHOD(CreateDevice)(GUID * rguid, LPDIRECTINPUTDEVICE8W * lplpDirectInputDevice, LPUNKNOWN pUnkOuter) PURE; 823 | STDMETHOD(EnumDevices)(DWORD dwDevType, LPDIENUMDEVICESCALLBACKW lpCallback, LPVOID pvRef, DWORD dwFlags) PURE; 824 | STDMETHOD(GetDeviceStatus)(GUID * rguidInstance) PURE; 825 | STDMETHOD(RunControlPanel)(HWND hwndOwner, DWORD dwFlags) PURE; 826 | STDMETHOD(Initialize)(HINSTANCE hinst, DWORD dwVersion) PURE; 827 | STDMETHOD(FindDevice)(GUID * rguid, LPCWSTR pszName, LPGUID pguidInstance) PURE; 828 | STDMETHOD(EnumDevicesBySemantics)(LPCWSTR ptszUserName, LPDIACTIONFORMATW lpdiActionFormat, LPDIENUMDEVICESBYSEMANTICSCBW lpCallback, LPVOID pvRef, DWORD dwFlags) PURE; 829 | STDMETHOD(ConfigureDevices)(LPDICONFIGUREDEVICESCALLBACK lpdiCallback, LPDICONFIGUREDEVICESPARAMSW lpdiCDParams, DWORD dwFlags, LPVOID pvRefData) PURE; 830 | }; 831 | 832 | typedef struct IDirectInput8W* LPDIRECTINPUT8W; -------------------------------------------------------------------------------- /dinput8wrapper/dinput8wrapper.vcxproj: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | Debug 6 | Win32 7 | 8 | 9 | Release 10 | Win32 11 | 12 | 13 | 14 | 16.0 15 | Win32Proj 16 | {2a4f4487-e283-4b63-805b-c5014cfb3685} 17 | dinput8wrapper 18 | 10.0 19 | 20 | 21 | 22 | DynamicLibrary 23 | true 24 | v143 25 | MultiByte 26 | 27 | 28 | 29 | 30 | 31 | 32 | 33 | 34 | 35 | 36 | 37 | 38 | 39 | 40 | false 41 | dinput8 42 | D:\vmshare\sub\Rogue Warrior\ 43 | 44 | 45 | false 46 | dinput8 47 | $(Configuration)\ 48 | 49 | 50 | 51 | Level3 52 | true 53 | WIN32;_DEBUG;DINPUT8WRAPPER_EXPORTS;_WINDOWS;_USRDLL;%(PreprocessorDefinitions) 54 | true 55 | NotUsing 56 | 57 | 58 | MultiThreadedDebug 59 | false 60 | ProgramDatabase 61 | 62 | 63 | Windows 64 | true 65 | false 66 | dinput8.def 67 | true 68 | true 69 | true 70 | Default 71 | C:\Steam\SteamApps\common\Kane and Lynch Dead Men\dinput8.pdb 72 | 73 | 74 | 75 | 76 | Level3 77 | false 78 | true 79 | true 80 | WIN32;NDEBUG;DINPUT8WRAPPER_EXPORTS;_WINDOWS;_USRDLL;%(PreprocessorDefinitions) 81 | true 82 | Use 83 | pch.h 84 | MultiThreaded 85 | 86 | 87 | Windows 88 | true 89 | true 90 | true 91 | false 92 | dinput8.def 93 | UseLinkTimeCodeGeneration 94 | 95 | 96 | 97 | 98 | 99 | 100 | 101 | 102 | 103 | 104 | 105 | 106 | 107 | 108 | 109 | 110 | 111 | 112 | 113 | 114 | 115 | 116 | 117 | 118 | 119 | 120 | 121 | 122 | 123 | 124 | 125 | 126 | 127 | -------------------------------------------------------------------------------- /dinput8wrapper/dinput8wrapper.vcxproj.filters: -------------------------------------------------------------------------------- 1 |  2 | 3 | 4 | 5 | {4FC737F1-C7A5-4376-A066-2A32D752A2FF} 6 | cpp;c;cc;cxx;c++;def;odl;idl;hpj;bat;asm;asmx 7 | 8 | 9 | {93995380-89BD-4b04-88EB-625FBE52EBFB} 10 | h;hh;hpp;hxx;h++;hm;inl;inc;ipp;xsd 11 | 12 | 13 | {67DA6AB6-F800-4c08-8B7A-83BB121AAD01} 14 | rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms 15 | 16 | 17 | 18 | 19 | Header Files 20 | 21 | 22 | Header Files 23 | 24 | 25 | Header Files 26 | 27 | 28 | Header Files 29 | 30 | 31 | Header Files 32 | 33 | 34 | Header Files 35 | 36 | 37 | Header Files 38 | 39 | 40 | Header Files 41 | 42 | 43 | Header Files 44 | 45 | 46 | Header Files 47 | 48 | 49 | Header Files 50 | 51 | 52 | Header Files 53 | 54 | 55 | Header Files 56 | 57 | 58 | Header Files 59 | 60 | 61 | Header Files 62 | 63 | 64 | Header Files 65 | 66 | 67 | Header Files 68 | 69 | 70 | 71 | 72 | Source Files 73 | 74 | 75 | 76 | 77 | Header Files 78 | 79 | 80 | 81 | 82 | Resource Files 83 | 84 | 85 | -------------------------------------------------------------------------------- /dinput8wrapper/dllmain.cpp: -------------------------------------------------------------------------------- 1 | // dllmain.cpp : Defines the entry point for the DLL application. 2 | #include "dllmain.h" 3 | 4 | BOOL APIENTRY DllMain( HMODULE hModule, 5 | DWORD ul_reason_for_call, 6 | LPVOID lpReserved 7 | ) 8 | { 9 | DllHModule = hModule; 10 | 11 | switch (ul_reason_for_call) 12 | { 13 | case DLL_PROCESS_ATTACH: 14 | case DLL_THREAD_ATTACH: 15 | case DLL_THREAD_DETACH: 16 | case DLL_PROCESS_DETACH: 17 | break; 18 | } 19 | return TRUE; 20 | } 21 | 22 | extern "C" HRESULT WINAPI DllCanUnloadNow() { return S_FALSE; } 23 | 24 | extern "C" HRESULT WINAPI DllGetClassObject(REFCLSID rclsid, REFIID riid, void** ppv) 25 | { 26 | return E_ABORT; 27 | } 28 | 29 | extern "C" HRESULT WINAPI DllRegisterServer() { 30 | return E_ABORT; 31 | } 32 | 33 | extern "C" HRESULT WINAPI DllUnregisterServer() { 34 | return E_ABORT; 35 | } 36 | 37 | extern "C" LPCDIDATAFORMAT WINAPI GetdfDIJoystick() { 38 | return NULL; 39 | } 40 | 41 | HRESULT WINAPI DirectInput8Create(HINSTANCE hinst, DWORD dwVersion, GUID* riidltf, LPVOID* ppvOut, LPUNKNOWN punkOuter) 42 | { 43 | LoadHidLibrary(); 44 | 45 | IID IID_IDirectInput8A = { 0xBF798030, 0x483A, 0x4DA2, 0xAA, 0x99, 0x5D, 0x64, 0xED, 0x36, 0x97, 0x00 }; 46 | IID IID_IDirectInput8W = { 0xBF798031, 0x483A, 0x4DA2, 0xAA, 0x99, 0x5D, 0x64, 0xED, 0x36, 0x97, 0x00 }; 47 | 48 | if (IsEqualIID(IID_IDirectInput8A, *riidltf)) 49 | { 50 | CDirectInput8A* obj = new CDirectInput8A(); 51 | 52 | *ppvOut = obj; 53 | 54 | return DI_OK; 55 | } 56 | else if (IsEqualIID(IID_IDirectInput8W, *riidltf)) 57 | { 58 | CDirectInput8W* obj = new CDirectInput8W(); 59 | 60 | *ppvOut = obj; 61 | 62 | return DI_OK; 63 | } 64 | else 65 | { 66 | char tmp[256]; 67 | StringCbPrintfA(tmp, 256, "Unsupported REFIID: %x %x %x %x", riidltf->Data1, riidltf->Data2, riidltf->Data3, riidltf->Data4); 68 | MessageBoxA(NULL, tmp, "dinput8wrapper", MB_OK); 69 | } 70 | 71 | return DIERR_INVALIDPARAM; 72 | } -------------------------------------------------------------------------------- /dinput8wrapper/dllmain.h: -------------------------------------------------------------------------------- 1 | // pch.h: This is a precompiled header file. 2 | // Files listed below are compiled only once, improving build performance for future builds. 3 | // This also affects IntelliSense performance, including code completion and many code browsing features. 4 | // However, files listed here are ALL re-compiled if any one of them is updated between builds. 5 | // Do not add files here that you will be updating frequently as this negates the performance advantage. 6 | 7 | #ifndef PCH_H 8 | #define PCH_H 9 | 10 | #include 11 | #include 12 | #include 13 | #include "dinput8.h" 14 | 15 | #include "hid.h" 16 | 17 | static HMODULE DllHModule; 18 | 19 | #include "CDirectInput8Globals.h" 20 | 21 | #include "CDirectInputDeviceMouse8.h" 22 | #include "CDirectInputDeviceMouse8A.h" 23 | #include "CDirectInputDeviceMouse8W.h" 24 | 25 | #include "CDirectInputDeviceKeyboard8.h" 26 | #include "CDirectInputDeviceKeyboard8A.h" 27 | #include "CDirectInputDeviceKeyboard8W.h" 28 | 29 | #include "CDirectInputDeviceGamepad8.h" 30 | #include "CDirectInputDeviceGamepad8A.h" 31 | #include "CDirectInputDeviceGamepad8W.h" 32 | 33 | #include "CDirectInput8.h" 34 | #include "CDirectInput8A.h" 35 | #include "CDirectInput8W.h" 36 | 37 | #endif //PCH_H 38 | -------------------------------------------------------------------------------- /dinput8wrapper/hid.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | // From hidusage.h 4 | /////////////////////////////////////////////////////////////////////// 5 | typedef USHORT USAGE, * PUSAGE; 6 | 7 | // From hidpi.h 8 | /////////////////////////////////////////////////////////////////////// 9 | typedef struct _HIDP_PREPARSED_DATA* PHIDP_PREPARSED_DATA; 10 | 11 | typedef struct _HIDP_CAPS 12 | { 13 | USAGE Usage; 14 | USAGE UsagePage; 15 | USHORT InputReportByteLength; 16 | USHORT OutputReportByteLength; 17 | USHORT FeatureReportByteLength; 18 | USHORT Reserved[17]; 19 | 20 | USHORT NumberLinkCollectionNodes; 21 | 22 | USHORT NumberInputButtonCaps; 23 | USHORT NumberInputValueCaps; 24 | USHORT NumberInputDataIndices; 25 | 26 | USHORT NumberOutputButtonCaps; 27 | USHORT NumberOutputValueCaps; 28 | USHORT NumberOutputDataIndices; 29 | 30 | USHORT NumberFeatureButtonCaps; 31 | USHORT NumberFeatureValueCaps; 32 | USHORT NumberFeatureDataIndices; 33 | } HIDP_CAPS, * PHIDP_CAPS; 34 | 35 | typedef struct _HIDP_BUTTON_CAPS 36 | { 37 | USAGE UsagePage; 38 | UCHAR ReportID; 39 | BOOLEAN IsAlias; 40 | 41 | USHORT BitField; 42 | USHORT LinkCollection; // A unique internal index pointer 43 | 44 | USAGE LinkUsage; 45 | USAGE LinkUsagePage; 46 | 47 | BOOLEAN IsRange; 48 | BOOLEAN IsStringRange; 49 | BOOLEAN IsDesignatorRange; 50 | BOOLEAN IsAbsolute; 51 | 52 | ULONG Reserved[10]; 53 | union { 54 | struct { 55 | USAGE UsageMin, UsageMax; 56 | USHORT StringMin, StringMax; 57 | USHORT DesignatorMin, DesignatorMax; 58 | USHORT DataIndexMin, DataIndexMax; 59 | } Range; 60 | struct { 61 | USAGE Usage, Reserved1; 62 | USHORT StringIndex, Reserved2; 63 | USHORT DesignatorIndex, Reserved3; 64 | USHORT DataIndex, Reserved4; 65 | } NotRange; 66 | }; 67 | 68 | } HIDP_BUTTON_CAPS, * PHIDP_BUTTON_CAPS; 69 | 70 | typedef enum _HIDP_REPORT_TYPE 71 | { 72 | HidP_Input, 73 | HidP_Output, 74 | HidP_Feature 75 | } HIDP_REPORT_TYPE; 76 | 77 | 78 | #ifndef FACILITY_HID_ERROR_CODE 79 | #define FACILITY_HID_ERROR_CODE 0x11 80 | #endif 81 | 82 | #define HIDP_ERROR_CODES(SEV, CODE) ((NTSTATUS) (((SEV) << 28) | (FACILITY_HID_ERROR_CODE << 16) | (CODE))) 83 | #define HIDP_STATUS_SUCCESS (HIDP_ERROR_CODES(0x0,0)) 84 | #define HIDP_STATUS_NULL (HIDP_ERROR_CODES(0x8,1)) 85 | #define HIDP_STATUS_INVALID_PREPARSED_DATA (HIDP_ERROR_CODES(0xC,1)) 86 | #define HIDP_STATUS_INVALID_REPORT_TYPE (HIDP_ERROR_CODES(0xC,2)) 87 | #define HIDP_STATUS_INVALID_REPORT_LENGTH (HIDP_ERROR_CODES(0xC,3)) 88 | #define HIDP_STATUS_USAGE_NOT_FOUND (HIDP_ERROR_CODES(0xC,4)) 89 | #define HIDP_STATUS_VALUE_OUT_OF_RANGE (HIDP_ERROR_CODES(0xC,5)) 90 | #define HIDP_STATUS_BAD_LOG_PHY_VALUES (HIDP_ERROR_CODES(0xC,6)) 91 | #define HIDP_STATUS_BUFFER_TOO_SMALL (HIDP_ERROR_CODES(0xC,7)) 92 | #define HIDP_STATUS_INTERNAL_ERROR (HIDP_ERROR_CODES(0xC,8)) 93 | #define HIDP_STATUS_I8042_TRANS_UNKNOWN (HIDP_ERROR_CODES(0xC,9)) 94 | #define HIDP_STATUS_INCOMPATIBLE_REPORT_ID (HIDP_ERROR_CODES(0xC,0xA)) 95 | #define HIDP_STATUS_NOT_VALUE_ARRAY (HIDP_ERROR_CODES(0xC,0xB)) 96 | #define HIDP_STATUS_IS_VALUE_ARRAY (HIDP_ERROR_CODES(0xC,0xC)) 97 | #define HIDP_STATUS_DATA_INDEX_NOT_FOUND (HIDP_ERROR_CODES(0xC,0xD)) 98 | #define HIDP_STATUS_DATA_INDEX_OUT_OF_RANGE (HIDP_ERROR_CODES(0xC,0xE)) 99 | #define HIDP_STATUS_BUTTON_NOT_PRESSED (HIDP_ERROR_CODES(0xC,0xF)) 100 | #define HIDP_STATUS_REPORT_DOES_NOT_EXIST (HIDP_ERROR_CODES(0xC,0x10)) 101 | #define HIDP_STATUS_NOT_IMPLEMENTED (HIDP_ERROR_CODES(0xC,0x20)) 102 | 103 | 104 | 105 | // hid.dll 106 | ///////////////////////////////////////////////////////////////////// 107 | bool hidDllLoaded = false; 108 | 109 | typedef NTSTATUS __stdcall HIDP_GETCAPS_FUNC(PHIDP_PREPARSED_DATA PreparsedData, PHIDP_CAPS Capabilities); 110 | HIDP_GETCAPS_FUNC* HidP_GetCaps; 111 | 112 | typedef NTSTATUS __stdcall HIDP_GETBUTTONCAPS_FUNC(HIDP_REPORT_TYPE ReportType, PHIDP_BUTTON_CAPS ButtonCaps, PUSHORT ButtonCapsLength, PHIDP_PREPARSED_DATA PreparsedData); 113 | HIDP_GETBUTTONCAPS_FUNC* HidP_GetButtonCaps; 114 | 115 | typedef NTSTATUS __stdcall HIDP_GETUSAGES_FUNC(HIDP_REPORT_TYPE ReportType, USAGE UsagePage, USHORT LinkCollection, PUSAGE UsageList, PULONG UsageLength, PHIDP_PREPARSED_DATA PreparsedData, PCHAR Report, ULONG ReportLength); 116 | HIDP_GETUSAGES_FUNC* HidP_GetUsages; 117 | 118 | void LoadHidLibrary() 119 | { 120 | if (hidDllLoaded) 121 | { 122 | return; 123 | } 124 | 125 | HMODULE hidModule = LoadLibrary(TEXT("hid.dll")); 126 | 127 | HidP_GetCaps = (HIDP_GETCAPS_FUNC*)GetProcAddress(hidModule, TEXT("HidP_GetCaps")); 128 | HidP_GetButtonCaps = (HIDP_GETBUTTONCAPS_FUNC*)GetProcAddress(hidModule, TEXT("HidP_GetButtonCaps")); 129 | HidP_GetUsages = (HIDP_GETUSAGES_FUNC*)GetProcAddress(hidModule, TEXT("HidP_GetUsages")); 130 | 131 | hidDllLoaded = true; 132 | } -------------------------------------------------------------------------------- /dinput8wrapper/pch.cpp: -------------------------------------------------------------------------------- 1 | // pch.cpp: source file corresponding to the pre-compiled header 2 | 3 | #include "pch.h" 4 | 5 | // When you are using pre-compiled headers, this source file is necessary for compilation to succeed. 6 | -------------------------------------------------------------------------------- /dinput8wrapper/resource.h: -------------------------------------------------------------------------------- 1 | //{{NO_DEPENDENCIES}} 2 | // Microsoft Visual C++ generated include file. 3 | // Used by Resource.rc 4 | 5 | // Next default values for new objects 6 | // 7 | #ifdef APSTUDIO_INVOKED 8 | #ifndef APSTUDIO_READONLY_SYMBOLS 9 | #define _APS_NEXT_RESOURCE_VALUE 101 10 | #define _APS_NEXT_COMMAND_VALUE 40001 11 | #define _APS_NEXT_CONTROL_VALUE 1001 12 | #define _APS_NEXT_SYMED_VALUE 101 13 | #endif 14 | #endif 15 | --------------------------------------------------------------------------------