home *** CD-ROM | disk | FTP | other *** search
/ Enigma Amiga Life 113 / EnigmaAmiga113CD.iso / software / sviluppo / quakeworld_src / client / gl_vidlinux_x11.c < prev    next >
Encoding:
C/C++ Source or Header  |  2000-06-17  |  19.8 KB  |  871 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. #include <asm/io.h>
  28.  
  29. //#include <X11/cursorfont.h>
  30. #include <X11/Xlib.h>
  31. #include <X11/Xutil.h>
  32. #include <X11/Xatom.h>
  33. #include <X11/keysym.h>
  34.  
  35. #include "GL/gl.h"
  36. #include "GL/glx.h"
  37.  
  38. #include "quakedef.h"
  39.  
  40. #define WARP_WIDTH              320
  41. #define WARP_HEIGHT             200
  42.  
  43. static Display *dpy = NULL;
  44. static Window win;
  45. static GLXContext ctx = NULL;
  46.  
  47. unsigned short d_8to16table[256];
  48. unsigned int d_8to24table[256];
  49. unsigned char d_15to8table[65536];
  50.  
  51. static qboolean usedga = false;
  52.  
  53. #define stringify(m) { #m, m }
  54.  
  55. cvar_t vid_mode = {"vid_mode","0",false};
  56.  
  57. cvar_t  mouse_button_commands[3] =
  58. {
  59.     {"mouse1","+attack"},
  60.     {"mouse2","+strafe"},
  61.     {"mouse3","+forward"},
  62. };
  63.  
  64. static int mouse_buttons=3;
  65. static int mouse_buttonstate;
  66. static int mouse_oldbuttonstate;
  67. static float mouse_x, mouse_y;
  68. static float p_mouse_x, p_mouse_y;
  69. static float old_mouse_x, old_mouse_y;
  70.  
  71. cvar_t _windowed_mouse = {"_windowed_mouse", "1", true};
  72. cvar_t m_filter = {"m_filter","0"};
  73. static float old_windowed_mouse;
  74.  
  75. static int scr_width, scr_height;
  76.  
  77. #define KEY_MASK (KeyPressMask | KeyReleaseMask)
  78. #define MOUSE_MASK (ButtonPressMask | ButtonReleaseMask | \
  79.         PointerMotionMask | ButtonMotionMask)
  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. qboolean is8bit = false;
  102. qboolean isPermedia = false;
  103. qboolean gl_mtexable = false;
  104.  
  105. /*-----------------------------------------------------------------------*/
  106. void D_BeginDirectRect (int x, int y, byte *pbitmap, int width, int height)
  107. {
  108. }
  109.  
  110. void D_EndDirectRect (int x, int y, int width, int height)
  111. {
  112. }
  113.  
  114. /*
  115. =================
  116. VID_Gamma_f
  117.  
  118. Keybinding command
  119. =================
  120. */
  121. void VID_Gamma_f (void)
  122. {
  123.   float gamma, f, inf;
  124.   unsigned char palette[768];
  125.   int   i;
  126.  
  127.   if (Cmd_Argc () == 2)
  128.   {
  129.     gamma = Q_atof (Cmd_Argv(1));
  130.  
  131.     for (i=0 ; i<768 ; i++)
  132.     {
  133.       f = pow ( (host_basepal[i]+1)/256.0 , gamma );
  134.       inf = f*255 + 0.5;
  135.       if (inf < 0)
  136.         inf = 0;
  137.       if (inf > 255)
  138.         inf = 255;
  139.       palette[i] = inf;
  140.     }
  141.  
  142.     VID_SetPalette (palette);
  143.  
  144.     vid.recalc_refdef = 1;        // force a surface cache flush
  145.   }
  146. }
  147.  
  148. void VID_Shutdown(void)
  149. {
  150.   if (!ctx)
  151.     return;
  152.  
  153.   XUngrabPointer(dpy,CurrentTime);
  154.   XUngrabKeyboard(dpy,CurrentTime);
  155.  
  156.   glXDestroyContext(dpy,ctx);
  157.  
  158. #ifdef USE_DGA
  159.   if (usedga)
  160.     XF86DGADirectVideo(dpy,DefaultScreen(dpy),0);
  161. #endif
  162. }
  163.  
  164. int XLateKey(XKeyEvent *ev)
  165. {
  166.  
  167.   int key;
  168.   char buf[64];
  169.   KeySym keysym;
  170.  
  171.   key = 0;
  172.  
  173.   XLookupString(ev, buf, sizeof buf, &keysym, 0);
  174.  
  175.   switch(keysym)
  176.   {
  177.     case XK_KP_Page_Up:
  178.     case XK_Page_Up:   key = K_PGUP; break;
  179.  
  180.     case XK_KP_Page_Down:
  181.     case XK_Page_Down:   key = K_PGDN; break;
  182.  
  183.     case XK_KP_Home:
  184.     case XK_Home:  key = K_HOME; break;
  185.  
  186.     case XK_KP_End:
  187.     case XK_End:   key = K_END; break;
  188.  
  189.     case XK_KP_Left:
  190.     case XK_Left:  key = K_LEFTARROW; break;
  191.  
  192.     case XK_KP_Right:
  193.     case XK_Right:  key = K_RIGHTARROW;   break;
  194.  
  195.     case XK_KP_Down:
  196.     case XK_Down:  key = K_DOWNARROW; break;
  197.  
  198.     case XK_KP_Up:
  199.     case XK_Up:    key = K_UPARROW;  break;
  200.  
  201.     case XK_Escape: key = K_ESCAPE;   break;
  202.  
  203.     case XK_KP_Enter:
  204.     case XK_Return: key = K_ENTER;     break;
  205.  
  206.     case XK_Tab:    key = K_TAB;       break;
  207.  
  208.     case XK_F1:    key = K_F1;        break;
  209.  
  210.     case XK_F2:    key = K_F2;        break;
  211.  
  212.     case XK_F3:    key = K_F3;        break;
  213.  
  214.     case XK_F4:    key = K_F4;        break;
  215.  
  216.     case XK_F5:    key = K_F5;        break;
  217.  
  218.     case XK_F6:    key = K_F6;        break;
  219.  
  220.     case XK_F7:    key = K_F7;        break;
  221.  
  222.     case XK_F8:    key = K_F8;        break;
  223.  
  224.     case XK_F9:    key = K_F9;        break;
  225.  
  226.     case XK_F10:    key = K_F10;       break;
  227.  
  228.     case XK_F11:    key = K_F11;       break;
  229.  
  230.     case XK_F12:    key = K_F12;       break;
  231.  
  232.     case XK_BackSpace: key = K_BACKSPACE; break;
  233.  
  234.     case XK_KP_Delete:
  235.     case XK_Delete: key = K_DEL; break;
  236.  
  237.     case XK_Pause:  key = K_PAUSE;     break;
  238.  
  239.     case XK_Shift_L:
  240.     case XK_Shift_R:  key = K_SHIFT;    break;
  241.  
  242.     case XK_Execute: 
  243.     case XK_Control_L: 
  244.     case XK_Control_R:  key = K_CTRL;    break;
  245.  
  246.     case XK_Alt_L:  
  247.     case XK_Meta_L: 
  248.     case XK_Alt_R:  
  249.     case XK_Meta_R: key = K_ALT;      break;
  250.  
  251.     case XK_KP_Begin: key = K_AUX30;  break;
  252.  
  253.     case XK_Insert:
  254.     case XK_KP_Insert: key = K_INS; break;
  255.  
  256.     case XK_KP_Multiply: key = '*'; break;
  257.     case XK_KP_Add: key = '+'; break;
  258.     case XK_KP_Subtract: key = '-'; break;
  259.     case XK_KP_Divide: key = '/'; break;
  260.  
  261. #if 0
  262.     case 0x021: key = '1';break;/* [!] */
  263.     case 0x040: key = '2';break;/* [@] */
  264.     case 0x023: key = '3';break;/* [#] */
  265.     case 0x024: key = '4';break;/* [$] */
  266.     case 0x025: key = '5';break;/* [%] */
  267.     case 0x05e: key = '6';break;/* [^] */
  268.     case 0x026: key = '7';break;/* [&] */
  269.     case 0x02a: key = '8';break;/* [*] */
  270.     case 0x028: key = '9';;break;/* [(] */
  271.     case 0x029: key = '0';break;/* [)] */
  272.     case 0x05f: key = '-';break;/* [_] */
  273.     case 0x02b: key = '=';break;/* [+] */
  274.     case 0x07c: key = '\'';break;/* [|] */
  275.     case 0x07d: key = '[';break;/* [}] */
  276.     case 0x07b: key = ']';break;/* [{] */
  277.     case 0x022: key = '\'';break;/* ["] */
  278.     case 0x03a: key = ';';break;/* [:] */
  279.     case 0x03f: key = '/';break;/* [?] */
  280.     case 0x03e: key = '.';break;/* [>] */
  281.     case 0x03c: key = ',';break;/* [<] */
  282. #endif
  283.  
  284.     default:
  285.       key = *(unsigned char*)buf;
  286.       if (key >= 'A' && key <= 'Z')
  287.         key = key - 'A' + 'a';
  288. //      fprintf(stdout, "case 0x0%x: key = ___;break;/* [%c] */\n", keysym);
  289.       break;
  290.   } 
  291.  
  292.   return key;
  293. }
  294.  
  295. struct
  296. {
  297.   int key;
  298.   int down;
  299. } keyq[64];
  300. int keyq_head=0;
  301. int keyq_tail=0;
  302.  
  303. int config_notify=0;
  304. int config_notify_width;
  305. int config_notify_height;
  306.                   
  307. qboolean Keyboard_Update(void)
  308. {
  309.   XEvent x_event;
  310.    
  311.   if(!XCheckMaskEvent(dpy,KEY_MASK,&x_event))
  312.     return false;
  313.  
  314.   switch(x_event.type) {
  315.   case KeyPress:
  316.     keyq[keyq_head].key = XLateKey(&x_event.xkey);
  317.     keyq[keyq_head].down = true;
  318.     keyq_head = (keyq_head + 1) & 63;
  319.     break;
  320.   case KeyRelease:
  321.     keyq[keyq_head].key = XLateKey(&x_event.xkey);
  322.     keyq[keyq_head].down = false;
  323.     keyq_head = (keyq_head + 1) & 63;
  324.     break;
  325.   }
  326.  
  327.   return true;
  328. }
  329.  
  330. qboolean Mouse_Update(void)
  331. {
  332.   XEvent x_event;
  333.   int b;
  334.    
  335.   if(!XCheckMaskEvent(dpy,MOUSE_MASK,&x_event))
  336.     return false;
  337.  
  338.   switch(x_event.type) {
  339.   case MotionNotify:
  340.     if (usedga) {
  341.       mouse_x += x_event.xmotion.x_root;
  342.       mouse_y += x_event.xmotion.y_root;
  343.     } else if (_windowed_mouse.value) {
  344.       mouse_x += (float) ((int)x_event.xmotion.x - (int)(scr_width/2));
  345.       mouse_y += (float) ((int)x_event.xmotion.y - (int)(scr_height/2));
  346.  
  347.       /* move the mouse to the window center again */
  348.       XSelectInput(dpy,win, (KEY_MASK | MOUSE_MASK) & ~PointerMotionMask);
  349.       XWarpPointer(dpy,None,win,0,0,0,0, (scr_width/2),(scr_height/2));
  350.       XSelectInput(dpy,win, KEY_MASK | MOUSE_MASK);
  351.     } else {
  352.       mouse_x = (float) (x_event.xmotion.x-p_mouse_x);
  353.       mouse_y = (float) (x_event.xmotion.y-p_mouse_y);
  354.       p_mouse_x=x_event.xmotion.x;
  355.       p_mouse_y=x_event.xmotion.y;
  356.     }
  357.     break;
  358.  
  359.   case ButtonPress:
  360.     b=-1;
  361.     if (x_event.xbutton.button == 1)
  362.       b = 0;
  363.     else if (x_event.xbutton.button == 2)
  364.       b = 2;
  365.     else if (x_event.xbutton.button == 3)
  366.       b = 1;
  367.     if (b>=0)
  368.       mouse_buttonstate |= 1<<b;
  369.     break;
  370.  
  371.   case ButtonRelease:
  372.     b=-1;
  373.     if (x_event.xbutton.button == 1)
  374.       b = 0;
  375.     else if (x_event.xbutton.button == 2)
  376.       b = 2;
  377.     else if (x_event.xbutton.button == 3)
  378.       b = 1;
  379.     if (b>=0)
  380.       mouse_buttonstate &= ~(1<<b);
  381.     break;
  382.   }
  383.    
  384.   if (old_windowed_mouse != _windowed_mouse.value) {
  385.     old_windowed_mouse = _windowed_mouse.value;
  386.  
  387.     if (!_windowed_mouse.value) {
  388.       /* ungrab the pointer */
  389.       Con_Printf("Releasing mouse.\n");
  390.  
  391.       XUngrabPointer(dpy,CurrentTime);
  392.       XUngrabKeyboard(dpy,CurrentTime);
  393.     } else {
  394.       /* grab the pointer */
  395.       Con_Printf("Grabbing mouse.\n");
  396.  
  397.       XGrabPointer(dpy,win,False,MOUSE_MASK,GrabModeAsync,
  398.         GrabModeAsync,win,None,CurrentTime);
  399.       XWarpPointer(dpy,None,win, 0,0,0,0, scr_width/2, scr_height/2);
  400.       XGrabKeyboard(dpy,win,
  401.         False,
  402.         GrabModeAsync,GrabModeAsync,
  403.         CurrentTime);
  404.  
  405.       //XSync(dpy,True);
  406.     }
  407.   }
  408.   return true;
  409. }
  410.  
  411. void signal_handler(int sig)
  412. {
  413.   printf("Received signal %d, exiting...\n", sig);
  414.   VID_Shutdown();
  415.   exit(0);
  416. }
  417.  
  418. void InitSig(void)
  419. {
  420.   signal(SIGHUP, signal_handler);
  421.   signal(SIGQUIT, signal_handler);
  422.   signal(SIGILL, signal_handler);
  423.   signal(SIGTRAP, signal_handler);
  424.   signal(SIGIOT, signal_handler);
  425.   signal(SIGBUS, signal_handler);
  426.   signal(SIGFPE, signal_handler);
  427.   signal(SIGSEGV, signal_handler);
  428.   signal(SIGTERM, signal_handler);
  429. }
  430.  
  431. void VID_ShiftPalette(unsigned char *p)
  432. {
  433.   VID_SetPalette(p);
  434. }
  435.  
  436. void  VID_SetPalette (unsigned char *palette)
  437. {
  438.   byte  *pal;
  439.   unsigned short r,g,b;
  440.   int     v;
  441.   int     r1,g1,b1;
  442.   int   k;
  443.   unsigned short i;
  444.   unsigned  *table;
  445.   FILE *f;
  446.   char s[255];
  447.   float dist, bestdist;
  448.   static qboolean palflag = false;
  449.  
  450. //
  451. // 8 8 8 encoding
  452. //
  453.   pal = palette;
  454.   table = d_8to24table;
  455.   for (i=0 ; i<256 ; i++)
  456.   {
  457.     r = pal[0];
  458.     g = pal[1];
  459.     b = pal[2];
  460.     pal += 3;
  461.     
  462. //    v = (255<<24) + (r<<16) + (g<<8) + (b<<0);
  463. //    v = (255<<0) + (r<<8) + (g<<16) + (b<<24);
  464.     v = (255<<24) + (r<<0) + (g<<8) + (b<<16);
  465.     *table++ = v;
  466.   }
  467.   d_8to24table[255] &= 0xffffff;  // 255 is transparent
  468.  
  469.   // JACK: 3D distance calcs - k is last closest, l is the distance.
  470.   // FIXME: Precalculate this and cache to disk.
  471.   if (palflag)
  472.     return;
  473.   palflag = true;
  474.  
  475.   COM_FOpenFile("glquake/15to8.pal", &f);
  476.   if (f) {
  477.     fread(d_15to8table, 1<<15, 1, f);
  478.     fclose(f);
  479.   } else {
  480.     for (i=0; i < (1<<15); i++) {
  481.       /* Maps
  482.       000000000000000
  483.       000000000011111 = Red  = 0x1F
  484.       000001111100000 = Blue = 0x03E0
  485.       111110000000000 = Grn  = 0x7C00
  486.       */
  487.       r = ((i & 0x1F) << 3)+4;
  488.       g = ((i & 0x03E0) >> 2)+4;
  489.       b = ((i & 0x7C00) >> 7)+4;
  490.       pal = (unsigned char *)d_8to24table;
  491.       for (v=0,k=0,bestdist=10000.0; v<256; v++,pal+=4) {
  492.         r1 = (int)r - (int)pal[0];
  493.         g1 = (int)g - (int)pal[1];
  494.         b1 = (int)b - (int)pal[2];
  495.         dist = sqrt(((r1*r1)+(g1*g1)+(b1*b1)));
  496.         if (dist < bestdist) {
  497.           k=v;
  498.           bestdist = dist;
  499.         }
  500.       }
  501.       d_15to8table[i]=k;
  502.     }
  503.     sprintf(s, "%s/glquake", com_gamedir);
  504.     Sys_mkdir (s);
  505.     sprintf(s, "%s/glquake/15to8.pal", com_gamedir);
  506.     if ((f = fopen(s, "wb")) != NULL) {
  507.       fwrite(d_15to8table, 1<<15, 1, f);
  508.       fclose(f);
  509.     }
  510.   }
  511. }
  512.  
  513. /*
  514. ===============
  515. GL_Init
  516. ===============
  517. */
  518. void GL_Init (void)
  519. {
  520.   gl_vendor = glGetString (GL_VENDOR);
  521.   Con_Printf ("GL_VENDOR: %s\n", gl_vendor);
  522.   gl_renderer = glGetString (GL_RENDERER);
  523.   Con_Printf ("GL_RENDERER: %s\n", gl_renderer);
  524.  
  525.   gl_version = glGetString (GL_VERSION);
  526.   Con_Printf ("GL_VERSION: %s\n", gl_version);
  527.   gl_extensions = glGetString (GL_EXTENSIONS);
  528.   Con_Printf ("GL_EXTENSIONS: %s\n", gl_extensions);
  529.  
  530. //  Con_Printf ("%s %s\n", gl_renderer, gl_version);
  531.  
  532.   glClearColor (1,0,0,0);
  533.   glCullFace(GL_FRONT);
  534.   glEnable(GL_TEXTURE_2D);
  535.  
  536.   glEnable(GL_ALPHA_TEST);
  537.   glAlphaFunc(GL_GREATER, 0.666);
  538.  
  539.   glPolygonMode (GL_FRONT_AND_BACK, GL_FILL);
  540.   glShadeModel (GL_FLAT);
  541.  
  542.   glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
  543.   glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
  544.   glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
  545.   glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
  546.  
  547.   glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
  548.  
  549. //  glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
  550.   glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
  551. }
  552.  
  553. /*
  554. =================
  555. GL_BeginRendering
  556.  
  557. =================
  558. */
  559. void GL_BeginRendering (int *x, int *y, int *width, int *height)
  560. {
  561.   extern cvar_t gl_clear;
  562.  
  563.   *x = *y = 0;
  564.   *width = scr_width;
  565.   *height = scr_height;
  566.  
  567. //    if (!wglMakeCurrent( maindc, baseRC ))
  568. //    Sys_Error ("wglMakeCurrent failed");
  569.  
  570. //  glViewport (*x, *y, *width, *height);
  571. }
  572.  
  573.  
  574. void GL_EndRendering (void)
  575. {
  576.   glFlush();
  577.   glXSwapBuffers(dpy,win);
  578. }
  579.  
  580. qboolean VID_Is8bit(void)
  581. {
  582.   return is8bit;
  583. }
  584.  
  585. #ifdef GL_EXT_SHARED
  586. void VID_Init8bitPalette() 
  587. {
  588.   // Check for 8bit Extensions and initialize them.
  589.   int i;
  590.   char thePalette[256*3];
  591.   char *oldPalette, *newPalette;
  592.  
  593.   if (strstr(gl_extensions, "GL_EXT_shared_texture_palette") == NULL)
  594.     return;
  595.  
  596.   Con_SafePrintf("8-bit GL extensions enabled.\n");
  597.   glEnable( GL_SHARED_TEXTURE_PALETTE_EXT );
  598.   oldPalette = (char *) d_8to24table; //d_8to24table3dfx;
  599.   newPalette = thePalette;
  600.   for (i=0;i<256;i++) {
  601.     *newPalette++ = *oldPalette++;
  602.     *newPalette++ = *oldPalette++;
  603.     *newPalette++ = *oldPalette++;
  604.     oldPalette++;
  605.   }
  606.   glColorTableEXT(GL_SHARED_TEXTURE_PALETTE_EXT, GL_RGB, 256, GL_RGB, GL_UNSIGNED_BYTE, (void *) thePalette);
  607.   is8bit = true;
  608. }
  609.  
  610. #else
  611. extern void gl3DfxSetPaletteEXT(GLuint *pal);
  612.  
  613. void VID_Init8bitPalette(void) 
  614. {
  615.   // Check for 8bit Extensions and initialize them.
  616.   int i;
  617.   GLubyte table[256][4];
  618.   char *oldpal;
  619.  
  620.   if (strstr(gl_extensions, "3DFX_set_global_palette") == NULL)
  621.     return;
  622.  
  623.   Con_SafePrintf("8-bit GL extensions enabled.\n");
  624.   glEnable( GL_SHARED_TEXTURE_PALETTE_EXT );
  625.   oldpal = (char *) d_8to24table; //d_8to24table3dfx;
  626.   for (i=0;i<256;i++) {
  627.     table[i][2] = *oldpal++;
  628.     table[i][1] = *oldpal++;
  629.     table[i][0] = *oldpal++;
  630.     table[i][3] = 255;
  631.     oldpal++;
  632.   }
  633.   gl3DfxSetPaletteEXT((GLuint *)table);
  634.   is8bit = true;
  635. }
  636. #endif
  637.  
  638. void VID_Init(unsigned char *palette)
  639. {
  640.   int i;
  641.   char  gldir[MAX_OSPATH];
  642.   int width = 640, height = 480;
  643.   int attrib[] = { 
  644.     GLX_RGBA,
  645.     GLX_RED_SIZE, 1,
  646.     GLX_GREEN_SIZE, 1,
  647.     GLX_BLUE_SIZE, 1,
  648.     GLX_DOUBLEBUFFER,
  649.     GLX_DEPTH_SIZE, 1,
  650.     None };
  651.   int scrnum;
  652.   XSetWindowAttributes attr;
  653.   unsigned long mask;
  654.   Window root;
  655.   XVisualInfo *visinfo;
  656.  
  657.   S_Init();
  658.  
  659.   Cvar_RegisterVariable (&vid_mode);
  660.   Cvar_RegisterVariable (&gl_ztrick);
  661.   
  662.   vid.maxwarpwidth = WARP_WIDTH;
  663.   vid.maxwarpheight = WARP_HEIGHT;
  664.   vid.colormap = host_colormap;
  665.   vid.fullbright = 256 - LittleLong (*((int *)vid.colormap + 2048));
  666.  
  667. // interpret command-line params
  668.  
  669. // set vid parameters
  670.  
  671.   if ((i = COM_CheckParm("-width")) != 0)
  672.     width = atoi(com_argv[i+1]);
  673.   if ((i = COM_CheckParm("-height")) != 0)
  674.     height = atoi(com_argv[i+1]);
  675.  
  676.   if ((i = COM_CheckParm("-conwidth")) != 0)
  677.     vid.conwidth = Q_atoi(com_argv[i+1]);
  678.   else
  679.     vid.conwidth = 640;
  680.  
  681.   vid.conwidth &= 0xfff8; // make it a multiple of eight
  682.  
  683.   if (vid.conwidth < 320)
  684.     vid.conwidth = 320;
  685.  
  686.   // pick a conheight that matches with correct aspect
  687.   vid.conheight = vid.conwidth*3 / 4;
  688.  
  689.   if ((i = COM_CheckParm("-conheight")) != 0)
  690.     vid.conheight = Q_atoi(com_argv[i+1]);
  691.   if (vid.conheight < 200)
  692.     vid.conheight = 200;
  693.  
  694.   if (!(dpy = XOpenDisplay(NULL))) {
  695.     fprintf(stderr, "Error couldn't open the X display\n");
  696.     exit(1);
  697.   }
  698.  
  699.   scrnum = DefaultScreen(dpy);
  700.   root = RootWindow(dpy, scrnum);
  701.  
  702.   visinfo=glXChooseVisual(dpy,scrnum,attrib);
  703.   if (!visinfo) {
  704.     fprintf(stderr, "Error couldn't get an RGB, Double-buffered, Depth visual\n");
  705.     exit(1);
  706.   }
  707.  
  708.   /* window attributes */
  709.   attr.background_pixel=0;
  710.   attr.border_pixel=0;
  711.   attr.colormap=XCreateColormap(dpy,root,visinfo->visual,AllocNone);
  712.   attr.event_mask=KEY_MASK|MOUSE_MASK|VisibilityChangeMask;
  713.   mask=CWBackPixel|CWBorderPixel|CWColormap|CWEventMask;
  714.  
  715.   win=XCreateWindow(dpy,root,0,0,width,height,
  716.       0,visinfo->depth,InputOutput,
  717.       visinfo->visual,mask,&attr);
  718.   XMapWindow(dpy,win);
  719.  
  720.   XMoveWindow(dpy,win,0,0);
  721.  
  722.   XFlush(dpy);
  723.  
  724.   if (COM_CheckParm("-window"))
  725.     putenv("MESA_GLX_FX=window");
  726.   else
  727.     putenv("MESA_GLX_FX=fullscreen");
  728.  
  729.   ctx = glXCreateContext(dpy,visinfo,NULL,True);
  730.  
  731.   if (!ctx) {
  732.     fprintf(stderr, "Unable to create glX context.\n");
  733.     exit(1);
  734.   }
  735.  
  736.   glXMakeCurrent(dpy,win,ctx);
  737.  
  738.   scr_width = width;
  739.   scr_height = height;
  740.  
  741.   if (vid.conheight > height)
  742.     vid.conheight = height;
  743.   if (vid.conwidth > width)
  744.     vid.conwidth = width;
  745.   vid.width = vid.conwidth;
  746.   vid.height = vid.conheight;
  747.  
  748.   vid.aspect = ((float)vid.height / (float)vid.width) *
  749.         (320.0 / 240.0);
  750.   vid.numpages = 2;
  751.  
  752.   InitSig(); // trap evil signals
  753.  
  754.   GL_Init();
  755.  
  756.   sprintf (gldir, "%s/glquake", com_gamedir);
  757.   Sys_mkdir (gldir);
  758.  
  759.   VID_SetPalette(palette);
  760.  
  761.   // Check for 3DFX Extensions and initialize them.
  762.   VID_Init8bitPalette();
  763.  
  764.   Con_SafePrintf ("Video mode %dx%d initialized.\n", width, height);
  765.  
  766.   vid.recalc_refdef = 1;        // force a surface cache flush
  767. }
  768.  
  769. void Sys_SendKeyEvents(void)
  770. {
  771.   if (dpy)
  772.   {
  773.     while (Keyboard_Update())
  774.       ;
  775.  
  776.     while (keyq_head != keyq_tail)
  777.     {
  778.       Key_Event(keyq[keyq_tail].key, keyq[keyq_tail].down);
  779.       keyq_tail = (keyq_tail + 1) & 63;
  780.     }
  781.   }
  782. }
  783.  
  784. void Force_CenterView_f (void)
  785. {
  786.   cl.viewangles[PITCH] = 0;
  787. }
  788.  
  789.  
  790. void IN_Init(void)
  791. {
  792.   Cvar_RegisterVariable (&_windowed_mouse);
  793.   Cvar_RegisterVariable (&m_filter);
  794.   Cvar_RegisterVariable (&mouse_button_commands[0]);
  795.   Cvar_RegisterVariable (&mouse_button_commands[1]);
  796.   Cvar_RegisterVariable (&mouse_button_commands[2]);
  797.   Cmd_AddCommand ("force_centerview", Force_CenterView_f);
  798. }
  799.  
  800. void IN_Shutdown(void)
  801. {
  802. }
  803.  
  804. /*
  805. ===========
  806. IN_Commands
  807. ===========
  808. */
  809. void IN_Commands (void)
  810. {
  811.   int i;
  812.  
  813.   for (i=0 ; i<mouse_buttons ; i++) {
  814.     if ( (mouse_buttonstate & (1<<i)) && !(mouse_oldbuttonstate & (1<<i)) )
  815.       Key_Event (K_MOUSE1 + i, true);
  816.  
  817.     if ( !(mouse_buttonstate & (1<<i)) && (mouse_oldbuttonstate & (1<<i)) )
  818.       Key_Event (K_MOUSE1 + i, false);
  819.   }
  820.  
  821.   mouse_oldbuttonstate = mouse_buttonstate;
  822. }
  823.  
  824. /*
  825. ===========
  826. IN_Move
  827. ===========
  828. */
  829. void IN_Move (usercmd_t *cmd)
  830. {
  831.   while (Mouse_Update())
  832.     ;
  833.  
  834.   if (m_filter.value) {
  835.     mouse_x = (mouse_x + old_mouse_x) * 0.5;
  836.     mouse_y = (mouse_y + old_mouse_y) * 0.5;
  837.   }
  838.  
  839.   old_mouse_x = mouse_x;
  840.   old_mouse_y = mouse_y;
  841.    
  842.   mouse_x *= sensitivity.value;
  843.   mouse_y *= sensitivity.value;
  844.    
  845.   if ( (in_strafe.state & 1) || (lookstrafe.value && (in_mlook.state & 1) ))
  846.     cmd->sidemove += m_side.value * mouse_x;
  847.   else
  848.     cl.viewangles[YAW] -= m_yaw.value * mouse_x;
  849.   if (in_mlook.state & 1)
  850.     V_StopPitchDrift ();
  851.    
  852.   if ( (in_mlook.state & 1) && !(in_strafe.state & 1)) {
  853.     cl.viewangles[PITCH] += m_pitch.value * mouse_y;
  854.     if (cl.viewangles[PITCH] > 80)
  855.       cl.viewangles[PITCH] = 80;
  856.     if (cl.viewangles[PITCH] < -70)
  857.       cl.viewangles[PITCH] = -70;
  858.   } else {
  859.     if ((in_strafe.state & 1) && noclip_anglehack)
  860.       cmd->upmove -= m_forward.value * mouse_y;
  861.     else
  862.       cmd->forwardmove -= m_forward.value * mouse_y;
  863.   }
  864.   mouse_x = mouse_y = 0.0;
  865. }
  866.  
  867.  
  868. void  VID_LockBuffer (void) {}
  869. void  VID_UnlockBuffer (void) {}
  870.  
  871.