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 || map->start < ch || map->start + FONT_CHARS_PER_MAP >= ch)
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                                                         GL_LockArrays(0, batchcount * 4);
1471                                                         R_Mesh_Draw(0, batchcount * 4, 0, batchcount * 2, quadelement3i, quadelement3s, 0, 0);
1472                                                         GL_LockArrays(0, 0);
1473                                                         batchcount = 0;
1474                                                         ac = color4f;
1475                                                         at = texcoord2f;
1476                                                         av = vertex3f;
1477                                                 }
1478                                                 R_SetupShader_Generic(fnt->tex, NULL, GL_MODULATE, 1);
1479                                                 map = ft2_oldstyle_map;
1480                                         }
1481                                 }
1482                                 prevch = 0;
1483                                 //num = (unsigned char) text[i];
1484                                 //thisw = fnt->width_of[num];
1485                                 thisw = fnt->width_of[ch];
1486                                 // FIXME make these smaller to just include the occupied part of the character for slightly faster rendering
1487                                 s = (ch & 15)*0.0625f + (0.5f / tw);
1488                                 t = (ch >> 4)*0.0625f + (0.5f / th);
1489                                 u = 0.0625f * thisw - (1.0f / tw);
1490                                 v = 0.0625f - (1.0f / th);
1491                                 ac[ 0] = color[0];ac[ 1] = color[1];ac[ 2] = color[2];ac[ 3] = color[3];
1492                                 ac[ 4] = color[0];ac[ 5] = color[1];ac[ 6] = color[2];ac[ 7] = color[3];
1493                                 ac[ 8] = color[0];ac[ 9] = color[1];ac[10] = color[2];ac[11] = color[3];
1494                                 ac[12] = color[0];ac[13] = color[1];ac[14] = color[2];ac[15] = color[3];
1495                                 at[ 0] = s              ; at[ 1] = t    ;
1496                                 at[ 2] = s+u    ; at[ 3] = t    ;
1497                                 at[ 4] = s+u    ; at[ 5] = t+v  ;
1498                                 at[ 6] = s              ; at[ 7] = t+v  ;
1499                                 av[ 0] = x                      ; av[ 1] = y    ; av[ 2] = 10;
1500                                 av[ 3] = x+dw*thisw     ; av[ 4] = y    ; av[ 5] = 10;
1501                                 av[ 6] = x+dw*thisw     ; av[ 7] = y+dh ; av[ 8] = 10;
1502                                 av[ 9] = x                      ; av[10] = y+dh ; av[11] = 10;
1503                                 ac += 16;
1504                                 at += 8;
1505                                 av += 12;
1506                                 batchcount++;
1507                                 if (batchcount >= QUADELEMENTS_MAXQUADS)
1508                                 {
1509                                         GL_LockArrays(0, batchcount * 4);
1510                                         R_Mesh_Draw(0, batchcount * 4, 0, batchcount * 2, quadelement3i, quadelement3s, 0, 0);
1511                                         GL_LockArrays(0, 0);
1512                                         batchcount = 0;
1513                                         ac = color4f;
1514                                         at = texcoord2f;
1515                                         av = vertex3f;
1516                                 }
1517                                 x += width_of[ch] * dw;
1518                         } else {
1519                                 if (!map || map == ft2_oldstyle_map || map->start < ch || map->start + FONT_CHARS_PER_MAP >= ch)
1520                                 {
1521                                         // new charmap - need to render
1522                                         if (batchcount)
1523                                         {
1524                                                 // we need a different character map, render what we currently have:
1525                                                 GL_LockArrays(0, batchcount * 4);
1526                                                 R_Mesh_Draw(0, batchcount * 4, 0, batchcount * 2, quadelement3i, quadelement3s, 0, 0);
1527                                                 GL_LockArrays(0, 0);
1528                                                 batchcount = 0;
1529                                                 ac = color4f;
1530                                                 at = texcoord2f;
1531                                                 av = vertex3f;
1532                                         }
1533                                         // find the new map
1534                                         map = FontMap_FindForChar(fontmap, ch);
1535                                         if (!map)
1536                                         {
1537                                                 if (!Font_LoadMapForIndex(ft2, map_index, ch, &map))
1538                                                 {
1539                                                         shadow = -1;
1540                                                         break;
1541                                                 }
1542                                                 if (!map)
1543                                                 {
1544                                                         // this shouldn't happen
1545                                                         shadow = -1;
1546                                                         break;
1547                                                 }
1548                                         }
1549                                         R_SetupShader_Generic(map->texture, NULL, GL_MODULATE, 1);
1550                                 }
1551
1552                                 mapch = ch - map->start;
1553                                 thisw = map->glyphs[mapch].advance_x;
1554
1555                                 //x += ftbase_x;
1556                                 y += ftbase_y;
1557                                 if (prevch && Font_GetKerningForMap(ft2, map_index, w, h, prevch, ch, &kx, &ky))
1558                                 {
1559                                         x += kx * dw;
1560                                         y += ky * dh;
1561                                 }
1562                                 else
1563                                         kx = ky = 0;
1564                                 ac[ 0] = color[0]; ac[ 1] = color[1]; ac[ 2] = color[2]; ac[ 3] = color[3];
1565                                 ac[ 4] = color[0]; ac[ 5] = color[1]; ac[ 6] = color[2]; ac[ 7] = color[3];
1566                                 ac[ 8] = color[0]; ac[ 9] = color[1]; ac[10] = color[2]; ac[11] = color[3];
1567                                 ac[12] = color[0]; ac[13] = color[1]; ac[14] = color[2]; ac[15] = color[3];
1568                                 at[0] = map->glyphs[mapch].txmin; at[1] = map->glyphs[mapch].tymin;
1569                                 at[2] = map->glyphs[mapch].txmax; at[3] = map->glyphs[mapch].tymin;
1570                                 at[4] = map->glyphs[mapch].txmax; at[5] = map->glyphs[mapch].tymax;
1571                                 at[6] = map->glyphs[mapch].txmin; at[7] = map->glyphs[mapch].tymax;
1572                                 av[ 0] = x + dw * map->glyphs[mapch].vxmin; av[ 1] = y + dh * map->glyphs[mapch].vymin; av[ 2] = 10;
1573                                 av[ 3] = x + dw * map->glyphs[mapch].vxmax; av[ 4] = y + dh * map->glyphs[mapch].vymin; av[ 5] = 10;
1574                                 av[ 6] = x + dw * map->glyphs[mapch].vxmax; av[ 7] = y + dh * map->glyphs[mapch].vymax; av[ 8] = 10;
1575                                 av[ 9] = x + dw * map->glyphs[mapch].vxmin; av[10] = y + dh * map->glyphs[mapch].vymax; av[11] = 10;
1576                                 //x -= ftbase_x;
1577                                 y -= ftbase_y;
1578
1579                                 x += thisw * dw;
1580                                 ac += 16;
1581                                 at += 8;
1582                                 av += 12;
1583                                 batchcount++;
1584                                 if (batchcount >= QUADELEMENTS_MAXQUADS)
1585                                 {
1586                                         GL_LockArrays(0, batchcount * 4);
1587                                         R_Mesh_Draw(0, batchcount * 4, 0, batchcount * 2, quadelement3i, quadelement3s, 0, 0);
1588                                         GL_LockArrays(0, 0);
1589                                         batchcount = 0;
1590                                         ac = color4f;
1591                                         at = texcoord2f;
1592                                         av = vertex3f;
1593                                 }
1594
1595                                 prevmap = map;
1596                                 prevch = ch;
1597                         }
1598                         if (shadow)
1599                         {
1600                                 x -= 1.0/pix_x * r_textshadow.value;
1601                                 y -= 1.0/pix_y * r_textshadow.value;
1602                         }
1603                 }
1604         }
1605         if (batchcount > 0)
1606         {
1607                 GL_LockArrays(0, batchcount * 4);
1608                 R_Mesh_Draw(0, batchcount * 4, 0, batchcount * 2, quadelement3i, quadelement3s, 0, 0);
1609                 GL_LockArrays(0, 0);
1610         }
1611
1612         if (outcolor)
1613                 *outcolor = colorindex;
1614
1615         // note: this relies on the proper text (not shadow) being drawn last
1616         return x;
1617 }
1618
1619 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)
1620 {
1621         return DrawQ_String_Scale(startx, starty, text, maxlen, w, h, 1, 1, basered, basegreen, baseblue, basealpha, flags, outcolor, ignorecolorcodes, fnt);
1622 }
1623
1624 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)
1625 {
1626         return DrawQ_TextWidth_UntilWidth_TrackColors_Scale(text, maxlen, w, h, 1, 1, outcolor, ignorecolorcodes, fnt, maxwidth);
1627 }
1628
1629 float DrawQ_TextWidth(const char *text, size_t maxlen, float w, float h, qboolean ignorecolorcodes, const dp_font_t *fnt)
1630 {
1631         return DrawQ_TextWidth_UntilWidth(text, &maxlen, w, h, ignorecolorcodes, fnt, 1000000000);
1632 }
1633
1634 float DrawQ_TextWidth_UntilWidth(const char *text, size_t *maxlen, float w, float h, qboolean ignorecolorcodes, const dp_font_t *fnt, float maxWidth)
1635 {
1636         return DrawQ_TextWidth_UntilWidth_TrackColors(text, maxlen, w, h, NULL, ignorecolorcodes, fnt, maxWidth);
1637 }
1638
1639 #if 0
1640 // not used
1641 // no ^xrgb management
1642 static int DrawQ_BuildColoredText(char *output2c, size_t maxoutchars, const char *text, int maxreadchars, qboolean ignorecolorcodes, int *outcolor)
1643 {
1644         int color, numchars = 0;
1645         char *outputend2c = output2c + maxoutchars - 2;
1646         if (!outcolor || *outcolor == -1)
1647                 color = STRING_COLOR_DEFAULT;
1648         else
1649                 color = *outcolor;
1650         if (!maxreadchars)
1651                 maxreadchars = 1<<30;
1652         textend = text + maxreadchars;
1653         while (text != textend && *text)
1654         {
1655                 if (*text == STRING_COLOR_TAG && !ignorecolorcodes && text + 1 != textend)
1656                 {
1657                         if (text[1] == STRING_COLOR_TAG)
1658                                 text++;
1659                         else if (text[1] >= '0' && text[1] <= '9')
1660                         {
1661                                 color = text[1] - '0';
1662                                 text += 2;
1663                                 continue;
1664                         }
1665                 }
1666                 if (output2c >= outputend2c)
1667                         break;
1668                 *output2c++ = *text++;
1669                 *output2c++ = color;
1670                 numchars++;
1671         }
1672         output2c[0] = output2c[1] = 0;
1673         if (outcolor)
1674                 *outcolor = color;
1675         return numchars;
1676 }
1677 #endif
1678
1679 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)
1680 {
1681         float floats[36];
1682
1683         _DrawQ_ProcessDrawFlag(flags);
1684
1685         R_Mesh_VertexPointer(floats, 0, 0);
1686         R_Mesh_ColorPointer(floats + 20, 0, 0);
1687         R_Mesh_ResetTextureState();
1688         if (pic)
1689         {
1690                 if (width == 0)
1691                         width = pic->width;
1692                 if (height == 0)
1693                         height = pic->height;
1694                 R_SetupShader_Generic(Draw_GetPicTexture(pic), NULL, GL_MODULATE, 1);
1695                 R_Mesh_TexCoordPointer(0, 2, floats + 12, 0, 0);
1696                 floats[12] = s1;floats[13] = t1;
1697                 floats[14] = s2;floats[15] = t2;
1698                 floats[16] = s4;floats[17] = t4;
1699                 floats[18] = s3;floats[19] = t3;
1700         }
1701         else
1702                 R_SetupShader_Generic(NULL, NULL, GL_MODULATE, 1);
1703
1704         floats[2] = floats[5] = floats[8] = floats[11] = 0;
1705         floats[0] = floats[9] = x;
1706         floats[1] = floats[4] = y;
1707         floats[3] = floats[6] = x + width;
1708         floats[7] = floats[10] = y + height;
1709         floats[20] = r1;floats[21] = g1;floats[22] = b1;floats[23] = a1;
1710         floats[24] = r2;floats[25] = g2;floats[26] = b2;floats[27] = a2;
1711         floats[28] = r4;floats[29] = g4;floats[30] = b4;floats[31] = a4;
1712         floats[32] = r3;floats[33] = g3;floats[34] = b3;floats[35] = a3;
1713
1714         R_Mesh_Draw(0, 4, 0, 2, polygonelement3i, polygonelement3s, 0, 0);
1715 }
1716
1717 void DrawQ_Mesh (drawqueuemesh_t *mesh, int flags)
1718 {
1719         _DrawQ_ProcessDrawFlag(flags);
1720
1721         R_Mesh_VertexPointer(mesh->data_vertex3f, 0, 0);
1722         R_Mesh_ColorPointer(mesh->data_color4f, 0, 0);
1723         R_Mesh_ResetTextureState();
1724         R_Mesh_TexCoordPointer(0, 2, mesh->data_texcoord2f, 0, 0);
1725         R_SetupShader_Generic(mesh->texture, NULL, GL_MODULATE, 1);
1726
1727         GL_LockArrays(0, mesh->num_vertices);
1728         R_Mesh_Draw(0, mesh->num_vertices, 0, mesh->num_triangles, mesh->data_element3i, mesh->data_element3s, 0, 0);
1729         GL_LockArrays(0, 0);
1730 }
1731
1732 void DrawQ_LineLoop (drawqueuemesh_t *mesh, int flags)
1733 {
1734         int num;
1735
1736         _DrawQ_ProcessDrawFlag(flags);
1737
1738         GL_Color(1,1,1,1);
1739         CHECKGLERROR
1740         qglBegin(GL_LINE_LOOP);
1741         for (num = 0;num < mesh->num_vertices;num++)
1742         {
1743                 if (mesh->data_color4f)
1744                         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]);
1745                 qglVertex2f(mesh->data_vertex3f[num*3+0], mesh->data_vertex3f[num*3+1]);
1746         }
1747         qglEnd();
1748         CHECKGLERROR
1749 }
1750
1751 //[515]: this is old, delete
1752 void DrawQ_Line (float width, float x1, float y1, float x2, float y2, float r, float g, float b, float alpha, int flags)
1753 {
1754         _DrawQ_ProcessDrawFlag(flags);
1755
1756         R_SetupShader_Generic(NULL, NULL, GL_MODULATE, 1);
1757
1758         CHECKGLERROR
1759         //qglLineWidth(width);CHECKGLERROR
1760
1761         GL_Color(r,g,b,alpha);
1762         CHECKGLERROR
1763         qglBegin(GL_LINES);
1764         qglVertex2f(x1, y1);
1765         qglVertex2f(x2, y2);
1766         qglEnd();
1767         CHECKGLERROR
1768 }
1769
1770 void DrawQ_SetClipArea(float x, float y, float width, float height)
1771 {
1772         int ix, iy, iw, ih;
1773         _DrawQ_Setup();
1774
1775         // We have to convert the con coords into real coords
1776         // OGL uses top to bottom
1777         ix = (int)(0.5 + x * ((float)vid.width / vid_conwidth.integer));
1778         iy = (int)(0.5 + y * ((float) vid.height / vid_conheight.integer));
1779         iw = (int)(width * ((float)vid.width / vid_conwidth.integer));
1780         ih = (int)(height * ((float)vid.height / vid_conheight.integer));
1781         GL_Scissor(ix, vid.height - iy - ih, iw, ih);
1782
1783         GL_ScissorTest(true);
1784 }
1785
1786 void DrawQ_ResetClipArea(void)
1787 {
1788         _DrawQ_Setup();
1789         GL_ScissorTest(false);
1790 }
1791
1792 void DrawQ_Finish(void)
1793 {
1794         r_refdef.draw2dstage = false;
1795 }
1796
1797 static float blendvertex3f[9] = {-5000, -5000, 10, 10000, -5000, 10, -5000, 10000, 10};
1798 void R_DrawGamma(void)
1799 {
1800         float c[4];
1801         switch(vid.renderpath)
1802         {
1803         case RENDERPATH_GL20:
1804         case RENDERPATH_CGGL:
1805                 if (vid_usinghwgamma || v_glslgamma.integer)
1806                         return;
1807                 break;
1808         case RENDERPATH_GL13:
1809         case RENDERPATH_GL11:
1810                 if (vid_usinghwgamma)
1811                         return;
1812                 break;
1813         }
1814         // all the blends ignore depth
1815         R_Mesh_VertexPointer(blendvertex3f, 0, 0);
1816         R_Mesh_ColorPointer(NULL, 0, 0);
1817         R_Mesh_ResetTextureState();
1818         R_SetupShader_Generic(NULL, NULL, GL_MODULATE, 1);
1819         GL_DepthMask(true);
1820         GL_DepthRange(0, 1);
1821         GL_PolygonOffset(0, 0);
1822         GL_DepthTest(false);
1823         if (v_color_enable.integer)
1824         {
1825                 c[0] = v_color_white_r.value;
1826                 c[1] = v_color_white_g.value;
1827                 c[2] = v_color_white_b.value;
1828         }
1829         else
1830                 c[0] = c[1] = c[2] = v_contrast.value;
1831         if (c[0] >= 1.01f || c[1] >= 1.01f || c[2] >= 1.01f)
1832         {
1833                 GL_BlendFunc(GL_DST_COLOR, GL_ONE);
1834                 while (c[0] >= 1.01f || c[1] >= 1.01f || c[2] >= 1.01f)
1835                 {
1836                         GL_Color(bound(0, c[0] - 1, 1), bound(0, c[1] - 1, 1), bound(0, c[2] - 1, 1), 1);
1837                         R_Mesh_Draw(0, 3, 0, 1, polygonelement3i, polygonelement3s, 0, 0);
1838                         VectorScale(c, 0.5, c);
1839                 }
1840         }
1841         if (v_color_enable.integer)
1842         {
1843                 c[0] = v_color_black_r.value;
1844                 c[1] = v_color_black_g.value;
1845                 c[2] = v_color_black_b.value;
1846         }
1847         else
1848                 c[0] = c[1] = c[2] = v_brightness.value;
1849         if (c[0] >= 0.01f || c[1] >= 0.01f || c[2] >= 0.01f)
1850         {
1851                 GL_BlendFunc(GL_ONE, GL_ONE);
1852                 GL_Color(c[0], c[1], c[2], 1);
1853                 R_Mesh_Draw(0, 3, 0, 1, polygonelement3i, polygonelement3s, 0, 0);
1854         }
1855 }
1856