Quake!

This ports id Software's Quake to run on the SDL plugin runtime. The
source code originated from id under the GPLv2 license. I used
https://github.com/ahefner/sdlquake as the base of my port.

Performance is, unsurprisingly, not on par with what you're probably
used to on PC. I average about 10FPS on ipod6g, but it's still
playable.

Sound works well enough, but in-game music is not supported. I've
written ARM assembly routines for the inner sound loop. Make sure you
turn the "brightness" all the way down, or colors will look funky.

To run, extract Quake's data files to /.rockbox/quake. Have fun!

Change-Id: I4285036e967d7f0722802d43cf2096c808ca5799

1 files changed, 866 insertions, 0 deletions

diff --git a/apps/plugins/sdl/progs/quake/gl_vidlinux.c b/apps/plugins/sdl/progs/quake/gl_vidlinux.c
new file mode 100644
index 0000000000..c29f0423a3
--- /dev/null
+++ b/apps/plugins/sdl/progs/quake/gl_vidlinux.c
@@ -0,0 +1,866 @@
+/*
+Copyright (C) 1996-1997 Id Software, Inc.
+
+This program is free software; you can redistribute it and/or
+modify it under the terms of the GNU General Public License
+as published by the Free Software Foundation; either version 2
+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.  
+
+See the GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+
+*/
+#include <termios.h>
+#include <sys/ioctl.h>
+#include <sys/stat.h>
+#include <sys/vt.h>
+#include <stdarg.h>
+#include <stdio.h>
+#include <signal.h>
+
+#include <asm/io.h>
+#include <dlfcn.h>
+
+/*#include "vga.h" */
+#include "vgakeyboard.h"
+#include "vgamouse.h"
+
+#include "quakedef.h"
+#include "GL/fxmesa.h"
+
+#define WARP_WIDTH              320
+#define WARP_HEIGHT             200
+
+static fxMesaContext fc = NULL;
+#define stringify(m) { #m, m }
+
+unsigned short  d_8to16table[256];
+unsigned        d_8to24table[256];
+unsigned char d_15to8table[65536];
+
+int num_shades=32;
+
+struct
+{
+        char *name;
+        int num;
+} mice[] =
+{
+        stringify(MOUSE_MICROSOFT),
+        stringify(MOUSE_MOUSESYSTEMS),
+        stringify(MOUSE_MMSERIES),
+        stringify(MOUSE_LOGITECH),
+        stringify(MOUSE_BUSMOUSE),
+        stringify(MOUSE_PS2),
+};
+
+static unsigned char scantokey[128];
+
+int num_mice = sizeof (mice) / sizeof(mice[0]);
+
+int     d_con_indirect = 0;
+
+int             svgalib_inited=0;
+int             UseMouse = 1;
+int             UseKeyboard = 1;
+
+int             mouserate = MOUSE_DEFAULTSAMPLERATE;
+
+cvar_t          vid_mode = {"vid_mode","5",false};
+cvar_t          vid_redrawfull = {"vid_redrawfull","0",false};
+cvar_t          vid_waitforrefresh = {"vid_waitforrefresh","0",true};
+ 
+char    *framebuffer_ptr;
+
+cvar_t  mouse_button_commands[3] =
+{
+    {"mouse1","+attack"},
+    {"mouse2","+strafe"},
+    {"mouse3","+forward"},
+};
+
+int     mouse_buttons;
+int     mouse_buttonstate;
+int     mouse_oldbuttonstate;
+float   mouse_x, mouse_y;
+float   old_mouse_x, old_mouse_y;
+int             mx, my;
+
+cvar_t  m_filter = {"m_filter","1"};
+
+int scr_width, scr_height;
+
+/*-----------------------------------------------------------------------*/
+
+//int           texture_mode = GL_NEAREST;
+//int           texture_mode = GL_NEAREST_MIPMAP_NEAREST;
+//int           texture_mode = GL_NEAREST_MIPMAP_LINEAR;
+int             texture_mode = GL_LINEAR;
+//int           texture_mode = GL_LINEAR_MIPMAP_NEAREST;
+//int           texture_mode = GL_LINEAR_MIPMAP_LINEAR;
+
+int             texture_extension_number = 1;
+
+float           gldepthmin, gldepthmax;
+
+cvar_t  gl_ztrick = {"gl_ztrick","1"};
+
+const char *gl_vendor;
+const char *gl_renderer;
+const char *gl_version;
+const char *gl_extensions;
+
+void (*qgl3DfxSetPaletteEXT) (GLuint *);
+void (*qglColorTableEXT) (int, int, int, int, int, const void *);
+
+static float vid_gamma = 1.0;
+
+qboolean is8bit = false;
+qboolean isPermedia = false;
+qboolean gl_mtexable = false;
+
+/*-----------------------------------------------------------------------*/
+void D_BeginDirectRect (int x, int y, byte *pbitmap, int width, int height)
+{
+}
+
+void D_EndDirectRect (int x, int y, int width, int height)
+{
+}
+
+int matchmouse(int mouse, char *name)
+{
+        int i;
+        for (i=0 ; i<num_mice ; i++)
+                if (!strcmp(mice[i].name, name))
+                        return i;
+        return mouse;
+}
+
+#if 0
+
+void vtswitch(int newconsole)
+{
+
+        int fd;
+        struct vt_stat x;
+
+// switch consoles and wait until reactivated
+        fd = open("/dev/console", O_RDONLY);
+        ioctl(fd, VT_GETSTATE, &x);
+        ioctl(fd, VT_ACTIVATE, newconsole);
+        ioctl(fd, VT_WAITACTIVE, x.v_active);
+        close(fd);
+
+}
+
+#endif
+
+void keyhandler(int scancode, int state)
+{
+        
+        int sc;
+
+        sc = scancode & 0x7f;
+
+        Key_Event(scantokey[sc], state == KEY_EVENTPRESS);
+
+}
+
+void VID_Shutdown(void)
+{
+        if (!fc)
+                return;
+
+        fxMesaDestroyContext(fc);
+
+        if (UseKeyboard)
+                keyboard_close();
+}
+
+void signal_handler(int sig)
+{
+        printf("Received signal %d, exiting...\n", sig);
+        Sys_Quit();
+        exit(0);
+}
+
+void InitSig(void)
+{
+        signal(SIGHUP, signal_handler);
+        signal(SIGINT, signal_handler);
+        signal(SIGQUIT, signal_handler);
+        signal(SIGILL, signal_handler);
+        signal(SIGTRAP, signal_handler);
+        signal(SIGIOT, signal_handler);
+        signal(SIGBUS, signal_handler);
+        signal(SIGFPE, signal_handler);
+        signal(SIGSEGV, signal_handler);
+        signal(SIGTERM, signal_handler);
+}
+
+void VID_ShiftPalette(unsigned char *p)
+{
+//      VID_SetPalette(p);
+}
+
+void    VID_SetPalette (unsigned char *palette)
+{
+        byte    *pal;
+        unsigned r,g,b;
+        unsigned v;
+        int     r1,g1,b1;
+        int             j,k,l,m;
+        unsigned short i;
+        unsigned        *table;
+        FILE *f;
+        char s[255];
+        int dist, bestdist;
+        static qboolean palflag = false;
+
+//
+// 8 8 8 encoding
+//
+        pal = palette;
+        table = d_8to24table;
+        for (i=0 ; i<256 ; i++)
+        {
+                r = pal[0];
+                g = pal[1];
+                b = pal[2];
+                pal += 3;
+                
+                v = (255<<24) + (r<<0) + (g<<8) + (b<<16);
+                *table++ = v;
+        }
+        d_8to24table[255] &= 0xffffff;  // 255 is transparent
+
+        // JACK: 3D distance calcs - k is last closest, l is the distance.
+        for (i=0; i < (1<<15); i++) {
+                /* Maps
+                000000000000000
+                000000000011111 = Red  = 0x1F
+                000001111100000 = Blue = 0x03E0
+                111110000000000 = Grn  = 0x7C00
+                */
+                r = ((i & 0x1F) << 3)+4;
+                g = ((i & 0x03E0) >> 2)+4;
+                b = ((i & 0x7C00) >> 7)+4;
+                pal = (unsigned char *)d_8to24table;
+                for (v=0,k=0,bestdist=10000*10000; v<256; v++,pal+=4) {
+                        r1 = (int)r - (int)pal[0];
+                        g1 = (int)g - (int)pal[1];
+                        b1 = (int)b - (int)pal[2];
+                        dist = (r1*r1)+(g1*g1)+(b1*b1);
+                        if (dist < bestdist) {
+                                k=v;
+                                bestdist = dist;
+                        }
+                }
+                d_15to8table[i]=k;
+        }
+}
+
+void CheckMultiTextureExtensions(void) 
+{
+        void *prjobj;
+
+        if (strstr(gl_extensions, "GL_SGIS_multitexture ") && !COM_CheckParm("-nomtex")) {
+                Con_Printf("Found GL_SGIS_multitexture...\n");
+
+                if ((prjobj = dlopen(NULL, RTLD_LAZY)) == NULL) {
+                        Con_Printf("Unable to open symbol list for main program.\n");
+                        return;
+                }
+
+                qglMTexCoord2fSGIS = (void *) dlsym(prjobj, "glMTexCoord2fSGIS");
+                qglSelectTextureSGIS = (void *) dlsym(prjobj, "glSelectTextureSGIS");
+
+                if (qglMTexCoord2fSGIS && qglSelectTextureSGIS) {
+                        Con_Printf("Multitexture extensions found.\n");
+                        gl_mtexable = true;
+                } else
+                        Con_Printf("Symbol not found, disabled.\n");
+
+                dlclose(prjobj);
+        }
+}
+
+/*
+===============
+GL_Init
+===============
+*/
+void GL_Init (void)
+{
+        gl_vendor = glGetString (GL_VENDOR);
+        Con_Printf ("GL_VENDOR: %s\n", gl_vendor);
+        gl_renderer = glGetString (GL_RENDERER);
+        Con_Printf ("GL_RENDERER: %s\n", gl_renderer);
+
+        gl_version = glGetString (GL_VERSION);
+        Con_Printf ("GL_VERSION: %s\n", gl_version);
+        gl_extensions = glGetString (GL_EXTENSIONS);
+        Con_Printf ("GL_EXTENSIONS: %s\n", gl_extensions);
+
+//      Con_Printf ("%s %s\n", gl_renderer, gl_version);
+
+        CheckMultiTextureExtensions ();
+
+        glClearColor (1,0,0,0);
+        glCullFace(GL_FRONT);
+        glEnable(GL_TEXTURE_2D);
+
+        glEnable(GL_ALPHA_TEST);
+        glAlphaFunc(GL_GREATER, 0.666);
+
+        glPolygonMode (GL_FRONT_AND_BACK, GL_FILL);
+        glShadeModel (GL_FLAT);
+
+        glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+        glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+        glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
+        glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
+
+        glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+
+//      glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
+        glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
+}
+
+/*
+=================
+GL_BeginRendering
+
+=================
+*/
+void GL_BeginRendering (int *x, int *y, int *width, int *height)
+{
+        extern cvar_t gl_clear;
+
+        *x = *y = 0;
+        *width = scr_width;
+        *height = scr_height;
+
+//    if (!wglMakeCurrent( maindc, baseRC ))
+//              Sys_Error ("wglMakeCurrent failed");
+
+//      glViewport (*x, *y, *width, *height);
+}
+
+
+void GL_EndRendering (void)
+{
+        glFlush();
+        fxMesaSwapBuffers();
+}
+
+void Init_KBD(void)
+{
+        int i;
+
+        if (COM_CheckParm("-nokbd")) UseKeyboard = 0;
+
+        if (UseKeyboard)
+        {
+                for (i=0 ; i<128 ; i++)
+                        scantokey[i] = ' ';
+
+                scantokey[42] = K_SHIFT;
+                scantokey[54] = K_SHIFT;
+                scantokey[72] = K_UPARROW;
+                scantokey[103] = K_UPARROW;
+                scantokey[80] = K_DOWNARROW;
+                scantokey[108] = K_DOWNARROW;
+                scantokey[75] = K_LEFTARROW;
+                scantokey[105] = K_LEFTARROW;
+                scantokey[77] = K_RIGHTARROW;
+                scantokey[106] = K_RIGHTARROW;
+                scantokey[29] = K_CTRL;
+                scantokey[97] = K_CTRL;
+                scantokey[56] = K_ALT;
+                scantokey[100] = K_ALT;
+//              scantokey[58] = JK_CAPS;
+//              scantokey[69] = JK_NUM_LOCK;
+                scantokey[71] = K_HOME;
+                scantokey[73] = K_PGUP;
+                scantokey[79] = K_END;
+                scantokey[81] = K_PGDN;
+                scantokey[82] = K_INS;
+                scantokey[83] = K_DEL;
+                scantokey[1 ] = K_ESCAPE;
+                scantokey[28] = K_ENTER;
+                scantokey[15] = K_TAB;
+                scantokey[14] = K_BACKSPACE;
+                scantokey[119] = K_PAUSE;
+                scantokey[57] = ' ';
+
+                scantokey[102] = K_HOME;
+                scantokey[104] = K_PGUP;
+                scantokey[107] = K_END;
+                scantokey[109] = K_PGDN;
+                scantokey[110] = K_INS;
+                scantokey[111] = K_DEL;
+
+                scantokey[2] = '1';
+                scantokey[3] = '2';
+                scantokey[4] = '3';
+                scantokey[5] = '4';
+                scantokey[6] = '5';
+                scantokey[7] = '6';
+                scantokey[8] = '7';
+                scantokey[9] = '8';
+                scantokey[10] = '9';
+                scantokey[11] = '0';
+                scantokey[12] = '-';
+                scantokey[13] = '=';
+                scantokey[41] = '`';
+                scantokey[26] = '[';
+                scantokey[27] = ']';
+                scantokey[39] = ';';
+                scantokey[40] = '\'';
+                scantokey[51] = ',';
+                scantokey[52] = '.';
+                scantokey[53] = '/';
+                scantokey[43] = '\\';
+
+                scantokey[59] = K_F1;
+                scantokey[60] = K_F2;
+                scantokey[61] = K_F3;
+                scantokey[62] = K_F4;
+                scantokey[63] = K_F5;
+                scantokey[64] = K_F6;
+                scantokey[65] = K_F7;
+                scantokey[66] = K_F8;
+                scantokey[67] = K_F9;
+                scantokey[68] = K_F10;
+                scantokey[87] = K_F11;
+                scantokey[88] = K_F12;
+                scantokey[30] = 'a';
+                scantokey[48] = 'b';
+                scantokey[46] = 'c';
+                scantokey[32] = 'd';       
+                scantokey[18] = 'e';       
+                scantokey[33] = 'f';       
+                scantokey[34] = 'g';       
+                scantokey[35] = 'h';       
+                scantokey[23] = 'i';       
+                scantokey[36] = 'j';       
+                scantokey[37] = 'k';       
+                scantokey[38] = 'l';       
+                scantokey[50] = 'm';       
+                scantokey[49] = 'n';       
+                scantokey[24] = 'o';       
+                scantokey[25] = 'p';       
+                scantokey[16] = 'q';       
+                scantokey[19] = 'r';       
+                scantokey[31] = 's';       
+                scantokey[20] = 't';       
+                scantokey[22] = 'u';       
+                scantokey[47] = 'v';       
+                scantokey[17] = 'w';       
+                scantokey[45] = 'x';       
+                scantokey[21] = 'y';       
+                scantokey[44] = 'z';       
+
+                scantokey[78] = '+';
+                scantokey[74] = '-';
+
+                if (keyboard_init())
+                        Sys_Error("keyboard_init() failed");
+                keyboard_seteventhandler(keyhandler);
+        }
+}
+
+#define NUM_RESOLUTIONS 16
+
+static int resolutions[NUM_RESOLUTIONS][3]={ 
+        320,200,  GR_RESOLUTION_320x200,
+        320,240,  GR_RESOLUTION_320x240,
+        400,256,  GR_RESOLUTION_400x256,
+        400,300,  GR_RESOLUTION_400x300,
+        512,384,  GR_RESOLUTION_512x384,
+        640,200,  GR_RESOLUTION_640x200,
+        640,350,  GR_RESOLUTION_640x350,
+        640,400,  GR_RESOLUTION_640x400,
+        640,480,  GR_RESOLUTION_640x480,
+        800,600,  GR_RESOLUTION_800x600,
+        960,720,  GR_RESOLUTION_960x720,
+        856,480,  GR_RESOLUTION_856x480,
+        512,256,  GR_RESOLUTION_512x256,
+        1024,768, GR_RESOLUTION_1024x768,
+        1280,1024,GR_RESOLUTION_1280x1024,
+        1600,1200,GR_RESOLUTION_1600x1200
+};
+
+int findres(int *width, int *height)
+{
+        int i;
+
+        for(i=0;i<NUM_RESOLUTIONS;i++)
+                if((*width<=resolutions[i][0]) && (*height<=resolutions[i][1])) {
+                        *width = resolutions[i][0];
+                        *height = resolutions[i][1];
+                        return resolutions[i][2];
+                }
+        
+        *width = 640;
+        *height = 480;
+        return GR_RESOLUTION_640x480;
+}
+
+qboolean VID_Is8bit(void)
+{
+        return is8bit;
+}
+
+void VID_Init8bitPalette(void) 
+{
+        // Check for 8bit Extensions and initialize them.
+        int i;
+        void *prjobj;
+
+        if (COM_CheckParm("-no8bit"))
+                return;
+
+        if ((prjobj = dlopen(NULL, RTLD_LAZY)) == NULL) {
+                Con_Printf("Unable to open symbol list for main program.\n");
+                return;
+        }
+
+        if (strstr(gl_extensions, "3DFX_set_global_palette") &&
+                (qgl3DfxSetPaletteEXT = dlsym(prjobj, "gl3DfxSetPaletteEXT")) != NULL) {
+                GLubyte table[256][4];
+                char *oldpal;
+
+                Con_SafePrintf("... Using 3DFX_set_global_palette\n");
+                glEnable( GL_SHARED_TEXTURE_PALETTE_EXT );
+                oldpal = (char *) d_8to24table; //d_8to24table3dfx;
+                for (i=0;i<256;i++) {
+                        table[i][2] = *oldpal++;
+                        table[i][1] = *oldpal++;
+                        table[i][0] = *oldpal++;
+                        table[i][3] = 255;
+                        oldpal++;
+                }
+                qgl3DfxSetPaletteEXT((GLuint *)table);
+                is8bit = true;
+
+        } else if (strstr(gl_extensions, "GL_EXT_shared_texture_palette") &&
+                (qglColorTableEXT = dlsym(prjobj, "glColorTableEXT")) != NULL) {
+                char thePalette[256*3];
+                char *oldPalette, *newPalette;
+
+                Con_SafePrintf("... Using GL_EXT_shared_texture_palette\n");
+                glEnable( GL_SHARED_TEXTURE_PALETTE_EXT );
+                oldPalette = (char *) d_8to24table; //d_8to24table3dfx;
+                newPalette = thePalette;
+                for (i=0;i<256;i++) {
+                        *newPalette++ = *oldPalette++;
+                        *newPalette++ = *oldPalette++;
+                        *newPalette++ = *oldPalette++;
+                        oldPalette++;
+                }
+                qglColorTableEXT(GL_SHARED_TEXTURE_PALETTE_EXT, GL_RGB, 256, GL_RGB, GL_UNSIGNED_BYTE, (void *) thePalette);
+                is8bit = true;
+        
+        }
+
+        dlclose(prjobj);
+}
+
+static void Check_Gamma (unsigned char *pal)
+{
+        float   f, inf;
+        unsigned char   palette[768];
+        int             i;
+
+        if ((i = COM_CheckParm("-gamma")) == 0) {
+                if ((gl_renderer && strstr(gl_renderer, "Voodoo")) ||
+                        (gl_vendor && strstr(gl_vendor, "3Dfx")))
+                        vid_gamma = 1;
+                else
+                        vid_gamma = 0.7; // default to 0.7 on non-3dfx hardware
+        } else
+                vid_gamma = Q_atof(com_argv[i+1]);
+
+        for (i=0 ; i<768 ; i++)
+        {
+                f = pow ( (pal[i]+1)/256.0 , vid_gamma );
+                inf = f*255 + 0.5;
+                if (inf < 0)
+                        inf = 0;
+                if (inf > 255)
+                        inf = 255;
+                palette[i] = inf;
+        }
+
+        memcpy (pal, palette, sizeof(palette));
+}
+
+void VID_Init(unsigned char *palette)
+{
+        int i;
+        GLint attribs[32];
+        char    gldir[MAX_OSPATH];
+        int width = 640, height = 480;
+
+        Init_KBD();
+
+        Cvar_RegisterVariable (&vid_mode);
+        Cvar_RegisterVariable (&vid_redrawfull);
+        Cvar_RegisterVariable (&vid_waitforrefresh);
+        Cvar_RegisterVariable (&gl_ztrick);
+        
+        vid.maxwarpwidth = WARP_WIDTH;
+        vid.maxwarpheight = WARP_HEIGHT;
+        vid.colormap = host_colormap;
+        vid.fullbright = 256 - LittleLong (*((int *)vid.colormap + 2048));
+
+// interpret command-line params
+
+// set vid parameters
+        attribs[0] = FXMESA_DOUBLEBUFFER;
+        attribs[1] = FXMESA_ALPHA_SIZE;
+        attribs[2] = 1;
+        attribs[3] = FXMESA_DEPTH_SIZE;
+        attribs[4] = 1;
+        attribs[5] = FXMESA_NONE;
+
+        if ((i = COM_CheckParm("-width")) != 0)
+                width = atoi(com_argv[i+1]);
+        if ((i = COM_CheckParm("-height")) != 0)
+                height = atoi(com_argv[i+1]);
+
+        if ((i = COM_CheckParm("-conwidth")) != 0)
+                vid.conwidth = Q_atoi(com_argv[i+1]);
+        else
+                vid.conwidth = 640;
+
+        vid.conwidth &= 0xfff8; // make it a multiple of eight
+
+        if (vid.conwidth < 320)
+                vid.conwidth = 320;
+
+        // pick a conheight that matches with correct aspect
+        vid.conheight = vid.conwidth*3 / 4;
+
+        if ((i = COM_CheckParm("-conheight")) != 0)
+                vid.conheight = Q_atoi(com_argv[i+1]);
+        if (vid.conheight < 200)
+                vid.conheight = 200;
+
+        fc = fxMesaCreateContext(0, findres(&width, &height), GR_REFRESH_75Hz, 
+                attribs);
+        if (!fc)
+                Sys_Error("Unable to create 3DFX context.\n");
+
+        InitSig(); // trap evil signals
+
+        scr_width = width;
+        scr_height = height;
+
+        fxMesaMakeCurrent(fc);
+
+        if (vid.conheight > height)
+                vid.conheight = height;
+        if (vid.conwidth > width)
+                vid.conwidth = width;
+        vid.width = vid.conwidth;
+        vid.height = vid.conheight;
+
+        vid.aspect = ((float)vid.height / (float)vid.width) *
+                                (320.0 / 240.0);
+        vid.numpages = 2;
+
+        GL_Init();
+
+        sprintf (gldir, "%s/glquake", com_gamedir);
+        Sys_mkdir (gldir);
+
+        Check_Gamma(palette);
+        VID_SetPalette(palette);
+
+        // Check for 3DFX Extensions and initialize them.
+        VID_Init8bitPalette();
+
+        Con_SafePrintf ("Video mode %dx%d initialized.\n", width, height);
+
+        vid.recalc_refdef = 1;                          // force a surface cache flush
+}
+
+void Sys_SendKeyEvents(void)
+{
+        if (UseKeyboard)
+                while (keyboard_update());
+}
+
+void Force_CenterView_f (void)
+{
+        cl.viewangles[PITCH] = 0;
+}
+
+
+void mousehandler(int buttonstate, int dx, int dy)
+{
+        mouse_buttonstate = buttonstate;
+        mx += dx;
+        my += dy;
+}
+
+void IN_Init(void)
+{
+
+        int mtype;
+        char *mousedev;
+        int mouserate;
+
+        if (UseMouse)
+        {
+
+                Cvar_RegisterVariable (&mouse_button_commands[0]);
+                Cvar_RegisterVariable (&mouse_button_commands[1]);
+                Cvar_RegisterVariable (&mouse_button_commands[2]);
+                Cmd_AddCommand ("force_centerview", Force_CenterView_f);
+
+                mouse_buttons = 3;
+
+                mtype = vga_getmousetype();
+
+                mousedev = "/dev/mouse";
+                if (getenv("MOUSEDEV")) mousedev = getenv("MOUSEDEV");
+                if (COM_CheckParm("-mdev"))
+                        mousedev = com_argv[COM_CheckParm("-mdev")+1];
+
+                mouserate = 1200;
+                if (getenv("MOUSERATE")) mouserate = atoi(getenv("MOUSERATE"));
+                if (COM_CheckParm("-mrate"))
+                        mouserate = atoi(com_argv[COM_CheckParm("-mrate")+1]);
+
+                if (mouse_init(mousedev, mtype, mouserate))
+                {
+                        Con_Printf("No mouse found\n");
+                        UseMouse = 0;
+                }
+                else
+                        mouse_seteventhandler(mousehandler);
+
+        }
+
+}
+
+void IN_Shutdown(void)
+{
+        if (UseMouse)
+                mouse_close();
+}
+
+/*
+===========
+IN_Commands
+===========
+*/
+void IN_Commands (void)
+{
+        if (UseMouse && cls.state != ca_dedicated)
+        {
+                // poll mouse values
+                while (mouse_update())
+                        ;
+
+                // perform button actions
+                if ((mouse_buttonstate & MOUSE_LEFTBUTTON) &&
+                        !(mouse_oldbuttonstate & MOUSE_LEFTBUTTON))
+                        Key_Event (K_MOUSE1, true);
+                else if (!(mouse_buttonstate & MOUSE_LEFTBUTTON) &&
+                        (mouse_oldbuttonstate & MOUSE_LEFTBUTTON))
+                        Key_Event (K_MOUSE1, false);
+
+                if ((mouse_buttonstate & MOUSE_RIGHTBUTTON) &&
+                        !(mouse_oldbuttonstate & MOUSE_RIGHTBUTTON))
+                        Key_Event (K_MOUSE2, true);
+                else if (!(mouse_buttonstate & MOUSE_RIGHTBUTTON) &&
+                        (mouse_oldbuttonstate & MOUSE_RIGHTBUTTON))
+                        Key_Event (K_MOUSE2, false);
+
+                if ((mouse_buttonstate & MOUSE_MIDDLEBUTTON) &&
+                        !(mouse_oldbuttonstate & MOUSE_MIDDLEBUTTON))
+                        Key_Event (K_MOUSE3, true);
+                else if (!(mouse_buttonstate & MOUSE_MIDDLEBUTTON) &&
+                        (mouse_oldbuttonstate & MOUSE_MIDDLEBUTTON))
+                        Key_Event (K_MOUSE3, false);
+
+                mouse_oldbuttonstate = mouse_buttonstate;
+        }
+}
+
+/*
+===========
+IN_Move
+===========
+*/
+void IN_MouseMove (usercmd_t *cmd)
+{
+        if (!UseMouse)
+                return;
+
+        // poll mouse values
+        while (mouse_update())
+                ;
+
+        if (m_filter.value)
+        {
+                mouse_x = (mx + old_mouse_x) * 0.5;
+                mouse_y = (my + old_mouse_y) * 0.5;
+        }
+        else
+        {
+                mouse_x = mx;
+                mouse_y = my;
+        }
+        old_mouse_x = mx;
+        old_mouse_y = my;
+        mx = my = 0; // clear for next update
+
+        mouse_x *= sensitivity.value;
+        mouse_y *= sensitivity.value;
+
+// add mouse X/Y movement to cmd
+        if ( (in_strafe.state & 1) || (lookstrafe.value && (in_mlook.state & 1) ))
+                cmd->sidemove += m_side.value * mouse_x;
+        else
+                cl.viewangles[YAW] -= m_yaw.value * mouse_x;
+        
+        if (in_mlook.state & 1)
+                V_StopPitchDrift ();
+                
+        if ( (in_mlook.state & 1) && !(in_strafe.state & 1))
+        {
+                cl.viewangles[PITCH] += m_pitch.value * mouse_y;
+                if (cl.viewangles[PITCH] > 80)
+                        cl.viewangles[PITCH] = 80;
+                if (cl.viewangles[PITCH] < -70)
+                        cl.viewangles[PITCH] = -70;
+        }
+        else
+        {
+                if ((in_strafe.state & 1) && noclip_anglehack)
+                        cmd->upmove -= m_forward.value * mouse_y;
+                else
+                        cmd->forwardmove -= m_forward.value * mouse_y;
+        }
+}
+
+void IN_Move (usercmd_t *cmd)
+{
+        IN_MouseMove(cmd);
+}
+
+