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