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
  27 #include "ft2.h"
  28 #include "ft2_fontdefs.h"
  29
  30 struct cachepic_s
  31 {
  32         // size of pic
  33         int width, height;
  34         // this flag indicates that it should be loaded and unloaded on demand
  35         int autoload;
  36         // texture flags to upload with
  37         int texflags;
  38         // texture may be freed after a while
  39         int lastusedframe;
  40         // renderable texture
  41         skinframe_t *skinframe;
  42         // used for hash lookups
  43         struct cachepic_s *chain;
  44         // flags - CACHEPICFLAG_NEWPIC for example
  45         unsigned int flags;
  46         // name of pic
  47         char name[MAX_QPATH];
  48 };
  49
  50 dp_fonts_t dp_fonts;
  51 static mempool_t *fonts_mempool = NULL;
  52
  53 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)"};
  54 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)"};
  55 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)"};
  56
  57 cvar_t r_font_postprocess_blur = {CVAR_SAVE, "r_font_postprocess_blur", "0", "font blur amount"};
  58 cvar_t r_font_postprocess_outline = {CVAR_SAVE, "r_font_postprocess_outline", "0", "font outline amount"};
  59 cvar_t r_font_postprocess_shadow_x = {CVAR_SAVE, "r_font_postprocess_shadow_x", "0", "font shadow X shift amount, applied during outlining"};
  60 cvar_t r_font_postprocess_shadow_y = {CVAR_SAVE, "r_font_postprocess_shadow_y", "0", "font shadow Y shift amount, applied during outlining"};
  61 cvar_t r_font_postprocess_shadow_z = {CVAR_SAVE, "r_font_postprocess_shadow_z", "0", "font shadow Z shift amount, applied during blurring"};
  62 cvar_t r_font_hinting = {CVAR_SAVE, "r_font_hinting", "3", "0 = no hinting, 1 = light autohinting, 2 = full autohinting, 3 = full hinting"};
  63 cvar_t r_font_antialias = {CVAR_SAVE, "r_font_antialias", "1", "0 = monochrome, 1 = grey" /* , 2 = rgb, 3 = bgr" */};
  64 cvar_t r_nearest_2d = {CVAR_SAVE, "r_nearest_2d", "0", "use nearest filtering on all 2d textures (including conchars)"};
  65 cvar_t r_nearest_conchars = {CVAR_SAVE, "r_nearest_conchars", "0", "use nearest filtering on conchars texture"};
  66
  67 //=============================================================================
  68 /* Support Routines */
  69
  70 static cachepic_t *cachepichash[CACHEPICHASHSIZE];
  71 static cachepic_t cachepics[MAX_CACHED_PICS];
  72 static int numcachepics;
  73
  74 rtexturepool_t *drawtexturepool;
  75
  76 int draw_frame = 1;
  77
  78 /*
  79 ================
  80 Draw_CachePic
  81 ================
  82 */
  83 // FIXME: move this to client somehow
  84 cachepic_t *Draw_CachePic_Flags(const char *path, unsigned int cachepicflags)
  85 {
  86         int crc, hashkey;
  87         cachepic_t *pic;
  88         int texflags;
  89
  90         texflags = TEXF_ALPHA;
  91         if (!(cachepicflags & CACHEPICFLAG_NOCLAMP))
  92                 texflags |= TEXF_CLAMP;
  93         if (cachepicflags & CACHEPICFLAG_MIPMAP)
  94                 texflags |= TEXF_MIPMAP;
  95         if (!(cachepicflags & CACHEPICFLAG_NOCOMPRESSION) && gl_texturecompression_2d.integer && gl_texturecompression.integer)
  96                 texflags |= TEXF_COMPRESS;
  97         if ((cachepicflags & CACHEPICFLAG_NEAREST) || r_nearest_2d.integer)
  98                 texflags |= TEXF_FORCENEAREST;
  99
 100         // check whether the picture has already been cached
 101         crc = CRC_Block((unsigned char *)path, strlen(path));
 102         hashkey = ((crc >> 8) ^ crc) % CACHEPICHASHSIZE;
 103         for (pic = cachepichash[hashkey];pic;pic = pic->chain)
 104         {
 105                 if (!strcmp(path, pic->name))
 106                 {
 107                         // if it was created (or replaced) by Draw_NewPic, just return it
 108                         if (!(pic->flags & CACHEPICFLAG_NEWPIC))
 109                         {
 110                                 // reload the pic if texflags changed in important ways
 111                                 // ignore TEXF_COMPRESS when comparing, because fallback pics remove the flag, and ignore TEXF_MIPMAP because QC specifies that
 112                                 if ((pic->texflags ^ texflags) & ~(TEXF_COMPRESS | TEXF_MIPMAP))
 113                                 {
 114                                         Con_DPrintf("Draw_CachePic(\"%s\"): reloading pic due to mismatch on flags\n", path);
 115                                         goto reload;
 116                                 }
 117                                 if (!pic->skinframe || !pic->skinframe->base)
 118                                 {
 119                                         Con_DPrintf("Draw_CachePic(\"%s\"): reloading pic\n", pic);
 120                                         goto reload;
 121                                 }
 122                                 if (!(cachepicflags & CACHEPICFLAG_NOTPERSISTENT))
 123                                         pic->autoload = false; // caller is making this pic persistent
 124                         }
 125                         if (pic->skinframe)
 126                                 R_SkinFrame_MarkUsed(pic->skinframe);
 127                         pic->lastusedframe = draw_frame;
 128                         return pic;
 129                 }
 130         }
 131
 132         if (numcachepics == MAX_CACHED_PICS)
 133         {
 134                 Con_Printf ("Draw_CachePic(\"%s\"): numcachepics == MAX_CACHED_PICS\n", path);
 135                 // FIXME: support NULL in callers?
 136                 return cachepics; // return the first one
 137         }
 138         Con_DPrintf("Draw_CachePic(\"%s\"): loading pic\n", path);
 139         pic = cachepics + (numcachepics++);
 140         memset(pic, 0, sizeof(*pic));
 141         strlcpy (pic->name, path, sizeof(pic->name));
 142         // link into list
 143         pic->chain = cachepichash[hashkey];
 144         cachepichash[hashkey] = pic;
 145
 146 reload:
 147         if (pic->skinframe)
 148                 R_SkinFrame_PurgeSkinFrame(pic->skinframe);
 149
 150         pic->flags = cachepicflags;
 151         pic->texflags = texflags;
 152         pic->autoload = (cachepicflags & CACHEPICFLAG_NOTPERSISTENT) != 0;
 153         pic->lastusedframe = draw_frame;
 154
 155         if (pic->skinframe)
 156         {
 157                 // reload image after it was unloaded or texflags changed significantly
 158                 R_SkinFrame_LoadExternal_SkinFrame(pic->skinframe, pic->name, texflags | TEXF_FORCE_RELOAD, (cachepicflags & CACHEPICFLAG_QUIET) == 0, (cachepicflags & CACHEPICFLAG_FAILONMISSING) == 0);
 159         }
 160         else
 161         {
 162                 // load high quality image (this falls back to low quality too)
 163                 pic->skinframe = R_SkinFrame_LoadExternal(pic->name, texflags | TEXF_FORCE_RELOAD, (cachepicflags & CACHEPICFLAG_QUIET) == 0, (cachepicflags & CACHEPICFLAG_FAILONMISSING) == 0);
 164         }
 165
 166         // get the dimensions of the image we loaded (if it was successful)
 167         if (pic->skinframe && pic->skinframe->base)
 168         {
 169                 pic->width = R_TextureWidth(pic->skinframe->base);
 170                 pic->height = R_TextureHeight(pic->skinframe->base);
 171         }
 172
 173         // check for a low quality version of the pic and use its size if possible, to match the stock hud
 174         Image_GetStockPicSize(pic->name, &pic->width, &pic->height);
 175
 176         return pic;
 177 }
 178
 179 cachepic_t *Draw_CachePic (const char *path)
 180 {
 181         return Draw_CachePic_Flags (path, 0); // default to persistent!
 182 }
 183
 184 const char *Draw_GetPicName(cachepic_t *pic)
 185 {
 186         if (pic == NULL)
 187                 return "";
 188         return pic->name;
 189 }
 190
 191 int Draw_GetPicWidth(cachepic_t *pic)
 192 {
 193         if (pic == NULL)
 194                 return 0;
 195         return pic->width;
 196 }
 197
 198 int Draw_GetPicHeight(cachepic_t *pic)
 199 {
 200         if (pic == NULL)
 201                 return 0;
 202         return pic->height;
 203 }
 204
 205 qboolean Draw_IsPicLoaded(cachepic_t *pic)
 206 {
 207         if (pic == NULL)
 208                 return false;
 209         if (pic->autoload && (!pic->skinframe || !pic->skinframe->base))
 210                 pic->skinframe = R_SkinFrame_LoadExternal(pic->name, pic->texflags | TEXF_FORCE_RELOAD, false, true);
 211         // skinframe will only be NULL if the pic was created with CACHEPICFLAG_FAILONMISSING and not found
 212         return pic->skinframe != NULL && pic->skinframe->base != NULL;
 213 }
 214
 215 rtexture_t *Draw_GetPicTexture(cachepic_t *pic)
 216 {
 217         if (pic == NULL)
 218                 return NULL;
 219         if (pic->autoload && (!pic->skinframe || !pic->skinframe->base))
 220                 pic->skinframe = R_SkinFrame_LoadExternal(pic->name, pic->texflags | TEXF_FORCE_RELOAD, false, true);
 221         pic->lastusedframe = draw_frame;
 222         return pic->skinframe ? pic->skinframe->base : NULL;
 223 }
 224
 225 void Draw_Frame(void)
 226 {
 227         int i;
 228         cachepic_t *pic;
 229         static double nextpurgetime;
 230         if (nextpurgetime > realtime)
 231                 return;
 232         nextpurgetime = realtime + 0.05;
 233         for (i = 0, pic = cachepics;i < numcachepics;i++, pic++)
 234                 if (pic->autoload && pic->skinframe && pic->skinframe->base && pic->lastusedframe < draw_frame - 3)
 235                         R_SkinFrame_PurgeSkinFrame(pic->skinframe);
 236         draw_frame++;
 237 }
 238
 239 cachepic_t *Draw_NewPic(const char *picname, int width, int height, unsigned char *pixels_bgra, textype_t textype, int texflags)
 240 {
 241         int crc, hashkey;
 242         cachepic_t *pic;
 243
 244         crc = CRC_Block((unsigned char *)picname, strlen(picname));
 245         hashkey = ((crc >> 8) ^ crc) % CACHEPICHASHSIZE;
 246         for (pic = cachepichash[hashkey];pic;pic = pic->chain)
 247                 if (!strcmp (picname, pic->name))
 248                         break;
 249
 250         if (pic)
 251         {
 252                 if (pic->flags & CACHEPICFLAG_NEWPIC && pic->skinframe && pic->skinframe->base && pic->width == width && pic->height == height)
 253                 {
 254                         R_UpdateTexture(pic->skinframe->base, pixels_bgra, 0, 0, 0, width, height, 1);
 255                         R_SkinFrame_MarkUsed(pic->skinframe);
 256                         pic->lastusedframe = draw_frame;
 257                         return pic;
 258                 }
 259         }
 260         else
 261         {
 262                 if (numcachepics == MAX_CACHED_PICS)
 263                 {
 264                         Con_Printf ("Draw_NewPic: numcachepics == MAX_CACHED_PICS\n");
 265                         // FIXME: support NULL in callers?
 266                         return cachepics; // return the first one
 267                 }
 268                 pic = cachepics + (numcachepics++);
 269                 memset(pic, 0, sizeof(*pic));
 270                 strlcpy (pic->name, picname, sizeof(pic->name));
 271                 // link into list
 272                 pic->chain = cachepichash[hashkey];
 273                 cachepichash[hashkey] = pic;
 274         }
 275
 276         R_SkinFrame_PurgeSkinFrame(pic->skinframe);
 277
 278         pic->autoload = false;
 279         pic->flags = CACHEPICFLAG_NEWPIC; // disable texflags checks in Draw_CachePic
 280         pic->flags |= (texflags & TEXF_CLAMP) ? 0 : CACHEPICFLAG_NOCLAMP;
 281         pic->flags |= (texflags & TEXF_FORCENEAREST) ? CACHEPICFLAG_NEAREST : 0;
 282         pic->width = width;
 283         pic->height = height;
 284         pic->skinframe = R_SkinFrame_LoadInternalBGRA(picname, texflags | TEXF_FORCE_RELOAD, pixels_bgra, width, height, vid.sRGB2D);
 285         pic->lastusedframe = draw_frame;
 286         return pic;
 287 }
 288
 289 void Draw_FreePic(const char *picname)
 290 {
 291         int crc;
 292         int hashkey;
 293         cachepic_t *pic;
 294         // this doesn't really free the pic, but does free its texture
 295         crc = CRC_Block((unsigned char *)picname, strlen(picname));
 296         hashkey = ((crc >> 8) ^ crc) % CACHEPICHASHSIZE;
 297         for (pic = cachepichash[hashkey];pic;pic = pic->chain)
 298         {
 299                 if (!strcmp (picname, pic->name) && pic->skinframe)
 300                 {
 301                         R_SkinFrame_PurgeSkinFrame(pic->skinframe);
 302                         pic->width = 0;
 303                         pic->height = 0;
 304                         return;
 305                 }
 306         }
 307 }
 308
 309 static float snap_to_pixel_x(float x, float roundUpAt);
 310 extern int con_linewidth; // to force rewrapping
 311 void LoadFont(qboolean override, const char *name, dp_font_t *fnt, float scale, float voffset)
 312 {
 313         int i, ch;
 314         float maxwidth;
 315         char widthfile[MAX_QPATH];
 316         char *widthbuf;
 317         fs_offset_t widthbufsize;
 318
 319         if(override || !fnt->texpath[0])
 320         {
 321                 strlcpy(fnt->texpath, name, sizeof(fnt->texpath));
 322                 // load the cvars when the font is FIRST loader
 323                 fnt->settings.scale = scale;
 324                 fnt->settings.voffset = voffset;
 325                 fnt->settings.antialias = r_font_antialias.integer;
 326                 fnt->settings.hinting = r_font_hinting.integer;
 327                 fnt->settings.outline = r_font_postprocess_outline.value;
 328                 fnt->settings.blur = r_font_postprocess_blur.value;
 329                 fnt->settings.shadowx = r_font_postprocess_shadow_x.value;
 330                 fnt->settings.shadowy = r_font_postprocess_shadow_y.value;
 331                 fnt->settings.shadowz = r_font_postprocess_shadow_z.value;
 332         }
 333         // fix bad scale
 334         if (fnt->settings.scale <= 0)
 335                 fnt->settings.scale = 1;
 336
 337         if(drawtexturepool == NULL)
 338                 return; // before gl_draw_start, so will be loaded later
 339
 340         if(fnt->ft2)
 341         {
 342                 // clear freetype font
 343                 Font_UnloadFont(fnt->ft2);
 344                 Mem_Free(fnt->ft2);
 345                 fnt->ft2 = NULL;
 346         }
 347
 348         if(fnt->req_face != -1)
 349         {
 350                 if(!Font_LoadFont(fnt->texpath, fnt))
 351                         Con_DPrintf("Failed to load font-file for '%s', it will not support as many characters.\n", fnt->texpath);
 352         }
 353
 354         fnt->pic = Draw_CachePic_Flags(fnt->texpath, CACHEPICFLAG_QUIET | CACHEPICFLAG_NOCOMPRESSION | (r_nearest_conchars.integer ? CACHEPICFLAG_NEAREST : 0) | CACHEPICFLAG_FAILONMISSING);
 355         if(!Draw_IsPicLoaded(fnt->pic))
 356         {
 357                 for (i = 0; i < MAX_FONT_FALLBACKS; ++i)
 358                 {
 359                         if (!fnt->fallbacks[i][0])
 360                                 break;
 361                         fnt->pic = Draw_CachePic_Flags(fnt->fallbacks[i], CACHEPICFLAG_QUIET | CACHEPICFLAG_NOCOMPRESSION | (r_nearest_conchars.integer ? CACHEPICFLAG_NEAREST : 0) | CACHEPICFLAG_FAILONMISSING);
 362                         if(Draw_IsPicLoaded(fnt->pic))
 363                                 break;
 364                 }
 365                 if(!Draw_IsPicLoaded(fnt->pic))
 366                 {
 367                         fnt->pic = Draw_CachePic_Flags("gfx/conchars", CACHEPICFLAG_NOCOMPRESSION | (r_nearest_conchars.integer ? CACHEPICFLAG_NEAREST : 0));
 368                         strlcpy(widthfile, "gfx/conchars.width", sizeof(widthfile));
 369                 }
 370                 else
 371                         dpsnprintf(widthfile, sizeof(widthfile), "%s.width", fnt->fallbacks[i]);
 372         }
 373         else
 374                 dpsnprintf(widthfile, sizeof(widthfile), "%s.width", fnt->texpath);
 375
 376         // unspecified width == 1 (base width)
 377         for(ch = 0; ch < 256; ++ch)
 378                 fnt->width_of[ch] = 1;
 379
 380         // FIXME load "name.width", if it fails, fill all with 1
 381         if((widthbuf = (char *) FS_LoadFile(widthfile, tempmempool, true, &widthbufsize)))
 382         {
 383                 float extraspacing = 0;
 384                 const char *p = widthbuf;
 385
 386                 ch = 0;
 387                 while(ch < 256)
 388                 {
 389                         if(!COM_ParseToken_Simple(&p, false, false, true))
 390                                 return;
 391
 392                         switch(*com_token)
 393                         {
 394                                 case '0':
 395                                 case '1':
 396                                 case '2':
 397                                 case '3':
 398                                 case '4':
 399                                 case '5':
 400                                 case '6':
 401                                 case '7':
 402                                 case '8':
 403                                 case '9':
 404                                 case '+':
 405                                 case '-':
 406                                 case '.':
 407                                         fnt->width_of[ch] = atof(com_token) + extraspacing;
 408                                         ch++;
 409                                         break;
 410                                 default:
 411                                         if(!strcmp(com_token, "extraspacing"))
 412                                         {
 413                                                 if(!COM_ParseToken_Simple(&p, false, false, true))
 414                                                         return;
 415                                                 extraspacing = atof(com_token);
 416                                         }
 417                                         else if(!strcmp(com_token, "scale"))
 418                                         {
 419                                                 if(!COM_ParseToken_Simple(&p, false, false, true))
 420                                                         return;
 421                                                 fnt->settings.scale = atof(com_token);
 422                                         }
 423                                         else
 424                                         {
 425                                                 Con_Printf("Warning: skipped unknown font property %s\n", com_token);
 426                                                 if(!COM_ParseToken_Simple(&p, false, false, true))
 427                                                         return;
 428                                         }
 429                                         break;
 430                         }
 431                 }
 432
 433                 Mem_Free(widthbuf);
 434         }
 435
 436         if(fnt->ft2)
 437         {
 438                 for (i = 0; i < MAX_FONT_SIZES; ++i)
 439                 {
 440                         ft2_font_map_t *map = Font_MapForIndex(fnt->ft2, i);
 441                         if (!map)
 442                                 break;
 443                         for(ch = 0; ch < 256; ++ch)
 444                                 map->width_of[ch] = Font_SnapTo(fnt->width_of[ch], 1/map->size);
 445                 }
 446         }
 447
 448         maxwidth = fnt->width_of[0];
 449         for(i = 1; i < 256; ++i)
 450                 maxwidth = max(maxwidth, fnt->width_of[i]);
 451         fnt->maxwidth = maxwidth;
 452
 453         // fix up maxwidth for overlap
 454         fnt->maxwidth *= fnt->settings.scale;
 455
 456         if(fnt == FONT_CONSOLE)
 457                 con_linewidth = -1; // rewrap console in next frame
 458 }
 459
 460 extern cvar_t developer_font;
 461 dp_font_t *FindFont(const char *title, qboolean allocate_new)
 462 {
 463         int i, oldsize;
 464
 465         // find font
 466         for(i = 0; i < dp_fonts.maxsize; ++i)
 467                 if(!strcmp(dp_fonts.f[i].title, title))
 468                         return &dp_fonts.f[i];
 469         // if not found - try allocate
 470         if (allocate_new)
 471         {
 472                 // find any font with empty title
 473                 for(i = 0; i < dp_fonts.maxsize; ++i)
 474                 {
 475                         if(!strcmp(dp_fonts.f[i].title, ""))
 476                         {
 477                                 strlcpy(dp_fonts.f[i].title, title, sizeof(dp_fonts.f[i].title));
 478                                 return &dp_fonts.f[i];
 479                         }
 480                 }
 481                 // if no any 'free' fonts - expand buffer
 482                 oldsize = dp_fonts.maxsize;
 483                 dp_fonts.maxsize = dp_fonts.maxsize + FONTS_EXPAND;
 484                 if (developer_font.integer)
 485                         Con_Printf("FindFont: enlarging fonts buffer (%i -> %i)\n", oldsize, dp_fonts.maxsize);
 486                 dp_fonts.f = (dp_font_t *)Mem_Realloc(fonts_mempool, dp_fonts.f, sizeof(dp_font_t) * dp_fonts.maxsize);
 487                 // relink ft2 structures
 488                 for(i = 0; i < oldsize; ++i)
 489                         if (dp_fonts.f[i].ft2)
 490                                 dp_fonts.f[i].ft2->settings = &dp_fonts.f[i].settings;
 491                 // register a font in first expanded slot
 492                 strlcpy(dp_fonts.f[oldsize].title, title, sizeof(dp_fonts.f[oldsize].title));
 493                 return &dp_fonts.f[oldsize];
 494         }
 495         return NULL;
 496 }
 497
 498 static float snap_to_pixel_x(float x, float roundUpAt)
 499 {
 500         float pixelpos = x * vid.width / vid_conwidth.value;
 501         int snap = (int) pixelpos;
 502         if (pixelpos - snap >= roundUpAt) ++snap;
 503         return ((float)snap * vid_conwidth.value / vid.width);
 504         /*
 505         x = (int)(x * vid.width / vid_conwidth.value);
 506         x = (x * vid_conwidth.value / vid.width);
 507         return x;
 508         */
 509 }
 510
 511 static float snap_to_pixel_y(float y, float roundUpAt)
 512 {
 513         float pixelpos = y * vid.height / vid_conheight.value;
 514         int snap = (int) pixelpos;
 515         if (pixelpos - snap > roundUpAt) ++snap;
 516         return ((float)snap * vid_conheight.value / vid.height);
 517         /*
 518         y = (int)(y * vid.height / vid_conheight.value);
 519         y = (y * vid_conheight.value / vid.height);
 520         return y;
 521         */
 522 }
 523
 524 static void LoadFont_f(void)
 525 {
 526         dp_font_t *f;
 527         int i, sizes;
 528         const char *filelist, *c, *cm;
 529         float sz, scale, voffset;
 530         char mainfont[MAX_QPATH];
 531
 532         if(Cmd_Argc() < 2)
 533         {
 534                 Con_Printf("Available font commands:\n");
 535                 for(i = 0; i < dp_fonts.maxsize; ++i)
 536                         if (dp_fonts.f[i].title[0])
 537                                 Con_Printf("  loadfont %s gfx/tgafile[...] [custom switches] [sizes...]\n", dp_fonts.f[i].title);
 538                 Con_Printf("A font can simply be gfx/tgafile, or alternatively you\n"
 539                            "can specify multiple fonts and faces\n"
 540                            "Like this: gfx/vera-sans:2,gfx/fallback:1\n"
 541                            "to load face 2 of the font gfx/vera-sans and use face 1\n"
 542                            "of gfx/fallback as fallback font.\n"
 543                            "You can also specify a list of font sizes to load, like this:\n"
 544                            "loadfont console gfx/conchars,gfx/fallback 8 12 16 24 32\n"
 545                            "In many cases, 8 12 16 24 32 should be a good choice.\n"
 546                            "custom switches:\n"
 547                            " scale x : scale all characters by this amount when rendering (doesnt change line height)\n"
 548                            " voffset x : offset all chars vertical when rendering, this is multiplied to character height\n"
 549                         );
 550                 return;
 551         }
 552         f = FindFont(Cmd_Argv(1), true);
 553         if(f == NULL)
 554         {
 555                 Con_Printf("font function not found\n");
 556                 return;
 557         }
 558
 559         if(Cmd_Argc() < 3)
 560                 filelist = "gfx/conchars";
 561         else
 562                 filelist = Cmd_Argv(2);
 563
 564         memset(f->fallbacks, 0, sizeof(f->fallbacks));
 565         memset(f->fallback_faces, 0, sizeof(f->fallback_faces));
 566
 567         // first font is handled "normally"
 568         c = strchr(filelist, ':');
 569         cm = strchr(filelist, ',');
 570         if(c && (!cm || c < cm))
 571                 f->req_face = atoi(c+1);
 572         else
 573         {
 574                 f->req_face = 0;
 575                 c = cm;
 576         }
 577
 578         if(!c || (c - filelist) > MAX_QPATH)
 579                 strlcpy(mainfont, filelist, sizeof(mainfont));
 580         else
 581         {
 582                 memcpy(mainfont, filelist, c - filelist);
 583                 mainfont[c - filelist] = 0;
 584         }
 585
 586         for(i = 0; i < MAX_FONT_FALLBACKS; ++i)
 587         {
 588                 c = strchr(filelist, ',');
 589                 if(!c)
 590                         break;
 591                 filelist = c + 1;
 592                 if(!*filelist)
 593                         break;
 594                 c = strchr(filelist, ':');
 595                 cm = strchr(filelist, ',');
 596                 if(c && (!cm || c < cm))
 597                         f->fallback_faces[i] = atoi(c+1);
 598                 else
 599                 {
 600                         f->fallback_faces[i] = 0; // f->req_face; could make it stick to the default-font's face index
 601                         c = cm;
 602                 }
 603                 if(!c || (c-filelist) > MAX_QPATH)
 604                 {
 605                         strlcpy(f->fallbacks[i], filelist, sizeof(mainfont));
 606                 }
 607                 else
 608                 {
 609                         memcpy(f->fallbacks[i], filelist, c - filelist);
 610                         f->fallbacks[i][c - filelist] = 0;
 611                 }
 612         }
 613
 614         // for now: by default load only one size: the default size
 615         f->req_sizes[0] = 0;
 616         for(i = 1; i < MAX_FONT_SIZES; ++i)
 617                 f->req_sizes[i] = -1;
 618
 619         scale = 1;
 620         voffset = 0;
 621         if(Cmd_Argc() >= 4)
 622         {
 623                 for(sizes = 0, i = 3; i < Cmd_Argc(); ++i)
 624                 {
 625                         // special switches
 626                         if (!strcmp(Cmd_Argv(i), "scale"))
 627                         {
 628                                 i++;
 629                                 if (i < Cmd_Argc())
 630                                         scale = atof(Cmd_Argv(i));
 631                                 continue;
 632                         }
 633                         if (!strcmp(Cmd_Argv(i), "voffset"))
 634                         {
 635                                 i++;
 636                                 if (i < Cmd_Argc())
 637                                         voffset = atof(Cmd_Argv(i));
 638                                 continue;
 639                         }
 640
 641                         if (sizes == -1)
 642                                 continue; // no slot for other sizes
 643
 644                         // parse one of sizes
 645                         sz = atof(Cmd_Argv(i));
 646                         if (sz > 0.001f && sz < 1000.0f) // do not use crap sizes
 647                         {
 648                                 // search for duplicated sizes
 649                                 int j;
 650                                 for (j=0; j<sizes; j++)
 651                                         if (f->req_sizes[j] == sz)
 652                                                 break;
 653                                 if (j != sizes)
 654                                         continue; // sz already in req_sizes, don't add it again
 655
 656                                 if (sizes == MAX_FONT_SIZES)
 657                                 {
 658                                         Con_Printf("Warning: specified more than %i different font sizes, exceding ones are ignored\n", MAX_FONT_SIZES);
 659                                         sizes = -1;
 660                                         continue;
 661                                 }
 662                                 f->req_sizes[sizes] = sz;
 663                                 sizes++;
 664                         }
 665                 }
 666         }
 667
 668         LoadFont(true, mainfont, f, scale, voffset);
 669 }
 670
 671 /*
 672 ===============
 673 Draw_Init
 674 ===============
 675 */
 676 static void gl_draw_start(void)
 677 {
 678         int i;
 679         char vabuf[1024];
 680         drawtexturepool = R_AllocTexturePool();
 681
 682         numcachepics = 0;
 683         memset(cachepichash, 0, sizeof(cachepichash));
 684
 685         font_start();
 686
 687         // load default font textures
 688         for(i = 0; i < dp_fonts.maxsize; ++i)
 689                 if (dp_fonts.f[i].title[0])
 690                         LoadFont(false, va(vabuf, sizeof(vabuf), "gfx/font_%s", dp_fonts.f[i].title), &dp_fonts.f[i], 1, 0);
 691
 692         // draw the loading screen so people have something to see in the newly opened window
 693         SCR_UpdateLoadingScreen(true, true);
 694 }
 695
 696 static void gl_draw_shutdown(void)
 697 {
 698         font_shutdown();
 699
 700         R_FreeTexturePool(&drawtexturepool);
 701
 702         numcachepics = 0;
 703         memset(cachepichash, 0, sizeof(cachepichash));
 704 }
 705
 706 static void gl_draw_newmap(void)
 707 {
 708         int i;
 709         font_newmap();
 710
 711         // mark all of the persistent pics so they are not purged...
 712         for (i = 0; i < numcachepics; i++)
 713         {
 714                 cachepic_t *pic = cachepics + i;
 715                 if (!pic->autoload && pic->skinframe)
 716                         R_SkinFrame_MarkUsed(pic->skinframe);
 717         }
 718 }
 719
 720 void GL_Draw_Init (void)
 721 {
 722         int i, j;
 723
 724         Cvar_RegisterVariable(&r_font_postprocess_blur);
 725         Cvar_RegisterVariable(&r_font_postprocess_outline);
 726         Cvar_RegisterVariable(&r_font_postprocess_shadow_x);
 727         Cvar_RegisterVariable(&r_font_postprocess_shadow_y);
 728         Cvar_RegisterVariable(&r_font_postprocess_shadow_z);
 729         Cvar_RegisterVariable(&r_font_hinting);
 730         Cvar_RegisterVariable(&r_font_antialias);
 731         Cvar_RegisterVariable(&r_textshadow);
 732         Cvar_RegisterVariable(&r_textbrightness);
 733         Cvar_RegisterVariable(&r_textcontrast);
 734         Cvar_RegisterVariable(&r_nearest_2d);
 735         Cvar_RegisterVariable(&r_nearest_conchars);
 736
 737         // allocate fonts storage
 738         fonts_mempool = Mem_AllocPool("FONTS", 0, NULL);
 739         dp_fonts.maxsize = MAX_FONTS;
 740         dp_fonts.f = (dp_font_t *)Mem_Alloc(fonts_mempool, sizeof(dp_font_t) * dp_fonts.maxsize);
 741         memset(dp_fonts.f, 0, sizeof(dp_font_t) * dp_fonts.maxsize);
 742
 743         // assign starting font names
 744         strlcpy(FONT_DEFAULT->title, "default", sizeof(FONT_DEFAULT->title));
 745         strlcpy(FONT_DEFAULT->texpath, "gfx/conchars", sizeof(FONT_DEFAULT->texpath));
 746         strlcpy(FONT_CONSOLE->title, "console", sizeof(FONT_CONSOLE->title));
 747         strlcpy(FONT_SBAR->title, "sbar", sizeof(FONT_SBAR->title));
 748         strlcpy(FONT_NOTIFY->title, "notify", sizeof(FONT_NOTIFY->title));
 749         strlcpy(FONT_CHAT->title, "chat", sizeof(FONT_CHAT->title));
 750         strlcpy(FONT_CENTERPRINT->title, "centerprint", sizeof(FONT_CENTERPRINT->title));
 751         strlcpy(FONT_INFOBAR->title, "infobar", sizeof(FONT_INFOBAR->title));
 752         strlcpy(FONT_MENU->title, "menu", sizeof(FONT_MENU->title));
 753         for(i = 0, j = 0; i < MAX_USERFONTS; ++i)
 754                 if(!FONT_USER(i)->title[0])
 755                         dpsnprintf(FONT_USER(i)->title, sizeof(FONT_USER(i)->title), "user%d", j++);
 756
 757         Cmd_AddCommand ("loadfont",LoadFont_f, "loadfont function tganame loads a font; example: loadfont console gfx/veramono; loadfont without arguments lists the available functions");
 758         R_RegisterModule("GL_Draw", gl_draw_start, gl_draw_shutdown, gl_draw_newmap, NULL, NULL);
 759 }
 760
 761 void DrawQ_Start(void)
 762 {
 763         r_refdef.draw2dstage = 1;
 764         R_ResetViewRendering2D_Common(0, NULL, NULL, 0, 0, vid.width, vid.height, vid_conwidth.integer, vid_conheight.integer);
 765 }
 766
 767 qboolean r_draw2d_force = false;
 768
 769 void DrawQ_Pic(float x, float y, cachepic_t *pic, float width, float height, float red, float green, float blue, float alpha, int flags)
 770 {
 771         dp_model_t *mod = CL_Mesh_UI();
 772         msurface_t *surf;
 773         int e0, e1, e2, e3;
 774         if (!pic)
 775                 pic = Draw_CachePic("white");
 776         // make sure pic is loaded - we don't use the texture here, Mod_Mesh_GetTexture looks up the skinframe by name
 777         Draw_GetPicTexture(pic);
 778         if (width == 0)
 779                 width = pic->width;
 780         if (height == 0)
 781                 height = pic->height;
 782         surf = Mod_Mesh_AddSurface(mod, Mod_Mesh_GetTexture(mod, pic->name, flags, pic->texflags, MATERIALFLAG_VERTEXCOLOR), true);
 783         e0 = Mod_Mesh_IndexForVertex(mod, surf, x        , y         , 0, 0, 0, -1, 0, 0, 0, 0, red, green, blue, alpha);
 784         e1 = Mod_Mesh_IndexForVertex(mod, surf, x + width, y         , 0, 0, 0, -1, 1, 0, 0, 0, red, green, blue, alpha);
 785         e2 = Mod_Mesh_IndexForVertex(mod, surf, x + width, y + height, 0, 0, 0, -1, 1, 1, 0, 0, red, green, blue, alpha);
 786         e3 = Mod_Mesh_IndexForVertex(mod, surf, x        , y + height, 0, 0, 0, -1, 0, 1, 0, 0, red, green, blue, alpha);
 787         Mod_Mesh_AddTriangle(mod, surf, e0, e1, e2);
 788         Mod_Mesh_AddTriangle(mod, surf, e0, e2, e3);
 789 }
 790
 791 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)
 792 {
 793         float af = DEG2RAD(-angle); // forward
 794         float ar = DEG2RAD(-angle + 90); // right
 795         float sinaf = sin(af);
 796         float cosaf = cos(af);
 797         float sinar = sin(ar);
 798         float cosar = cos(ar);
 799         dp_model_t *mod = CL_Mesh_UI();
 800         msurface_t *surf;
 801         int e0, e1, e2, e3;
 802         if (!pic)
 803                 pic = Draw_CachePic("white");
 804         // make sure pic is loaded - we don't use the texture here, Mod_Mesh_GetTexture looks up the skinframe by name
 805         Draw_GetPicTexture(pic);
 806         if (width == 0)
 807                 width = pic->width;
 808         if (height == 0)
 809                 height = pic->height;
 810         surf = Mod_Mesh_AddSurface(mod, Mod_Mesh_GetTexture(mod, pic->name, flags, pic->texflags, MATERIALFLAG_VERTEXCOLOR), true);
 811         e0 = Mod_Mesh_IndexForVertex(mod, surf, x - cosaf *          org_x  - cosar *           org_y , y - sinaf *          org_x  - sinar *           org_y , 0, 0, 0, -1, 0, 0, 0, 0, red, green, blue, alpha);
 812         e1 = Mod_Mesh_IndexForVertex(mod, surf, x + cosaf * (width - org_x) - cosar *           org_y , y + sinaf * (width - org_x) - sinar *           org_y , 0, 0, 0, -1, 1, 0, 0, 0, red, green, blue, alpha);
 813         e2 = Mod_Mesh_IndexForVertex(mod, surf, x + cosaf * (width - org_x) + cosar * (height - org_y), y + sinaf * (width - org_x) + sinar * (height - org_y), 0, 0, 0, -1, 1, 1, 0, 0, red, green, blue, alpha);
 814         e3 = Mod_Mesh_IndexForVertex(mod, surf, x - cosaf *          org_x  + cosar * (height - org_y), y - sinaf *          org_x  + sinar * (height - org_y), 0, 0, 0, -1, 0, 1, 0, 0, red, green, blue, alpha);
 815         Mod_Mesh_AddTriangle(mod, surf, e0, e1, e2);
 816         Mod_Mesh_AddTriangle(mod, surf, e0, e2, e3);
 817 }
 818
 819 void DrawQ_Fill(float x, float y, float width, float height, float red, float green, float blue, float alpha, int flags)
 820 {
 821         DrawQ_Pic(x, y, Draw_CachePic("white"), width, height, red, green, blue, alpha, flags);
 822 }
 823
 824 /// color tag printing
 825 static const vec4_t string_colors[] =
 826 {
 827         // Quake3 colors
 828         // LordHavoc: why on earth is cyan before magenta in Quake3?
 829         // LordHavoc: note: Doom3 uses white for [0] and [7]
 830         {0.0, 0.0, 0.0, 1.0}, // black
 831         {1.0, 0.0, 0.0, 1.0}, // red
 832         {0.0, 1.0, 0.0, 1.0}, // green
 833         {1.0, 1.0, 0.0, 1.0}, // yellow
 834         {0.0, 0.0, 1.0, 1.0}, // blue
 835         {0.0, 1.0, 1.0, 1.0}, // cyan
 836         {1.0, 0.0, 1.0, 1.0}, // magenta
 837         {1.0, 1.0, 1.0, 1.0}, // white
 838         // [515]'s BX_COLOREDTEXT extension
 839         {1.0, 1.0, 1.0, 0.5}, // half transparent
 840         {0.5, 0.5, 0.5, 1.0}  // half brightness
 841         // Black's color table
 842         //{1.0, 1.0, 1.0, 1.0},
 843         //{1.0, 0.0, 0.0, 1.0},
 844         //{0.0, 1.0, 0.0, 1.0},
 845         //{0.0, 0.0, 1.0, 1.0},
 846         //{1.0, 1.0, 0.0, 1.0},
 847         //{0.0, 1.0, 1.0, 1.0},
 848         //{1.0, 0.0, 1.0, 1.0},
 849         //{0.1, 0.1, 0.1, 1.0}
 850 };
 851
 852 #define STRING_COLORS_COUNT     (sizeof(string_colors) / sizeof(vec4_t))
 853
 854 static void DrawQ_GetTextColor(float color[4], int colorindex, float r, float g, float b, float a, qboolean shadow)
 855 {
 856         float C = r_textcontrast.value;
 857         float B = r_textbrightness.value;
 858         if (colorindex & 0x10000) // that bit means RGB color
 859         {
 860                 color[0] = ((colorindex >> 12) & 0xf) / 15.0;
 861                 color[1] = ((colorindex >> 8) & 0xf) / 15.0;
 862                 color[2] = ((colorindex >> 4) & 0xf) / 15.0;
 863                 color[3] = (colorindex & 0xf) / 15.0;
 864         }
 865         else
 866                 Vector4Copy(string_colors[colorindex], color);
 867         Vector4Set(color, color[0] * r * C + B, color[1] * g * C + B, color[2] * b * C + B, color[3] * a);
 868         if (shadow)
 869         {
 870                 float shadowalpha = (color[0]+color[1]+color[2]) * 0.8;
 871                 Vector4Set(color, 0, 0, 0, color[3] * bound(0, shadowalpha, 1));
 872         }
 873 }
 874
 875 // NOTE: this function always draws exactly one character if maxwidth <= 0
 876 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)
 877 {
 878         const char *text_start = text;
 879         int colorindex = STRING_COLOR_DEFAULT;
 880         size_t i;
 881         float x = 0;
 882         Uchar ch, mapch, nextch;
 883         Uchar prevch = 0; // used for kerning
 884         int tempcolorindex;
 885         float kx;
 886         int map_index = 0;
 887         size_t bytes_left;
 888         ft2_font_map_t *fontmap = NULL;
 889         ft2_font_map_t *map = NULL;
 890         //ft2_font_map_t *prevmap = NULL;
 891         ft2_font_t *ft2 = fnt->ft2;
 892         // float ftbase_x;
 893         qboolean snap = true;
 894         qboolean least_one = false;
 895         float dw; // display w
 896         //float dh; // display h
 897         const float *width_of;
 898
 899         if (!h) h = w;
 900         if (!h) {
 901                 w = h = 1;
 902                 snap = false;
 903         }
 904         // do this in the end
 905         w *= fnt->settings.scale;
 906         h *= fnt->settings.scale;
 907
 908         // find the most fitting size:
 909         if (ft2 != NULL)
 910         {
 911                 if (snap)
 912                         map_index = Font_IndexForSize(ft2, h, &w, &h);
 913                 else
 914                         map_index = Font_IndexForSize(ft2, h, NULL, NULL);
 915                 fontmap = Font_MapForIndex(ft2, map_index);
 916         }
 917
 918         dw = w * sw;
 919         //dh = h * sh;
 920
 921         if (*maxlen < 1)
 922                 *maxlen = 1<<30;
 923
 924         if (!outcolor || *outcolor == -1)
 925                 colorindex = STRING_COLOR_DEFAULT;
 926         else
 927                 colorindex = *outcolor;
 928
 929         // maxwidth /= fnt->scale; // w and h are multiplied by it already
 930         // ftbase_x = snap_to_pixel_x(0);
 931
 932         if(maxwidth <= 0)
 933         {
 934                 least_one = true;
 935                 maxwidth = -maxwidth;
 936         }
 937
 938         //if (snap)
 939         //      x = snap_to_pixel_x(x, 0.4); // haha, it's 0 anyway
 940
 941         if (fontmap)
 942                 width_of = fontmap->width_of;
 943         else
 944                 width_of = fnt->width_of;
 945
 946         i = 0;
 947         while (((bytes_left = *maxlen - (text - text_start)) > 0) && *text)
 948         {
 949                 size_t i0 = i;
 950                 nextch = ch = u8_getnchar(text, &text, bytes_left);
 951                 i = text - text_start;
 952                 if (!ch)
 953                         break;
 954                 if (ch == ' ' && !fontmap)
 955                 {
 956                         if(!least_one || i0) // never skip the first character
 957                         if(x + width_of[(int) ' '] * dw > maxwidth)
 958                         {
 959                                 i = i0;
 960                                 break; // oops, can't draw this
 961                         }
 962                         x += width_of[(int) ' '] * dw;
 963                         continue;
 964                 }
 965                 // i points to the char after ^
 966                 if (ch == STRING_COLOR_TAG && !ignorecolorcodes && i < *maxlen)
 967                 {
 968                         ch = *text; // colors are ascii, so no u8_ needed
 969                         if (ch <= '9' && ch >= '0') // ^[0-9] found
 970                         {
 971                                 colorindex = ch - '0';
 972                                 ++text;
 973                                 ++i;
 974                                 continue;
 975                         }
 976                         // i points to the char after ^...
 977                         // i+3 points to 3 in ^x123
 978                         // i+3 == *maxlen would mean that char is missing
 979                         else if (ch == STRING_COLOR_RGB_TAG_CHAR && i + 3 < *maxlen ) // ^x found
 980                         {
 981                                 // building colorindex...
 982                                 ch = tolower(text[1]);
 983                                 tempcolorindex = 0x10000; // binary: 1,0000,0000,0000,0000
 984                                 if (ch <= '9' && ch >= '0') tempcolorindex |= (ch - '0') << 12;
 985                                 else if (ch >= 'a' && ch <= 'f') tempcolorindex |= (ch - 87) << 12;
 986                                 else tempcolorindex = 0;
 987                                 if (tempcolorindex)
 988                                 {
 989                                         ch = tolower(text[2]);
 990                                         if (ch <= '9' && ch >= '0') tempcolorindex |= (ch - '0') << 8;
 991                                         else if (ch >= 'a' && ch <= 'f') tempcolorindex |= (ch - 87) << 8;
 992                                         else tempcolorindex = 0;
 993                                         if (tempcolorindex)
 994                                         {
 995                                                 ch = tolower(text[3]);
 996                                                 if (ch <= '9' && ch >= '0') tempcolorindex |= (ch - '0') << 4;
 997                                                 else if (ch >= 'a' && ch <= 'f') tempcolorindex |= (ch - 87) << 4;
 998                                                 else tempcolorindex = 0;
 999                                                 if (tempcolorindex)
1000                                                 {
1001                                                         colorindex = tempcolorindex | 0xf;
1002                                                         // ...done! now colorindex has rgba codes (1,rrrr,gggg,bbbb,aaaa)
1003                                                         i+=4;
1004                                                         text += 4;
1005                                                         continue;
1006                                                 }
1007                                         }
1008                                 }
1009                         }
1010                         else if (ch == STRING_COLOR_TAG) // ^^ found, ignore the first ^ and go to print the second
1011                         {
1012                                 i++;
1013                                 text++;
1014                         }
1015                         i--;
1016                 }
1017                 ch = nextch;
1018
1019                 if (!fontmap || (ch <= 0xFF && fontmap->glyphs[ch].image) || (ch >= 0xE000 && ch <= 0xE0FF))
1020                 {
1021                         if (ch > 0xE000)
1022                                 ch -= 0xE000;
1023                         if (ch > 0xFF)
1024                                 continue;
1025                         if (fontmap)
1026                                 map = ft2_oldstyle_map;
1027                         prevch = 0;
1028                         if(!least_one || i0) // never skip the first character
1029                         if(x + width_of[ch] * dw > maxwidth)
1030                         {
1031                                 i = i0;
1032                                 break; // oops, can't draw this
1033                         }
1034                         x += width_of[ch] * dw;
1035                 } else {
1036                         if (!map || map == ft2_oldstyle_map || ch < map->start || ch >= map->start + FONT_CHARS_PER_MAP)
1037                         {
1038                                 map = FontMap_FindForChar(fontmap, ch);
1039                                 if (!map)
1040                                 {
1041                                         if (!Font_LoadMapForIndex(ft2, map_index, ch, &map))
1042                                                 break;
1043                                         if (!map)
1044                                                 break;
1045                                 }
1046                         }
1047                         mapch = ch - map->start;
1048                         if (prevch && Font_GetKerningForMap(ft2, map_index, w, h, prevch, ch, &kx, NULL))
1049                                 x += kx * dw;
1050                         x += map->glyphs[mapch].advance_x * dw;
1051                         //prevmap = map;
1052                         prevch = ch;
1053                 }
1054         }
1055
1056         *maxlen = i;
1057
1058         if (outcolor)
1059                 *outcolor = colorindex;
1060
1061         return x;
1062 }
1063
1064 float DrawQ_Color[4];
1065 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)
1066 {
1067         int shadow, colorindex = STRING_COLOR_DEFAULT;
1068         size_t i;
1069         float x = startx, y, s, t, u, v, thisw;
1070         Uchar ch, mapch, nextch;
1071         Uchar prevch = 0; // used for kerning
1072         int tempcolorindex;
1073         int map_index = 0;
1074         //ft2_font_map_t *prevmap = NULL; // the previous map
1075         ft2_font_map_t *map = NULL;     // the currently used map
1076         ft2_font_map_t *fontmap = NULL; // the font map for the size
1077         float ftbase_y;
1078         const char *text_start = text;
1079         float kx, ky;
1080         ft2_font_t *ft2 = fnt->ft2;
1081         qboolean snap = true;
1082         float pix_x, pix_y;
1083         size_t bytes_left;
1084         float dw, dh;
1085         const float *width_of;
1086         dp_model_t *mod = CL_Mesh_UI();
1087         msurface_t *surf = NULL;
1088         int e0, e1, e2, e3;
1089         int tw, th;
1090         tw = Draw_GetPicWidth(fnt->pic);
1091         th = Draw_GetPicHeight(fnt->pic);
1092
1093         if (!h) h = w;
1094         if (!h) {
1095                 h = w = 1;
1096                 snap = false;
1097         }
1098
1099         starty -= (fnt->settings.scale - 1) * h * 0.5 - fnt->settings.voffset*h; // center & offset
1100         w *= fnt->settings.scale;
1101         h *= fnt->settings.scale;
1102
1103         if (ft2 != NULL)
1104         {
1105                 if (snap)
1106                         map_index = Font_IndexForSize(ft2, h, &w, &h);
1107                 else
1108                         map_index = Font_IndexForSize(ft2, h, NULL, NULL);
1109                 fontmap = Font_MapForIndex(ft2, map_index);
1110         }
1111
1112         dw = w * sw;
1113         dh = h * sh;
1114
1115         // draw the font at its baseline when using freetype
1116         //ftbase_x = 0;
1117         ftbase_y = dh * (4.5/6.0);
1118
1119         if (maxlen < 1)
1120                 maxlen = 1<<30;
1121
1122         if(!r_draw2d.integer && !r_draw2d_force)
1123                 return startx + DrawQ_TextWidth_UntilWidth_TrackColors_Scale(text, &maxlen, w, h, sw, sh, NULL, ignorecolorcodes, fnt, 1000000000);
1124
1125         //ftbase_x = snap_to_pixel_x(ftbase_x);
1126         if(snap)
1127         {
1128                 startx = snap_to_pixel_x(startx, 0.4);
1129                 starty = snap_to_pixel_y(starty, 0.4);
1130                 ftbase_y = snap_to_pixel_y(ftbase_y, 0.3);
1131         }
1132
1133         pix_x = vid.width / vid_conwidth.value;
1134         pix_y = vid.height / vid_conheight.value;
1135
1136         if (fontmap)
1137                 width_of = fontmap->width_of;
1138         else
1139                 width_of = fnt->width_of;
1140
1141         for (shadow = r_textshadow.value != 0 && basealpha > 0;shadow >= 0;shadow--)
1142         {
1143                 prevch = 0;
1144                 text = text_start;
1145
1146                 if (!outcolor || *outcolor == -1)
1147                         colorindex = STRING_COLOR_DEFAULT;
1148                 else
1149                         colorindex = *outcolor;
1150
1151                 DrawQ_GetTextColor(DrawQ_Color, colorindex, basered, basegreen, baseblue, basealpha, shadow != 0);
1152
1153                 x = startx;
1154                 y = starty;
1155                 /*
1156                 if (shadow)
1157                 {
1158                         x += r_textshadow.value * vid.width / vid_conwidth.value;
1159                         y += r_textshadow.value * vid.height / vid_conheight.value;
1160                 }
1161                 */
1162                 while (((bytes_left = maxlen - (text - text_start)) > 0) && *text)
1163                 {
1164                         nextch = ch = u8_getnchar(text, &text, bytes_left);
1165                         i = text - text_start;
1166                         if (!ch)
1167                                 break;
1168                         if (ch == ' ' && !fontmap)
1169                         {
1170                                 x += width_of[(int) ' '] * dw;
1171                                 continue;
1172                         }
1173                         if (ch == STRING_COLOR_TAG && !ignorecolorcodes && i < maxlen)
1174                         {
1175                                 ch = *text; // colors are ascii, so no u8_ needed
1176                                 if (ch <= '9' && ch >= '0') // ^[0-9] found
1177                                 {
1178                                         colorindex = ch - '0';
1179                                         DrawQ_GetTextColor(DrawQ_Color, colorindex, basered, basegreen, baseblue, basealpha, shadow != 0);
1180                                         ++text;
1181                                         ++i;
1182                                         continue;
1183                                 }
1184                                 else if (ch == STRING_COLOR_RGB_TAG_CHAR && i+3 < maxlen ) // ^x found
1185                                 {
1186                                         // building colorindex...
1187                                         ch = tolower(text[1]);
1188                                         tempcolorindex = 0x10000; // binary: 1,0000,0000,0000,0000
1189                                         if (ch <= '9' && ch >= '0') tempcolorindex |= (ch - '0') << 12;
1190                                         else if (ch >= 'a' && ch <= 'f') tempcolorindex |= (ch - 87) << 12;
1191                                         else tempcolorindex = 0;
1192                                         if (tempcolorindex)
1193                                         {
1194                                                 ch = tolower(text[2]);
1195                                                 if (ch <= '9' && ch >= '0') tempcolorindex |= (ch - '0') << 8;
1196                                                 else if (ch >= 'a' && ch <= 'f') tempcolorindex |= (ch - 87) << 8;
1197                                                 else tempcolorindex = 0;
1198                                                 if (tempcolorindex)
1199                                                 {
1200                                                         ch = tolower(text[3]);
1201                                                         if (ch <= '9' && ch >= '0') tempcolorindex |= (ch - '0') << 4;
1202                                                         else if (ch >= 'a' && ch <= 'f') tempcolorindex |= (ch - 87) << 4;
1203                                                         else tempcolorindex = 0;
1204                                                         if (tempcolorindex)
1205                                                         {
1206                                                                 colorindex = tempcolorindex | 0xf;
1207                                                                 // ...done! now colorindex has rgba codes (1,rrrr,gggg,bbbb,aaaa)
1208                                                                 //Con_Printf("^1colorindex:^7 %x\n", colorindex);
1209                                                                 DrawQ_GetTextColor(DrawQ_Color, colorindex, basered, basegreen, baseblue, basealpha, shadow != 0);
1210                                                                 i+=4;
1211                                                                 text+=4;
1212                                                                 continue;
1213                                                         }
1214                                                 }
1215                                         }
1216                                 }
1217                                 else if (ch == STRING_COLOR_TAG)
1218                                 {
1219                                         i++;
1220                                         text++;
1221                                 }
1222                                 i--;
1223                         }
1224                         // get the backup
1225                         ch = nextch;
1226                         // using a value of -1 for the oldstyle map because NULL means uninitialized...
1227                         // this way we don't need to rebind fnt->tex for every old-style character
1228                         // E000..E0FF: emulate old-font characters (to still have smileys and such available)
1229                         if (shadow)
1230                         {
1231                                 x += 1.0/pix_x * r_textshadow.value;
1232                                 y += 1.0/pix_y * r_textshadow.value;
1233                         }
1234                         if (!fontmap || (ch <= 0xFF && fontmap->glyphs[ch].image) || (ch >= 0xE000 && ch <= 0xE0FF))
1235                         {
1236                                 if (ch >= 0xE000)
1237                                         ch -= 0xE000;
1238                                 if (ch > 0xFF)
1239                                         goto out;
1240                                 if (fontmap)
1241                                         map = ft2_oldstyle_map;
1242                                 prevch = 0;
1243                                 //num = (unsigned char) text[i];
1244                                 //thisw = fnt->width_of[num];
1245                                 thisw = fnt->width_of[ch];
1246                                 // FIXME make these smaller to just include the occupied part of the character for slightly faster rendering
1247                                 if (r_nearest_conchars.integer)
1248                                 {
1249                                         s = (ch & 15)*0.0625f;
1250                                         t = (ch >> 4)*0.0625f;
1251                                         u = 0.0625f * thisw;
1252                                         v = 0.0625f;
1253                                 }
1254                                 else
1255                                 {
1256                                         s = (ch & 15)*0.0625f + (0.5f / tw);
1257                                         t = (ch >> 4)*0.0625f + (0.5f / th);
1258                                         u = 0.0625f * thisw - (1.0f / tw);
1259                                         v = 0.0625f - (1.0f / th);
1260                                 }
1261                                 surf = Mod_Mesh_AddSurface(mod, Mod_Mesh_GetTexture(mod, fnt->pic->name, flags, TEXF_ALPHA | TEXF_CLAMP, MATERIALFLAG_VERTEXCOLOR), true);
1262                                 e0 = Mod_Mesh_IndexForVertex(mod, surf, x         , y   , 10, 0, 0, -1, s  , t  , 0, 0, DrawQ_Color[0], DrawQ_Color[1], DrawQ_Color[2], DrawQ_Color[3]);
1263                                 e1 = Mod_Mesh_IndexForVertex(mod, surf, x+dw*thisw, y   , 10, 0, 0, -1, s+u, t  , 0, 0, DrawQ_Color[0], DrawQ_Color[1], DrawQ_Color[2], DrawQ_Color[3]);
1264                                 e2 = Mod_Mesh_IndexForVertex(mod, surf, x+dw*thisw, y+dh, 10, 0, 0, -1, s+u, t+v, 0, 0, DrawQ_Color[0], DrawQ_Color[1], DrawQ_Color[2], DrawQ_Color[3]);
1265                                 e3 = Mod_Mesh_IndexForVertex(mod, surf, x         , y+dh, 10, 0, 0, -1, s  , t+v, 0, 0, DrawQ_Color[0], DrawQ_Color[1], DrawQ_Color[2], DrawQ_Color[3]);
1266                                 Mod_Mesh_AddTriangle(mod, surf, e0, e1, e2);
1267                                 Mod_Mesh_AddTriangle(mod, surf, e0, e2, e3);
1268                                 x += width_of[ch] * dw;
1269                         } else {
1270                                 if (!map || map == ft2_oldstyle_map || ch < map->start || ch >= map->start + FONT_CHARS_PER_MAP)
1271                                 {
1272                                         // find the new map
1273                                         map = FontMap_FindForChar(fontmap, ch);
1274                                         if (!map)
1275                                         {
1276                                                 if (!Font_LoadMapForIndex(ft2, map_index, ch, &map))
1277                                                 {
1278                                                         shadow = -1;
1279                                                         break;
1280                                                 }
1281                                                 if (!map)
1282                                                 {
1283                                                         // this shouldn't happen
1284                                                         shadow = -1;
1285                                                         break;
1286                                                 }
1287                                         }
1288                                 }
1289
1290                                 mapch = ch - map->start;
1291                                 thisw = map->glyphs[mapch].advance_x;
1292
1293                                 //x += ftbase_x;
1294                                 y += ftbase_y;
1295                                 if (prevch && Font_GetKerningForMap(ft2, map_index, w, h, prevch, ch, &kx, &ky))
1296                                 {
1297                                         x += kx * dw;
1298                                         y += ky * dh;
1299                                 }
1300                                 else
1301                                         kx = ky = 0;
1302                                 surf = Mod_Mesh_AddSurface(mod, Mod_Mesh_GetTexture(mod, map->pic->name, flags, TEXF_ALPHA | TEXF_CLAMP, MATERIALFLAG_VERTEXCOLOR), true);
1303                                 e0 = Mod_Mesh_IndexForVertex(mod, surf, x + dw * map->glyphs[mapch].vxmin, y + dh * map->glyphs[mapch].vymin, 10, 0, 0, -1, map->glyphs[mapch].txmin, map->glyphs[mapch].tymin, 0, 0, DrawQ_Color[0], DrawQ_Color[1], DrawQ_Color[2], DrawQ_Color[3]);
1304                                 e1 = Mod_Mesh_IndexForVertex(mod, surf, x + dw * map->glyphs[mapch].vxmax, y + dh * map->glyphs[mapch].vymin, 10, 0, 0, -1, map->glyphs[mapch].txmax, map->glyphs[mapch].tymin, 0, 0, DrawQ_Color[0], DrawQ_Color[1], DrawQ_Color[2], DrawQ_Color[3]);
1305                                 e2 = Mod_Mesh_IndexForVertex(mod, surf, x + dw * map->glyphs[mapch].vxmax, y + dh * map->glyphs[mapch].vymax, 10, 0, 0, -1, map->glyphs[mapch].txmax, map->glyphs[mapch].tymax, 0, 0, DrawQ_Color[0], DrawQ_Color[1], DrawQ_Color[2], DrawQ_Color[3]);
1306                                 e3 = Mod_Mesh_IndexForVertex(mod, surf, x + dw * map->glyphs[mapch].vxmin, y + dh * map->glyphs[mapch].vymax, 10, 0, 0, -1, map->glyphs[mapch].txmin, map->glyphs[mapch].tymax, 0, 0, DrawQ_Color[0], DrawQ_Color[1], DrawQ_Color[2], DrawQ_Color[3]);
1307                                 Mod_Mesh_AddTriangle(mod, surf, e0, e1, e2);
1308                                 Mod_Mesh_AddTriangle(mod, surf, e0, e2, e3);
1309                                 //x -= ftbase_x;
1310                                 y -= ftbase_y;
1311
1312                                 x += thisw * dw;
1313
1314                                 //prevmap = map;
1315                                 prevch = ch;
1316                         }
1317 out:
1318                         if (shadow)
1319                         {
1320                                 x -= 1.0/pix_x * r_textshadow.value;
1321                                 y -= 1.0/pix_y * r_textshadow.value;
1322                         }
1323                 }
1324         }
1325
1326         if (outcolor)
1327                 *outcolor = colorindex;
1328
1329         // note: this relies on the proper text (not shadow) being drawn last
1330         return x;
1331 }
1332
1333 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)
1334 {
1335         return DrawQ_String_Scale(startx, starty, text, maxlen, w, h, 1, 1, basered, basegreen, baseblue, basealpha, flags, outcolor, ignorecolorcodes, fnt);
1336 }
1337
1338 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)
1339 {
1340         return DrawQ_TextWidth_UntilWidth_TrackColors_Scale(text, maxlen, w, h, 1, 1, outcolor, ignorecolorcodes, fnt, maxwidth);
1341 }
1342
1343 float DrawQ_TextWidth(const char *text, size_t maxlen, float w, float h, qboolean ignorecolorcodes, const dp_font_t *fnt)
1344 {
1345         return DrawQ_TextWidth_UntilWidth(text, &maxlen, w, h, ignorecolorcodes, fnt, 1000000000);
1346 }
1347
1348 float DrawQ_TextWidth_UntilWidth(const char *text, size_t *maxlen, float w, float h, qboolean ignorecolorcodes, const dp_font_t *fnt, float maxWidth)
1349 {
1350         return DrawQ_TextWidth_UntilWidth_TrackColors(text, maxlen, w, h, NULL, ignorecolorcodes, fnt, maxWidth);
1351 }
1352
1353 #if 0
1354 // not used
1355 // no ^xrgb management
1356 static int DrawQ_BuildColoredText(char *output2c, size_t maxoutchars, const char *text, int maxreadchars, qboolean ignorecolorcodes, int *outcolor)
1357 {
1358         int color, numchars = 0;
1359         char *outputend2c = output2c + maxoutchars - 2;
1360         if (!outcolor || *outcolor == -1)
1361                 color = STRING_COLOR_DEFAULT;
1362         else
1363                 color = *outcolor;
1364         if (!maxreadchars)
1365                 maxreadchars = 1<<30;
1366         textend = text + maxreadchars;
1367         while (text != textend && *text)
1368         {
1369                 if (*text == STRING_COLOR_TAG && !ignorecolorcodes && text + 1 != textend)
1370                 {
1371                         if (text[1] == STRING_COLOR_TAG)
1372                                 text++;
1373                         else if (text[1] >= '0' && text[1] <= '9')
1374                         {
1375                                 color = text[1] - '0';
1376                                 text += 2;
1377                                 continue;
1378                         }
1379                 }
1380                 if (output2c >= outputend2c)
1381                         break;
1382                 *output2c++ = *text++;
1383                 *output2c++ = color;
1384                 numchars++;
1385         }
1386         output2c[0] = output2c[1] = 0;
1387         if (outcolor)
1388                 *outcolor = color;
1389         return numchars;
1390 }
1391 #endif
1392
1393 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)
1394 {
1395         dp_model_t *mod = CL_Mesh_UI();
1396         msurface_t *surf;
1397         int e0, e1, e2, e3;
1398         if (!pic)
1399                 pic = Draw_CachePic("white");
1400         // make sure pic is loaded - we don't use the texture here, Mod_Mesh_GetTexture looks up the skinframe by name
1401         Draw_GetPicTexture(pic);
1402         if (width == 0)
1403                 width = pic->width;
1404         if (height == 0)
1405                 height = pic->height;
1406         surf = Mod_Mesh_AddSurface(mod, Mod_Mesh_GetTexture(mod, pic->name, flags, pic->texflags, MATERIALFLAG_VERTEXCOLOR), true);
1407         e0 = Mod_Mesh_IndexForVertex(mod, surf, x        , y         , 0, 0, 0, -1, s1, t1, 0, 0, r1, g1, b1, a1);
1408         e1 = Mod_Mesh_IndexForVertex(mod, surf, x + width, y         , 0, 0, 0, -1, s2, t2, 0, 0, r2, g2, b2, a2);
1409         e2 = Mod_Mesh_IndexForVertex(mod, surf, x + width, y + height, 0, 0, 0, -1, s4, t4, 0, 0, r4, g4, b4, a4);
1410         e3 = Mod_Mesh_IndexForVertex(mod, surf, x        , y + height, 0, 0, 0, -1, s3, t3, 0, 0, r3, g3, b3, a3);
1411         Mod_Mesh_AddTriangle(mod, surf, e0, e1, e2);
1412         Mod_Mesh_AddTriangle(mod, surf, e0, e2, e3);
1413 }
1414
1415 void DrawQ_Line (float width, float x1, float y1, float x2, float y2, float r, float g, float b, float alpha, int flags)
1416 {
1417         dp_model_t *mod = CL_Mesh_UI();
1418         msurface_t *surf;
1419         int e0, e1, e2, e3;
1420         float offsetx, offsety;
1421         // width is measured in real pixels
1422         if (fabs(x2 - x1) > fabs(y2 - y1))
1423         {
1424                 offsetx = 0;
1425                 offsety = 0.5f * width * vid_conheight.value / vid.height;
1426         }
1427         else
1428         {
1429                 offsetx = 0.5f * width * vid_conwidth.value / vid.width;
1430                 offsety = 0;
1431         }
1432         surf = Mod_Mesh_AddSurface(mod, Mod_Mesh_GetTexture(mod, "white", 0, 0, MATERIALFLAG_VERTEXCOLOR), true);
1433         e0 = Mod_Mesh_IndexForVertex(mod, surf, x1 - offsetx, y1 - offsety, 10, 0, 0, -1, 0, 0, 0, 0, r, g, b, alpha);
1434         e1 = Mod_Mesh_IndexForVertex(mod, surf, x2 - offsetx, y2 - offsety, 10, 0, 0, -1, 0, 0, 0, 0, r, g, b, alpha);
1435         e2 = Mod_Mesh_IndexForVertex(mod, surf, x2 + offsetx, y2 + offsety, 10, 0, 0, -1, 0, 0, 0, 0, r, g, b, alpha);
1436         e3 = Mod_Mesh_IndexForVertex(mod, surf, x1 + offsetx, y1 + offsety, 10, 0, 0, -1, 0, 0, 0, 0, r, g, b, alpha);
1437         Mod_Mesh_AddTriangle(mod, surf, e0, e1, e2);
1438         Mod_Mesh_AddTriangle(mod, surf, e0, e2, e3);
1439 }
1440
1441 void DrawQ_SetClipArea(float x, float y, float width, float height)
1442 {
1443         int ix, iy, iw, ih;
1444         DrawQ_FlushUI();
1445
1446         // We have to convert the con coords into real coords
1447         // OGL uses bottom to top (origin is in bottom left)
1448         ix = (int)(0.5 + x * ((float)r_refdef.view.width / vid_conwidth.integer)) + r_refdef.view.x;
1449         iy = (int)(0.5 + y * ((float)r_refdef.view.height / vid_conheight.integer)) + r_refdef.view.y;
1450         iw = (int)(0.5 + width * ((float)r_refdef.view.width / vid_conwidth.integer));
1451         ih = (int)(0.5 + height * ((float)r_refdef.view.height / vid_conheight.integer));
1452         switch(vid.renderpath)
1453         {
1454         case RENDERPATH_GL32:
1455         case RENDERPATH_GLES2:
1456                 GL_Scissor(ix, vid.height - iy - ih, iw, ih);
1457                 break;
1458         }
1459
1460         GL_ScissorTest(true);
1461 }
1462
1463 void DrawQ_ResetClipArea(void)
1464 {
1465         DrawQ_FlushUI();
1466         GL_ScissorTest(false);
1467 }
1468
1469 void DrawQ_Finish(void)
1470 {
1471         DrawQ_FlushUI();
1472         r_refdef.draw2dstage = 0;
1473 }
1474
1475 void DrawQ_RecalcView(void)
1476 {
1477         DrawQ_FlushUI();
1478         if(r_refdef.draw2dstage)
1479                 r_refdef.draw2dstage = -1; // next draw call will set viewport etc. again
1480 }
1481
1482 void DrawQ_FlushUI(void)
1483 {
1484         int i;
1485         dp_model_t *mod = CL_Mesh_UI();
1486         if (mod->num_surfaces == 0)
1487                 return;
1488
1489         if (!r_draw2d.integer && !r_draw2d_force)
1490         {
1491                 Mod_Mesh_Reset(mod);
1492                 return;
1493         }
1494
1495         // TODO: render the mesh using R_Q1BSP_Draw or similar, for full material support.
1496         GL_DepthMask(false);
1497         R_Mesh_PrepareVertices_Generic_Arrays(mod->surfmesh.num_vertices, mod->surfmesh.data_vertex3f, mod->surfmesh.data_lightmapcolor4f, mod->surfmesh.data_texcoordtexture2f);
1498         for (i = 0; i < mod->num_surfaces; i++)
1499         {
1500                 msurface_t *surf = mod->data_surfaces + i;
1501                 texture_t *tex = surf->texture;
1502                 if (tex->currentmaterialflags & MATERIALFLAG_CUSTOMBLEND)
1503                         GL_BlendFunc(tex->customblendfunc[0], tex->customblendfunc[1]);
1504                 else if (tex->currentmaterialflags & MATERIALFLAG_ADD)
1505                         GL_BlendFunc(GL_SRC_ALPHA, GL_ONE);
1506                 else if (tex->currentmaterialflags & MATERIALFLAG_ALPHA)
1507                         GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
1508                 else
1509                         GL_BlendFunc(GL_ONE, GL_ZERO);
1510                 R_SetupShader_Generic(tex->currentskinframe->base, (tex->currentmaterialflags & MATERIALFLAG_CUSTOMBLEND) ? false : true, true, false);
1511                 R_Mesh_Draw(surf->num_firstvertex, surf->num_vertices, surf->num_firsttriangle, surf->num_triangles, mod->surfmesh.data_element3i, NULL, 0, mod->surfmesh.data_element3s, NULL, 0);
1512         }
1513
1514         Mod_Mesh_Reset(mod);
1515 }