home *** CD-ROM | disk | FTP | other *** search
/ Enigma Amiga Life 113 / EnigmaAmiga113CD.iso / software / sviluppo / quake_src / gl_vidlinuxglx.c < prev    next >
C/C++ Source or Header  |  2000-06-17  |  23KB  |  998 lines
  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. static qboolean        mouse_avail;
  61. static qboolean        mouse_active;
  62. static int   mx, my;
  63. static int  old_mouse_x, old_mouse_y;
  64.  
  65. static cvar_t in_mouse = {"in_mouse", "1", false};
  66. static cvar_t in_dgamouse = {"in_dgamouse", "1", false};
  67. static cvar_t m_filter = {"m_filter", "0"};
  68.  
  69. qboolean dgamouse = false;
  70. qboolean vidmode_ext = false;
  71.  
  72. static int win_x, win_y;
  73.  
  74. static int scr_width, scr_height;
  75.  
  76. static XF86VidModeModeInfo **vidmodes;
  77. static int default_dotclock_vidmode;
  78. static int num_vidmodes;
  79. static qboolean vidmode_active = false;
  80.  
  81. /*-----------------------------------------------------------------------*/
  82.  
  83. //int   texture_mode = GL_NEAREST;
  84. //int   texture_mode = GL_NEAREST_MIPMAP_NEAREST;
  85. //int   texture_mode = GL_NEAREST_MIPMAP_LINEAR;
  86. int   texture_mode = GL_LINEAR;
  87. //int   texture_mode = GL_LINEAR_MIPMAP_NEAREST;
  88. //int   texture_mode = GL_LINEAR_MIPMAP_LINEAR;
  89.  
  90. int   texture_extension_number = 1;
  91.  
  92. float   gldepthmin, gldepthmax;
  93.  
  94. cvar_t  gl_ztrick = {"gl_ztrick","1"};
  95.  
  96. const char *gl_vendor;
  97. const char *gl_renderer;
  98. const char *gl_version;
  99. const char *gl_extensions;
  100.  
  101. void (*qglColorTableEXT) (int, int, int, int, int, const void*);
  102. void (*qgl3DfxSetPaletteEXT) (GLuint *);
  103.  
  104. static float vid_gamma = 1.0;
  105.  
  106. qboolean is8bit = false;
  107. qboolean isPermedia = false;
  108. qboolean gl_mtexable = false;
  109.  
  110. /*-----------------------------------------------------------------------*/
  111. void D_BeginDirectRect (int x, int y, byte *pbitmap, int width, int height)
  112. {
  113. }
  114.  
  115. void D_EndDirectRect (int x, int y, int width, int height)
  116. {
  117. }
  118.  
  119. static int XLateKey(XKeyEvent *ev)
  120. {
  121.  
  122.   int key;
  123.   char buf[64];
  124.   KeySym keysym;
  125.  
  126.   key = 0;
  127.  
  128.   XLookupString(ev, buf, sizeof buf, &keysym, 0);
  129.  
  130.   switch(keysym)
  131.   {
  132.     case XK_KP_Page_Up:  
  133.     case XK_Page_Up:   key = K_PGUP; break;
  134.  
  135.     case XK_KP_Page_Down: 
  136.     case XK_Page_Down:   key = K_PGDN; break;
  137.  
  138.     case XK_KP_Home: 
  139.     case XK_Home:  key = K_HOME; break;
  140.  
  141.     case XK_KP_End:  
  142.     case XK_End:   key = K_END; break;
  143.  
  144.     case XK_KP_Left: 
  145.     case XK_Left:  key = K_LEFTARROW; break;
  146.  
  147.     case XK_KP_Right: 
  148.     case XK_Right:  key = K_RIGHTARROW;   break;
  149.  
  150.     case XK_KP_Down: 
  151.     case XK_Down:  key = K_DOWNARROW; break;
  152.  
  153.     case XK_KP_Up:   
  154.     case XK_Up:    key = K_UPARROW;  break;
  155.  
  156.     case XK_Escape: key = K_ESCAPE;   break;
  157.  
  158.     case XK_KP_Enter: 
  159.     case XK_Return: key = K_ENTER;     break;
  160.  
  161.     case XK_Tab:    key = K_TAB;       break;
  162.  
  163.     case XK_F1:    key = K_F1;        break;
  164.  
  165.     case XK_F2:    key = K_F2;        break;
  166.  
  167.     case XK_F3:    key = K_F3;        break;
  168.  
  169.     case XK_F4:    key = K_F4;        break;
  170.  
  171.     case XK_F5:    key = K_F5;        break;
  172.  
  173.     case XK_F6:    key = K_F6;        break;
  174.  
  175.     case XK_F7:    key = K_F7;        break;
  176.  
  177.     case XK_F8:    key = K_F8;        break;
  178.  
  179.     case XK_F9:    key = K_F9;        break;
  180.  
  181.     case XK_F10:    key = K_F10;       break;
  182.  
  183.     case XK_F11:    key = K_F11;       break;
  184.  
  185.     case XK_F12:    key = K_F12;       break;
  186.  
  187.     case XK_BackSpace: key = K_BACKSPACE; break;
  188.  
  189.     case XK_KP_Delete: 
  190.     case XK_Delete: key = K_DEL; break;
  191.  
  192.     case XK_Pause:  key = K_PAUSE;     break;
  193.  
  194.     case XK_Shift_L:
  195.     case XK_Shift_R:  key = K_SHIFT;    break;
  196.  
  197.     case XK_Execute: 
  198.     case XK_Control_L: 
  199.     case XK_Control_R:  key = K_CTRL;    break;
  200.  
  201.     case XK_Alt_L:  
  202.     case XK_Meta_L: 
  203.     case XK_Alt_R:  
  204.     case XK_Meta_R: key = K_ALT;      break;
  205.  
  206.     case XK_KP_Begin: key = '5';  break;
  207.  
  208.     case XK_KP_Insert: 
  209.     case XK_Insert:key = K_INS; break;
  210.  
  211.     case XK_KP_Multiply: key = '*'; break;
  212.     case XK_KP_Add:  key = '+'; break;
  213.     case XK_KP_Subtract: key = '-'; break;
  214.     case XK_KP_Divide: key = '/'; break;
  215.  
  216. #if 0
  217.     case 0x021: key = '1';break;/* [!] */
  218.     case 0x040: key = '2';break;/* [@] */
  219.     case 0x023: key = '3';break;/* [#] */
  220.     case 0x024: key = '4';break;/* [$] */
  221.     case 0x025: key = '5';break;/* [%] */
  222.     case 0x05e: key = '6';break;/* [^] */
  223.     case 0x026: key = '7';break;/* [&] */
  224.     case 0x02a: key = '8';break;/* [*] */
  225.     case 0x028: key = '9';;break;/* [(] */
  226.     case 0x029: key = '0';break;/* [)] */
  227.     case 0x05f: key = '-';break;/* [_] */
  228.     case 0x02b: key = '=';break;/* [+] */
  229.     case 0x07c: key = '\'';break;/* [|] */
  230.     case 0x07d: key = '[';break;/* [}] */
  231.     case 0x07b: key = ']';break;/* [{] */
  232.     case 0x022: key = '\'';break;/* ["] */
  233.     case 0x03a: key = ';';break;/* [:] */
  234.     case 0x03f: key = '/';break;/* [?] */
  235.     case 0x03e: key = '.';break;/* [>] */
  236.     case 0x03c: key = ',';break;/* [<] */
  237. #endif
  238.  
  239.     default:
  240.       key = *(unsigned char*)buf;
  241.       if (key >= 'A' && key <= 'Z')
  242.         key = key - 'A' + 'a';
  243.       break;
  244.   } 
  245.  
  246.   return key;
  247. }
  248.  
  249. static Cursor CreateNullCursor(Display *display, Window root)
  250. {
  251.     Pixmap cursormask; 
  252.     XGCValues xgc;
  253.     GC gc;
  254.     XColor dummycolour;
  255.     Cursor cursor;
  256.  
  257.     cursormask = XCreatePixmap(display, root, 1, 1, 1/*depth*/);
  258.     xgc.function = GXclear;
  259.     gc =  XCreateGC(display, cursormask, GCFunction, &xgc);
  260.     XFillRectangle(display, cursormask, gc, 0, 0, 1, 1);
  261.     dummycolour.pixel = 0;
  262.     dummycolour.red = 0;
  263.     dummycolour.flags = 04;
  264.     cursor = XCreatePixmapCursor(display, cursormask, cursormask,
  265.           &dummycolour,&dummycolour, 0,0);
  266.     XFreePixmap(display,cursormask);
  267.     XFreeGC(display,gc);
  268.     return cursor;
  269. }
  270.  
  271. static void install_grabs(void)
  272. {
  273.  
  274. // inviso cursor
  275.   XDefineCursor(dpy, win, CreateNullCursor(dpy, win));
  276.  
  277.   XGrabPointer(dpy, win,
  278.          True,
  279.          0,
  280.          GrabModeAsync, GrabModeAsync,
  281.          win,
  282.          None,
  283.          CurrentTime);
  284.  
  285.   if (in_dgamouse.value) {
  286.     int MajorVersion, MinorVersion;
  287.  
  288.     if (!XF86DGAQueryVersion(dpy, &MajorVersion, &MinorVersion)) { 
  289.       // unable to query, probalby not supported
  290.       Con_Printf( "Failed to detect XF86DGA Mouse\n" );
  291.       in_dgamouse.value = 0;
  292.     } else {
  293.       dgamouse = true;
  294.       XF86DGADirectVideo(dpy, DefaultScreen(dpy), XF86DGADirectMouse);
  295.       XWarpPointer(dpy, None, win, 0, 0, 0, 0, 0, 0);
  296.     }
  297.   } else {
  298.     XWarpPointer(dpy, None, win,
  299.            0, 0, 0, 0,
  300.            vid.width / 2, vid.height / 2);
  301.   }
  302.  
  303.   XGrabKeyboard(dpy, win,
  304.           False,
  305.           GrabModeAsync, GrabModeAsync,
  306.           CurrentTime);
  307.  
  308.   mouse_active = true;
  309.  
  310. //  XSync(dpy, True);
  311. }
  312.  
  313. static void uninstall_grabs(void)
  314. {
  315.   if (!dpy || !win)
  316.     return;
  317.  
  318.   if (dgamouse) {
  319.     dgamouse = false;
  320.     XF86DGADirectVideo(dpy, DefaultScreen(dpy), 0);
  321.   }
  322.  
  323.   XUngrabPointer(dpy, CurrentTime);
  324.   XUngrabKeyboard(dpy, CurrentTime);
  325.  
  326. // inviso cursor
  327.   XUndefineCursor(dpy, win);
  328.  
  329.   mouse_active = false;
  330. }
  331.  
  332. static void HandleEvents(void)
  333. {
  334.   XEvent event;
  335.   KeySym ks;
  336.   int b;
  337.   qboolean dowarp = false;
  338.   int mwx = vid.width/2;
  339.   int mwy = vid.height/2;
  340.  
  341.   if (!dpy)
  342.     return;
  343.  
  344.   while (XPending(dpy)) {
  345.     XNextEvent(dpy, &event);
  346.  
  347.     switch (event.type) {
  348.     case KeyPress:
  349.     case KeyRelease:
  350.       Key_Event(XLateKey(&event.xkey), event.type == KeyPress);
  351.       break;
  352.  
  353.     case MotionNotify:
  354.       if (mouse_active) {
  355.         if (dgamouse) {
  356.           mx += (event.xmotion.x + win_x) * 2;
  357.           my += (event.xmotion.y + win_y) * 2;
  358.         } 
  359.         else 
  360.         {
  361.           mx += ((int)event.xmotion.x - mwx) * 2;
  362.           my += ((int)event.xmotion.y - mwy) * 2;
  363.           mwx = event.xmotion.x;
  364.           mwy = event.xmotion.y;
  365.  
  366.           if (mx || my)
  367.             dowarp = true;
  368.         }
  369.       }
  370.       break;
  371.  
  372.       break;
  373.  
  374.     case ButtonPress:
  375.       b=-1;
  376.       if (event.xbutton.button == 1)
  377.         b = 0;
  378.       else if (event.xbutton.button == 2)
  379.         b = 2;
  380.       else if (event.xbutton.button == 3)
  381.         b = 1;
  382.       if (b>=0)
  383.         Key_Event(K_MOUSE1 + b, true);
  384.       break;
  385.  
  386.     case ButtonRelease:
  387.       b=-1;
  388.       if (event.xbutton.button == 1)
  389.         b = 0;
  390.       else if (event.xbutton.button == 2)
  391.         b = 2;
  392.       else if (event.xbutton.button == 3)
  393.         b = 1;
  394.       if (b>=0)
  395.         Key_Event(K_MOUSE1 + b, false);
  396.       break;
  397.  
  398.     case CreateNotify :
  399.       win_x = event.xcreatewindow.x;
  400.       win_y = event.xcreatewindow.y;
  401.       break;
  402.  
  403.     case ConfigureNotify :
  404.       win_x = event.xconfigure.x;
  405.       win_y = event.xconfigure.y;
  406.       break;
  407.     }
  408.   }
  409.  
  410.   if (dowarp) {
  411.     /* move the mouse to the window center again */
  412.     XWarpPointer(dpy, None, win, 0, 0, 0, 0, vid.width / 2, vid.height / 2);
  413.   }
  414.  
  415. }
  416.  
  417. static void IN_DeactivateMouse( void ) 
  418. {
  419.   if (!mouse_avail || !dpy || !win)
  420.     return;
  421.  
  422.   if (mouse_active) {
  423.     uninstall_grabs();
  424.     mouse_active = false;
  425.   }
  426. }
  427.  
  428. static void IN_ActivateMouse( void ) 
  429. {
  430.   if (!mouse_avail || !dpy || !win)
  431.     return;
  432.  
  433.   if (!mouse_active) {
  434.     mx = my = 0; // don't spazz
  435.     install_grabs();
  436.     mouse_active = true;
  437.   }
  438. }
  439.  
  440.  
  441. void VID_Shutdown(void)
  442. {
  443.   if (!ctx || !dpy)
  444.     return;
  445.   IN_DeactivateMouse();
  446.   if (dpy) {
  447.     if (ctx)
  448.       glXDestroyContext(dpy, ctx);
  449.     if (win)
  450.       XDestroyWindow(dpy, win);
  451.     if (vidmode_active)
  452.       XF86VidModeSwitchToMode(dpy, scrnum, vidmodes[0]);
  453.     XCloseDisplay(dpy);
  454.   }
  455.   vidmode_active = false;
  456.   dpy = NULL;
  457.   win = 0;
  458.   ctx = NULL;
  459. }
  460.  
  461. void signal_handler(int sig)
  462. {
  463.   printf("Received signal %d, exiting...\n", sig);
  464.   Sys_Quit();
  465.   exit(0);
  466. }
  467.  
  468. void InitSig(void)
  469. {
  470.   signal(SIGHUP, signal_handler);
  471.   signal(SIGINT, signal_handler);
  472.   signal(SIGQUIT, signal_handler);
  473.   signal(SIGILL, signal_handler);
  474.   signal(SIGTRAP, signal_handler);
  475.   signal(SIGIOT, signal_handler);
  476.   signal(SIGBUS, signal_handler);
  477.   signal(SIGFPE, signal_handler);
  478.   signal(SIGSEGV, signal_handler);
  479.   signal(SIGTERM, signal_handler);
  480. }
  481.  
  482. void VID_ShiftPalette(unsigned char *p)
  483. {
  484. //  VID_SetPalette(p);
  485. }
  486.  
  487. void  VID_SetPalette (unsigned char *palette)
  488. {
  489.   byte  *pal;
  490.   unsigned r,g,b;
  491.   unsigned v;
  492.   int     r1,g1,b1;
  493.   int   j,k,l,m;
  494.   unsigned short i;
  495.   unsigned  *table;
  496.   FILE *f;
  497.   char s[255];
  498.   int dist, bestdist;
  499.  
  500. //
  501. // 8 8 8 encoding
  502. //
  503.   pal = palette;
  504.   table = d_8to24table;
  505.   for (i=0 ; i<256 ; i++)
  506.   {
  507.     r = pal[0];
  508.     g = pal[1];
  509.     b = pal[2];
  510.     pal += 3;
  511.     
  512.     v = (255<<24) + (r<<0) + (g<<8) + (b<<16);
  513.     *table++ = v;
  514.   }
  515.   d_8to24table[255] &= 0xffffff;  // 255 is transparent
  516.  
  517.   for (i=0; i < (1<<15); i++) {
  518.     /* Maps
  519.     000000000000000
  520.     000000000011111 = Red  = 0x1F
  521.     000001111100000 = Blue = 0x03E0
  522.     111110000000000 = Grn  = 0x7C00
  523.     */
  524.     r = ((i & 0x1F) << 3)+4;
  525.     g = ((i & 0x03E0) >> 2)+4;
  526.     b = ((i & 0x7C00) >> 7)+4;
  527.     pal = (unsigned char *)d_8to24table;
  528.     for (v=0,k=0,bestdist=10000*10000; v<256; v++,pal+=4) {
  529.       r1 = (int)r - (int)pal[0];
  530.       g1 = (int)g - (int)pal[1];
  531.       b1 = (int)b - (int)pal[2];
  532.       dist = (r1*r1)+(g1*g1)+(b1*b1);
  533.       if (dist < bestdist) {
  534.         k=v;
  535.         bestdist = dist;
  536.       }
  537.     }
  538.     d_15to8table[i]=k;
  539.   }
  540. }
  541.  
  542. void CheckMultiTextureExtensions(void) 
  543. {
  544.   void *prjobj;
  545.  
  546.   if (strstr(gl_extensions, "GL_SGIS_multitexture ") && !COM_CheckParm("-nomtex")) {
  547.     Con_Printf("Found GL_SGIS_multitexture...\n");
  548.  
  549.     if ((prjobj = dlopen(NULL, RTLD_LAZY)) == NULL) {
  550.       Con_Printf("Unable to open symbol list for main program.\n");
  551.       return;
  552.     }
  553.  
  554.     qglMTexCoord2fSGIS = (void *) dlsym(prjobj, "glMTexCoord2fSGIS");
  555.     qglSelectTextureSGIS = (void *) dlsym(prjobj, "glSelectTextureSGIS");
  556.  
  557.     if (qglMTexCoord2fSGIS && qglSelectTextureSGIS) {
  558.       Con_Printf("Multitexture extensions found.\n");
  559.       gl_mtexable = true;
  560.     } else
  561.       Con_Printf("Symbol not found, disabled.\n");
  562.  
  563.     dlclose(prjobj);
  564.   }
  565. }
  566.  
  567. /*
  568. ===============
  569. GL_Init
  570. ===============
  571. */
  572. void GL_Init (void)
  573. {
  574.   gl_vendor = glGetString (GL_VENDOR);
  575.   Con_Printf ("GL_VENDOR: %s\n", gl_vendor);
  576.   gl_renderer = glGetString (GL_RENDERER);
  577.   Con_Printf ("GL_RENDERER: %s\n", gl_renderer);
  578.  
  579.   gl_version = glGetString (GL_VERSION);
  580.   Con_Printf ("GL_VERSION: %s\n", gl_version);
  581.   gl_extensions = glGetString (GL_EXTENSIONS);
  582.   Con_Printf ("GL_EXTENSIONS: %s\n", gl_extensions);
  583.  
  584. //  Con_Printf ("%s %s\n", gl_renderer, gl_version);
  585.  
  586.   CheckMultiTextureExtensions ();
  587.  
  588.   glClearColor (1,0,0,0);
  589.   glCullFace(GL_FRONT);
  590.   glEnable(GL_TEXTURE_2D);
  591.  
  592.   glEnable(GL_ALPHA_TEST);
  593.   glAlphaFunc(GL_GREATER, 0.666);
  594.  
  595.   glPolygonMode (GL_FRONT_AND_BACK, GL_FILL);
  596.   glShadeModel (GL_FLAT);
  597.  
  598.   glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
  599.   glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
  600.   glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
  601.   glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
  602.  
  603.   glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
  604.  
  605. //  glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
  606.   glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
  607. }
  608.  
  609. /*
  610. =================
  611. GL_BeginRendering
  612.  
  613. =================
  614. */
  615. void GL_BeginRendering (int *x, int *y, int *width, int *height)
  616. {
  617.   extern cvar_t gl_clear;
  618.  
  619.   *x = *y = 0;
  620.   *width = scr_width;
  621.   *height = scr_height;
  622.  
  623. //    if (!wglMakeCurrent( maindc, baseRC ))
  624. //    Sys_Error ("wglMakeCurrent failed");
  625.  
  626. //  glViewport (*x, *y, *width, *height);
  627. }
  628.  
  629.  
  630. void GL_EndRendering (void)
  631. {
  632.   glFlush();
  633.   glXSwapBuffers(dpy, win);
  634. }
  635.  
  636. qboolean VID_Is8bit(void)
  637. {
  638.   return is8bit;
  639. }
  640.  
  641. void VID_Init8bitPalette(void) 
  642. {
  643.   // Check for 8bit Extensions and initialize them.
  644.   int i;
  645.   void *prjobj;
  646.  
  647.   if ((prjobj = dlopen(NULL, RTLD_LAZY)) == NULL) {
  648.     Con_Printf("Unable to open symbol list for main program.\n");
  649.     return;
  650.   }
  651.  
  652.   if (strstr(gl_extensions, "3DFX_set_global_palette") &&
  653.     (qgl3DfxSetPaletteEXT = dlsym(prjobj, "gl3DfxSetPaletteEXT")) != NULL) {
  654.     GLubyte table[256][4];
  655.     char *oldpal;
  656.  
  657.     Con_SafePrintf("8-bit GL extensions enabled.\n");
  658.     glEnable( GL_SHARED_TEXTURE_PALETTE_EXT );
  659.     oldpal = (char *) d_8to24table; //d_8to24table3dfx;
  660.     for (i=0;i<256;i++) {
  661.       table[i][2] = *oldpal++;
  662.       table[i][1] = *oldpal++;
  663.       table[i][0] = *oldpal++;
  664.       table[i][3] = 255;
  665.       oldpal++;
  666.     }
  667.     qgl3DfxSetPaletteEXT((GLuint *)table);
  668.     is8bit = true;
  669.  
  670.   } else if (strstr(gl_extensions, "GL_EXT_shared_texture_palette") &&
  671.     (qglColorTableEXT = dlsym(prjobj, "glColorTableEXT")) != NULL) {
  672.     char thePalette[256*3];
  673.     char *oldPalette, *newPalette;
  674.  
  675.     Con_SafePrintf("8-bit GL extensions enabled.\n");
  676.     glEnable( GL_SHARED_TEXTURE_PALETTE_EXT );
  677.     oldPalette = (char *) d_8to24table; //d_8to24table3dfx;
  678.     newPalette = thePalette;
  679.     for (i=0;i<256;i++) {
  680.       *newPalette++ = *oldPalette++;
  681.       *newPalette++ = *oldPalette++;
  682.       *newPalette++ = *oldPalette++;
  683.       oldPalette++;
  684.     }
  685.     qglColorTableEXT(GL_SHARED_TEXTURE_PALETTE_EXT, GL_RGB, 256, GL_RGB, GL_UNSIGNED_BYTE, (void *) thePalette);
  686.     is8bit = true;
  687.   }
  688.   
  689.   dlclose(prjobj);
  690. }
  691.  
  692. static void Check_Gamma (unsigned char *pal)
  693. {
  694.   float f, inf;
  695.   unsigned char palette[768];
  696.   int   i;
  697.  
  698.   if ((i = COM_CheckParm("-gamma")) == 0) {
  699.     if ((gl_renderer && strstr(gl_renderer, "Voodoo")) ||
  700.       (gl_vendor && strstr(gl_vendor, "3Dfx")))
  701.       vid_gamma = 1;
  702.     else
  703.       vid_gamma = 0.7; // default to 0.7 on non-3dfx hardware
  704.   } else
  705.     vid_gamma = Q_atof(com_argv[i+1]);
  706.  
  707.   for (i=0 ; i<768 ; i++)
  708.   {
  709.     f = pow ( (pal[i]+1)/256.0 , vid_gamma );
  710.     inf = f*255 + 0.5;
  711.     if (inf < 0)
  712.       inf = 0;
  713.     if (inf > 255)
  714.       inf = 255;
  715.     palette[i] = inf;
  716.   }
  717.  
  718.   memcpy (pal, palette, sizeof(palette));
  719. }
  720.  
  721. void VID_Init(unsigned char *palette)
  722. {
  723.   int i;
  724.   int attrib[] = {
  725.     GLX_RGBA,
  726.     GLX_RED_SIZE, 1,
  727.     GLX_GREEN_SIZE, 1,
  728.     GLX_BLUE_SIZE, 1,
  729.     GLX_DOUBLEBUFFER,
  730.     GLX_DEPTH_SIZE, 1,
  731.     None
  732.   };
  733.   char  gldir[MAX_OSPATH];
  734.   int width = 640, height = 480;
  735.   XSetWindowAttributes attr;
  736.   unsigned long mask;
  737.   Window root;
  738.   XVisualInfo *visinfo;
  739.   qboolean fullscreen = true;
  740.   int MajorVersion, MinorVersion;
  741.   int actualWidth, actualHeight;
  742.  
  743.   Cvar_RegisterVariable (&vid_mode);
  744.   Cvar_RegisterVariable (&in_mouse);
  745.   Cvar_RegisterVariable (&in_dgamouse);
  746.   Cvar_RegisterVariable (&m_filter);
  747.   Cvar_RegisterVariable (&gl_ztrick);
  748.   
  749.   vid.maxwarpwidth = WARP_WIDTH;
  750.   vid.maxwarpheight = WARP_HEIGHT;
  751.   vid.colormap = host_colormap;
  752.   vid.fullbright = 256 - LittleLong (*((int *)vid.colormap + 2048));
  753.  
  754. // interpret command-line params
  755.  
  756. // set vid parameters
  757.   if ((i = COM_CheckParm("-window")) != 0)
  758.     fullscreen = false;
  759.  
  760.   if ((i = COM_CheckParm("-width")) != 0)
  761.     width = atoi(com_argv[i+1]);
  762.  
  763.   if ((i = COM_CheckParm("-height")) != 0)
  764.     height = atoi(com_argv[i+1]);
  765.  
  766.   if ((i = COM_CheckParm("-conwidth")) != 0)
  767.     vid.conwidth = Q_atoi(com_argv[i+1]);
  768.   else
  769.     vid.conwidth = 640;
  770.  
  771.   vid.conwidth &= 0xfff8; // make it a multiple of eight
  772.  
  773.   if (vid.conwidth < 320)
  774.     vid.conwidth = 320;
  775.  
  776.   // pick a conheight that matches with correct aspect
  777.   vid.conheight = vid.conwidth*3 / 4;
  778.  
  779.   if ((i = COM_CheckParm("-conheight")) != 0)
  780.     vid.conheight = Q_atoi(com_argv[i+1]);
  781.   if (vid.conheight < 200)
  782.     vid.conheight = 200;
  783.  
  784.   if (!(dpy = XOpenDisplay(NULL))) {
  785.     fprintf(stderr, "Error couldn't open the X display\n");
  786.     exit(1);
  787.   }
  788.  
  789.   scrnum = DefaultScreen(dpy);
  790.   root = RootWindow(dpy, scrnum);
  791.  
  792.   // Get video mode list
  793.   MajorVersion = MinorVersion = 0;
  794.   if (!XF86VidModeQueryVersion(dpy, &MajorVersion, &MinorVersion)) { 
  795.     vidmode_ext = false;
  796.   } else {
  797.     Con_Printf("Using XFree86-VidModeExtension Version %d.%d\n", MajorVersion, MinorVersion);
  798.     vidmode_ext = true;
  799.   }
  800.  
  801.   visinfo = glXChooseVisual(dpy, scrnum, attrib);
  802.   if (!visinfo) {
  803.     fprintf(stderr, "qkHack: Error couldn't get an RGB, Double-buffered, Depth visual\n");
  804.     exit(1);
  805.   }
  806.  
  807.   if (vidmode_ext) {
  808.     int best_fit, best_dist, dist, x, y;
  809.     
  810.     XF86VidModeGetAllModeLines(dpy, scrnum, &num_vidmodes, &vidmodes);
  811.  
  812.     // Are we going fullscreen?  If so, let's change video mode
  813.     if (fullscreen) {
  814.       best_dist = 9999999;
  815.       best_fit = -1;
  816.  
  817.       for (i = 0; i < num_vidmodes; i++) {
  818.         if (width > vidmodes[i]->hdisplay ||
  819.           height > vidmodes[i]->vdisplay)
  820.           continue;
  821.  
  822.         x = width - vidmodes[i]->hdisplay;
  823.         y = height - vidmodes[i]->vdisplay;
  824.         dist = (x * x) + (y * y);
  825.         if (dist < best_dist) {
  826.           best_dist = dist;
  827.           best_fit = i;
  828.         }
  829.       }
  830.  
  831.       if (best_fit != -1) {
  832.         actualWidth = vidmodes[best_fit]->hdisplay;
  833.         actualHeight = vidmodes[best_fit]->vdisplay;
  834.  
  835.         // change to the mode
  836.         XF86VidModeSwitchToMode(dpy, scrnum, vidmodes[best_fit]);
  837.         vidmode_active = true;
  838.  
  839.         // Move the viewport to top left
  840.         XF86VidModeSetViewPort(dpy, scrnum, 0, 0);
  841.       } else
  842.         fullscreen = 0;
  843.     }
  844.   }
  845.  
  846.   /* window attributes */
  847.   attr.background_pixel = 0;
  848.   attr.border_pixel = 0;
  849.   attr.colormap = XCreateColormap(dpy, root, visinfo->visual, AllocNone);
  850.   attr.event_mask = X_MASK;
  851.   if (vidmode_active) {
  852.     mask = CWBackPixel | CWColormap | CWSaveUnder | CWBackingStore | 
  853.       CWEventMask | CWOverrideRedirect;
  854.     attr.override_redirect = True;
  855.     attr.backing_store = NotUseful;
  856.     attr.save_under = False;
  857.   } else
  858.     mask = CWBackPixel | CWBorderPixel | CWColormap | CWEventMask;
  859.  
  860.   win = XCreateWindow(dpy, root, 0, 0, width, height,
  861.             0, visinfo->depth, InputOutput,
  862.             visinfo->visual, mask, &attr);
  863.   XMapWindow(dpy, win);
  864.  
  865.   if (vidmode_active) {
  866.     XMoveWindow(dpy, win, 0, 0);
  867.     XRaiseWindow(dpy, win);
  868.     XWarpPointer(dpy, None, win, 0, 0, 0, 0, 0, 0);
  869.     XFlush(dpy);
  870.     // Move the viewport to top left
  871.     XF86VidModeSetViewPort(dpy, scrnum, 0, 0);
  872.   }
  873.  
  874.   XFlush(dpy);
  875.  
  876.   ctx = glXCreateContext(dpy, visinfo, NULL, True);
  877.  
  878.   glXMakeCurrent(dpy, win, ctx);
  879.  
  880.   scr_width = width;
  881.   scr_height = height;
  882.  
  883.   if (vid.conheight > height)
  884.     vid.conheight = height;
  885.   if (vid.conwidth > width)
  886.     vid.conwidth = width;
  887.   vid.width = vid.conwidth;
  888.   vid.height = vid.conheight;
  889.  
  890.   vid.aspect = ((float)vid.height / (float)vid.width) * (320.0 / 240.0);
  891.   vid.numpages = 2;
  892.  
  893.   InitSig(); // trap evil signals
  894.  
  895.   GL_Init();
  896.  
  897.   sprintf (gldir, "%s/glquake", com_gamedir);
  898.   Sys_mkdir (gldir);
  899.  
  900.   VID_SetPalette(palette);
  901.  
  902.   // Check for 3DFX Extensions and initialize them.
  903.   VID_Init8bitPalette();
  904.  
  905.   Con_SafePrintf ("Video mode %dx%d initialized.\n", width, height);
  906.  
  907.   vid.recalc_refdef = 1;        // force a surface cache flush
  908. }
  909.  
  910. void Sys_SendKeyEvents(void)
  911. {
  912.   HandleEvents();
  913. }
  914.  
  915. void Force_CenterView_f (void)
  916. {
  917.   cl.viewangles[PITCH] = 0;
  918. }
  919.  
  920. void IN_Init(void)
  921. {
  922. }
  923.  
  924. void IN_Shutdown(void)
  925. {
  926. }
  927.  
  928. /*
  929. ===========
  930. IN_Commands
  931. ===========
  932. */
  933. void IN_Commands (void)
  934. {
  935.   if (!dpy || !win)
  936.     return;
  937.  
  938.   if (vidmode_active || key_dest == key_game)
  939.     IN_ActivateMouse();
  940.   else
  941.     IN_DeactivateMouse ();
  942. }
  943.  
  944. /*
  945. ===========
  946. IN_Move
  947. ===========
  948. */
  949. void IN_MouseMove (usercmd_t *cmd)
  950. {
  951.   if (!mouse_avail)
  952.     return;
  953.    
  954.   if (m_filter.value)
  955.   {
  956.     mx = (mx + old_mouse_x) * 0.5;
  957.     my = (my + old_mouse_y) * 0.5;
  958.   }
  959.   old_mouse_x = mx;
  960.   old_mouse_y = my;
  961.  
  962.   mx *= sensitivity.value;
  963.   my *= sensitivity.value;
  964.  
  965. // add mouse X/Y movement to cmd
  966.   if ( (in_strafe.state & 1) || (lookstrafe.value && (in_mlook.state & 1) ))
  967.     cmd->sidemove += m_side.value * mx;
  968.   else
  969.     cl.viewangles[YAW] -= m_yaw.value * mx;
  970.   
  971.   if (in_mlook.state & 1)
  972.     V_StopPitchDrift ();
  973.     
  974.   if ( (in_mlook.state & 1) && !(in_strafe.state & 1))
  975.   {
  976.     cl.viewangles[PITCH] += m_pitch.value * my;
  977.     if (cl.viewangles[PITCH] > 80)
  978.       cl.viewangles[PITCH] = 80;
  979.     if (cl.viewangles[PITCH] < -70)
  980.       cl.viewangles[PITCH] = -70;
  981.   }
  982.   else
  983.   {
  984.     if ((in_strafe.state & 1) && noclip_anglehack)
  985.       cmd->upmove -= m_forward.value * my;
  986.     else
  987.       cmd->forwardmove -= m_forward.value * my;
  988.   }
  989.   mx = my = 0;
  990. }
  991.  
  992. void IN_Move (usercmd_t *cmd)
  993. {
  994.   IN_MouseMove(cmd);
  995. }
  996.  
  997.  
  998.