1 /// Partial translation of dinput.h 2 /// 3 /// Assumes direct input version 8, so old versions of interfaces are not included 4 /// Also assumes `UNICODE`, so only the variants that end in W (using wchar) instead of A (using ascii char). 5 module glfw3.directinput8; 6 7 extern(Windows): @nogc: nothrow: __gshared: 8 9 import core.sys.windows.windows; 10 import core.sys.windows.objbase; 11 12 alias IDirectInputDevice8 = IDirectInputDevice8W; 13 enum DIRECTINPUT_VERSION = 0x0800; 14 15 struct _DIDATAFORMAT { 16 DWORD dwSize; 17 DWORD dwObjSize; 18 DWORD dwFlags; 19 DWORD dwDataSize; 20 DWORD dwNumObjs; 21 LPDIOBJECTDATAFORMAT rgodf; 22 }alias _DIDATAFORMAT DIDATAFORMAT;alias _DIDATAFORMAT* LPDIDATAFORMAT; 23 alias const(DIDATAFORMAT)* LPCDIDATAFORMAT; 24 25 struct DIDEVICEOBJECTINSTANCEW { 26 DWORD dwSize; 27 GUID guidType; 28 DWORD dwOfs; 29 DWORD dwType; 30 DWORD dwFlags; 31 WCHAR[MAX_PATH] tszName; 32 DWORD dwFFMaxForce; 33 DWORD dwFFForceResolution; 34 WORD wCollectionNumber; 35 WORD wDesignatorIndex; 36 WORD wUsagePage; 37 WORD wUsage; 38 DWORD dwDimension; 39 WORD wExponent; 40 WORD wReserved; 41 } 42 alias DIDEVICEOBJECTINSTANCEW* LPDIDEVICEOBJECTINSTANCEW; 43 alias const(DIDEVICEOBJECTINSTANCEW)* LPCDIDEVICEOBJECTINSTANCEW; 44 45 enum DIDOI_FFACTUATOR = 0x00000001; 46 enum DIDOI_FFEFFECTTRIGGER = 0x00000002; 47 enum DIDOI_POLLED = 0x00008000; 48 enum DIDOI_ASPECTPOSITION = 0x00000100; 49 enum DIDOI_ASPECTVELOCITY = 0x00000200; 50 enum DIDOI_ASPECTACCEL = 0x00000300; 51 enum DIDOI_ASPECTFORCE = 0x00000400; 52 enum DIDOI_ASPECTMASK = 0x00000F00; 53 enum DIDOI_GUIDISUSAGE = 0x00010000; 54 55 struct DIPROPHEADER { 56 DWORD dwSize; 57 DWORD dwHeaderSize; 58 DWORD dwObj; 59 DWORD dwHow; 60 } 61 alias DIPROPHEADER* LPDIPROPHEADER; 62 alias const(DIPROPHEADER)* LPCDIPROPHEADER; 63 64 enum DIPH_DEVICE = 0; 65 enum DIPH_BYOFFSET = 1; 66 enum DIPH_BYID = 2; 67 enum DIPH_BYUSAGE = 3; 68 69 struct DIPROPDWORD { 70 DIPROPHEADER diph; 71 DWORD dwData; 72 } 73 alias DIPROPDWORD* LPDIPROPDWORD; 74 alias const(DIPROPDWORD)* LPCDIPROPDWORD; 75 76 struct DIPROPRANGE { 77 DIPROPHEADER diph; 78 LONG lMin; 79 LONG lMax; 80 } 81 alias DIPROPRANGE* LPDIPROPRANGE; 82 alias const(DIPROPRANGE)* LPCDIPROPRANGE; 83 84 enum DIPROPRANGE_NOMIN = cast(LONG) 0x80000000; 85 enum DIPROPRANGE_NOMAX = cast(LONG) 0x7FFFFFFF; 86 87 struct DIPROPCAL { 88 DIPROPHEADER diph; 89 LONG lMin; 90 LONG lCenter; 91 LONG lMax; 92 } 93 alias DIPROPCAL* LPDIPROPCAL; 94 alias const(DIPROPCAL)* LPCDIPROPCAL; 95 96 struct DIPROPCALPOV { 97 DIPROPHEADER diph; 98 LONG[5] lMin; 99 LONG[5] lMax; 100 } 101 alias DIPROPCALPOV* LPDIPROPCALPOV; 102 alias const(DIPROPCALPOV)* LPCDIPROPCALPOV; 103 104 struct DIPROPGUIDANDPATH { 105 DIPROPHEADER diph; 106 GUID guidClass; 107 WCHAR[MAX_PATH] wszPath; 108 } 109 alias DIPROPGUIDANDPATH* LPDIPROPGUIDANDPATH; 110 alias const(DIPROPGUIDANDPATH)* LPCDIPROPGUIDANDPATH; 111 112 struct DIPROPSTRING { 113 DIPROPHEADER diph; 114 WCHAR[MAX_PATH] wsz; 115 } 116 alias DIPROPSTRING* LPDIPROPSTRING; 117 alias const(DIPROPSTRING)* LPCDIPROPSTRING; 118 119 struct DIPROPPOINTER { 120 DIPROPHEADER diph; 121 UINT_PTR uData; 122 }/+alias DIPROPPOINTER DIPROPPOINTER;+/alias DIPROPPOINTER* LPDIPROPPOINTER; 123 alias const(DIPROPPOINTER)* LPCDIPROPPOINTER; 124 125 auto MAKEDIPROP(int prop) {return cast(REFGUID) prop;} 126 127 enum DIPROP_BUFFERSIZE = MAKEDIPROP(1); 128 enum DIPROP_AXISMODE = MAKEDIPROP(2); 129 130 enum DIPROPAXISMODE_ABS = 0; 131 enum DIPROPAXISMODE_REL = 1; 132 133 enum DIPROP_GRANULARITY = MAKEDIPROP(3); 134 enum DIPROP_RANGE = MAKEDIPROP(4); 135 enum DIPROP_DEADZONE = MAKEDIPROP(5); 136 enum DIPROP_SATURATION = MAKEDIPROP(6); 137 enum DIPROP_FFGAIN = MAKEDIPROP(7); 138 enum DIPROP_FFLOAD = MAKEDIPROP(8); 139 enum DIPROP_AUTOCENTER = MAKEDIPROP(9); 140 141 enum DIPROPAUTOCENTER_OFF = 0; 142 enum DIPROPAUTOCENTER_ON = 1; 143 144 enum DIPROP_CALIBRATIONMODE = MAKEDIPROP(10); 145 146 enum DIPROPCALIBRATIONMODE_COOKED = 0; 147 enum DIPROPCALIBRATIONMODE_RAW = 1; 148 149 enum DIPROP_CALIBRATION = MAKEDIPROP(11); 150 enum DIPROP_GUIDANDPATH = MAKEDIPROP(12); 151 enum DIPROP_INSTANCENAME = MAKEDIPROP(13); 152 enum DIPROP_PRODUCTNAME = MAKEDIPROP(14); 153 154 enum DIPROP_JOYSTICKID = MAKEDIPROP(15); 155 enum DIPROP_GETPORTDISPLAYNAME = MAKEDIPROP(16); 156 157 enum DIPROP_PHYSICALRANGE = MAKEDIPROP(18); 158 enum DIPROP_LOGICALRANGE = MAKEDIPROP(19); 159 160 enum DIPROP_KEYNAME = MAKEDIPROP(20); 161 enum DIPROP_CPOINTS = MAKEDIPROP(21); 162 enum DIPROP_APPDATA = MAKEDIPROP(22); 163 enum DIPROP_SCANCODE = MAKEDIPROP(23); 164 enum DIPROP_VIDPID = MAKEDIPROP(24); 165 enum DIPROP_USERNAME = MAKEDIPROP(25); 166 enum DIPROP_TYPENAME = MAKEDIPROP(26); 167 168 enum MAXCPOINTSNUM = 8; 169 170 struct _CPOINT { 171 LONG lP; 172 DWORD dwLog; 173 }alias _CPOINT CPOINT;alias _CPOINT* PCPOINT; 174 175 struct DIPROPCPOINTS { 176 DIPROPHEADER diph; 177 DWORD dwCPointsNum; 178 CPOINT[MAXCPOINTSNUM] cp; 179 }/+alias DIPROPCPOINTS DIPROPCPOINTS;+/alias DIPROPCPOINTS* LPDIPROPCPOINTS; 180 alias const(DIPROPCPOINTS)* LPCDIPROPCPOINTS; 181 182 /* Device FF flags */ 183 enum DISFFC_RESET = 0x00000001; 184 enum DISFFC_STOPALL = 0x00000002; 185 enum DISFFC_PAUSE = 0x00000004; 186 enum DISFFC_CONTINUE = 0x00000008; 187 enum DISFFC_SETACTUATORSON = 0x00000010; 188 enum DISFFC_SETACTUATORSOFF = 0x00000020; 189 190 enum DIGFFS_EMPTY = 0x00000001; 191 enum DIGFFS_STOPPED = 0x00000002; 192 enum DIGFFS_PAUSED = 0x00000004; 193 enum DIGFFS_ACTUATORSON = 0x00000010; 194 enum DIGFFS_ACTUATORSOFF = 0x00000020; 195 enum DIGFFS_POWERON = 0x00000040; 196 enum DIGFFS_POWEROFF = 0x00000080; 197 enum DIGFFS_SAFETYSWITCHON = 0x00000100; 198 enum DIGFFS_SAFETYSWITCHOFF = 0x00000200; 199 enum DIGFFS_USERFFSWITCHON = 0x00000400; 200 enum DIGFFS_USERFFSWITCHOFF = 0x00000800; 201 enum DIGFFS_DEVICELOST = 0x80000000; 202 203 /* Effect flags */ 204 enum DIEFT_ALL = 0x00000000; 205 206 enum DIEFT_CONSTANTFORCE = 0x00000001; 207 enum DIEFT_RAMPFORCE = 0x00000002; 208 enum DIEFT_PERIODIC = 0x00000003; 209 enum DIEFT_CONDITION = 0x00000004; 210 enum DIEFT_CUSTOMFORCE = 0x00000005; 211 enum DIEFT_HARDWARE = 0x000000FF; 212 enum DIEFT_FFATTACK = 0x00000200; 213 enum DIEFT_FFFADE = 0x00000400; 214 enum DIEFT_SATURATION = 0x00000800; 215 enum DIEFT_POSNEGCOEFFICIENTS = 0x00001000; 216 enum DIEFT_POSNEGSATURATION = 0x00002000; 217 enum DIEFT_DEADBAND = 0x00004000; 218 enum DIEFT_STARTDELAY = 0x00008000; 219 alias DIEFT_GETTYPE = LOBYTE; //auto DIEFT_GETTYPE(T)(T n) {return LOBYTE(n);} 220 221 enum DIEFF_OBJECTIDS = 0x00000001; 222 enum DIEFF_OBJECTOFFSETS = 0x00000002; 223 enum DIEFF_CARTESIAN = 0x00000010; 224 enum DIEFF_POLAR = 0x00000020; 225 enum DIEFF_SPHERICAL = 0x00000040; 226 227 enum DIEP_DURATION = 0x00000001; 228 enum DIEP_SAMPLEPERIOD = 0x00000002; 229 enum DIEP_GAIN = 0x00000004; 230 enum DIEP_TRIGGERBUTTON = 0x00000008; 231 enum DIEP_TRIGGERREPEATINTERVAL = 0x00000010; 232 enum DIEP_AXES = 0x00000020; 233 enum DIEP_DIRECTION = 0x00000040; 234 enum DIEP_ENVELOPE = 0x00000080; 235 enum DIEP_TYPESPECIFICPARAMS = 0x00000100; 236 enum DIEP_STARTDELAY = 0x00000200; 237 enum DIEP_ALLPARAMS_DX5 = 0x000001FF; 238 enum DIEP_ALLPARAMS = 0x000003FF; 239 enum DIEP_START = 0x20000000; 240 enum DIEP_NORESTART = 0x40000000; 241 enum DIEP_NODOWNLOAD = 0x80000000; 242 enum DIEB_NOTRIGGER = 0xFFFFFFFF; 243 244 enum DIES_SOLO = 0x00000001; 245 enum DIES_NODOWNLOAD = 0x80000000; 246 247 enum DIEGES_PLAYING = 0x00000001; 248 enum DIEGES_EMULATED = 0x00000002; 249 250 enum DI_DEGREES = 100; 251 enum DI_FFNOMINALMAX = 10000; 252 enum DI_SECONDS = 1000000; 253 254 struct DICONSTANTFORCE { 255 LONG lMagnitude; 256 } 257 alias DICONSTANTFORCE* LPDICONSTANTFORCE; 258 alias const(DICONSTANTFORCE)* LPCDICONSTANTFORCE; 259 260 struct DIRAMPFORCE { 261 LONG lStart; 262 LONG lEnd; 263 } 264 alias DIRAMPFORCE* LPDIRAMPFORCE; 265 alias const(DIRAMPFORCE)* LPCDIRAMPFORCE; 266 267 struct DIPERIODIC { 268 DWORD dwMagnitude; 269 LONG lOffset; 270 DWORD dwPhase; 271 DWORD dwPeriod; 272 } 273 alias DIPERIODIC* LPDIPERIODIC; 274 alias const(DIPERIODIC)* LPCDIPERIODIC; 275 276 struct DICONDITION { 277 LONG lOffset; 278 LONG lPositiveCoefficient; 279 LONG lNegativeCoefficient; 280 DWORD dwPositiveSaturation; 281 DWORD dwNegativeSaturation; 282 LONG lDeadBand; 283 } 284 alias DICONDITION* LPDICONDITION; 285 alias const(DICONDITION)* LPCDICONDITION; 286 287 struct DICUSTOMFORCE { 288 DWORD cChannels; 289 DWORD dwSamplePeriod; 290 DWORD cSamples; 291 LPLONG rglForceData; 292 } 293 alias DICUSTOMFORCE* LPDICUSTOMFORCE; 294 alias const(DICUSTOMFORCE)* LPCDICUSTOMFORCE; 295 296 struct DIENVELOPE { 297 DWORD dwSize; 298 DWORD dwAttackLevel; 299 DWORD dwAttackTime; 300 DWORD dwFadeLevel; 301 DWORD dwFadeTime; 302 } 303 alias DIENVELOPE* LPDIENVELOPE; 304 alias const(DIENVELOPE)* LPCDIENVELOPE; 305 306 struct DIEFFECT_DX5 { 307 DWORD dwSize; 308 DWORD dwFlags; 309 DWORD dwDuration; 310 DWORD dwSamplePeriod; 311 DWORD dwGain; 312 DWORD dwTriggerButton; 313 DWORD dwTriggerRepeatInterval; 314 DWORD cAxes; 315 LPDWORD rgdwAxes; 316 LPLONG rglDirection; 317 LPDIENVELOPE lpEnvelope; 318 DWORD cbTypeSpecificParams; 319 LPVOID lpvTypeSpecificParams; 320 } 321 alias DIEFFECT_DX5* LPDIEFFECT_DX5; 322 alias const(DIEFFECT_DX5)* LPCDIEFFECT_DX5; 323 324 struct DIEFFECT { 325 DWORD dwSize; 326 DWORD dwFlags; 327 DWORD dwDuration; 328 DWORD dwSamplePeriod; 329 DWORD dwGain; 330 DWORD dwTriggerButton; 331 DWORD dwTriggerRepeatInterval; 332 DWORD cAxes; 333 LPDWORD rgdwAxes; 334 LPLONG rglDirection; 335 LPDIENVELOPE lpEnvelope; 336 DWORD cbTypeSpecificParams; 337 LPVOID lpvTypeSpecificParams; 338 DWORD dwStartDelay; 339 } 340 alias DIEFFECT* LPDIEFFECT; 341 alias const(DIEFFECT)* LPCDIEFFECT; 342 alias DIEFFECT DIEFFECT_DX6; 343 alias LPDIEFFECT LPDIEFFECT_DX6; 344 345 struct DIEFFECTINFOA { 346 DWORD dwSize; 347 GUID guid; 348 DWORD dwEffType; 349 DWORD dwStaticParams; 350 DWORD dwDynamicParams; 351 CHAR[MAX_PATH] tszName; 352 } 353 alias DIEFFECTINFOA* LPDIEFFECTINFOA; 354 alias const(DIEFFECTINFOA)* LPCDIEFFECTINFOA; 355 356 struct DIEFFECTINFOW { 357 DWORD dwSize; 358 GUID guid; 359 DWORD dwEffType; 360 DWORD dwStaticParams; 361 DWORD dwDynamicParams; 362 WCHAR[MAX_PATH] tszName; 363 } 364 alias DIEFFECTINFOW* LPDIEFFECTINFOW; 365 alias const(DIEFFECTINFOW)* LPCDIEFFECTINFOW; 366 367 struct DIEFFESCAPE { 368 DWORD dwSize; 369 DWORD dwCommand; 370 LPVOID lpvInBuffer; 371 DWORD cbInBuffer; 372 LPVOID lpvOutBuffer; 373 DWORD cbOutBuffer; 374 } 375 alias DIEFFESCAPE* LPDIEFFESCAPE; 376 377 struct DIJOYSTATE { 378 LONG lX; 379 LONG lY; 380 LONG lZ; 381 LONG lRx; 382 LONG lRy; 383 LONG lRz; 384 LONG[2] rglSlider; 385 DWORD[4] rgdwPOV; 386 BYTE[32] rgbButtons; 387 } 388 alias DIJOYSTATE* LPDIJOYSTATE; 389 390 struct DIJOYSTATE2 { 391 LONG lX; 392 LONG lY; 393 LONG lZ; 394 LONG lRx; 395 LONG lRy; 396 LONG lRz; 397 LONG[2] rglSlider; 398 DWORD[4] rgdwPOV; 399 BYTE[128] rgbButtons; 400 LONG lVX; /* 'v' as in velocity */ 401 LONG lVY; 402 LONG lVZ; 403 LONG lVRx; 404 LONG lVRy; 405 LONG lVRz; 406 LONG[2] rglVSlider; 407 LONG lAX; /* 'a' as in acceleration */ 408 LONG lAY; 409 LONG lAZ; 410 LONG lARx; 411 LONG lARy; 412 LONG lARz; 413 LONG[2] rglASlider; 414 LONG lFX; /* 'f' as in force */ 415 LONG lFY; 416 LONG lFZ; 417 LONG lFRx; /* 'fr' as in rotational force aka torque */ 418 LONG lFRy; 419 LONG lFRz; 420 LONG[2] rglFSlider; 421 } 422 alias DIJOYSTATE2* LPDIJOYSTATE2; 423 424 enum DIJOFS_X = DIJOYSTATE.lX.offsetof; 425 enum DIJOFS_Y = DIJOYSTATE.lY.offsetof; 426 enum DIJOFS_Z = DIJOYSTATE.lZ.offsetof; 427 enum DIJOFS_RX = DIJOYSTATE.lRx.offsetof; 428 enum DIJOFS_RY = DIJOYSTATE.lRy.offsetof; 429 enum DIJOFS_RZ = DIJOYSTATE.lRz.offsetof; 430 pragma(inline, true) extern(D) int DIJOFS_SLIDER(int n) {return cast(int) (DIJOYSTATE.rglSlider.offsetof + n * LONG.sizeof);} 431 pragma(inline, true) extern(D) int DIJOFS_POV(int n) {return cast(int) (DIJOYSTATE.rgdwPOV.offsetof + n * DWORD.sizeof);} 432 pragma(inline, true) extern(D) int DIJOFS_BUTTON(int n) {return cast(int) (DIJOYSTATE.rgbButtons.offsetof + n);} 433 enum DIJOFS_BUTTON0 = DIJOFS_BUTTON(0); 434 enum DIJOFS_BUTTON1 = DIJOFS_BUTTON(1); 435 enum DIJOFS_BUTTON2 = DIJOFS_BUTTON(2); 436 enum DIJOFS_BUTTON3 = DIJOFS_BUTTON(3); 437 enum DIJOFS_BUTTON4 = DIJOFS_BUTTON(4); 438 enum DIJOFS_BUTTON5 = DIJOFS_BUTTON(5); 439 enum DIJOFS_BUTTON6 = DIJOFS_BUTTON(6); 440 enum DIJOFS_BUTTON7 = DIJOFS_BUTTON(7); 441 enum DIJOFS_BUTTON8 = DIJOFS_BUTTON(8); 442 enum DIJOFS_BUTTON9 = DIJOFS_BUTTON(9); 443 enum DIJOFS_BUTTON10 = DIJOFS_BUTTON(10); 444 enum DIJOFS_BUTTON11 = DIJOFS_BUTTON(11); 445 enum DIJOFS_BUTTON12 = DIJOFS_BUTTON(12); 446 enum DIJOFS_BUTTON13 = DIJOFS_BUTTON(13); 447 enum DIJOFS_BUTTON14 = DIJOFS_BUTTON(14); 448 enum DIJOFS_BUTTON15 = DIJOFS_BUTTON(15); 449 enum DIJOFS_BUTTON16 = DIJOFS_BUTTON(16); 450 enum DIJOFS_BUTTON17 = DIJOFS_BUTTON(17); 451 enum DIJOFS_BUTTON18 = DIJOFS_BUTTON(18); 452 enum DIJOFS_BUTTON19 = DIJOFS_BUTTON(19); 453 enum DIJOFS_BUTTON20 = DIJOFS_BUTTON(20); 454 enum DIJOFS_BUTTON21 = DIJOFS_BUTTON(21); 455 enum DIJOFS_BUTTON22 = DIJOFS_BUTTON(22); 456 enum DIJOFS_BUTTON23 = DIJOFS_BUTTON(23); 457 enum DIJOFS_BUTTON24 = DIJOFS_BUTTON(24); 458 enum DIJOFS_BUTTON25 = DIJOFS_BUTTON(25); 459 enum DIJOFS_BUTTON26 = DIJOFS_BUTTON(26); 460 enum DIJOFS_BUTTON27 = DIJOFS_BUTTON(27); 461 enum DIJOFS_BUTTON28 = DIJOFS_BUTTON(28); 462 enum DIJOFS_BUTTON29 = DIJOFS_BUTTON(29); 463 enum DIJOFS_BUTTON30 = DIJOFS_BUTTON(30); 464 enum DIJOFS_BUTTON31 = DIJOFS_BUTTON(31); 465 466 enum DIK_ESCAPE = 0x01; 467 enum DIK_1 = 0x02; 468 enum DIK_2 = 0x03; 469 enum DIK_3 = 0x04; 470 enum DIK_4 = 0x05; 471 enum DIK_5 = 0x06; 472 enum DIK_6 = 0x07; 473 enum DIK_7 = 0x08; 474 enum DIK_8 = 0x09; 475 enum DIK_9 = 0x0A; 476 enum DIK_0 = 0x0B; 477 enum DIK_MINUS = 0x0C /* - on main keyboard */; 478 enum DIK_EQUALS = 0x0D; 479 enum DIK_BACK = 0x0E /* backspace */; 480 enum DIK_TAB = 0x0F; 481 enum DIK_Q = 0x10; 482 enum DIK_W = 0x11; 483 enum DIK_E = 0x12; 484 enum DIK_R = 0x13; 485 enum DIK_T = 0x14; 486 enum DIK_Y = 0x15; 487 enum DIK_U = 0x16; 488 enum DIK_I = 0x17; 489 enum DIK_O = 0x18; 490 enum DIK_P = 0x19; 491 enum DIK_LBRACKET = 0x1A; 492 enum DIK_RBRACKET = 0x1B; 493 enum DIK_RETURN = 0x1C /* Enter on main keyboard */; 494 enum DIK_LCONTROL = 0x1D; 495 enum DIK_A = 0x1E; 496 enum DIK_S = 0x1F; 497 enum DIK_D = 0x20; 498 enum DIK_F = 0x21; 499 enum DIK_G = 0x22; 500 enum DIK_H = 0x23; 501 enum DIK_J = 0x24; 502 enum DIK_K = 0x25; 503 enum DIK_L = 0x26; 504 enum DIK_SEMICOLON = 0x27; 505 enum DIK_APOSTROPHE = 0x28; 506 enum DIK_GRAVE = 0x29 /* accent grave */; 507 enum DIK_LSHIFT = 0x2A; 508 enum DIK_BACKSLASH = 0x2B; 509 enum DIK_Z = 0x2C; 510 enum DIK_X = 0x2D; 511 enum DIK_C = 0x2E; 512 enum DIK_V = 0x2F; 513 enum DIK_B = 0x30; 514 enum DIK_N = 0x31; 515 enum DIK_M = 0x32; 516 enum DIK_COMMA = 0x33; 517 enum DIK_PERIOD = 0x34 /* . on main keyboard */; 518 enum DIK_SLASH = 0x35 /* / on main keyboard */; 519 enum DIK_RSHIFT = 0x36; 520 enum DIK_MULTIPLY = 0x37 /* * on numeric keypad */; 521 enum DIK_LMENU = 0x38 /* left Alt */; 522 enum DIK_SPACE = 0x39; 523 enum DIK_CAPITAL = 0x3A; 524 enum DIK_F1 = 0x3B; 525 enum DIK_F2 = 0x3C; 526 enum DIK_F3 = 0x3D; 527 enum DIK_F4 = 0x3E; 528 enum DIK_F5 = 0x3F; 529 enum DIK_F6 = 0x40; 530 enum DIK_F7 = 0x41; 531 enum DIK_F8 = 0x42; 532 enum DIK_F9 = 0x43; 533 enum DIK_F10 = 0x44; 534 enum DIK_NUMLOCK = 0x45; 535 enum DIK_SCROLL = 0x46 /* Scroll Lock */; 536 enum DIK_NUMPAD7 = 0x47; 537 enum DIK_NUMPAD8 = 0x48; 538 enum DIK_NUMPAD9 = 0x49; 539 enum DIK_SUBTRACT = 0x4A /* - on numeric keypad */; 540 enum DIK_NUMPAD4 = 0x4B; 541 enum DIK_NUMPAD5 = 0x4C; 542 enum DIK_NUMPAD6 = 0x4D; 543 enum DIK_ADD = 0x4E /* + on numeric keypad */; 544 enum DIK_NUMPAD1 = 0x4F; 545 enum DIK_NUMPAD2 = 0x50; 546 enum DIK_NUMPAD3 = 0x51; 547 enum DIK_NUMPAD0 = 0x52; 548 enum DIK_DECIMAL = 0x53 /* . on numeric keypad */; 549 enum DIK_OEM_102 = 0x56 /* < > | on UK/Germany keyboards */; 550 enum DIK_F11 = 0x57; 551 enum DIK_F12 = 0x58; 552 enum DIK_F13 = 0x64 /* (NEC PC98) */; 553 enum DIK_F14 = 0x65 /* (NEC PC98) */; 554 enum DIK_F15 = 0x66 /* (NEC PC98) */; 555 enum DIK_KANA = 0x70 /* (Japanese keyboard) */; 556 enum DIK_ABNT_C1 = 0x73 /* / ? on Portugese (Brazilian) keyboards */; 557 enum DIK_CONVERT = 0x79 /* (Japanese keyboard) */; 558 enum DIK_NOCONVERT = 0x7B /* (Japanese keyboard) */; 559 enum DIK_YEN = 0x7D /* (Japanese keyboard) */; 560 enum DIK_ABNT_C2 = 0x7E /* Numpad . on Portugese (Brazilian) keyboards */; 561 enum DIK_NUMPADEQUALS = 0x8D /* = on numeric keypad (NEC PC98) */; 562 enum DIK_CIRCUMFLEX = 0x90 /* (Japanese keyboard) */; 563 enum DIK_AT = 0x91 /* (NEC PC98) */; 564 enum DIK_COLON = 0x92 /* (NEC PC98) */; 565 enum DIK_UNDERLINE = 0x93 /* (NEC PC98) */; 566 enum DIK_KANJI = 0x94 /* (Japanese keyboard) */; 567 enum DIK_STOP = 0x95 /* (NEC PC98) */; 568 enum DIK_AX = 0x96 /* (Japan AX) */; 569 enum DIK_UNLABELED = 0x97 /* (J3100) */; 570 enum DIK_NEXTTRACK = 0x99 /* Next Track */; 571 enum DIK_NUMPADENTER = 0x9C /* Enter on numeric keypad */; 572 enum DIK_RCONTROL = 0x9D; 573 enum DIK_MUTE = 0xA0 /* Mute */; 574 enum DIK_CALCULATOR = 0xA1 /* Calculator */; 575 enum DIK_PLAYPAUSE = 0xA2 /* Play / Pause */; 576 enum DIK_MEDIASTOP = 0xA4 /* Media Stop */; 577 enum DIK_VOLUMEDOWN = 0xAE /* Volume - */; 578 enum DIK_VOLUMEUP = 0xB0 /* Volume + */; 579 enum DIK_WEBHOME = 0xB2 /* Web home */; 580 enum DIK_NUMPADCOMMA = 0xB3 /* , on numeric keypad (NEC PC98) */; 581 enum DIK_DIVIDE = 0xB5 /* / on numeric keypad */; 582 enum DIK_SYSRQ = 0xB7; 583 enum DIK_RMENU = 0xB8 /* right Alt */; 584 enum DIK_PAUSE = 0xC5 /* Pause */; 585 enum DIK_HOME = 0xC7 /* Home on arrow keypad */; 586 enum DIK_UP = 0xC8 /* UpArrow on arrow keypad */; 587 enum DIK_PRIOR = 0xC9 /* PgUp on arrow keypad */; 588 enum DIK_LEFT = 0xCB /* LeftArrow on arrow keypad */; 589 enum DIK_RIGHT = 0xCD /* RightArrow on arrow keypad */; 590 enum DIK_END = 0xCF /* End on arrow keypad */; 591 enum DIK_DOWN = 0xD0 /* DownArrow on arrow keypad */; 592 enum DIK_NEXT = 0xD1 /* PgDn on arrow keypad */; 593 enum DIK_INSERT = 0xD2 /* Insert on arrow keypad */; 594 enum DIK_DELETE = 0xD3 /* Delete on arrow keypad */; 595 enum DIK_LWIN = 0xDB /* Left Windows key */; 596 enum DIK_RWIN = 0xDC /* Right Windows key */; 597 enum DIK_APPS = 0xDD /* AppMenu key */; 598 enum DIK_POWER = 0xDE; 599 enum DIK_SLEEP = 0xDF; 600 enum DIK_WAKE = 0xE3 /* System Wake */; 601 enum DIK_WEBSEARCH = 0xE5 /* Web Search */; 602 enum DIK_WEBFAVORITES = 0xE6 /* Web Favorites */; 603 enum DIK_WEBREFRESH = 0xE7 /* Web Refresh */; 604 enum DIK_WEBSTOP = 0xE8 /* Web Stop */; 605 enum DIK_WEBFORWARD = 0xE9 /* Web Forward */; 606 enum DIK_WEBBACK = 0xEA /* Web Back */; 607 enum DIK_MYCOMPUTER = 0xEB /* My Computer */; 608 enum DIK_MAIL = 0xEC /* Mail */; 609 enum DIK_MEDIASELECT = 0xED /* Media Select */; 610 611 enum DIK_BACKSPACE = DIK_BACK /* backspace */; 612 enum DIK_NUMPADSTAR = DIK_MULTIPLY /* * on numeric keypad */; 613 enum DIK_LALT = DIK_LMENU /* left Alt */; 614 enum DIK_CAPSLOCK = DIK_CAPITAL /* CapsLock */; 615 enum DIK_NUMPADMINUS = DIK_SUBTRACT /* - on numeric keypad */; 616 enum DIK_NUMPADPLUS = DIK_ADD /* + on numeric keypad */; 617 enum DIK_NUMPADPERIOD = DIK_DECIMAL /* . on numeric keypad */; 618 enum DIK_NUMPADSLASH = DIK_DIVIDE /* / on numeric keypad */; 619 enum DIK_RALT = DIK_RMENU /* right Alt */; 620 enum DIK_UPARROW = DIK_UP /* UpArrow on arrow keypad */; 621 enum DIK_PGUP = DIK_PRIOR /* PgUp on arrow keypad */; 622 enum DIK_LEFTARROW = DIK_LEFT /* LeftArrow on arrow keypad */; 623 enum DIK_RIGHTARROW = DIK_RIGHT /* RightArrow on arrow keypad */; 624 enum DIK_DOWNARROW = DIK_DOWN /* DownArrow on arrow keypad */; 625 enum DIK_PGDN = DIK_NEXT /* PgDn on arrow keypad */; 626 627 enum DIDFT_ALL = 0x00000000; 628 enum DIDFT_RELAXIS = 0x00000001; 629 enum DIDFT_ABSAXIS = 0x00000002; 630 enum DIDFT_AXIS = 0x00000003; 631 enum DIDFT_PSHBUTTON = 0x00000004; 632 enum DIDFT_TGLBUTTON = 0x00000008; 633 enum DIDFT_BUTTON = 0x0000000C; 634 enum DIDFT_POV = 0x00000010; 635 enum DIDFT_COLLECTION = 0x00000040; 636 enum DIDFT_NODATA = 0x00000080; 637 enum DIDFT_ANYINSTANCE = 0x00FFFF00; 638 enum DIDFT_INSTANCEMASK = DIDFT_ANYINSTANCE; 639 640 enum DIERR_INSUFFICIENTPRIVS = 0x80040200L; 641 enum DIERR_DEVICEFULL = 0x80040201L; 642 enum DIERR_MOREDATA = 0x80040202L; 643 enum DIERR_NOTDOWNLOADED = 0x80040203L; 644 enum DIERR_HASEFFECTS = 0x80040204L; 645 enum DIERR_NOTEXCLUSIVEACQUIRED = 0x80040205L; 646 enum DIERR_INCOMPLETEEFFECT = 0x80040206L; 647 enum DIERR_NOTBUFFERED = 0x80040207L; 648 enum DIERR_EFFECTPLAYING = 0x80040208L; 649 enum DIERR_UNPLUGGED = 0x80040209L; 650 enum DIERR_REPORTFULL = 0x8004020AL; 651 enum DIERR_MAPFILEFAIL = 0x8004020BL; 652 653 enum DIENUM_STOP = 0; 654 enum DIENUM_CONTINUE = 1; 655 656 enum DIEDFL_ALLDEVICES = 0x00000000; 657 enum DIEDFL_ATTACHEDONLY = 0x00000001; 658 enum DIEDFL_FORCEFEEDBACK = 0x00000100; 659 enum DIEDFL_INCLUDEALIASES = 0x00010000; 660 enum DIEDFL_INCLUDEPHANTOMS = 0x00020000; 661 enum DIEDFL_INCLUDEHIDDEN = 0x00040000; 662 663 enum DIDEVTYPE_DEVICE = 1; 664 enum DIDEVTYPE_MOUSE = 2; 665 enum DIDEVTYPE_KEYBOARD = 3; 666 enum DIDEVTYPE_JOYSTICK = 4; 667 enum DIDEVTYPE_HID = 0x00010000; 668 669 enum DI8DEVCLASS_ALL = 0; 670 enum DI8DEVCLASS_DEVICE = 1; 671 enum DI8DEVCLASS_POINTER = 2; 672 enum DI8DEVCLASS_KEYBOARD = 3; 673 enum DI8DEVCLASS_GAMECTRL = 4; 674 675 enum DI8DEVTYPE_DEVICE = 0x11; 676 enum DI8DEVTYPE_MOUSE = 0x12; 677 enum DI8DEVTYPE_KEYBOARD = 0x13; 678 enum DI8DEVTYPE_JOYSTICK = 0x14; 679 enum DI8DEVTYPE_GAMEPAD = 0x15; 680 enum DI8DEVTYPE_DRIVING = 0x16; 681 enum DI8DEVTYPE_FLIGHT = 0x17; 682 enum DI8DEVTYPE_1STPERSON = 0x18; 683 enum DI8DEVTYPE_DEVICECTRL = 0x19; 684 enum DI8DEVTYPE_SCREENPOINTER = 0x1A; 685 enum DI8DEVTYPE_REMOTE = 0x1B; 686 enum DI8DEVTYPE_SUPPLEMENTAL = 0x1C; 687 688 enum DIDEVTYPEMOUSE_UNKNOWN = 1; 689 enum DIDEVTYPEMOUSE_TRADITIONAL = 2; 690 enum DIDEVTYPEMOUSE_FINGERSTICK = 3; 691 enum DIDEVTYPEMOUSE_TOUCHPAD = 4; 692 enum DIDEVTYPEMOUSE_TRACKBALL = 5; 693 694 enum DIDEVTYPEKEYBOARD_UNKNOWN = 0; 695 enum DIDEVTYPEKEYBOARD_PCXT = 1; 696 enum DIDEVTYPEKEYBOARD_OLIVETTI = 2; 697 enum DIDEVTYPEKEYBOARD_PCAT = 3; 698 enum DIDEVTYPEKEYBOARD_PCENH = 4; 699 enum DIDEVTYPEKEYBOARD_NOKIA1050 = 5; 700 enum DIDEVTYPEKEYBOARD_NOKIA9140 = 6; 701 enum DIDEVTYPEKEYBOARD_NEC98 = 7; 702 enum DIDEVTYPEKEYBOARD_NEC98LAPTOP = 8; 703 enum DIDEVTYPEKEYBOARD_NEC98106 = 9; 704 enum DIDEVTYPEKEYBOARD_JAPAN106 = 10; 705 enum DIDEVTYPEKEYBOARD_JAPANAX = 11; 706 enum DIDEVTYPEKEYBOARD_J3100 = 12; 707 708 enum DIDEVTYPEJOYSTICK_UNKNOWN = 1; 709 enum DIDEVTYPEJOYSTICK_TRADITIONAL = 2; 710 enum DIDEVTYPEJOYSTICK_FLIGHTSTICK = 3; 711 enum DIDEVTYPEJOYSTICK_GAMEPAD = 4; 712 enum DIDEVTYPEJOYSTICK_RUDDER = 5; 713 enum DIDEVTYPEJOYSTICK_WHEEL = 6; 714 enum DIDEVTYPEJOYSTICK_HEADTRACKER = 7; 715 716 enum DI8DEVTYPEMOUSE_UNKNOWN = 1; 717 enum DI8DEVTYPEMOUSE_TRADITIONAL = 2; 718 enum DI8DEVTYPEMOUSE_FINGERSTICK = 3; 719 enum DI8DEVTYPEMOUSE_TOUCHPAD = 4; 720 enum DI8DEVTYPEMOUSE_TRACKBALL = 5; 721 enum DI8DEVTYPEMOUSE_ABSOLUTE = 6; 722 723 enum DI8DEVTYPEKEYBOARD_UNKNOWN = 0; 724 enum DI8DEVTYPEKEYBOARD_PCXT = 1; 725 enum DI8DEVTYPEKEYBOARD_OLIVETTI = 2; 726 enum DI8DEVTYPEKEYBOARD_PCAT = 3; 727 enum DI8DEVTYPEKEYBOARD_PCENH = 4; 728 enum DI8DEVTYPEKEYBOARD_NOKIA1050 = 5; 729 enum DI8DEVTYPEKEYBOARD_NOKIA9140 = 6; 730 enum DI8DEVTYPEKEYBOARD_NEC98 = 7; 731 enum DI8DEVTYPEKEYBOARD_NEC98LAPTOP = 8; 732 enum DI8DEVTYPEKEYBOARD_NEC98106 = 9; 733 enum DI8DEVTYPEKEYBOARD_JAPAN106 = 10; 734 enum DI8DEVTYPEKEYBOARD_JAPANAX = 11; 735 enum DI8DEVTYPEKEYBOARD_J3100 = 12; 736 737 enum DI8DEVTYPE_LIMITEDGAMESUBTYPE = 1; 738 739 enum DI8DEVTYPEJOYSTICK_LIMITED = DI8DEVTYPE_LIMITEDGAMESUBTYPE; 740 enum DI8DEVTYPEJOYSTICK_STANDARD = 2; 741 742 enum DI8DEVTYPEGAMEPAD_LIMITED = DI8DEVTYPE_LIMITEDGAMESUBTYPE; 743 enum DI8DEVTYPEGAMEPAD_STANDARD = 2; 744 enum DI8DEVTYPEGAMEPAD_TILT = 3; 745 746 enum DI8DEVTYPEDRIVING_LIMITED = DI8DEVTYPE_LIMITEDGAMESUBTYPE; 747 enum DI8DEVTYPEDRIVING_COMBINEDPEDALS = 2; 748 enum DI8DEVTYPEDRIVING_DUALPEDALS = 3; 749 enum DI8DEVTYPEDRIVING_THREEPEDALS = 4; 750 enum DI8DEVTYPEDRIVING_HANDHELD = 5; 751 752 enum DI8DEVTYPEFLIGHT_LIMITED = DI8DEVTYPE_LIMITEDGAMESUBTYPE; 753 enum DI8DEVTYPEFLIGHT_STICK = 2; 754 enum DI8DEVTYPEFLIGHT_YOKE = 3; 755 enum DI8DEVTYPEFLIGHT_RC = 4; 756 757 enum DI8DEVTYPE1STPERSON_LIMITED = DI8DEVTYPE_LIMITEDGAMESUBTYPE; 758 enum DI8DEVTYPE1STPERSON_UNKNOWN = 2; 759 enum DI8DEVTYPE1STPERSON_SIXDOF = 3; 760 enum DI8DEVTYPE1STPERSON_SHOOTER = 4; 761 762 enum DI8DEVTYPESCREENPTR_UNKNOWN = 2; 763 enum DI8DEVTYPESCREENPTR_LIGHTGUN = 3; 764 enum DI8DEVTYPESCREENPTR_LIGHTPEN = 4; 765 enum DI8DEVTYPESCREENPTR_TOUCH = 5; 766 767 enum DI8DEVTYPEREMOTE_UNKNOWN = 2; 768 769 enum DI8DEVTYPEDEVICECTRL_UNKNOWN = 2; 770 enum DI8DEVTYPEDEVICECTRL_COMMSSELECTION = 3; 771 enum DI8DEVTYPEDEVICECTRL_COMMSSELECTION_HARDWIRED = 4; 772 773 enum DI8DEVTYPESUPPLEMENTAL_UNKNOWN = 2; 774 enum DI8DEVTYPESUPPLEMENTAL_2NDHANDCONTROLLER = 3; 775 enum DI8DEVTYPESUPPLEMENTAL_HEADTRACKER = 4; 776 enum DI8DEVTYPESUPPLEMENTAL_HANDTRACKER = 5; 777 enum DI8DEVTYPESUPPLEMENTAL_SHIFTSTICKGATE = 6; 778 enum DI8DEVTYPESUPPLEMENTAL_SHIFTER = 7; 779 enum DI8DEVTYPESUPPLEMENTAL_THROTTLE = 8; 780 enum DI8DEVTYPESUPPLEMENTAL_SPLITTHROTTLE = 9; 781 enum DI8DEVTYPESUPPLEMENTAL_COMBINEDPEDALS = 10; 782 enum DI8DEVTYPESUPPLEMENTAL_DUALPEDALS = 11; 783 enum DI8DEVTYPESUPPLEMENTAL_THREEPEDALS = 12; 784 enum DI8DEVTYPESUPPLEMENTAL_RUDDERPEDALS = 13; 785 786 struct DIDEVICEINSTANCEW { 787 DWORD dwSize; 788 GUID guidInstance; 789 GUID guidProduct; 790 DWORD dwDevType; 791 WCHAR[MAX_PATH] tszInstanceName; 792 WCHAR[MAX_PATH] tszProductName; 793 GUID guidFFDriver; 794 WORD wUsagePage; 795 WORD wUsage; 796 } 797 alias DIDEVICEINSTANCEW* LPDIDEVICEINSTANCEW; 798 alias const(DIDEVICEINSTANCEW)* LPCDIDEVICEINSTANCEW; 799 800 alias DIDEVICEINSTANCE = DIDEVICEINSTANCEW; 801 802 enum DI_OK = S_OK; 803 enum DI_NOTATTACHED = S_FALSE; 804 enum DI_BUFFEROVERFLOW = S_FALSE; 805 enum DI_PROPNOEFFECT = S_FALSE; 806 enum DI_NOEFFECT = S_FALSE; 807 enum DI_POLLEDDEVICE = HRESULT(0x0002); 808 enum DI_DOWNLOADSKIPPED = HRESULT(0x0003); 809 enum DI_EFFECTRESTARTED = HRESULT(0x0004); 810 enum DI_TRUNCATED = HRESULT(0x0008); 811 enum DI_SETTINGSNOTSAVED = HRESULT(0x000B); 812 enum DI_TRUNCATEDANDRESTARTED = HRESULT(0x000C); 813 enum DI_WRITEPROTECT = HRESULT(0x0013); 814 815 enum DIERR_OLDDIRECTINPUTVERSION = MAKE_HRESULT(SEVERITY_ERROR, FACILITY_WIN32, ERROR_OLD_WIN_VERSION); 816 enum DIERR_BETADIRECTINPUTVERSION = MAKE_HRESULT(SEVERITY_ERROR, FACILITY_WIN32, ERROR_RMODE_APP); 817 enum DIERR_BADDRIVERVER = MAKE_HRESULT(SEVERITY_ERROR, FACILITY_WIN32, ERROR_BAD_DRIVER_LEVEL); 818 enum DIERR_DEVICENOTREG = REGDB_E_CLASSNOTREG; 819 enum DIERR_NOTFOUND = MAKE_HRESULT(SEVERITY_ERROR, FACILITY_WIN32, ERROR_FILE_NOT_FOUND); 820 enum DIERR_OBJECTNOTFOUND = MAKE_HRESULT(SEVERITY_ERROR, FACILITY_WIN32, ERROR_FILE_NOT_FOUND); 821 enum DIERR_INVALIDPARAM = E_INVALIDARG; 822 enum DIERR_NOINTERFACE = E_NOINTERFACE; 823 enum DIERR_GENERIC = E_FAIL; 824 enum DIERR_OUTOFMEMORY = E_OUTOFMEMORY; 825 enum DIERR_UNSUPPORTED = E_NOTIMPL; 826 enum DIERR_NOTINITIALIZED = MAKE_HRESULT(SEVERITY_ERROR, FACILITY_WIN32, ERROR_NOT_READY); 827 enum DIERR_ALREADYINITIALIZED = MAKE_HRESULT(SEVERITY_ERROR, FACILITY_WIN32, ERROR_ALREADY_INITIALIZED); 828 enum DIERR_NOAGGREGATION = CLASS_E_NOAGGREGATION; 829 enum DIERR_OTHERAPPHASPRIO = E_ACCESSDENIED; 830 enum DIERR_INPUTLOST = MAKE_HRESULT(SEVERITY_ERROR, FACILITY_WIN32, ERROR_READ_FAULT); 831 enum DIERR_ACQUIRED = MAKE_HRESULT(SEVERITY_ERROR, FACILITY_WIN32, ERROR_BUSY); 832 enum DIERR_NOTACQUIRED = MAKE_HRESULT(SEVERITY_ERROR, FACILITY_WIN32, ERROR_INVALID_ACCESS); 833 enum DIERR_READONLY = E_ACCESSDENIED; 834 enum DIERR_HANDLEEXISTS = E_ACCESSDENIED; 835 enum E_PENDING = 0x8000000AL; 836 837 enum string DIDFT_MAKEINSTANCE(string n) = ` ((WORD)(n) << 8)`; 838 auto DIDFT_GETTYPE(T)(T a) {return LOBYTE(cast(ushort) a);} 839 enum string DIDFT_GETINSTANCE(string n) = ` LOWORD((n) >> 8)`; 840 enum DIDFT_FFACTUATOR = 0x01000000; 841 enum DIDFT_FFEFFECTTRIGGER = 0x02000000; 842 enum DIDFT_OUTPUT = 0x10000000; 843 enum DIDFT_VENDORDEFINED = 0x04000000; 844 enum DIDFT_ALIAS = 0x08000000; 845 enum DIDFT_OPTIONAL = 0x80000000; 846 enum string DIDFT_ENUMCOLLECTION(string n) = ` ((WORD)(n) << 8)`; 847 enum DIDFT_NOCOLLECTION = 0x00FFFF00; 848 849 enum DIDF_ABSAXIS = 0x00000001; 850 enum DIDF_RELAXIS = 0x00000002; 851 enum DIGDD_PEEK = 0x00000001; 852 853 enum string DISEQUENCE_COMPARE(string dwSq1,string cmp,string dwSq2) = ` ((int)((dwSq1) - (dwSq2)) cmp 0)`; 854 855 struct DIDEVCAPS_DX3 { 856 DWORD dwSize; 857 DWORD dwFlags; 858 DWORD dwDevType; 859 DWORD dwAxes; 860 DWORD dwButtons; 861 DWORD dwPOVs; 862 } 863 alias DIDEVCAPS_DX3* LPDIDEVCAPS_DX3; 864 865 struct DIDEVCAPS { 866 DWORD dwSize; 867 DWORD dwFlags; 868 DWORD dwDevType; 869 DWORD dwAxes; 870 DWORD dwButtons; 871 DWORD dwPOVs; 872 DWORD dwFFSamplePeriod; 873 DWORD dwFFMinTimeResolution; 874 DWORD dwFirmwareRevision; 875 DWORD dwHardwareRevision; 876 DWORD dwFFDriverVersion; 877 } 878 alias DIDEVCAPS* LPDIDEVCAPS; 879 880 alias BOOL function(LPCDIDEVICEINSTANCEW, LPDIRECTINPUTDEVICE8W, DWORD, DWORD, LPVOID) LPDIENUMDEVICESBYSEMANTICSCBW; 881 alias LPDIENUMDEVICESBYSEMANTICSCB = LPDIENUMDEVICESBYSEMANTICSCBW; 882 alias LPDICONFIGUREDEVICESCALLBACK = extern(Windows) BOOL function(LPUNKNOWN, LPVOID); 883 alias LPDIENUMDEVICEOBJECTSCALLBACKW = extern(Windows) BOOL function(LPCDIDEVICEOBJECTINSTANCEW, LPVOID); 884 alias LPDIENUMDEVICEOBJECTSCALLBACK = LPDIENUMDEVICEOBJECTSCALLBACKW; 885 alias LPDIENUMEFFECTSCALLBACKW = extern(Windows) BOOL function(LPCDIEFFECTINFOW, LPVOID); 886 alias LPDIENUMDEVICESCALLBACKW = extern(Windows) BOOL function(LPCDIDEVICEINSTANCEW, LPVOID); 887 888 alias LPDIENUMCREATEDEFFECTOBJECTSCALLBACK = BOOL function(LPDIRECTINPUTEFFECT, LPVOID); 889 890 struct DIFILEEFFECT { 891 DWORD dwSize; 892 GUID GuidEffect; 893 LPCDIEFFECT lpDiEffect; 894 CHAR[MAX_PATH] szFriendlyName; 895 } 896 alias DIFILEEFFECT* LPDIFILEEFFECT; 897 898 alias const(DIFILEEFFECT)* LPCDIFILEEFFECT; 899 alias BOOL function(LPCDIFILEEFFECT, LPVOID) LPDIENUMEFFECTSINFILECALLBACK; 900 901 struct DIDEVICEOBJECTDATA { 902 DWORD dwOfs; 903 DWORD dwData; 904 DWORD dwTimeStamp; 905 DWORD dwSequence; 906 UINT_PTR uAppData; 907 } 908 alias DIDEVICEOBJECTDATA* LPDIDEVICEOBJECTDATA; 909 alias const(DIDEVICEOBJECTDATA)* LPCDIDEVICEOBJECTDATA; 910 911 struct _DIOBJECTDATAFORMAT { 912 const(GUID)* pguid; 913 DWORD dwOfs; 914 DWORD dwType; 915 DWORD dwFlags; 916 } 917 alias _DIOBJECTDATAFORMAT DIOBJECTDATAFORMAT; 918 alias _DIOBJECTDATAFORMAT* LPDIOBJECTDATAFORMAT; 919 alias const(DIOBJECTDATAFORMAT)* LPCDIOBJECTDATAFORMAT; 920 921 struct IDirectInputW ;alias IDirectInputW* LPDIRECTINPUTW; 922 /*struct IDirectInput8W*/;alias IDirectInput8W* LPDIRECTINPUT8W; 923 struct IDirectInputDeviceW ;alias IDirectInputDeviceW* LPDIRECTINPUTDEVICEW; 924 /*struct IDirectInputDevice8W*/;alias IDirectInputDevice8W* LPDIRECTINPUTDEVICE8W; 925 struct IDirectInputEffect ;alias IDirectInputEffect* LPDIRECTINPUTEFFECT; 926 927 struct _DIDEVICEIMAGEINFOW { 928 WCHAR[MAX_PATH] tszImagePath; 929 DWORD dwFlags; 930 DWORD dwViewID; 931 RECT rcOverlay; 932 DWORD dwObjID; 933 DWORD dwcValidPts; 934 POINT[5] rgptCalloutLine; 935 RECT rcCalloutRect; 936 DWORD dwTextAlign; 937 }alias _DIDEVICEIMAGEINFOW DIDEVICEIMAGEINFOW;alias _DIDEVICEIMAGEINFOW* LPDIDEVICEIMAGEINFOW; 938 alias const(DIDEVICEIMAGEINFOW)* LPCDIDEVICEIMAGEINFOW; 939 940 struct _DIDEVICEIMAGEINFOHEADERW { 941 DWORD dwSize; 942 DWORD dwSizeImageInfo; 943 DWORD dwcViews; 944 DWORD dwcButtons; 945 DWORD dwcAxes; 946 DWORD dwcPOVs; 947 DWORD dwBufferSize; 948 DWORD dwBufferUsed; 949 LPDIDEVICEIMAGEINFOW lprgImageInfoArray; 950 }alias _DIDEVICEIMAGEINFOHEADERW DIDEVICEIMAGEINFOHEADERW;alias _DIDEVICEIMAGEINFOHEADERW* LPDIDEVICEIMAGEINFOHEADERW; 951 alias const(DIDEVICEIMAGEINFOHEADERW)* LPCDIDEVICEIMAGEINFOHEADERW; 952 953 struct _DIACTIONW { 954 UINT_PTR uAppData; 955 DWORD dwSemantic; 956 DWORD dwFlags; 957 union { 958 LPCWSTR lptszActionName; 959 UINT uResIdString; 960 } 961 GUID guidInstance; 962 DWORD dwObjID; 963 DWORD dwHow; 964 } 965 alias DIACTIONW = _DIACTIONW; alias LPDIACTIONW = _DIACTIONW; 966 alias const(DIACTIONW)* LPCDIACTIONW; 967 968 struct _DIACTIONFORMATW { 969 DWORD dwSize; 970 DWORD dwActionSize; 971 DWORD dwDataSize; 972 DWORD dwNumActions; 973 LPDIACTIONW rgoAction; 974 GUID guidActionMap; 975 DWORD dwGenre; 976 DWORD dwBufferSize; 977 LONG lAxisMin; 978 LONG lAxisMax; 979 HINSTANCE hInstString; 980 FILETIME ftTimeStamp; 981 DWORD dwCRC; 982 WCHAR[MAX_PATH] tszActionMap; 983 }alias _DIACTIONFORMATW DIACTIONFORMATW;alias _DIACTIONFORMATW* LPDIACTIONFORMATW; 984 alias const(DIACTIONFORMATW)* LPCDIACTIONFORMATW; 985 986 struct IDirectInputDevice8W { 987 private alias THIS_ = typeof(this)*; 988 989 // First member of struct is Vtable 990 // https://docs.microsoft.com/en-us/windows/win32/multimedia/virtual-function-tables 991 static struct Vtable { 992 import core.sys.windows.windows; 993 pure: nothrow: @nogc: extern(Windows): 994 /*** IUnknown methods ***/ 995 HRESULT function (THIS_, REFIID riid, void** ppvObject) QueryInterface; 996 ULONG function (THIS_,) AddRef; 997 ULONG function (THIS_,) Release; 998 /*** IDirectInputDeviceW methods ***/ 999 HRESULT function (THIS_, LPDIDEVCAPS lpDIDevCaps) GetCapabilities; 1000 HRESULT function (THIS_, LPDIENUMDEVICEOBJECTSCALLBACKW lpCallback, LPVOID pvRef, DWORD dwFlags) EnumObjects; 1001 HRESULT function (THIS_, REFGUID rguidProp, LPDIPROPHEADER pdiph) GetProperty; 1002 HRESULT function (THIS_, REFGUID rguidProp, LPCDIPROPHEADER pdiph) SetProperty; 1003 HRESULT function (THIS_,) Acquire; 1004 HRESULT function (THIS_,) Unacquire; 1005 HRESULT function (THIS_, DWORD cbData, LPVOID lpvData) GetDeviceState; 1006 HRESULT function (THIS_, DWORD cbObjectData, LPDIDEVICEOBJECTDATA rgdod, LPDWORD pdwInOut, DWORD dwFlags) GetDeviceData; 1007 HRESULT function (THIS_, LPCDIDATAFORMAT lpdf) SetDataFormat; 1008 HRESULT function (THIS_, HANDLE hEvent) SetEventNotification; 1009 HRESULT function (THIS_, HWND hwnd, DWORD dwFlags) SetCooperativeLevel; 1010 HRESULT function (THIS_, LPDIDEVICEOBJECTINSTANCEW pdidoi, DWORD dwObj, DWORD dwHow) GetObjectInfo; 1011 HRESULT function (THIS_, LPDIDEVICEINSTANCEW pdidi) GetDeviceInfo; 1012 HRESULT function (THIS_, HWND hwndOwner, DWORD dwFlags) RunControlPanel; 1013 HRESULT function (THIS_, HINSTANCE hinst, DWORD dwVersion, REFGUID rguid) Initialize; 1014 /*** IDirectInputDevice2W methods ***/ 1015 HRESULT function (THIS_, REFGUID rguid, LPCDIEFFECT lpeff, LPDIRECTINPUTEFFECT *ppdeff, LPUNKNOWN punkOuter) CreateEffect; 1016 HRESULT function (THIS_, LPDIENUMEFFECTSCALLBACKW lpCallback, LPVOID pvRef, DWORD dwEffType) EnumEffects; 1017 HRESULT function (THIS_, LPDIEFFECTINFOW pdei, REFGUID rguid) GetEffectInfo; 1018 HRESULT function (THIS_, LPDWORD pdwOut) GetForceFeedbackState; 1019 HRESULT function (THIS_, DWORD dwFlags) SendForceFeedbackCommand; 1020 HRESULT function (THIS_, LPDIENUMCREATEDEFFECTOBJECTSCALLBACK lpCallback, LPVOID pvRef, DWORD fl) EnumCreatedEffectObjects; 1021 HRESULT function (THIS_, LPDIEFFESCAPE pesc) Escape; 1022 HRESULT function (THIS_,) Poll; 1023 HRESULT function (THIS_, DWORD cbObjectData, LPCDIDEVICEOBJECTDATA rgdod, LPDWORD pdwInOut, DWORD fl) SendDeviceData; 1024 /*** IDirectInputDevice7W methods ***/ 1025 HRESULT function (THIS_, LPCWSTR lpszFileName,LPDIENUMEFFECTSINFILECALLBACK pec,LPVOID pvRef,DWORD dwFlags) EnumEffectsInFile; 1026 HRESULT function (THIS_, LPCWSTR lpszFileName,DWORD dwEntries,LPDIFILEEFFECT rgDiFileEft,DWORD dwFlags) WriteEffectToFile; 1027 /*** IDirectInputDevice8W methods ***/ 1028 HRESULT function (THIS_, LPDIACTIONFORMATW lpdiaf, LPCWSTR lpszUserName, DWORD dwFlags) BuildActionMap; 1029 HRESULT function (THIS_, LPDIACTIONFORMATW lpdiaf, LPCWSTR lpszUserName, DWORD dwFlags) SetActionMap; 1030 HRESULT function (THIS_, LPDIDEVICEIMAGEINFOHEADERW lpdiDevImageInfoHeader) GetImageInfo; 1031 } 1032 Vtable* lpVtbl; 1033 } 1034 1035 /*** IUnknown methods **/ 1036 auto IDirectInputDevice8_QueryInterface(T)(T* p, REFIID riid, void** ppvObject) {return p.lpVtbl.QueryInterface(p,riid,ppvObject);} 1037 auto IDirectInputDevice8_AddRef(T)(T* p) {return p.lpVtbl.AddRef(p);} 1038 auto IDirectInputDevice8_Release(T)(T* p) {return p.lpVtbl.Release(p);} 1039 /*** IDirectInputDevice methods **/ 1040 auto IDirectInputDevice8_GetCapabilities(T)(T* p, LPDIDEVCAPS a) {return p.lpVtbl.GetCapabilities(p,a);} 1041 auto IDirectInputDevice8_EnumObjects(T)(T* p, LPDIENUMDEVICEOBJECTSCALLBACKW a,LPVOID b,DWORD c) {return p.lpVtbl.EnumObjects(p,a,b,c);} 1042 auto IDirectInputDevice8_GetProperty(T)(T* p, REFGUID a,LPDIPROPHEADER b) {return p.lpVtbl.GetProperty(p,a,b);} 1043 auto IDirectInputDevice8_SetProperty(T)(T* p, REFGUID a,LPCDIPROPHEADER b) {return p.lpVtbl.SetProperty(p,a,b);} 1044 auto IDirectInputDevice8_Acquire(T)(T* p) {return p.lpVtbl.Acquire(p);} 1045 auto IDirectInputDevice8_Unacquire(T)(T* p) {return p.lpVtbl.Unacquire(p);} 1046 auto IDirectInputDevice8_GetDeviceState(T)(T* p, DWORD a,LPVOID b) {return p.lpVtbl.GetDeviceState(p,a,b);} 1047 auto IDirectInputDevice8_GetDeviceData(T)(T* p, DWORD a, LPDIDEVICEOBJECTDATA b, LPDWORD c, DWORD d) {return p.lpVtbl.GetDeviceData(p,a,b,c,d);} 1048 auto IDirectInputDevice8_SetDataFormat(T)(T* p, LPCDIDATAFORMAT a) {return p.lpVtbl.SetDataFormat(p,a);} 1049 auto IDirectInputDevice8_SetEventNotification(T)(T* p, HANDLE a) {return p.lpVtbl.SetEventNotification(p,a);} 1050 auto IDirectInputDevice8_SetCooperativeLevel(T)(T* p, HWND a,DWORD b) {return p.lpVtbl.SetCooperativeLevel(p,a,b);} 1051 auto IDirectInputDevice8_GetObjectInfo(T)(T* p, LPDIDEVICEOBJECTINSTANCEW a,DWORD b,DWORD c) {return p.lpVtbl.GetObjectInfo(p,a,b,c);} 1052 auto IDirectInputDevice8_GetDeviceInfo(T)(T* p, LPDIDEVICEINSTANCEW a) {return p.lpVtbl.GetDeviceInfo(p,a);} 1053 auto IDirectInputDevice8_RunControlPanel(T)(T* p, HWND a,DWORD b) {return p.lpVtbl.RunControlPanel(p,a,b);} 1054 auto IDirectInputDevice8_Initialize(T)(T* p, HINSTANCE a,DWORD b,REFGUID c) {return p.lpVtbl.Initialize(p,a,b,c);} 1055 /*** IDirectInputDevice2 methods **/ 1056 auto IDirectInputDevice8_CreateEffect(T)(T* p, REFGUID a,LPCDIEFFECT b,LPDIRECTINPUTEFFECT c,LPUNKNOWN d) {return p.lpVtbl.CreateEffect(p,a,b,c,d);} 1057 auto IDirectInputDevice8_EnumEffects(T)(T* p, LPDIENUMEFFECTSCALLBACKW a,LPVOID b,DWORD c) {return p.lpVtbl.EnumEffects(p,a,b,c);} 1058 auto IDirectInputDevice8_GetEffectInfo(T)(T* p, LPDIEFFECTINFOW a,REFGUID b) {return p.lpVtbl.GetEffectInfo(p,a,b);} 1059 auto IDirectInputDevice8_GetForceFeedbackState(T)(T* p, LPDWORD a) {return p.lpVtbl.GetForceFeedbackState(p,a);} 1060 auto IDirectInputDevice8_SendForceFeedbackCommand(T)(T* p, DWORD a) {return p.lpVtbl.SendForceFeedbackCommand(p,a);} 1061 auto IDirectInputDevice8_EnumCreatedEffectObjects(T)(T* p, LPDIENUMCREATEDEFFECTOBJECTSCALLBACK a,LPVOID b,DWORD c) {return p.lpVtbl.EnumCreatedEffectObjects(p,a,b,c);} 1062 auto IDirectInputDevice8_Escape(T)(T* p, LPDIEFFESCAPE a) {return p.lpVtbl.Escape(p,a);} 1063 auto IDirectInputDevice8_Poll(T)(T* p) {return p.lpVtbl.Poll(p);} 1064 auto IDirectInputDevice8_SendDeviceData(T)(T* p, DWORD a,LPCDIDEVICEOBJECTDATA b,LPDWORD c,DWORD d) {return p.lpVtbl.SendDeviceData(p,a,b,c,d);} 1065 /*** IDirectInputDevice7 methods **/ 1066 auto IDirectInputDevice8_EnumEffectsInFile(T)(T* p, LPCWSTR lpszFileName,LPDIENUMEFFECTSINFILECALLBACK pec,LPVOID pvRef,DWORD dwFlags) {return p.lpVtbl.EnumEffectsInFile(p,lpszFileName,pec,pvRef,dwFlags);} 1067 auto IDirectInputDevice8_WriteEffectToFile(T)(T* p, LPCWSTR lpszFileName,DWORD dwEntries,LPDIFILEEFFECT rgDiFileEft,DWORD dwFlags) {return p.lpVtbl.WriteEffectToFile(p,lpszFileName,dwEntries,rgDiFileEft,dwFlags);} 1068 /*** IDirectInputDevice8 methods **/ 1069 auto IDirectInputDevice8_BuildActionMap(T)(T* p, LPDIACTIONFORMATW a,LPCWSTR b,DWORD c) {return p.lpVtbl.BuildActionMap(p,a,b,c);} 1070 auto IDirectInputDevice8_SetActionMap(T)(T* p, LPDIACTIONFORMATW a,LPCWSTR b,DWORD c) {return p.lpVtbl.SetActionMap(p,a,b,c);} 1071 auto IDirectInputDevice8_GetImageInfo(T)(T* p, LPDIDEVICEIMAGEINFOHEADERW a) {return p.lpVtbl.GetImageInfo(p,a);} 1072 1073 alias DWORD D3DCOLOR; 1074 1075 struct _DICOLORSET { 1076 DWORD dwSize; 1077 D3DCOLOR cTextFore; 1078 D3DCOLOR cTextHighlight; 1079 D3DCOLOR cCalloutLine; 1080 D3DCOLOR cCalloutHighlight; 1081 D3DCOLOR cBorder; 1082 D3DCOLOR cControlFill; 1083 D3DCOLOR cHighlightFill; 1084 D3DCOLOR cAreaFill; 1085 } 1086 alias _DICOLORSET DICOLORSET; 1087 alias _DICOLORSET* LPDICOLORSET; 1088 alias const(DICOLORSET)* LPCDICOLORSET; 1089 1090 struct _DICONFIGUREDEVICESPARAMSW { 1091 DWORD dwSize; 1092 DWORD dwcUsers; 1093 LPWSTR lptszUserNames; 1094 DWORD dwcFormats; 1095 LPDIACTIONFORMATW lprgFormats; 1096 HWND hwnd; 1097 DICOLORSET dics; 1098 LPUNKNOWN lpUnkDDSTarget; 1099 } 1100 alias _DICONFIGUREDEVICESPARAMSW DICONFIGUREDEVICESPARAMSW; 1101 alias _DICONFIGUREDEVICESPARAMSW* LPDICONFIGUREDEVICESPARAMSW; 1102 alias const(DICONFIGUREDEVICESPARAMSW)* LPCDICONFIGUREDEVICESPARAMSW; 1103 1104 struct IDirectInput8W 1105 { 1106 private alias THIS_ = typeof(this)*; 1107 // First member of struct is Vtable 1108 // https://docs.microsoft.com/en-us/windows/win32/multimedia/virtual-function-tables 1109 static struct Vtable { 1110 import core.sys.windows.windows; 1111 pure: nothrow: @nogc: extern(Windows): 1112 /*** IUnknown methods ***/ 1113 HRESULT function(THIS_, REFIID riid, void** ppvObject) QueryInterface; 1114 ULONG function(THIS_) AddRef; 1115 ULONG function(THIS_) Release; 1116 /*** IDirectInput8W methods ***/ 1117 HRESULT function(THIS_, REFGUID rguid, LPDIRECTINPUTDEVICE8W* lplpDirectInputDevice, LPUNKNOWN pUnkOuter) CreateDevice; 1118 HRESULT function(THIS_, DWORD dwDevType, LPDIENUMDEVICESCALLBACKW lpCallback, LPVOID pvRef, DWORD dwFlags) EnumDevices; 1119 HRESULT function(THIS_, REFGUID rguidInstance) GetDeviceStatus; 1120 HRESULT function(THIS_, HWND hwndOwner, DWORD dwFlags) RunControlPanel; 1121 HRESULT function(THIS_, HINSTANCE hinst, DWORD dwVersion) Initialize; 1122 HRESULT function(THIS_, REFGUID rguid, LPCWSTR pszName, LPGUID pguidInstance) FindDevice; 1123 HRESULT function(THIS_, LPCWSTR ptszUserName, LPDIACTIONFORMATW lpdiActionFormat, LPDIENUMDEVICESBYSEMANTICSCBW lpCallback, LPVOID pvRef, DWORD dwFlags) EnumDevicesBySemantics; 1124 HRESULT function(THIS_, LPDICONFIGUREDEVICESCALLBACK, LPDICONFIGUREDEVICESPARAMSW lpdiCDParams, DWORD dwFlags, LPVOID pvRefData) ConfigureDevices; 1125 } 1126 Vtable* lpVtble; 1127 } 1128 1129 /*** IUnknown methods ***/ 1130 auto IDirectInput8_QueryInterface(T)(T* p,REFIID a,void** b) {return p.lpVtble.QueryInterface(p,a,b);} 1131 auto IDirectInput8_AddRef(T)(T* p) {return p.lpVtble.AddRef(p);} 1132 auto IDirectInput8_Release(T)(T* p) {return p.lpVtble.Release(p);} 1133 /*** IDirectInput8 methods ***/ 1134 auto IDirectInput8_CreateDevice(T)(T* p,REFGUID a,LPDIRECTINPUTDEVICE8W* b,LPUNKNOWN c) {return p.lpVtble.CreateDevice(p,a,b,c);} 1135 auto IDirectInput8_EnumDevices(T)(T* p,DWORD a,LPDIENUMDEVICESCALLBACKW b,LPVOID c,DWORD d) {return p.lpVtble.EnumDevices(p,a,b,c,d);} 1136 auto IDirectInput8_GetDeviceStatus(T)(T* p,REFGUID a) {return p.lpVtble.GetDeviceStatus(p,a);} 1137 auto IDirectInput8_RunControlPanel(T)(T* p,HWND a,DWORD b) {return p.lpVtble.RunControlPanel(p,a,b);} 1138 auto IDirectInput8_Initialize(T)(T* p,HINSTANCE a,DWORD b) {return p.lpVtble.Initialize(p,a,b);} 1139 auto IDirectInput8_FindDevice(T)(T* p,REFGUID a,LPCWSTR b,LPGUID c) {return p.lpVtble.FindDevice(p,a,b,c);} 1140 auto IDirectInput8_EnumDevicesBySemantics(T)(T* p,LPCWSTR a,LPDIACTIONFORMATW b,LPDIENUMDEVICESBYSEMANTICSCBW c,LPVOID d,DWORD e) {return p.lpVtble.EnumDevicesBySemantics(p,a,b,c,d,e);} 1141 auto IDirectInput8_ConfigureDevices(T)(T* p,LPDICONFIGUREDEVICESCALLBACK a,LPDICONFIGUREDEVICESPARAMSW b,DWORD c,LPVOID d) {return p.lpVtble.ConfigureDevices(p,a,b,c,d);}