made darkplaces compile successfully with g++ to test for errors C doesn't care about...
[xonotic/darkplaces.git] / vid_wgl.c
index 9ce018a..afb773f 100644 (file)
--- a/vid_wgl.c
+++ b/vid_wgl.c
@@ -8,7 +8,7 @@ of the License, or (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 
 See the GNU General Public License for more details.
 
@@ -19,537 +19,362 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 */
 // gl_vidnt.c -- NT GL vid component
 
+// we don't need a very new dinput
+#define DIRECTINPUT_VERSION 0x0300
+
 #include "quakedef.h"
-#include "winquake.h"
+#include <windows.h>
+#include <dsound.h>
 #include "resource.h"
 #include <commctrl.h>
 
-#define MAX_MODE_LIST  30
-#define VID_ROW_SIZE   3
-#define MAXWIDTH               10000
-#define MAXHEIGHT              10000
-
-#define MODE_WINDOWED                  0
-#define NO_MODE                                        (MODE_WINDOWED - 1)
-#define MODE_FULLSCREEN_DEFAULT        (MODE_WINDOWED + 1)
-
-typedef struct {
-       modestate_t     type;
-       int                     width;
-       int                     height;
-       int                     modenum;
-       int                     dib;
-       int                     fullscreen;
-       int                     bpp;
-       int                     halfscreen;
-       char            modedesc[17];
-} vmode_t;
-
-typedef struct {
-       int                     width;
-       int                     height;
-} lmode_t;
-
-lmode_t        lowresmodes[] = {
-       {320, 200},
-       {320, 240},
-       {400, 300},
-       {512, 384},
+extern void S_BlockSound (void);
+extern void S_UnblockSound (void);
+extern HINSTANCE global_hInstance;
+
+
+#ifndef WM_MOUSEWHEEL
+#define WM_MOUSEWHEEL                   0x020A
+#endif
+
+// Tell startup code that we have a client
+int cl_available = true;
+
+static int (WINAPI *qwglChoosePixelFormat)(HDC, CONST PIXELFORMATDESCRIPTOR *);
+static int (WINAPI *qwglDescribePixelFormat)(HDC, int, UINT, LPPIXELFORMATDESCRIPTOR);
+//static int (WINAPI *qwglGetPixelFormat)(HDC);
+static BOOL (WINAPI *qwglSetPixelFormat)(HDC, int, CONST PIXELFORMATDESCRIPTOR *);
+static BOOL (WINAPI *qwglSwapBuffers)(HDC);
+static HGLRC (WINAPI *qwglCreateContext)(HDC);
+static BOOL (WINAPI *qwglDeleteContext)(HGLRC);
+static HGLRC (WINAPI *qwglGetCurrentContext)(VOID);
+static HDC (WINAPI *qwglGetCurrentDC)(VOID);
+static PROC (WINAPI *qwglGetProcAddress)(LPCSTR);
+static BOOL (WINAPI *qwglMakeCurrent)(HDC, HGLRC);
+static BOOL (WINAPI *qwglSwapIntervalEXT)(int interval);
+static const char *(WINAPI *qwglGetExtensionsStringARB)(HDC hdc);
+
+static dllfunction_t wglfuncs[] =
+{
+       {"wglChoosePixelFormat", (void **) &qwglChoosePixelFormat},
+       {"wglDescribePixelFormat", (void **) &qwglDescribePixelFormat},
+//     {"wglGetPixelFormat", (void **) &qwglGetPixelFormat},
+       {"wglSetPixelFormat", (void **) &qwglSetPixelFormat},
+       {"wglSwapBuffers", (void **) &qwglSwapBuffers},
+       {"wglCreateContext", (void **) &qwglCreateContext},
+       {"wglDeleteContext", (void **) &qwglDeleteContext},
+       {"wglGetProcAddress", (void **) &qwglGetProcAddress},
+       {"wglMakeCurrent", (void **) &qwglMakeCurrent},
+       {"wglGetCurrentContext", (void **) &qwglGetCurrentContext},
+       {"wglGetCurrentDC", (void **) &qwglGetCurrentDC},
+       {NULL, NULL}
 };
 
-const char *gl_vendor;
-const char *gl_renderer;
-const char *gl_version;
-const char *gl_extensions;
-
-qboolean               scr_skipupdate;
-
-static vmode_t modelist[MAX_MODE_LIST];
-static int             nummodes;
-static vmode_t *pcurrentmode;
-static vmode_t badmode;
+static dllfunction_t wglswapintervalfuncs[] =
+{
+       {"wglSwapIntervalEXT", (void **) &qwglSwapIntervalEXT},
+       {NULL, NULL}
+};
 
-static DEVMODE gdevmode;
-static qboolean        vid_initialized = false;
-static qboolean        windowed, leavecurrentmode;
-static qboolean vid_canalttab = false;
+static DEVMODE gdevmode;
+static qboolean vid_initialized = false;
 static qboolean vid_wassuspended = false;
-static int             usingmouse;
-extern qboolean        mouseactive;  // from in_win.c
-static HICON   hIcon;
-
-int                    DIBWidth, DIBHeight;
-RECT           WindowRect;
-DWORD          WindowStyle, ExWindowStyle;
-
-HWND   mainwindow;
+static qboolean vid_usingmouse = false;
+static qboolean vid_usingvsync = false;
+static qboolean vid_usevsync = false;
+static HICON hIcon;
 
-int                    vid_modenum = NO_MODE;
-int                    vid_realmode;
-int                    vid_default = MODE_WINDOWED;
-static int     windowed_default;
-unsigned char  vid_curpal[256*3];
+// used by cd_win.c and snd_win.c
+HWND mainwindow;
 
-HGLRC  baseRC;
-HDC            maindc;
+static HDC      baseDC;
+static HGLRC baseRC;
 
-HWND WINAPI InitializeWindow (HINSTANCE hInstance, int nCmdShow);
+//HWND WINAPI InitializeWindow (HINSTANCE hInstance, int nCmdShow);
 
-viddef_t       vid;                            // global video state
+static qboolean vid_isfullscreen;
 
-float          gldepthmin, gldepthmax;
+//void VID_MenuDraw (void);
+//void VID_MenuKey (int key);
 
-modestate_t    modestate = MS_UNINIT;
-
-void VID_MenuDraw (void);
-void VID_MenuKey (int key);
-
-LONG WINAPI MainWndProc (HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
-void AppActivate(BOOL fActive, BOOL minimize);
-char *VID_GetModeDescription (int mode);
-void ClearAllStates (void);
-void VID_UpdateWindowStatus (void);
+//LONG WINAPI MainWndProc (HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
+//void AppActivate(BOOL fActive, BOOL minimize);
+//void ClearAllStates (void);
+//void VID_UpdateWindowStatus (void);
 
 //====================================
 
-// Note that 0 is MODE_WINDOWED
-//cvar_t               _vid_default_mode = {"_vid_default_mode","0", true};
-// Note that 3 is MODE_FULLSCREEN_DEFAULT
-//cvar_t               _vid_default_mode_win = {"_vid_default_mode_win","3", true};
-
-int                    window_center_x, window_center_y, window_x, window_y, window_width, window_height;
-RECT           window_rect;
-
-// direct draw software compatability stuff
-
-void CenterWindow(HWND hWndCenter, int width, int height, BOOL lefttopjustify)
-{
-    int     CenterX, CenterY;
-
-       CenterX = (GetSystemMetrics(SM_CXSCREEN) - width) / 2;
-       CenterY = (GetSystemMetrics(SM_CYSCREEN) - height) / 2;
-       if (CenterX > CenterY*2)
-               CenterX >>= 1;  // dual screens
-       CenterX = (CenterX < 0) ? 0: CenterX;
-       CenterY = (CenterY < 0) ? 0: CenterY;
-       SetWindowPos (hWndCenter, NULL, CenterX, CenterY, 0, 0,
-                       SWP_NOSIZE | SWP_NOZORDER | SWP_SHOWWINDOW | SWP_DRAWFRAME);
-}
-
-qboolean VID_SetWindowedMode (int modenum)
+static int window_x, window_y;
+
+static void IN_Activate (qboolean grab);
+
+static qboolean mouseinitialized;
+static qboolean dinput;
+
+// input code
+
+#include <dinput.h>
+
+#define DINPUT_BUFFERSIZE           16
+#define iDirectInputCreate(a,b,c,d)    pDirectInputCreate(a,b,c,d)
+
+static HRESULT (WINAPI *pDirectInputCreate)(HINSTANCE hinst, DWORD dwVersion, LPDIRECTINPUT * lplpDirectInput, LPUNKNOWN punkOuter);
+
+// LordHavoc: thanks to backslash for this support for mouse buttons 4 and 5
+/* backslash :: imouse explorer buttons */
+/* These are #ifdefed out for non-Win2K in the February 2001 version of
+   MS's platform SDK, but we need them for compilation. . . */
+#ifndef WM_XBUTTONDOWN
+   #define WM_XBUTTONDOWN      0x020B
+   #define WM_XBUTTONUP      0x020C
+#endif
+#ifndef MK_XBUTTON1
+   #define MK_XBUTTON1         0x0020
+   #define MK_XBUTTON2         0x0040
+// LordHavoc: lets hope this allows more buttons in the future...
+   #define MK_XBUTTON3         0x0080
+   #define MK_XBUTTON4         0x0100
+   #define MK_XBUTTON5         0x0200
+   #define MK_XBUTTON6         0x0400
+   #define MK_XBUTTON7         0x0800
+#endif
+/* :: backslash */
+
+// mouse variables
+static int                     mouse_buttons;
+static int                     mouse_oldbuttonstate;
+
+static qboolean        restore_spi;
+static int             originalmouseparms[3], newmouseparms[3] = {0, 0, 1};
+
+static unsigned int uiWheelMessage;
+static qboolean        mouseparmsvalid;
+static qboolean        dinput_acquired;
+
+static unsigned int            mstate_di;
+
+// joystick defines and variables
+// where should defines be moved?
+#define JOY_ABSOLUTE_AXIS      0x00000000              // control like a joystick
+#define JOY_RELATIVE_AXIS      0x00000010              // control like a mouse, spinner, trackball
+#define        JOY_MAX_AXES            6                               // X, Y, Z, R, U, V
+#define JOY_AXIS_X                     0
+#define JOY_AXIS_Y                     1
+#define JOY_AXIS_Z                     2
+#define JOY_AXIS_R                     3
+#define JOY_AXIS_U                     4
+#define JOY_AXIS_V                     5
+
+enum _ControlList
 {
-       int                             lastmodestate, width, height;
-       RECT                    rect;
-
-       lastmodestate = modestate;
-
-       WindowRect.top = WindowRect.left = 0;
-
-       WindowRect.right = modelist[modenum].width;
-       WindowRect.bottom = modelist[modenum].height;
-
-       DIBWidth = modelist[modenum].width;
-       DIBHeight = modelist[modenum].height;
-
-       WindowStyle = WS_OVERLAPPED | WS_BORDER | WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX;
-       ExWindowStyle = 0;
-
-       rect = WindowRect;
-       AdjustWindowRectEx(&rect, WindowStyle, false, 0);
-
-       width = rect.right - rect.left;
-       height = rect.bottom - rect.top;
-
-       // Create the DIB window
-       mainwindow = CreateWindowEx (ExWindowStyle, gamename, gamename, WindowStyle, rect.left, rect.top, width, height, NULL, NULL, global_hInstance, NULL);
-
-       if (!mainwindow)
-               Sys_Error ("Couldn't create DIB window");
-
-       // Center and show the DIB window
-       CenterWindow(mainwindow, WindowRect.right - WindowRect.left, WindowRect.bottom - WindowRect.top, false);
-
-       ShowWindow (mainwindow, SW_SHOWDEFAULT);
-       UpdateWindow (mainwindow);
-
-       modestate = MS_WINDOWED;
-
-       if (vid.conheight > modelist[modenum].height)
-               vid.conheight = modelist[modenum].height;
-       if (vid.conwidth > modelist[modenum].width)
-               vid.conwidth = modelist[modenum].width;
-
-       SendMessage (mainwindow, WM_SETICON, (WPARAM)true, (LPARAM)hIcon);
-       SendMessage (mainwindow, WM_SETICON, (WPARAM)false, (LPARAM)hIcon);
-
-       return true;
-}
-
+       AxisNada = 0, AxisForward, AxisLook, AxisSide, AxisTurn
+};
 
-qboolean VID_SetFullDIBMode (int modenum)
+static DWORD   dwAxisFlags[JOY_MAX_AXES] =
 {
-       int                             lastmodestate, width, height;
-       RECT                    rect;
-
-       if (!leavecurrentmode)
-       {
-               gdevmode.dmFields = DM_BITSPERPEL | DM_PELSWIDTH | DM_PELSHEIGHT;
-               gdevmode.dmBitsPerPel = modelist[modenum].bpp;
-               gdevmode.dmPelsWidth = modelist[modenum].width <<
-                                                          modelist[modenum].halfscreen;
-               gdevmode.dmPelsHeight = modelist[modenum].height;
-               gdevmode.dmSize = sizeof (gdevmode);
-
-               if (ChangeDisplaySettings (&gdevmode, CDS_FULLSCREEN) != DISP_CHANGE_SUCCESSFUL)
-                       Sys_Error ("Couldn't set fullscreen DIB mode");
-       }
-
-       lastmodestate = modestate;
-       modestate = MS_FULLDIB;
-
-       WindowRect.top = WindowRect.left = 0;
-
-       WindowRect.right = modelist[modenum].width;
-       WindowRect.bottom = modelist[modenum].height;
-
-       DIBWidth = modelist[modenum].width;
-       DIBHeight = modelist[modenum].height;
-
-       WindowStyle = WS_POPUP;
-       ExWindowStyle = 0;
-
-       rect = WindowRect;
-       AdjustWindowRectEx(&rect, WindowStyle, false, 0);
-
-       width = rect.right - rect.left;
-       height = rect.bottom - rect.top;
-
-       // Create the DIB window
-       mainwindow = CreateWindowEx (ExWindowStyle, gamename, gamename, WindowStyle, rect.left, rect.top, width, height, NULL, NULL, global_hInstance, NULL);
-
-       if (!mainwindow)
-               Sys_Error ("Couldn't create DIB window");
+       JOY_RETURNX, JOY_RETURNY, JOY_RETURNZ, JOY_RETURNR, JOY_RETURNU, JOY_RETURNV
+};
 
-       ShowWindow (mainwindow, SW_SHOWDEFAULT);
-       UpdateWindow (mainwindow);
+static DWORD   dwAxisMap[JOY_MAX_AXES];
+static DWORD   dwControlMap[JOY_MAX_AXES];
+static PDWORD  pdwRawValue[JOY_MAX_AXES];
+
+// none of these cvars are saved over a session
+// this means that advanced controller configuration needs to be executed
+// each time.  this avoids any problems with getting back to a default usage
+// or when changing from one controller to another.  this way at least something
+// works.
+static cvar_t  in_joystick = {CVAR_SAVE, "joystick","0"};
+static cvar_t  joy_name = {0, "joyname", "joystick"};
+static cvar_t  joy_advanced = {0, "joyadvanced", "0"};
+static cvar_t  joy_advaxisx = {0, "joyadvaxisx", "0"};
+static cvar_t  joy_advaxisy = {0, "joyadvaxisy", "0"};
+static cvar_t  joy_advaxisz = {0, "joyadvaxisz", "0"};
+static cvar_t  joy_advaxisr = {0, "joyadvaxisr", "0"};
+static cvar_t  joy_advaxisu = {0, "joyadvaxisu", "0"};
+static cvar_t  joy_advaxisv = {0, "joyadvaxisv", "0"};
+static cvar_t  joy_forwardthreshold = {0, "joyforwardthreshold", "0.15"};
+static cvar_t  joy_sidethreshold = {0, "joysidethreshold", "0.15"};
+static cvar_t  joy_pitchthreshold = {0, "joypitchthreshold", "0.15"};
+static cvar_t  joy_yawthreshold = {0, "joyyawthreshold", "0.15"};
+static cvar_t  joy_forwardsensitivity = {0, "joyforwardsensitivity", "-1.0"};
+static cvar_t  joy_sidesensitivity = {0, "joysidesensitivity", "-1.0"};
+static cvar_t  joy_pitchsensitivity = {0, "joypitchsensitivity", "1.0"};
+static cvar_t  joy_yawsensitivity = {0, "joyyawsensitivity", "-1.0"};
+static cvar_t  joy_wwhack1 = {0, "joywwhack1", "0.0"};
+static cvar_t  joy_wwhack2 = {0, "joywwhack2", "0.0"};
+
+static qboolean        joy_avail, joy_advancedinit, joy_haspov;
+static DWORD           joy_oldbuttonstate, joy_oldpovstate;
+
+static int                     joy_id;
+static DWORD           joy_flags;
+static DWORD           joy_numbuttons;
+
+static LPDIRECTINPUT           g_pdi;
+static LPDIRECTINPUTDEVICE     g_pMouse;
+
+static JOYINFOEX       ji;
+
+static HINSTANCE hInstDI;
+
+//static qboolean      dinput;
+
+typedef struct MYDATA {
+       LONG  lX;                   // X axis goes here
+       LONG  lY;                   // Y axis goes here
+       LONG  lZ;                   // Z axis goes here
+       BYTE  bButtonA;             // One button goes here
+       BYTE  bButtonB;             // Another button goes here
+       BYTE  bButtonC;             // Another button goes here
+       BYTE  bButtonD;             // Another button goes here
+} MYDATA;
+
+static DIOBJECTDATAFORMAT rgodf[] = {
+  { &GUID_XAxis,    FIELD_OFFSET(MYDATA, lX),       DIDFT_AXIS | DIDFT_ANYINSTANCE,   0,},
+  { &GUID_YAxis,    FIELD_OFFSET(MYDATA, lY),       DIDFT_AXIS | DIDFT_ANYINSTANCE,   0,},
+  { &GUID_ZAxis,    FIELD_OFFSET(MYDATA, lZ),       0x80000000 | DIDFT_AXIS | DIDFT_ANYINSTANCE,   0,},
+  { 0,              FIELD_OFFSET(MYDATA, bButtonA), DIDFT_BUTTON | DIDFT_ANYINSTANCE, 0,},
+  { 0,              FIELD_OFFSET(MYDATA, bButtonB), DIDFT_BUTTON | DIDFT_ANYINSTANCE, 0,},
+  { 0,              FIELD_OFFSET(MYDATA, bButtonC), 0x80000000 | DIDFT_BUTTON | DIDFT_ANYINSTANCE, 0,},
+  { 0,              FIELD_OFFSET(MYDATA, bButtonD), 0x80000000 | DIDFT_BUTTON | DIDFT_ANYINSTANCE, 0,},
+};
 
-       if (vid.conheight > modelist[modenum].height)
-               vid.conheight = modelist[modenum].height;
-       if (vid.conwidth > modelist[modenum].width)
-               vid.conwidth = modelist[modenum].width;
+#define NUM_OBJECTS (sizeof(rgodf) / sizeof(rgodf[0]))
 
-// needed because we're not getting WM_MOVE messages fullscreen on NT
-       window_x = 0;
-       window_y = 0;
+static DIDATAFORMAT    df = {
+       sizeof(DIDATAFORMAT),       // this structure
+       sizeof(DIOBJECTDATAFORMAT), // size of object data format
+       DIDF_RELAXIS,               // absolute axis coordinates
+       sizeof(MYDATA),             // device data size
+       NUM_OBJECTS,                // number of objects
+       rgodf,                      // and here they are
+};
 
-       SendMessage (mainwindow, WM_SETICON, (WPARAM)true, (LPARAM)hIcon);
-       SendMessage (mainwindow, WM_SETICON, (WPARAM)false, (LPARAM)hIcon);
+// forward-referenced functions
+static void IN_StartupJoystick (void);
+static void Joy_AdvancedUpdate_f (void);
+static void IN_JoyMove (void);
+static void IN_StartupMouse (void);
 
-       return true;
-}
 
+//====================================
 
-int VID_SetMode (int modenum)
+void VID_Finish (void)
 {
-       int                             original_mode, temp;
-       qboolean                stat;
-    MSG                                msg;
-
-       if ((windowed && (modenum != 0)) || (!windowed && (modenum < 1)) || (!windowed && (modenum >= nummodes)))
-               Sys_Error ("Bad video mode\n");
-
-// so Con_Printfs don't mess us up by forcing vid and snd updates
-       temp = scr_disabled_for_loading;
-       scr_disabled_for_loading = true;
+       qboolean vid_usemouse;
 
-       CDAudio_Pause ();
-
-       if (vid_modenum == NO_MODE)
-               original_mode = windowed_default;
-       else
-               original_mode = vid_modenum;
-
-       // Set either the fullscreen or windowed mode
-       if (modelist[modenum].type == MS_WINDOWED)
-       {
-//             if (vid_mouse.integer && key_dest == key_game)
-//             {
-//                     stat = VID_SetWindowedMode(modenum);
-//                     usingmouse = true;
-//                     IN_ActivateMouse ();
-//                     IN_HideMouse ();
-//             }
-//             else
-//             {
-//                     usingmouse = false;
-//                     IN_DeactivateMouse ();
-//                     IN_ShowMouse ();
-//                     stat = VID_SetWindowedMode(modenum);
-//             }
-               stat = VID_SetWindowedMode(modenum);
-       }
-       else if (modelist[modenum].type == MS_FULLDIB)
+       vid_usevsync = vid_vsync.integer && !cls.timedemo && gl_videosyncavailable;
+       if (vid_usingvsync != vid_usevsync && gl_videosyncavailable)
        {
-               stat = VID_SetFullDIBMode(modenum);
-//             usingmouse = true;
-//             IN_ActivateMouse ();
-//             IN_HideMouse ();
+               vid_usingvsync = vid_usevsync;
+               qwglSwapIntervalEXT (vid_usevsync);
        }
-       else
-               Sys_Error ("VID_SetMode: Bad mode type in modelist");
-
-       window_width = DIBWidth;
-       window_height = DIBHeight;
-       VID_UpdateWindowStatus ();
-
-       CDAudio_Resume ();
-       scr_disabled_for_loading = temp;
 
-       if (!stat)
-               Sys_Error ("Couldn't set video mode");
-
-// now we try to make sure we get the focus on the mode switch, because
-// sometimes in some systems we don't.  We grab the foreground, then
-// finish setting up, pump all our messages, and sleep for a little while
-// to let messages finish bouncing around the system, then we put
-// ourselves at the top of the z order, then grab the foreground again,
-// Who knows if it helps, but it probably doesn't hurt
-       SetForegroundWindow (mainwindow);
-       vid_modenum = modenum;
-       Cvar_SetValue ("vid_mode", (float)vid_modenum);
-
-       while (PeekMessage (&msg, NULL, 0, 0, PM_REMOVE))
+// handle the mouse state when windowed if that's changed
+       vid_usemouse = false;
+       if (vid_mouse.integer && !key_consoleactive && !cls.demoplayback)
+               vid_usemouse = true;
+       if (vid_isfullscreen)
+               vid_usemouse = true;
+       if (!vid_activewindow)
+               vid_usemouse = false;
+       IN_Activate(vid_usemouse);
+
+       if (r_render.integer && !vid_hidden)
        {
-       TranslateMessage (&msg);
-       DispatchMessage (&msg);
+               if (r_speeds.integer || gl_finish.integer)
+                       qglFinish();
+               SwapBuffers(baseDC);
        }
-
-       Sleep (100);
-
-       SetWindowPos (mainwindow, HWND_TOP, 0, 0, 0, 0, SWP_DRAWFRAME | SWP_NOMOVE | SWP_NOSIZE | SWP_SHOWWINDOW | SWP_NOCOPYBITS);
-
-       SetForegroundWindow (mainwindow);
-
-// fix the leftover Alt from any Alt-Tab or the like that switched us away
-       ClearAllStates ();
-
-       if (!msg_suppress_1)
-               Con_SafePrintf ("Video mode %s initialized.\n", VID_GetModeDescription (vid_modenum));
-
-//     vid.recalc_refdef = 1;
-
-       return true;
 }
 
+//==========================================================================
 
-/*
-================
-VID_UpdateWindowStatus
-================
-*/
-void VID_UpdateWindowStatus (void)
-{
 
-       window_rect.left = window_x;
-       window_rect.top = window_y;
-       window_rect.right = window_x + window_width;
-       window_rect.bottom = window_y + window_height;
-       window_center_x = (window_rect.left + window_rect.right) / 2;
-       window_center_y = (window_rect.top + window_rect.bottom) / 2;
 
-       IN_UpdateClipCursor ();
-}
 
+static qbyte scantokey[128] =
+{
+//  0           1       2    3     4     5       6       7      8         9      A          B           C       D           E           F
+       0          ,27    ,'1'  ,'2'  ,'3'  ,'4'    ,'5'    ,'6'   ,'7'      ,'8'   ,'9'       ,'0'        ,'-'   ,'='         ,K_BACKSPACE,9    ,//0
+       'q'        ,'w'   ,'e'  ,'r'  ,'t'  ,'y'    ,'u'    ,'i'   ,'o'      ,'p'   ,'['       ,']'        ,13    ,K_CTRL      ,'a'        ,'s'  ,//1
+       'd'        ,'f'   ,'g'  ,'h'  ,'j'  ,'k'    ,'l'    ,';'   ,'\''     ,'`'   ,K_SHIFT   ,'\\'       ,'z'   ,'x'         ,'c'        ,'v'  ,//2
+       'b'        ,'n'   ,'m'  ,','  ,'.'  ,'/'    ,K_SHIFT,'*'   ,K_ALT    ,' '   ,0         ,K_F1       ,K_F2  ,K_F3        ,K_F4       ,K_F5 ,//3
+       K_F6       ,K_F7  ,K_F8 ,K_F9 ,K_F10,K_PAUSE,0      ,K_HOME,K_UPARROW,K_PGUP,K_KP_MINUS,K_LEFTARROW,K_KP_5,K_RIGHTARROW,K_KP_PLUS  ,K_END,//4
+       K_DOWNARROW,K_PGDN,K_INS,K_DEL,0    ,0      ,0      ,K_F11 ,K_F12    ,0     ,0         ,0          ,0     ,0           ,0          ,0    ,//5
+       0          ,0     ,0    ,0    ,0    ,0      ,0      ,0     ,0        ,0     ,0         ,0          ,0     ,0           ,0          ,0    ,//6
+       0          ,0     ,0    ,0    ,0    ,0      ,0      ,0     ,0        ,0     ,0         ,0          ,0     ,0           ,0          ,0     //7
+};
 
-//====================================
 
 /*
-=================
-VID_GetWindowSize
-=================
+=======
+MapKey
+
+Map from windows to quake keynums
+=======
 */
-void VID_GetWindowSize (int *x, int *y, int *width, int *height)
+static int MapKey (int key, int virtualkey)
 {
-       *x = *y = 0;
-       *width = WindowRect.right - WindowRect.left;
-       *height = WindowRect.bottom - WindowRect.top;
-}
-
+       int result;
+       int modified = (key >> 16) & 255;
+       qboolean is_extended = false;
 
-void VID_Finish (void)
-{
-       int usemouse;
-       if (r_render.integer && !scr_skipupdate)
+       if (modified < 128 && scantokey[modified])
+               result = scantokey[modified];
+       else
        {
-               glFinish();
-               SwapBuffers(maindc);
+               result = 0;
+               Con_DPrintf("key 0x%02x (0x%8x, 0x%8x) has no translation\n", modified, key, virtualkey);
        }
 
-// handle the mouse state when windowed if that's changed
-       usemouse = false;
-       if (vid_mouse.integer && key_dest == key_game)
-               usemouse = true;
-       if (modestate == MS_FULLDIB)
-               usemouse = true;
-       if (!ActiveApp)
-               usemouse = false;
-       if (usemouse)
+       if (key & (1 << 24))
+               is_extended = true;
+
+       if ( !is_extended )
        {
-               if (!usingmouse)
+               switch ( result )
                {
-                       usingmouse = true;
-                       IN_ActivateMouse ();
-                       IN_HideMouse();
+               case K_HOME:
+                       return K_KP_HOME;
+               case K_UPARROW:
+                       return K_KP_UPARROW;
+               case K_PGUP:
+                       return K_KP_PGUP;
+               case K_LEFTARROW:
+                       return K_KP_LEFTARROW;
+               case K_RIGHTARROW:
+                       return K_KP_RIGHTARROW;
+               case K_END:
+                       return K_KP_END;
+               case K_DOWNARROW:
+                       return K_KP_DOWNARROW;
+               case K_PGDN:
+                       return K_KP_PGDN;
+               case K_INS:
+                       return K_KP_INS;
+               case K_DEL:
+                       return K_KP_DEL;
+               default:
+                       return result;
                }
        }
        else
        {
-               if (usingmouse)
+               switch ( result )
                {
-                       usingmouse = false;
-                       IN_DeactivateMouse ();
-                       IN_ShowMouse();
+               case 0x0D:
+                       return K_KP_ENTER;
+               case 0x2F:
+                       return K_KP_SLASH;
+               case 0xAF:
+                       return K_KP_PLUS;
                }
+               return result;
        }
 }
 
-void VID_SetDefaultMode (void)
-{
-       IN_DeactivateMouse ();
-}
-
-void VID_RestoreSystemGamma(void);
-
-void   VID_Shutdown (void)
-{
-       HGLRC hRC;
-       HDC       hDC;
-       int i;
-       GLuint temp[8192];
-
-       if (vid_initialized)
-       {
-               vid_canalttab = false;
-               hRC = wglGetCurrentContext();
-       hDC = wglGetCurrentDC();
-
-       wglMakeCurrent(NULL, NULL);
-
-               // LordHavoc: free textures before closing (may help NVIDIA)
-               for (i = 0;i < 8192;i++)
-                       temp[i] = i+1;
-               glDeleteTextures(8192, temp);
-
-       if (hRC)
-           wglDeleteContext(hRC);
-
-               if (hDC && mainwindow)
-                       ReleaseDC(mainwindow, hDC);
-
-               if (modestate == MS_FULLDIB)
-                       ChangeDisplaySettings (NULL, 0);
-
-               if (maindc && mainwindow)
-                       ReleaseDC (mainwindow, maindc);
-
-               AppActivate(false, false);
-
-               VID_RestoreSystemGamma();
-       }
-}
-
-
-//==========================================================================
-
-
-BOOL bSetupPixelFormat(HDC hDC)
-{
-    static PIXELFORMATDESCRIPTOR pfd = {
-       sizeof(PIXELFORMATDESCRIPTOR),  // size of this pfd
-       1,                              // version number
-       PFD_DRAW_TO_WINDOW              // support window
-       |  PFD_SUPPORT_OPENGL   // support OpenGL
-       |  PFD_DOUBLEBUFFER ,   // double buffered
-       PFD_TYPE_RGBA,                  // RGBA type
-       24,                             // 24-bit color depth
-       0, 0, 0, 0, 0, 0,               // color bits ignored
-       0,                              // no alpha buffer
-       0,                              // shift bit ignored
-       0,                              // no accumulation buffer
-       0, 0, 0, 0,                     // accum bits ignored
-       32,                             // 32-bit z-buffer      
-       0,                              // no stencil buffer
-       0,                              // no auxiliary buffer
-       PFD_MAIN_PLANE,                 // main layer
-       0,                              // reserved
-       0, 0, 0                         // layer masks ignored
-    };
-    int pixelformat;
-
-    if ( (pixelformat = ChoosePixelFormat(hDC, &pfd)) == 0 )
-    {
-        MessageBox(NULL, "ChoosePixelFormat failed", "Error", MB_OK);
-        return false;
-    }
-
-    if (SetPixelFormat(hDC, pixelformat, &pfd) == false)
-    {
-        MessageBox(NULL, "SetPixelFormat failed", "Error", MB_OK);
-        return false;
-    }
-
-    return true;
-}
-
-
-
-byte scantokey[128] =
-{
-//     0           1      2     3     4     5       6       7      8         9      A       B           C     D            E           F
-       0          ,27    ,'1'  ,'2'  ,'3'  ,'4'    ,'5'    ,'6'   ,'7'      ,'8'   ,'9'    ,'0'        ,'-'  ,'='         ,K_BACKSPACE,9     , // 0
-       'q'        ,'w'   ,'e'  ,'r'  ,'t'  ,'y'    ,'u'    ,'i'   ,'o'      ,'p'   ,'['    ,']'        ,13   ,K_CTRL      ,'a'        ,'s'   , // 1
-       'd'        ,'f'   ,'g'  ,'h'  ,'j'  ,'k'    ,'l'    ,';'   ,'\''     ,'`'   ,K_SHIFT,'\\'       ,'z'  ,'x'         ,'c'        ,'v'   , // 2
-       'b'        ,'n'   ,'m'  ,','  ,'.'  ,'/'    ,K_SHIFT,'*'   ,K_ALT    ,' '   ,0      ,K_F1       ,K_F2 ,K_F3        ,K_F4       ,K_F5  , // 3
-       K_F6       ,K_F7  ,K_F8 ,K_F9 ,K_F10,K_PAUSE,0      ,K_HOME,K_UPARROW,K_PGUP,'-'    ,K_LEFTARROW,'5'  ,K_RIGHTARROW,'+'        ,K_END , // 4
-       K_DOWNARROW,K_PGDN,K_INS,K_DEL,0    ,0      ,0      ,K_F11 ,K_F12    ,0     ,0      ,0          ,0    ,0           ,0          ,0     , // 5
-       0          ,0     ,0    ,0    ,0    ,0      ,0      ,0     ,0        ,0     ,0      ,0          ,0    ,0           ,0          ,0     , // 6
-       0          ,0     ,0    ,0    ,0    ,0      ,0      ,0     ,0        ,0     ,0      ,0          ,0    ,0           ,0          ,0       // 7
-};
-
-/*
-byte shiftscantokey[128] =
-{ 
-//     0           1      2     3     4     5       6       7      8         9      A       B           C    D            E           F 
-       0          ,27    ,'!'  ,'@'  ,'#'  ,'$'    ,'%'    ,'^'   ,'&'      ,'*'   ,'('    ,')'        ,'_' ,'+'         ,K_BACKSPACE,9    , // 0
-       'Q'        ,'W'   ,'E'  ,'R'  ,'T'  ,'Y'    ,'U'    ,'I'   ,'O'      ,'P'   ,'{'    ,'}'        ,13  ,K_CTRL      ,'A'        ,'S'  , // 1
-       'D'        ,'F'   ,'G'  ,'H'  ,'J'  ,'K'    ,'L'    ,':'   ,'"'      ,'~'   ,K_SHIFT,'|'        ,'Z' ,'X'         ,'C'        ,'V'  , // 2
-       'B'        ,'N'   ,'M'  ,'<'  ,'>'  ,'?'    ,K_SHIFT,'*'   ,K_ALT    ,' '   ,0      ,K_F1       ,K_F2,K_F3        ,K_F4       ,K_F5 , // 3
-       K_F6       ,K_F7  ,K_F8 ,K_F9 ,K_F10,K_PAUSE,0      ,K_HOME,K_UPARROW,K_PGUP,'_'    ,K_LEFTARROW,'%' ,K_RIGHTARROW,'+'        ,K_END, // 4
-       K_DOWNARROW,K_PGDN,K_INS,K_DEL,0    ,0      ,0      ,K_F11 ,K_F12    ,0     ,0      ,0          ,0   ,0           ,0          ,0    , // 5
-       0          ,0     ,0    ,0    ,0    ,0      ,0      ,0     ,0        ,0     ,0      ,0          ,0   ,0           ,0          ,0    , // 6
-       0          ,0     ,0    ,0    ,0    ,0      ,0      ,0     ,0        ,0     ,0      ,0          ,0   ,0           ,0          ,0      // 7 
-}; 
-*/
-
-/*
-=======
-MapKey
-
-Map from windows to quake keynums
-=======
-*/
-int MapKey (int key, int virtualkey)
-{
-       key = (key>>16)&255;
-       if (key > 127)
-               return 0;
-       if (scantokey[key] == 0)
-               Con_DPrintf("key 0x%02x has no translation\n", key);
-//     if (scantokey[key] >= 0x20 && scantokey[key] < 0x7F)
-//             return realchar;
-       return scantokey[key];
-}
-
 /*
 ===================================================================
 
@@ -563,23 +388,13 @@ MAIN WINDOW
 ClearAllStates
 ================
 */
-void ClearAllStates (void)
+static void ClearAllStates (void)
 {
-       int             i;
-       
-// send an up event for each key, to make sure the server clears them all
-       for (i=0 ; i<256 ; i++)
-       {
-               Key_Event (i, false);
-       }
-
        Key_ClearStates ();
-       IN_ClearStates ();
+       if (vid_usingmouse)
+               mouse_oldbuttonstate = 0;
 }
 
-void VID_RestoreGameGamma(void);
-extern qboolean host_loopactive;
-
 void AppActivate(BOOL fActive, BOOL minimize)
 /****************************************************************************
 *
@@ -594,16 +409,16 @@ void AppActivate(BOOL fActive, BOOL minimize)
 {
        static BOOL     sound_active;
 
-       ActiveApp = fActive;
-       Minimized = minimize;
+       vid_activewindow = fActive;
+       vid_hidden = minimize;
 
 // enable/disable sound on focus gain/loss
-       if (!ActiveApp && sound_active)
+       if (!vid_activewindow && sound_active)
        {
                S_BlockSound ();
                sound_active = false;
        }
-       else if (ActiveApp && !sound_active)
+       else if (vid_activewindow && !sound_active)
        {
                S_UnblockSound ();
                sound_active = true;
@@ -611,12 +426,9 @@ void AppActivate(BOOL fActive, BOOL minimize)
 
        if (fActive)
        {
-               if (modestate == MS_FULLDIB)
+               if (vid_isfullscreen)
                {
-//                     usingmouse = true;
-//                     IN_ActivateMouse ();
-//                     IN_HideMouse ();
-                       if (vid_canalttab && vid_wassuspended)
+                       if (vid_wassuspended)
                        {
                                vid_wassuspended = false;
                                ChangeDisplaySettings (&gdevmode, CDS_FULLSCREEN);
@@ -626,58 +438,55 @@ void AppActivate(BOOL fActive, BOOL minimize)
                        // LordHavoc: from dabb, fix for alt-tab bug in NVidia drivers
                        MoveWindow(mainwindow,0,0,gdevmode.dmPelsWidth,gdevmode.dmPelsHeight,false);
                }
-//             else if ((modestate == MS_WINDOWED) && vid_mouse.integer && key_dest == key_game)
-//             {
-//                     usingmouse = true;
-//                     IN_ActivateMouse ();
-//                     IN_HideMouse ();
-//             }
-               if (host_loopactive)
-                       VID_RestoreGameGamma();
        }
 
        if (!fActive)
        {
-               usingmouse = false;
-               IN_DeactivateMouse ();
-               IN_ShowMouse ();
-               if (modestate == MS_FULLDIB)
+               IN_Activate (false);
+               if (vid_isfullscreen)
                {
-//                     usingmouse = false;
-//                     IN_DeactivateMouse ();
-//                     IN_ShowMouse ();
-                       if (vid_canalttab)
-                       { 
-                               ChangeDisplaySettings (NULL, 0);
-                               vid_wassuspended = true;
-                       }
+                       ChangeDisplaySettings (NULL, 0);
+                       vid_wassuspended = true;
                }
-//             else if ((modestate == MS_WINDOWED) && vid_mouse.integer)
-//             {
-//                     usingmouse = false;
-//                     IN_DeactivateMouse ();
-//                     IN_ShowMouse ();
-//             }
                VID_RestoreSystemGamma();
        }
 }
 
+//TODO: move it around in vid_wgl.c since I dont think this is the right position
+void Sys_SendKeyEvents (void)
+{
+       MSG msg;
+
+       while (PeekMessage (&msg, NULL, 0, 0, PM_NOREMOVE))
+       {
+               if (!GetMessage (&msg, NULL, 0, 0))
+                       Sys_Quit ();
+
+               TranslateMessage (&msg);
+               DispatchMessage (&msg);
+       }
+}
+
 LONG CDAudio_MessageHandler(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
 
 /* main window procedure */
 LONG WINAPI MainWndProc (HWND hWnd, UINT uMsg, WPARAM  wParam, LPARAM lParam)
 {
-    LONG    lRet = 1;
+       LONG    lRet = 1;
        int             fActive, fMinimized, temp;
-       extern unsigned int uiWheelMessage;
+       char    state[256];
+       char    asciichar[4];
+       int             vkey;
+       int             charlength;
+       qboolean down = false;
 
        if ( uMsg == uiWheelMessage )
                uMsg = WM_MOUSEWHEEL;
 
-    switch (uMsg)
-    {
+       switch (uMsg)
+       {
                case WM_KILLFOCUS:
-                       if (modestate == MS_FULLDIB)
+                       if (vid_isfullscreen)
                                ShowWindow(mainwindow, SW_SHOWMINNOACTIVE);
                        break;
 
@@ -687,17 +496,25 @@ LONG WINAPI MainWndProc (HWND hWnd, UINT uMsg, WPARAM  wParam, LPARAM lParam)
                case WM_MOVE:
                        window_x = (int) LOWORD(lParam);
                        window_y = (int) HIWORD(lParam);
-                       VID_UpdateWindowStatus ();
+                       IN_Activate(false);
                        break;
 
                case WM_KEYDOWN:
                case WM_SYSKEYDOWN:
-                       Key_Event (MapKey(lParam, wParam), true);
-                       break;
-                       
+                       down = true;
                case WM_KEYUP:
                case WM_SYSKEYUP:
-                       Key_Event (MapKey(lParam, wParam), false);
+                       vkey = MapKey(lParam, wParam);
+                       GetKeyboardState (state);
+                       // alt/ctrl/shift tend to produce funky ToAscii values,
+                       // and if it's not a single character we don't know care about it
+                       charlength = ToAscii (wParam, lParam >> 16, state, (unsigned short *)asciichar, 0);
+                       if (vkey == K_ALT || vkey == K_CTRL || vkey == K_SHIFT || charlength == 0)
+                               asciichar[0] = 0;
+                       else if( charlength == 2 ) {
+                               asciichar[0] = asciichar[1];
+                       }
+                       Key_Event (vkey, asciichar[0], down);
                        break;
 
                case WM_SYSCHAR:
@@ -712,6 +529,8 @@ LONG WINAPI MainWndProc (HWND hWnd, UINT uMsg, WPARAM  wParam, LPARAM lParam)
                case WM_RBUTTONUP:
                case WM_MBUTTONDOWN:
                case WM_MBUTTONUP:
+               case WM_XBUTTONDOWN:   // backslash :: imouse explorer buttons
+               case WM_XBUTTONUP:      // backslash :: imouse explorer buttons
                case WM_MOUSEMOVE:
                        temp = 0;
 
@@ -724,31 +543,59 @@ LONG WINAPI MainWndProc (HWND hWnd, UINT uMsg, WPARAM  wParam, LPARAM lParam)
                        if (wParam & MK_MBUTTON)
                                temp |= 4;
 
-                       IN_MouseEvent (temp);
+                       /* backslash :: imouse explorer buttons */
+                       if (wParam & MK_XBUTTON1)
+                               temp |= 8;
+
+                       if (wParam & MK_XBUTTON2)
+                               temp |= 16;
+                       /* :: backslash */
+
+                       // LordHavoc: lets hope this allows more buttons in the future...
+                       if (wParam & MK_XBUTTON3)
+                               temp |= 32;
+                       if (wParam & MK_XBUTTON4)
+                               temp |= 64;
+                       if (wParam & MK_XBUTTON5)
+                               temp |= 128;
+                       if (wParam & MK_XBUTTON6)
+                               temp |= 256;
+                       if (wParam & MK_XBUTTON7)
+                               temp |= 512;
+
+                       if (vid_usingmouse && !dinput_acquired)
+                       {
+                               // perform button actions
+                               int i;
+                               for (i=0 ; i<mouse_buttons ; i++)
+                                       if ((temp ^ mouse_oldbuttonstate) & (1<<i))
+                                               Key_Event (K_MOUSE1 + i, 0, (temp & (1<<i)) != 0);
+                               mouse_oldbuttonstate = temp;
+                       }
 
                        break;
 
                // JACK: This is the mouse wheel with the Intellimouse
                // Its delta is either positive or neg, and we generate the proper
                // Event.
-               case WM_MOUSEWHEEL: 
+               case WM_MOUSEWHEEL:
                        if ((short) HIWORD(wParam) > 0) {
-                               Key_Event(K_MWHEELUP, true);
-                               Key_Event(K_MWHEELUP, false);
+                               Key_Event(K_MWHEELUP, 0, true);
+                               Key_Event(K_MWHEELUP, 0, false);
                        } else {
-                               Key_Event(K_MWHEELDOWN, true);
-                               Key_Event(K_MWHEELDOWN, false);
+                               Key_Event(K_MWHEELDOWN, 0, true);
+                               Key_Event(K_MWHEELDOWN, 0, false);
                        }
                        break;
 
-       case WM_SIZE:
-            break;
+               case WM_SIZE:
+                       break;
 
-           case WM_CLOSE:
+               case WM_CLOSE:
                        if (MessageBox (mainwindow, "Are you sure you want to quit?", "Confirm Exit", MB_YESNO | MB_SETFOREGROUND | MB_ICONQUESTION) == IDYES)
                                Sys_Quit ();
 
-               break;
+                       break;
 
                case WM_ACTIVATE:
                        fActive = LOWORD(wParam);
@@ -760,800 +607,1171 @@ LONG WINAPI MainWndProc (HWND hWnd, UINT uMsg, WPARAM  wParam, LPARAM lParam)
 
                        break;
 
-           case WM_DESTROY:
-        {
-                       if (mainwindow)
-                               DestroyWindow (mainwindow);
-
-            PostQuitMessage (0);
-        }
-        break;
+               //case WM_DESTROY:
+               //      PostQuitMessage (0);
+               //      break;
 
                case MM_MCINOTIFY:
-            lRet = CDAudio_MessageHandler (hWnd, uMsg, wParam, lParam);
+                       lRet = CDAudio_MessageHandler (hWnd, uMsg, wParam, lParam);
                        break;
 
-       default:
-            /* pass all unhandled messages to DefWindowProc */
-            lRet = DefWindowProc (hWnd, uMsg, wParam, lParam);
-        break;
-    }
+               default:
+                       /* pass all unhandled messages to DefWindowProc */
+                       lRet = DefWindowProc (hWnd, uMsg, wParam, lParam);
+               break;
+       }
 
-    /* return 1 if handled message, 0 if not */
-    return lRet;
+       /* return 1 if handled message, 0 if not */
+       return lRet;
 }
 
-
-/*
-=================
-VID_NumModes
-=================
-*/
-int VID_NumModes (void)
+int VID_SetGamma(unsigned short *ramps)
 {
-       return nummodes;
+       HDC hdc = GetDC (NULL);
+       int i = SetDeviceGammaRamp(hdc, ramps);
+       ReleaseDC (NULL, hdc);
+       return i; // return success or failure
 }
 
-       
-/*
-=================
-VID_GetModePtr
-=================
-*/
-vmode_t *VID_GetModePtr (int modenum)
+int VID_GetGamma(unsigned short *ramps)
 {
-
-       if ((modenum >= 0) && (modenum < nummodes))
-               return &modelist[modenum];
-       else
-               return &badmode;
+       HDC hdc = GetDC (NULL);
+       int i = GetDeviceGammaRamp(hdc, ramps);
+       ReleaseDC (NULL, hdc);
+       return i; // return success or failure
 }
 
+static HINSTANCE gldll;
 
-/*
-=================
-VID_GetModeDescription
-=================
-*/
-char *VID_GetModeDescription (int mode)
+static void GL_CloseLibrary(void)
 {
-       char            *pinfo;
-       vmode_t         *pv;
-       static char     temp[100];
-
-       if ((mode < 0) || (mode >= nummodes))
-               return NULL;
-
-       if (!leavecurrentmode)
-       {
-               pv = VID_GetModePtr (mode);
-               pinfo = pv->modedesc;
-       }
-       else
-       {
-               sprintf (temp, "Desktop resolution (%dx%d)", modelist[MODE_FULLSCREEN_DEFAULT].width, modelist[MODE_FULLSCREEN_DEFAULT].height);
-               pinfo = temp;
-       }
-
-       return pinfo;
+       FreeLibrary(gldll);
+       gldll = 0;
+       gl_driver[0] = 0;
+       qwglGetProcAddress = NULL;
+       gl_extensions = "";
+       gl_platform = "";
+       gl_platformextensions = "";
 }
 
-
-// KJB: Added this to return the mode driver name in description for console
-
-char *VID_GetExtModeDescription (int mode)
+static int GL_OpenLibrary(const char *name)
 {
-       static char     pinfo[40];
-       vmode_t         *pv;
-
-       if ((mode < 0) || (mode >= nummodes))
-               return NULL;
-
-       pv = VID_GetModePtr (mode);
-       if (modelist[mode].type == MS_FULLDIB)
-       {
-               if (!leavecurrentmode)
-                       sprintf(pinfo,"%s fullscreen", pv->modedesc);
-               else
-                       sprintf (pinfo, "Desktop resolution (%dx%d)", modelist[MODE_FULLSCREEN_DEFAULT].width, modelist[MODE_FULLSCREEN_DEFAULT].height);
-       }
-       else
+       Con_Printf("Loading OpenGL driver %s\n", name);
+       GL_CloseLibrary();
+       if (!(gldll = LoadLibrary(name)))
        {
-               if (modestate == MS_WINDOWED)
-                       sprintf(pinfo, "%s windowed", pv->modedesc);
-               else
-                       sprintf(pinfo, "windowed");
+               Con_Printf("Unable to LoadLibrary %s\n", name);
+               return false;
        }
-
-       return pinfo;
+       strcpy(gl_driver, name);
+       return true;
 }
 
-
-/*
-=================
-VID_DescribeCurrentMode_f
-=================
-*/
-void VID_DescribeCurrentMode_f (void)
+void *GL_GetProcAddress(const char *name)
 {
-       Con_Printf ("%s\n", VID_GetExtModeDescription (vid_modenum));
+       void *p = NULL;
+       if (qwglGetProcAddress != NULL)
+               p = (void *) qwglGetProcAddress(name);
+       if (p == NULL)
+               p = (void *) GetProcAddress(gldll, name);
+       return p;
 }
 
-
-/*
-=================
-VID_NumModes_f
-=================
-*/
-void VID_NumModes_f (void)
+static void IN_Init(void);
+void VID_Init(void)
 {
+       WNDCLASS wc;
 
-       if (nummodes == 1)
-               Con_Printf ("%d video mode is available\n", nummodes);
-       else
-               Con_Printf ("%d video modes are available\n", nummodes);
-}
-
-
-/*
-=================
-VID_DescribeMode_f
-=================
-*/
-void VID_DescribeMode_f (void)
-{
-       int             t, modenum;
-       
-       modenum = atoi (Cmd_Argv(1));
+       InitCommonControls();
+       hIcon = LoadIcon (global_hInstance, MAKEINTRESOURCE (IDI_ICON1));
 
-       t = leavecurrentmode;
-       leavecurrentmode = 0;
+       // Register the frame class
+       wc.style         = 0;
+       wc.lpfnWndProc   = (WNDPROC)MainWndProc;
+       wc.cbClsExtra    = 0;
+       wc.cbWndExtra    = 0;
+       wc.hInstance     = global_hInstance;
+       wc.hIcon         = hIcon;
+       wc.hCursor       = LoadCursor (NULL,IDC_ARROW);
+       wc.hbrBackground = NULL;
+       wc.lpszMenuName  = 0;
+       wc.lpszClassName = "DarkPlacesWindowClass";
 
-       Con_Printf ("%s\n", VID_GetExtModeDescription (modenum));
+       if (!RegisterClass (&wc))
+               Con_Printf ("Couldn't register window class\n");
 
-       leavecurrentmode = t;
+       IN_Init();
 }
 
-
-/*
-=================
-VID_DescribeModes_f
-=================
-*/
-void VID_DescribeModes_f (void)
+int VID_InitMode (int fullscreen, int width, int height, int bpp)
 {
-       int                     i, lnummodes, t;
-       char            *pinfo;
-       vmode_t         *pv;
-
-       lnummodes = VID_NumModes ();
+       int i;
+       HDC hdc;
+       RECT rect;
+       MSG msg;
+       PIXELFORMATDESCRIPTOR pfd =
+       {
+               sizeof(PIXELFORMATDESCRIPTOR),  // size of this pfd
+               1,                              // version number
+               PFD_DRAW_TO_WINDOW              // support window
+               |  PFD_SUPPORT_OPENGL   // support OpenGL
+               |  PFD_DOUBLEBUFFER ,   // double buffered
+               PFD_TYPE_RGBA,                  // RGBA type
+               24,                             // 24-bit color depth
+               0, 0, 0, 0, 0, 0,               // color bits ignored
+               0,                              // no alpha buffer
+               0,                              // shift bit ignored
+               0,                              // no accumulation buffer
+               0, 0, 0, 0,                     // accum bits ignored
+               32,                             // 32-bit z-buffer
+               0,                              // no stencil buffer
+               0,                              // no auxiliary buffer
+               PFD_MAIN_PLANE,                 // main layer
+               0,                              // reserved
+               0, 0, 0                         // layer masks ignored
+       };
+       int pixelformat;
+       DWORD WindowStyle, ExWindowStyle;
+       int CenterX, CenterY;
+       const char *gldrivername;
+       int depth;
 
-       t = leavecurrentmode;
-       leavecurrentmode = 0;
+       if (vid_initialized)
+               Sys_Error("VID_InitMode called when video is already initialised\n");
 
-       for (i=1 ; i<lnummodes ; i++)
+       // if stencil is enabled, ask for alpha too
+       if (bpp >= 32)
        {
-               pv = VID_GetModePtr (i);
-               pinfo = VID_GetExtModeDescription (i);
-               Con_Printf ("%2d: %s\n", i, pinfo);
+               pfd.cStencilBits = 8;
+               pfd.cAlphaBits = 8;
        }
-
-       leavecurrentmode = t;
-}
-
-void VID_AddMode(int type, int width, int height, int modenum, int halfscreen, int dib, int fullscreen, int bpp)
-{
-       int i;
-       if (nummodes >= MAX_MODE_LIST)
-               return;
-       modelist[nummodes].type = type;
-       modelist[nummodes].width = width;
-       modelist[nummodes].height = height;
-       modelist[nummodes].modenum = modenum;
-       modelist[nummodes].halfscreen = halfscreen;
-       modelist[nummodes].dib = dib;
-       modelist[nummodes].fullscreen = fullscreen;
-       modelist[nummodes].bpp = bpp;
-       if (bpp == 0)
-               sprintf (modelist[nummodes].modedesc, "%dx%d", width, height);
        else
-               sprintf (modelist[nummodes].modedesc, "%dx%dx%d", width, height, bpp);
-       for (i = 0;i < nummodes;i++)
        {
-               if (!memcmp(&modelist[i], &modelist[nummodes], sizeof(vmode_t)))
-                       return;
+               pfd.cStencilBits = 0;
+               pfd.cAlphaBits = 0;
        }
-       nummodes++;
-}
-
-void VID_InitDIB (HINSTANCE hInstance)
-{
-       int w, h;
-       WNDCLASS                wc;
 
-       // Register the frame class
-    wc.style         = 0;
-    wc.lpfnWndProc   = (WNDPROC)MainWndProc;
-    wc.cbClsExtra    = 0;
-    wc.cbWndExtra    = 0;
-    wc.hInstance     = hInstance;
-    wc.hIcon         = 0;
-    wc.hCursor       = LoadCursor (NULL,IDC_ARROW);
-       wc.hbrBackground = NULL;
-    wc.lpszMenuName  = 0;
-    wc.lpszClassName = gamename;
-
-    if (!RegisterClass (&wc) )
-               Sys_Error ("Couldn't register window class");
-
-       /*
-       modelist[0].type = MS_WINDOWED;
+       gldrivername = "opengl32.dll";
+// COMMANDLINEOPTION: Windows WGL: -gl_driver <drivername> selects a GL driver library, default is opengl32.dll, useful only for 3dfxogl.dll or 3dfxvgl.dll, if you don't know what this is for, you don't need it
+       i = COM_CheckParm("-gl_driver");
+       if (i && i < com_argc - 1)
+               gldrivername = com_argv[i + 1];
+       if (!GL_OpenLibrary(gldrivername))
+       {
+               Con_Printf("Unable to load GL driver %s\n", gldrivername);
+               return false;
+       }
 
-       if (COM_CheckParm("-width"))
-               modelist[0].width = atoi(com_argv[COM_CheckParm("-width")+1]);
-       else
-               modelist[0].width = 640;
+       memset(&gdevmode, 0, sizeof(gdevmode));
 
-       if (modelist[0].width < 320)
-               modelist[0].width = 320;
+       vid_isfullscreen = false;
+       if (fullscreen)
+       {
+               gdevmode.dmFields = DM_BITSPERPEL | DM_PELSWIDTH | DM_PELSHEIGHT;
+               gdevmode.dmBitsPerPel = bpp;
+               gdevmode.dmPelsWidth = width;
+               gdevmode.dmPelsHeight = height;
+               gdevmode.dmSize = sizeof (gdevmode);
+               if (ChangeDisplaySettings (&gdevmode, CDS_FULLSCREEN) != DISP_CHANGE_SUCCESSFUL)
+               {
+                       VID_Shutdown();
+                       Con_Printf("Unable to change to requested mode %dx%dx%dbpp\n", width, height, bpp);
+                       return false;
+               }
 
-       if (COM_CheckParm("-height"))
-               modelist[0].height= atoi(com_argv[COM_CheckParm("-height")+1]);
+               vid_isfullscreen = true;
+               WindowStyle = WS_POPUP;
+               ExWindowStyle = WS_EX_TOPMOST;
+       }
        else
-               modelist[0].height = modelist[0].width * 240/320;
+       {
+               hdc = GetDC (NULL);
+               i = GetDeviceCaps(hdc, RASTERCAPS);
+               depth = GetDeviceCaps(hdc, PLANES) * GetDeviceCaps(hdc, BITSPIXEL);
+               ReleaseDC (NULL, hdc);
+               if (i & RC_PALETTE)
+               {
+                       VID_Shutdown();
+                       Con_Print("Can't run in non-RGB mode\n");
+                       return false;
+               }
+               if (bpp > depth)
+               {
+                       VID_Shutdown();
+                       Con_Print("A higher desktop depth is required to run this video mode\n");
+                       return false;
+               }
 
-       if (modelist[0].height < 240)
-               modelist[0].height = 240;
+               WindowStyle = WS_OVERLAPPED | WS_BORDER | WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX;
+               ExWindowStyle = 0;
+       }
 
-       sprintf (modelist[0].modedesc, "%dx%d", modelist[0].width, modelist[0].height);
+       rect.top = 0;
+       rect.left = 0;
+       rect.right = width;
+       rect.bottom = height;
+       AdjustWindowRectEx(&rect, WindowStyle, false, 0);
 
-       modelist[0].modenum = MODE_WINDOWED;
-       modelist[0].dib = 1;
-       modelist[0].fullscreen = 0;
-       modelist[0].halfscreen = 0;
-       modelist[0].bpp = 0;
+       if (fullscreen)
+       {
+               CenterX = 0;
+               CenterY = 0;
+       }
+       else
+       {
+               CenterX = (GetSystemMetrics(SM_CXSCREEN) - (rect.right - rect.left)) / 2;
+               CenterY = (GetSystemMetrics(SM_CYSCREEN) - (rect.bottom - rect.top)) / 2;
+       }
+       CenterX = max(0, CenterX);
+       CenterY = max(0, CenterY);
+
+       // x and y may be changed by WM_MOVE messages
+       window_x = CenterX;
+       window_y = CenterY;
+       rect.left += CenterX;
+       rect.right += CenterX;
+       rect.top += CenterY;
+       rect.bottom += CenterY;
+
+       mainwindow = CreateWindowEx (ExWindowStyle, "DarkPlacesWindowClass", gamename, WindowStyle, rect.left, rect.top, rect.right - rect.left, rect.bottom - rect.top, NULL, NULL, global_hInstance, NULL);
+       if (!mainwindow)
+       {
+               Con_Printf("CreateWindowEx(%d, %s, %s, %d, %d, %d, %d, %d, %p, %p, %d, %p) failed\n", ExWindowStyle, "DarkPlacesWindowClass", gamename, WindowStyle, rect.left, rect.top, rect.right - rect.left, rect.bottom - rect.top, NULL, NULL, global_hInstance, NULL);
+               VID_Shutdown();
+               return false;
+       }
 
-       nummodes = 1;
+       /*
+       if (!fullscreen)
+               SetWindowPos (mainwindow, NULL, CenterX, CenterY, 0, 0,SWP_NOSIZE | SWP_NOZORDER | SWP_SHOWWINDOW | SWP_DRAWFRAME);
        */
-       if (COM_CheckParm("-width"))
-               w = atoi(com_argv[COM_CheckParm("-width")+1]);
-       else
-               w = 640;
 
-       if (w < 320)
-               w = 320;
+       ShowWindow (mainwindow, SW_SHOWDEFAULT);
+       UpdateWindow (mainwindow);
 
-       if (COM_CheckParm("-height"))
-               h = atoi(com_argv[COM_CheckParm("-height")+1]);
-       else
-               h = w * 240/320;
+       // now we try to make sure we get the focus on the mode switch, because
+       // sometimes in some systems we don't.  We grab the foreground, then
+       // finish setting up, pump all our messages, and sleep for a little while
+       // to let messages finish bouncing around the system, then we put
+       // ourselves at the top of the z order, then grab the foreground again,
+       // Who knows if it helps, but it probably doesn't hurt
+       SetForegroundWindow (mainwindow);
 
-       if (h < 240)
-               h = 240;
+       while (PeekMessage (&msg, NULL, 0, 0, PM_REMOVE))
+       {
+               TranslateMessage (&msg);
+               DispatchMessage (&msg);
+       }
 
-       VID_AddMode(MS_WINDOWED, w, h, 0, 0, 1, 0, 0);
-}
+       Sleep (100);
 
+       SetWindowPos (mainwindow, HWND_TOP, 0, 0, 0, 0, SWP_DRAWFRAME | SWP_NOMOVE | SWP_NOSIZE | SWP_SHOWWINDOW | SWP_NOCOPYBITS);
 
-/*
-=================
-VID_InitFullDIB
-=================
-*/
-void VID_InitFullDIB (HINSTANCE hInstance)
-{
-       DEVMODE devmode;
-//     int             i;
-       int             modenum;
-       int             originalnummodes;
-//     int             existingmode;
-       int             numlowresmodes;
-       int             j;
-       int             bpp;
-       int             done;
-       BOOL    stat;
-
-// enumerate >8 bpp modes
-       originalnummodes = nummodes;
-       modenum = 0;
-
-       do
+       SetForegroundWindow (mainwindow);
+
+       // fix the leftover Alt from any Alt-Tab or the like that switched us away
+       ClearAllStates ();
+
+       baseDC = GetDC(mainwindow);
+
+       if ((pixelformat = ChoosePixelFormat(baseDC, &pfd)) == 0)
        {
-               stat = EnumDisplaySettings (NULL, modenum, &devmode);
+               VID_Shutdown();
+               Con_Printf("ChoosePixelFormat(%d, %p) failed\n", baseDC, &pfd);
+               return false;
+       }
 
-               if ((devmode.dmBitsPerPel >= 15) && (devmode.dmPelsWidth <= MAXWIDTH) && (devmode.dmPelsHeight <= MAXHEIGHT) && (nummodes < MAX_MODE_LIST))
-               {
-                       devmode.dmFields = DM_BITSPERPEL | DM_PELSWIDTH | DM_PELSHEIGHT;
+       if (SetPixelFormat(baseDC, pixelformat, &pfd) == false)
+       {
+               VID_Shutdown();
+               Con_Printf("SetPixelFormat(%d, %d, %p) failed\n", baseDC, pixelformat, &pfd);
+               return false;
+       }
 
-                       if (ChangeDisplaySettings (&devmode, CDS_TEST | CDS_FULLSCREEN) == DISP_CHANGE_SUCCESSFUL)
-                       {
-                       // if the width is more than twice the height, reduce it by half because this
-                       // is probably a dual-screen monitor
-                               if ((!COM_CheckParm("-noadjustaspect")) && (devmode.dmPelsWidth > (devmode.dmPelsHeight << 1)))
-                                       VID_AddMode(MS_FULLDIB, devmode.dmPelsWidth >> 1, devmode.dmPelsHeight, 0, 1, 1, 1, devmode.dmBitsPerPel);
-                               else
-                                       VID_AddMode(MS_FULLDIB, devmode.dmPelsWidth, devmode.dmPelsHeight, 0, 0, 1, 1, devmode.dmBitsPerPel);
-                               /*
-                               modelist[nummodes].type = MS_FULLDIB;
-                               modelist[nummodes].width = devmode.dmPelsWidth;
-                               modelist[nummodes].height = devmode.dmPelsHeight;
-                               modelist[nummodes].modenum = 0;
-                               modelist[nummodes].halfscreen = 0;
-                               modelist[nummodes].dib = 1;
-                               modelist[nummodes].fullscreen = 1;
-                               modelist[nummodes].bpp = devmode.dmBitsPerPel;
-                               sprintf (modelist[nummodes].modedesc, "%dx%dx%d", devmode.dmPelsWidth, devmode.dmPelsHeight, devmode.dmBitsPerPel);
-
-                       // if the width is more than twice the height, reduce it by half because this
-                       // is probably a dual-screen monitor
-                               if (!COM_CheckParm("-noadjustaspect"))
-                               {
-                                       if (modelist[nummodes].width > (modelist[nummodes].height << 1))
-                                       {
-                                               modelist[nummodes].width >>= 1;
-                                               modelist[nummodes].halfscreen = 1;
-                                               sprintf (modelist[nummodes].modedesc, "%dx%dx%d", modelist[nummodes].width, modelist[nummodes].height, modelist[nummodes].bpp);
-                                       }
-                               }
+       if (!GL_CheckExtension("wgl", wglfuncs, NULL, false))
+       {
+               VID_Shutdown();
+               Con_Print("wgl functions not found\n");
+               return false;
+       }
 
-                               for (i=originalnummodes, existingmode = 0 ; i<nummodes ; i++)
-                               {
-                                       if ((modelist[nummodes].width == modelist[i].width) && (modelist[nummodes].height == modelist[i].height) && (modelist[nummodes].bpp == modelist[i].bpp))
-                                       {
-                                               existingmode = 1;
-                                               break;
-                                       }
-                               }
+       baseRC = qwglCreateContext(baseDC);
+       if (!baseRC)
+       {
+               VID_Shutdown();
+               Con_Print("Could not initialize GL (wglCreateContext failed).\n\nMake sure you are in 65536 color mode, and try running -window.\n");
+               return false;
+       }
+       if (!qwglMakeCurrent(baseDC, baseRC))
+       {
+               VID_Shutdown();
+               Con_Printf("wglMakeCurrent(%d, %d) failed\n", baseDC, baseRC);
+               return false;
+       }
 
-                               if (!existingmode)
-                                       nummodes++;
-                               */
-                       }
-               }
+       if ((qglGetString = (const GLubyte* (GLAPIENTRY *)(GLenum name))GL_GetProcAddress("glGetString")) == NULL)
+       {
+               VID_Shutdown();
+               Con_Print("glGetString not found\n");
+               return false;
+       }
+       if ((qwglGetExtensionsStringARB = (const char *(WINAPI *)(HDC hdc))GL_GetProcAddress("wglGetExtensionsStringARB")) == NULL)
+               Con_Print("wglGetExtensionsStringARB not found\n");
+       gl_renderer = qglGetString(GL_RENDERER);
+       gl_vendor = qglGetString(GL_VENDOR);
+       gl_version = qglGetString(GL_VERSION);
+       gl_extensions = qglGetString(GL_EXTENSIONS);
+       gl_platform = "WGL";
+       gl_platformextensions = "";
+
+       gl_videosyncavailable = false;
+
+       if (qwglGetExtensionsStringARB)
+               gl_platformextensions = qwglGetExtensionsStringARB(baseDC);
+
+// COMMANDLINEOPTION: Windows WGL: -novideosync disables WGL_EXT_swap_control
+       gl_videosyncavailable = GL_CheckExtension("WGL_EXT_swap_control", wglswapintervalfuncs, "-novideosync", false);
+       //ReleaseDC(mainwindow, hdc);
+
+       GL_Init ();
+
+       // LordHavoc: special differences for ATI (broken 8bit color when also using 32bit? weird!)
+       if (strncasecmp(gl_vendor,"ATI",3)==0)
+       {
+               if (strncasecmp(gl_renderer,"Rage Pro",8)==0)
+                       isRagePro = true;
+       }
+       if (strncasecmp(gl_renderer,"Matrox G200 Direct3D",20)==0) // a D3D driver for GL? sigh...
+               isG200 = true;
+
+       //vid_menudrawfn = VID_MenuDraw;
+       //vid_menukeyfn = VID_MenuKey;
+       vid_usingmouse = false;
+       vid_usingvsync = false;
+       vid_hidden = false;
+       vid_initialized = true;
 
-               modenum++;
+       IN_StartupMouse ();
+       IN_StartupJoystick ();
+
+       if (gl_videosyncavailable)
+       {
+               vid_usevsync = vid_vsync.integer;
+               vid_usingvsync = vid_vsync.integer;
+               qwglSwapIntervalEXT (vid_usevsync);
        }
-       while (stat);
 
-// see if there are any low-res modes that aren't being reported
-       numlowresmodes = sizeof(lowresmodes) / sizeof(lowresmodes[0]);
-       bpp = 16;
-       done = 0;
+       return true;
+}
+
+static void IN_Shutdown(void);
+void VID_Shutdown (void)
+{
+       if(vid_initialized == false)
+               return;
+
+       VID_RestoreSystemGamma();
+
+       vid_initialized = false;
+       IN_Shutdown();
+       if (qwglMakeCurrent)
+               qwglMakeCurrent(NULL, NULL);
+       if (baseRC && qwglDeleteContext)
+               qwglDeleteContext(baseRC);
+       // close the library before we get rid of the window
+       GL_CloseLibrary();
+       if (baseDC && mainwindow)
+               ReleaseDC(mainwindow, baseDC);
+       AppActivate(false, false);
+       if (mainwindow)
+               DestroyWindow(mainwindow);
+       mainwindow = 0;
+       if (vid_isfullscreen)
+               ChangeDisplaySettings (NULL, 0);
+       vid_isfullscreen = false;
+}
+
+static void IN_Activate (qboolean grab)
+{
+       if (!mouseinitialized)
+               return;
 
-       do
+       if (grab)
        {
-               for (j=0 ; (j<numlowresmodes) && (nummodes < MAX_MODE_LIST) ; j++)
+               if (!vid_usingmouse)
                {
-                       devmode.dmBitsPerPel = bpp;
-                       devmode.dmPelsWidth = lowresmodes[j].width;
-                       devmode.dmPelsHeight = lowresmodes[j].height;
-                       devmode.dmFields = DM_BITSPERPEL | DM_PELSWIDTH | DM_PELSHEIGHT;
-
-                       if (ChangeDisplaySettings (&devmode, CDS_TEST | CDS_FULLSCREEN) == DISP_CHANGE_SUCCESSFUL)
-                               VID_AddMode(MS_FULLDIB, devmode.dmPelsWidth, devmode.dmPelsHeight, 0, 0, 1, 1, devmode.dmBitsPerPel);
-                       /*
+                       vid_usingmouse = true;
+                       cl_ignoremousemove = true;
+                       if (dinput && g_pMouse)
                        {
-                               modelist[nummodes].type = MS_FULLDIB;
-                               modelist[nummodes].width = devmode.dmPelsWidth;
-                               modelist[nummodes].height = devmode.dmPelsHeight;
-                               modelist[nummodes].modenum = 0;
-                               modelist[nummodes].halfscreen = 0;
-                               modelist[nummodes].dib = 1;
-                               modelist[nummodes].fullscreen = 1;
-                               modelist[nummodes].bpp = devmode.dmBitsPerPel;
-                               sprintf (modelist[nummodes].modedesc, "%dx%dx%d", devmode.dmPelsWidth, devmode.dmPelsHeight, devmode.dmBitsPerPel);
-
-                               for (i=originalnummodes, existingmode = 0 ; i<nummodes ; i++)
-                               {
-                                       if ((modelist[nummodes].width == modelist[i].width) && (modelist[nummodes].height == modelist[i].height) && (modelist[nummodes].bpp == modelist[i].bpp))
-                                       {
-                                               existingmode = 1;
-                                               break;
-                                       }
-                               }
-
-                               if (!existingmode)
-                                       nummodes++;
+                               IDirectInputDevice_Acquire(g_pMouse);
+                               dinput_acquired = true;
+                       }
+                       else
+                       {
+                               RECT window_rect;
+                               window_rect.left = window_x;
+                               window_rect.top = window_y;
+                               window_rect.right = window_x + vid.width;
+                               window_rect.bottom = window_y + vid.height;
+                               if (mouseparmsvalid)
+                                       restore_spi = SystemParametersInfo (SPI_SETMOUSE, 0, newmouseparms, 0);
+                               SetCursorPos ((window_x + vid.width / 2), (window_y + vid.height / 2));
+                               SetCapture (mainwindow);
+                               ClipCursor (&window_rect);
                        }
-                       */
+                       ShowCursor (false);
                }
-               switch (bpp)
+       }
+       else
+       {
+               if (vid_usingmouse)
                {
-                       case 16:
-                               bpp = 32;
-                               break;
+                       vid_usingmouse = false;
+                       cl_ignoremousemove = true;
+                       if (dinput_acquired)
+                       {
+                               IDirectInputDevice_Unacquire(g_pMouse);
+                               dinput_acquired = false;
+                       }
+                       else
+                       {
+                               if (restore_spi)
+                                       SystemParametersInfo (SPI_SETMOUSE, 0, originalmouseparms, 0);
+                               ClipCursor (NULL);
+                               ReleaseCapture ();
+                       }
+                       ShowCursor (true);
+               }
+       }
+}
 
-                       case 32:
-                               bpp = 24;
-                               break;
 
-                       case 24:
-                               done = 1;
-                               break;
+/*
+===========
+IN_InitDInput
+===========
+*/
+static qboolean IN_InitDInput (void)
+{
+    HRESULT            hr;
+       DIPROPDWORD     dipdw = {
+               {
+                       sizeof(DIPROPDWORD),        // diph.dwSize
+                       sizeof(DIPROPHEADER),       // diph.dwHeaderSize
+                       0,                          // diph.dwObj
+                       DIPH_DEVICE,                // diph.dwHow
+               },
+               DINPUT_BUFFERSIZE,              // dwData
+       };
+
+       if (!hInstDI)
+       {
+               hInstDI = LoadLibrary("dinput.dll");
+
+               if (hInstDI == NULL)
+               {
+                       Con_Print("Couldn't load dinput.dll\n");
+                       return false;
                }
        }
-       while (!done);
 
-       if (nummodes == originalnummodes)
-               Con_SafePrintf ("No fullscreen DIB modes found\n");
-}
+       if (!pDirectInputCreate)
+       {
+               pDirectInputCreate = (void *)GetProcAddress(hInstDI,"DirectInputCreateA");
 
-static int grabsysgamma = true;
-WORD systemgammaramps[3][256], currentgammaramps[3][256];
+               if (!pDirectInputCreate)
+               {
+                       Con_Print("Couldn't get DI proc addr\n");
+                       return false;
+               }
+       }
 
-int VID_SetGamma(float prescale, float gamma, float scale, float base)
-{
-       int i;
-       HDC hdc;
-       hdc = GetDC (NULL);
+// register with DirectInput and get an IDirectInput to play with.
+       hr = iDirectInputCreate(global_hInstance, DIRECTINPUT_VERSION, &g_pdi, NULL);
 
-       BuildGammaTable16(prescale, gamma, scale, base, &currentgammaramps[0][0]);
-       for (i = 0;i < 256;i++)
-               currentgammaramps[1][i] = currentgammaramps[2][i] = currentgammaramps[0][i];
+       if (FAILED(hr))
+       {
+               return false;
+       }
 
-       i = SetDeviceGammaRamp(hdc, &currentgammaramps[0][0]);
+// obtain an interface to the system mouse device.
+       hr = IDirectInput_CreateDevice(g_pdi, &GUID_SysMouse, &g_pMouse, NULL);
 
-       ReleaseDC (NULL, hdc);
-       return i; // return success or failure
-}
+       if (FAILED(hr))
+       {
+               Con_Print("Couldn't open DI mouse device\n");
+               return false;
+       }
 
-void VID_RestoreGameGamma(void)
-{
-       VID_UpdateGamma(true);
-}
+// set the data format to "mouse format".
+       hr = IDirectInputDevice_SetDataFormat(g_pMouse, &df);
 
-void VID_GetSystemGamma(void)
-{
-       HDC hdc;
-       hdc = GetDC (NULL);
+       if (FAILED(hr))
+       {
+               Con_Print("Couldn't set DI mouse format\n");
+               return false;
+       }
 
-       GetDeviceGammaRamp(hdc, &systemgammaramps[0][0]);
+// set the cooperativity level.
+       hr = IDirectInputDevice_SetCooperativeLevel(g_pMouse, mainwindow,
+                       DISCL_EXCLUSIVE | DISCL_FOREGROUND);
 
-       ReleaseDC (NULL, hdc);
-}
+       if (FAILED(hr))
+       {
+               Con_Print("Couldn't set DI coop level\n");
+               return false;
+       }
 
-void VID_RestoreSystemGamma(void)
-{
-       HDC hdc;
-       hdc = GetDC (NULL);
 
-       SetDeviceGammaRamp(hdc, &systemgammaramps[0][0]);
+// set the buffer size to DINPUT_BUFFERSIZE elements.
+// the buffer size is a DWORD property associated with the device
+       hr = IDirectInputDevice_SetProperty(g_pMouse, DIPROP_BUFFERSIZE, &dipdw.diph);
 
-       ReleaseDC (NULL, hdc);
+       if (FAILED(hr))
+       {
+               Con_Print("Couldn't set DI buffersize\n");
+               return false;
+       }
+
+       return true;
 }
 
+
 /*
-===================
-VID_Init
-===================
+===========
+IN_StartupMouse
+===========
 */
-void   VID_Init (void)
+static void IN_StartupMouse (void)
 {
-       int             i;
-//     int             existingmode;
-       int             basenummodes, width, height, bpp, findbpp, done;
-       HDC             hdc;
-       DEVMODE devmode;
-
-       memset(&devmode, 0, sizeof(devmode));
-
-//     Cvar_RegisterVariable (&_vid_default_mode);
-//     Cvar_RegisterVariable (&_vid_default_mode_win);
+       if (COM_CheckParm ("-nomouse") || COM_CheckParm("-safe"))
+               return;
 
-       Cmd_AddCommand ("vid_nummodes", VID_NumModes_f);
-       Cmd_AddCommand ("vid_describecurrentmode", VID_DescribeCurrentMode_f);
-       Cmd_AddCommand ("vid_describemode", VID_DescribeMode_f);
-       Cmd_AddCommand ("vid_describemodes", VID_DescribeModes_f);
+       mouseinitialized = true;
 
-       VID_GetSystemGamma();
+// COMMANDLINEOPTION: Windows Input: -dinput enables DirectInput for mouse/joystick input
+       if (COM_CheckParm ("-dinput"))
+               dinput = IN_InitDInput ();
 
-       hIcon = LoadIcon (global_hInstance, MAKEINTRESOURCE (IDI_ICON2));
+       if (dinput)
+               Con_Print("DirectInput initialized\n");
+       else
+               Con_Print("DirectInput not initialized\n");
 
-       InitCommonControls();
+       mouseparmsvalid = SystemParametersInfo (SPI_GETMOUSE, 0, originalmouseparms, 0);
 
-       VID_InitDIB (global_hInstance);
-       basenummodes = nummodes = 1;
+       if (mouseparmsvalid)
+       {
+// COMMANDLINEOPTION: Windows GDI Input: -noforcemspd disables setting of mouse speed (not used with -dinput, windows only)
+               if ( COM_CheckParm ("-noforcemspd") )
+                       newmouseparms[2] = originalmouseparms[2];
 
-       VID_InitFullDIB (global_hInstance);
+// COMMANDLINEOPTION: Windows GDI Input: -noforcemaccel disables setting of mouse acceleration (not used with -dinput, windows only)
+               if ( COM_CheckParm ("-noforcemaccel") )
+               {
+                       newmouseparms[0] = originalmouseparms[0];
+                       newmouseparms[1] = originalmouseparms[1];
+               }
 
-       if (COM_CheckParm("-window"))
-       {
-               hdc = GetDC (NULL);
+// COMMANDLINEOPTION: Windows GDI Input: -noforcemparms disables setting of mouse parameters (not used with -dinput, windows only)
+               if ( COM_CheckParm ("-noforcemparms") )
+               {
+                       newmouseparms[0] = originalmouseparms[0];
+                       newmouseparms[1] = originalmouseparms[1];
+                       newmouseparms[2] = originalmouseparms[2];
+               }
+       }
 
-               if (GetDeviceCaps(hdc, RASTERCAPS) & RC_PALETTE)
-                       Sys_Error ("Can't run in non-RGB mode");
+       mouse_buttons = 10;
+}
 
-               ReleaseDC (NULL, hdc);
 
-               windowed = true;
+/*
+===========
+IN_MouseMove
+===========
+*/
+static void IN_MouseMove (void)
+{
+       int i, mx, my;
+       POINT current_pos;
 
-               vid_default = MODE_WINDOWED;
-       }
-       else
+       if (!vid_usingmouse)
        {
-               if (nummodes == 1)
-                       Sys_Error ("No RGB fullscreen modes available");
+               //GetCursorPos (&current_pos);
+               //ui_mouseupdate(current_pos.x - window_x, current_pos.y - window_y);
+               return;
+       }
 
-               windowed = false;
+       if (dinput_acquired)
+       {
+               DIDEVICEOBJECTDATA      od;
+               DWORD                           dwElements;
+               HRESULT                         hr;
+               mx = 0;
+               my = 0;
 
-               if (COM_CheckParm("-mode"))
-                       vid_default = atoi(com_argv[COM_CheckParm("-mode")+1]);
-               else
+               for (;;)
                {
-                       if (COM_CheckParm("-current"))
+                       dwElements = 1;
+
+                       hr = IDirectInputDevice_GetDeviceData(g_pMouse,
+                                       sizeof(DIDEVICEOBJECTDATA), &od, &dwElements, 0);
+
+                       if ((hr == DIERR_INPUTLOST) || (hr == DIERR_NOTACQUIRED))
                        {
-                               modelist[MODE_FULLSCREEN_DEFAULT].width = GetSystemMetrics (SM_CXSCREEN);
-                               modelist[MODE_FULLSCREEN_DEFAULT].height = GetSystemMetrics (SM_CYSCREEN);
-                               vid_default = MODE_FULLSCREEN_DEFAULT;
-                               leavecurrentmode = 1;
+                               IDirectInputDevice_Acquire(g_pMouse);
+                               break;
                        }
-                       else
-                       {
-                               if (COM_CheckParm("-width"))
-                                       width = atoi(com_argv[COM_CheckParm("-width")+1]);
-                               else
-                                       width = 640;
 
-                               if (COM_CheckParm("-bpp"))
-                               {
-                                       bpp = atoi(com_argv[COM_CheckParm("-bpp")+1]);
-                                       findbpp = 0;
-                               }
-                               else
-                               {
-                                       bpp = 15;
-                                       findbpp = 1;
-                               }
-
-                               if (COM_CheckParm("-height"))
-                                       height = atoi(com_argv[COM_CheckParm("-height")+1]);
+                       /* Unable to read data or no data available */
+                       if (FAILED(hr) || dwElements == 0)
+                               break;
 
-                       // if they want to force it, add the specified mode to the list
-                               if (COM_CheckParm("-force") && (nummodes < MAX_MODE_LIST))
-                                       VID_AddMode(MS_FULLDIB, width, height, 0, 0, 1, 1, bpp);
-                               /*
-                               {
-                                       modelist[nummodes].type = MS_FULLDIB;
-                                       modelist[nummodes].width = width;
-                                       modelist[nummodes].height = height;
-                                       modelist[nummodes].modenum = 0;
-                                       modelist[nummodes].halfscreen = 0;
-                                       modelist[nummodes].dib = 1;
-                                       modelist[nummodes].fullscreen = 1;
-                                       modelist[nummodes].bpp = bpp;
-                                       sprintf (modelist[nummodes].modedesc, "%dx%dx%d", devmode.dmPelsWidth, devmode.dmPelsHeight, devmode.dmBitsPerPel);
-
-                                       for (i=nummodes, existingmode = 0 ; i<nummodes ; i++)
-                                       {
-                                               if ((modelist[nummodes].width == modelist[i].width) && (modelist[nummodes].height == modelist[i].height) && (modelist[nummodes].bpp == modelist[i].bpp))
-                                               {
-                                                       existingmode = 1;
-                                                       break;
-                                               }
-                                       }
+                       /* Look at the element to see what happened */
 
-                                       if (!existingmode)
-                                               nummodes++;
-                               }
-                               */
+                       switch (od.dwOfs)
+                       {
+                               case DIMOFS_X:
+                                       mx += od.dwData;
+                                       break;
 
-                               done = 0;
+                               case DIMOFS_Y:
+                                       my += od.dwData;
+                                       break;
 
-                               do
-                               {
-                                       if (COM_CheckParm("-height"))
-                                       {
-                                               height = atoi(com_argv[COM_CheckParm("-height")+1]);
-
-                                               for (i=1, vid_default=0 ; i<nummodes ; i++)
-                                               {
-                                                       if ((modelist[i].width == width) && (modelist[i].height == height) && (modelist[i].bpp == bpp))
-                                                       {
-                                                               vid_default = i;
-                                                               done = 1;
-                                                               break;
-                                                       }
-                                               }
-                                       }
+                               case DIMOFS_BUTTON0:
+                                       if (od.dwData & 0x80)
+                                               mstate_di |= 1;
                                        else
-                                       {
-                                               for (i=1, vid_default=0 ; i<nummodes ; i++)
-                                               {
-                                                       if ((modelist[i].width == width) && (modelist[i].bpp == bpp))
-                                                       {
-                                                               vid_default = i;
-                                                               done = 1;
-                                                               break;
-                                                       }
-                                               }
-                                       }
+                                               mstate_di &= ~1;
+                                       break;
 
-                                       if (!done)
-                                       {
-                                               if (findbpp)
-                                               {
-                                                       switch (bpp)
-                                                       {
-                                                       case 15: bpp = 16;break;
-                                                       case 16: bpp = 32;break;
-                                                       case 32: bpp = 24;break;
-                                                       case 24: done = 1;break;
-                                                       }
-                                               }
-                                               else
-                                                       done = 1;
-                                       }
-                               }
-                               while (!done);
+                               case DIMOFS_BUTTON1:
+                                       if (od.dwData & 0x80)
+                                               mstate_di |= (1<<1);
+                                       else
+                                               mstate_di &= ~(1<<1);
+                                       break;
 
-                               if (!vid_default)
-                                       Sys_Error ("Specified video mode not available");
+                               case DIMOFS_BUTTON2:
+                                       if (od.dwData & 0x80)
+                                               mstate_di |= (1<<2);
+                                       else
+                                               mstate_di &= ~(1<<2);
+                                       break;
                        }
                }
-       }
 
-       vid_initialized = true;
+               // perform button actions
+               for (i=0 ; i<mouse_buttons ; i++)
+                       if ((mstate_di ^ mouse_oldbuttonstate) & (1<<i))
+                               Key_Event (K_MOUSE1 + i, 0, (mstate_di & (1<<i)) != 0);
+               mouse_oldbuttonstate = mstate_di;
 
-       if ((i = COM_CheckParm("-conwidth")) != 0)
-               vid.conwidth = atoi(com_argv[i+1]);
+               in_mouse_x = mx;
+               in_mouse_y = my;
+       }
        else
-               vid.conwidth = 640;
+       {
+               GetCursorPos (&current_pos);
+               mx = current_pos.x - (window_x + vid.width / 2);
+               my = current_pos.y - (window_y + vid.height / 2);
 
-       vid.conwidth &= 0xfff8; // make it a multiple of eight
+               in_mouse_x = mx;
+               in_mouse_y = my;
+
+               // if the mouse has moved, force it to the center, so there's room to move
+               if (mx || my)
+                       SetCursorPos ((window_x + vid.width / 2), (window_y + vid.height / 2));
+       }
+}
 
