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/XShm.h>
  38 #include <X11/extensions/xf86dga.h>
  39 #include <X11/extensions/xf86vmode.h>
  40
  41 static Display *dpy = NULL;
  42 static int scrnum;
  43 static Window win;
  44 static GLXContext ctx = NULL;
  45
  46 #define KEY_MASK (KeyPressMask | KeyReleaseMask)
  47 #define MOUSE_MASK (ButtonPressMask | ButtonReleaseMask | \
  48                     PointerMotionMask | ButtonMotionMask )
  49 #define X_MASK (KEY_MASK | MOUSE_MASK | VisibilityChangeMask | StructureNotifyMask )
  50
  51
  52 viddef_t        vid;                            // global video state
  53
  54 static qboolean         mouse_avail = true;
  55 static qboolean         mouse_active = false, usingmouse = false;
  56 // static qboolean              dga_active;
  57 static float    mouse_x, mouse_y;
  58 static float    old_mouse_x, old_mouse_y;
  59 static int p_mouse_x, p_mouse_y;
  60
  61 cvar_t vid_dga = {"vid_dga", "1", true};
  62 cvar_t vid_dga_mouseaccel = {"vid_dga_mouseaccel", "1", false};
  63 cvar_t m_filter = {"m_filter", "0"};
  64
  65 qboolean vidmode_ext = false;
  66
  67 static int win_x, win_y;
  68
  69 static int scr_width, scr_height;
  70
  71 static XF86VidModeModeInfo **vidmodes;
  72 //static int default_dotclock_vidmode;
  73 static int num_vidmodes;
  74 static qboolean vidmode_active = false;
  75
  76 /*-----------------------------------------------------------------------*/
  77
  78 float           gldepthmin, gldepthmax;
  79
  80 const char *gl_vendor;
  81 const char *gl_renderer;
  82 const char *gl_version;
  83 const char *gl_extensions;
  84
  85 /*-----------------------------------------------------------------------*/
  86 static int
  87 XLateKey(XKeyEvent *ev/*, qboolean modified*/)
  88 {
  89 //      char tmp[2];
  90         int key = 0;
  91         KeySym keysym;
  92
  93         keysym = XLookupKeysym(ev, 0);
  94
  95         switch(keysym)
  96         {
  97                 case XK_KP_Page_Up:     key = KP_PGUP; break;
  98                 case XK_Page_Up:        key = K_PGUP; break;
  99
 100                 case XK_KP_Page_Down:   key = KP_PGDN; break;
 101                 case XK_Page_Down:      key = K_PGDN; break;
 102
 103                 case XK_KP_Home:        key = KP_HOME; break;
 104                 case XK_Home:           key = K_HOME; break;
 105
 106                 case XK_KP_End:         key = KP_END; break;
 107                 case XK_End:            key = K_END; break;
 108
 109                 case XK_KP_Left:        key = KP_LEFTARROW; break;
 110                 case XK_Left:           key = K_LEFTARROW; break;
 111
 112                 case XK_KP_Right:       key = KP_RIGHTARROW; break;
 113                 case XK_Right:          key = K_RIGHTARROW; break;
 114
 115                 case XK_KP_Down:        key = KP_DOWNARROW; break;
 116                 case XK_Down:           key = K_DOWNARROW; break;
 117
 118                 case XK_KP_Up:          key = KP_UPARROW; break;
 119                 case XK_Up:                     key = K_UPARROW; break;
 120
 121                 case XK_Escape:         key = K_ESCAPE; break;
 122
 123                 case XK_KP_Enter:       key = KP_ENTER; break;
 124                 case XK_Return:         key = K_ENTER; break;
 125
 126                 case XK_Tab:            key = K_TAB; break;
 127
 128                 case XK_F1:                     key = K_F1; break;
 129                 case XK_F2:                     key = K_F2; break;
 130                 case XK_F3:                     key = K_F3; break;
 131                 case XK_F4:                     key = K_F4; break;
 132                 case XK_F5:                     key = K_F5; break;
 133                 case XK_F6:                     key = K_F6; break;
 134                 case XK_F7:                     key = K_F7; break;
 135                 case XK_F8:                     key = K_F8; break;
 136                 case XK_F9:                     key = K_F9; break;
 137                 case XK_F10:            key = K_F10; break;
 138                 case XK_F11:            key = K_F11; break;
 139                 case XK_F12:            key = K_F12; break;
 140
 141                 case XK_BackSpace:      key = K_BACKSPACE; break;
 142
 143                 case XK_KP_Delete:      key = KP_DEL; break;
 144                 case XK_Delete:         key = K_DEL; break;
 145
 146                 case XK_Pause:          key = K_PAUSE; break;
 147
 148                 case XK_Shift_L:
 149                 case XK_Shift_R:        key = K_SHIFT; break;
 150
 151                 case XK_Execute:
 152                 case XK_Control_L:
 153                 case XK_Control_R:      key = K_CTRL; break;
 154
 155                 case XK_Mode_switch:
 156                 case XK_Alt_L:
 157                 case XK_Meta_L:
 158                 case XK_Alt_R:
 159                 case XK_Meta_R:         key = K_ALT; break;
 160
 161                 case XK_Caps_Lock:      key = K_CAPSLOCK; break;
 162                 case XK_KP_Begin:       key = KP_5; break;
 163
 164                 case XK_Insert:         key = K_INS; break;
 165                 case XK_KP_Insert:      key = KP_INS; break;
 166
 167                 case XK_KP_Multiply:    key = KP_MULTIPLY; break;
 168                 case XK_KP_Add:         key = KP_PLUS; break;
 169                 case XK_KP_Subtract:    key = KP_MINUS; break;
 170                 case XK_KP_Divide:      key = KP_DIVIDE; break;
 171
 172                 /* For Sun keyboards */
 173                 case XK_F27:            key = K_HOME; break;
 174                 case XK_F29:            key = K_PGUP; break;
 175                 case XK_F33:            key = K_END; break;
 176                 case XK_F35:            key = K_PGDN; break;
 177
 178                 default:
 179                         if (keysym < 128)
 180                         {
 181                                 /* ASCII keys */
 182                                 key = keysym;
 183                                 if (/*!modified && */((key >= 'A') && (key <= 'Z')))
 184                                         key = key + ('a' - 'A');
 185                         }
 186                         break;
 187         }
 188
 189         return key;
 190 }
 191
 192 static Cursor CreateNullCursor(Display *display, Window root)
 193 {
 194         Pixmap cursormask;
 195         XGCValues xgc;
 196         GC gc;
 197         XColor dummycolour;
 198         Cursor cursor;
 199
 200         cursormask = XCreatePixmap(display, root, 1, 1, 1/*depth*/);
 201         xgc.function = GXclear;
 202         gc =  XCreateGC(display, cursormask, GCFunction, &xgc);
 203         XFillRectangle(display, cursormask, gc, 0, 0, 1, 1);
 204         dummycolour.pixel = 0;
 205         dummycolour.red = 0;
 206         dummycolour.flags = 04;
 207         cursor = XCreatePixmapCursor(display, cursormask, cursormask, &dummycolour,&dummycolour, 0,0);
 208         XFreePixmap(display,cursormask);
 209         XFreeGC(display,gc);
 210         return cursor;
 211 }
 212
 213 static void install_grabs(void)
 214 {
 215         XWindowAttributes attribs_1;
 216         XSetWindowAttributes attribs_2;
 217
 218         XGetWindowAttributes(dpy, win, &attribs_1);
 219         attribs_2.event_mask = attribs_1.your_event_mask | KEY_MASK | MOUSE_MASK;
 220         XChangeWindowAttributes(dpy, win, CWEventMask, &attribs_2);
 221
 222 // inviso cursor
 223         XDefineCursor(dpy, win, CreateNullCursor(dpy, win));
 224
 225         XGrabPointer(dpy, win,  True, 0, GrabModeAsync, GrabModeAsync, win, None, CurrentTime);
 226
 227         if (vid_dga.value)
 228         {
 229                 int MajorVersion, MinorVersion;
 230
 231                 if (!XF86DGAQueryVersion(dpy, &MajorVersion, &MinorVersion))
 232                 {
 233                         // unable to query, probalby not supported
 234                         Con_Printf( "Failed to detect XF86DGA Mouse\n" );
 235                         vid_dga.value = 0;
 236                 }
 237                 else
 238                 {
 239                         vid_dga.value = 1;
 240                         XF86DGADirectVideo(dpy, DefaultScreen(dpy), XF86DGADirectMouse);
 241                         XWarpPointer(dpy, None, win, 0, 0, 0, 0, 0, 0);
 242                 }
 243         }
 244         else
 245                 XWarpPointer(dpy, None, win, 0, 0, 0, 0, vid.width / 2, vid.height / 2);
 246
 247         XGrabKeyboard(dpy, win, False, GrabModeAsync, GrabModeAsync, CurrentTime);
 248
 249         mouse_active = true;
 250         mouse_x = mouse_y = 0;
 251
 252 //      XSync(dpy, True);
 253 }
 254
 255 static void uninstall_grabs(void)
 256 {
 257         if (!dpy || !win)
 258                 return;
 259
 260         if (vid_dga.value == 1)
 261                 XF86DGADirectVideo(dpy, DefaultScreen(dpy), 0);
 262
 263         XUngrabPointer(dpy, CurrentTime);
 264         XUngrabKeyboard(dpy, CurrentTime);
 265
 266 // inviso cursor
 267         XUndefineCursor(dpy, win);
 268
 269         mouse_active = false;
 270 }
 271
 272 static void HandleEvents(void)
 273 {
 274         XEvent event;
 275 //      KeySym ks;
 276         qboolean dowarp = false;
 277
 278         if (!dpy)
 279                 return;
 280
 281         while (XPending(dpy))
 282         {
 283                 XNextEvent(dpy, &event);
 284
 285                 switch (event.type)
 286                 {
 287                 case KeyPress:
 288                 case KeyRelease:
 289                         Key_Event(XLateKey(&event.xkey), event.type == KeyPress);
 290                         break;
 291
 292                 case MotionNotify:
 293                         if (usingmouse)
 294                         {
 295                                 if (vid_dga.value == 1)
 296                                 {
 297                                         mouse_x += event.xmotion.x_root * vid_dga_mouseaccel.value;
 298                                         mouse_y += event.xmotion.y_root * vid_dga_mouseaccel.value;
 299                                 }
 300                                 else
 301                                 {
 302                                         /*
 303                                         if (!p_mouse_x && !p_mouse_y)
 304                                         {
 305                                                 Con_Printf("event->xmotion.x: %d\n", event.xmotion.x);
 306                                                 Con_Printf("event->xmotion.y: %d\n", event.xmotion.y);
 307                                         }
 308                                         */
 309                                         //if (usingmouse)
 310                                         {
 311                                                 if (!event.xmotion.send_event)
 312                                                 {
 313                                                         mouse_x += (event.xmotion.x - p_mouse_x);
 314                                                         mouse_y += (event.xmotion.y - p_mouse_y);
 315                                                         if (abs(vid.width/2 - event.xmotion.x) > vid.width / 4 || abs(vid.height/2 - event.xmotion.y) > vid.height / 4)
 316                                                                 dowarp = true;
 317                                                 }
 318                                         }
 319                                         /*
 320                                         else
 321                                         {
 322                                                 mouse_x += (event.xmotion.x - p_mouse_x);
 323                                                 mouse_y += (event.xmotion.y - p_mouse_y);
 324                                         }
 325                                         */
 326                                         p_mouse_x = event.xmotion.x;
 327                                         p_mouse_y = event.xmotion.y;
 328                                 }
 329                         }
 330                         break;
 331
 332                 case ButtonPress:
 333                         switch(event.xbutton.button)
 334                         {
 335                         case 1:
 336                                 Key_Event(K_MOUSE1, true);
 337                                 break;
 338                         case 2:
 339                                 Key_Event(K_MOUSE3, true);
 340                                 break;
 341                         case 3:
 342                                 Key_Event(K_MOUSE2, true);
 343                                 break;
 344                         case 4:
 345                                 Key_Event(K_MWHEELUP, true);
 346                                 break;
 347                         case 5:
 348                                 Key_Event(K_MWHEELDOWN, true);
 349                                 break;
 350                 default:
 351                                 Con_Printf("HandleEvents: ButtonPress gave value %d, 1-5 expected\n", event.xbutton.button);
 352                                 break;
 353                         }
 354                         break;
 355
 356                 case ButtonRelease:
 357                         switch(event.xbutton.button)
 358                         {
 359                         case 1:
 360                                 Key_Event(K_MOUSE1, false);
 361                                 break;
 362                         case 2:
 363                                 Key_Event(K_MOUSE3, false);
 364                                 break;
 365                         case 3:
 366                                 Key_Event(K_MOUSE2, false);
 367                                 break;
 368                         case 4:
 369                                 Key_Event(K_MWHEELUP, false);
 370                                 break;
 371                         case 5:
 372                                 Key_Event(K_MWHEELDOWN, false);
 373                                 break;
 374                 default:
 375                                 Con_Printf("HandleEvents: ButtonRelease gave value %d, 1-5 expected\n", event.xbutton.button);
 376                                 break;
 377                         }
 378                         break;
 379
 380                 case CreateNotify :
 381                         win_x = event.xcreatewindow.x;
 382                         win_y = event.xcreatewindow.y;
 383                         break;
 384
 385                 case ConfigureNotify :
 386                         win_x = event.xconfigure.x;
 387                         win_y = event.xconfigure.y;
 388                         break;
 389                 }
 390         }
 391
 392         if (dowarp)
 393         {
 394                 /* move the mouse to the window center again */
 395                 p_mouse_x = vid.width / 2;
 396                 p_mouse_y = vid.height / 2;
 397                 XWarpPointer(dpy, None, win, 0, 0, 0, 0, p_mouse_x, p_mouse_y);
 398         }
 399
 400 }
 401
 402 static void IN_DeactivateMouse( void )
 403 {
 404         if (!mouse_avail || !dpy || !win)
 405                 return;
 406
 407         if (mouse_active)
 408         {
 409                 uninstall_grabs();
 410                 mouse_active = false;
 411         }
 412 }
 413
 414 static void IN_ActivateMouse( void )
 415 {
 416         if (!mouse_avail || !dpy || !win)
 417                 return;
 418
 419         if (!mouse_active)
 420         {
 421                 mouse_x = mouse_y = 0; // don't spazz
 422                 install_grabs();
 423                 mouse_active = true;
 424         }
 425 }
 426
 427
 428 void VID_Shutdown(void)
 429 {
 430         if (!ctx || !dpy)
 431                 return;
 432
 433         if (dpy)
 434         {
 435                 uninstall_grabs();
 436
 437                 if (vidmode_active)
 438                         XF86VidModeSwitchToMode(dpy, scrnum, vidmodes[0]);
 439 /* Disabled, causes a segfault during shutdown.
 440                 if (ctx)
 441                         glXDestroyContext(dpy, ctx);
 442 */
 443                 if (win)
 444                         XDestroyWindow(dpy, win);
 445                 XCloseDisplay(dpy);
 446         }
 447         vidmode_active = false;
 448         dpy = NULL;
 449         win = 0;
 450         ctx = NULL;
 451 }
 452
 453 void signal_handler(int sig)
 454 {
 455         printf("Received signal %d, exiting...\n", sig);
 456         Sys_Quit();
 457         exit(0);
 458 }
 459
 460 void InitSig(void)
 461 {
 462         signal(SIGHUP, signal_handler);
 463         signal(SIGINT, signal_handler);
 464         signal(SIGQUIT, signal_handler);
 465         signal(SIGILL, signal_handler);
 466         signal(SIGTRAP, signal_handler);
 467         signal(SIGIOT, signal_handler);
 468         signal(SIGBUS, signal_handler);
 469         signal(SIGFPE, signal_handler);
 470         signal(SIGSEGV, signal_handler);
 471         signal(SIGTERM, signal_handler);
 472 }
 473
 474 void VID_CheckMultitexture(void)
 475 {
 476         void *prjobj;
 477         qglMTexCoord2f = NULL;
 478         qglSelectTexture = NULL;
 479         // Check to see if multitexture is disabled
 480         if (COM_CheckParm("-nomtex"))
 481         {
 482                 Con_Printf("...multitexture disabled\n");
 483                 return;
 484         }
 485         if ((prjobj = dlopen(NULL, RTLD_LAZY)) == NULL)
 486         {
 487                 Con_Printf("Unable to open symbol list for main program.\n");
 488                 return;
 489         }
 490         // Test for ARB_multitexture
 491         if (!COM_CheckParm("-SGISmtex") && strstr(gl_extensions, "GL_ARB_multitexture "))
 492         {
 493                 Con_Printf("...using GL_ARB_multitexture\n");
 494                 qglMTexCoord2f = (void *) dlsym(prjobj, "glMultiTexCoord2fARB");
 495                 qglSelectTexture = (void *) dlsym(prjobj, "glActiveTextureARB");
 496                 gl_mtexable = true;
 497                 gl_mtex_enum = GL_TEXTURE0_ARB;
 498         }
 499         else if (strstr(gl_extensions, "GL_SGIS_multitexture ")) // Test for SGIS_multitexture (if ARB_multitexture not found)
 500         {
 501                 Con_Printf("...using GL_SGIS_multitexture\n");
 502                 qglMTexCoord2f = (void *) dlsym(prjobj, "glMTexCoord2fSGIS");
 503                 qglSelectTexture = (void *) dlsym(prjobj, "glSelectTextureSGIS");
 504                 gl_mtexable = true;
 505                 gl_mtex_enum = TEXTURE0_SGIS;
 506         }
 507         else
 508                 Con_Printf("...multitexture disabled (not detected)\n");
 509         dlclose(prjobj);
 510 }
 511
 512 void VID_CheckCVA(void)
 513 {
 514         void *prjobj;
 515         qglLockArraysEXT = NULL;
 516         qglUnlockArraysEXT = NULL;
 517         gl_supportslockarrays = false;
 518         if (COM_CheckParm("-nocva"))
 519         {
 520                 Con_Printf("...compiled vertex arrays disabled\n");
 521                 return;
 522         }
 523         if ((prjobj = dlopen(NULL, RTLD_LAZY)) == NULL)
 524         {
 525                 Con_Printf("Unable to open symbol list for main program.\n");
 526                 return;
 527         }
 528         if (strstr(gl_extensions, "GL_EXT_compiled_vertex_array"))
 529         {
 530                 Con_Printf("...using compiled vertex arrays\n");
 531                 qglLockArraysEXT = (void *) dlsym(prjobj, "glLockArraysEXT");
 532                 qglUnlockArraysEXT = (void *) dlsym(prjobj, "glUnlockArraysEXT");
 533                 gl_supportslockarrays = true;
 534         }
 535         dlclose(prjobj);
 536 }
 537
 538 /*
 539 =================
 540 GL_BeginRendering
 541
 542 =================
 543 */
 544 void GL_BeginRendering (int *x, int *y, int *width, int *height)
 545 {
 546         *x = *y = 0;
 547         *width = scr_width;
 548         *height = scr_height;
 549
 550 //      glViewport (*x, *y, *width, *height);
 551 }
 552
 553
 554 void GL_EndRendering (void)
 555 {
 556         int usemouse;
 557         if (!r_render.value)
 558                 return;
 559         glFlush();
 560         glXSwapBuffers(dpy, win);
 561
 562 // handle the mouse state when windowed if that's changed
 563         usemouse = false;
 564         if (vid_mouse.value && key_dest == key_game)
 565                 usemouse = true;
 566         if (vidmode_active)
 567                 usemouse = true;
 568         if (usemouse)
 569         {
 570                 if (!usingmouse)
 571                 {
 572                         usingmouse = true;
 573                         IN_ActivateMouse ();
 574                 }
 575         }
 576         else
 577         {
 578                 if (usingmouse)
 579                 {
 580                         usingmouse = false;
 581                         IN_DeactivateMouse ();
 582                 }
 583         }
 584 }
 585
 586 int VID_SetGamma(float prescale, float gamma, float scale, float base)
 587 {
 588         return FALSE;
 589 }
 590
 591 void VID_Init(void)
 592 {
 593         int i;
 594         int attrib[] =
 595         {
 596                 GLX_RGBA,
 597                 GLX_RED_SIZE, 1,
 598                 GLX_GREEN_SIZE, 1,
 599                 GLX_BLUE_SIZE, 1,
 600                 GLX_DOUBLEBUFFER,
 601                 GLX_DEPTH_SIZE, 1,
 602                 None
 603         };
 604 //      char    gldir[MAX_OSPATH];
 605         int width = 640, height = 480;
 606         XSetWindowAttributes attr;
 607         unsigned long mask;
 608         Window root;
 609         XVisualInfo *visinfo;
 610         qboolean fullscreen = true;
 611         int MajorVersion, MinorVersion;
 612         int actualWidth, actualHeight;
 613
 614         Cvar_RegisterVariable (&vid_mouse);
 615         Cvar_RegisterVariable (&vid_dga);
 616         Cvar_RegisterVariable (&vid_dga_mouseaccel);
 617         Cvar_RegisterVariable (&m_filter);
 618
 619 // interpret command-line params
 620
 621 // set vid parameters
 622         if ((i = COM_CheckParm("-window")) != 0)
 623                 fullscreen = false;
 624
 625         if ((i = COM_CheckParm("-width")) != 0)
 626                 width = atoi(com_argv[i+1]);
 627
 628         if ((i = COM_CheckParm("-height")) != 0)
 629                 height = atoi(com_argv[i+1]);
 630
 631         if ((i = COM_CheckParm("-conwidth")) != 0)
 632                 vid.conwidth = atoi(com_argv[i+1]);
 633         else
 634                 vid.conwidth = 640;
 635
 636         vid.conwidth &= 0xfff8; // make it a multiple of eight
 637
 638         if (vid.conwidth < 320)
 639                 vid.conwidth = 320;
 640
 641         // pick a conheight that matches with correct aspect
 642         vid.conheight = vid.conwidth*3 / 4;
 643
 644         if ((i = COM_CheckParm("-conheight")) != 0)
 645                 vid.conheight = atoi(com_argv[i+1]);
 646         if (vid.conheight < 200)
 647                 vid.conheight = 200;
 648
 649         if (!(dpy = XOpenDisplay(NULL)))
 650         {
 651                 fprintf(stderr, "Error couldn't open the X display\n");
 652                 exit(1);
 653         }
 654
 655         scrnum = DefaultScreen(dpy);
 656         root = RootWindow(dpy, scrnum);
 657
 658         // Get video mode list
 659         MajorVersion = MinorVersion = 0;
 660         if (!XF86VidModeQueryVersion(dpy, &MajorVersion, &MinorVersion))
 661                 vidmode_ext = false;
 662         else
 663         {
 664                 Con_Printf("Using XFree86-VidModeExtension Version %d.%d\n", MajorVersion, MinorVersion);
 665                 vidmode_ext = true;
 666         }
 667
 668         visinfo = glXChooseVisual(dpy, scrnum, attrib);
 669         if (!visinfo)
 670         {
 671                 fprintf(stderr, "qkHack: Error couldn't get an RGB, Double-buffered, Depth visual\n");
 672                 exit(1);
 673         }
 674
 675         if (vidmode_ext)
 676         {
 677                 int best_fit, best_dist, dist, x, y;
 678
 679                 XF86VidModeGetAllModeLines(dpy, scrnum, &num_vidmodes, &vidmodes);
 680
 681                 // Are we going fullscreen?  If so, let's change video mode
 682                 if (fullscreen)
 683                 {
 684                         best_dist = 9999999;
 685                         best_fit = -1;
 686
 687                         for (i = 0; i < num_vidmodes; i++)
 688                         {
 689                                 if (width > vidmodes[i]->hdisplay || height > vidmodes[i]->vdisplay)
 690                                         continue;
 691
 692                                 x = width - vidmodes[i]->hdisplay;
 693                                 y = height - vidmodes[i]->vdisplay;
 694                                 dist = (x * x) + (y * y);
 695                                 if (dist < best_dist)
 696                                 {
 697                                         best_dist = dist;
 698                                         best_fit = i;
 699                                 }
 700                         }
 701
 702                         if (best_fit != -1)
 703                         {
 704                                 actualWidth = vidmodes[best_fit]->hdisplay;
 705                                 actualHeight = vidmodes[best_fit]->vdisplay;
 706
 707                                 // change to the mode
 708                                 XF86VidModeSwitchToMode(dpy, scrnum, vidmodes[best_fit]);
 709                                 vidmode_active = true;
 710
 711                                 // Move the viewport to top left
 712                                 XF86VidModeSetViewPort(dpy, scrnum, 0, 0);
 713                         }
 714                         else
 715                                 fullscreen = 0;
 716                 }
 717         }
 718
 719         /* window attributes */
 720         attr.background_pixel = 0;
 721         attr.border_pixel = 0;
 722         attr.colormap = XCreateColormap(dpy, root, visinfo->visual, AllocNone);
 723         attr.event_mask = X_MASK;
 724         if (vidmode_active)
 725         {
 726                 mask = CWBackPixel | CWColormap | CWSaveUnder | CWBackingStore | CWEventMask | CWOverrideRedirect;
 727                 attr.override_redirect = True;
 728                 attr.backing_store = NotUseful;
 729                 attr.save_under = False;
 730         }
 731         else
 732                 mask = CWBackPixel | CWBorderPixel | CWColormap | CWEventMask;
 733
 734         win = XCreateWindow(dpy, root, 0, 0, width, height, 0, visinfo->depth, InputOutput, visinfo->visual, mask, &attr);
 735         XStoreName(dpy, win, "DarkPlaces-GLX");
 736         XMapWindow(dpy, win);
 737
 738         if (vidmode_active)
 739         {
 740                 XMoveWindow(dpy, win, 0, 0);
 741                 XRaiseWindow(dpy, win);
 742                 XWarpPointer(dpy, None, win, 0, 0, 0, 0, 0, 0);
 743                 XFlush(dpy);
 744                 // Move the viewport to top left
 745                 XF86VidModeSetViewPort(dpy, scrnum, 0, 0);
 746         }
 747
 748         XFlush(dpy);
 749
 750         ctx = glXCreateContext(dpy, visinfo, NULL, True);
 751
 752         glXMakeCurrent(dpy, win, ctx);
 753
 754         scr_width = width;
 755         scr_height = height;
 756
 757         if (vid.conheight > height)
 758                 vid.conheight = height;
 759         if (vid.conwidth > width)
 760                 vid.conwidth = width;
 761         vid.width = vid.conwidth;
 762         vid.height = vid.conheight;
 763
 764         InitSig(); // trap evil signals
 765
 766         GL_Init();
 767
 768         Con_SafePrintf ("Video mode %dx%d initialized.\n", width, height);
 769
 770         // force a surface cache flush
 771         vid.recalc_refdef = 1;
 772 }
 773
 774 void Sys_SendKeyEvents(void)
 775 {
 776         HandleEvents();
 777 }
 778
 779 void Force_CenterView_f (void)
 780 {
 781         cl.viewangles[PITCH] = 0;
 782 }
 783
 784 void IN_Init(void)
 785 {
 786 }
 787
 788 void IN_Shutdown(void)
 789 {
 790 }
 791
 792 /*
 793 ===========
 794 IN_Commands
 795 ===========
 796 */
 797 void IN_Commands (void)
 798 {
 799 }
 800
 801 /*
 802 ===========
 803 IN_Move
 804 ===========
 805 */
 806 void IN_MouseMove (usercmd_t *cmd)
 807 {
 808         if (!mouse_avail)
 809                 return;
 810
 811         if (m_filter.value)
 812         {
 813                 mouse_x = (mouse_x + old_mouse_x) * 0.5;
 814                 mouse_y = (mouse_y + old_mouse_y) * 0.5;
 815
 816                 old_mouse_x = mouse_x;
 817                 old_mouse_y = mouse_y;
 818         }
 819
 820         mouse_x *= sensitivity.value;
 821         mouse_y *= sensitivity.value;
 822
 823         if (in_strafe.state & 1)
 824                 cmd->sidemove += m_side.value * mouse_x;
 825         else
 826                 cl.viewangles[YAW] -= m_yaw.value * mouse_x;
 827
 828         //if (freelook)
 829                 V_StopPitchDrift ();
 830
 831         if (/*freelook && */!(in_strafe.state & 1))
 832         {
 833                 cl.viewangles[PITCH] += m_pitch.value * mouse_y;
 834                 cl.viewangles[PITCH] = bound (-70, cl.viewangles[PITCH], 80);
 835         }
 836         else
 837         {
 838                 if ((in_strafe.state & 1) && noclip_anglehack)
 839                         cmd->upmove -= m_forward.value * mouse_y;
 840                 else
 841                         cmd->forwardmove -= m_forward.value * mouse_y;
 842         }
 843         mouse_x = mouse_y = 0.0;
 844 }
 845
 846 void IN_Move (usercmd_t *cmd)
 847 {
 848         IN_MouseMove(cmd);
 849 }
 850
 851