From 218ca90543758a20ac326e444ca0643174ca7384 Mon Sep 17 00:00:00 2001 From: Rebellion Developments Date: Thu, 16 Mar 2000 11:25:00 +0100 Subject: Import Aliens vs Predator - Gold (Build 116) Source code release, imported from: https://www.gamefront.com/games/aliens-vs-predator-3/file/avp-gold-complete-source-code All text files were converted to Unix format. --- 3dc/win95/Di_func.cpp | 1344 +++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 1344 insertions(+) create mode 100644 3dc/win95/Di_func.cpp (limited to '3dc/win95/Di_func.cpp') diff --git a/3dc/win95/Di_func.cpp b/3dc/win95/Di_func.cpp new file mode 100644 index 0000000..c29b4c1 --- /dev/null +++ b/3dc/win95/Di_func.cpp @@ -0,0 +1,1344 @@ +// Interface functions (written in C++) for +// Direct3D immediate mode system + +// Must link to C code in main engine system + +extern "C" { + +// Note: INITGUID has NOT been defined here, +// since the definition in d3_func.cpp is amply +// sufficient. + +#include "3dc.h" +#include "module.h" +#include "inline.h" +#include "stratdef.h" +#include "gamedef.h" +#include "gameplat.h" +#include "usr_io.h" +extern "C++"{ +#include "iofocus.h" +}; + +#include "showcmds.h" + +// DirectInput key down value +#define DikOn 0x80 + +// Internal DirectInput driver +// buffer Size for direct mouse read +#define DMouse_BufferSize 128 + +// Maximum number of buffered events retrievable +// from a mouse data acquisition +#define DMouse_RetrieveSize 128 + +/* + These are (hopefully) temporary #defines, + introduced as a hack because the curious + FIELD_OFFSET macros in the dinput.h header + don't appear to compile, at least in Watcom 10.6. + They will obviously have to be kept up to date + with changes in the DIMOUSESTATE structure manually. +*/ + +#define DIMouseXOffset 0 + +#define DIMouseYOffset 4 +#define DIMouseZOffset 8 + +#define DIMouseButton0Offset 12 + +#define DIMouseButton1Offset 13 + +#define DIMouseButton2Offset 14 + +#define DIMouseButton3Offset 15 + + +/* + Globals +*/ + + +static LPDIRECTINPUT lpdi; // DirectInput interface +static LPDIRECTINPUTDEVICE lpdiKeyboard; // keyboard device interface +static LPDIRECTINPUTDEVICE lpdiMouse; // mouse device interface +static BOOL DIKeyboardOkay; // Is the keyboard acquired? + +static IDirectInputDevice* g_pJoystick = NULL; +static IDirectInputDevice2* g_pJoystickDevice2 = NULL; // needed to poll joystick + + static char bGravePressed = No; + // added 14/1/98 by DHM as a temporary hack to debounce the GRAVE key + +/* + Externs for input communication +*/ + +extern HINSTANCE hInst; +extern HWND hWndMain; + +int GotMouse; +unsigned int MouseButton; +int MouseVelX; +int MouseVelY; +int MouseVelZ; +int MouseX; +int MouseY; +int MouseZ; + +extern unsigned char KeyboardInput[]; +extern unsigned char GotAnyKey; +static unsigned char LastGotAnyKey; +unsigned char DebouncedGotAnyKey; + +int GotJoystick; +JOYCAPS JoystickCaps; +JOYINFOEX JoystickData; +int JoystickEnabled; + +DIJOYSTATE JoystickState; // DirectInput joystick state + + +/* + 8/4/98 DHM: A new array, analagous to KeyboardInput, except it's debounced +*/ +extern "C" +{ + unsigned char DebouncedKeyboardInput[MAX_NUMBER_OF_INPUT_KEYS]; +} + +// Implementation of the debounced KeyboardInput +// There's probably a more efficient way of getting it direct from DirectInput +// but it's getting late and I can't face reading any more Microsoft documentation... +static unsigned char LastFramesKeyboardInput[MAX_NUMBER_OF_INPUT_KEYS]; + + +extern int NormalFrameTime; + +static char IngameKeyboardInput[256]; +extern IngameKeyboardInput_KeyDown(unsigned char key); +extern IngameKeyboardInput_KeyUp(unsigned char key); +extern IngameKeyboardInput_ClearBuffer(void); + +/* + + Create DirectInput via CoCreateInstance + +*/ + + +BOOL InitialiseDirectInput(void) + +{ + // try to create di object + if (DirectInputCreate(hInst, DIRECTINPUT_VERSION, &lpdi, NULL) != DI_OK) + { + #if debug + ReleaseDirect3D(); + exit(0x4111); + #else + return FALSE; + #endif + } + + return TRUE; +} + +/* + + Release DirectInput object + +*/ + + +void ReleaseDirectInput(void) + +{ + if (lpdi!= NULL) + { + lpdi->Release(); + lpdi = NULL; + } +} + + + + +// see comments below + +#define UseForegroundKeyboard No + +GUID guid = GUID_SysKeyboard; +BOOL InitialiseDirectKeyboard() + +{ + HRESULT hRes; + + // try to create keyboard device + if (lpdi->CreateDevice(guid, &lpdiKeyboard, NULL) !=DI_OK) + { + #if debug + ReleaseDirect3D(); + exit(0x4112); + #else + return FALSE; + #endif + } + + // Tell DirectInput that we want to receive data in keyboard format + if (lpdiKeyboard->SetDataFormat(&c_dfDIKeyboard) != DI_OK) + { + #if debug + ReleaseDirect3D(); + exit(0x4113); + #else + return FALSE; + #endif + } + + // set cooperative level + // this level is the most likely to work across + // multiple hardware targets + // (i.e. this is probably best for a production + // release) + #if UseForegroundKeyboard + if (lpdiKeyboard->SetCooperativeLevel(hWndMain, + DISCL_NONEXCLUSIVE | DISCL_FOREGROUND) != DI_OK) + #else + // this level makes alt-tabbing multiple instances in + // SunWindow mode possible without receiving lots + // of false inputs + if (lpdiKeyboard->SetCooperativeLevel(hWndMain, + DISCL_NONEXCLUSIVE | DISCL_BACKGROUND) != DI_OK) + #endif + { + #if debug + ReleaseDirect3D(); + exit(0x4114); + #else + return FALSE; + #endif + } + + // try to acquire the keyboard + hRes = lpdiKeyboard->Acquire(); + if (hRes == DI_OK) + { + // keyboard was acquired + DIKeyboardOkay = TRUE; + } + else + { + // keyboard was NOT acquired + DIKeyboardOkay = FALSE; + } + + // if we get here, all objects were created successfully + return TRUE; +} + + + +/* + + Use DirectInput to read keyboard + + PS: I know this function involves an + apparently unnecessary layer of translation + between one keyboard array and another one. + This is to allow people to swap from a windows + procedure keyboard handler to a DirectInput one + without having to change their IDemand functions. + + I can't think of a faster way to do the translation + below, but given that it only runs once per frame + it shouldn't be too bad. BUT NOTE THAT IT DOES + ONLY RUN ONCE PER FRAME (FROM READUSERINPUT) AND + SO YOU MUST HAVE A DECENT FRAME RATE IF KEYS ARE NOT + TO BE MISSED. + + NOTE ALSO THAT IF YOU ARE USING THIS SYSTEM YOU CAN + ACCESS THE KEYBOARD ARRAY IN A TIGHT LOOP WHILE CALLING + READUSERINPUT BUT -->NOT<-- CHECKWINDOWSMESSAGES (AS REQUIRED + FOR THE WINPROC HANDLER). BUT CHECKFORWINDOWSMESSAGES WON'T DO + ANY HARM. +*/ + +void DirectReadKeyboard(void) +{ + // Local array for map of all 256 characters on + // keyboard + BYTE DiKeybd[256]; + HRESULT hRes; + + // Get keyboard state + hRes = lpdiKeyboard->GetDeviceState(sizeof(DiKeybd), DiKeybd); + if (hRes != DI_OK) + { + if (hRes == DIERR_INPUTLOST) + { + // keyboard control lost; try to reacquire + DIKeyboardOkay = FALSE; + hRes = lpdiKeyboard->Acquire(); + if (hRes == DI_OK) + DIKeyboardOkay = TRUE; + } + } + + // Check for error values on routine exit + if (hRes != DI_OK) + { + // failed to read the keyboard + #if debug + ReleaseDirect3D(); + exit(0x999774); + #else + return; + #endif + } + + // Take a copy of last frame's inputs: + memcpy((void*)LastFramesKeyboardInput, (void*)KeyboardInput, MAX_NUMBER_OF_INPUT_KEYS); + LastGotAnyKey=GotAnyKey; + + // Zero current inputs (i.e. set all keys to FALSE, + // or not pressed) + memset((void*)KeyboardInput, FALSE, MAX_NUMBER_OF_INPUT_KEYS); + GotAnyKey = FALSE; + + #if 1 + { + int c; + + for (c='a'; c<='z'; c++) + { + if (IngameKeyboardInput[c]) + { + KeyboardInput[KEY_A + c - 'a'] = TRUE; + GotAnyKey = TRUE; + } + } + if (IngameKeyboardInput[246]) + { + KeyboardInput[KEY_O_UMLAUT] = TRUE; + GotAnyKey = TRUE; + } + if (IngameKeyboardInput[228]) + { + KeyboardInput[KEY_A_UMLAUT] = TRUE; + GotAnyKey = TRUE; + } + if (IngameKeyboardInput[252]) + { + KeyboardInput[KEY_U_UMLAUT] = TRUE; + GotAnyKey = TRUE; + } + if (IngameKeyboardInput[223]) + { + KeyboardInput[KEY_BETA] = TRUE; + GotAnyKey = TRUE; + } + if (IngameKeyboardInput['+']) + { + KeyboardInput[KEY_PLUS] = TRUE; + GotAnyKey = TRUE; + } + if (IngameKeyboardInput['#']) + { + KeyboardInput[KEY_HASH] = TRUE; + GotAnyKey = TRUE; + } + if (IngameKeyboardInput[161]) + { + KeyboardInput[KEY_UPSIDEDOWNEXCLAMATION] = TRUE; + GotAnyKey = TRUE; + } + if (IngameKeyboardInput[231]) + { + KeyboardInput[KEY_C_CEDILLA] = TRUE; + GotAnyKey = TRUE; + } + if (IngameKeyboardInput[241]) + { + KeyboardInput[KEY_N_TILDE] = TRUE; + GotAnyKey = TRUE; + } + if (IngameKeyboardInput[')']) + { + KeyboardInput[KEY_RIGHTBRACKET] = TRUE; + GotAnyKey = TRUE; + } + if (IngameKeyboardInput['*']) + { + KeyboardInput[KEY_ASTERISK] = TRUE; + GotAnyKey = TRUE; + } + if (IngameKeyboardInput['$']) + { + KeyboardInput[KEY_DOLLAR] = TRUE; + GotAnyKey = TRUE; + } + if (IngameKeyboardInput[249]) + { + KeyboardInput[KEY_U_GRAVE] = TRUE; + GotAnyKey = TRUE; + } + if (IngameKeyboardInput['!']) + { + KeyboardInput[KEY_EXCLAMATION] = TRUE; + GotAnyKey = TRUE; + } + if (IngameKeyboardInput[':']) + { + KeyboardInput[KEY_COLON] = TRUE; + GotAnyKey = TRUE; + } + if (IngameKeyboardInput[96]) + { + KeyboardInput[KEY_DIACRITIC_GRAVE] = TRUE; + GotAnyKey = TRUE; + } + if (IngameKeyboardInput[180]) + { + KeyboardInput[KEY_DIACRITIC_ACUTE] = TRUE; + GotAnyKey = TRUE; + } + if (IngameKeyboardInput[94]) + { + KeyboardInput[KEY_DIACRITIC_CARET] = TRUE; + GotAnyKey = TRUE; + } + if (IngameKeyboardInput[168]) + { + KeyboardInput[KEY_DIACRITIC_UMLAUT] = TRUE; + GotAnyKey = TRUE; + } + if (IngameKeyboardInput['<']) + { + KeyboardInput[KEY_LESSTHAN] = TRUE; + GotAnyKey = TRUE; + } + if (IngameKeyboardInput[176]) + { + KeyboardInput[KEY_ORDINAL] = TRUE; + GotAnyKey = TRUE; + } + + + if (IngameKeyboardInput['[']) + { + KeyboardInput[KEY_LBRACKET] = TRUE; + GotAnyKey = TRUE; + } + if (IngameKeyboardInput[']']) + { + KeyboardInput[KEY_RBRACKET] = TRUE; + GotAnyKey = TRUE; + } + if (IngameKeyboardInput[';']) + { + KeyboardInput[KEY_SEMICOLON] = TRUE; + GotAnyKey = TRUE; + } + if (IngameKeyboardInput['\'']) + { + KeyboardInput[KEY_APOSTROPHE] = TRUE; + GotAnyKey = TRUE; + } + if (IngameKeyboardInput['\\']) + { + KeyboardInput[KEY_BACKSLASH] = TRUE; + GotAnyKey = TRUE; + } + if (IngameKeyboardInput['/']) + { + KeyboardInput[KEY_SLASH] = TRUE; + GotAnyKey = TRUE; + } + if (IngameKeyboardInput['-']) + { + KeyboardInput[KEY_MINUS] = TRUE; + GotAnyKey = TRUE; + } + if (IngameKeyboardInput['=']) + { + KeyboardInput[KEY_EQUALS] = TRUE; + GotAnyKey = TRUE; + } + if (IngameKeyboardInput[',']) + { + KeyboardInput[KEY_COMMA] = TRUE; + GotAnyKey = TRUE; + } + if (IngameKeyboardInput['.']) + { + KeyboardInput[KEY_FSTOP] = TRUE; + GotAnyKey = TRUE; + } + + } + + #endif + + // Check and set keyboard array + // (test checks only for the moment) + if (DiKeybd[DIK_LEFT] & DikOn) + { + KeyboardInput[KEY_LEFT] = TRUE; + GotAnyKey = TRUE; + } + + if (DiKeybd[DIK_RIGHT] & DikOn) + { + KeyboardInput[KEY_RIGHT] = TRUE; + GotAnyKey = TRUE; + } + + if (DiKeybd[DIK_UP] & DikOn) + { + KeyboardInput[KEY_UP] = TRUE; + GotAnyKey = TRUE; + } + + if (DiKeybd[DIK_DOWN] & DikOn) + { + KeyboardInput[KEY_DOWN] = TRUE; + GotAnyKey = TRUE; + } + + if (DiKeybd[DIK_ESCAPE] & DikOn) + { + KeyboardInput[KEY_ESCAPE] = TRUE; + GotAnyKey = TRUE; + } + + if (DiKeybd[DIK_RETURN] & DikOn) + { + KeyboardInput[KEY_CR] = TRUE; + GotAnyKey = TRUE; + } + + if (DiKeybd[DIK_TAB] & DikOn) + { + KeyboardInput[KEY_TAB] = TRUE; + GotAnyKey = TRUE; + } + + if (DiKeybd[DIK_F1] & DikOn) + { + KeyboardInput[KEY_F1] = TRUE; + GotAnyKey = TRUE; + } + + if (DiKeybd[DIK_F2] & DikOn) + { + KeyboardInput[KEY_F2] = TRUE; + GotAnyKey = TRUE; + } + + if (DiKeybd[DIK_F3] & DikOn) + { + KeyboardInput[KEY_F3] = TRUE; + GotAnyKey = TRUE; + } + + if (DiKeybd[DIK_F4] & DikOn) + { + KeyboardInput[KEY_F4] = TRUE; + GotAnyKey = TRUE; + } + + if (DiKeybd[DIK_F5] & DikOn) + { + KeyboardInput[KEY_F5] = TRUE; + GotAnyKey = TRUE; + } + + if (DiKeybd[DIK_F6] & DikOn) + { + KeyboardInput[KEY_F6] = TRUE; + GotAnyKey = TRUE; + } + + if (DiKeybd[DIK_F7] & DikOn) + { + KeyboardInput[KEY_F7] = TRUE; + GotAnyKey = TRUE; + } + + if (DiKeybd[DIK_F8] & DikOn) + { + KeyboardInput[KEY_F8] = TRUE; +/* KJL 14:51:38 21/04/98 - F8 does screen shots, and so this is a hack +to make F8 not count in a 'press any key' situation */ +// GotAnyKey = TRUE; + } + + if (DiKeybd[DIK_F9] & DikOn) + { + KeyboardInput[KEY_F9] = TRUE; + GotAnyKey = TRUE; + } + + if (DiKeybd[DIK_F10] & DikOn) + { + KeyboardInput[KEY_F10] = TRUE; + GotAnyKey = TRUE; + } + + if (DiKeybd[DIK_F11] & DikOn) + { + KeyboardInput[KEY_F11] = TRUE; + GotAnyKey = TRUE; + } + + if (DiKeybd[DIK_F12] & DikOn) + { + KeyboardInput[KEY_F12] = TRUE; + GotAnyKey = TRUE; + } + + if (DiKeybd[DIK_INSERT] & DikOn) + { + KeyboardInput[KEY_INS] = TRUE; + GotAnyKey = TRUE; + } + + if (DiKeybd[DIK_DELETE] & DikOn) + { + KeyboardInput[KEY_DEL] = TRUE; + GotAnyKey = TRUE; + } + + if (DiKeybd[DIK_END] & DikOn) + { + KeyboardInput[KEY_END] = TRUE; + GotAnyKey = TRUE; + } + + if (DiKeybd[DIK_HOME] & DikOn) + { + KeyboardInput[KEY_HOME] = TRUE; + GotAnyKey = TRUE; + } + + if (DiKeybd[DIK_PRIOR] & DikOn) + { + KeyboardInput[KEY_PAGEUP] = TRUE; + GotAnyKey = TRUE; + } + + if (DiKeybd[DIK_NEXT] & DikOn) + { + KeyboardInput[KEY_PAGEDOWN] = TRUE; + GotAnyKey = TRUE; + } + + if (DiKeybd[DIK_BACK] & DikOn) + { + KeyboardInput[KEY_BACKSPACE] = TRUE; + GotAnyKey = TRUE; + } + + if (DiKeybd[DIK_SPACE] & DikOn) + { + KeyboardInput[KEY_SPACE] = TRUE; + GotAnyKey = TRUE; + } + + if (DiKeybd[DIK_LSHIFT] & DikOn) + { + KeyboardInput[KEY_LEFTSHIFT] = TRUE; + GotAnyKey = TRUE; + } + + if (DiKeybd[DIK_RSHIFT] & DikOn) + { + KeyboardInput[KEY_RIGHTSHIFT] = TRUE; + GotAnyKey = TRUE; + } + + if (DiKeybd[DIK_LCONTROL] & DikOn) + { + KeyboardInput[KEY_LEFTCTRL] = TRUE; + GotAnyKey = TRUE; + } + + if (DiKeybd[DIK_RCONTROL] & DikOn) + { + KeyboardInput[KEY_RIGHTCTRL] = TRUE; + GotAnyKey = TRUE; + } + + if (DiKeybd[DIK_CAPSLOCK] & DikOn) + { + KeyboardInput[KEY_CAPS] = TRUE; + GotAnyKey = TRUE; + } + + if (DiKeybd[DIK_NUMLOCK] & DikOn) + { + KeyboardInput[KEY_NUMLOCK] = TRUE; + GotAnyKey = TRUE; + } + + if (DiKeybd[DIK_SCROLL] & DikOn) + { + KeyboardInput[KEY_SCROLLOK] = TRUE; + GotAnyKey = TRUE; + } + + if (DiKeybd[DIK_LMENU] & DikOn) + { + KeyboardInput[KEY_LEFTALT] = TRUE; + GotAnyKey = TRUE; + } + + if (DiKeybd[DIK_RMENU] & DikOn) + { + KeyboardInput[KEY_RIGHTALT] = TRUE; + GotAnyKey = TRUE; + } + + if (DiKeybd[DIK_0] & DikOn) + { + KeyboardInput[KEY_0] = TRUE; + GotAnyKey = TRUE; + } + + if (DiKeybd[DIK_1] & DikOn) + { + KeyboardInput[KEY_1] = TRUE; + GotAnyKey = TRUE; + } + + if (DiKeybd[DIK_2] & DikOn) + { + KeyboardInput[KEY_2] = TRUE; + GotAnyKey = TRUE; + } + + if (DiKeybd[DIK_3] & DikOn) + { + KeyboardInput[KEY_3] = TRUE; + GotAnyKey = TRUE; + } + + if (DiKeybd[DIK_4] & DikOn) + { + KeyboardInput[KEY_4] = TRUE; + GotAnyKey = TRUE; + } + + if (DiKeybd[DIK_5] & DikOn) + { + KeyboardInput[KEY_5] = TRUE; + GotAnyKey = TRUE; + } + + if (DiKeybd[DIK_6] & DikOn) + { + KeyboardInput[KEY_6] = TRUE; + GotAnyKey = TRUE; + } + + if (DiKeybd[DIK_7] & DikOn) + { + KeyboardInput[KEY_7] = TRUE; + GotAnyKey = TRUE; + } + + if (DiKeybd[DIK_8] & DikOn) + { + KeyboardInput[KEY_8] = TRUE; + GotAnyKey = TRUE; + } + + if (DiKeybd[DIK_9] & DikOn) + { + KeyboardInput[KEY_9] = TRUE; + GotAnyKey = TRUE; + } + + + /* KJL 16:12:19 05/11/97 - numeric pad follows */ + if (DiKeybd[DIK_NUMPAD7] & DikOn) + { + KeyboardInput[KEY_NUMPAD7] = TRUE; + GotAnyKey = TRUE; + } + if (DiKeybd[DIK_NUMPAD8] & DikOn) + { + KeyboardInput[KEY_NUMPAD8] = TRUE; + GotAnyKey = TRUE; + } + if (DiKeybd[DIK_NUMPAD9] & DikOn) + { + KeyboardInput[KEY_NUMPAD9] = TRUE; + GotAnyKey = TRUE; + } + if (DiKeybd[DIK_SUBTRACT] & DikOn) + { + KeyboardInput[KEY_NUMPADSUB] = TRUE; + GotAnyKey = TRUE; + } + if (DiKeybd[DIK_NUMPAD4] & DikOn) + { + KeyboardInput[KEY_NUMPAD4] = TRUE; + GotAnyKey = TRUE; + } + if (DiKeybd[DIK_NUMPAD5] & DikOn) + { + KeyboardInput[KEY_NUMPAD5] = TRUE; + GotAnyKey = TRUE; + } + if (DiKeybd[DIK_NUMPAD6] & DikOn) + { + KeyboardInput[KEY_NUMPAD6] = TRUE; + GotAnyKey = TRUE; + } + if (DiKeybd[DIK_ADD] & DikOn) + { + KeyboardInput[KEY_NUMPADADD] = TRUE; + GotAnyKey = TRUE; + } + if (DiKeybd[DIK_NUMPAD1] & DikOn) + { + KeyboardInput[KEY_NUMPAD1] = TRUE; + GotAnyKey = TRUE; + } + if (DiKeybd[DIK_NUMPAD2] & DikOn) + { + KeyboardInput[KEY_NUMPAD2] = TRUE; + GotAnyKey = TRUE; + } + if (DiKeybd[DIK_NUMPAD3] & DikOn) + { + KeyboardInput[KEY_NUMPAD3] = TRUE; + GotAnyKey = TRUE; + } + if (DiKeybd[DIK_NUMPAD0] & DikOn) + { + KeyboardInput[KEY_NUMPAD0] = TRUE; + GotAnyKey = TRUE; + } + if (DiKeybd[DIK_DECIMAL] & DikOn) + { + KeyboardInput[KEY_NUMPADDEL] = TRUE; + GotAnyKey = TRUE; + } + if (DiKeybd[DIK_NUMPADENTER] & DikOn) + { + KeyboardInput[KEY_NUMPADENTER] = TRUE; + GotAnyKey = TRUE; + } + if (DiKeybd[DIK_DIVIDE] & DikOn) + { + KeyboardInput[KEY_NUMPADDIVIDE] = TRUE; + GotAnyKey = TRUE; + } + if (DiKeybd[DIK_MULTIPLY] & DikOn) + { + KeyboardInput[KEY_NUMPADMULTIPLY] = TRUE; + GotAnyKey = TRUE; + } + if (DiKeybd[DIK_CAPITAL] & DikOn) + { + KeyboardInput[KEY_CAPITAL] = TRUE; + GotAnyKey = TRUE; + } + if (DiKeybd[DIK_LWIN] & DikOn) + { + KeyboardInput[KEY_LWIN] = TRUE; + GotAnyKey = TRUE; + } + if (DiKeybd[DIK_RWIN] & DikOn) + { + KeyboardInput[KEY_RWIN] = TRUE; + GotAnyKey = TRUE; + } + if (DiKeybd[DIK_APPS] & DikOn) + { + KeyboardInput[KEY_APPS] = TRUE; + GotAnyKey = TRUE; + } + + + #if 0 + // Added 14/1/98 by DHM: Process the grave key (known to some as the tilde key) + // Done this way as a bit of a hack to avoid touching PLATFORM.H + // which would force big recompiles + if (DiKeybd[DIK_GRAVE] & DikOn) + { + if ( !bGravePressed ) + { + IOFOCUS_Toggle(); + } + + bGravePressed = Yes; + + GotAnyKey = TRUE; + } + else + { + bGravePressed = No; + } + #else + if (DiKeybd[DIK_GRAVE] & DikOn) + { + KeyboardInput[KEY_GRAVE] = TRUE; + } + #endif + + /* mouse keys */ + if (MouseButton & LeftButton) + { + KeyboardInput[KEY_LMOUSE] = TRUE; + GotAnyKey = TRUE; + } + if (MouseButton & MiddleButton) + { + KeyboardInput[KEY_MMOUSE] = TRUE; + GotAnyKey = TRUE; + } + if (MouseButton & RightButton) + { + KeyboardInput[KEY_RMOUSE] = TRUE; + GotAnyKey = TRUE; + } + + /* mouse wheel - read using windows messages */ + { + extern signed int MouseWheelStatus; + if (MouseWheelStatus>0) + { + KeyboardInput[KEY_MOUSEWHEELUP] = TRUE; + GotAnyKey = TRUE; + } + else if (MouseWheelStatus<0) + { + KeyboardInput[KEY_MOUSEWHEELDOWN] = TRUE; + GotAnyKey = TRUE; + } + } + + + /* joystick buttons */ + if (GotJoystick) + { + unsigned int n,bit; + + for (n=0,bit=1; n<16; n++,bit*=2) + { + if(JoystickData.dwButtons&bit) + { + KeyboardInput[KEY_JOYSTICK_BUTTON_1+n]=TRUE; + GotAnyKey = TRUE; + } + } + + } + + + /* update debounced keys array */ + { + for (int i=0;iUnacquire(); + DIKeyboardOkay = FALSE; + } + + if (lpdiKeyboard != NULL) + { + lpdiKeyboard->Release(); + lpdiKeyboard = NULL; + } +} + + +BOOL InitialiseDirectMouse() + +{ + GUID guid = GUID_SysMouse; + HRESULT hres; + + //MouseButton = 0; + + // Obtain an interface to the system mouse device. + hres = lpdi->CreateDevice(guid, &lpdiMouse, NULL); + if (hres != DI_OK) return FALSE; + + // Set the data format to "mouse format". + hres = lpdiMouse->SetDataFormat(&c_dfDIMouse); + if (hres != DI_OK) return FALSE; + + // Set the cooperativity level. + + #if debug + // This level should allow the debugger to actually work + // not to mention drop 'n' drag in sub-window mode + hres = lpdiMouse->SetCooperativeLevel(hWndMain, + DISCL_NONEXCLUSIVE | DISCL_FOREGROUND); + #else + // this level is the most likely to work across + // multiple mouse drivers + hres = lpdiMouse->SetCooperativeLevel(hWndMain, + DISCL_EXCLUSIVE | DISCL_FOREGROUND); + #endif + if (hres != DI_OK) return FALSE; + + // Set the buffer size for reading the mouse to + // DMouse_BufferSize elements + // mouse-type should be relative by default, so there + // is no need to change axis mode. + DIPROPDWORD dipdw = + { + { + sizeof(DIPROPDWORD), // diph.dwSize + sizeof(DIPROPHEADER), // diph.dwHeaderSize + 0, // diph.dwObj + DIPH_DEVICE, // diph.dwHow + }, + DMouse_BufferSize, // dwData + }; + + hres = lpdiMouse->SetProperty(DIPROP_BUFFERSIZE, &dipdw.diph); + + if (hres != DI_OK) return FALSE; + + // try to acquire the mouse + hres = lpdiMouse->Acquire(); + + return TRUE; +} + +void DirectReadMouse(void) +{ + DIDEVICEOBJECTDATA od[DMouse_RetrieveSize]; + DWORD dwElements = DMouse_RetrieveSize; + HRESULT hres; + int OldMouseX, OldMouseY, OldMouseZ; + + GotMouse = No; + MouseVelX = 0; + MouseVelY = 0; + MouseVelZ = 0; + + hres = lpdiMouse->GetDeviceData(sizeof(DIDEVICEOBJECTDATA),&od[0],&dwElements, 0); + + + if (hres == DIERR_INPUTLOST || hres==DIERR_NOTACQUIRED) + { + // We had acquisition, but lost it. Try to reacquire it. + hres = lpdiMouse->Acquire(); + // No data this time + return; + } + + // Unable to read data + if (hres != DI_OK) return; + + // Check for any data being picked up + GotMouse = Yes; + if (dwElements == 0) return; + + // Save mouse x and y for velocity determination + OldMouseX = MouseX; + OldMouseY = MouseY; + OldMouseZ = MouseZ; + + // Process all recovered elements and + // make appropriate modifications to mouse + // status variables. + + int i; + + for (i=0; iRelease(); + lpdiMouse = NULL; + } +} + + + +/*KJL**************************************************************** +* * +* JOYSTICK SUPPORT - I've moved all joystick support to here. * +* * +****************************************************************KJL*/ + + +/* KJL 11:32:46 04/30/97 - + + Okay, this has been changed for the sake of AvP. I know that this + isn't in AvP\win95\..., but moving this file probably isn't worth + the trouble. + + This code is designed to read only one joystick. + +*/ + + +/* + Decide which (if any) joysticks + exist, access capabilities, + initialise internal variables. +*/ +#if 1 +void InitJoysticks(void) +{ + JoystickData.dwFlags = (JOY_RETURNALL | JOY_RETURNCENTERED | JOY_USEDEADZONE); + JoystickData.dwSize = sizeof(JoystickData); + + GotJoystick = CheckForJoystick(); +} + +void ReadJoysticks(void) +{ + GotJoystick = ReadJoystick(); +} + +int ReadJoystick(void) +{ + MMRESULT joyreturn; + + if(!JoystickControlMethods.JoystickEnabled) return No; + + joyreturn = joyGetPosEx(JOYSTICKID1,&JoystickData); + + if (joyreturn == JOYERR_NOERROR) return Yes; + + return No; +} + +int CheckForJoystick(void) +{ + MMRESULT joyreturn; + + joyreturn = joyGetDevCaps(JOYSTICKID1, + &JoystickCaps, + sizeof(JOYCAPS)); + + if (joyreturn == JOYERR_NOERROR) return Yes; + + return No; +} +#else +// Eleventh hour rewrite of joystick code, to support PantherXL trackerball. +// Typical. KJL, 99/5/1 +BOOL CALLBACK EnumJoysticksCallback( LPCDIDEVICEINSTANCE pInst, LPVOID lpvContext ); + + +void InitJoysticks(void) +{ + HRESULT hr; + GotJoystick = No; + g_pJoystick = NULL; + + hr = lpdi->EnumDevices(DIDEVTYPE_JOYSTICK, EnumJoysticksCallback, NULL, DIEDFL_ATTACHEDONLY); + if ( FAILED(hr) ) return; + + hr = g_pJoystick->SetDataFormat( &c_dfDIJoystick ); + if ( FAILED(hr) ) return; + + hr = g_pJoystick->SetCooperativeLevel( hWndMain, DISCL_EXCLUSIVE | DISCL_FOREGROUND); + if ( FAILED(hr) ) return; + + GotJoystick = Yes; +} + +void ReadJoysticks(void) +{ + + GotJoystick = No; + + if(!JoystickControlMethods.JoystickEnabled || g_pJoystick==NULL) + { + return; + } + + HRESULT hr = DIERR_INPUTLOST; + + // if input is lost then acquire and keep trying + while ( DIERR_INPUTLOST == hr ) + { + // poll the joystick to read the current state + hr = g_pJoystickDevice2->Poll(); + if ( FAILED(hr) ) return; + + // get the input's device state, and put the state in dims + hr = g_pJoystick->GetDeviceState( sizeof(DIJOYSTATE), &JoystickState ); + + if ( hr == DIERR_INPUTLOST ) + { + // DirectInput is telling us that the input stream has + // been interrupted. We aren't tracking any state + // between polls, so we don't have any special reset + // that needs to be done. We just re-acquire and + // try again. + hr = g_pJoystick->Acquire(); + if ( FAILED(hr) ) return; + } + } + + if ( FAILED(hr) ) return; + + GotJoystick = Yes; + PrintDebuggingText("%d %d\n",JoystickState.rglSlider[0],JoystickState.rglSlider[1]); + +} +//----------------------------------------------------------------------------- +// Function: EnumJoysticksCallback +// +// Description: +// Called once for each enumerated joystick. If we find one, +// create a device interface on it so we can play with it. +// +//----------------------------------------------------------------------------- +BOOL CALLBACK EnumJoysticksCallback( LPCDIDEVICEINSTANCE pInst, + LPVOID lpvContext ) +{ + HRESULT hr; + LPDIRECTINPUTDEVICE pDevice; + + // obtain an interface to the enumerated force feedback joystick. + hr = lpdi->CreateDevice( pInst->guidInstance, &pDevice, NULL ); + + // if it failed, then we can't use this joystick for some + // bizarre reason. (Maybe the user unplugged it while we + // were in the middle of enumerating it.) So continue enumerating + if ( FAILED(hr) ) + return DIENUM_CONTINUE; + + // we successfully created an IDirectInputDevice. So stop looking + // for another one. + g_pJoystick = pDevice; + + // query for IDirectInputDevice2 - we need this to poll the joystick + pDevice->QueryInterface( IID_IDirectInputDevice2, (LPVOID *)&g_pJoystickDevice2 ); + + return DIENUM_STOP; +} +#endif + + +extern IngameKeyboardInput_KeyDown(unsigned char key) +{ + IngameKeyboardInput[key] = 1; +} + +extern IngameKeyboardInput_KeyUp(unsigned char key) +{ + IngameKeyboardInput[key] = 0; +} + +extern IngameKeyboardInput_ClearBuffer(void) +{ + int i; + + for (i=0; i<=255; i++) + { + IngameKeyboardInput[i] = 0; + } +} + +// For extern "C" +}; + + + -- cgit v1.3