-       if (vid.conwidth < 320)
-               vid.conwidth = 320;
 
-       // pick a conheight that matches with correct aspect
-       vid.conheight = vid.conwidth*3 / 4;
+/*
+===========
+IN_Move
+===========
+*/
+void IN_Move (void)
+{
+       if (vid_activewindow && !vid_hidden)
+       {
+               IN_MouseMove ();
+               IN_JoyMove ();
+       }
+}
 
-       if ((i = COM_CheckParm("-conheight")) != 0)
-               vid.conheight = atoi(com_argv[i+1]);
-       if (vid.conheight < 200)
-               vid.conheight = 200;
 
-       VID_SetMode (vid_default);
+/*
+===============
+IN_StartupJoystick
+===============
+*/
+static void IN_StartupJoystick (void)
+{
+       int                     numdevs;
+       JOYCAPS         jc;
+       MMRESULT        mmr;
+       mmr = 0;
 
-       maindc = GetDC(mainwindow);
-       bSetupPixelFormat(maindc);
+       // assume no joystick
+       joy_avail = false;
 
-       baseRC = wglCreateContext( maindc );
-       if (!baseRC)
-               Sys_Error ("Could not initialize GL (wglCreateContext failed).\n\nMake sure you are in 65536 color mode, and try running -window.");
-       if (!wglMakeCurrent( maindc, baseRC ))
-               Sys_Error ("wglMakeCurrent failed");
+       // abort startup if user requests no joystick
+// COMMANDLINEOPTION: Windows Input: -nojoy disables joystick support, may be a small speed increase
+       if (COM_CheckParm ("-nojoy") || COM_CheckParm("-safe"))
+               return;
 
-       GL_Init ();
+       // verify joystick driver is present
+       if ((numdevs = joyGetNumDevs ()) == 0)
+       {
+               Con_Print("\njoystick not found -- driver not present\n\n");
+               return;
+       }
 
-       // LordHavoc: special differences for ATI (broken 8bit color when also using 32bit? weird!)
-       if (strncasecmp(gl_vendor,"ATI",3)==0)
+       // cycle through the joystick ids for the first valid one
+       for (joy_id=0 ; joy_id<numdevs ; joy_id++)
        {
-               if (strncasecmp(gl_renderer,"Rage Pro",8)==0)
-                       isRagePro = true;
+               memset (&ji, 0, sizeof(ji));
+               ji.dwSize = sizeof(ji);
+               ji.dwFlags = JOY_RETURNCENTERED;
+
+               if ((mmr = joyGetPosEx (joy_id, &ji)) == JOYERR_NOERROR)
+                       break;
+       }
+
+       // abort startup if we didn't find a valid joystick
+       if (mmr != JOYERR_NOERROR)
+       {
+               Con_Printf("\njoystick not found -- no valid joysticks (%x)\n\n", mmr);
+               return;
+       }
+
+       // get the capabilities of the selected joystick
+       // abort startup if command fails
+       memset (&jc, 0, sizeof(jc));
+       if ((mmr = joyGetDevCaps (joy_id, &jc, sizeof(jc))) != JOYERR_NOERROR)
+       {
+               Con_Printf("\njoystick not found -- invalid joystick capabilities (%x)\n\n", mmr);
+               return;
        }
-       if (strncasecmp(gl_renderer,"Matrox G200 Direct3D",20)==0) // a D3D driver for GL? sigh...
-               isG200 = true;
 
-//     sprintf (gldir, "%s/glquake", com_gamedir);
-//     Sys_mkdir (gldir);
+       // save the joystick's number of buttons and POV status
+       joy_numbuttons = jc.wNumButtons;
+       joy_haspov = jc.wCaps & JOYCAPS_HASPOV;
 
-       vid_realmode = vid_modenum;
+       // old button and POV states default to no buttons pressed
+       joy_oldbuttonstate = joy_oldpovstate = 0;
 
-       vid_menudrawfn = VID_MenuDraw;
-       vid_menukeyfn = VID_MenuKey;
+       // mark the joystick as available and advanced initialization not completed
+       // this is needed as cvars are not available during initialization
 
-       strcpy (badmode.modedesc, "Bad mode");
-       vid_canalttab = true;
-}
+       joy_avail = true;
+       joy_advancedinit = false;
 
