Return to gl_draw.c CVS log

Up to [Quake] / quakeworld / client

Annotation of quakeworld/client/gl_draw.c, revision 1.1

1.1     ! root        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: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.