home *** CD-ROM | disk | FTP | other *** search
/ Magazyn Amiga 14 / MA_Cover_14.iso / source / c / q1source_amy / qw / client / gl_draw.c < prev    next >
Encoding:
C/C++ Source or Header  |  1999-12-21  |  29.4 KB  |  1,379 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.  
  21. // draw.c -- this is the only file outside the refresh that touches the
  22. // vid buffer
  23.  
  24. #include "quakedef.h"
  25.  
  26. extern unsigned char d_15to8table[65536];
  27. extern cvar_t crosshair, cl_crossx, cl_crossy, crosshaircolor;
  28.  
  29. cvar_t        gl_nobind = {"gl_nobind", "0"};
  30. cvar_t        gl_max_size = {"gl_max_size", "1024"};
  31. cvar_t        gl_picmip = {"gl_picmip", "0"};
  32.  
  33. byte        *draw_chars;                // 8*8 graphic characters
  34. qpic_t        *draw_disc;
  35. qpic_t        *draw_backtile;
  36.  
  37. int            translate_texture;
  38. int            char_texture;
  39. int            cs_texture; // crosshair texture
  40.  
  41. static byte cs_data[64] = {
  42.     0xff, 0xff, 0xff, 0xfe, 0xff, 0xff, 0xff, 0xff,
  43.     0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
  44.     0xff, 0xff, 0xff, 0xfe, 0xff, 0xff, 0xff, 0xff,
  45.     0xfe, 0xff, 0xfe, 0xff, 0xfe, 0xff, 0xfe, 0xff,
  46.     0xff, 0xff, 0xff, 0xfe, 0xff, 0xff, 0xff, 0xff,
  47.     0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
  48.     0xff, 0xff, 0xff, 0xfe, 0xff, 0xff, 0xff, 0xff,
  49.     0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff
  50. };
  51.  
  52.  
  53. typedef struct
  54. {
  55.     int        texnum;
  56.     float    sl, tl, sh, th;
  57. } glpic_t;
  58.  
  59. byte        conback_buffer[sizeof(qpic_t) + sizeof(glpic_t)];
  60. qpic_t        *conback = (qpic_t *)&conback_buffer;
  61.  
  62. int        gl_lightmap_format = 4;
  63. int        gl_solid_format = 3;
  64. int        gl_alpha_format = 4;
  65.  
  66. int        gl_filter_min = GL_LINEAR_MIPMAP_NEAREST;
  67. int        gl_filter_max = GL_LINEAR;
  68.  
  69.  
  70. int        texels;
  71.  
  72. typedef struct
  73. {
  74.     int        texnum;
  75.     char    identifier[64];
  76.     int        width, height;
  77.     qboolean    mipmap;
  78. } gltexture_t;
  79.  
  80. #define    MAX_GLTEXTURES    1024
  81. gltexture_t    gltextures[MAX_GLTEXTURES];
  82. int            numgltextures;
  83.  
  84. void GL_Bind (int texnum)
  85. {
  86.     if (gl_nobind.value)
  87.         texnum = char_texture;
  88.     if (currenttexture == texnum)
  89.         return;
  90.     currenttexture = texnum;
  91. #ifdef _WIN32
  92.     bindTexFunc (GL_TEXTURE_2D, texnum);
  93. #else
  94.     glBindTexture (GL_TEXTURE_2D, texnum);
  95. #endif
  96. }
  97.  
  98.  
  99. /*
  100. =============================================================================
  101.  
  102.   scrap allocation
  103.  
  104.   Allocate all the little status bar obejcts into a single texture
  105.   to crutch up stupid hardware / drivers
  106.  
  107. =============================================================================
  108. */
  109.  
  110. #define    MAX_SCRAPS        1
  111. #define    BLOCK_WIDTH        256
  112. #define    BLOCK_HEIGHT    256
  113.  
  114. int            scrap_allocated[MAX_SCRAPS][BLOCK_WIDTH];
  115. byte        scrap_texels[MAX_SCRAPS][BLOCK_WIDTH*BLOCK_HEIGHT*4];
  116. qboolean    scrap_dirty;
  117. int            scrap_texnum;
  118.  
  119. // returns a texture number and the position inside it
  120. int Scrap_AllocBlock (int w, int h, int *x, int *y)
  121. {
  122.     int        i, j;
  123.     int        best, best2;
  124.     int        texnum;
  125.  
  126.     for (texnum=0 ; texnum<MAX_SCRAPS ; texnum++)
  127.     {
  128.         best = BLOCK_HEIGHT;
  129.  
  130.         for (i=0 ; i<BLOCK_WIDTH-w ; i++)
  131.         {
  132.             best2 = 0;
  133.  
  134.             for (j=0 ; j<w ; j++)
  135.             {
  136.                 if (scrap_allocated[texnum][i+j] >= best)
  137.                     break;
  138.                 if (scrap_allocated[texnum][i+j] > best2)
  139.                     best2 = scrap_allocated[texnum][i+j];
  140.             }
  141.             if (j == w)
  142.             {    // this is a valid spot
  143.                 *x = i;
  144.                 *y = best = best2;
  145.             }
  146.         }
  147.  
  148.         if (best + h > BLOCK_HEIGHT)
  149.             continue;
  150.  
  151.         for (i=0 ; i<w ; i++)
  152.             scrap_allocated[texnum][*x + i] = best + h;
  153.  
  154.         return texnum;
  155.     }
  156.  
  157.     Sys_Error ("Scrap_AllocBlock: full");
  158.     return 0;
  159. }
  160.  
  161. int    scrap_uploads;
  162.  
  163. void Scrap_Upload (void)
  164. {
  165.     scrap_uploads++;
  166.     GL_Bind(scrap_texnum);
  167.     GL_Upload8 (scrap_texels[0], BLOCK_WIDTH, BLOCK_HEIGHT, false, true);
  168.     scrap_dirty = false;
  169. }
  170.  
  171. //=============================================================================
  172. /* Support Routines */
  173.  
  174. typedef struct cachepic_s
  175. {
  176.     char        name[MAX_QPATH];
  177.     qpic_t        pic;
  178.     byte        padding[32];    // for appended glpic
  179. } cachepic_t;
  180.  
  181. #define    MAX_CACHED_PICS        128
  182. cachepic_t    menu_cachepics[MAX_CACHED_PICS];
  183. int            menu_numcachepics;
  184.  
  185. byte        menuplyr_pixels[4096];
  186.  
  187. int        pic_texels;
  188. int        pic_count;
  189.  
  190. qpic_t *Draw_PicFromWad (char *name)
  191. {
  192.     qpic_t    *p;
  193.     glpic_t    *gl;
  194.  
  195.     p = W_GetLumpName (name);
  196.     gl = (glpic_t *)p->data;
  197.  
  198.     // load little ones into the scrap
  199.     if (p->width < 64 && p->height < 64)
  200.     {
  201.         int        x, y;
  202.         int        i, j, k;
  203.         int        texnum;
  204.  
  205.         texnum = Scrap_AllocBlock (p->width, p->height, &x, &y);
  206.         scrap_dirty = true;
  207.         k = 0;
  208.         for (i=0 ; i<p->height ; i++)
  209.             for (j=0 ; j<p->width ; j++, k++)
  210.                 scrap_texels[texnum][(y+i)*BLOCK_WIDTH + x + j] = p->data[k];
  211.         texnum += scrap_texnum;
  212.         gl->texnum = texnum;
  213.         gl->sl = (x+0.01)/(float)BLOCK_WIDTH;
  214.         gl->sh = (x+p->width-0.01)/(float)BLOCK_WIDTH;
  215.         gl->tl = (y+0.01)/(float)BLOCK_WIDTH;
  216.         gl->th = (y+p->height-0.01)/(float)BLOCK_WIDTH;
  217.  
  218.         pic_count++;
  219.         pic_texels += p->width*p->height;
  220.     }
  221.     else
  222.     {
  223.         gl->texnum = GL_LoadPicTexture (p);
  224.         gl->sl = 0;
  225.         gl->sh = 1;
  226.         gl->tl = 0;
  227.         gl->th = 1;
  228.     }
  229.     return p;
  230. }
  231.  
  232.  
  233. /*
  234. ================
  235. Draw_CachePic
  236. ================
  237. */
  238. qpic_t    *Draw_CachePic (char *path)
  239. {
  240.     cachepic_t    *pic;
  241.     int            i;
  242.     qpic_t        *dat;
  243.     glpic_t        *gl;
  244.  
  245.     for (pic=menu_cachepics, i=0 ; i<menu_numcachepics ; pic++, i++)
  246.         if (!strcmp (path, pic->name))
  247.             return &pic->pic;
  248.  
  249.     if (menu_numcachepics == MAX_CACHED_PICS)
  250.         Sys_Error ("menu_numcachepics == MAX_CACHED_PICS");
  251.     menu_numcachepics++;
  252.     strcpy (pic->name, path);
  253.  
  254. //
  255. // load the pic from disk
  256. //
  257.     dat = (qpic_t *)COM_LoadTempFile (path);    
  258.     if (!dat)
  259.         Sys_Error ("Draw_CachePic: failed to load %s", path);
  260.     SwapPic (dat);
  261.  
  262.     // HACK HACK HACK --- we need to keep the bytes for
  263.     // the translatable player picture just for the menu
  264.     // configuration dialog
  265.     if (!strcmp (path, "gfx/menuplyr.lmp"))
  266.         memcpy (menuplyr_pixels, dat->data, dat->width*dat->height);
  267.  
  268.     pic->pic.width = dat->width;
  269.     pic->pic.height = dat->height;
  270.  
  271.     gl = (glpic_t *)pic->pic.data;
  272.     gl->texnum = GL_LoadPicTexture (dat);
  273.     gl->sl = 0;
  274.     gl->sh = 1;
  275.     gl->tl = 0;
  276.     gl->th = 1;
  277.  
  278.     return &pic->pic;
  279. }
  280.  
  281.  
  282. void Draw_CharToConback (int num, byte *dest)
  283. {
  284.     int        row, col;
  285.     byte    *source;
  286.     int        drawline;
  287.     int        x;
  288.  
  289.     row = num>>4;
  290.     col = num&15;
  291.     source = draw_chars + (row<<10) + (col<<3);
  292.  
  293.     drawline = 8;
  294.  
  295.     while (drawline--)
  296.     {
  297.         for (x=0 ; x<8 ; x++)
  298.             if (source[x] != 255)
  299.                 dest[x] = 0x60 + source[x];
  300.         source += 128;
  301.         dest += 320;
  302.     }
  303.  
  304. }
  305.  
  306. typedef struct
  307. {
  308.     char *name;
  309.     int    minimize, maximize;
  310. } glmode_t;
  311.  
  312. glmode_t modes[] = {
  313.     {"GL_NEAREST", GL_NEAREST, GL_NEAREST},
  314.     {"GL_LINEAR", GL_LINEAR, GL_LINEAR},
  315.     {"GL_NEAREST_MIPMAP_NEAREST", GL_NEAREST_MIPMAP_NEAREST, GL_NEAREST},
  316.     {"GL_LINEAR_MIPMAP_NEAREST", GL_LINEAR_MIPMAP_NEAREST, GL_LINEAR},
  317.     {"GL_NEAREST_MIPMAP_LINEAR", GL_NEAREST_MIPMAP_LINEAR, GL_NEAREST},
  318.     {"GL_LINEAR_MIPMAP_LINEAR", GL_LINEAR_MIPMAP_LINEAR, GL_LINEAR}
  319. };
  320.  
  321. /*
  322. ===============
  323. Draw_TextureMode_f
  324. ===============
  325. */
  326. void Draw_TextureMode_f (void)
  327. {
  328.     int        i;
  329.     gltexture_t    *glt;
  330.  
  331.     if (Cmd_Argc() == 1)
  332.     {
  333.         for (i=0 ; i< 6 ; i++)
  334.             if (gl_filter_min == modes[i].minimize)
  335.             {
  336.                 Con_Printf ("%s\n", modes[i].name);
  337.                 return;
  338.             }
  339.         Con_Printf ("current filter is unknown???\n");
  340.         return;
  341.     }
  342.  
  343.     for (i=0 ; i< 6 ; i++)
  344.     {
  345.         if (!Q_strcasecmp (modes[i].name, Cmd_Argv(1) ) )
  346.             break;
  347.     }
  348.     if (i == 6)
  349.     {
  350.         Con_Printf ("bad filter name\n");
  351.         return;
  352.     }
  353.  
  354.     gl_filter_min = modes[i].minimize;
  355.     gl_filter_max = modes[i].maximize;
  356.  
  357.     // change all the existing mipmap texture objects
  358.     for (i=0, glt=gltextures ; i<numgltextures ; i++, glt++)
  359.     {
  360.         if (glt->mipmap)
  361.         {
  362.             GL_Bind (glt->texnum);
  363.             glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, gl_filter_min);
  364.             glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, gl_filter_max);
  365.         }
  366.     }
  367. }
  368.  
  369. /*
  370. ===============
  371. Draw_Init
  372. ===============
  373. */
  374. void Draw_Init (void)
  375. {
  376.     int        i;
  377.     qpic_t    *cb;
  378.     byte    *dest;
  379.     int        x;
  380.     char    ver[40];
  381.     glpic_t    *gl;
  382.     int start;
  383.     byte    *ncdata;
  384.  
  385.     Cvar_RegisterVariable (&gl_nobind);
  386.     Cvar_RegisterVariable (&gl_max_size);
  387.     Cvar_RegisterVariable (&gl_picmip);
  388.  
  389.     // 3dfx can only handle 256 wide textures
  390.     if (!Q_strncasecmp ((char *)gl_renderer, "3dfx",4) ||
  391.         !Q_strncasecmp ((char *)gl_renderer, "Mesa",4))
  392.         Cvar_Set ("gl_max_size", "256");
  393.  
  394.     Cmd_AddCommand ("gl_texturemode", &Draw_TextureMode_f);
  395.  
  396.     // load the console background and the charset
  397.     // by hand, because we need to write the version
  398.     // string into the background before turning
  399.     // it into a texture
  400.     draw_chars = W_GetLumpName ("conchars");
  401.     for (i=0 ; i<256*64 ; i++)
  402.         if (draw_chars[i] == 0)
  403.             draw_chars[i] = 255;    // proper transparent color
  404.  
  405.     // now turn them into textures
  406.     char_texture = GL_LoadTexture ("charset", 128, 128, draw_chars, false, true);
  407. //    Draw_CrosshairAdjust();
  408.     cs_texture = GL_LoadTexture ("crosshair", 8, 8, cs_data, false, true);
  409.  
  410.     start = Hunk_LowMark ();
  411.  
  412.     cb = (qpic_t *)COM_LoadHunkFile ("gfx/conback.lmp");    
  413.     if (!cb)
  414.         Sys_Error ("Couldn't load gfx/conback.lmp");
  415.     SwapPic (cb);
  416.  
  417.     sprintf (ver, "%4.2f", VERSION);
  418.     dest = cb->data + 320 + 320*186 - 11 - 8*strlen(ver);
  419.     for (x=0 ; x<strlen(ver) ; x++)
  420.         Draw_CharToConback (ver[x], dest+(x<<3));
  421.  
  422. #if 0
  423.     conback->width = vid.conwidth;
  424.     conback->height = vid.conheight;
  425.  
  426.     // scale console to vid size
  427.     dest = ncdata = Hunk_AllocName(vid.conwidth * vid.conheight, "conback");
  428.  
  429.     for (y=0 ; y<vid.conheight ; y++, dest += vid.conwidth)
  430.     {
  431.         src = cb->data + cb->width * (y*cb->height/vid.conheight);
  432.         if (vid.conwidth == cb->width)
  433.             memcpy (dest, src, vid.conwidth);
  434.         else
  435.         {
  436.             f = 0;
  437.             fstep = cb->width*0x10000/vid.conwidth;
  438.             for (x=0 ; x<vid.conwidth ; x+=4)
  439.             {
  440.                 dest[x] = src[f>>16];
  441.                 f += fstep;
  442.                 dest[x+1] = src[f>>16];
  443.                 f += fstep;
  444.                 dest[x+2] = src[f>>16];
  445.                 f += fstep;
  446.                 dest[x+3] = src[f>>16];
  447.                 f += fstep;
  448.             }
  449.         }
  450.     }
  451. #else
  452.     conback->width = cb->width;
  453.     conback->height = cb->height;
  454.     ncdata = cb->data;
  455. #endif
  456.     
  457.     glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
  458.     glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
  459.  
  460.     gl = (glpic_t *)conback->data;
  461.     gl->texnum = GL_LoadTexture ("conback", conback->width, conback->height, ncdata, false, false);
  462.     gl->sl = 0;
  463.     gl->sh = 1;
  464.     gl->tl = 0;
  465.     gl->th = 1;
  466.     conback->width = vid.conwidth;
  467.     conback->height = vid.conheight;
  468.  
  469.     // free loaded console
  470.     Hunk_FreeToLowMark (start);
  471.  
  472.     // save a texture slot for translated picture
  473.     translate_texture = texture_extension_number++;
  474.  
  475.     // save slots for scraps
  476.     scrap_texnum = texture_extension_number;
  477.     texture_extension_number += MAX_SCRAPS;
  478.  
  479.     //
  480.     // get the other pics we need
  481.     //
  482.     draw_disc = Draw_PicFromWad ("disc");
  483.     draw_backtile = Draw_PicFromWad ("backtile");
  484. }
  485.  
  486.  
  487.  
  488. /*
  489. ================
  490. Draw_Character
  491.  
  492. Draws one 8*8 graphics character with 0 being transparent.
  493. It can be clipped to the top of the screen to allow the console to be
  494. smoothly scrolled off.
  495. ================
  496. */
  497. void Draw_Character (int x, int y, int num)
  498. {
  499.     int                row, col;
  500.     float            frow, fcol, size;
  501.  
  502.     if (num == 32)
  503.         return;        // space
  504.  
  505.     num &= 255;
  506.     
  507.     if (y <= -8)
  508.         return;            // totally off screen
  509.  
  510.     row = num>>4;
  511.     col = num&15;
  512.  
  513.     frow = row*0.0625;
  514.     fcol = col*0.0625;
  515.     size = 0.0625;
  516.  
  517.     GL_Bind (char_texture);
  518.  
  519.     glBegin (GL_QUADS);
  520.     glTexCoord2f (fcol, frow);
  521.     glVertex2f (x, y);
  522.     glTexCoord2f (fcol + size, frow);
  523.     glVertex2f (x+8, y);
  524.     glTexCoord2f (fcol + size, frow + size);
  525.     glVertex2f (x+8, y+8);
  526.     glTexCoord2f (fcol, frow + size);
  527.     glVertex2f (x, y+8);
  528.     glEnd ();
  529. }
  530.  
  531. /*
  532. ================
  533. Draw_String
  534. ================
  535. */
  536. void Draw_String (int x, int y, char *str)
  537. {
  538.     while (*str)
  539.     {
  540.         Draw_Character (x, y, *str);
  541.         str++;
  542.         x += 8;
  543.     }
  544. }
  545.  
  546. /*
  547. ================
  548. Draw_Alt_String
  549. ================
  550. */
  551. void Draw_Alt_String (int x, int y, char *str)
  552. {
  553.     while (*str)
  554.     {
  555.         Draw_Character (x, y, (*str) | 0x80);
  556.         str++;
  557.         x += 8;
  558.     }
  559. }
  560.  
  561. void Draw_Crosshair(void)
  562. {
  563.     int x, y;
  564.     extern vrect_t        scr_vrect;
  565.     unsigned char *pColor;
  566.  
  567.     if (crosshair.value == 2) {
  568.         x = scr_vrect.x + scr_vrect.width/2 - 3 + cl_crossx.value; 
  569.         y = scr_vrect.y + scr_vrect.height/2 - 3 + cl_crossy.value;
  570.  
  571.         glTexEnvf ( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE );
  572.         pColor = (unsigned char *) &d_8to24table[(byte) crosshaircolor.value];
  573.         glColor4ubv ( pColor );
  574.         GL_Bind (cs_texture);
  575.  
  576.         glBegin (GL_QUADS);
  577.         glTexCoord2f (0, 0);
  578.         glVertex2f (x - 4, y - 4);
  579.         glTexCoord2f (1, 0);
  580.         glVertex2f (x+12, y-4);
  581.         glTexCoord2f (1, 1);
  582.         glVertex2f (x+12, y+12);
  583.         glTexCoord2f (0, 1);
  584.         glVertex2f (x - 4, y+12);
  585.         glEnd ();
  586.         
  587.         glTexEnvf ( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE );
  588.     } else if (crosshair.value)
  589.         Draw_Character (scr_vrect.x + scr_vrect.width/2-4 + cl_crossx.value, 
  590.             scr_vrect.y + scr_vrect.height/2-4 + cl_crossy.value, 
  591.             '+');
  592. }
  593.  
  594.  
  595. /*
  596. ================
  597. Draw_DebugChar
  598.  
  599. Draws a single character directly to the upper right corner of the screen.
  600. This is for debugging lockups by drawing different chars in different parts
  601. of the code.
  602. ================
  603. */
  604. void Draw_DebugChar (char num)
  605. {
  606. }
  607.  
  608. /*
  609. =============
  610. Draw_Pic
  611. =============
  612. */
  613. void Draw_Pic (int x, int y, qpic_t *pic)
  614. {
  615.     glpic_t            *gl;
  616.  
  617.     if (scrap_dirty)
  618.         Scrap_Upload ();
  619.     gl = (glpic_t *)pic->data;
  620.     glColor4f (1,1,1,1);
  621.     GL_Bind (gl->texnum);
  622.     glBegin (GL_QUADS);
  623.     glTexCoord2f (gl->sl, gl->tl);
  624.     glVertex2f (x, y);
  625.     glTexCoord2f (gl->sh, gl->tl);
  626.     glVertex2f (x+pic->width, y);
  627.     glTexCoord2f (gl->sh, gl->th);
  628.     glVertex2f (x+pic->width, y+pic->height);
  629.     glTexCoord2f (gl->sl, gl->th);
  630.     glVertex2f (x, y+pic->height);
  631.     glEnd ();
  632. }
  633.  
  634. /*
  635. =============
  636. Draw_AlphaPic
  637. =============
  638. */
  639. void Draw_AlphaPic (int x, int y, qpic_t *pic, float alpha)
  640. {
  641.     glpic_t            *gl;
  642.  
  643.     if (scrap_dirty)
  644.         Scrap_Upload ();
  645.     gl = (glpic_t *)pic->data;
  646.     glDisable(GL_ALPHA_TEST);
  647.     glEnable (GL_BLEND);
  648. //    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
  649.     glCullFace(GL_FRONT);
  650.     glColor4f (1,1,1,alpha);
  651.     GL_Bind (gl->texnum);
  652.     glBegin (GL_QUADS);
  653.     glTexCoord2f (gl->sl, gl->tl);
  654.     glVertex2f (x, y);
  655.     glTexCoord2f (gl->sh, gl->tl);
  656.     glVertex2f (x+pic->width, y);
  657.     glTexCoord2f (gl->sh, gl->th);
  658.     glVertex2f (x+pic->width, y+pic->height);
  659.     glTexCoord2f (gl->sl, gl->th);
  660.     glVertex2f (x, y+pic->height);
  661.     glEnd ();
  662.     glColor4f (1,1,1,1);
  663.     glEnable(GL_ALPHA_TEST);
  664.     glDisable (GL_BLEND);
  665. }
  666.  
  667. void Draw_SubPic(int x, int y, qpic_t *pic, int srcx, int srcy, int width, int height)
  668. {
  669.     glpic_t            *gl;
  670.     float newsl, newtl, newsh, newth;
  671.     float oldglwidth, oldglheight;
  672.  
  673.     if (scrap_dirty)
  674.         Scrap_Upload ();
  675.     gl = (glpic_t *)pic->data;
  676.     
  677.     oldglwidth = gl->sh - gl->sl;
  678.     oldglheight = gl->th - gl->tl;
  679.  
  680.     newsl = gl->sl + (srcx*oldglwidth)/pic->width;
  681.     newsh = newsl + (width*oldglwidth)/pic->width;
  682.  
  683.     newtl = gl->tl + (srcy*oldglheight)/pic->height;
  684.     newth = newtl + (height*oldglheight)/pic->height;
  685.     
  686.     glColor4f (1,1,1,1);
  687.     GL_Bind (gl->texnum);
  688.     glBegin (GL_QUADS);
  689.     glTexCoord2f (newsl, newtl);
  690.     glVertex2f (x, y);
  691.     glTexCoord2f (newsh, newtl);
  692.     glVertex2f (x+width, y);
  693.     glTexCoord2f (newsh, newth);
  694.     glVertex2f (x+width, y+height);
  695.     glTexCoord2f (newsl, newth);
  696.     glVertex2f (x, y+height);
  697.     glEnd ();
  698. }
  699.  
  700. /*
  701. =============
  702. Draw_TransPic
  703. =============
  704. */
  705. void Draw_TransPic (int x, int y, qpic_t *pic)
  706. {
  707.  
  708.     if (x < 0 || (unsigned)(x + pic->width) > vid.width || y < 0 ||
  709.          (unsigned)(y + pic->height) > vid.height)
  710.     {
  711.         Sys_Error ("Draw_TransPic: bad coordinates");
  712.     }
  713.         
  714.     Draw_Pic (x, y, pic);
  715. }
  716.  
  717.  
  718. /*
  719. =============
  720. Draw_TransPicTranslate
  721.  
  722. Only used for the player color selection menu
  723. =============
  724. */
  725. void Draw_TransPicTranslate (int x, int y, qpic_t *pic, byte *translation)
  726. {
  727.     int                v, u, c;
  728.     unsigned        trans[64*64], *dest;
  729.     byte            *src;
  730.     int                p;
  731.  
  732.     GL_Bind (translate_texture);
  733.  
  734.     c = pic->width * pic->height;
  735.  
  736.     dest = trans;
  737.     for (v=0 ; v<64 ; v++, dest += 64)
  738.     {
  739.         src = &menuplyr_pixels[ ((v*pic->height)>>6) *pic->width];
  740.         for (u=0 ; u<64 ; u++)
  741.         {
  742.             p = src[(u*pic->width)>>6];
  743.             if (p == 255)
  744.                 dest[u] = p;
  745.             else
  746.                 dest[u] =  d_8to24table[translation[p]];
  747.         }
  748.     }
  749.  
  750.     glTexImage2D (GL_TEXTURE_2D, 0, gl_alpha_format, 64, 64, 0, GL_RGBA, GL_UNSIGNED_BYTE, trans);
  751.  
  752.     glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
  753.     glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
  754.  
  755.     glColor3f (1,1,1);
  756.     glBegin (GL_QUADS);
  757.     glTexCoord2f (0, 0);
  758.     glVertex2f (x, y);
  759.     glTexCoord2f (1, 0);
  760.     glVertex2f (x+pic->width, y);
  761.     glTexCoord2f (1, 1);
  762.     glVertex2f (x+pic->width, y+pic->height);
  763.     glTexCoord2f (0, 1);
  764.     glVertex2f (x, y+pic->height);
  765.     glEnd ();
  766. }
  767.  
  768.  
  769. /*
  770. ================
  771. Draw_ConsoleBackground
  772.  
  773. ================
  774. */
  775. void Draw_ConsoleBackground (int lines)
  776. {
  777.     char ver[80];
  778.     int x, i;
  779.     int y;
  780.  
  781.     y = (vid.height * 3) >> 2;
  782.     if (lines > y)
  783.         Draw_Pic(0, lines-vid.height, conback);
  784.     else
  785.         Draw_AlphaPic (0, lines - vid.height, conback, (float)(1.2 * lines)/y);
  786.  
  787.     // hack the version number directly into the pic
  788. //    y = lines-186;
  789.     y = lines-14;
  790.     if (!cls.download) {
  791. #ifdef __linux__
  792.         sprintf (ver, "LinuxGL (%4.2f) QuakeWorld", LINUX_VERSION);
  793. #else
  794.         sprintf (ver, "GL (%4.2f) QuakeWorld", GLQUAKE_VERSION);
  795. #endif
  796.         x = vid.conwidth - (strlen(ver)*8 + 11) - (vid.conwidth*8/320)*7;
  797.         for (i=0 ; i<strlen(ver) ; i++)
  798.             Draw_Character (x + i * 8, y, ver[i] | 0x80);
  799.     }
  800. }
  801.  
  802.  
  803. /*
  804. =============
  805. Draw_TileClear
  806.  
  807. This repeats a 64*64 tile graphic to fill the screen around a sized down
  808. refresh window.
  809. =============
  810. */
  811. void Draw_TileClear (int x, int y, int w, int h)
  812. {
  813.     glColor3f (1,1,1);
  814.     GL_Bind (*(int *)draw_backtile->data);
  815.     glBegin (GL_QUADS);
  816.     glTexCoord2f (x/64.0, y/64.0);
  817.     glVertex2f (x, y);
  818.     glTexCoord2f ( (x+w)/64.0, y/64.0);
  819.     glVertex2f (x+w, y);
  820.     glTexCoord2f ( (x+w)/64.0, (y+h)/64.0);
  821.     glVertex2f (x+w, y+h);
  822.     glTexCoord2f ( x/64.0, (y+h)/64.0 );
  823.     glVertex2f (x, y+h);
  824.     glEnd ();
  825. }
  826.  
  827.  
  828. /*
  829. =============
  830. Draw_Fill
  831.  
  832. Fills a box of pixels with a single color
  833. =============
  834. */
  835. void Draw_Fill (int x, int y, int w, int h, int c)
  836. {
  837.     glDisable (GL_TEXTURE_2D);
  838.     glColor3f (host_basepal[c*3]/255.0,
  839.         host_basepal[c*3+1]/255.0,
  840.         host_basepal[c*3+2]/255.0);
  841.  
  842.     glBegin (GL_QUADS);
  843.  
  844.     glVertex2f (x,y);
  845.     glVertex2f (x+w, y);
  846.     glVertex2f (x+w, y+h);
  847.     glVertex2f (x, y+h);
  848.  
  849.     glEnd ();
  850.     glColor3f (1,1,1);
  851.     glEnable (GL_TEXTURE_2D);
  852. }
  853. //=============================================================================
  854.  
  855. /*
  856. ================
  857. Draw_FadeScreen
  858.  
  859. ================
  860. */
  861. void Draw_FadeScreen (void)
  862. {
  863.     glEnable (GL_BLEND);
  864.     glDisable (GL_TEXTURE_2D);
  865.     glColor4f (0, 0, 0, 0.8);
  866.     glBegin (GL_QUADS);
  867.  
  868.     glVertex2f (0,0);
  869.     glVertex2f (vid.width, 0);
  870.     glVertex2f (vid.width, vid.height);
  871.     glVertex2f (0, vid.height);
  872.  
  873.     glEnd ();
  874.     glColor4f (1,1,1,1);
  875.     glEnable (GL_TEXTURE_2D);
  876.     glDisable (GL_BLEND);
  877.  
  878.     Sbar_Changed();
  879. }
  880.  
  881. //=============================================================================
  882.  
  883. /*
  884. ================
  885. Draw_BeginDisc
  886.  
  887. Draws the little blue disc in the corner of the screen.
  888. Call before beginning any disc IO.
  889. ================
  890. */
  891. void Draw_BeginDisc (void)
  892. {
  893.     if (!draw_disc)
  894.         return;
  895.     glDrawBuffer  (GL_FRONT);
  896.     Draw_Pic (vid.width - 24, 0, draw_disc);
  897.     glDrawBuffer  (GL_BACK);
  898. }
  899.  
  900.  
  901. /*
  902. ================
  903. Draw_EndDisc
  904.  
  905. Erases the disc icon.
  906. Call after completing any disc IO
  907. ================
  908. */
  909. void Draw_EndDisc (void)
  910. {
  911. }
  912.  
  913. /*
  914. ================
  915. GL_Set2D
  916.  
  917. Setup as if the screen was 320*200
  918. ================
  919. */
  920. void GL_Set2D (void)
  921. {
  922.     glViewport (glx, gly, glwidth, glheight);
  923.  
  924.     glMatrixMode(GL_PROJECTION);
  925.     glLoadIdentity ();
  926.     glOrtho  (0, vid.width, vid.height, 0, -99999, 99999);
  927.  
  928.     glMatrixMode(GL_MODELVIEW);
  929.     glLoadIdentity ();
  930.  
  931.     glDisable (GL_DEPTH_TEST);
  932.     glDisable (GL_CULL_FACE);
  933.     glDisable (GL_BLEND);
  934.     glEnable (GL_ALPHA_TEST);
  935. //    glDisable (GL_ALPHA_TEST);
  936.  
  937.     glColor4f (1,1,1,1);
  938. }
  939.  
  940. //====================================================================
  941.  
  942. /*
  943. ================
  944. GL_FindTexture
  945. ================
  946. */
  947. int GL_FindTexture (char *identifier)
  948. {
  949.     int        i;
  950.     gltexture_t    *glt;
  951.  
  952.     for (i=0, glt=gltextures ; i<numgltextures ; i++, glt++)
  953.     {
  954.         if (!strcmp (identifier, glt->identifier))
  955.             return gltextures[i].texnum;
  956.     }
  957.  
  958.     return -1;
  959. }
  960.  
  961. /*
  962. ================
  963. GL_ResampleTexture
  964. ================
  965. */
  966. void GL_ResampleTexture (unsigned *in, int inwidth, int inheight, unsigned *out,  int outwidth, int outheight)
  967. {
  968.     int        i, j;
  969.     unsigned    *inrow;
  970.     unsigned    frac, fracstep;
  971.  
  972.     fracstep = inwidth*0x10000/outwidth;
  973.     for (i=0 ; i<outheight ; i++, out += outwidth)
  974.     {
  975.         inrow = in + inwidth*(i*inheight/outheight);
  976.         frac = fracstep >> 1;
  977.         for (j=0 ; j<outwidth ; j+=4)
  978.         {
  979.             out[j] = inrow[frac>>16];
  980.             frac += fracstep;
  981.             out[j+1] = inrow[frac>>16];
  982.             frac += fracstep;
  983.             out[j+2] = inrow[frac>>16];
  984.             frac += fracstep;
  985.             out[j+3] = inrow[frac>>16];
  986.             frac += fracstep;
  987.         }
  988.     }
  989. }
  990.  
  991. /*
  992. ================
  993. GL_Resample8BitTexture -- JACK
  994. ================
  995. */
  996. void GL_Resample8BitTexture (unsigned char *in, int inwidth, int inheight, unsigned char *out,  int outwidth, int outheight)
  997. {
  998.     int        i, j;
  999.     unsigned    char *inrow;
  1000.     unsigned    frac, fracstep;
  1001.  
  1002.     fracstep = inwidth*0x10000/outwidth;
  1003.     for (i=0 ; i<outheight ; i++, out += outwidth)
  1004.     {
  1005.         inrow = in + inwidth*(i*inheight/outheight);
  1006.         frac = fracstep >> 1;
  1007.         for (j=0 ; j<outwidth ; j+=4)
  1008.         {
  1009.             out[j] = inrow[frac>>16];
  1010.             frac += fracstep;
  1011.             out[j+1] = inrow[frac>>16];
  1012.             frac += fracstep;
  1013.             out[j+2] = inrow[frac>>16];
  1014.             frac += fracstep;
  1015.             out[j+3] = inrow[frac>>16];
  1016.             frac += fracstep;
  1017.         }
  1018.     }
  1019. }
  1020.  
  1021. /*
  1022. ================
  1023. GL_MipMap
  1024.  
  1025. Operates in place, quartering the size of the texture
  1026. ================
  1027. */
  1028. void GL_MipMap (byte *in, int width, int height)
  1029. {
  1030.     int        i, j;
  1031.     byte    *out;
  1032.  
  1033.     width <<=2;
  1034.     height >>= 1;
  1035.     out = in;
  1036.     for (i=0 ; i<height ; i++, in+=width)
  1037.     {
  1038.         for (j=0 ; j<width ; j+=8, out+=4, in+=8)
  1039.         {
  1040.             out[0] = (in[0] + in[4] + in[width+0] + in[width+4])>>2;
  1041.             out[1] = (in[1] + in[5] + in[width+1] + in[width+5])>>2;
  1042.             out[2] = (in[2] + in[6] + in[width+2] + in[width+6])>>2;
  1043.             out[3] = (in[3] + in[7] + in[width+3] + in[width+7])>>2;
  1044.         }
  1045.     }
  1046. }
  1047.  
  1048. /*
  1049. ================
  1050. GL_MipMap8Bit
  1051.  
  1052. Mipping for 8 bit textures
  1053. ================
  1054. */
  1055. void GL_MipMap8Bit (byte *in, int width, int height)
  1056. {
  1057.     int        i, j;
  1058.     byte    *out;
  1059.     unsigned short     r,g,b;
  1060.     byte    *at1, *at2, *at3, *at4;
  1061.  
  1062.     height >>= 1;
  1063.     out = in;
  1064.     for (i=0 ; i<height ; i++, in+=width)
  1065.         for (j=0 ; j<width ; j+=2, out+=1, in+=2)
  1066.         {
  1067.             at1 = (byte *) &d_8to24table[in[0]];
  1068.             at2 = (byte *) &d_8to24table[in[1]];
  1069.             at3 = (byte *) &d_8to24table[in[width+0]];
  1070.             at4 = (byte *) &d_8to24table[in[width+1]];
  1071.  
  1072.              r = (at1[0]+at2[0]+at3[0]+at4[0]); r>>=5;
  1073.              g = (at1[1]+at2[1]+at3[1]+at4[1]); g>>=5;
  1074.              b = (at1[2]+at2[2]+at3[2]+at4[2]); b>>=5;
  1075.  
  1076.             out[0] = d_15to8table[(r<<0) + (g<<5) + (b<<10)];
  1077.         }
  1078. }
  1079.  
  1080. /*
  1081. ===============
  1082. GL_Upload32
  1083. ===============
  1084. */
  1085. void GL_Upload32 (unsigned *data, int width, int height,  qboolean mipmap, qboolean alpha)
  1086. {
  1087.     int            samples;
  1088. static    unsigned    scaled[1024*512];    // [512*256];
  1089.     int            scaled_width, scaled_height;
  1090.  
  1091.     for (scaled_width = 1 ; scaled_width < width ; scaled_width<<=1)
  1092.         ;
  1093.     for (scaled_height = 1 ; scaled_height < height ; scaled_height<<=1)
  1094.         ;
  1095.  
  1096.     scaled_width >>= (int)gl_picmip.value;
  1097.     scaled_height >>= (int)gl_picmip.value;
  1098.  
  1099.     if (scaled_width > gl_max_size.value)
  1100.         scaled_width = gl_max_size.value;
  1101.     if (scaled_height > gl_max_size.value)
  1102.         scaled_height = gl_max_size.value;
  1103.  
  1104.     if (scaled_width * scaled_height > sizeof(scaled)/4)
  1105.         Sys_Error ("GL_LoadTexture: too big");
  1106.  
  1107.     samples = alpha ? gl_alpha_format : gl_solid_format;
  1108.  
  1109. #if 0
  1110.     if (mipmap)
  1111.         gluBuild2DMipmaps (GL_TEXTURE_2D, samples, width, height, GL_RGBA, GL_UNSIGNED_BYTE, trans);
  1112.     else if (scaled_width == width && scaled_height == height)
  1113.         glTexImage2D (GL_TEXTURE_2D, 0, samples, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, trans);
  1114.     else
  1115.     {
  1116.         gluScaleImage (GL_RGBA, width, height, GL_UNSIGNED_BYTE, trans,
  1117.             scaled_width, scaled_height, GL_UNSIGNED_BYTE, scaled);
  1118.         glTexImage2D (GL_TEXTURE_2D, 0, samples, scaled_width, scaled_height, 0, GL_RGBA, GL_UNSIGNED_BYTE, scaled);
  1119.     }
  1120. #else
  1121. texels += scaled_width * scaled_height;
  1122.  
  1123.     if (scaled_width == width && scaled_height == height)
  1124.     {
  1125.         if (!mipmap)
  1126.         {
  1127.             glTexImage2D (GL_TEXTURE_2D, 0, samples, scaled_width, scaled_height, 0, GL_RGBA, GL_UNSIGNED_BYTE, data);
  1128.             goto done;
  1129.         }
  1130.         memcpy (scaled, data, width*height*4);
  1131.     }
  1132.     else
  1133.         GL_ResampleTexture (data, width, height, scaled, scaled_width, scaled_height);
  1134.  
  1135.     glTexImage2D (GL_TEXTURE_2D, 0, samples, scaled_width, scaled_height, 0, GL_RGBA, GL_UNSIGNED_BYTE, scaled);
  1136.     if (mipmap)
  1137.     {
  1138.         int        miplevel;
  1139.  
  1140.         miplevel = 0;
  1141.         while (scaled_width > 1 || scaled_height > 1)
  1142.         {
  1143.             GL_MipMap ((byte *)scaled, scaled_width, scaled_height);
  1144.             scaled_width >>= 1;
  1145.             scaled_height >>= 1;
  1146.             if (scaled_width < 1)
  1147.                 scaled_width = 1;
  1148.             if (scaled_height < 1)
  1149.                 scaled_height = 1;
  1150.             miplevel++;
  1151.             glTexImage2D (GL_TEXTURE_2D, miplevel, samples, scaled_width, scaled_height, 0, GL_RGBA, GL_UNSIGNED_BYTE, scaled);
  1152.         }
  1153.     }
  1154. done: ;
  1155. #endif
  1156.  
  1157.  
  1158.     if (mipmap)
  1159.     {
  1160.         glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, gl_filter_min);
  1161.         glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, gl_filter_max);
  1162.     }
  1163.     else
  1164.     {
  1165.         glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, gl_filter_max);
  1166.         glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, gl_filter_max);
  1167.     }
  1168. }
  1169.  
  1170. void GL_Upload8_EXT (byte *data, int width, int height,  qboolean mipmap, qboolean alpha) 
  1171. {
  1172.     int            i, s;
  1173.     qboolean    noalpha;
  1174.     int            samples;
  1175.     static    unsigned char scaled[1024*512];    // [512*256];
  1176.     int            scaled_width, scaled_height;
  1177.  
  1178.     s = width*height;
  1179.     // if there are no transparent pixels, make it a 3 component
  1180.     // texture even if it was specified as otherwise
  1181.     if (alpha)
  1182.     {
  1183.         noalpha = true;
  1184.         for (i=0 ; i<s ; i++)
  1185.         {
  1186.             if (data[i] == 255)
  1187.                 noalpha = false;
  1188.         }
  1189.  
  1190.         if (alpha && noalpha)
  1191.             alpha = false;
  1192.     }
  1193.     for (scaled_width = 1 ; scaled_width < width ; scaled_width<<=1)
  1194.         ;
  1195.     for (scaled_height = 1 ; scaled_height < height ; scaled_height<<=1)
  1196.         ;
  1197.  
  1198.     scaled_width >>= (int)gl_picmip.value;
  1199.     scaled_height >>= (int)gl_picmip.value;
  1200.  
  1201.     if (scaled_width > gl_max_size.value)
  1202.         scaled_width = gl_max_size.value;
  1203.     if (scaled_height > gl_max_size.value)
  1204.         scaled_height = gl_max_size.value;
  1205.  
  1206.     if (scaled_width * scaled_height > sizeof(scaled))
  1207.         Sys_Error ("GL_LoadTexture: too big");
  1208.  
  1209.     samples = 1; // alpha ? gl_alpha_format : gl_solid_format;
  1210.  
  1211.     texels += scaled_width * scaled_height;
  1212.  
  1213.     if (scaled_width == width && scaled_height == height)
  1214.     {
  1215.         if (!mipmap)
  1216.         {
  1217.             glTexImage2D (GL_TEXTURE_2D, 0, GL_COLOR_INDEX8_EXT, scaled_width, scaled_height, 0, GL_COLOR_INDEX , GL_UNSIGNED_BYTE, data);
  1218.             goto done;
  1219.         }
  1220.         memcpy (scaled, data, width*height);
  1221.     }
  1222.     else
  1223.         GL_Resample8BitTexture (data, width, height, scaled, scaled_width, scaled_height);
  1224.  
  1225.     glTexImage2D (GL_TEXTURE_2D, 0, GL_COLOR_INDEX8_EXT, scaled_width, scaled_height, 0, GL_COLOR_INDEX, GL_UNSIGNED_BYTE, scaled);
  1226.     if (mipmap)
  1227.     {
  1228.         int        miplevel;
  1229.  
  1230.         miplevel = 0;
  1231.         while (scaled_width > 1 || scaled_height > 1)
  1232.         {
  1233.             GL_MipMap8Bit ((byte *)scaled, scaled_width, scaled_height);
  1234.             scaled_width >>= 1;
  1235.             scaled_height >>= 1;
  1236.             if (scaled_width < 1)
  1237.                 scaled_width = 1;
  1238.             if (scaled_height < 1)
  1239.                 scaled_height = 1;
  1240.             miplevel++;
  1241.             glTexImage2D (GL_TEXTURE_2D, miplevel, GL_COLOR_INDEX8_EXT, scaled_width, scaled_height, 0, GL_COLOR_INDEX, GL_UNSIGNED_BYTE, scaled);
  1242.         }
  1243.     }
  1244. done: ;
  1245.  
  1246.     if (mipmap)
  1247.     {
  1248.         glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, gl_filter_min);
  1249.         glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, gl_filter_max);
  1250.     }
  1251.     else
  1252.     {
  1253.         glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, gl_filter_max);
  1254.         glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, gl_filter_max);
  1255.     }
  1256. }
  1257.  
  1258. extern qboolean VID_Is8bit();
  1259.  
  1260. /*
  1261. ===============
  1262. GL_Upload8
  1263. ===============
  1264. */
  1265. void GL_Upload8 (byte *data, int width, int height,  qboolean mipmap, qboolean alpha)
  1266. {
  1267. static    unsigned    trans[640*480];        // FIXME, temporary
  1268.     int            i, s;
  1269.     qboolean    noalpha;
  1270.     int            p;
  1271.  
  1272.     s = width*height;
  1273.     // if there are no transparent pixels, make it a 3 component
  1274.     // texture even if it was specified as otherwise
  1275.     if (alpha)
  1276.     {
  1277.         noalpha = true;
  1278.         for (i=0 ; i<s ; i++)
  1279.         {
  1280.             p = data[i];
  1281.             if (p == 255)
  1282.                 noalpha = false;
  1283.             trans[i] = d_8to24table[p];
  1284.         }
  1285.  
  1286.         if (alpha && noalpha)
  1287.             alpha = false;
  1288.     }
  1289.     else
  1290.     {
  1291.         if (s&3)
  1292.             Sys_Error ("GL_Upload8: s&3");
  1293.         for (i=0 ; i<s ; i+=4)
  1294.         {
  1295.             trans[i] = d_8to24table[data[i]];
  1296.             trans[i+1] = d_8to24table[data[i+1]];
  1297.             trans[i+2] = d_8to24table[data[i+2]];
  1298.             trans[i+3] = d_8to24table[data[i+3]];
  1299.         }
  1300.     }
  1301.  
  1302.     if (VID_Is8bit() && !alpha && (data!=scrap_texels[0])) {
  1303.         GL_Upload8_EXT (data, width, height, mipmap, alpha);
  1304.         return;
  1305.     }
  1306.  
  1307.     GL_Upload32 (trans, width, height, mipmap, alpha);
  1308. }
  1309.  
  1310. /*
  1311. ================
  1312. GL_LoadTexture
  1313. ================
  1314. */
  1315. int GL_LoadTexture (char *identifier, int width, int height, byte *data, qboolean mipmap, qboolean alpha)
  1316. {
  1317.     int            i;
  1318.     gltexture_t    *glt;
  1319.  
  1320.     // see if the texture is allready present
  1321.     if (identifier[0])
  1322.     {
  1323.         for (i=0, glt=gltextures ; i<numgltextures ; i++, glt++)
  1324.         {
  1325.             if (!strcmp (identifier, glt->identifier))
  1326.             {
  1327.                 if (width != glt->width || height != glt->height)
  1328.                     Sys_Error ("GL_LoadTexture: cache mismatch");
  1329.                 return gltextures[i].texnum;
  1330.             }
  1331.         }
  1332.     }
  1333.     else
  1334.         glt = &gltextures[numgltextures];
  1335.     numgltextures++;
  1336.  
  1337.     strcpy (glt->identifier, identifier);
  1338.     glt->texnum = texture_extension_number;
  1339.     glt->width = width;
  1340.     glt->height = height;
  1341.     glt->mipmap = mipmap;
  1342.  
  1343.     GL_Bind(texture_extension_number );
  1344.  
  1345.     GL_Upload8 (data, width, height, mipmap, alpha);
  1346.  
  1347.     texture_extension_number++;
  1348.  
  1349.     return texture_extension_number-1;
  1350. }
  1351.  
  1352. /*
  1353. ================
  1354. GL_LoadPicTexture
  1355. ================
  1356. */
  1357. int GL_LoadPicTexture (qpic_t *pic)
  1358. {
  1359.     return GL_LoadTexture ("", pic->width, pic->height, pic->data, false, true);
  1360. }
  1361.  
  1362. /****************************************/
  1363.  
  1364. static GLenum oldtarget = TEXTURE0_SGIS;
  1365.  
  1366. void GL_SelectTexture (GLenum target) 
  1367. {
  1368.     if (!gl_mtexable)
  1369.         return;
  1370. #ifndef __linux__ // no multitexture under Linux yet
  1371.     qglSelectTextureSGIS(target);
  1372. #endif
  1373.     if (target == oldtarget) 
  1374.         return;
  1375.     cnttextures[oldtarget-TEXTURE0_SGIS] = currenttexture;
  1376.     currenttexture = cnttextures[target-TEXTURE0_SGIS];
  1377.     oldtarget = target;
  1378. }
  1379.