+       Con_Print("\njoystick detected\n\n");
+}
 
-//========================================================
-// Video menu stuff
-//========================================================
 
-extern void M_Menu_Options_f (void);
-extern void M_Print (int cx, int cy, char *str);
-extern void M_PrintWhite (int cx, int cy, char *str);
-extern void M_DrawCharacter (int cx, int line, int num);
-extern void M_DrawPic (int x, int y, char *picname);
+/*
+===========
+RawValuePointer
+===========
+*/
+static PDWORD RawValuePointer (int axis)
+{
+       switch (axis)
+       {
+       case JOY_AXIS_X:
+               return &ji.dwXpos;
+       case JOY_AXIS_Y:
+               return &ji.dwYpos;
+       case JOY_AXIS_Z:
+               return &ji.dwZpos;
+       case JOY_AXIS_R:
+               return &ji.dwRpos;
+       case JOY_AXIS_U:
+               return &ji.dwUpos;
+       case JOY_AXIS_V:
+               return &ji.dwVpos;
+       }
+       return NULL; // LordHavoc: hush compiler warning
+}
 
-static int     vid_line, vid_wmodes;
 
-typedef struct
+/*
+===========
+Joy_AdvancedUpdate_f
+===========
+*/
+static void Joy_AdvancedUpdate_f (void)
 {
-       int             modenum;
-       char    *desc;
-       int             iscur;
-} modedesc_t;
 
