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                         if (!map || map == ft2_oldstyle_map || ch < map->start || ch >= map->start + FONT_CHARS_PER_MAP)
1246                         {
1247                                 map = FontMap_FindForChar(fontmap, ch);
1248                                 if (!map)
1249                                 {
1250                                         if (!Font_LoadMapForIndex(ft2, map_index, ch, &map))
1251                                                 break;
1252                                         if (!map)
1253                                                 break;
1254                                 }
1255                         }
1256                         mapch = ch - map->start;
1257                         if (prevch && Font_GetKerningForMap(ft2, map_index, w, h, prevch, ch, &kx, NULL))
1258                                 x += kx * dw;
1259                         x += map->glyphs[mapch].advance_x * dw;
1260                         prevmap = map;
1261                         prevch = ch;
1262                 }
1263         }
1264
1265         *maxlen = i;
1266
1267         if (outcolor)
1268                 *outcolor = colorindex;
1269
1270         return x;
1271 }
1272
1273 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)
1274 {
1275         int shadow, colorindex = STRING_COLOR_DEFAULT;
1276         size_t i;
1277         float x = startx, y, s, t, u, v, thisw;
1278         float *av, *at, *ac;
1279         float color[4];
1280         int batchcount;
1281         static float vertex3f[QUADELEMENTS_MAXQUADS*4*3];
1282         static float texcoord2f[QUADELEMENTS_MAXQUADS*4*2];
1283         static float color4f[QUADELEMENTS_MAXQUADS*4*4];
1284         Uchar ch, mapch, nextch;
1285         Uchar prevch = 0; // used for kerning
1286         int tempcolorindex;
1287         int map_index = 0;
1288         ft2_font_map_t *prevmap = NULL; // the previous map
1289         ft2_font_map_t *map = NULL;     // the currently used map
1290         ft2_font_map_t *fontmap = NULL; // the font map for the size
1291         float ftbase_y;
1292         const char *text_start = text;
1293         float kx, ky;
1294         ft2_font_t *ft2 = fnt->ft2;
1295         qboolean snap = true;
1296         float pix_x, pix_y;
1297         size_t bytes_left;
1298         float dw, dh;
1299         const float *width_of;
1300
1301         int tw, th;
1302         tw = R_TextureWidth(fnt->tex);
1303         th = R_TextureHeight(fnt->tex);
1304
1305         if (!h) h = w;
1306         if (!h) {
1307                 h = w = 1;
1308                 snap = false;
1309         }
1310
1311         starty -= (fnt->scale - 1) * h * 0.5; // center
1312         w *= fnt->scale;
1313         h *= fnt->scale;
1314
1315         if (ft2 != NULL)
1316         {
1317                 if (snap)
1318                         map_index = Font_IndexForSize(ft2, h, &w, &h);
1319                 else
1320                         map_index = Font_IndexForSize(ft2, h, NULL, NULL);
1321                 fontmap = Font_MapForIndex(ft2, map_index);
1322         }
1323
1324         dw = w * sw;
1325         dh = h * sh;
1326
1327         // draw the font at its baseline when using freetype
1328         //ftbase_x = 0;
1329         ftbase_y = dh * (4.5/6.0);
1330
1331         if (maxlen < 1)
1332                 maxlen = 1<<30;
1333
1334         _DrawQ_ProcessDrawFlag(flags);
1335
1336         R_Mesh_ColorPointer(color4f, 0, 0);
1337         R_Mesh_ResetTextureState();
1338         if (!fontmap)
1339                 R_Mesh_TexBind(0, fnt->tex);
1340         R_Mesh_TexCoordPointer(0, 2, texcoord2f, 0, 0);
1341         R_Mesh_VertexPointer(vertex3f, 0, 0);
1342         R_SetupShader_Generic(fnt->tex, NULL, GL_MODULATE, 1);
1343
1344         ac = color4f;
1345         at = texcoord2f;
1346         av = vertex3f;
1347         batchcount = 0;
1348
1349         //ftbase_x = snap_to_pixel_x(ftbase_x);
1350         if(snap)
1351         {
1352                 startx = snap_to_pixel_x(startx, 0.4);
1353                 starty = snap_to_pixel_y(starty, 0.4);
1354                 ftbase_y = snap_to_pixel_y(ftbase_y, 0.3);
1355         }
1356
1357         pix_x = vid.width / vid_conwidth.value;
1358         pix_y = vid.height / vid_conheight.value;
1359
1360         if (fontmap)
1361                 width_of = fontmap->width_of;
1362         else
1363                 width_of = fnt->width_of;
1364
1365         for (shadow = r_textshadow.value != 0 && basealpha > 0;shadow >= 0;shadow--)
1366         {
1367                 prevch = 0;
1368                 text = text_start;
1369
1370                 if (!outcolor || *outcolor == -1)
1371                         colorindex = STRING_COLOR_DEFAULT;
1372                 else
1373                         colorindex = *outcolor;
1374
1375                 DrawQ_GetTextColor(color, colorindex, basered, basegreen, baseblue, basealpha, shadow != 0);
1376
1377                 x = startx;
1378                 y = starty;
1379                 /*
1380                 if (shadow)
1381                 {
1382                         x += r_textshadow.value * vid.width / vid_conwidth.value;
1383                         y += r_textshadow.value * vid.height / vid_conheight.value;
1384                 }
1385                 */
1386                 for (i = 0;((bytes_left = maxlen - (text - text_start)) > 0) && *text;)
1387                 {
1388                         nextch = ch = u8_getnchar(text, &text, bytes_left);
1389                         i = text - text_start;
1390                         if (!ch)
1391                                 break;
1392                         if (ch == ' ' && !fontmap)
1393                         {
1394                                 x += width_of[(int) ' '] * dw;
1395                                 continue;
1396                         }
1397                         if (ch == STRING_COLOR_TAG && !ignorecolorcodes && i < maxlen)
1398                         {
1399                                 ch = *text; // colors are ascii, so no u8_ needed
1400                                 if (ch <= '9' && ch >= '0') // ^[0-9] found
1401                                 {
1402                                         colorindex = ch - '0';
1403                                         DrawQ_GetTextColor(color, colorindex, basered, basegreen, baseblue, basealpha, shadow != 0);
1404                                         ++text;
1405                                         ++i;
1406                                         continue;
1407                                 }
1408                                 else if (ch == STRING_COLOR_RGB_TAG_CHAR && i+3 < maxlen ) // ^x found
1409                                 {
1410                                         // building colorindex...
1411                                         ch = tolower(text[1]);
1412                                         tempcolorindex = 0x10000; // binary: 1,0000,0000,0000,0000
1413                                         if (ch <= '9' && ch >= '0') tempcolorindex |= (ch - '0') << 12;
1414                                         else if (ch >= 'a' && ch <= 'f') tempcolorindex |= (ch - 87) << 12;
1415                                         else tempcolorindex = 0;
1416                                         if (tempcolorindex)
1417                                         {
1418                                                 ch = tolower(text[2]);
1419                                                 if (ch <= '9' && ch >= '0') tempcolorindex |= (ch - '0') << 8;
1420                                                 else if (ch >= 'a' && ch <= 'f') tempcolorindex |= (ch - 87) << 8;
1421                                                 else tempcolorindex = 0;
1422                                                 if (tempcolorindex)
1423                                                 {
1424                                                         ch = tolower(text[3]);
1425                                                         if (ch <= '9' && ch >= '0') tempcolorindex |= (ch - '0') << 4;
1426                                                         else if (ch >= 'a' && ch <= 'f') tempcolorindex |= (ch - 87) << 4;
1427                                                         else tempcolorindex = 0;
1428                                                         if (tempcolorindex)
1429                                                         {
1430                                                                 colorindex = tempcolorindex | 0xf;
1431                                                                 // ...done! now colorindex has rgba codes (1,rrrr,gggg,bbbb,aaaa)
1432                                                                 //Con_Printf("^1colorindex:^7 %x\n", colorindex);
1433                                                                 DrawQ_GetTextColor(color, colorindex, basered, basegreen, baseblue, basealpha, shadow != 0);
1434                                                                 i+=4;
1435                                                                 text+=4;
1436                                                                 continue;
1437                                                         }
1438                                                 }
1439                                         }
1440                                 }
1441                                 else if (ch == STRING_COLOR_TAG)
1442                                 {
1443                                         i++;
1444                                         text++;
1445                                 }
1446                                 i--;
1447                         }
1448                         // get the backup
1449                         ch = nextch;
1450                         // using a value of -1 for the oldstyle map because NULL means uninitialized...
1451                         // this way we don't need to rebind fnt->tex for every old-style character
1452                         // E000..E0FF: emulate old-font characters (to still have smileys and such available)
1453                         if (shadow)
1454                         {
1455                                 x += 1.0/pix_x * r_textshadow.value;
1456                                 y += 1.0/pix_y * r_textshadow.value;
1457                         }
1458                         if (!fontmap || (ch <= 0xFF && fontmap->glyphs[ch].image) || (ch >= 0xE000 && ch <= 0xE0FF))
1459                         {
1460                                 if (ch > 0xE000)
1461                                         ch -= 0xE000;
1462                                 if (ch > 0xFF)
1463                                         continue;
1464                                 if (fontmap)
1465                                 {
1466                                         if (map != ft2_oldstyle_map)
1467                                         {
1468                                                 if (batchcount)
1469                                                 {
1470                                                         // switching from freetype to non-freetype rendering
1471                                                         R_Mesh_Draw(0, batchcount * 4, 0, batchcount * 2, quadelement3i, quadelement3s, 0, 0);
1472                                                         batchcount = 0;
1473                                                         ac = color4f;
1474                                                         at = texcoord2f;
1475                                                         av = vertex3f;
1476                                                 }
1477                                                 R_SetupShader_Generic(fnt->tex, NULL, GL_MODULATE, 1);
1478                                                 map = ft2_oldstyle_map;
1479                                         }
1480                                 }
1481                                 prevch = 0;
1482                                 //num = (unsigned char) text[i];
1483                                 //thisw = fnt->width_of[num];
1484                                 thisw = fnt->width_of[ch];
1485                                 // FIXME make these smaller to just include the occupied part of the character for slightly faster rendering
1486                                 s = (ch & 15)*0.0625f + (0.5f / tw);
1487                                 t = (ch >> 4)*0.0625f + (0.5f / th);
1488                                 u = 0.0625f * thisw - (1.0f / tw);
1489                                 v = 0.0625f - (1.0f / th);
1490                                 ac[ 0] = color[0];ac[ 1] = color[1];ac[ 2] = color[2];ac[ 3] = color[3];
1491                                 ac[ 4] = color[0];ac[ 5] = color[1];ac[ 6] = color[2];ac[ 7] = color[3];
1492                                 ac[ 8] = color[0];ac[ 9] = color[1];ac[10] = color[2];ac[11] = color[3];
1493                                 ac[12] = color[0];ac[13] = color[1];ac[14] = color[2];ac[15] = color[3];
1494                                 at[ 0] = s              ; at[ 1] = t    ;
1495                                 at[ 2] = s+u    ; at[ 3] = t    ;
1496                                 at[ 4] = s+u    ; at[ 5] = t+v  ;
1497                                 at[ 6] = s              ; at[ 7] = t+v  ;
1498                                 av[ 0] = x                      ; av[ 1] = y    ; av[ 2] = 10;
1499                                 av[ 3] = x+dw*thisw     ; av[ 4] = y    ; av[ 5] = 10;
1500                                 av[ 6] = x+dw*thisw     ; av[ 7] = y+dh ; av[ 8] = 10;
1501                                 av[ 9] = x                      ; av[10] = y+dh ; av[11] = 10;
1502                                 ac += 16;
1503                                 at += 8;
1504                                 av += 12;
1505                                 batchcount++;
1506                                 if (batchcount >= QUADELEMENTS_MAXQUADS)
1507                                 {
1508                                         R_Mesh_Draw(0, batchcount * 4, 0, batchcount * 2, quadelement3i, quadelement3s, 0, 0);
1509                                         batchcount = 0;
1510                                         ac = color4f;
1511                                         at = texcoord2f;
1512                                         av = vertex3f;
1513                                 }
1514                                 x += width_of[ch] * dw;
1515                         } else {
1516                                 if (!map || map == ft2_oldstyle_map || map->start < ch || map->start + FONT_CHARS_PER_MAP >= ch)
1517                                 {
1518                                         // new charmap - need to render
1519                                         if (batchcount)
1520                                         {
1521                                                 // we need a different character map, render what we currently have:
1522                                                 R_Mesh_Draw(0, batchcount * 4, 0, batchcount * 2, quadelement3i, quadelement3s, 0, 0);
1523                                                 batchcount = 0;
1524                                                 ac = color4f;
1525                                                 at = texcoord2f;
1526                                                 av = vertex3f;
1527                                         }
1528                                         // find the new map
1529                                         map = FontMap_FindForChar(fontmap, ch);
1530                                         if (!map)
1531                                         {
1532                                                 if (!Font_LoadMapForIndex(ft2, map_index, ch, &map))
1533                                                 {
1534                                                         shadow = -1;
1535                                                         break;
1536                                                 }
1537                                                 if (!map)
1538                                                 {
1539                                                         // this shouldn't happen
1540                                                         shadow = -1;
1541                                                         break;
1542                                                 }
1543                                         }
1544                                         R_SetupShader_Generic(map->texture, NULL, GL_MODULATE, 1);
1545                                 }
1546
1547                                 mapch = ch - map->start;
1548                                 thisw = map->glyphs[mapch].advance_x;
1549
1550                                 //x += ftbase_x;
1551                                 y += ftbase_y;
1552                                 if (prevch && Font_GetKerningForMap(ft2, map_index, w, h, prevch, ch, &kx, &ky))
1553                                 {
1554                                         x += kx * dw;
1555                                         y += ky * dh;
1556                                 }
1557                                 else
1558                                         kx = ky = 0;
1559                                 ac[ 0] = color[0]; ac[ 1] = color[1]; ac[ 2] = color[2]; ac[ 3] = color[3];
1560                                 ac[ 4] = color[0]; ac[ 5] = color[1]; ac[ 6] = color[2]; ac[ 7] = color[3];
1561                                 ac[ 8] = color[0]; ac[ 9] = color[1]; ac[10] = color[2]; ac[11] = color[3];
1562                                 ac[12] = color[0]; ac[13] = color[1]; ac[14] = color[2]; ac[15] = color[3];
1563                                 at[0] = map->glyphs[mapch].txmin; at[1] = map->glyphs[mapch].tymin;
1564                                 at[2] = map->glyphs[mapch].txmax; at[3] = map->glyphs[mapch].tymin;
1565                                 at[4] = map->glyphs[mapch].txmax; at[5] = map->glyphs[mapch].tymax;
1566                                 at[6] = map->glyphs[mapch].txmin; at[7] = map->glyphs[mapch].tymax;
1567                                 av[ 0] = x + dw * map->glyphs[mapch].vxmin; av[ 1] = y + dh * map->glyphs[mapch].vymin; av[ 2] = 10;
1568                                 av[ 3] = x + dw * map->glyphs[mapch].vxmax; av[ 4] = y + dh * map->glyphs[mapch].vymin; av[ 5] = 10;
1569                                 av[ 6] = x + dw * map->glyphs[mapch].vxmax; av[ 7] = y + dh * map->glyphs[mapch].vymax; av[ 8] = 10;
1570                                 av[ 9] = x + dw * map->glyphs[mapch].vxmin; av[10] = y + dh * map->glyphs[mapch].vymax; av[11] = 10;
1571                                 //x -= ftbase_x;
1572                                 y -= ftbase_y;
1573
1574                                 x += thisw * dw;
1575                                 ac += 16;
1576                                 at += 8;
1577                                 av += 12;
1578                                 batchcount++;
1579                                 if (batchcount >= QUADELEMENTS_MAXQUADS)
1580                                 {
1581                                         R_Mesh_Draw(0, batchcount * 4, 0, batchcount * 2, quadelement3i, quadelement3s, 0, 0);
1582                                         batchcount = 0;
1583                                         ac = color4f;
1584                                         at = texcoord2f;
1585                                         av = vertex3f;
1586                                 }
1587
1588                                 prevmap = map;
1589                                 prevch = ch;
1590                         }
1591                         if (shadow)
1592                         {
1593                                 x -= 1.0/pix_x * r_textshadow.value;
1594                                 y -= 1.0/pix_y * r_textshadow.value;
1595                         }
1596                 }
1597         }
1598         if (batchcount > 0)
1599                 R_Mesh_Draw(0, batchcount * 4, 0, batchcount * 2, quadelement3i, quadelement3s, 0, 0);
1600
1601         if (outcolor)
1602                 *outcolor = colorindex;
1603
1604         // note: this relies on the proper text (not shadow) being drawn last
1605         return x;
1606 }
1607
1608 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)
1609 {
1610         return DrawQ_String_Scale(startx, starty, text, maxlen, w, h, 1, 1, basered, basegreen, baseblue, basealpha, flags, outcolor, ignorecolorcodes, fnt);
1611 }
1612
1613 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)
1614 {
1615         return DrawQ_TextWidth_UntilWidth_TrackColors_Scale(text, maxlen, w, h, 1, 1, outcolor, ignorecolorcodes, fnt, maxwidth);
1616 }
1617
1618 float DrawQ_TextWidth(const char *text, size_t maxlen, float w, float h, qboolean ignorecolorcodes, const dp_font_t *fnt)
1619 {
1620         return DrawQ_TextWidth_UntilWidth(text, &maxlen, w, h, ignorecolorcodes, fnt, 1000000000);
1621 }
1622
1623 float DrawQ_TextWidth_UntilWidth(const char *text, size_t *maxlen, float w, float h, qboolean ignorecolorcodes, const dp_font_t *fnt, float maxWidth)
1624 {
1625         return DrawQ_TextWidth_UntilWidth_TrackColors(text, maxlen, w, h, NULL, ignorecolorcodes, fnt, maxWidth);
1626 }
1627
1628 #if 0
1629 // not used
1630 // no ^xrgb management
1631 static int DrawQ_BuildColoredText(char *output2c, size_t maxoutchars, const char *text, int maxreadchars, qboolean ignorecolorcodes, int *outcolor)
1632 {
1633         int color, numchars = 0;
1634         char *outputend2c = output2c + maxoutchars - 2;
1635         if (!outcolor || *outcolor == -1)
1636                 color = STRING_COLOR_DEFAULT;
1637         else
1638                 color = *outcolor;
1639         if (!maxreadchars)
1640                 maxreadchars = 1<<30;
1641         textend = text + maxreadchars;
1642         while (text != textend && *text)
1643         {
1644                 if (*text == STRING_COLOR_TAG && !ignorecolorcodes && text + 1 != textend)
1645                 {
1646                         if (text[1] == STRING_COLOR_TAG)
1647                                 text++;
1648                         else if (text[1] >= '0' && text[1] <= '9')
1649                         {
1650                                 color = text[1] - '0';
1651                                 text += 2;
1652                                 continue;
1653                         }
1654                 }
1655                 if (output2c >= outputend2c)
1656                         break;
1657                 *output2c++ = *text++;
1658                 *output2c++ = color;
1659                 numchars++;
1660         }
1661         output2c[0] = output2c[1] = 0;
1662         if (outcolor)
1663                 *outcolor = color;
1664         return numchars;
1665 }
1666 #endif
1667
1668 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)
1669 {
1670         float floats[36];
1671
1672         _DrawQ_ProcessDrawFlag(flags);
1673
1674         R_Mesh_VertexPointer(floats, 0, 0);
1675         R_Mesh_ColorPointer(floats + 20, 0, 0);
1676         R_Mesh_ResetTextureState();
1677         if (pic)
1678         {
1679                 if (width == 0)
1680                         width = pic->width;
1681                 if (height == 0)
1682                         height = pic->height;
1683                 R_SetupShader_Generic(Draw_GetPicTexture(pic), NULL, GL_MODULATE, 1);
1684                 R_Mesh_TexCoordPointer(0, 2, floats + 12, 0, 0);
1685                 floats[12] = s1;floats[13] = t1;
1686                 floats[14] = s2;floats[15] = t2;
1687                 floats[16] = s4;floats[17] = t4;
1688                 floats[18] = s3;floats[19] = t3;
1689         }
1690         else
1691                 R_SetupShader_Generic(NULL, NULL, GL_MODULATE, 1);
1692
1693         floats[2] = floats[5] = floats[8] = floats[11] = 0;
1694         floats[0] = floats[9] = x;
1695         floats[1] = floats[4] = y;
1696         floats[3] = floats[6] = x + width;
1697         floats[7] = floats[10] = y + height;
1698         floats[20] = r1;floats[21] = g1;floats[22] = b1;floats[23] = a1;
1699         floats[24] = r2;floats[25] = g2;floats[26] = b2;floats[27] = a2;
1700         floats[28] = r4;floats[29] = g4;floats[30] = b4;floats[31] = a4;
1701         floats[32] = r3;floats[33] = g3;floats[34] = b3;floats[35] = a3;
1702
1703         R_Mesh_Draw(0, 4, 0, 2, polygonelement3i, polygonelement3s, 0, 0);
1704 }
1705
1706 void DrawQ_Mesh (drawqueuemesh_t *mesh, int flags)
1707 {
1708         _DrawQ_ProcessDrawFlag(flags);
1709
1710         R_Mesh_VertexPointer(mesh->data_vertex3f, 0, 0);
1711         R_Mesh_ColorPointer(mesh->data_color4f, 0, 0);
1712         R_Mesh_ResetTextureState();
1713         R_Mesh_TexCoordPointer(0, 2, mesh->data_texcoord2f, 0, 0);
1714         R_SetupShader_Generic(mesh->texture, NULL, GL_MODULATE, 1);
1715
1716         R_Mesh_Draw(0, mesh->num_vertices, 0, mesh->num_triangles, mesh->data_element3i, mesh->data_element3s, 0, 0);
1717 }
1718
1719 void DrawQ_LineLoop (drawqueuemesh_t *mesh, int flags)
1720 {
1721         int num;
1722
1723         _DrawQ_ProcessDrawFlag(flags);
1724
1725         GL_Color(1,1,1,1);
1726         CHECKGLERROR
1727         qglBegin(GL_LINE_LOOP);
1728         for (num = 0;num < mesh->num_vertices;num++)
1729         {
1730                 if (mesh->data_color4f)
1731                         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]);
1732                 qglVertex2f(mesh->data_vertex3f[num*3+0], mesh->data_vertex3f[num*3+1]);
1733         }
1734         qglEnd();
1735         CHECKGLERROR
1736 }
1737
1738 //[515]: this is old, delete
1739 void DrawQ_Line (float width, float x1, float y1, float x2, float y2, float r, float g, float b, float alpha, int flags)
1740 {
1741         _DrawQ_ProcessDrawFlag(flags);
1742
1743         R_SetupShader_Generic(NULL, NULL, GL_MODULATE, 1);
1744
1745         CHECKGLERROR
1746         //qglLineWidth(width);CHECKGLERROR
1747
1748         GL_Color(r,g,b,alpha);
1749         CHECKGLERROR
1750         qglBegin(GL_LINES);
1751         qglVertex2f(x1, y1);
1752         qglVertex2f(x2, y2);
1753         qglEnd();
1754         CHECKGLERROR
1755 }
1756
1757 void DrawQ_SetClipArea(float x, float y, float width, float height)
1758 {
1759         int ix, iy, iw, ih;
1760         _DrawQ_Setup();
1761
1762         // We have to convert the con coords into real coords
1763         // OGL uses top to bottom
1764         ix = (int)(0.5 + x * ((float)vid.width / vid_conwidth.integer));
1765         iy = (int)(0.5 + y * ((float) vid.height / vid_conheight.integer));
1766         iw = (int)(width * ((float)vid.width / vid_conwidth.integer));
1767         ih = (int)(height * ((float)vid.height / vid_conheight.integer));
1768         GL_Scissor(ix, vid.height - iy - ih, iw, ih);
1769
1770         GL_ScissorTest(true);
1771 }
1772
1773 void DrawQ_ResetClipArea(void)
1774 {
1775         _DrawQ_Setup();
1776         GL_ScissorTest(false);
1777 }
1778
1779 void DrawQ_Finish(void)
1780 {
1781         r_refdef.draw2dstage = false;
1782 }
1783
1784 static float blendvertex3f[9] = {-5000, -5000, 10, 10000, -5000, 10, -5000, 10000, 10};
1785 void R_DrawGamma(void)
1786 {
1787         float c[4];
1788         switch(vid.renderpath)
1789         {
1790         case RENDERPATH_GL20:
1791         case RENDERPATH_CGGL:
1792                 if (vid_usinghwgamma || v_glslgamma.integer)
1793                         return;
1794                 break;
1795         case RENDERPATH_GL13:
1796         case RENDERPATH_GL11:
1797                 if (vid_usinghwgamma)
1798                         return;
1799                 break;
1800         }
1801         // all the blends ignore depth
1802         R_Mesh_VertexPointer(blendvertex3f, 0, 0);
1803         R_Mesh_ColorPointer(NULL, 0, 0);
1804         R_Mesh_ResetTextureState();
1805         R_SetupShader_Generic(NULL, NULL, GL_MODULATE, 1);
1806         GL_DepthMask(true);
1807         GL_DepthRange(0, 1);
1808         GL_PolygonOffset(0, 0);
1809         GL_DepthTest(false);
1810         if (v_color_enable.integer)
1811         {
1812                 c[0] = v_color_white_r.value;
1813                 c[1] = v_color_white_g.value;
1814                 c[2] = v_color_white_b.value;
1815         }
1816         else
1817                 c[0] = c[1] = c[2] = v_contrast.value;
1818         if (c[0] >= 1.01f || c[1] >= 1.01f || c[2] >= 1.01f)
1819         {
1820                 GL_BlendFunc(GL_DST_COLOR, GL_ONE);
1821                 while (c[0] >= 1.01f || c[1] >= 1.01f || c[2] >= 1.01f)
1822                 {
1823                         GL_Color(bound(0, c[0] - 1, 1), bound(0, c[1] - 1, 1), bound(0, c[2] - 1, 1), 1);
1824                         R_Mesh_Draw(0, 3, 0, 1, polygonelement3i, polygonelement3s, 0, 0);
1825                         VectorScale(c, 0.5, c);
1826                 }
1827         }
1828         if (v_color_enable.integer)
1829         {
1830                 c[0] = v_color_black_r.value;
1831                 c[1] = v_color_black_g.value;
1832                 c[2] = v_color_black_b.value;
1833         }
1834         else
1835                 c[0] = c[1] = c[2] = v_brightness.value;
1836         if (c[0] >= 0.01f || c[1] >= 0.01f || c[2] >= 0.01f)
1837         {
1838                 GL_BlendFunc(GL_ONE, GL_ONE);
1839                 GL_Color(c[0], c[1], c[2], 1);
1840                 R_Mesh_Draw(0, 3, 0, 1, polygonelement3i, polygonelement3s, 0, 0);
1841         }
1842 }
1843