![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to gl_glx.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Quake II] / quake2 / linux|
Return to gl_glx.c CVS log | Up to [Quake II] / quake2 / linux |
1.1 ! root 1: /* ! 2: Copyright (C) 1997-2001 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: /* ! 21: ** GLW_IMP.C ! 22: ** ! 23: ** This file contains ALL Linux specific stuff having to do with the ! 24: ** OpenGL refresh. When a port is being made the following functions ! 25: ** must be implemented by the port: ! 26: ** ! 27: ** GLimp_EndFrame ! 28: ** GLimp_Init ! 29: ** GLimp_Shutdown ! 30: ** GLimp_SwitchFullscreen ! 31: ** ! 32: */ ! 33: ! 34: #include <termios.h> ! 35: #include <sys/ioctl.h> ! 36: #include <sys/stat.h> ! 37: #include <sys/vt.h> ! 38: #include <stdarg.h> ! 39: #include <stdio.h> ! 40: #include <signal.h> ! 41: ! 42: #include "../ref_gl/gl_local.h" ! 43: ! 44: #include "../client/keys.h" ! 45: ! 46: #include "../linux/rw_linux.h" ! 47: #include "../linux/glw_linux.h" ! 48: ! 49: #include <GL/glx.h> ! 50: ! 51: #include <X11/keysym.h> ! 52: #include <X11/cursorfont.h> ! 53: ! 54: #include <X11/extensions/xf86dga.h> ! 55: #include <X11/extensions/xf86vmode.h> ! 56: ! 57: glwstate_t glw_state; ! 58: ! 59: static Display *dpy = NULL; ! 60: static int scrnum; ! 61: static Window win; ! 62: static GLXContext ctx = NULL; ! 63: ! 64: #define KEY_MASK (KeyPressMask | KeyReleaseMask) ! 65: #define MOUSE_MASK (ButtonPressMask | ButtonReleaseMask | \ ! 66: PointerMotionMask | ButtonMotionMask ) ! 67: #define X_MASK (KEY_MASK | MOUSE_MASK | VisibilityChangeMask | StructureNotifyMask ) ! 68: ! 69: /*****************************************************************************/ ! 70: /* MOUSE */ ! 71: /*****************************************************************************/ ! 72: ! 73: // this is inside the renderer shared lib, so these are called from vid_so ! 74: ! 75: static qboolean mouse_avail; ! 76: static int mx, my; ! 77: static int old_mouse_x, old_mouse_y; ! 78: ! 79: static int win_x, win_y; ! 80: ! 81: static cvar_t *m_filter; ! 82: static cvar_t *in_mouse; ! 83: static cvar_t *in_dgamouse; ! 84: ! 85: static cvar_t *r_fakeFullscreen; ! 86: ! 87: static XF86VidModeModeInfo **vidmodes; ! 88: static int default_dotclock_vidmode; ! 89: static int num_vidmodes; ! 90: static qboolean vidmode_active = false; ! 91: ! 92: static qboolean mlooking; ! 93: ! 94: static qboolean mouse_active = false; ! 95: static qboolean dgamouse = false; ! 96: static qboolean vidmode_ext = false; ! 97: ! 98: // state struct passed in Init ! 99: static in_state_t *in_state; ! 100: ! 101: static cvar_t *sensitivity; ! 102: static cvar_t *lookstrafe; ! 103: static cvar_t *m_side; ! 104: static cvar_t *m_yaw; ! 105: static cvar_t *m_pitch; ! 106: static cvar_t *m_forward; ! 107: static cvar_t *freelook; ! 108: ! 109: static Cursor CreateNullCursor(Display *display, Window root) ! 110: { ! 111: Pixmap cursormask; ! 112: XGCValues xgc; ! 113: GC gc; ! 114: XColor dummycolour; ! 115: Cursor cursor; ! 116: ! 117: cursormask = XCreatePixmap(display, root, 1, 1, 1/*depth*/); ! 118: xgc.function = GXclear; ! 119: gc = XCreateGC(display, cursormask, GCFunction, &xgc); ! 120: XFillRectangle(display, cursormask, gc, 0, 0, 1, 1); ! 121: dummycolour.pixel = 0; ! 122: dummycolour.red = 0; ! 123: dummycolour.flags = 04; ! 124: cursor = XCreatePixmapCursor(display, cursormask, cursormask, ! 125: &dummycolour,&dummycolour, 0,0); ! 126: XFreePixmap(display,cursormask); ! 127: XFreeGC(display,gc); ! 128: return cursor; ! 129: } ! 130: ! 131: static void install_grabs(void) ! 132: { ! 133: ! 134: // inviso cursor ! 135: XDefineCursor(dpy, win, CreateNullCursor(dpy, win)); ! 136: ! 137: XGrabPointer(dpy, win, ! 138: True, ! 139: 0, ! 140: GrabModeAsync, GrabModeAsync, ! 141: win, ! 142: None, ! 143: CurrentTime); ! 144: ! 145: if (in_dgamouse->value) { ! 146: int MajorVersion, MinorVersion; ! 147: ! 148: if (!XF86DGAQueryVersion(dpy, &MajorVersion, &MinorVersion)) { ! 149: // unable to query, probalby not supported ! 150: ri.Con_Printf( PRINT_ALL, "Failed to detect XF86DGA Mouse\n" ); ! 151: ri.Cvar_Set( "in_dgamouse", "0" ); ! 152: } else { ! 153: dgamouse = true; ! 154: XF86DGADirectVideo(dpy, DefaultScreen(dpy), XF86DGADirectMouse); ! 155: XWarpPointer(dpy, None, win, 0, 0, 0, 0, 0, 0); ! 156: } ! 157: } else { ! 158: XWarpPointer(dpy, None, win, ! 159: 0, 0, 0, 0, ! 160: vid.width / 2, vid.height / 2); ! 161: } ! 162: ! 163: XGrabKeyboard(dpy, win, ! 164: False, ! 165: GrabModeAsync, GrabModeAsync, ! 166: CurrentTime); ! 167: ! 168: mouse_active = true; ! 169: ! 170: // XSync(dpy, True); ! 171: } ! 172: ! 173: static void uninstall_grabs(void) ! 174: { ! 175: if (!dpy || !win) ! 176: return; ! 177: ! 178: if (dgamouse) { ! 179: dgamouse = false; ! 180: XF86DGADirectVideo(dpy, DefaultScreen(dpy), 0); ! 181: } ! 182: ! 183: XUngrabPointer(dpy, CurrentTime); ! 184: XUngrabKeyboard(dpy, CurrentTime); ! 185: ! 186: // inviso cursor ! 187: XUndefineCursor(dpy, win); ! 188: ! 189: mouse_active = false; ! 190: } ! 191: ! 192: static void Force_CenterView_f (void) ! 193: { ! 194: in_state->viewangles[PITCH] = 0; ! 195: } ! 196: ! 197: static void RW_IN_MLookDown (void) ! 198: { ! 199: mlooking = true; ! 200: } ! 201: ! 202: static void RW_IN_MLookUp (void) ! 203: { ! 204: mlooking = false; ! 205: in_state->IN_CenterView_fp (); ! 206: } ! 207: ! 208: void RW_IN_Init(in_state_t *in_state_p) ! 209: { ! 210: int mtype; ! 211: int i; ! 212: ! 213: in_state = in_state_p; ! 214: ! 215: // mouse variables ! 216: m_filter = ri.Cvar_Get ("m_filter", "0", 0); ! 217: in_mouse = ri.Cvar_Get ("in_mouse", "1", CVAR_ARCHIVE); ! 218: in_dgamouse = ri.Cvar_Get ("in_dgamouse", "1", CVAR_ARCHIVE); ! 219: freelook = ri.Cvar_Get( "freelook", "0", 0 ); ! 220: lookstrafe = ri.Cvar_Get ("lookstrafe", "0", 0); ! 221: sensitivity = ri.Cvar_Get ("sensitivity", "3", 0); ! 222: m_pitch = ri.Cvar_Get ("m_pitch", "0.022", 0); ! 223: m_yaw = ri.Cvar_Get ("m_yaw", "0.022", 0); ! 224: m_forward = ri.Cvar_Get ("m_forward", "1", 0); ! 225: m_side = ri.Cvar_Get ("m_side", "0.8", 0); ! 226: ! 227: ri.Cmd_AddCommand ("+mlook", RW_IN_MLookDown); ! 228: ri.Cmd_AddCommand ("-mlook", RW_IN_MLookUp); ! 229: ! 230: ri.Cmd_AddCommand ("force_centerview", Force_CenterView_f); ! 231: ! 232: mx = my = 0.0; ! 233: mouse_avail = true; ! 234: } ! 235: ! 236: void RW_IN_Shutdown(void) ! 237: { ! 238: mouse_avail = false; ! 239: } ! 240: ! 241: /* ! 242: =========== ! 243: IN_Commands ! 244: =========== ! 245: */ ! 246: void RW_IN_Commands (void) ! 247: { ! 248: } ! 249: ! 250: /* ! 251: =========== ! 252: IN_Move ! 253: =========== ! 254: */ ! 255: void RW_IN_Move (usercmd_t *cmd) ! 256: { ! 257: if (!mouse_avail) ! 258: return; ! 259: ! 260: if (m_filter->value) ! 261: { ! 262: mx = (mx + old_mouse_x) * 0.5; ! 263: my = (my + old_mouse_y) * 0.5; ! 264: } ! 265: ! 266: old_mouse_x = mx; ! 267: old_mouse_y = my; ! 268: ! 269: mx *= sensitivity->value; ! 270: my *= sensitivity->value; ! 271: ! 272: // add mouse X/Y movement to cmd ! 273: if ( (*in_state->in_strafe_state & 1) || ! 274: (lookstrafe->value && mlooking )) ! 275: cmd->sidemove += m_side->value * mx; ! 276: else ! 277: in_state->viewangles[YAW] -= m_yaw->value * mx; ! 278: ! 279: if ( (mlooking || freelook->value) && ! 280: !(*in_state->in_strafe_state & 1)) ! 281: { ! 282: in_state->viewangles[PITCH] += m_pitch->value * my; ! 283: } ! 284: else ! 285: { ! 286: cmd->forwardmove -= m_forward->value * my; ! 287: } ! 288: ! 289: mx = my = 0; ! 290: } ! 291: ! 292: static void IN_DeactivateMouse( void ) ! 293: { ! 294: if (!mouse_avail || !dpy || !win) ! 295: return; ! 296: ! 297: if (mouse_active) { ! 298: uninstall_grabs(); ! 299: mouse_active = false; ! 300: } ! 301: } ! 302: ! 303: static void IN_ActivateMouse( void ) ! 304: { ! 305: if (!mouse_avail || !dpy || !win) ! 306: return; ! 307: ! 308: if (!mouse_active) { ! 309: mx = my = 0; // don't spazz ! 310: install_grabs(); ! 311: mouse_active = true; ! 312: } ! 313: } ! 314: ! 315: void RW_IN_Frame (void) ! 316: { ! 317: } ! 318: ! 319: void RW_IN_Activate(qboolean active) ! 320: { ! 321: if (active || vidmode_active) ! 322: IN_ActivateMouse(); ! 323: else ! 324: IN_DeactivateMouse (); ! 325: } ! 326: ! 327: /*****************************************************************************/ ! 328: /* KEYBOARD */ ! 329: /*****************************************************************************/ ! 330: ! 331: static int XLateKey(XKeyEvent *ev) ! 332: { ! 333: ! 334: int key; ! 335: char buf[64]; ! 336: KeySym keysym; ! 337: ! 338: key = 0; ! 339: ! 340: XLookupString(ev, buf, sizeof buf, &keysym, 0); ! 341: ! 342: switch(keysym) ! 343: { ! 344: case XK_KP_Page_Up: key = K_KP_PGUP; break; ! 345: case XK_Page_Up: key = K_PGUP; break; ! 346: ! 347: case XK_KP_Page_Down: key = K_KP_PGDN; break; ! 348: case XK_Page_Down: key = K_PGDN; break; ! 349: ! 350: case XK_KP_Home: key = K_KP_HOME; break; ! 351: case XK_Home: key = K_HOME; break; ! 352: ! 353: case XK_KP_End: key = K_KP_END; break; ! 354: case XK_End: key = K_END; break; ! 355: ! 356: case XK_KP_Left: key = K_KP_LEFTARROW; break; ! 357: case XK_Left: key = K_LEFTARROW; break; ! 358: ! 359: case XK_KP_Right: key = K_KP_RIGHTARROW; break; ! 360: case XK_Right: key = K_RIGHTARROW; break; ! 361: ! 362: case XK_KP_Down: key = K_KP_DOWNARROW; break; ! 363: case XK_Down: key = K_DOWNARROW; break; ! 364: ! 365: case XK_KP_Up: key = K_KP_UPARROW; break; ! 366: case XK_Up: key = K_UPARROW; break; ! 367: ! 368: case XK_Escape: key = K_ESCAPE; break; ! 369: ! 370: case XK_KP_Enter: key = K_KP_ENTER; break; ! 371: case XK_Return: key = K_ENTER; break; ! 372: ! 373: case XK_Tab: key = K_TAB; break; ! 374: ! 375: case XK_F1: key = K_F1; break; ! 376: ! 377: case XK_F2: key = K_F2; break; ! 378: ! 379: case XK_F3: key = K_F3; break; ! 380: ! 381: case XK_F4: key = K_F4; break; ! 382: ! 383: case XK_F5: key = K_F5; break; ! 384: ! 385: case XK_F6: key = K_F6; break; ! 386: ! 387: case XK_F7: key = K_F7; break; ! 388: ! 389: case XK_F8: key = K_F8; break; ! 390: ! 391: case XK_F9: key = K_F9; break; ! 392: ! 393: case XK_F10: key = K_F10; break; ! 394: ! 395: case XK_F11: key = K_F11; break; ! 396: ! 397: case XK_F12: key = K_F12; break; ! 398: ! 399: case XK_BackSpace: key = K_BACKSPACE; break; ! 400: ! 401: case XK_KP_Delete: key = K_KP_DEL; break; ! 402: case XK_Delete: key = K_DEL; break; ! 403: ! 404: case XK_Pause: key = K_PAUSE; break; ! 405: ! 406: case XK_Shift_L: ! 407: case XK_Shift_R: key = K_SHIFT; break; ! 408: ! 409: case XK_Execute: ! 410: case XK_Control_L: ! 411: case XK_Control_R: key = K_CTRL; break; ! 412: ! 413: case XK_Alt_L: ! 414: case XK_Meta_L: ! 415: case XK_Alt_R: ! 416: case XK_Meta_R: key = K_ALT; break; ! 417: ! 418: case XK_KP_Begin: key = K_KP_5; break; ! 419: ! 420: case XK_Insert:key = K_INS; break; ! 421: case XK_KP_Insert: key = K_KP_INS; break; ! 422: ! 423: case XK_KP_Multiply: key = '*'; break; ! 424: case XK_KP_Add: key = K_KP_PLUS; break; ! 425: case XK_KP_Subtract: key = K_KP_MINUS; break; ! 426: case XK_KP_Divide: key = K_KP_SLASH; break; ! 427: ! 428: #if 0 ! 429: case 0x021: key = '1';break;/* [!] */ ! 430: case 0x040: key = '2';break;/* [@] */ ! 431: case 0x023: key = '3';break;/* [#] */ ! 432: case 0x024: key = '4';break;/* [$] */ ! 433: case 0x025: key = '5';break;/* [%] */ ! 434: case 0x05e: key = '6';break;/* [^] */ ! 435: case 0x026: key = '7';break;/* [&] */ ! 436: case 0x02a: key = '8';break;/* [*] */ ! 437: case 0x028: key = '9';;break;/* [(] */ ! 438: case 0x029: key = '0';break;/* [)] */ ! 439: case 0x05f: key = '-';break;/* [_] */ ! 440: case 0x02b: key = '=';break;/* [+] */ ! 441: case 0x07c: key = '\'';break;/* [|] */ ! 442: case 0x07d: key = '[';break;/* [}] */ ! 443: case 0x07b: key = ']';break;/* [{] */ ! 444: case 0x022: key = '\'';break;/* ["] */ ! 445: case 0x03a: key = ';';break;/* [:] */ ! 446: case 0x03f: key = '/';break;/* [?] */ ! 447: case 0x03e: key = '.';break;/* [>] */ ! 448: case 0x03c: key = ',';break;/* [<] */ ! 449: #endif ! 450: ! 451: default: ! 452: key = *(unsigned char*)buf; ! 453: if (key >= 'A' && key <= 'Z') ! 454: key = key - 'A' + 'a'; ! 455: break; ! 456: } ! 457: ! 458: return key; ! 459: } ! 460: ! 461: ! 462: static void HandleEvents(void) ! 463: { ! 464: XEvent event; ! 465: int b; ! 466: qboolean dowarp = false; ! 467: int mwx = vid.width/2; ! 468: int mwy = vid.height/2; ! 469: ! 470: if (!dpy) ! 471: return; ! 472: ! 473: while (XPending(dpy)) { ! 474: ! 475: XNextEvent(dpy, &event); ! 476: ! 477: switch(event.type) { ! 478: case KeyPress: ! 479: case KeyRelease: ! 480: if (in_state && in_state->Key_Event_fp) ! 481: in_state->Key_Event_fp (XLateKey(&event.xkey), event.type == KeyPress); ! 482: break; ! 483: ! 484: case MotionNotify: ! 485: if (mouse_active) { ! 486: if (dgamouse) { ! 487: mx += (event.xmotion.x + win_x) * 2; ! 488: my += (event.xmotion.y + win_y) * 2; ! 489: } ! 490: else ! 491: { ! 492: mx += ((int)event.xmotion.x - mwx) * 2; ! 493: my += ((int)event.xmotion.y - mwy) * 2; ! 494: mwx = event.xmotion.x; ! 495: mwy = event.xmotion.y; ! 496: ! 497: if (mx || my) ! 498: dowarp = true; ! 499: } ! 500: } ! 501: break; ! 502: ! 503: ! 504: case ButtonPress: ! 505: b=-1; ! 506: if (event.xbutton.button == 1) ! 507: b = 0; ! 508: else if (event.xbutton.button == 2) ! 509: b = 2; ! 510: else if (event.xbutton.button == 3) ! 511: b = 1; ! 512: if (b>=0 && in_state && in_state->Key_Event_fp) ! 513: in_state->Key_Event_fp (K_MOUSE1 + b, true); ! 514: break; ! 515: ! 516: case ButtonRelease: ! 517: b=-1; ! 518: if (event.xbutton.button == 1) ! 519: b = 0; ! 520: else if (event.xbutton.button == 2) ! 521: b = 2; ! 522: else if (event.xbutton.button == 3) ! 523: b = 1; ! 524: if (b>=0 && in_state && in_state->Key_Event_fp) ! 525: in_state->Key_Event_fp (K_MOUSE1 + b, false); ! 526: break; ! 527: ! 528: case CreateNotify : ! 529: win_x = event.xcreatewindow.x; ! 530: win_y = event.xcreatewindow.y; ! 531: break; ! 532: ! 533: case ConfigureNotify : ! 534: win_x = event.xconfigure.x; ! 535: win_y = event.xconfigure.y; ! 536: break; ! 537: } ! 538: } ! 539: ! 540: if (dowarp) { ! 541: /* move the mouse to the window center again */ ! 542: XWarpPointer(dpy,None,win,0,0,0,0, vid.width/2,vid.height/2); ! 543: } ! 544: } ! 545: ! 546: Key_Event_fp_t Key_Event_fp; ! 547: ! 548: void KBD_Init(Key_Event_fp_t fp) ! 549: { ! 550: Key_Event_fp = fp; ! 551: } ! 552: ! 553: void KBD_Update(void) ! 554: { ! 555: // get events from x server ! 556: HandleEvents(); ! 557: } ! 558: ! 559: void KBD_Close(void) ! 560: { ! 561: } ! 562: ! 563: /*****************************************************************************/ ! 564: ! 565: static qboolean GLimp_SwitchFullscreen( int width, int height ); ! 566: qboolean GLimp_InitGL (void); ! 567: ! 568: static void signal_handler(int sig) ! 569: { ! 570: printf("Received signal %d, exiting...\n", sig); ! 571: GLimp_Shutdown(); ! 572: _exit(0); ! 573: } ! 574: ! 575: static void InitSig(void) ! 576: { ! 577: signal(SIGHUP, signal_handler); ! 578: signal(SIGQUIT, signal_handler); ! 579: signal(SIGILL, signal_handler); ! 580: signal(SIGTRAP, signal_handler); ! 581: signal(SIGIOT, signal_handler); ! 582: signal(SIGBUS, signal_handler); ! 583: signal(SIGFPE, signal_handler); ! 584: signal(SIGSEGV, signal_handler); ! 585: signal(SIGTERM, signal_handler); ! 586: } ! 587: ! 588: /* ! 589: ** GLimp_SetMode ! 590: */ ! 591: int GLimp_SetMode( int *pwidth, int *pheight, int mode, qboolean fullscreen ) ! 592: { ! 593: int width, height; ! 594: int attrib[] = { ! 595: GLX_RGBA, ! 596: GLX_RED_SIZE, 1, ! 597: GLX_GREEN_SIZE, 1, ! 598: GLX_BLUE_SIZE, 1, ! 599: GLX_DOUBLEBUFFER, ! 600: GLX_DEPTH_SIZE, 1, ! 601: None ! 602: }; ! 603: Window root; ! 604: XVisualInfo *visinfo; ! 605: XSetWindowAttributes attr; ! 606: unsigned long mask; ! 607: int MajorVersion, MinorVersion; ! 608: int actualWidth, actualHeight; ! 609: int i; ! 610: ! 611: r_fakeFullscreen = ri.Cvar_Get( "r_fakeFullscreen", "0", CVAR_ARCHIVE); ! 612: ! 613: ri.Con_Printf( PRINT_ALL, "Initializing OpenGL display\n"); ! 614: ! 615: if (fullscreen) ! 616: ri.Con_Printf (PRINT_ALL, "...setting fullscreen mode %d:", mode ); ! 617: else ! 618: ri.Con_Printf (PRINT_ALL, "...setting mode %d:", mode ); ! 619: ! 620: if ( !ri.Vid_GetModeInfo( &width, &height, mode ) ) ! 621: { ! 622: ri.Con_Printf( PRINT_ALL, " invalid mode\n" ); ! 623: return rserr_invalid_mode; ! 624: } ! 625: ! 626: ri.Con_Printf( PRINT_ALL, " %d %d\n", width, height ); ! 627: ! 628: // destroy the existing window ! 629: GLimp_Shutdown (); ! 630: ! 631: // Mesa VooDoo hacks ! 632: if (fullscreen) ! 633: putenv("MESA_GLX_FX=fullscreen"); ! 634: else ! 635: putenv("MESA_GLX_FX=window"); ! 636: ! 637: if (!(dpy = XOpenDisplay(NULL))) { ! 638: fprintf(stderr, "Error couldn't open the X display\n"); ! 639: return rserr_invalid_mode; ! 640: } ! 641: ! 642: scrnum = DefaultScreen(dpy); ! 643: root = RootWindow(dpy, scrnum); ! 644: ! 645: // Get video mode list ! 646: MajorVersion = MinorVersion = 0; ! 647: if (!XF86VidModeQueryVersion(dpy, &MajorVersion, &MinorVersion)) { ! 648: vidmode_ext = false; ! 649: } else { ! 650: ri.Con_Printf(PRINT_ALL, "Using XFree86-VidModeExtension Version %d.%d\n", ! 651: MajorVersion, MinorVersion); ! 652: vidmode_ext = true; ! 653: } ! 654: ! 655: visinfo = qglXChooseVisual(dpy, scrnum, attrib); ! 656: if (!visinfo) { ! 657: fprintf(stderr, "Error couldn't get an RGB, Double-buffered, Depth visual\n"); ! 658: return rserr_invalid_mode; ! 659: } ! 660: ! 661: if (vidmode_ext) { ! 662: int best_fit, best_dist, dist, x, y; ! 663: ! 664: XF86VidModeGetAllModeLines(dpy, scrnum, &num_vidmodes, &vidmodes); ! 665: ! 666: // Are we going fullscreen? If so, let's change video mode ! 667: if (fullscreen && !r_fakeFullscreen->value) { ! 668: best_dist = 9999999; ! 669: best_fit = -1; ! 670: ! 671: for (i = 0; i < num_vidmodes; i++) { ! 672: if (width > vidmodes[i]->hdisplay || ! 673: height > vidmodes[i]->vdisplay) ! 674: continue; ! 675: ! 676: x = width - vidmodes[i]->hdisplay; ! 677: y = height - vidmodes[i]->vdisplay; ! 678: dist = (x * x) + (y * y); ! 679: if (dist < best_dist) { ! 680: best_dist = dist; ! 681: best_fit = i; ! 682: } ! 683: } ! 684: ! 685: if (best_fit != -1) { ! 686: actualWidth = vidmodes[best_fit]->hdisplay; ! 687: actualHeight = vidmodes[best_fit]->vdisplay; ! 688: ! 689: // change to the mode ! 690: XF86VidModeSwitchToMode(dpy, scrnum, vidmodes[best_fit]); ! 691: vidmode_active = true; ! 692: ! 693: // Move the viewport to top left ! 694: XF86VidModeSetViewPort(dpy, scrnum, 0, 0); ! 695: } else ! 696: fullscreen = 0; ! 697: } ! 698: } ! 699: ! 700: /* window attributes */ ! 701: attr.background_pixel = 0; ! 702: attr.border_pixel = 0; ! 703: attr.colormap = XCreateColormap(dpy, root, visinfo->visual, AllocNone); ! 704: attr.event_mask = X_MASK; ! 705: if (vidmode_active) { ! 706: mask = CWBackPixel | CWColormap | CWSaveUnder | CWBackingStore | ! 707: CWEventMask | CWOverrideRedirect; ! 708: attr.override_redirect = True; ! 709: attr.backing_store = NotUseful; ! 710: attr.save_under = False; ! 711: } else ! 712: mask = CWBackPixel | CWBorderPixel | CWColormap | CWEventMask; ! 713: ! 714: win = XCreateWindow(dpy, root, 0, 0, width, height, ! 715: 0, visinfo->depth, InputOutput, ! 716: visinfo->visual, mask, &attr); ! 717: XMapWindow(dpy, win); ! 718: ! 719: if (vidmode_active) { ! 720: XMoveWindow(dpy, win, 0, 0); ! 721: XRaiseWindow(dpy, win); ! 722: XWarpPointer(dpy, None, win, 0, 0, 0, 0, 0, 0); ! 723: XFlush(dpy); ! 724: // Move the viewport to top left ! 725: XF86VidModeSetViewPort(dpy, scrnum, 0, 0); ! 726: } ! 727: ! 728: XFlush(dpy); ! 729: ! 730: ctx = qglXCreateContext(dpy, visinfo, NULL, True); ! 731: ! 732: qglXMakeCurrent(dpy, win, ctx); ! 733: ! 734: *pwidth = width; ! 735: *pheight = height; ! 736: ! 737: // let the sound and input subsystems know about the new window ! 738: ri.Vid_NewWindow (width, height); ! 739: ! 740: qglXMakeCurrent(dpy, win, ctx); ! 741: ! 742: return rserr_ok; ! 743: } ! 744: ! 745: /* ! 746: ** GLimp_Shutdown ! 747: ** ! 748: ** This routine does all OS specific shutdown procedures for the OpenGL ! 749: ** subsystem. Under OpenGL this means NULLing out the current DC and ! 750: ** HGLRC, deleting the rendering context, and releasing the DC acquired ! 751: ** for the window. The state structure is also nulled out. ! 752: ** ! 753: */ ! 754: void GLimp_Shutdown( void ) ! 755: { ! 756: uninstall_grabs(); ! 757: mouse_active = false; ! 758: dgamouse = false; ! 759: ! 760: if (dpy) { ! 761: if (ctx) ! 762: qglXDestroyContext(dpy, ctx); ! 763: if (win) ! 764: XDestroyWindow(dpy, win); ! 765: if (vidmode_active) ! 766: XF86VidModeSwitchToMode(dpy, scrnum, vidmodes[0]); ! 767: XCloseDisplay(dpy); ! 768: } ! 769: ctx = NULL; ! 770: dpy = NULL; ! 771: win = 0; ! 772: ctx = NULL; ! 773: } ! 774: ! 775: /* ! 776: ** GLimp_Init ! 777: ** ! 778: ** This routine is responsible for initializing the OS specific portions ! 779: ** of OpenGL. ! 780: */ ! 781: int GLimp_Init( void *hinstance, void *wndproc ) ! 782: { ! 783: InitSig(); ! 784: ! 785: return true; ! 786: } ! 787: ! 788: /* ! 789: ** GLimp_BeginFrame ! 790: */ ! 791: void GLimp_BeginFrame( float camera_seperation ) ! 792: { ! 793: } ! 794: ! 795: /* ! 796: ** GLimp_EndFrame ! 797: ** ! 798: ** Responsible for doing a swapbuffers and possibly for other stuff ! 799: ** as yet to be determined. Probably better not to make this a GLimp ! 800: ** function and instead do a call to GLimp_SwapBuffers. ! 801: */ ! 802: void GLimp_EndFrame (void) ! 803: { ! 804: qglFlush(); ! 805: qglXSwapBuffers(dpy, win); ! 806: } ! 807: ! 808: /* ! 809: ** GLimp_AppActivate ! 810: */ ! 811: void GLimp_AppActivate( qboolean active ) ! 812: { ! 813: } ! 814: ! 815: void Fake_glColorTableEXT( GLenum target, GLenum internalformat, ! 816: GLsizei width, GLenum format, GLenum type, ! 817: const GLvoid *table ) ! 818: { ! 819: byte temptable[256][4]; ! 820: byte *intbl; ! 821: int i; ! 822: ! 823: for (intbl = (byte *)table, i = 0; i < 256; i++) { ! 824: temptable[i][2] = *intbl++; ! 825: temptable[i][1] = *intbl++; ! 826: temptable[i][0] = *intbl++; ! 827: temptable[i][3] = 255; ! 828: } ! 829: qgl3DfxSetPaletteEXT((GLuint *)temptable); ! 830: } ! 831: ! 832: ! 833: /*------------------------------------------------*/ ! 834: /* X11 Input Stuff ! 835: /*------------------------------------------------*/ ! 836:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.