-#define MAX_COLUMN_SIZE                9
-#define MODE_AREA_HEIGHT       (MAX_COLUMN_SIZE + 2)
-#define MAX_MODEDESCS          (MAX_COLUMN_SIZE*3)
+       // called once by IN_ReadJoystick and by user whenever an update is needed
+       // cvars are now available
+       int     i;
+       DWORD dwTemp;
+
+       // initialize all the maps
+       for (i = 0; i < JOY_MAX_AXES; i++)
+       {
+               dwAxisMap[i] = AxisNada;
+               dwControlMap[i] = JOY_ABSOLUTE_AXIS;
+               pdwRawValue[i] = RawValuePointer(i);
+       }
+
+       if( joy_advanced.integer == 0)
+       {
+               // default joystick initialization
+               // 2 axes only with joystick control
+               dwAxisMap[JOY_AXIS_X] = AxisTurn;
+               // dwControlMap[JOY_AXIS_X] = JOY_ABSOLUTE_AXIS;
+               dwAxisMap[JOY_AXIS_Y] = AxisForward;
+               // dwControlMap[JOY_AXIS_Y] = JOY_ABSOLUTE_AXIS;
+       }
+       else
+       {
+               if (strcmp (joy_name.string, "joystick") != 0)
+               {
+                       // notify user of advanced controller
+                       Con_Printf("\n%s configured\n\n", joy_name.string);
+               }
+
+               // advanced initialization here
+               // data supplied by user via joy_axisn cvars
+               dwTemp = (DWORD) joy_advaxisx.value;
+               dwAxisMap[JOY_AXIS_X] = dwTemp & 0x0000000f;
+               dwControlMap[JOY_AXIS_X] = dwTemp & JOY_RELATIVE_AXIS;
+               dwTemp = (DWORD) joy_advaxisy.value;
+               dwAxisMap[JOY_AXIS_Y] = dwTemp & 0x0000000f;
+               dwControlMap[JOY_AXIS_Y] = dwTemp & JOY_RELATIVE_AXIS;
+               dwTemp = (DWORD) joy_advaxisz.value;
+               dwAxisMap[JOY_AXIS_Z] = dwTemp & 0x0000000f;
+               dwControlMap[JOY_AXIS_Z] = dwTemp & JOY_RELATIVE_AXIS;
+               dwTemp = (DWORD) joy_advaxisr.value;
+               dwAxisMap[JOY_AXIS_R] = dwTemp & 0x0000000f;
+               dwControlMap[JOY_AXIS_R] = dwTemp & JOY_RELATIVE_AXIS;
+               dwTemp = (DWORD) joy_advaxisu.value;
+               dwAxisMap[JOY_AXIS_U] = dwTemp & 0x0000000f;
+               dwControlMap[JOY_AXIS_U] = dwTemp & JOY_RELATIVE_AXIS;
+               dwTemp = (DWORD) joy_advaxisv.value;
+               dwAxisMap[JOY_AXIS_V] = dwTemp & 0x0000000f;
+               dwControlMap[JOY_AXIS_V] = dwTemp & JOY_RELATIVE_AXIS;
+       }
 
