gl_draw.c

   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 //#define GL_COLOR_INDEX8_EXT     0x80E5
  27
  28 cvar_t          scr_conalpha = {"scr_conalpha", "1"};
  29
  30 byte            *draw_chars;                            // 8*8 graphic characters
  31 qpic_t          *draw_disc;
  32
  33 rtexture_t      *char_texture;
  34
  35 typedef struct
  36 {
  37         rtexture_t      *tex;
  38 } glpic_t;
  39
  40 rtexture_t      *conbacktex;
  41
  42 //=============================================================================
  43 /* Support Routines */
  44
  45 typedef struct cachepic_s
  46 {
  47         char            name[MAX_QPATH];
  48         qpic_t          pic;
  49         byte            padding[32];    // for appended glpic
  50 } cachepic_t;
  51
  52 #define MAX_CACHED_PICS         128
  53 cachepic_t      menu_cachepics[MAX_CACHED_PICS];
  54 int                     menu_numcachepics;
  55
  56 byte            menuplyr_pixels[4096];
  57
  58 int             pic_texels;
  59 int             pic_count;
  60
  61 qpic_t *Draw_PicFromWad (char *name)
  62 {
  63         qpic_t  *p;
  64         glpic_t *gl;
  65
  66         p = W_GetLumpName (name);
  67         gl = (glpic_t *)p->data;
  68
  69         gl->tex = R_LoadTexture (name, p->width, p->height, p->data, TEXF_ALPHA | TEXF_PRECACHE);
  70         return p;
  71 }
  72
  73
  74 /*
  75 ================
  76 Draw_CachePic
  77 ================
  78 */
  79 qpic_t  *Draw_CachePic (char *path)
  80 {
  81         cachepic_t      *pic;
  82         int                     i;
  83         qpic_t          *dat;
  84         glpic_t         *gl;
  85
  86         for (pic=menu_cachepics, i=0 ; i<menu_numcachepics ; pic++, i++)
  87                 if (!strcmp (path, pic->name))
  88                         return &pic->pic;
  89
  90         if (menu_numcachepics == MAX_CACHED_PICS)
  91                 Sys_Error ("menu_numcachepics == MAX_CACHED_PICS");
  92         menu_numcachepics++;
  93         strcpy (pic->name, path);
  94
  95 //
  96 // load the pic from disk
  97 //
  98         dat = (qpic_t *)COM_LoadMallocFile (path, false);
  99         if (!dat)
 100                 Sys_Error ("Draw_CachePic: failed to load %s", path);
 101         SwapPic (dat);
 102
 103         // HACK HACK HACK --- we need to keep the bytes for
 104         // the translatable player picture just for the menu
 105         // configuration dialog
 106         if (!strcmp (path, "gfx/menuplyr.lmp"))
 107                 memcpy (menuplyr_pixels, dat->data, dat->width*dat->height);
 108
 109         pic->pic.width = dat->width;
 110         pic->pic.height = dat->height;
 111
 112         gl = (glpic_t *)pic->pic.data;
 113         gl->tex = loadtextureimage(path, 0, 0, false, false, true);
 114         if (!gl->tex)
 115                 gl->tex = R_LoadTexture (path, dat->width, dat->height, dat->data, TEXF_ALPHA | TEXF_PRECACHE);
 116
 117         qfree(dat);
 118
 119         return &pic->pic;
 120 }
 121
 122 extern void LoadSky_f(void);
 123
 124 /*
 125 ===============
 126 Draw_Init
 127 ===============
 128 */
 129 void rmain_registercvars();
 130
 131 void gl_draw_start()
 132 {
 133         int             i;
 134
 135         char_texture = loadtextureimage ("conchars", 0, 0, false, false, true);
 136         if (!char_texture)
 137         {
 138                 draw_chars = W_GetLumpName ("conchars");
 139                 for (i=0 ; i<128*128 ; i++)
 140                         if (draw_chars[i] == 0)
 141                                 draw_chars[i] = 255;    // proper transparent color
 142
 143                 // now turn them into textures
 144                 char_texture = R_LoadTexture ("charset", 128, 128, draw_chars, TEXF_ALPHA | TEXF_PRECACHE);
 145         }
 146
 147         conbacktex = loadtextureimage("gfx/conback", 0, 0, false, false, true);
 148
 149         // get the other pics we need
 150         draw_disc = Draw_PicFromWad ("disc");
 151 }
 152
 153 void gl_draw_shutdown()
 154 {
 155 }
 156
 157 void gl_draw_newmap()
 158 {
 159 }
 160
 161 char engineversion[40];
 162 int engineversionx, engineversiony;
 163
 164 extern void R_Textures_Init();
 165 void GL_Draw_Init (void)
 166 {
 167         int i;
 168         Cvar_RegisterVariable (&scr_conalpha);
 169
 170         Cmd_AddCommand ("loadsky", &LoadSky_f);
 171
 172 #if defined(__linux__)
 173         sprintf (engineversion, "DarkPlaces Linux   GL %.2f build %3i", (float) VERSION, buildnumber);
 174 #elif defined(WIN32)
 175         sprintf (engineversion, "DarkPlaces Windows GL %.2f build %3i", (float) VERSION, buildnumber);
 176 #else
 177         sprintf (engineversion, "DarkPlaces Unknown GL %.2f build %3i", (float) VERSION, buildnumber);
 178 #endif
 179         for (i = 0;i < 40 && engineversion[i];i++)
 180                 engineversion[i] += 0x80; // shift to orange
 181         engineversionx = vid.width - strlen(engineversion) * 8 - 8;
 182         engineversiony = vid.height - 8;
 183
 184         R_Textures_Init();
 185         R_RegisterModule("GL_Draw", gl_draw_start, gl_draw_shutdown, gl_draw_newmap);
 186 }
 187
 188 /*
 189 ================
 190 Draw_Character
 191
 192 Draws one 8*8 graphics character with 0 being transparent.
 193 It can be clipped to the top of the screen to allow the console to be
 194 smoothly scrolled off.
 195 ================
 196 */
 197 void Draw_Character (int x, int y, int num)
 198 {
 199         int                             row, col;
 200         float                   frow, fcol, size;
 201
 202         if (num == 32)
 203                 return;         // space
 204
 205         num &= 255;
 206
 207         if (y <= -8)
 208                 return;                 // totally off screen
 209
 210         row = num>>4;
 211         col = num&15;
 212
 213         frow = row*0.0625;
 214         fcol = col*0.0625;
 215         size = 0.0625;
 216
 217         if (!r_render.value)
 218                 return;
 219         glBindTexture(GL_TEXTURE_2D, R_GetTexture(char_texture));
 220         // LordHavoc: NEAREST mode on text if not scaling up
 221         if (glwidth <= (int) vid.width)
 222         {
 223                 glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
 224                 glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
 225         }
 226         else
 227         {
 228                 glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
 229                 glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
 230         }
 231
 232         if (lighthalf)
 233                 glColor3f(0.5f,0.5f,0.5f);
 234         else
 235                 glColor3f(1.0f,1.0f,1.0f);
 236         glBegin (GL_QUADS);
 237         glTexCoord2f (fcol, frow);
 238         glVertex2f (x, y);
 239         glTexCoord2f (fcol + size, frow);
 240         glVertex2f (x+8, y);
 241         glTexCoord2f (fcol + size, frow + size);
 242         glVertex2f (x+8, y+8);
 243         glTexCoord2f (fcol, frow + size);
 244         glVertex2f (x, y+8);
 245         glEnd ();
 246
 247         // LordHavoc: revert to LINEAR mode
 248 //      if (glwidth < (int) vid.width)
 249 //      {
 250 //              glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
 251 //              glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
 252 //      }
 253 }
 254
 255 /*
 256 ================
 257 Draw_String
 258 ================
 259 */
 260 // LordHavoc: sped this up a lot, and added maxlen
 261 void Draw_String (int x, int y, char *str, int maxlen)
 262 {
 263         int num;
 264         float frow, fcol;
 265         if (!r_render.value)
 266                 return;
 267         if (y <= -8 || y >= (int) vid.height || x >= (int) vid.width || *str == 0) // completely offscreen or no text to print
 268                 return;
 269         if (maxlen < 1)
 270                 maxlen = strlen(str);
 271         else if (maxlen > (int) strlen(str))
 272                 maxlen = strlen(str);
 273         glBindTexture(GL_TEXTURE_2D, R_GetTexture(char_texture));
 274
 275         // LordHavoc: NEAREST mode on text if not scaling up
 276         if (glwidth <= (int) vid.width)
 277         {
 278                 glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
 279                 glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
 280         }
 281         else
 282         {
 283                 glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
 284                 glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
 285         }
 286
 287         if (lighthalf)
 288                 glColor3f(0.5f,0.5f,0.5f);
 289         else
 290                 glColor3f(1.0f,1.0f,1.0f);
 291         glBegin (GL_QUADS);
 292         while (maxlen-- && x < (int) vid.width) // stop rendering when out of characters or room
 293         {
 294                 if ((num = *str++) != 32) // skip spaces
 295                 {
 296                         frow = (float) ((int) num >> 4)*0.0625;
 297                         fcol = (float) ((int) num & 15)*0.0625;
 298                         glTexCoord2f (fcol         , frow         );glVertex2f (x, y);
 299                         glTexCoord2f (fcol + 0.0625, frow         );glVertex2f (x+8, y);
 300                         glTexCoord2f (fcol + 0.0625, frow + 0.0625);glVertex2f (x+8, y+8);
 301                         glTexCoord2f (fcol         , frow + 0.0625);glVertex2f (x, y+8);
 302                 }
 303                 x += 8;
 304         }
 305         glEnd ();
 306
 307         // LordHavoc: revert to LINEAR mode
 308 //      if (glwidth < (int) vid.width)
 309 //      {
 310 //              glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
 311 //              glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
 312 //      }
 313 }
 314
 315 void Draw_GenericPic (rtexture_t *tex, float red, float green, float blue, float alpha, int x, int y, int width, int height)
 316 {
 317         if (!r_render.value)
 318                 return;
 319         if (lighthalf)
 320                 glColor4f(red * 0.5f, green * 0.5f, blue * 0.5f, alpha);
 321         else
 322                 glColor4f(red, green, blue, alpha);
 323         glBindTexture(GL_TEXTURE_2D, R_GetTexture(tex));
 324         glBegin (GL_QUADS);
 325         glTexCoord2f (0, 0);glVertex2f (x, y);
 326         glTexCoord2f (1, 0);glVertex2f (x+width, y);
 327         glTexCoord2f (1, 1);glVertex2f (x+width, y+height);
 328         glTexCoord2f (0, 1);glVertex2f (x, y+height);
 329         glEnd ();
 330 }
 331
 332 /*
 333 =============
 334 Draw_AlphaPic
 335 =============
 336 */
 337 void Draw_AlphaPic (int x, int y, qpic_t *pic, float alpha)
 338 {
 339         Draw_GenericPic(((glpic_t *)pic->data)->tex, 1,1,1,alpha, x,y,pic->width, pic->height);
 340 }
 341
 342
 343 /*
 344 =============
 345 Draw_Pic
 346 =============
 347 */
 348 void Draw_Pic (int x, int y, qpic_t *pic)
 349 {
 350         Draw_GenericPic(((glpic_t *)pic->data)->tex, 1,1,1,1, x,y,pic->width, pic->height);
 351 }
 352
 353
 354 /*
 355 =============
 356 Draw_PicTranslate
 357
 358 Only used for the player color selection menu
 359 =============
 360 */
 361 void Draw_PicTranslate (int x, int y, qpic_t *pic, byte *translation)
 362 {
 363         int                             i, c;
 364         byte                    *trans, *src, *dest;
 365         rtexture_t              *rt;
 366
 367         c = pic->width * pic->height;
 368         src = menuplyr_pixels;
 369         dest = trans = qmalloc(c);
 370         for (i = 0;i < c;i++)
 371                 *dest++ = translation[*src++];
 372
 373         rt = R_LoadTexture ("translatedplayerpic", pic->width, pic->height, trans, TEXF_ALPHA | TEXF_PRECACHE);
 374         qfree(trans);
 375
 376         if (!r_render.value)
 377                 return;
 378         Draw_GenericPic (rt, 1,1,1,1, x, y, pic->width, pic->height);
 379 }
 380
 381
 382 /*
 383 ================
 384 Draw_ConsoleBackground
 385
 386 ================
 387 */
 388 void Draw_ConsoleBackground (int lines)
 389 {
 390         Draw_GenericPic (conbacktex, 1,1,1,scr_conalpha.value*lines/vid.height, 0, lines - vid.height, vid.width, vid.height);
 391         // LordHavoc: draw version
 392         Draw_String(engineversionx, lines - vid.height + engineversiony, engineversion, 9999);
 393 }
 394
 395 /*
 396 =============
 397 Draw_Fill
 398
 399 Fills a box of pixels with a single color
 400 =============
 401 */
 402 void Draw_Fill (int x, int y, int w, int h, int c)
 403 {
 404         if (!r_render.value)
 405                 return;
 406         glDisable (GL_TEXTURE_2D);
 407         if (lighthalf)
 408         {
 409                 byte *tempcolor = (byte *)&d_8to24table[c];
 410                 glColor4ub ((byte) (tempcolor[0] >> 1), (byte) (tempcolor[1] >> 1), (byte) (tempcolor[2] >> 1), tempcolor[3]);
 411         }
 412         else
 413                 glColor4ubv ((byte *)&d_8to24table[c]);
 414
 415         glBegin (GL_QUADS);
 416
 417         glVertex2f (x,y);
 418         glVertex2f (x+w, y);
 419         glVertex2f (x+w, y+h);
 420         glVertex2f (x, y+h);
 421
 422         glEnd ();
 423         glColor3f(1,1,1);
 424         glEnable (GL_TEXTURE_2D);
 425 }
 426 //=============================================================================
 427
 428 //=============================================================================
 429
 430 /*
 431 ================
 432 GL_Set2D
 433
 434 Setup as if the screen was 320*200
 435 ================
 436 */
 437 void GL_Set2D (void)
 438 {
 439         if (!r_render.value)
 440                 return;
 441         glViewport (glx, gly, glwidth, glheight);
 442
 443         glMatrixMode(GL_PROJECTION);
 444     glLoadIdentity ();
 445         glOrtho  (0, vid.width, vid.height, 0, -99999, 99999);
 446
 447         glMatrixMode(GL_MODELVIEW);
 448     glLoadIdentity ();
 449
 450         glDisable (GL_DEPTH_TEST);
 451         glDisable (GL_CULL_FACE);
 452         glEnable (GL_BLEND);
 453         glDisable (GL_ALPHA_TEST);
 454         glEnable(GL_TEXTURE_2D);
 455
 456         // LordHavoc: added this
 457         glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 458         glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
 459
 460         glColor3f(1,1,1);
 461 }
 462
 463 // LordHavoc: SHOWLMP stuff
 464 #define SHOWLMP_MAXLABELS 256
 465 typedef struct showlmp_s
 466 {
 467         qboolean        isactive;
 468         float           x;
 469         float           y;
 470         char            label[32];
 471         char            pic[128];
 472 } showlmp_t;
 473
 474 showlmp_t showlmp[SHOWLMP_MAXLABELS];
 475
 476 void SHOWLMP_decodehide()
 477 {
 478         int i;
 479         byte *lmplabel;
 480         lmplabel = MSG_ReadString();
 481         for (i = 0;i < SHOWLMP_MAXLABELS;i++)
 482                 if (showlmp[i].isactive && strcmp(showlmp[i].label, lmplabel) == 0)
 483                 {
 484                         showlmp[i].isactive = false;
 485                         return;
 486                 }
 487 }
 488
 489 void SHOWLMP_decodeshow()
 490 {
 491         int i, k;
 492         byte lmplabel[256], picname[256];
 493         float x, y;
 494         strcpy(lmplabel,MSG_ReadString());
 495         strcpy(picname, MSG_ReadString());
 496         if (nehahra) // LordHavoc: nasty old legacy junk
 497         {
 498                 x = MSG_ReadByte();
 499                 y = MSG_ReadByte();
 500         }
 501         else
 502         {
 503                 x = MSG_ReadShort();
 504                 y = MSG_ReadShort();
 505         }
 506         k = -1;
 507         for (i = 0;i < SHOWLMP_MAXLABELS;i++)
 508                 if (showlmp[i].isactive)
 509                 {
 510                         if (strcmp(showlmp[i].label, lmplabel) == 0)
 511                         {
 512                                 k = i;
 513                                 break; // drop out to replace it
 514                         }
 515                 }
 516                 else if (k < 0) // find first empty one to replace
 517                         k = i;
 518         if (k < 0)
 519                 return; // none found to replace
 520         // change existing one
 521         showlmp[k].isactive = true;
 522         strcpy(showlmp[k].label, lmplabel);
 523         strcpy(showlmp[k].pic, picname);
 524         showlmp[k].x = x;
 525         showlmp[k].y = y;
 526 }
 527
 528 void SHOWLMP_drawall()
 529 {
 530         int i;
 531         for (i = 0;i < SHOWLMP_MAXLABELS;i++)
 532                 if (showlmp[i].isactive)
 533                         Draw_Pic(showlmp[i].x, showlmp[i].y, Draw_CachePic(showlmp[i].pic));
 534 }
 535
 536 void SHOWLMP_clear()
 537 {
 538         int i;
 539         for (i = 0;i < SHOWLMP_MAXLABELS;i++)
 540                 showlmp[i].isactive = false;
 541 }