very minor cruft removal
[divverent/darkplaces.git] / vid_glx.c
1 /*
2 Copyright (C) 1996-1997 Id Software, Inc.
3
4 This program is free software; you can redistribute it and/or
5 modify it under the terms of the GNU General Public License
6 as published by the Free Software Foundation; either version 2
7 of the License, or (at your option) any later version.
8
9 This program is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  
12
13 See the GNU General Public License for more details.
14
15 You should have received a copy of the GNU General Public License
16 along with this program; if not, write to the Free Software
17 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
18
19 */
20 #include <termios.h>
21 #include <sys/ioctl.h>
22 #include <sys/stat.h>
23 #include <sys/vt.h>
24 #include <stdarg.h>
25 #include <stdio.h>
26 #include <signal.h>
27
28 #include <dlfcn.h>
29
30 #include "quakedef.h"
31
32 #include <GL/glx.h>
33
34 #include <X11/keysym.h>
35 #include <X11/cursorfont.h>
36
37 #include <X11/extensions/xf86dga.h>
38 #include <X11/extensions/xf86vmode.h>
39
40 #define WARP_WIDTH              320
41 #define WARP_HEIGHT             200
42
43 static Display *dpy = NULL;
44 static int scrnum;
45 static Window win;
46 static GLXContext ctx = NULL;
47
48 #define KEY_MASK (KeyPressMask | KeyReleaseMask)
49 #define MOUSE_MASK (ButtonPressMask | ButtonReleaseMask | \
50                     PointerMotionMask | ButtonMotionMask )
51 #define X_MASK (KEY_MASK | MOUSE_MASK | VisibilityChangeMask | StructureNotifyMask )
52
53
54 unsigned short  d_8to16table[256];
55 unsigned                d_8to24table[256];
56 unsigned char   d_15to8table[65536];
57
58 cvar_t  vid_mode = {"vid_mode","0",false};
59  
60 viddef_t        vid;                            // global video state
61
62 static qboolean        mouse_avail;
63 static qboolean        mouse_active;
64 static int   mx, my;
65 static int      old_mouse_x, old_mouse_y;
66
67 static cvar_t in_mouse = {"in_mouse", "1", false};
68 static cvar_t in_dgamouse = {"in_dgamouse", "1", false};
69 static cvar_t m_filter = {"m_filter", "0"};
70
71 qboolean dgamouse = false;
72 qboolean vidmode_ext = false;
73
74 static int win_x, win_y;
75
76 static int scr_width, scr_height;
77
78 static XF86VidModeModeInfo **vidmodes;
79 //static int default_dotclock_vidmode;
80 static int num_vidmodes;
81 static qboolean vidmode_active = false;
82
83 /*-----------------------------------------------------------------------*/
84
85 int             texture_extension_number = 1;
86
87 float           gldepthmin, gldepthmax;
88
89 const char *gl_vendor;
90 const char *gl_renderer;
91 const char *gl_version;
92 const char *gl_extensions;
93
94 void (*qglColorTableEXT) (int, int, int, int, int, const void*);
95 void (*qgl3DfxSetPaletteEXT) (GLuint *);
96 void (*qglMTexCoord2f) (GLenum, GLfloat, GLfloat);
97 void (*qglSelectTexture) (GLenum);
98
99 //static float vid_gamma = 1.0;
100
101 // LordHavoc: ARB multitexture support
102 int gl_mtex_enum = 0;
103
104 // LordHavoc: in GLX these are never set, simply provided to make the rest of the code work
105 qboolean is8bit = false;
106 qboolean isPermedia = false;
107 qboolean isATI = false;
108 qboolean isG200 = false;
109 qboolean isRagePro = false;
110 qboolean gl_mtexable = false;
111 qboolean gl_arrays = false;
112
113 /*-----------------------------------------------------------------------*/
114 void D_BeginDirectRect (int x, int y, byte *pbitmap, int width, int height)
115 {
116 }
117
118 void D_EndDirectRect (int x, int y, int width, int height)
119 {
120 }
121
122 static int XLateKey(XKeyEvent *ev)
123 {
124
125         int key;
126         char buf[64];
127         KeySym keysym;
128
129         key = 0;
130
131         XLookupString(ev, buf, sizeof buf, &keysym, 0);
132
133         switch(keysym)
134         {
135                 case XK_KP_Page_Up:      
136                 case XK_Page_Up:         key = K_PGUP; break;
137
138                 case XK_KP_Page_Down: 
139                 case XK_Page_Down:       key = K_PGDN; break;
140
141                 case XK_KP_Home: 
142                 case XK_Home:    key = K_HOME; break;
143
144                 case XK_KP_End:  
145                 case XK_End:     key = K_END; break;
146
147                 case XK_KP_Left: 
148                 case XK_Left:    key = K_LEFTARROW; break;
149
150                 case XK_KP_Right: 
151                 case XK_Right:  key = K_RIGHTARROW;             break;
152
153                 case XK_KP_Down: 
154                 case XK_Down:    key = K_DOWNARROW; break;
155
156                 case XK_KP_Up:   
157                 case XK_Up:              key = K_UPARROW;        break;
158
159                 case XK_Escape: key = K_ESCAPE;         break;
160
161                 case XK_KP_Enter: 
162                 case XK_Return: key = K_ENTER;           break;
163
164                 case XK_Tab:            key = K_TAB;                     break;
165
166                 case XK_F1:              key = K_F1;                            break;
167
168                 case XK_F2:              key = K_F2;                            break;
169
170                 case XK_F3:              key = K_F3;                            break;
171
172                 case XK_F4:              key = K_F4;                            break;
173
174                 case XK_F5:              key = K_F5;                            break;
175
176                 case XK_F6:              key = K_F6;                            break;
177
178                 case XK_F7:              key = K_F7;                            break;
179
180                 case XK_F8:              key = K_F8;                            break;
181
182                 case XK_F9:              key = K_F9;                            break;
183
184                 case XK_F10:            key = K_F10;                     break;
185
186                 case XK_F11:            key = K_F11;                     break;
187
188                 case XK_F12:            key = K_F12;                     break;
189
190                 case XK_BackSpace: key = K_BACKSPACE; break;
191
192                 case XK_KP_Delete: 
193                 case XK_Delete: key = K_DEL; break;
194
195                 case XK_Pause:  key = K_PAUSE;           break;
196
197                 case XK_Shift_L:
198                 case XK_Shift_R:        key = K_SHIFT;          break;
199
200                 case XK_Execute: 
201                 case XK_Control_L: 
202                 case XK_Control_R:      key = K_CTRL;            break;
203
204                 case XK_Alt_L:  
205                 case XK_Meta_L: 
206                 case XK_Alt_R:  
207                 case XK_Meta_R: key = K_ALT;                    break;
208
209                 case XK_KP_Begin: key = '5';    break;
210
211                 case XK_KP_Insert: 
212                 case XK_Insert:key = K_INS; break;
213
214                 case XK_KP_Multiply: key = '*'; break;
215                 case XK_KP_Add:  key = '+'; break;
216                 case XK_KP_Subtract: key = '-'; break;
217                 case XK_KP_Divide: key = '/'; break;
218
219 #if 0
220                 case 0x021: key = '1';break;/* [!] */
221                 case 0x040: key = '2';break;/* [@] */
222                 case 0x023: key = '3';break;/* [#] */
223                 case 0x024: key = '4';break;/* [$] */
224                 case 0x025: key = '5';break;/* [%] */
225                 case 0x05e: key = '6';break;/* [^] */
226                 case 0x026: key = '7';break;/* [&] */
227                 case 0x02a: key = '8';break;/* [*] */
228                 case 0x028: key = '9';;break;/* [(] */
229                 case 0x029: key = '0';break;/* [)] */
230                 case 0x05f: key = '-';break;/* [_] */
231                 case 0x02b: key = '=';break;/* [+] */
232                 case 0x07c: key = '\'';break;/* [|] */
233                 case 0x07d: key = '[';break;/* [}] */
234                 case 0x07b: key = ']';break;/* [{] */
235                 case 0x022: key = '\'';break;/* ["] */
236                 case 0x03a: key = ';';break;/* [:] */
237                 case 0x03f: key = '/';break;/* [?] */
238                 case 0x03e: key = '.';break;/* [>] */
239                 case 0x03c: key = ',';break;/* [<] */
240 #endif
241
242                 default:
243                         key = *(unsigned char*)buf;
244                         if (key >= 'A' && key <= 'Z')
245                                 key = key - 'A' + 'a';
246                         break;
247         } 
248
249         return key;
250 }
251
252 static Cursor CreateNullCursor(Display *display, Window root)
253 {
254     Pixmap cursormask; 
255     XGCValues xgc;
256     GC gc;
257     XColor dummycolour;
258     Cursor cursor;
259
260     cursormask = XCreatePixmap(display, root, 1, 1, 1/*depth*/);
261     xgc.function = GXclear;
262     gc =  XCreateGC(display, cursormask, GCFunction, &xgc);
263     XFillRectangle(display, cursormask, gc, 0, 0, 1, 1);
264     dummycolour.pixel = 0;
265     dummycolour.red = 0;
266     dummycolour.flags = 04;
267     cursor = XCreatePixmapCursor(display, cursormask, cursormask,
268           &dummycolour,&dummycolour, 0,0);
269     XFreePixmap(display,cursormask);
270     XFreeGC(display,gc);
271     return cursor;
272 }
273
274 static void install_grabs(void)
275 {
276
277 // inviso cursor
278         XDefineCursor(dpy, win, CreateNullCursor(dpy, win));
279
280         XGrabPointer(dpy, win,
281                                  True,
282                                  0,
283                                  GrabModeAsync, GrabModeAsync,
284                                  win,
285                                  None,
286                                  CurrentTime);
287
288         if (in_dgamouse.value) {
289                 int MajorVersion, MinorVersion;
290
291                 if (!XF86DGAQueryVersion(dpy, &MajorVersion, &MinorVersion)) { 
292                         // unable to query, probalby not supported
293                         Con_Printf( "Failed to detect XF86DGA Mouse\n" );
294                         in_dgamouse.value = 0;
295                 } else {
296                         dgamouse = true;
297                         XF86DGADirectVideo(dpy, DefaultScreen(dpy), XF86DGADirectMouse);
298                         XWarpPointer(dpy, None, win, 0, 0, 0, 0, 0, 0);
299                 }
300         } else {
301                 XWarpPointer(dpy, None, win,
302                                          0, 0, 0, 0,
303                                          vid.width / 2, vid.height / 2);
304         }
305
306         XGrabKeyboard(dpy, win,
307                                   False,
308                                   GrabModeAsync, GrabModeAsync,
309                                   CurrentTime);
310
311         mouse_active = true;
312
313 //      XSync(dpy, True);
314 }
315
316 static void uninstall_grabs(void)
317 {
318         if (!dpy || !win)
319                 return;
320
321         if (dgamouse) {
322                 dgamouse = false;
323                 XF86DGADirectVideo(dpy, DefaultScreen(dpy), 0);
324         }
325
326         XUngrabPointer(dpy, CurrentTime);
327         XUngrabKeyboard(dpy, CurrentTime);
328
329 // inviso cursor
330         XUndefineCursor(dpy, win);
331
332         mouse_active = false;
333 }
334
335 static void HandleEvents(void)
336 {
337         XEvent event;
338 //      KeySym ks;
339         int b;
340         qboolean dowarp = false;
341         int mwx = vid.width/2;
342         int mwy = vid.height/2;
343
344         if (!dpy)
345                 return;
346
347         while (XPending(dpy)) {
348                 XNextEvent(dpy, &event);
349
350                 switch (event.type) {
351                 case KeyPress:
352                 case KeyRelease:
353                         Key_Event(XLateKey(&event.xkey), event.type == KeyPress);
354                         break;
355
356                 case MotionNotify:
357                         if (mouse_active) {
358                                 if (dgamouse) {
359                                         mx += (event.xmotion.x + win_x) * 2;
360                                         my += (event.xmotion.y + win_y) * 2;
361                                 } 
362                                 else 
363                                 {
364                                         mx += ((int)event.xmotion.x - mwx) * 2;
365                                         my += ((int)event.xmotion.y - mwy) * 2;
366                                         mwx = event.xmotion.x;
367                                         mwy = event.xmotion.y;
368
369                                         if (mx || my)
370                                                 dowarp = true;
371                                 }
372                         }
373                         break;
374
375                         break;
376
377                 case ButtonPress:
378                         b=-1;
379                         if (event.xbutton.button == 1)
380                                 b = 0;
381                         else if (event.xbutton.button == 2)
382                                 b = 2;
383                         else if (event.xbutton.button == 3)
384                                 b = 1;
385                         if (b>=0)
386                                 Key_Event(K_MOUSE1 + b, true);
387                         break;
388
389                 case ButtonRelease:
390                         b=-1;
391                         if (event.xbutton.button == 1)
392                                 b = 0;
393                         else if (event.xbutton.button == 2)
394                                 b = 2;
395                         else if (event.xbutton.button == 3)
396                                 b = 1;
397                         if (b>=0)
398                                 Key_Event(K_MOUSE1 + b, false);
399                         break;
400
401                 case CreateNotify :
402                         win_x = event.xcreatewindow.x;
403                         win_y = event.xcreatewindow.y;
404                         break;
405
406                 case ConfigureNotify :
407                         win_x = event.xconfigure.x;
408                         win_y = event.xconfigure.y;
409                         break;
410                 }
411         }
412
413         if (dowarp) {
414                 /* move the mouse to the window center again */
415                 XWarpPointer(dpy, None, win, 0, 0, 0, 0, vid.width / 2, vid.height / 2);
416         }
417
418 }
419
420 static void IN_DeactivateMouse( void ) 
421 {
422         if (!mouse_avail || !dpy || !win)
423                 return;
424
425         if (mouse_active) {
426                 uninstall_grabs();
427                 mouse_active = false;
428         }
429 }
430
431 static void IN_ActivateMouse( void ) 
432 {
433         if (!mouse_avail || !dpy || !win)
434                 return;
435
436         if (!mouse_active) {
437                 mx = my = 0; // don't spazz
438                 install_grabs();
439                 mouse_active = true;
440         }
441 }
442
443
444 void VID_Shutdown(void)
445 {
446         if (!ctx || !dpy)
447                 return;
448         IN_DeactivateMouse();
449         if (dpy) {
450                 if (ctx)
451                         glXDestroyContext(dpy, ctx);
452                 if (win)
453                         XDestroyWindow(dpy, win);
454                 if (vidmode_active)
455                         XF86VidModeSwitchToMode(dpy, scrnum, vidmodes[0]);
456                 XCloseDisplay(dpy);
457         }
458         vidmode_active = false;
459         dpy = NULL;
460         win = 0;
461         ctx = NULL;
462 }
463
464 void signal_handler(int sig)
465 {
466         printf("Received signal %d, exiting...\n", sig);
467         Sys_Quit();
468         exit(0);
469 }
470
471 void InitSig(void)
472 {
473         signal(SIGHUP, signal_handler);
474         signal(SIGINT, signal_handler);
475         signal(SIGQUIT, signal_handler);
476         signal(SIGILL, signal_handler);
477         signal(SIGTRAP, signal_handler);
478         signal(SIGIOT, signal_handler);
479         signal(SIGBUS, signal_handler);
480         signal(SIGFPE, signal_handler);
481         signal(SIGSEGV, signal_handler);
482         signal(SIGTERM, signal_handler);
483 }
484
485 /*
486 void (*qglVertexPointer)(GLint size, GLenum type, GLsizei stride, const GLvoid *ptr);
487 void (*qglColorPointer)(GLint size, GLenum type, GLsizei stride, const GLvoid *ptr);
488 void (*qglTexCoordPointer)(GLint size, GLenum type, GLsizei stride, const GLvoid *ptr);
489 void (*qglArrayElement)(GLint i);
490 void (*qglDrawElements)(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices);
491 void (*qglMTexCoord2f)(GLenum, GLfloat, GLfloat);
492 void (*qglSelectTexture)(GLenum);
493 void (*glColorTableEXT)(int, int, int, int, int, const void*);
494
495 void CheckVertexArrays (void)
496 {
497         void *prjobj;
498         if (COM_CheckParm("-novertex"))
499         {
500                 Con_Printf("...vertex array support disabled\n");
501                 return;
502         }
503         if ((prjobj = dlopen(NULL, RTLD_LAZY)) == NULL)
504         {
505                 Con_Printf("Unable to open symbol list for main program.\n");
506                 return;
507         }
508         qglMTexCoord2fSGIS = (void *) dlsym(prjobj, "glMTexCoord2fSGIS");
509         if ((qglArrayElement = (void *) dlsym(prjobj, "glArrayElement"))
510          && (qglColorPointer = (void *) dlsym(prjobj, "glColorPointer"))
511 //       && (qglDrawArrays = (void *) dlsym(prjobj, "glDrawArrays"))
512          && (qglDrawElements = (void *) dlsym(prjobj, "glDrawElements"))
513 //       && (qglInterleavedArrays = (void *) dlsym(prjobj, "glInterleavedArrays"))
514          && (qglTexCoordPointer = (void *) dlsym(prjobj, "glTexCoordPointer"))
515          && (qglVertexPointer = (void *) dlsym(prjobj, "glVertexPointer"))
516                 )
517         {
518                 Con_Printf("...vertex array support detected\n");
519                 gl_arrays = true;
520                 dlclose(prjobj);
521                 return;
522         }
523
524         Con_Printf("...vertex array support disabled (not detected - get a better driver)\n");
525         dlclose(prjobj);
526 }
527 */
528
529 void CheckMultiTexture(void) 
530 {
531         void *prjobj;
532         qglMTexCoord2f = NULL;
533         qglSelectTexture = NULL;
534         // Check to see if multitexture is disabled
535         if (COM_CheckParm("-nomtex"))
536         {
537                 Con_Printf("...multitexture disabled\n");
538                 return;
539         }
540         if ((prjobj = dlopen(NULL, RTLD_LAZY)) == NULL)
541         {
542                 Con_Printf("Unable to open symbol list for main program.\n");
543                 return;
544         }
545         // Test for ARB_multitexture
546         if (!COM_CheckParm("-SGISmtex") && strstr(gl_extensions, "GL_ARB_multitexture "))
547         {
548                 Con_Printf("...using GL_ARB_multitexture\n");
549                 qglMTexCoord2f = (void *) dlsym(prjobj, "glMultiTexCoord2fARB");
550                 qglSelectTexture = (void *) dlsym(prjobj, "glActiveTextureARB");
551                 gl_mtexable = true;
552                 gl_mtex_enum = GL_TEXTURE0_ARB;
553         }
554         else if (strstr(gl_extensions, "GL_SGIS_multitexture ")) // Test for SGIS_multitexture (if ARB_multitexture not found)
555         {
556                 Con_Printf("...using GL_SGIS_multitexture\n");
557                 qglMTexCoord2f = (void *) dlsym(prjobj, "glMTexCoord2fSGIS");
558                 qglSelectTexture = (void *) dlsym(prjobj, "glSelectTextureSGIS");
559                 gl_mtexable = true;
560                 gl_mtex_enum = TEXTURE0_SGIS;
561         }
562         if (!gl_mtexable)
563                 Con_Printf("...multitexture disabled (not detected)\n");
564         dlclose(prjobj);
565 }
566
567 /*
568 ===============
569 GL_Init
570 ===============
571 */
572 extern char *QSG_EXTENSIONS;
573 void GL_Init (void)
574 {
575         gl_vendor = glGetString (GL_VENDOR);
576         Con_Printf ("GL_VENDOR: %s\n", gl_vendor);
577         gl_renderer = glGetString (GL_RENDERER);
578         Con_Printf ("GL_RENDERER: %s\n", gl_renderer);
579
580         gl_version = glGetString (GL_VERSION);
581         Con_Printf ("GL_VERSION: %s\n", gl_version);
582         gl_extensions = glGetString (GL_EXTENSIONS);
583         Con_Printf ("GL_EXTENSIONS: %s\n", gl_extensions);
584
585 //      Con_Printf ("%s %s\n", gl_renderer, gl_version);
586
587         CheckMultiTexture();
588 //      CheckVertexArrays();
589
590         // LordHavoc: report supported extensions
591         Con_Printf ("\nQSG extensions: %s\n", QSG_EXTENSIONS);
592
593         glCullFace(GL_FRONT);
594         glAlphaFunc(GL_GREATER, 0.5);
595 }
596
597 /*
598 =================
599 GL_BeginRendering
600
601 =================
602 */
603 void GL_BeginRendering (int *x, int *y, int *width, int *height)
604 {
605         *x = *y = 0;
606         *width = scr_width;
607         *height = scr_height;
608
609 //    if (!wglMakeCurrent( maindc, baseRC ))
610 //              Sys_Error ("wglMakeCurrent failed");
611
612 //      glViewport (*x, *y, *width, *height);
613 }
614
615
616 void GL_EndRendering (void)
617 {
618         if (!r_render.value)
619                 return;
620         glFlush();
621         glXSwapBuffers(dpy, win);
622 }
623
624 qboolean VID_Is8bit(void)
625 {
626         return is8bit;
627 }
628
629 void VID_Init8bitPalette(void) 
630 {
631         // Check for 8bit Extensions and initialize them.
632         int i;
633         void *prjobj;
634
635         if (!COM_CheckParm("-8bit"))
636                 return;
637         if ((prjobj = dlopen(NULL, RTLD_LAZY)) == NULL)
638         {
639                 Con_Printf("Unable to open symbol list for main program.\n");
640                 return;
641         }
642
643         if (strstr(gl_extensions, "3DFX_set_global_palette") && (qgl3DfxSetPaletteEXT = dlsym(prjobj, "gl3DfxSetPaletteEXT")) != NULL)
644         {
645                 GLubyte table[256][4];
646                 char *oldpal;
647
648                 Con_SafePrintf("8-bit GL extensions enabled.\n");
649                 glEnable( GL_SHARED_TEXTURE_PALETTE_EXT );
650                 oldpal = (char *) d_8to24table; //d_8to24table3dfx;
651                 for (i=0;i<256;i++)
652                 {
653                         table[i][2] = *oldpal++;
654                         table[i][1] = *oldpal++;
655                         table[i][0] = *oldpal++;
656                         table[i][3] = 255;
657                         oldpal++;
658                 }
659                 qgl3DfxSetPaletteEXT((GLuint *)table);
660                 is8bit = true;
661
662         }
663         else if (strstr(gl_extensions, "GL_EXT_shared_texture_palette") && (qglColorTableEXT = dlsym(prjobj, "glColorTableEXT")) != NULL)
664         {
665                 char thePalette[256*3];
666                 char *oldPalette, *newPalette;
667
668                 Con_SafePrintf("8-bit GL extensions enabled.\n");
669                 glEnable( GL_SHARED_TEXTURE_PALETTE_EXT );
670                 oldPalette = (char *) d_8to24table; //d_8to24table3dfx;
671                 newPalette = thePalette;
672                 for (i=0;i<256;i++)
673                 {
674                         *newPalette++ = *oldPalette++;
675                         *newPalette++ = *oldPalette++;
676                         *newPalette++ = *oldPalette++;
677                         oldPalette++;
678                 }
679                 qglColorTableEXT(GL_SHARED_TEXTURE_PALETTE_EXT, GL_RGB, 256, GL_RGB, GL_UNSIGNED_BYTE, (void *) thePalette);
680                 is8bit = true;
681         }
682         
683         dlclose(prjobj);
684 }
685
686 extern void Check_Gamma (unsigned char *pal);
687 void VID_Setup15to8Palette ();
688
689 void VID_Init(unsigned char *palette)
690 {
691         int i;
692         int attrib[] = {
693                 GLX_RGBA,
694                 GLX_RED_SIZE, 1,
695                 GLX_GREEN_SIZE, 1,
696                 GLX_BLUE_SIZE, 1,
697                 GLX_DOUBLEBUFFER,
698                 GLX_DEPTH_SIZE, 1,
699                 None
700         };
701 //      char    gldir[MAX_OSPATH];
702         int width = 640, height = 480;
703         XSetWindowAttributes attr;
704         unsigned long mask;
705         Window root;
706         XVisualInfo *visinfo;
707         qboolean fullscreen = true;
708         int MajorVersion, MinorVersion;
709         int actualWidth, actualHeight;
710
711         Cvar_RegisterVariable (&vid_mode);
712         Cvar_RegisterVariable (&in_mouse);
713         Cvar_RegisterVariable (&in_dgamouse);
714         Cvar_RegisterVariable (&m_filter);
715         
716 // interpret command-line params
717
718 // set vid parameters
719         if ((i = COM_CheckParm("-window")) != 0)
720                 fullscreen = false;
721
722         if ((i = COM_CheckParm("-width")) != 0)
723                 width = atoi(com_argv[i+1]);
724
725         if ((i = COM_CheckParm("-height")) != 0)
726                 height = atoi(com_argv[i+1]);
727
728         if ((i = COM_CheckParm("-conwidth")) != 0)
729                 vid.conwidth = atoi(com_argv[i+1]);
730         else
731                 vid.conwidth = 640;
732
733         vid.conwidth &= 0xfff8; // make it a multiple of eight
734
735         if (vid.conwidth < 320)
736                 vid.conwidth = 320;
737
738         // pick a conheight that matches with correct aspect
739         vid.conheight = vid.conwidth*3 / 4;
740
741         if ((i = COM_CheckParm("-conheight")) != 0)
742                 vid.conheight = atoi(com_argv[i+1]);
743         if (vid.conheight < 200)
744                 vid.conheight = 200;
745
746         if (!(dpy = XOpenDisplay(NULL))) {
747                 fprintf(stderr, "Error couldn't open the X display\n");
748                 exit(1);
749         }
750
751         scrnum = DefaultScreen(dpy);
752         root = RootWindow(dpy, scrnum);
753
754         // Get video mode list
755         MajorVersion = MinorVersion = 0;
756         if (!XF86VidModeQueryVersion(dpy, &MajorVersion, &MinorVersion)) { 
757                 vidmode_ext = false;
758         } else {
759                 Con_Printf("Using XFree86-VidModeExtension Version %d.%d\n", MajorVersion, MinorVersion);
760                 vidmode_ext = true;
761         }
762
763         visinfo = glXChooseVisual(dpy, scrnum, attrib);
764         if (!visinfo) {
765                 fprintf(stderr, "qkHack: Error couldn't get an RGB, Double-buffered, Depth visual\n");
766                 exit(1);
767         }
768
769         if (vidmode_ext) {
770                 int best_fit, best_dist, dist, x, y;
771                 
772                 XF86VidModeGetAllModeLines(dpy, scrnum, &num_vidmodes, &vidmodes);
773
774                 // Are we going fullscreen?  If so, let's change video mode
775                 if (fullscreen) {
776                         best_dist = 9999999;
777                         best_fit = -1;
778
779                         for (i = 0; i < num_vidmodes; i++) {
780                                 if (width > vidmodes[i]->hdisplay ||
781                                         height > vidmodes[i]->vdisplay)
782                                         continue;
783
784                                 x = width - vidmodes[i]->hdisplay;
785                                 y = height - vidmodes[i]->vdisplay;
786                                 dist = (x * x) + (y * y);
787                                 if (dist < best_dist) {
788                                         best_dist = dist;
789                                         best_fit = i;
790                                 }
791                         }
792
793                         if (best_fit != -1) {
794                                 actualWidth = vidmodes[best_fit]->hdisplay;
795                                 actualHeight = vidmodes[best_fit]->vdisplay;
796
797                                 // change to the mode
798                                 XF86VidModeSwitchToMode(dpy, scrnum, vidmodes[best_fit]);
799                                 vidmode_active = true;
800
801                                 // Move the viewport to top left
802                                 XF86VidModeSetViewPort(dpy, scrnum, 0, 0);
803                         } else
804                                 fullscreen = 0;
805                 }
806         }
807
808         /* window attributes */
809         attr.background_pixel = 0;
810         attr.border_pixel = 0;
811         attr.colormap = XCreateColormap(dpy, root, visinfo->visual, AllocNone);
812         attr.event_mask = X_MASK;
813         if (vidmode_active) {
814                 mask = CWBackPixel | CWColormap | CWSaveUnder | CWBackingStore | 
815                         CWEventMask | CWOverrideRedirect;
816                 attr.override_redirect = True;
817                 attr.backing_store = NotUseful;
818                 attr.save_under = False;
819         } else
820                 mask = CWBackPixel | CWBorderPixel | CWColormap | CWEventMask;
821
822         win = XCreateWindow(dpy, root, 0, 0, width, height,
823                                                 0, visinfo->depth, InputOutput,
824                                                 visinfo->visual, mask, &attr);
825         XMapWindow(dpy, win);
826
827         if (vidmode_active) {
828                 XMoveWindow(dpy, win, 0, 0);
829                 XRaiseWindow(dpy, win);
830                 XWarpPointer(dpy, None, win, 0, 0, 0, 0, 0, 0);
831                 XFlush(dpy);
832                 // Move the viewport to top left
833                 XF86VidModeSetViewPort(dpy, scrnum, 0, 0);
834         }
835
836         XFlush(dpy);
837
838         ctx = glXCreateContext(dpy, visinfo, NULL, True);
839
840         glXMakeCurrent(dpy, win, ctx);
841
842         scr_width = width;
843         scr_height = height;
844
845         if (vid.conheight > height)
846                 vid.conheight = height;
847         if (vid.conwidth > width)
848                 vid.conwidth = width;
849         vid.width = vid.conwidth;
850         vid.height = vid.conheight;
851
852         vid.aspect = ((float)vid.height / (float)vid.width) * (320.0 / 240.0);
853
854         InitSig(); // trap evil signals
855
856         GL_Init();
857
858 //      sprintf (gldir, "%s/glquake", com_gamedir);
859 //      Sys_mkdir (gldir);
860
861         VID_SetPalette(palette);
862
863         Check_Gamma(palette);
864
865         VID_Init8bitPalette();
866
867         if (is8bit) // LordHavoc: avoid calculating 15to8 table if it won't be used
868                 VID_Setup15to8Palette ();
869
870         Con_SafePrintf ("Video mode %dx%d initialized.\n", width, height);
871
872         vid.recalc_refdef = 1;                          // force a surface cache flush
873 }
874
875 void Sys_SendKeyEvents(void)
876 {
877         HandleEvents();
878 }
879
880 void Force_CenterView_f (void)
881 {
882         cl.viewangles[PITCH] = 0;
883 }
884
885 void IN_Init(void)
886 {
887 }
888
889 void IN_Shutdown(void)
890 {
891 }
892
893 /*
894 ===========
895 IN_Commands
896 ===========
897 */
898 void IN_Commands (void)
899 {
900         if (!dpy || !win)
901                 return;
902
903         if (vidmode_active || key_dest == key_game)
904                 IN_ActivateMouse();
905         else
906                 IN_DeactivateMouse ();
907 }
908
909 /*
910 ===========
911 IN_Move
912 ===========
913 */
914 void IN_MouseMove (usercmd_t *cmd)
915 {
916         if (!mouse_avail)
917                 return;
918    
919         if (m_filter.value)
920         {
921                 mx = (mx + old_mouse_x) * 0.5;
922                 my = (my + old_mouse_y) * 0.5;
923         }
924         old_mouse_x = mx;
925         old_mouse_y = my;
926
927         mx *= sensitivity.value;
928         my *= sensitivity.value;
929
930 // add mouse X/Y movement to cmd
931         if ( (in_strafe.state & 1) || (lookstrafe.value && (in_mlook.state & 1) ))
932                 cmd->sidemove += m_side.value * mx;
933         else
934                 cl.viewangles[YAW] -= m_yaw.value * mx;
935         
936         if (in_mlook.state & 1)
937                 V_StopPitchDrift ();
938                 
939         if ( (in_mlook.state & 1) && !(in_strafe.state & 1))
940         {
941                 cl.viewangles[PITCH] += m_pitch.value * my;
942                 if (cl.viewangles[PITCH] > 80)
943                         cl.viewangles[PITCH] = 80;
944                 if (cl.viewangles[PITCH] < -70)
945                         cl.viewangles[PITCH] = -70;
946         }
947         else
948         {
949                 if ((in_strafe.state & 1) && noclip_anglehack)
950                         cmd->upmove -= m_forward.value * my;
951                 else
952                         cmd->forwardmove -= m_forward.value * my;
953         }
954         mx = my = 0;
955 }
956
957 void IN_Move (usercmd_t *cmd)
958 {
959         IN_MouseMove(cmd);
960 }
961
962