-static modedesc_t      modedescs[MAX_MODEDESCS];
+       // compute the axes to collect from DirectInput
+       joy_flags = JOY_RETURNCENTERED | JOY_RETURNBUTTONS | JOY_RETURNPOV;
+       for (i = 0; i < JOY_MAX_AXES; i++)
+       {
+               if (dwAxisMap[i] != AxisNada)
+               {
+                       joy_flags |= dwAxisFlags[i];
+               }
+       }
+}
 
 /*
-================
-VID_MenuDraw
-================
+===============
+IN_ReadJoystick
+===============
 */
-void VID_MenuDraw (void)
+static qboolean IN_ReadJoystick (void)
 {
-       cachepic_t *p;
-       char *ptr;
-       int lnummodes, i, k, column, row;
-       vmode_t *pv;
 
-       p = Draw_CachePic ("gfx/vidmodes.lmp");
-       M_DrawPic ( (320-p->width)/2, 4, "gfx/vidmodes.lmp");
+       memset (&ji, 0, sizeof(ji));
+       ji.dwSize = sizeof(ji);
+       ji.dwFlags = joy_flags;
+
+       if (joyGetPosEx (joy_id, &ji) == JOYERR_NOERROR)
+       {
+               // this is a hack -- there is a bug in the Logitech WingMan Warrior DirectInput Driver
+               // rather than having 32768 be the zero point, they have the zero point at 32668
+               // go figure -- anyway, now we get the full resolution out of the device
+               if (joy_wwhack1.integer != 0.0)
+               {
+                       ji.dwUpos += 100;
+               }
+               return true;
+       }
+       else
+       {
+               // read error occurred
+               // turning off the joystick seems too harsh for 1 read error,
+               // but what should be done?
+               return false;
+       }
+}
+
+
+/*
+===========
+IN_JoyMove
+===========
+*/
+static void IN_JoyMove (void)
+{
+       float   speed, aspeed;
+       float   fAxisValue, fTemp;
+       int             i, mouselook = (in_mlook.state & 1) || freelook.integer;
 
-       vid_wmodes = 0;
-       lnummodes = VID_NumModes ();
+       // complete initialization if first time in
+       // this is needed as cvars are not available at initialization time
+       if( joy_advancedinit != true )
+       {
+               Joy_AdvancedUpdate_f();
+               joy_advancedinit = true;
+       }
 
-       for (i=1 ; (i<lnummodes) && (vid_wmodes < MAX_MODEDESCS) ; i++)
+       if (joy_avail)
        {
-               ptr = VID_GetModeDescription (i);
-               pv = VID_GetModePtr (i);
+               int             i, key_index;
+               DWORD   buttonstate, povstate;
+
+               // loop through the joystick buttons
+               // key a joystick event or auxillary event for higher number buttons for each state change
+               buttonstate = ji.dwButtons;
+               for (i=0 ; i < (int) joy_numbuttons ; i++)
+               {
+                       if ( (buttonstate & (1<<i)) && !(joy_oldbuttonstate & (1<<i)) )
+                       {
+                               key_index = (i < 16) ? K_JOY1 : K_AUX1;
+                               Key_Event (key_index + i, 0, true);
+                       }
 
-               k = vid_wmodes;
+                       if ( !(buttonstate & (1<<i)) && (joy_oldbuttonstate & (1<<i)) )
+                       {
+                               key_index = (i < 16) ? K_JOY1 : K_AUX1;
+                               Key_Event (key_index + i, 0, false);
+                       }
+               }
+               joy_oldbuttonstate = buttonstate;
 
-               modedescs[k].modenum = i;
-               modedescs[k].desc = ptr;
-               modedescs[k].iscur = 0;
+               if (joy_haspov)
+               {
+                       // convert POV information into 4 bits of state information
+                       // this avoids any potential problems related to moving from one
+                       // direction to another without going through the center position
+                       povstate = 0;
+                       if(ji.dwPOV != JOY_POVCENTERED)
+                       {
+                               if (ji.dwPOV == JOY_POVFORWARD)
+                                       povstate |= 0x01;
+                               if (ji.dwPOV == JOY_POVRIGHT)
+                                       povstate |= 0x02;
+                               if (ji.dwPOV == JOY_POVBACKWARD)
+                                       povstate |= 0x04;
+                               if (ji.dwPOV == JOY_POVLEFT)
+                                       povstate |= 0x08;
+                       }
+                       // determine which bits have changed and key an auxillary event for each change
+                       for (i=0 ; i < 4 ; i++)
+                       {
+                               if ( (povstate & (1<<i)) && !(joy_oldpovstate & (1<<i)) )
+                               {
+                                       Key_Event (K_AUX29 + i, 0, true);
+                               }
 
-               if (i == vid_modenum)
-                       modedescs[k].iscur = 1;
+                               if ( !(povstate & (1<<i)) && (joy_oldpovstate & (1<<i)) )
+                               {
+                                       Key_Event (K_AUX29 + i, 0, false);
+                               }
+                       }
+                       joy_oldpovstate = povstate;
+               }
+       }
 
-               vid_wmodes++;
+       // verify joystick is available and that the user wants to use it
+       if (!joy_avail || !in_joystick.integer)
+       {
+               return;
+       }
 
+       // collect the joystick data, if possible
+       if (IN_ReadJoystick () != true)
+       {
+               return;
        }
 
-       if (vid_wmodes > 0)
+       if (in_speed.state & 1)
+               speed = cl_movespeedkey.value;
+       else
+               speed = 1;
+       // LordHavoc: viewzoom affects sensitivity for sniping
+       aspeed = speed * host_realframetime * cl.viewzoom;
+
+       // loop through the axes
+       for (i = 0; i < JOY_MAX_AXES; i++)
        {
-               M_Print (2*8, 36+0*8, "Fullscreen Modes (WIDTHxHEIGHTxBPP)");
+               // get the floating point zero-centered, potentially-inverted data for the current axis
+               fAxisValue = (float) *pdwRawValue[i];
+               // move centerpoint to zero
+               fAxisValue -= 32768.0;
+
+               if (joy_wwhack2.integer != 0.0)
+               {
+                       if (dwAxisMap[i] == AxisTurn)
+                       {
+                               // this is a special formula for the Logitech WingMan Warrior
+                               // y=ax^b; where a = 300 and b = 1.3
+                               // also x values are in increments of 800 (so this is factored out)
+                               // then bounds check result to level out excessively high spin rates
+                               fTemp = 300.0 * pow(abs(fAxisValue) / 800.0, 1.3);
+                               if (fTemp > 14000.0)
+                                       fTemp = 14000.0;
+                               // restore direction information
+                               fAxisValue = (fAxisValue > 0.0) ? fTemp : -fTemp;
+                       }
+               }
 
-               column = 8;
-               row = 36+2*8;
+               // convert range from -32768..32767 to -1..1
+               fAxisValue /= 32768.0;
 
-               for (i=0 ; i<vid_wmodes ; i++)
+               switch (dwAxisMap[i])
                {
-                       if (modedescs[i].iscur)
-                               M_PrintWhite (column, row, modedescs[i].desc);
+               case AxisForward:
+                       if ((joy_advanced.integer == 0) && mouselook)
+                       {
+                               // user wants forward control to become look control
+                               if (fabs(fAxisValue) > joy_pitchthreshold.value)
+                               {
+                                       // if mouse invert is on, invert the joystick pitch value
+                                       // only absolute control support here (joy_advanced is false)
+                                       if (m_pitch.value < 0.0)
+                                       {
+                                               cl.viewangles[PITCH] -= (fAxisValue * joy_pitchsensitivity.value) * aspeed * cl_pitchspeed.value;
+                                       }
+                                       else
+                                       {
+                                               cl.viewangles[PITCH] += (fAxisValue * joy_pitchsensitivity.value) * aspeed * cl_pitchspeed.value;
+                                       }
+                                       V_StopPitchDrift();
+                               }
+                               else
+                               {
+                                       // no pitch movement
+                                       // disable pitch return-to-center unless requested by user
+                                       // *** this code can be removed when the lookspring bug is fixed
+                                       // *** the bug always has the lookspring feature on
+                                       if(lookspring.value == 0.0)
+                                               V_StopPitchDrift();
+                               }
+                       }
+                       else
+                       {
+                               // user wants forward control to be forward control
+                               if (fabs(fAxisValue) > joy_forwardthreshold.value)
+                               {
+                                       cl.cmd.forwardmove += (fAxisValue * joy_forwardsensitivity.value) * speed * cl_forwardspeed.value;
+                               }
+                       }
+                       break;
+
+               case AxisSide:
+                       if (fabs(fAxisValue) > joy_sidethreshold.value)
+                       {
+                               cl.cmd.sidemove += (fAxisValue * joy_sidesensitivity.value) * speed * cl_sidespeed.value;
+                       }
+                       break;
+
+               case AxisTurn:
+                       if ((in_strafe.state & 1) || (lookstrafe.integer && mouselook))
+                       {
+                               // user wants turn control to become side control
+                               if (fabs(fAxisValue) > joy_sidethreshold.value)
+                               {
+                                       cl.cmd.sidemove -= (fAxisValue * joy_sidesensitivity.value) * speed * cl_sidespeed.value;
+                               }
+                       }
                        else
-                               M_Print (column, row, modedescs[i].desc);
+                       {
+                               // user wants turn control to be turn control
+                               if (fabs(fAxisValue) > joy_yawthreshold.value)
+                               {
+                                       if(dwControlMap[i] == JOY_ABSOLUTE_AXIS)
+                                       {
+                                               cl.viewangles[YAW] += (fAxisValue * joy_yawsensitivity.value) * aspeed * cl_yawspeed.value;
+                                       }
+                                       else
+                                       {
+                                               cl.viewangles[YAW] += (fAxisValue * joy_yawsensitivity.value) * speed * 180.0;
+                                       }
 
-                       column += 13*8;
+                               }
+                       }
+                       break;
 
-                       if ((i % VID_ROW_SIZE) == (VID_ROW_SIZE - 1))
+               case AxisLook:
+                       if (mouselook)
                        {
-                               column = 8;
-                               row += 8;
+                               if (fabs(fAxisValue) > joy_pitchthreshold.value)
+                               {
+                                       // pitch movement detected and pitch movement desired by user
+                                       if(dwControlMap[i] == JOY_ABSOLUTE_AXIS)
+                                       {
+                                               cl.viewangles[PITCH] += (fAxisValue * joy_pitchsensitivity.value) * aspeed * cl_pitchspeed.value;
+                                       }
+                                       else
+                                       {
+                                               cl.viewangles[PITCH] += (fAxisValue * joy_pitchsensitivity.value) * speed * 180.0;
+                                       }
+                                       V_StopPitchDrift();
+                               }
+                               else
+                               {
+                                       // no pitch movement
+                                       // disable pitch return-to-center unless requested by user
+                                       // *** this code can be removed when the lookspring bug is fixed
+                                       // *** the bug always has the lookspring feature on
+                                       if(lookspring.integer == 0)
+                                               V_StopPitchDrift();
+                               }
                        }
+                       break;
+
+               default:
+                       break;
                }
        }
-
-       M_Print (3*8, 36 + MODE_AREA_HEIGHT * 8 + 8*2, "Video modes must be set from the");
-       M_Print (3*8, 36 + MODE_AREA_HEIGHT * 8 + 8*3, "command line with -width <width>");
-       M_Print (3*8, 36 + MODE_AREA_HEIGHT * 8 + 8*4, "and -bpp <bits-per-pixel>");
-       M_Print (3*8, 36 + MODE_AREA_HEIGHT * 8 + 8*6, "Select windowed mode with -window");
 }
 
