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 #include "quakedef.h"
  22 #include "image.h"
  23 #include "wad.h"
  24
  25 #include "cl_video.h"
  26 #include "cl_dyntexture.h"
  27
  28 #include "ft2.h"
  29 #include "ft2_fontdefs.h"
  30
  31 dp_font_t dp_fonts[MAX_FONTS] = {{0}};
  32
  33 cvar_t r_textshadow = {CVAR_SAVE, "r_textshadow", "0", "draws a shadow on all text to improve readability (note: value controls offset, 1 = 1 pixel, 1.5 = 1.5 pixels, etc)"};
  34 cvar_t r_textbrightness = {CVAR_SAVE, "r_textbrightness", "0", "additional brightness for text color codes (0 keeps colors as is, 1 makes them all white)"};
  35 cvar_t r_textcontrast = {CVAR_SAVE, "r_textcontrast", "1", "additional contrast for text color codes (1 keeps colors as is, 0 makes them all black)"};
  36
  37 extern cvar_t v_glslgamma;
  38
  39 //=============================================================================
  40 /* Support Routines */
  41
  42 #define FONT_FILESIZE 13468
  43 static cachepic_t *cachepichash[CACHEPICHASHSIZE];
  44 static cachepic_t cachepics[MAX_CACHED_PICS];
  45 static int numcachepics;
  46
  47 static rtexturepool_t *drawtexturepool;
  48
  49 static const unsigned char concharimage[FONT_FILESIZE] =
  50 {
  51 #include "lhfont.h"
  52 };
  53
  54 static rtexture_t *draw_generateconchars(void)
  55 {
  56         int i;
  57         unsigned char *data;
  58         double random;
  59         rtexture_t *tex;
  60
  61         data = LoadTGA_BGRA (concharimage, FONT_FILESIZE);
  62 // Gold numbers
  63         for (i = 0;i < 8192;i++)
  64         {
  65                 random = lhrandom (0.0,1.0);
  66                 data[i*4+3] = data[i*4+0];
  67                 data[i*4+2] = 83 + (unsigned char)(random * 64);
  68                 data[i*4+1] = 71 + (unsigned char)(random * 32);
  69                 data[i*4+0] = 23 + (unsigned char)(random * 16);
  70         }
  71 // White chars
  72         for (i = 8192;i < 32768;i++)
  73         {
  74                 random = lhrandom (0.0,1.0);
  75                 data[i*4+3] = data[i*4+0];
  76                 data[i*4+2] = 95 + (unsigned char)(random * 64);
  77                 data[i*4+1] = 95 + (unsigned char)(random * 64);
  78                 data[i*4+0] = 95 + (unsigned char)(random * 64);
  79         }
  80 // Gold numbers
  81         for (i = 32768;i < 40960;i++)
  82         {
  83                 random = lhrandom (0.0,1.0);
  84                 data[i*4+3] = data[i*4+0];
  85                 data[i*4+2] = 83 + (unsigned char)(random * 64);
  86                 data[i*4+1] = 71 + (unsigned char)(random * 32);
  87                 data[i*4+0] = 23 + (unsigned char)(random * 16);
  88         }
  89 // Red chars
  90         for (i = 40960;i < 65536;i++)
  91         {
  92                 random = lhrandom (0.0,1.0);
  93                 data[i*4+3] = data[i*4+0];
  94                 data[i*4+2] = 96 + (unsigned char)(random * 64);
  95                 data[i*4+1] = 43 + (unsigned char)(random * 32);
  96                 data[i*4+0] = 27 + (unsigned char)(random * 32);
  97         }
  98
  99 #if 0
 100         Image_WriteTGABGRA ("gfx/generated_conchars.tga", 256, 256, data);
 101 #endif
 102
 103         tex = R_LoadTexture2D(drawtexturepool, "conchars", 256, 256, data, TEXTYPE_BGRA, TEXF_ALPHA, NULL);
 104         Mem_Free(data);
 105         return tex;
 106 }
 107
 108 static rtexture_t *draw_generateditherpattern(void)
 109 {
 110         int x, y;
 111         unsigned char pixels[8][8];
 112         for (y = 0;y < 8;y++)
 113                 for (x = 0;x < 8;x++)
 114                         pixels[y][x] = ((x^y) & 4) ? 254 : 0;
 115         return R_LoadTexture2D(drawtexturepool, "ditherpattern", 8, 8, pixels[0], TEXTYPE_PALETTE, TEXF_FORCENEAREST, palette_bgra_transparent);
 116 }
 117
 118 typedef struct embeddedpic_s
 119 {
 120         const char *name;
 121         int width;
 122         int height;
 123         const char *pixels;
 124 }
 125 embeddedpic_t;
 126
 127 static const embeddedpic_t embeddedpics[] =
 128 {
 129         {
 130         "gfx/prydoncursor001", 16, 16,
 131         "477777774......."
 132         "77.....6........"
 133         "7.....6........."
 134         "7....6.........."
 135         "7.....6........."
 136         "7..6...6........"
 137         "7.6.6...6......."
 138         "76...6...6......"
 139         "4.....6.6......."
 140         ".......6........"
 141         "................"
 142         "................"
 143         "................"
 144         "................"
 145         "................"
 146         "................"
 147         },
 148         {
 149         "ui/mousepointer", 16, 16,
 150         "477777774......."
 151         "77.....6........"
 152         "7.....6........."
 153         "7....6.........."
 154         "7.....6........."
 155         "7..6...6........"
 156         "7.6.6...6......."
 157         "76...6...6......"
 158         "4.....6.6......."
 159         ".......6........"
 160         "................"
 161         "................"
 162         "................"
 163         "................"
 164         "................"
 165         "................"
 166         },
 167         {
 168         "gfx/crosshair1", 16, 16,
 169         "................"
 170         "................"
 171         "................"
 172         "...33......33..."
 173         "...355....553..."
 174         "....577..775...."
 175         ".....77..77....."
 176         "................"
 177         "................"
 178         ".....77..77....."
 179         "....577..775...."
 180         "...355....553..."
 181         "...33......33..."
 182         "................"
 183         "................"
 184         "................"
 185         },
 186         {
 187         "gfx/crosshair2", 16, 16,
 188         "................"
 189         "................"
 190         "................"
 191         "...3........3..."
 192         "....5......5...."
 193         ".....7....7....."
 194         "......7..7......"
 195         "................"
 196         "................"
 197         "......7..7......"
 198         ".....7....7....."
 199         "....5......5...."
 200         "...3........3..."
 201         "................"
 202         "................"
 203         "................"
 204         },
 205         {
 206         "gfx/crosshair3", 16, 16,
 207         "................"
 208         ".......77......."
 209         ".......77......."
 210         "................"
 211         "................"
 212         ".......44......."
 213         ".......44......."
 214         ".77..44..44..77."
 215         ".77..44..44..77."
 216         ".......44......."
 217         ".......44......."
 218         "................"
 219         "................"
 220         ".......77......."
 221         ".......77......."
 222         "................"
 223         },
 224         {
 225         "gfx/crosshair4", 16, 16,
 226         "................"
 227         "................"
 228         "................"
 229         "................"
 230         "................"
 231         "................"
 232         "................"
 233         "................"
 234         "........7777777."
 235         "........752....."
 236         "........72......"
 237         "........7......."
 238         "........7......."
 239         "........7......."
 240         "........7......."
 241         "................"
 242         },
 243         {
 244         "gfx/crosshair5", 8, 8,
 245         "........"
 246         "........"
 247         "....7..."
 248         "........"
 249         "..7.7.7."
 250         "........"
 251         "....7..."
 252         "........"
 253         },
 254         {
 255         "gfx/crosshair6", 2, 2,
 256         "77"
 257         "77"
 258         },
 259         {
 260         "gfx/crosshair7", 16, 16,
 261         "................"
 262         ".3............3."
 263         "..5...2332...5.."
 264         "...7.3....3.7..."
 265         "....7......7...."
 266         "...3.7....7.3..."
 267         "..2...7..7...2.."
 268         "..3..........3.."
 269         "..3..........3.."
 270         "..2...7..7...2.."
 271         "...3.7....7.3..."
 272         "....7......7...."
 273         "...7.3....3.7..."
 274         "..5...2332...5.."
 275         ".3............3."
 276         "................"
 277         },
 278         {NULL, 0, 0, NULL}
 279 };
 280
 281 static rtexture_t *draw_generatepic(const char *name, qboolean quiet)
 282 {
 283         const embeddedpic_t *p;
 284         for (p = embeddedpics;p->name;p++)
 285                 if (!strcmp(name, p->name))
 286                         return R_LoadTexture2D(drawtexturepool, p->name, p->width, p->height, (const unsigned char *)p->pixels, TEXTYPE_PALETTE, TEXF_ALPHA, palette_bgra_embeddedpic);
 287         if (!strcmp(name, "gfx/conchars"))
 288                 return draw_generateconchars();
 289         if (!strcmp(name, "gfx/colorcontrol/ditherpattern"))
 290                 return draw_generateditherpattern();
 291         if (!quiet)
 292                 Con_DPrintf("Draw_CachePic: failed to load %s\n", name);
 293         return r_texture_notexture;
 294 }
 295
 296
 297 /*
 298 ================
 299 Draw_CachePic
 300 ================
 301 */
 302 // FIXME: move this to client somehow
 303 cachepic_t *Draw_CachePic_Flags(const char *path, unsigned int cachepicflags)
 304 {
 305         int crc, hashkey;
 306         unsigned char *pixels;
 307         cachepic_t *pic;
 308         fs_offset_t lmpsize;
 309         unsigned char *lmpdata;
 310         char lmpname[MAX_QPATH];
 311
 312         // check whether the picture has already been cached
 313         crc = CRC_Block((unsigned char *)path, strlen(path));
 314         hashkey = ((crc >> 8) ^ crc) % CACHEPICHASHSIZE;
 315         for (pic = cachepichash[hashkey];pic;pic = pic->chain)
 316                 if (!strcmp (path, pic->name))
 317                         return pic;
 318
 319         if (numcachepics == MAX_CACHED_PICS)
 320         {
 321                 Con_Printf ("Draw_CachePic: numcachepics == MAX_CACHED_PICS\n");
 322                 // FIXME: support NULL in callers?
 323                 return cachepics; // return the first one
 324         }
 325         pic = cachepics + (numcachepics++);
 326         strlcpy (pic->name, path, sizeof(pic->name));
 327         // link into list
 328         pic->chain = cachepichash[hashkey];
 329         cachepichash[hashkey] = pic;
 330
 331         // check whether it is an dynamic texture (if so, we can directly use its texture handler)
 332         pic->tex = CL_GetDynTexture( path );
 333         // if so, set the width/height, too
 334         if( pic->tex ) {
 335                 pic->width = R_TextureWidth(pic->tex);
 336                 pic->height = R_TextureHeight(pic->tex);
 337                 // we're done now (early-out)
 338                 return pic;
 339         }
 340
 341         pic->texflags = TEXF_ALPHA;
 342         if (!(cachepicflags & CACHEPICFLAG_NOCLAMP))
 343                 pic->texflags |= TEXF_CLAMP;
 344         if (!(cachepicflags & CACHEPICFLAG_NOCOMPRESSION) && gl_texturecompression_2d.integer)
 345                 pic->texflags |= TEXF_COMPRESS;
 346
 347         pic->autoload = (cachepicflags & CACHEPICFLAG_NOTPERSISTENT);
 348
 349         // load a high quality image from disk if possible
 350         pixels = loadimagepixelsbgra(path, false, true);
 351         if (pixels == NULL && !strncmp(path, "gfx/", 4))
 352                 pixels = loadimagepixelsbgra(path+4, false, true);
 353         if (pixels)
 354         {
 355                 pic->width = image_width;
 356                 pic->height = image_height;
 357                 if (!pic->autoload)
 358                         pic->tex = R_LoadTexture2D(drawtexturepool, path, image_width, image_height, pixels, TEXTYPE_BGRA, pic->texflags, NULL);
 359         }
 360         else
 361         {
 362                 pic->autoload = false;
 363                 // never compress the fallback images
 364                 pic->texflags &= ~TEXF_COMPRESS;
 365         }
 366
 367         // now read the low quality version (wad or lmp file), and take the pic
 368         // size from that even if we don't upload the texture, this way the pics
 369         // show up the right size in the menu even if they were replaced with
 370         // higher or lower resolution versions
 371         dpsnprintf(lmpname, sizeof(lmpname), "%s.lmp", path);
 372         if (!strncmp(path, "gfx/", 4) && (lmpdata = FS_LoadFile(lmpname, tempmempool, false, &lmpsize)))
 373         {
 374                 if (developer_loading.integer)
 375                         Con_Printf("loading lump \"%s\"\n", path);
 376
 377                 if (lmpsize >= 9)
 378                 {
 379                         pic->width = lmpdata[0] + lmpdata[1] * 256 + lmpdata[2] * 65536 + lmpdata[3] * 16777216;
 380                         pic->height = lmpdata[4] + lmpdata[5] * 256 + lmpdata[6] * 65536 + lmpdata[7] * 16777216;
 381                         // if no high quality replacement image was found, upload the original low quality texture
 382                         if (!pixels)
 383                                 pic->tex = R_LoadTexture2D(drawtexturepool, path, pic->width, pic->height, lmpdata + 8, TEXTYPE_PALETTE, pic->texflags, palette_bgra_transparent);
 384                 }
 385                 Mem_Free(lmpdata);
 386         }
 387         else if ((lmpdata = W_GetLumpName (path + 4)))
 388         {
 389                 if (developer_loading.integer)
 390                         Con_Printf("loading gfx.wad lump \"%s\"\n", path + 4);
 391
 392                 if (!strcmp(path, "gfx/conchars"))
 393                 {
 394                         // conchars is a raw image and with color 0 as transparent instead of 255
 395                         pic->width = 128;
 396                         pic->height = 128;
 397                         // if no high quality replacement image was found, upload the original low quality texture
 398                         if (!pixels)
 399                                 pic->tex = R_LoadTexture2D(drawtexturepool, path, 128, 128, lmpdata, TEXTYPE_PALETTE, pic->texflags, palette_bgra_font);
 400                 }
 401                 else
 402                 {
 403                         pic->width = lmpdata[0] + lmpdata[1] * 256 + lmpdata[2] * 65536 + lmpdata[3] * 16777216;
 404                         pic->height = lmpdata[4] + lmpdata[5] * 256 + lmpdata[6] * 65536 + lmpdata[7] * 16777216;
 405                         // if no high quality replacement image was found, upload the original low quality texture
 406                         if (!pixels)
 407                                 pic->tex = R_LoadTexture2D(drawtexturepool, path, pic->width, pic->height, lmpdata + 8, TEXTYPE_PALETTE, pic->texflags, palette_bgra_transparent);
 408                 }
 409         }
 410
 411         if (pixels)
 412         {
 413                 Mem_Free(pixels);
 414                 pixels = NULL;
 415         }
 416         else if (pic->tex == NULL)
 417         {
 418                 // if it's not found on disk, generate an image
 419                 pic->tex = draw_generatepic(path, (cachepicflags & CACHEPICFLAG_QUIET) != 0);
 420                 pic->width = R_TextureWidth(pic->tex);
 421                 pic->height = R_TextureHeight(pic->tex);
 422         }
 423
 424         return pic;
 425 }
 426
 427 cachepic_t *Draw_CachePic (const char *path)
 428 {
 429         return Draw_CachePic_Flags (path, 0);
 430 }
 431
 432 int draw_frame = 1;
 433
 434 rtexture_t *Draw_GetPicTexture(cachepic_t *pic)
 435 {
 436         if (pic->autoload && !pic->tex)
 437         {
 438                 pic->tex = loadtextureimage(drawtexturepool, pic->name, false, pic->texflags, true);
 439                 if (pic->tex == NULL && !strncmp(pic->name, "gfx/", 4))
 440                         pic->tex = loadtextureimage(drawtexturepool, pic->name+4, false, pic->texflags, true);
 441                 if (pic->tex == NULL)
 442                         pic->tex = draw_generatepic(pic->name, true);
 443         }
 444         pic->lastusedframe = draw_frame;
 445         return pic->tex;
 446 }
 447
 448 void Draw_Frame(void)
 449 {
 450         int i;
 451         cachepic_t *pic;
 452         static double nextpurgetime;
 453         int purgeframe;
 454         if (nextpurgetime > realtime)
 455                 return;
 456         nextpurgetime = realtime + 0.05;
 457         purgeframe = draw_frame - 1;
 458         for (i = 0, pic = cachepics;i < numcachepics;i++, pic++)
 459         {
 460                 if (pic->autoload && pic->tex && pic->lastusedframe < draw_frame)
 461                 {
 462                         R_FreeTexture(pic->tex);
 463                         pic->tex = NULL;
 464                 }
 465         }
 466         draw_frame++;
 467 }
 468
 469 cachepic_t *Draw_NewPic(const char *picname, int width, int height, int alpha, unsigned char *pixels_bgra)
 470 {
 471         int crc, hashkey;
 472         cachepic_t *pic;
 473
 474         crc = CRC_Block((unsigned char *)picname, strlen(picname));
 475         hashkey = ((crc >> 8) ^ crc) % CACHEPICHASHSIZE;
 476         for (pic = cachepichash[hashkey];pic;pic = pic->chain)
 477                 if (!strcmp (picname, pic->name))
 478                         break;
 479
 480         if (pic)
 481         {
 482                 if (pic->tex && pic->width == width && pic->height == height)
 483                 {
 484                         R_UpdateTexture(pic->tex, pixels_bgra, 0, 0, width, height);
 485                         return pic;
 486                 }
 487         }
 488         else
 489         {
 490                 if (pic == NULL)
 491                 {
 492                         if (numcachepics == MAX_CACHED_PICS)
 493                         {
 494                                 Con_Printf ("Draw_NewPic: numcachepics == MAX_CACHED_PICS\n");
 495                                 // FIXME: support NULL in callers?
 496                                 return cachepics; // return the first one
 497                         }
 498                         pic = cachepics + (numcachepics++);
 499                         strlcpy (pic->name, picname, sizeof(pic->name));
 500                         // link into list
 501                         pic->chain = cachepichash[hashkey];
 502                         cachepichash[hashkey] = pic;
 503                 }
 504         }
 505
 506         pic->width = width;
 507         pic->height = height;
 508         if (pic->tex)
 509                 R_FreeTexture(pic->tex);
 510         pic->tex = R_LoadTexture2D(drawtexturepool, picname, width, height, pixels_bgra, TEXTYPE_BGRA, (alpha ? TEXF_ALPHA : 0) | TEXF_ALLOWUPDATES, NULL);
 511         return pic;
 512 }
 513
 514 void Draw_FreePic(const char *picname)
 515 {
 516         int crc;
 517         int hashkey;
 518         cachepic_t *pic;
 519         // this doesn't really free the pic, but does free it's texture
 520         crc = CRC_Block((unsigned char *)picname, strlen(picname));
 521         hashkey = ((crc >> 8) ^ crc) % CACHEPICHASHSIZE;
 522         for (pic = cachepichash[hashkey];pic;pic = pic->chain)
 523         {
 524                 if (!strcmp (picname, pic->name) && pic->tex)
 525                 {
 526                         R_FreeTexture(pic->tex);
 527                         pic->tex = NULL;
 528                         pic->width = 0;
 529                         pic->height = 0;
 530                         return;
 531                 }
 532         }
 533 }
 534
 535 static float snap_to_pixel_x(float x, float roundUpAt);
 536 extern int con_linewidth; // to force rewrapping
 537 static void LoadFont(qboolean override, const char *name, dp_font_t *fnt)
 538 {
 539         int i;
 540         float maxwidth, scale;
 541         char widthfile[MAX_QPATH];
 542         char *widthbuf;
 543         fs_offset_t widthbufsize;
 544
 545         if(override || !fnt->texpath[0])
 546                 strlcpy(fnt->texpath, name, sizeof(fnt->texpath));
 547
 548         if(drawtexturepool == NULL)
 549                 return; // before gl_draw_start, so will be loaded later
 550
 551         if(fnt->ft2)
 552         {
 553                 // clear freetype font
 554                 Font_UnloadFont(fnt->ft2);
 555                 Mem_Free(fnt->ft2);
 556                 fnt->ft2 = NULL;
 557         }
 558
 559         if(fnt->req_face != -1)
 560         {
 561                 if(!Font_LoadFont(fnt->texpath, fnt))
 562                         Con_DPrintf("Failed to load font-file for '%s', it will not support as many characters.\n", fnt->texpath);
 563         }
 564
 565         fnt->tex = Draw_CachePic_Flags(fnt->texpath, CACHEPICFLAG_QUIET | CACHEPICFLAG_NOCOMPRESSION)->tex;
 566         if(fnt->tex == r_texture_notexture)
 567         {
 568                 for (i = 0; i < MAX_FONT_FALLBACKS; ++i)
 569                 {
 570                         if (!fnt->fallbacks[i][0])
 571                                 break;
 572                         fnt->tex = Draw_CachePic_Flags(fnt->fallbacks[i], CACHEPICFLAG_QUIET | CACHEPICFLAG_NOCOMPRESSION)->tex;
 573                         if(fnt->tex != r_texture_notexture)
 574                                 break;
 575                 }
 576                 if(fnt->tex == r_texture_notexture)
 577                 {
 578                         fnt->tex = Draw_CachePic_Flags("gfx/conchars", CACHEPICFLAG_NOCOMPRESSION)->tex;
 579                         strlcpy(widthfile, "gfx/conchars.width", sizeof(widthfile));
 580                 }
 581                 else
 582                         dpsnprintf(widthfile, sizeof(widthfile), "%s.width", fnt->fallbacks[i]);
 583         }
 584         else
 585                 dpsnprintf(widthfile, sizeof(widthfile), "%s.width", fnt->texpath);
 586
 587         // unspecified width == 1 (base width)
 588         for(i = 1; i < 256; ++i)
 589                 fnt->width_of[i] = 1;
 590         scale = 1;
 591
 592         // FIXME load "name.width", if it fails, fill all with 1
 593         if((widthbuf = (char *) FS_LoadFile(widthfile, tempmempool, true, &widthbufsize)))
 594         {
 595                 float extraspacing = 0;
 596                 const char *p = widthbuf;
 597                 int ch = 0;
 598
 599                 while(ch < 256)
 600                 {
 601                         if(!COM_ParseToken_Simple(&p, false, false))
 602                                 return;
 603
 604                         switch(*com_token)
 605                         {
 606                                 case '0':
 607                                 case '1':
 608                                 case '2':
 609                                 case '3':
 610                                 case '4':
 611                                 case '5':
 612                                 case '6':
 613                                 case '7':
 614                                 case '8':
 615                                 case '9':
 616                                 case '+':
 617                                 case '-':
 618                                 case '.':
 619                                         fnt->width_of[ch] = atof(com_token) + extraspacing;
 620                                         if (fnt->ft2)
 621                                         {
 622                                                 for (i = 0; i < MAX_FONT_SIZES; ++i)
 623                                                 {
 624                                                         //Font_MapForIndex(fnt->ft2, i)->width_of[ch] = snap_to_pixel_x(fnt->width_of[ch] * fnt->req_sizes[i], 0.4);
 625                                                         ft2_font_map_t *map = Font_MapForIndex(fnt->ft2, i);
 626                                                         if (!map)
 627                                                                 break;
 628                                                         map->width_of[ch] = Font_SnapTo(fnt->width_of[ch], 1/map->size);
 629                                                 }
 630                                         }
 631                                         ch++;
 632                                         break;
 633                                 default:
 634                                         if(!strcmp(com_token, "extraspacing"))
 635                                         {
 636                                                 if(!COM_ParseToken_Simple(&p, false, false))
 637                                                         return;
 638                                                 extraspacing = atof(com_token);
 639                                         }
 640                                         else if(!strcmp(com_token, "scale"))
 641                                         {
 642                                                 if(!COM_ParseToken_Simple(&p, false, false))
 643                                                         return;
 644                                                 scale = atof(com_token);
 645                                         }
 646                                         else
 647                                         {
 648                                                 Con_Printf("Warning: skipped unknown font property %s\n", com_token);
 649                                                 if(!COM_ParseToken_Simple(&p, false, false))
 650                                                         return;
 651                                         }
 652                                         break;
 653                         }
 654                 }
 655
 656                 Mem_Free(widthbuf);
 657         }
 658
 659         maxwidth = fnt->width_of[1];
 660         for(i = 2; i < 256; ++i)
 661                 maxwidth = max(maxwidth, fnt->width_of[i]);
 662         fnt->maxwidth = maxwidth;
 663
 664         // fix up maxwidth for overlap
 665         fnt->maxwidth *= scale;
 666         fnt->scale = scale;
 667
 668         if(fnt == FONT_CONSOLE)
 669                 con_linewidth = -1; // rewrap console in next frame
 670 }
 671
 672 static dp_font_t *FindFont(const char *title)
 673 {
 674         int i;
 675         for(i = 0; i < MAX_FONTS; ++i)
 676                 if(!strcmp(dp_fonts[i].title, title))
 677                         return &dp_fonts[i];
 678         return NULL;
 679 }
 680
 681 static float snap_to_pixel_x(float x, float roundUpAt)
 682 {
 683         float pixelpos = x * vid.width / vid_conwidth.value;
 684         int snap = (int) pixelpos;
 685         if (pixelpos - snap >= roundUpAt) ++snap;
 686         return ((float)snap * vid_conwidth.value / vid.width);
 687         /*
 688         x = (int)(x * vid.width / vid_conwidth.value);
 689         x = (x * vid_conwidth.value / vid.width);
 690         return x;
 691         */
 692 }
 693
 694 static float snap_to_pixel_y(float y, float roundUpAt)
 695 {
 696         float pixelpos = y * vid.height / vid_conheight.value;
 697         int snap = (int) pixelpos;
 698         if (pixelpos - snap > roundUpAt) ++snap;
 699         return ((float)snap * vid_conheight.value / vid.height);
 700         /*
 701         y = (int)(y * vid.height / vid_conheight.value);
 702         y = (y * vid_conheight.value / vid.height);
 703         return y;
 704         */
 705 }
 706
 707 static void LoadFont_f(void)
 708 {
 709         dp_font_t *f;
 710         int i;
 711         const char *filelist, *c, *cm;
 712         float sz;
 713         char mainfont[MAX_QPATH];
 714
 715         if(Cmd_Argc() < 2)
 716         {
 717                 Con_Printf("Available font commands:\n");
 718                 for(i = 0; i < MAX_FONTS; ++i)
 719                         Con_Printf("  loadfont %s gfx/tgafile[...] [sizes...]\n", dp_fonts[i].title);
 720                 Con_Printf("A font can simply be gfx/tgafile, or alternatively you\n"
 721                            "can specify multiple fonts and faces\n"
 722                            "Like this: gfx/vera-sans:2,gfx/fallback:1\n"
 723                            "to load face 2 of the font gfx/vera-sans and use face 1\n"
 724                            "of gfx/fallback as fallback font.\n"
 725                            "You can also specify a list of font sizes to load, like this:\n"
 726                            "loadfont console gfx/conchars,gfx/fallback 8 12 16 24 32\n"
 727                            "In many cases, 8 12 16 24 32 should be a good choice.\n"
 728                         );
 729                 return;
 730         }
 731         f = FindFont(Cmd_Argv(1));
 732         if(f == NULL)
 733         {
 734                 Con_Printf("font function not found\n");
 735                 return;
 736         }
 737
 738         if(Cmd_Argc() < 3)
 739                 filelist = "gfx/conchars";
 740         else
 741                 filelist = Cmd_Argv(2);
 742
 743         memset(f->fallbacks, 0, sizeof(f->fallbacks));
 744         memset(f->fallback_faces, 0, sizeof(f->fallback_faces));
 745
 746         // first font is handled "normally"
 747         c = strchr(filelist, ':');
 748         cm = strchr(filelist, ',');
 749         if(c && (!cm || c < cm))
 750                 f->req_face = atoi(c+1);
 751         else
 752         {
 753                 f->req_face = 0;
 754                 c = cm;
 755         }
 756
 757         if(!c || (c - filelist) > MAX_QPATH)
 758                 strlcpy(mainfont, filelist, sizeof(mainfont));
 759         else
 760         {
 761                 memcpy(mainfont, filelist, c - filelist);
 762                 mainfont[c - filelist] = 0;
 763         }
 764
 765         for(i = 0; i < MAX_FONT_FALLBACKS; ++i)
 766         {
 767                 c = strchr(filelist, ',');
 768                 if(!c)
 769                         break;
 770                 filelist = c + 1;
 771                 if(!*filelist)
 772                         break;
 773                 c = strchr(filelist, ':');
 774                 cm = strchr(filelist, ',');
 775                 if(c && (!cm || c < cm))
 776                         f->fallback_faces[i] = atoi(c+1);
 777                 else
 778                 {
 779                         f->fallback_faces[i] = 0; // f->req_face; could make it stick to the default-font's face index
 780                         c = cm;
 781                 }
 782                 if(!c || (c-filelist) > MAX_QPATH)
 783                 {
 784                         strlcpy(f->fallbacks[i], filelist, sizeof(mainfont));
 785                 }
 786                 else
 787                 {
 788                         memcpy(f->fallbacks[i], filelist, c - filelist);
 789                         f->fallbacks[i][c - filelist] = 0;
 790                 }
 791         }
 792
 793         // for now: by default load only one size: the default size
 794         f->req_sizes[0] = 0;
 795         for(i = 1; i < MAX_FONT_SIZES; ++i)
 796                 f->req_sizes[i] = -1;
 797
 798         if(Cmd_Argc() >= 3)
 799         {
 800                 for(i = 0; i < Cmd_Argc()-3; ++i)
 801                 {
 802                         sz = atof(Cmd_Argv(i+3));
 803                         if (sz > 0.001f && sz < 1000.0f) // do not use crap sizes
 804                                 f->req_sizes[i] = sz;
 805                 }
 806         }
 807         LoadFont(true, mainfont, f);
 808 }
 809
 810 /*
 811 ===============
 812 Draw_Init
 813 ===============
 814 */
 815 static void gl_draw_start(void)
 816 {
 817         int i;
 818         drawtexturepool = R_AllocTexturePool();
 819
 820         numcachepics = 0;
 821         memset(cachepichash, 0, sizeof(cachepichash));
 822
 823         font_start();
 824
 825         for(i = 0; i < MAX_FONTS; ++i)
 826                 LoadFont(false, va("gfx/font_%s", dp_fonts[i].title), &dp_fonts[i]);
 827
 828         // draw the loading screen so people have something to see in the newly opened window
 829         SCR_UpdateLoadingScreen(true);
 830 }
 831
 832 static void gl_draw_shutdown(void)
 833 {
 834         font_shutdown();
 835
 836         R_FreeTexturePool(&drawtexturepool);
 837
 838         numcachepics = 0;
 839         memset(cachepichash, 0, sizeof(cachepichash));
 840 }
 841
 842 static void gl_draw_newmap(void)
 843 {
 844         font_newmap();
 845 }
 846
 847 void GL_Draw_Init (void)
 848 {
 849         int i, j;
 850         Cvar_RegisterVariable(&r_textshadow);
 851         Cvar_RegisterVariable(&r_textbrightness);
 852         Cvar_RegisterVariable(&r_textcontrast);
 853         Cmd_AddCommand ("loadfont",LoadFont_f, "loadfont function tganame loads a font; example: loadfont console gfx/veramono; loadfont without arguments lists the available functions");
 854         R_RegisterModule("GL_Draw", gl_draw_start, gl_draw_shutdown, gl_draw_newmap);
 855
 856         strlcpy(FONT_DEFAULT->title, "default", sizeof(FONT_DEFAULT->title));
 857                 strlcpy(FONT_DEFAULT->texpath, "gfx/conchars", sizeof(FONT_DEFAULT->texpath));
 858         strlcpy(FONT_CONSOLE->title, "console", sizeof(FONT_CONSOLE->title));
 859         strlcpy(FONT_SBAR->title, "sbar", sizeof(FONT_SBAR->title));
 860         strlcpy(FONT_NOTIFY->title, "notify", sizeof(FONT_NOTIFY->title));
 861         strlcpy(FONT_CHAT->title, "chat", sizeof(FONT_CHAT->title));
 862         strlcpy(FONT_CENTERPRINT->title, "centerprint", sizeof(FONT_CENTERPRINT->title));
 863         strlcpy(FONT_INFOBAR->title, "infobar", sizeof(FONT_INFOBAR->title));
 864         strlcpy(FONT_MENU->title, "menu", sizeof(FONT_MENU->title));
 865         for(i = 0, j = 0; i < MAX_USERFONTS; ++i)
 866                 if(!FONT_USER[i].title[0])
 867                         dpsnprintf(FONT_USER[i].title, sizeof(FONT_USER[i].title), "user%d", j++);
 868 }
 869
 870 void _DrawQ_Setup(void)
 871 {
 872         r_viewport_t viewport;
 873         if (r_refdef.draw2dstage)
 874                 return;
 875         r_refdef.draw2dstage = true;
 876         CHECKGLERROR
 877         R_Viewport_InitOrtho(&viewport, &identitymatrix, r_refdef.view.x, vid.height - r_refdef.view.y - r_refdef.view.height, r_refdef.view.width, r_refdef.view.height, 0, 0, vid_conwidth.integer, vid_conheight.integer, -10, 100, NULL);
 878         R_SetViewport(&viewport);
 879         GL_ColorMask(r_refdef.view.colormask[0], r_refdef.view.colormask[1], r_refdef.view.colormask[2], 1);
 880         qglDepthFunc(GL_LEQUAL);CHECKGLERROR
 881         qglDisable(GL_POLYGON_OFFSET_FILL);CHECKGLERROR
 882         GL_CullFace(GL_FRONT); // quake is backwards, this culls back faces
 883         R_EntityMatrix(&identitymatrix);
 884
 885         GL_DepthMask(true);
 886         GL_DepthRange(0, 1);
 887         GL_PolygonOffset(0, 0);
 888         GL_DepthTest(false);
 889         GL_Color(1,1,1,1);
 890         GL_AlphaTest(false);
 891         GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 892 }
 893
 894 static void _DrawQ_ProcessDrawFlag(int flags)
 895 {
 896         _DrawQ_Setup();
 897         CHECKGLERROR
 898         if(flags == DRAWFLAG_ADDITIVE)
 899                 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE);
 900         else if(flags == DRAWFLAG_MODULATE)
 901                 GL_BlendFunc(GL_DST_COLOR, GL_ZERO);
 902         else if(flags == DRAWFLAG_2XMODULATE)
 903                 GL_BlendFunc(GL_DST_COLOR,GL_SRC_COLOR);
 904         else if(flags == DRAWFLAG_SCREEN)
 905                 GL_BlendFunc(GL_ONE_MINUS_DST_COLOR,GL_ONE);
 906         else
 907                 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 908 }
 909
 910 void DrawQ_Pic(float x, float y, cachepic_t *pic, float width, float height, float red, float green, float blue, float alpha, int flags)
 911 {
 912         float floats[20];
 913
 914         _DrawQ_ProcessDrawFlag(flags);
 915         GL_Color(red, green, blue, alpha);
 916
 917         R_Mesh_VertexPointer(floats, 0, 0);
 918         R_Mesh_ColorPointer(NULL, 0, 0);
 919         R_Mesh_ResetTextureState();
 920         if (pic)
 921         {
 922                 if (width == 0)
 923                         width = pic->width;
 924                 if (height == 0)
 925                         height = pic->height;
 926                 R_SetupShader_Generic(Draw_GetPicTexture(pic), NULL, GL_MODULATE, 1);
 927                 R_Mesh_TexCoordPointer(0, 2, floats + 12, 0, 0);
 928
 929 #if 1
 930                 floats[12] = 0.0f;floats[13] = 0.0f;
 931                 floats[14] = 1.0f;floats[15] = 0.0f;
 932                 floats[16] = 1.0f;floats[17] = 1.0f;
 933                 floats[18] = 0.0f;floats[19] = 1.0f;
 934 #else
 935       // AK07: lets be texel correct on the corners
 936       {
 937          float horz_offset = 0.5f / pic->width;
 938          float vert_offset = 0.5f / pic->height;
 939
 940                    floats[12] = 0.0f + horz_offset;floats[13] = 0.0f + vert_offset;
 941                    floats[14] = 1.0f - horz_offset;floats[15] = 0.0f + vert_offset;
 942                    floats[16] = 1.0f - horz_offset;floats[17] = 1.0f - vert_offset;
 943                    floats[18] = 0.0f + horz_offset;floats[19] = 1.0f - vert_offset;
 944       }
 945 #endif
 946         }
 947         else
 948                 R_SetupShader_Generic(NULL, NULL, GL_MODULATE, 1);
 949
 950         floats[2] = floats[5] = floats[8] = floats[11] = 0;
 951         floats[0] = floats[9] = x;
 952         floats[1] = floats[4] = y;
 953         floats[3] = floats[6] = x + width;
 954         floats[7] = floats[10] = y + height;
 955
 956         R_Mesh_Draw(0, 4, 0, 2, polygonelement3i, polygonelement3s, 0, 0);
 957 }
 958
 959 void DrawQ_RotPic(float x, float y, cachepic_t *pic, float width, float height, float org_x, float org_y, float angle, float red, float green, float blue, float alpha, int flags)
 960 {
 961         float floats[20];
 962         float af = DEG2RAD(-angle); // forward
 963         float ar = DEG2RAD(-angle + 90); // right
 964         float sinaf = sin(af);
 965         float cosaf = cos(af);
 966         float sinar = sin(ar);
 967         float cosar = cos(ar);
 968
 969         _DrawQ_ProcessDrawFlag(flags);
 970         GL_Color(red, green, blue, alpha);
 971
 972         R_Mesh_VertexPointer(floats, 0, 0);
 973         R_Mesh_ColorPointer(NULL, 0, 0);
 974         R_Mesh_ResetTextureState();
 975         if (pic)
 976         {
 977                 if (width == 0)
 978                         width = pic->width;
 979                 if (height == 0)
 980                         height = pic->height;
 981                 R_SetupShader_Generic(Draw_GetPicTexture(pic), NULL, GL_MODULATE, 1);
 982                 R_Mesh_TexCoordPointer(0, 2, floats + 12, 0, 0);
 983
 984                 floats[12] = 0.0f;floats[13] = 0.0f;
 985                 floats[14] = 1.0f;floats[15] = 0.0f;
 986                 floats[16] = 1.0f;floats[17] = 1.0f;
 987                 floats[18] = 0.0f;floats[19] = 1.0f;
 988         }
 989         else
 990                 R_SetupShader_Generic(NULL, NULL, GL_MODULATE, 1);
 991
 992         floats[2] = floats[5] = floats[8] = floats[11] = 0;
 993
 994 // top left
 995         floats[0] = x - cosaf*org_x - cosar*org_y;
 996         floats[1] = y - sinaf*org_x - sinar*org_y;
 997
 998 // top right
 999         floats[3] = x + cosaf*(width-org_x) - cosar*org_y;
1000         floats[4] = y + sinaf*(width-org_x) - sinar*org_y;
1001
1002 // bottom right
1003         floats[6] = x + cosaf*(width-org_x) + cosar*(height-org_y);
1004         floats[7] = y + sinaf*(width-org_x) + sinar*(height-org_y);
1005
1006 // bottom left
1007         floats[9]  = x - cosaf*org_x + cosar*(height-org_y);
1008         floats[10] = y - sinaf*org_x + sinar*(height-org_y);
1009
1010         R_Mesh_Draw(0, 4, 0, 2, polygonelement3i, polygonelement3s, 0, 0);
1011 }
1012
1013 void DrawQ_Fill(float x, float y, float width, float height, float red, float green, float blue, float alpha, int flags)
1014 {
1015         float floats[12];
1016
1017         _DrawQ_ProcessDrawFlag(flags);
1018         GL_Color(red, green, blue, alpha);
1019
1020         R_Mesh_VertexPointer(floats, 0, 0);
1021         R_Mesh_ColorPointer(NULL, 0, 0);
1022         R_Mesh_ResetTextureState();
1023         R_SetupShader_Generic(NULL, NULL, GL_MODULATE, 1);
1024
1025         floats[2] = floats[5] = floats[8] = floats[11] = 0;
1026         floats[0] = floats[9] = x;
1027         floats[1] = floats[4] = y;
1028         floats[3] = floats[6] = x + width;
1029         floats[7] = floats[10] = y + height;
1030
1031         R_Mesh_Draw(0, 4, 0, 2, polygonelement3i, polygonelement3s, 0, 0);
1032 }
1033
1034 /// color tag printing
1035 static const vec4_t string_colors[] =
1036 {
1037         // Quake3 colors
1038         // LordHavoc: why on earth is cyan before magenta in Quake3?
1039         // LordHavoc: note: Doom3 uses white for [0] and [7]
1040         {0.0, 0.0, 0.0, 1.0}, // black
1041         {1.0, 0.0, 0.0, 1.0}, // red
1042         {0.0, 1.0, 0.0, 1.0}, // green
1043         {1.0, 1.0, 0.0, 1.0}, // yellow
1044         {0.0, 0.0, 1.0, 1.0}, // blue
1045         {0.0, 1.0, 1.0, 1.0}, // cyan
1046         {1.0, 0.0, 1.0, 1.0}, // magenta
1047         {1.0, 1.0, 1.0, 1.0}, // white
1048         // [515]'s BX_COLOREDTEXT extension
1049         {1.0, 1.0, 1.0, 0.5}, // half transparent
1050         {0.5, 0.5, 0.5, 1.0}  // half brightness
1051         // Black's color table
1052         //{1.0, 1.0, 1.0, 1.0},
1053         //{1.0, 0.0, 0.0, 1.0},
1054         //{0.0, 1.0, 0.0, 1.0},
1055         //{0.0, 0.0, 1.0, 1.0},
1056         //{1.0, 1.0, 0.0, 1.0},
1057         //{0.0, 1.0, 1.0, 1.0},
1058         //{1.0, 0.0, 1.0, 1.0},
1059         //{0.1, 0.1, 0.1, 1.0}
1060 };
1061
1062 #define STRING_COLORS_COUNT     (sizeof(string_colors) / sizeof(vec4_t))
1063
1064 static void DrawQ_GetTextColor(float color[4], int colorindex, float r, float g, float b, float a, qboolean shadow)
1065 {
1066         float C = r_textcontrast.value;
1067         float B = r_textbrightness.value;
1068         if (colorindex & 0x10000) // that bit means RGB color
1069         {
1070                 color[0] = ((colorindex >> 12) & 0xf) / 15.0;
1071                 color[1] = ((colorindex >> 8) & 0xf) / 15.0;
1072                 color[2] = ((colorindex >> 4) & 0xf) / 15.0;
1073                 color[3] = (colorindex & 0xf) / 15.0;
1074         }
1075         else
1076                 Vector4Copy(string_colors[colorindex], color);
1077         Vector4Set(color, color[0] * r * C + B, color[1] * g * C + B, color[2] * b * C + B, color[3] * a);
1078         if (shadow)
1079         {
1080                 float shadowalpha = (color[0]+color[1]+color[2]) * 0.8;
1081                 Vector4Set(color, 0, 0, 0, color[3] * bound(0, shadowalpha, 1));
1082         }
1083 }
1084
1085 // NOTE: this function always draws exactly one character if maxwidth <= 0
1086 float DrawQ_TextWidth_UntilWidth_TrackColors_Scale(const char *text, size_t *maxlen, float w, float h, float sw, float sh, int *outcolor, qboolean ignorecolorcodes, const dp_font_t *fnt, float maxwidth)
1087 {
1088         const char *text_start = text;
1089         int colorindex = STRING_COLOR_DEFAULT;
1090         size_t i;
1091         float x = 0;
1092         Uchar ch, mapch, nextch;
1093         Uchar prevch = 0; // used for kerning
1094         int tempcolorindex;
1095         float kx;
1096         int map_index = 0;
1097         size_t bytes_left;
1098         ft2_font_map_t *fontmap = NULL;
1099         ft2_font_map_t *map = NULL;
1100         ft2_font_map_t *prevmap = NULL;
1101         ft2_font_t *ft2 = fnt->ft2;
1102         // float ftbase_x;
1103         qboolean snap = true;
1104         qboolean least_one = false;
1105         float dw, dh; // display w/h
1106         const float *width_of;
1107
1108         if (!h) h = w;
1109         if (!h) {
1110                 w = h = 1;
1111                 snap = false;
1112         }
1113         // do this in the end
1114         w *= fnt->scale;
1115         h *= fnt->scale;
1116
1117         // find the most fitting size:
1118         if (ft2 != NULL)
1119         {
1120                 if (snap)
1121                         map_index = Font_IndexForSize(ft2, h, &w, &h);
1122                 else
1123                         map_index = Font_IndexForSize(ft2, h, NULL, NULL);
1124                 fontmap = Font_MapForIndex(ft2, map_index);
1125         }
1126
1127         dw = w * sw;
1128         dh = h * sh;
1129
1130         if (*maxlen < 1)
1131                 *maxlen = 1<<30;
1132
1133         if (!outcolor || *outcolor == -1)
1134                 colorindex = STRING_COLOR_DEFAULT;
1135         else
1136                 colorindex = *outcolor;
1137
1138         // maxwidth /= fnt->scale; // w and h are multiplied by it already
1139         // ftbase_x = snap_to_pixel_x(0);
1140
1141         if(maxwidth <= 0)
1142         {
1143                 least_one = true;
1144                 maxwidth = -maxwidth;
1145         }
1146
1147         //if (snap)
1148         //      x = snap_to_pixel_x(x, 0.4); // haha, it's 0 anyway
1149
1150         if (fontmap)
1151                 width_of = fontmap->width_of;
1152         else
1153                 width_of = fnt->width_of;
1154
1155         for (i = 0;((bytes_left = *maxlen - (text - text_start)) > 0) && *text;)
1156         {
1157                 size_t i0 = i;
1158                 nextch = ch = u8_getnchar(text, &text, bytes_left);
1159                 i = text - text_start;
1160                 if (!ch)
1161                         break;
1162                 if (ch == ' ' && !fontmap)
1163                 {
1164                         if(!least_one || i0) // never skip the first character
1165                         if(x + width_of[(int) ' '] * dw > maxwidth)
1166                         {
1167                                 i = i0;
1168                                 break; // oops, can't draw this
1169                         }
1170                         x += width_of[(int) ' '] * dw;
1171                         continue;
1172                 }
1173                 // i points to the char after ^
1174                 if (ch == STRING_COLOR_TAG && !ignorecolorcodes && i < *maxlen)
1175                 {
1176                         ch = *text; // colors are ascii, so no u8_ needed
1177                         if (ch <= '9' && ch >= '0') // ^[0-9] found
1178                         {
1179                                 colorindex = ch - '0';
1180                                 ++text;
1181                                 ++i;
1182                                 continue;
1183                         }
1184                         // i points to the char after ^...
1185                         // i+3 points to 3 in ^x123
1186                         // i+3 == *maxlen would mean that char is missing
1187                         else if (ch == STRING_COLOR_RGB_TAG_CHAR && i + 3 < *maxlen ) // ^x found
1188                         {
1189                                 // building colorindex...
1190                                 ch = tolower(text[1]);
1191                                 tempcolorindex = 0x10000; // binary: 1,0000,0000,0000,0000
1192                                 if (ch <= '9' && ch >= '0') tempcolorindex |= (ch - '0') << 12;
1193                                 else if (ch >= 'a' && ch <= 'f') tempcolorindex |= (ch - 87) << 12;
1194                                 else tempcolorindex = 0;
1195                                 if (tempcolorindex)
1196                                 {
1197                                         ch = tolower(text[2]);
1198                                         if (ch <= '9' && ch >= '0') tempcolorindex |= (ch - '0') << 8;
1199                                         else if (ch >= 'a' && ch <= 'f') tempcolorindex |= (ch - 87) << 8;
1200                                         else tempcolorindex = 0;
1201                                         if (tempcolorindex)
1202                                         {
1203                                                 ch = tolower(text[3]);
1204                                                 if (ch <= '9' && ch >= '0') tempcolorindex |= (ch - '0') << 4;
1205                                                 else if (ch >= 'a' && ch <= 'f') tempcolorindex |= (ch - 87) << 4;
1206                                                 else tempcolorindex = 0;
1207                                                 if (tempcolorindex)
1208                                                 {
1209                                                         colorindex = tempcolorindex | 0xf;
1210                                                         // ...done! now colorindex has rgba codes (1,rrrr,gggg,bbbb,aaaa)
1211                                                         i+=4;
1212                                                         text += 4;
1213                                                         continue;
1214                                                 }
1215                                         }
1216                                 }
1217                         }
1218                         else if (ch == STRING_COLOR_TAG) // ^^ found, ignore the first ^ and go to print the second
1219                         {
1220                                 i++;
1221                                 text++;
1222                         }
1223                         i--;
1224                 }
1225                 ch = nextch;
1226
1227                 if (!fontmap || (ch <= 0xFF && fontmap->glyphs[ch].image) || (ch >= 0xE000 && ch <= 0xE0FF))
1228                 {
1229                         if (ch > 0xE000)
1230                                 ch -= 0xE000;
1231                         if (ch > 0xFF)
1232                                 continue;
1233                         if (fontmap)
1234                                 map = ft2_oldstyle_map;
1235                         prevch = 0;
1236                         if(!least_one || i0) // never skip the first character
1237                         if(x + width_of[ch] * dw > maxwidth)
1238                         {
1239                                 i = i0;
1240                                 break; // oops, can't draw this
1241                         }
1242                         x += width_of[ch] * dw;
1243                 } else {
1244                         if (!map || map == ft2_oldstyle_map || ch < map->start || ch >= map->start + FONT_CHARS_PER_MAP)
1245                         {
1246                                 map = FontMap_FindForChar(fontmap, ch);
1247                                 if (!map)
1248                                 {
1249                                         if (!Font_LoadMapForIndex(ft2, map_index, ch, &map))
1250                                                 break;
1251                                         if (!map)
1252                                                 break;
1253                                 }
1254                         }
1255                         mapch = ch - map->start;
1256                         if (prevch && Font_GetKerningForMap(ft2, map_index, w, h, prevch, ch, &kx, NULL))
1257                                 x += kx * dw;
1258                         x += map->glyphs[mapch].advance_x * dw;
1259                         prevmap = map;
1260                         prevch = ch;
1261                 }
1262         }
1263
1264         *maxlen = i;
1265
1266         if (outcolor)
1267                 *outcolor = colorindex;
1268
1269         return x;
1270 }
1271
1272 float DrawQ_String_Scale(float startx, float starty, const char *text, size_t maxlen, float w, float h, float sw, float sh, float basered, float basegreen, float baseblue, float basealpha, int flags, int *outcolor, qboolean ignorecolorcodes, const dp_font_t *fnt)
1273 {
1274         int shadow, colorindex = STRING_COLOR_DEFAULT;
1275         size_t i;
1276         float x = startx, y, s, t, u, v, thisw;
1277         float *av, *at, *ac;
1278         float color[4];
1279         int batchcount;
1280         static float vertex3f[QUADELEMENTS_MAXQUADS*4*3];
1281         static float texcoord2f[QUADELEMENTS_MAXQUADS*4*2];
1282         static float color4f[QUADELEMENTS_MAXQUADS*4*4];
1283         Uchar ch, mapch, nextch;
1284         Uchar prevch = 0; // used for kerning
1285         int tempcolorindex;
1286         int map_index = 0;
1287         ft2_font_map_t *prevmap = NULL; // the previous map
1288         ft2_font_map_t *map = NULL;     // the currently used map
1289         ft2_font_map_t *fontmap = NULL; // the font map for the size
1290         float ftbase_y;
1291         const char *text_start = text;
1292         float kx, ky;
1293         ft2_font_t *ft2 = fnt->ft2;
1294         qboolean snap = true;
1295         float pix_x, pix_y;
1296         size_t bytes_left;
1297         float dw, dh;
1298         const float *width_of;
1299
1300         int tw, th;
1301         tw = R_TextureWidth(fnt->tex);
1302         th = R_TextureHeight(fnt->tex);
1303
1304         if (!h) h = w;
1305         if (!h) {
1306                 h = w = 1;
1307                 snap = false;
1308         }
1309
1310         starty -= (fnt->scale - 1) * h * 0.5; // center
1311         w *= fnt->scale;
1312         h *= fnt->scale;
1313
1314         if (ft2 != NULL)
1315         {
1316                 if (snap)
1317                         map_index = Font_IndexForSize(ft2, h, &w, &h);
1318                 else
1319                         map_index = Font_IndexForSize(ft2, h, NULL, NULL);
1320                 fontmap = Font_MapForIndex(ft2, map_index);
1321         }
1322
1323         dw = w * sw;
1324         dh = h * sh;
1325
1326         // draw the font at its baseline when using freetype
1327         //ftbase_x = 0;
1328         ftbase_y = dh * (4.5/6.0);
1329
1330         if (maxlen < 1)
1331                 maxlen = 1<<30;
1332
1333         _DrawQ_ProcessDrawFlag(flags);
1334
1335         R_Mesh_ColorPointer(color4f, 0, 0);
1336         R_Mesh_ResetTextureState();
1337         if (!fontmap)
1338                 R_Mesh_TexBind(0, fnt->tex);
1339         R_Mesh_TexCoordPointer(0, 2, texcoord2f, 0, 0);
1340         R_Mesh_VertexPointer(vertex3f, 0, 0);
1341         R_SetupShader_Generic(fnt->tex, NULL, GL_MODULATE, 1);
1342
1343         ac = color4f;
1344         at = texcoord2f;
1345         av = vertex3f;
1346         batchcount = 0;
1347
1348         //ftbase_x = snap_to_pixel_x(ftbase_x);
1349         if(snap)
1350         {
1351                 startx = snap_to_pixel_x(startx, 0.4);
1352                 starty = snap_to_pixel_y(starty, 0.4);
1353                 ftbase_y = snap_to_pixel_y(ftbase_y, 0.3);
1354         }
1355
1356         pix_x = vid.width / vid_conwidth.value;
1357         pix_y = vid.height / vid_conheight.value;
1358
1359         if (fontmap)
1360                 width_of = fontmap->width_of;
1361         else
1362                 width_of = fnt->width_of;
1363
1364         for (shadow = r_textshadow.value != 0 && basealpha > 0;shadow >= 0;shadow--)
1365         {
1366                 prevch = 0;
1367                 text = text_start;
1368
1369                 if (!outcolor || *outcolor == -1)
1370                         colorindex = STRING_COLOR_DEFAULT;
1371                 else
1372                         colorindex = *outcolor;
1373
1374                 DrawQ_GetTextColor(color, colorindex, basered, basegreen, baseblue, basealpha, shadow != 0);
1375
1376                 x = startx;
1377                 y = starty;
1378                 /*
1379                 if (shadow)
1380                 {
1381                         x += r_textshadow.value * vid.width / vid_conwidth.value;
1382                         y += r_textshadow.value * vid.height / vid_conheight.value;
1383                 }
1384                 */
1385                 for (i = 0;((bytes_left = maxlen - (text - text_start)) > 0) && *text;)
1386                 {
1387                         nextch = ch = u8_getnchar(text, &text, bytes_left);
1388                         i = text - text_start;
1389                         if (!ch)
1390                                 break;
1391                         if (ch == ' ' && !fontmap)
1392                         {
1393                                 x += width_of[(int) ' '] * dw;
1394                                 continue;
1395                         }
1396                         if (ch == STRING_COLOR_TAG && !ignorecolorcodes && i < maxlen)
1397                         {
1398                                 ch = *text; // colors are ascii, so no u8_ needed
1399                                 if (ch <= '9' && ch >= '0') // ^[0-9] found
1400                                 {
1401                                         colorindex = ch - '0';
1402                                         DrawQ_GetTextColor(color, colorindex, basered, basegreen, baseblue, basealpha, shadow != 0);
1403                                         ++text;
1404                                         ++i;
1405                                         continue;
1406                                 }
1407                                 else if (ch == STRING_COLOR_RGB_TAG_CHAR && i+3 < maxlen ) // ^x found
1408                                 {
1409                                         // building colorindex...
1410                                         ch = tolower(text[1]);
1411                                         tempcolorindex = 0x10000; // binary: 1,0000,0000,0000,0000
1412                                         if (ch <= '9' && ch >= '0') tempcolorindex |= (ch - '0') << 12;
1413                                         else if (ch >= 'a' && ch <= 'f') tempcolorindex |= (ch - 87) << 12;
1414                                         else tempcolorindex = 0;
1415                                         if (tempcolorindex)
1416                                         {
1417                                                 ch = tolower(text[2]);
1418                                                 if (ch <= '9' && ch >= '0') tempcolorindex |= (ch - '0') << 8;
1419                                                 else if (ch >= 'a' && ch <= 'f') tempcolorindex |= (ch - 87) << 8;
1420                                                 else tempcolorindex = 0;
1421                                                 if (tempcolorindex)
1422                                                 {
1423                                                         ch = tolower(text[3]);
1424                                                         if (ch <= '9' && ch >= '0') tempcolorindex |= (ch - '0') << 4;
1425                                                         else if (ch >= 'a' && ch <= 'f') tempcolorindex |= (ch - 87) << 4;
1426                                                         else tempcolorindex = 0;
1427                                                         if (tempcolorindex)
1428                                                         {
1429                                                                 colorindex = tempcolorindex | 0xf;
1430                                                                 // ...done! now colorindex has rgba codes (1,rrrr,gggg,bbbb,aaaa)
1431                                                                 //Con_Printf("^1colorindex:^7 %x\n", colorindex);
1432                                                                 DrawQ_GetTextColor(color, colorindex, basered, basegreen, baseblue, basealpha, shadow != 0);
1433                                                                 i+=4;
1434                                                                 text+=4;
1435                                                                 continue;
1436                                                         }
1437                                                 }
1438                                         }
1439                                 }
1440                                 else if (ch == STRING_COLOR_TAG)
1441                                 {
1442                                         i++;
1443                                         text++;
1444                                 }
1445                                 i--;
1446                         }
1447                         // get the backup
1448                         ch = nextch;
1449                         // using a value of -1 for the oldstyle map because NULL means uninitialized...
1450                         // this way we don't need to rebind fnt->tex for every old-style character
1451                         // E000..E0FF: emulate old-font characters (to still have smileys and such available)
1452                         if (shadow)
1453                         {
1454                                 x += 1.0/pix_x * r_textshadow.value;
1455                                 y += 1.0/pix_y * r_textshadow.value;
1456                         }
1457                         if (!fontmap || (ch <= 0xFF && fontmap->glyphs[ch].image) || (ch >= 0xE000 && ch <= 0xE0FF))
1458                         {
1459                                 if (ch > 0xE000)
1460                                         ch -= 0xE000;
1461                                 if (ch > 0xFF)
1462                                         continue;
1463                                 if (fontmap)
1464                                 {
1465                                         if (map != ft2_oldstyle_map)
1466                                         {
1467                                                 if (batchcount)
1468                                                 {
1469                                                         // switching from freetype to non-freetype rendering
1470                                                         R_Mesh_Draw(0, batchcount * 4, 0, batchcount * 2, quadelement3i, quadelement3s, 0, 0);
1471                                                         batchcount = 0;
1472                                                         ac = color4f;
1473                                                         at = texcoord2f;
1474                                                         av = vertex3f;
1475                                                 }
1476                                                 R_SetupShader_Generic(fnt->tex, NULL, GL_MODULATE, 1);
1477                                                 map = ft2_oldstyle_map;
1478                                         }
1479                                 }
1480                                 prevch = 0;
1481                                 //num = (unsigned char) text[i];
1482                                 //thisw = fnt->width_of[num];
1483                                 thisw = fnt->width_of[ch];
1484                                 // FIXME make these smaller to just include the occupied part of the character for slightly faster rendering
1485                                 s = (ch & 15)*0.0625f + (0.5f / tw);
1486                                 t = (ch >> 4)*0.0625f + (0.5f / th);
1487                                 u = 0.0625f * thisw - (1.0f / tw);
1488                                 v = 0.0625f - (1.0f / th);
1489                                 ac[ 0] = color[0];ac[ 1] = color[1];ac[ 2] = color[2];ac[ 3] = color[3];
1490                                 ac[ 4] = color[0];ac[ 5] = color[1];ac[ 6] = color[2];ac[ 7] = color[3];
1491                                 ac[ 8] = color[0];ac[ 9] = color[1];ac[10] = color[2];ac[11] = color[3];
1492                                 ac[12] = color[0];ac[13] = color[1];ac[14] = color[2];ac[15] = color[3];
1493                                 at[ 0] = s              ; at[ 1] = t    ;
1494                                 at[ 2] = s+u    ; at[ 3] = t    ;
1495                                 at[ 4] = s+u    ; at[ 5] = t+v  ;
1496                                 at[ 6] = s              ; at[ 7] = t+v  ;
1497                                 av[ 0] = x                      ; av[ 1] = y    ; av[ 2] = 10;
1498                                 av[ 3] = x+dw*thisw     ; av[ 4] = y    ; av[ 5] = 10;
1499                                 av[ 6] = x+dw*thisw     ; av[ 7] = y+dh ; av[ 8] = 10;
1500                                 av[ 9] = x                      ; av[10] = y+dh ; av[11] = 10;
1501                                 ac += 16;
1502                                 at += 8;
1503                                 av += 12;
1504                                 batchcount++;
1505                                 if (batchcount >= QUADELEMENTS_MAXQUADS)
1506                                 {
1507                                         R_Mesh_Draw(0, batchcount * 4, 0, batchcount * 2, quadelement3i, quadelement3s, 0, 0);
1508                                         batchcount = 0;
1509                                         ac = color4f;
1510                                         at = texcoord2f;
1511                                         av = vertex3f;
1512                                 }
1513                                 x += width_of[ch] * dw;
1514                         } else {
1515                                 if (!map || map == ft2_oldstyle_map || ch < map->start || ch >= map->start + FONT_CHARS_PER_MAP)
1516                                 {
1517                                         // new charmap - need to render
1518                                         if (batchcount)
1519                                         {
1520                                                 // we need a different character map, render what we currently have:
1521                                                 R_Mesh_Draw(0, batchcount * 4, 0, batchcount * 2, quadelement3i, quadelement3s, 0, 0);
1522                                                 batchcount = 0;
1523                                                 ac = color4f;
1524                                                 at = texcoord2f;
1525                                                 av = vertex3f;
1526                                         }
1527                                         // find the new map
1528                                         map = FontMap_FindForChar(fontmap, ch);
1529                                         if (!map)
1530                                         {
1531                                                 if (!Font_LoadMapForIndex(ft2, map_index, ch, &map))
1532                                                 {
1533                                                         shadow = -1;
1534                                                         break;
1535                                                 }
1536                                                 if (!map)
1537                                                 {
1538                                                         // this shouldn't happen
1539                                                         shadow = -1;
1540                                                         break;
1541                                                 }
1542                                         }
1543                                         R_SetupShader_Generic(map->texture, NULL, GL_MODULATE, 1);
1544                                 }
1545
1546                                 mapch = ch - map->start;
1547                                 thisw = map->glyphs[mapch].advance_x;
1548
1549                                 //x += ftbase_x;
1550                                 y += ftbase_y;
1551                                 if (prevch && Font_GetKerningForMap(ft2, map_index, w, h, prevch, ch, &kx, &ky))
1552                                 {
1553                                         x += kx * dw;
1554                                         y += ky * dh;
1555                                 }
1556                                 else
1557                                         kx = ky = 0;
1558                                 ac[ 0] = color[0]; ac[ 1] = color[1]; ac[ 2] = color[2]; ac[ 3] = color[3];
1559                                 ac[ 4] = color[0]; ac[ 5] = color[1]; ac[ 6] = color[2]; ac[ 7] = color[3];
1560                                 ac[ 8] = color[0]; ac[ 9] = color[1]; ac[10] = color[2]; ac[11] = color[3];
1561                                 ac[12] = color[0]; ac[13] = color[1]; ac[14] = color[2]; ac[15] = color[3];
1562                                 at[0] = map->glyphs[mapch].txmin; at[1] = map->glyphs[mapch].tymin;
1563                                 at[2] = map->glyphs[mapch].txmax; at[3] = map->glyphs[mapch].tymin;
1564                                 at[4] = map->glyphs[mapch].txmax; at[5] = map->glyphs[mapch].tymax;
1565                                 at[6] = map->glyphs[mapch].txmin; at[7] = map->glyphs[mapch].tymax;
1566                                 av[ 0] = x + dw * map->glyphs[mapch].vxmin; av[ 1] = y + dh * map->glyphs[mapch].vymin; av[ 2] = 10;
1567                                 av[ 3] = x + dw * map->glyphs[mapch].vxmax; av[ 4] = y + dh * map->glyphs[mapch].vymin; av[ 5] = 10;
1568                                 av[ 6] = x + dw * map->glyphs[mapch].vxmax; av[ 7] = y + dh * map->glyphs[mapch].vymax; av[ 8] = 10;
1569                                 av[ 9] = x + dw * map->glyphs[mapch].vxmin; av[10] = y + dh * map->glyphs[mapch].vymax; av[11] = 10;
1570                                 //x -= ftbase_x;
1571                                 y -= ftbase_y;
1572
1573                                 x += thisw * dw;
1574                                 ac += 16;
1575                                 at += 8;
1576                                 av += 12;
1577                                 batchcount++;
1578                                 if (batchcount >= QUADELEMENTS_MAXQUADS)
1579                                 {
1580                                         R_Mesh_Draw(0, batchcount * 4, 0, batchcount * 2, quadelement3i, quadelement3s, 0, 0);
1581                                         batchcount = 0;
1582                                         ac = color4f;
1583                                         at = texcoord2f;
1584                                         av = vertex3f;
1585                                 }
1586
1587                                 prevmap = map;
1588                                 prevch = ch;
1589                         }
1590                         if (shadow)
1591                         {
1592                                 x -= 1.0/pix_x * r_textshadow.value;
1593                                 y -= 1.0/pix_y * r_textshadow.value;
1594                         }
1595                 }
1596         }
1597         if (batchcount > 0)
1598                 R_Mesh_Draw(0, batchcount * 4, 0, batchcount * 2, quadelement3i, quadelement3s, 0, 0);
1599
1600         if (outcolor)
1601                 *outcolor = colorindex;
1602
1603         // note: this relies on the proper text (not shadow) being drawn last
1604         return x;
1605 }
1606
1607 float DrawQ_String(float startx, float starty, const char *text, size_t maxlen, float w, float h, float basered, float basegreen, float baseblue, float basealpha, int flags, int *outcolor, qboolean ignorecolorcodes, const dp_font_t *fnt)
1608 {
1609         return DrawQ_String_Scale(startx, starty, text, maxlen, w, h, 1, 1, basered, basegreen, baseblue, basealpha, flags, outcolor, ignorecolorcodes, fnt);
1610 }
1611
1612 float DrawQ_TextWidth_UntilWidth_TrackColors(const char *text, size_t *maxlen, float w, float h, int *outcolor, qboolean ignorecolorcodes, const dp_font_t *fnt, float maxwidth)
1613 {
1614         return DrawQ_TextWidth_UntilWidth_TrackColors_Scale(text, maxlen, w, h, 1, 1, outcolor, ignorecolorcodes, fnt, maxwidth);
1615 }
1616
1617 float DrawQ_TextWidth(const char *text, size_t maxlen, float w, float h, qboolean ignorecolorcodes, const dp_font_t *fnt)
1618 {
1619         return DrawQ_TextWidth_UntilWidth(text, &maxlen, w, h, ignorecolorcodes, fnt, 1000000000);
1620 }
1621
1622 float DrawQ_TextWidth_UntilWidth(const char *text, size_t *maxlen, float w, float h, qboolean ignorecolorcodes, const dp_font_t *fnt, float maxWidth)
1623 {
1624         return DrawQ_TextWidth_UntilWidth_TrackColors(text, maxlen, w, h, NULL, ignorecolorcodes, fnt, maxWidth);
1625 }
1626
1627 #if 0
1628 // not used
1629 // no ^xrgb management
1630 static int DrawQ_BuildColoredText(char *output2c, size_t maxoutchars, const char *text, int maxreadchars, qboolean ignorecolorcodes, int *outcolor)
1631 {
1632         int color, numchars = 0;
1633         char *outputend2c = output2c + maxoutchars - 2;
1634         if (!outcolor || *outcolor == -1)
1635                 color = STRING_COLOR_DEFAULT;
1636         else
1637                 color = *outcolor;
1638         if (!maxreadchars)
1639                 maxreadchars = 1<<30;
1640         textend = text + maxreadchars;
1641         while (text != textend && *text)
1642         {
1643                 if (*text == STRING_COLOR_TAG && !ignorecolorcodes && text + 1 != textend)
1644                 {
1645                         if (text[1] == STRING_COLOR_TAG)
1646                                 text++;
1647                         else if (text[1] >= '0' && text[1] <= '9')
1648                         {
1649                                 color = text[1] - '0';
1650                                 text += 2;
1651                                 continue;
1652                         }
1653                 }
1654                 if (output2c >= outputend2c)
1655                         break;
1656                 *output2c++ = *text++;
1657                 *output2c++ = color;
1658                 numchars++;
1659         }
1660         output2c[0] = output2c[1] = 0;
1661         if (outcolor)
1662                 *outcolor = color;
1663         return numchars;
1664 }
1665 #endif
1666
1667 void DrawQ_SuperPic(float x, float y, cachepic_t *pic, float width, float height, float s1, float t1, float r1, float g1, float b1, float a1, float s2, float t2, float r2, float g2, float b2, float a2, float s3, float t3, float r3, float g3, float b3, float a3, float s4, float t4, float r4, float g4, float b4, float a4, int flags)
1668 {
1669         float floats[36];
1670
1671         _DrawQ_ProcessDrawFlag(flags);
1672
1673         R_Mesh_VertexPointer(floats, 0, 0);
1674         R_Mesh_ColorPointer(floats + 20, 0, 0);
1675         R_Mesh_ResetTextureState();
1676         if (pic)
1677         {
1678                 if (width == 0)
1679                         width = pic->width;
1680                 if (height == 0)
1681                         height = pic->height;
1682                 R_SetupShader_Generic(Draw_GetPicTexture(pic), NULL, GL_MODULATE, 1);
1683                 R_Mesh_TexCoordPointer(0, 2, floats + 12, 0, 0);
1684                 floats[12] = s1;floats[13] = t1;
1685                 floats[14] = s2;floats[15] = t2;
1686                 floats[16] = s4;floats[17] = t4;
1687                 floats[18] = s3;floats[19] = t3;
1688         }
1689         else
1690                 R_SetupShader_Generic(NULL, NULL, GL_MODULATE, 1);
1691
1692         floats[2] = floats[5] = floats[8] = floats[11] = 0;
1693         floats[0] = floats[9] = x;
1694         floats[1] = floats[4] = y;
1695         floats[3] = floats[6] = x + width;
1696         floats[7] = floats[10] = y + height;
1697         floats[20] = r1;floats[21] = g1;floats[22] = b1;floats[23] = a1;
1698         floats[24] = r2;floats[25] = g2;floats[26] = b2;floats[27] = a2;
1699         floats[28] = r4;floats[29] = g4;floats[30] = b4;floats[31] = a4;
1700         floats[32] = r3;floats[33] = g3;floats[34] = b3;floats[35] = a3;
1701
1702         R_Mesh_Draw(0, 4, 0, 2, polygonelement3i, polygonelement3s, 0, 0);
1703 }
1704
1705 void DrawQ_Mesh (drawqueuemesh_t *mesh, int flags)
1706 {
1707         _DrawQ_ProcessDrawFlag(flags);
1708
1709         R_Mesh_VertexPointer(mesh->data_vertex3f, 0, 0);
1710         R_Mesh_ColorPointer(mesh->data_color4f, 0, 0);
1711         R_Mesh_ResetTextureState();
1712         R_Mesh_TexCoordPointer(0, 2, mesh->data_texcoord2f, 0, 0);
1713         R_SetupShader_Generic(mesh->texture, NULL, GL_MODULATE, 1);
1714
1715         R_Mesh_Draw(0, mesh->num_vertices, 0, mesh->num_triangles, mesh->data_element3i, mesh->data_element3s, 0, 0);
1716 }
1717
1718 void DrawQ_LineLoop (drawqueuemesh_t *mesh, int flags)
1719 {
1720         int num;
1721
1722         _DrawQ_ProcessDrawFlag(flags);
1723
1724         GL_Color(1,1,1,1);
1725         CHECKGLERROR
1726         qglBegin(GL_LINE_LOOP);
1727         for (num = 0;num < mesh->num_vertices;num++)
1728         {
1729                 if (mesh->data_color4f)
1730                         GL_Color(mesh->data_color4f[num*4+0], mesh->data_color4f[num*4+1], mesh->data_color4f[num*4+2], mesh->data_color4f[num*4+3]);
1731                 qglVertex2f(mesh->data_vertex3f[num*3+0], mesh->data_vertex3f[num*3+1]);
1732         }
1733         qglEnd();
1734         CHECKGLERROR
1735 }
1736
1737 //[515]: this is old, delete
1738 void DrawQ_Line (float width, float x1, float y1, float x2, float y2, float r, float g, float b, float alpha, int flags)
1739 {
1740         _DrawQ_ProcessDrawFlag(flags);
1741
1742         R_SetupShader_Generic(NULL, NULL, GL_MODULATE, 1);
1743
1744         CHECKGLERROR
1745         //qglLineWidth(width);CHECKGLERROR
1746
1747         GL_Color(r,g,b,alpha);
1748         CHECKGLERROR
1749         qglBegin(GL_LINES);
1750         qglVertex2f(x1, y1);
1751         qglVertex2f(x2, y2);
1752         qglEnd();
1753         CHECKGLERROR
1754 }
1755
1756 void DrawQ_SetClipArea(float x, float y, float width, float height)
1757 {
1758         int ix, iy, iw, ih;
1759         _DrawQ_Setup();
1760
1761         // We have to convert the con coords into real coords
1762         // OGL uses top to bottom
1763         ix = (int)(0.5 + x * ((float)vid.width / vid_conwidth.integer));
1764         iy = (int)(0.5 + y * ((float) vid.height / vid_conheight.integer));
1765         iw = (int)(width * ((float)vid.width / vid_conwidth.integer));
1766         ih = (int)(height * ((float)vid.height / vid_conheight.integer));
1767         GL_Scissor(ix, vid.height - iy - ih, iw, ih);
1768
1769         GL_ScissorTest(true);
1770 }
1771
1772 void DrawQ_ResetClipArea(void)
1773 {
1774         _DrawQ_Setup();
1775         GL_ScissorTest(false);
1776 }
1777
1778 void DrawQ_Finish(void)
1779 {
1780         r_refdef.draw2dstage = false;
1781 }
1782
1783 static float blendvertex3f[9] = {-5000, -5000, 10, 10000, -5000, 10, -5000, 10000, 10};
1784 void R_DrawGamma(void)
1785 {
1786         float c[4];
1787         switch(vid.renderpath)
1788         {
1789         case RENDERPATH_GL20:
1790         case RENDERPATH_CGGL:
1791                 if (vid_usinghwgamma || v_glslgamma.integer)
1792                         return;
1793                 break;
1794         case RENDERPATH_GL13:
1795         case RENDERPATH_GL11:
1796                 if (vid_usinghwgamma)
1797                         return;
1798                 break;
1799         }
1800         // all the blends ignore depth
1801         R_Mesh_VertexPointer(blendvertex3f, 0, 0);
1802         R_Mesh_ColorPointer(NULL, 0, 0);
1803         R_Mesh_ResetTextureState();
1804         R_SetupShader_Generic(NULL, NULL, GL_MODULATE, 1);
1805         GL_DepthMask(true);
1806         GL_DepthRange(0, 1);
1807         GL_PolygonOffset(0, 0);
1808         GL_DepthTest(false);
1809         if (v_color_enable.integer)
1810         {
1811                 c[0] = v_color_white_r.value;
1812                 c[1] = v_color_white_g.value;
1813                 c[2] = v_color_white_b.value;
1814         }
1815         else
1816                 c[0] = c[1] = c[2] = v_contrast.value;
1817         if (c[0] >= 1.01f || c[1] >= 1.01f || c[2] >= 1.01f)
1818         {
1819                 GL_BlendFunc(GL_DST_COLOR, GL_ONE);
1820                 while (c[0] >= 1.01f || c[1] >= 1.01f || c[2] >= 1.01f)
1821                 {
1822                         GL_Color(bound(0, c[0] - 1, 1), bound(0, c[1] - 1, 1), bound(0, c[2] - 1, 1), 1);
1823                         R_Mesh_Draw(0, 3, 0, 1, polygonelement3i, polygonelement3s, 0, 0);
1824                         VectorScale(c, 0.5, c);
1825                 }
1826         }
1827         if (v_color_enable.integer)
1828         {
1829                 c[0] = v_color_black_r.value;
1830                 c[1] = v_color_black_g.value;
1831                 c[2] = v_color_black_b.value;
1832         }
1833         else
1834                 c[0] = c[1] = c[2] = v_brightness.value;
1835         if (c[0] >= 0.01f || c[1] >= 0.01f || c[2] >= 0.01f)
1836         {
1837                 GL_BlendFunc(GL_ONE, GL_ONE);
1838                 GL_Color(c[0], c[1], c[2], 1);
1839                 R_Mesh_Draw(0, 3, 0, 1, polygonelement3i, polygonelement3s, 0, 0);
1840         }
1841 }
1842