+static void IN_Init(void)
+{
+       uiWheelMessage = RegisterWindowMessage ( "MSWHEEL_ROLLMSG" );
+
+       // joystick variables
+       Cvar_RegisterVariable (&in_joystick);
+       Cvar_RegisterVariable (&joy_name);
+       Cvar_RegisterVariable (&joy_advanced);
+       Cvar_RegisterVariable (&joy_advaxisx);
+       Cvar_RegisterVariable (&joy_advaxisy);
+       Cvar_RegisterVariable (&joy_advaxisz);
+       Cvar_RegisterVariable (&joy_advaxisr);
+       Cvar_RegisterVariable (&joy_advaxisu);
+       Cvar_RegisterVariable (&joy_advaxisv);
+       Cvar_RegisterVariable (&joy_forwardthreshold);
+       Cvar_RegisterVariable (&joy_sidethreshold);
+       Cvar_RegisterVariable (&joy_pitchthreshold);
+       Cvar_RegisterVariable (&joy_yawthreshold);
+       Cvar_RegisterVariable (&joy_forwardsensitivity);
+       Cvar_RegisterVariable (&joy_sidesensitivity);
+       Cvar_RegisterVariable (&joy_pitchsensitivity);
+       Cvar_RegisterVariable (&joy_yawsensitivity);
+       Cvar_RegisterVariable (&joy_wwhack1);
+       Cvar_RegisterVariable (&joy_wwhack2);
+       Cmd_AddCommand ("joyadvancedupdate", Joy_AdvancedUpdate_f);
+}
 
-/*
-================
-VID_MenuKey
-================
-*/
-void VID_MenuKey (int key)
+static void IN_Shutdown(void)
 {
-       switch (key)
-       {
-       case K_ESCAPE:
-               S_LocalSound ("misc/menu1.wav");
-               M_Menu_Options_f ();
-               break;
+       IN_Activate (false);
 
-       default:
-               break;
-       }
+       if (g_pMouse)
+               IDirectInputDevice_Release(g_pMouse);
+       g_pMouse = NULL;
+
+       if (g_pdi)
+               IDirectInput_Release(g_pdi);
+       g_pdi = NULL;
 }