ft2.c

   1 /* FreeType 2 and UTF-8 encoding support for
   2  * DarkPlaces
   3  */
   4 #include "quakedef.h"
   5
   6 #include "ft2.h"
   7 #include "ft2_defs.h"
   8 #include "ft2_fontdefs.h"
   9
  10 static int img_fontmap[256] = {
  11         1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
  12         1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
  13         1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // shift+digit line
  14         1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // digits
  15         1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // caps
  16         1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // caps
  17         1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // small
  18         1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // small
  19         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // specials
  20         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // faces
  21         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  22         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  23         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  24         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  25         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  26         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
  27 };
  28
  29 /*
  30 ================================================================================
  31 CVars introduced with the freetype extension
  32 ================================================================================
  33 */
  34
  35 cvar_t r_font_disable_freetype = {CVAR_SAVE, "r_font_disable_freetype", "1", "disable freetype support for fonts entirely"};
  36 cvar_t r_font_use_alpha_textures = {CVAR_SAVE, "r_font_use_alpha_textures", "0", "use alpha-textures for font rendering, this should safe memory"};
  37 cvar_t r_font_size_snapping = {CVAR_SAVE, "r_font_size_snapping", "1", "stick to good looking font sizes whenever possible - bad when the mod doesn't support it!"};
  38 cvar_t r_font_hinting = {CVAR_SAVE, "r_font_hinting", "3", "0 = no hinting, 1 = light autohinting, 2 = full autohinting, 3 = full hinting"};
  39 cvar_t r_font_antialias = {CVAR_SAVE, "r_font_antialias", "1", "0 = monochrome, 1 = grey" /* , 2 = rgb, 3 = bgr" */};
  40 cvar_t r_font_kerning = {CVAR_SAVE, "r_font_kerning", "1", "Use kerning if available"};
  41 cvar_t developer_font = {CVAR_SAVE, "developer_font", "0", "prints debug messages about fonts"};
  42
  43 /*
  44 ================================================================================
  45 Function definitions. Taken from the freetype2 headers.
  46 ================================================================================
  47 */
  48
  49
  50 FT_EXPORT( FT_Error )
  51 (*qFT_Init_FreeType)( FT_Library  *alibrary );
  52 FT_EXPORT( FT_Error )
  53 (*qFT_Done_FreeType)( FT_Library  library );
  54 /*
  55 FT_EXPORT( FT_Error )
  56 (*qFT_New_Face)( FT_Library   library,
  57                  const char*  filepathname,
  58                  FT_Long      face_index,
  59                  FT_Face     *aface );
  60 */
  61 FT_EXPORT( FT_Error )
  62 (*qFT_New_Memory_Face)( FT_Library      library,
  63                         const FT_Byte*  file_base,
  64                         FT_Long         file_size,
  65                         FT_Long         face_index,
  66                         FT_Face        *aface );
  67 FT_EXPORT( FT_Error )
  68 (*qFT_Done_Face)( FT_Face  face );
  69 FT_EXPORT( FT_Error )
  70 (*qFT_Select_Size)( FT_Face  face,
  71                     FT_Int   strike_index );
  72 FT_EXPORT( FT_Error )
  73 (*qFT_Request_Size)( FT_Face          face,
  74                      FT_Size_Request  req );
  75 FT_EXPORT( FT_Error )
  76 (*qFT_Set_Char_Size)( FT_Face     face,
  77                       FT_F26Dot6  char_width,
  78                       FT_F26Dot6  char_height,
  79                       FT_UInt     horz_resolution,
  80                       FT_UInt     vert_resolution );
  81 FT_EXPORT( FT_Error )
  82 (*qFT_Set_Pixel_Sizes)( FT_Face  face,
  83                         FT_UInt  pixel_width,
  84                         FT_UInt  pixel_height );
  85 FT_EXPORT( FT_Error )
  86 (*qFT_Load_Glyph)( FT_Face   face,
  87                    FT_UInt   glyph_index,
  88                    FT_Int32  load_flags );
  89 FT_EXPORT( FT_Error )
  90 (*qFT_Load_Char)( FT_Face   face,
  91                   FT_ULong  char_code,
  92                   FT_Int32  load_flags );
  93 FT_EXPORT( FT_UInt )
  94 (*qFT_Get_Char_Index)( FT_Face   face,
  95                        FT_ULong  charcode );
  96 FT_EXPORT( FT_Error )
  97 (*qFT_Render_Glyph)( FT_GlyphSlot    slot,
  98                      FT_Render_Mode  render_mode );
  99 FT_EXPORT( FT_Error )
 100 (*qFT_Get_Kerning)( FT_Face     face,
 101                     FT_UInt     left_glyph,
 102                     FT_UInt     right_glyph,
 103                     FT_UInt     kern_mode,
 104                     FT_Vector  *akerning );
 105 FT_EXPORT( FT_Error )
 106 (*qFT_Attach_Stream)( FT_Face        face,
 107                       FT_Open_Args*  parameters );
 108 /*
 109 ================================================================================
 110 Support for dynamically loading the FreeType2 library
 111 ================================================================================
 112 */
 113
 114 static dllfunction_t ft2funcs[] =
 115 {
 116         {"FT_Init_FreeType",            (void **) &qFT_Init_FreeType},
 117         {"FT_Done_FreeType",            (void **) &qFT_Done_FreeType},
 118         //{"FT_New_Face",                       (void **) &qFT_New_Face},
 119         {"FT_New_Memory_Face",          (void **) &qFT_New_Memory_Face},
 120         {"FT_Done_Face",                (void **) &qFT_Done_Face},
 121         {"FT_Select_Size",              (void **) &qFT_Select_Size},
 122         {"FT_Request_Size",             (void **) &qFT_Request_Size},
 123         {"FT_Set_Char_Size",            (void **) &qFT_Set_Char_Size},
 124         {"FT_Set_Pixel_Sizes",          (void **) &qFT_Set_Pixel_Sizes},
 125         {"FT_Load_Glyph",               (void **) &qFT_Load_Glyph},
 126         {"FT_Load_Char",                (void **) &qFT_Load_Char},
 127         {"FT_Get_Char_Index",           (void **) &qFT_Get_Char_Index},
 128         {"FT_Render_Glyph",             (void **) &qFT_Render_Glyph},
 129         {"FT_Get_Kerning",              (void **) &qFT_Get_Kerning},
 130         {"FT_Attach_Stream",            (void **) &qFT_Attach_Stream},
 131         {NULL, NULL}
 132 };
 133
 134 /// Handle for FreeType2 DLL
 135 static dllhandle_t ft2_dll = NULL;
 136
 137 /// Memory pool for fonts
 138 static mempool_t *font_mempool= NULL;
 139 static rtexturepool_t *font_texturepool = NULL;
 140
 141 /// FreeType library handle
 142 static FT_Library font_ft2lib = NULL;
 143
 144 /*
 145 ====================
 146 Font_CloseLibrary
 147
 148 Unload the FreeType2 DLL
 149 ====================
 150 */
 151 void Font_CloseLibrary (void)
 152 {
 153         if (font_mempool)
 154                 Mem_FreePool(&font_mempool);
 155         if (font_texturepool)
 156                 R_FreeTexturePool(&font_texturepool);
 157         if (font_ft2lib && qFT_Done_FreeType)
 158         {
 159                 qFT_Done_FreeType(font_ft2lib);
 160                 font_ft2lib = NULL;
 161         }
 162         Sys_UnloadLibrary (&ft2_dll);
 163 }
 164
 165 /*
 166 ====================
 167 Font_OpenLibrary
 168
 169 Try to load the FreeType2 DLL
 170 ====================
 171 */
 172 qboolean Font_OpenLibrary (void)
 173 {
 174         const char* dllnames [] =
 175         {
 176 #if defined(WIN32)
 177                 "freetype6.dll",
 178                 "libfreetype-6.dll",
 179 #elif defined(MACOSX)
 180                 "libfreetype.6.dylib",
 181                 "libfreetype.dylib",
 182 #else
 183                 "libfreetype.so.6",
 184                 "libfreetype.so",
 185 #endif
 186                 NULL
 187         };
 188
 189         if (r_font_disable_freetype.integer)
 190                 return false;
 191
 192         // Already loaded?
 193         if (ft2_dll)
 194                 return true;
 195
 196         // Load the DLL
 197         if (!Sys_LoadLibrary (dllnames, &ft2_dll, ft2funcs))
 198                 return false;
 199         return true;
 200 }
 201
 202 /*
 203 ====================
 204 Font_Init
 205
 206 Initialize the freetype2 font subsystem
 207 ====================
 208 */
 209
 210 void font_start(void)
 211 {
 212         if (!Font_OpenLibrary())
 213                 return;
 214
 215         if (qFT_Init_FreeType(&font_ft2lib))
 216         {
 217                 Con_Print("ERROR: Failed to initialize the FreeType2 library!\n");
 218                 Font_CloseLibrary();
 219                 return;
 220         }
 221
 222         font_mempool = Mem_AllocPool("FONT", 0, NULL);
 223         if (!font_mempool)
 224         {
 225                 Con_Print("ERROR: Failed to allocate FONT memory pool!\n");
 226                 Font_CloseLibrary();
 227                 return;
 228         }
 229
 230         font_texturepool = R_AllocTexturePool();
 231         if (!font_texturepool)
 232         {
 233                 Con_Print("ERROR: Failed to allocate FONT texture pool!\n");
 234                 Font_CloseLibrary();
 235                 return;
 236         }
 237 }
 238
 239 void font_shutdown(void)
 240 {
 241         int i;
 242         for (i = 0; i < MAX_FONTS; ++i)
 243         {
 244                 if (dp_fonts[i].ft2)
 245                 {
 246                         Font_UnloadFont(dp_fonts[i].ft2);
 247                         dp_fonts[i].ft2 = NULL;
 248                 }
 249         }
 250         Font_CloseLibrary();
 251 }
 252
 253 void font_newmap(void)
 254 {
 255 }
 256
 257 void Font_Init(void)
 258 {
 259         Cvar_RegisterVariable(&r_font_disable_freetype);
 260         Cvar_RegisterVariable(&r_font_use_alpha_textures);
 261         Cvar_RegisterVariable(&r_font_size_snapping);
 262         Cvar_RegisterVariable(&r_font_hinting);
 263         Cvar_RegisterVariable(&r_font_antialias);
 264         Cvar_RegisterVariable(&r_font_kerning);
 265         Cvar_RegisterVariable(&developer_font);
 266         // let's open it at startup already
 267         Font_OpenLibrary();
 268 }
 269
 270 /*
 271 ================================================================================
 272 Implementation of a more or less lazy font loading and rendering code.
 273 ================================================================================
 274 */
 275
 276 #include "ft2_fontdefs.h"
 277
 278 ft2_font_t *Font_Alloc(void)
 279 {
 280         if (!ft2_dll)
 281                 return NULL;
 282         return Mem_Alloc(font_mempool, sizeof(ft2_font_t));
 283 }
 284
 285 qboolean Font_Attach(ft2_font_t *font, ft2_attachment_t *attachment)
 286 {
 287         ft2_attachment_t *na;
 288
 289         font->attachmentcount++;
 290         na = (ft2_attachment_t*)Mem_Alloc(font_mempool, sizeof(font->attachments[0]) * font->attachmentcount);
 291         if (na == NULL)
 292                 return false;
 293         if (font->attachments && font->attachmentcount > 1)
 294         {
 295                 memcpy(na, font->attachments, sizeof(font->attachments[0]) * (font->attachmentcount - 1));
 296                 Mem_Free(font->attachments);
 297         }
 298         memcpy(na + sizeof(font->attachments[0]) * (font->attachmentcount - 1), attachment, sizeof(*attachment));
 299         font->attachments = na;
 300         return true;
 301 }
 302
 303 float Font_VirtualToRealSize(float sz)
 304 {
 305         int vh, vw, si;
 306         float sn;
 307         if(sz < 0)
 308                 return sz;
 309         vw = ((vid.width > 0) ? vid.width : vid_width.value);
 310         vh = ((vid.height > 0) ? vid.height : vid_height.value);
 311         // now try to scale to our actual size:
 312         sn = sz * vh / vid_conheight.value;
 313         si = (int)sn;
 314         if ( sn - (float)si >= 0.5 )
 315                 ++si;
 316         return si;
 317 }
 318
 319 float Font_SnapTo(float val, float snapwidth)
 320 {
 321         return floor(val / snapwidth + 0.5f) * snapwidth;
 322 }
 323
 324 static qboolean Font_LoadFile(const char *name, int _face, ft2_font_t *font);
 325 static qboolean Font_LoadSize(ft2_font_t *font, float size, qboolean check_only);
 326 qboolean Font_LoadFont(const char *name, dp_font_t *dpfnt)
 327 {
 328         int s, count, i;
 329         ft2_font_t *ft2, *fbfont, *fb;
 330
 331         ft2 = Font_Alloc();
 332         if (!ft2)
 333         {
 334                 dpfnt->ft2 = NULL;
 335                 return false;
 336         }
 337
 338         // check if a fallback font has been specified, if it has been, and the
 339         // font fails to load, use the image font as main font
 340         for (i = 0; i < MAX_FONT_FALLBACKS; ++i)
 341         {
 342                 if (dpfnt->fallbacks[i][0])
 343                         break;
 344         }
 345
 346         if (!Font_LoadFile(name, dpfnt->req_face, ft2))
 347         {
 348                 if (i >= MAX_FONT_FALLBACKS)
 349                 {
 350                         dpfnt->ft2 = NULL;
 351                         Mem_Free(ft2);
 352                         return false;
 353                 }
 354                 strlcpy(ft2->name, name, sizeof(ft2->name));
 355                 ft2->image_font = true;
 356                 ft2->has_kerning = false;
 357         }
 358         else
 359         {
 360                 ft2->image_font = false;
 361         }
 362
 363         // attempt to load fallback fonts:
 364         fbfont = ft2;
 365         for (i = 0; i < MAX_FONT_FALLBACKS; ++i)
 366         {
 367                 if (!dpfnt->fallbacks[i][0])
 368                         break;
 369                 if (! (fb = Font_Alloc()) )
 370                 {
 371                         Con_Printf("Failed to allocate font for fallback %i of font %s\n", i, name);
 372                         break;
 373                 }
 374                 if (!Font_LoadFile(dpfnt->fallbacks[i], dpfnt->fallback_faces[i], fb))
 375                 {
 376                         Con_Printf("Failed to allocate font for fallback %i of font %s\n", i, name);
 377                         Mem_Free(fb);
 378                         break;
 379                 }
 380                 count = 0;
 381                 for (s = 0; s < MAX_FONT_SIZES && dpfnt->req_sizes[s] >= 0; ++s)
 382                 {
 383                         if (Font_LoadSize(fb, Font_VirtualToRealSize(dpfnt->req_sizes[s]), true))
 384                                 ++count;
 385                 }
 386                 if (!count)
 387                 {
 388                         Con_Printf("Failed to allocate font for fallback %i of font %s\n", i, name);
 389                         Font_UnloadFont(fb);
 390                         Mem_Free(fb);
 391                         break;
 392                 }
 393                 // at least one size of the fallback font loaded successfully
 394                 // link it:
 395                 fbfont->next = fb;
 396                 fbfont = fb;
 397         }
 398
 399         if (fbfont == ft2 && ft2->image_font)
 400         {
 401                 // no fallbacks were loaded successfully:
 402                 dpfnt->ft2 = NULL;
 403                 Mem_Free(ft2);
 404                 return false;
 405         }
 406
 407         count = 0;
 408         for (s = 0; s < MAX_FONT_SIZES && dpfnt->req_sizes[s] >= 0; ++s)
 409         {
 410                 if (Font_LoadSize(ft2, Font_VirtualToRealSize(dpfnt->req_sizes[s]), false))
 411                         ++count;
 412         }
 413         if (!count)
 414         {
 415                 // loading failed for every requested size
 416                 Font_UnloadFont(ft2);
 417                 Mem_Free(ft2);
 418                 dpfnt->ft2 = NULL;
 419                 return false;
 420         }
 421
 422         //Con_Printf("%i sizes loaded\n", count);
 423         dpfnt->ft2 = ft2;
 424         return true;
 425 }
 426
 427 static qboolean Font_LoadFile(const char *name, int _face, ft2_font_t *font)
 428 {
 429         size_t namelen;
 430         char filename[MAX_QPATH];
 431         int status;
 432         size_t i;
 433         unsigned char *data;
 434         fs_offset_t datasize;
 435
 436         memset(font, 0, sizeof(*font));
 437
 438         if (!Font_OpenLibrary())
 439         {
 440                 if (!r_font_disable_freetype.integer)
 441                 {
 442                         Con_Printf("WARNING: can't open load font %s\n"
 443                                    "You need the FreeType2 DLL to load font files\n",
 444                                    name);
 445                 }
 446                 return false;
 447         }
 448
 449         namelen = strlen(name);
 450
 451         memcpy(filename, name, namelen);
 452         memcpy(filename + namelen, ".ttf", 5);
 453         data = FS_LoadFile(filename, font_mempool, false, &datasize);
 454         if (!data)
 455         {
 456                 memcpy(filename + namelen, ".otf", 5);
 457                 data = FS_LoadFile(filename, font_mempool, false, &datasize);
 458         }
 459         if (!data)
 460         {
 461                 ft2_attachment_t afm;
 462
 463                 memcpy(filename + namelen, ".pfb", 5);
 464                 data = FS_LoadFile(filename, font_mempool, false, &datasize);
 465
 466                 if (data)
 467                 {
 468                         memcpy(filename + namelen, ".afm", 5);
 469                         afm.data = FS_LoadFile(filename, font_mempool, false, &afm.size);
 470
 471                         if (afm.data)
 472                                 Font_Attach(font, &afm);
 473                 }
 474         }
 475
 476         if (!data)
 477         {
 478                 // FS_LoadFile being not-quiet should print an error :)
 479                 return false;
 480         }
 481         Con_Printf("Loading font %s face %i...\n", filename, _face);
 482
 483         status = qFT_New_Memory_Face(font_ft2lib, (FT_Bytes)data, datasize, _face, (FT_Face*)&font->face);
 484         if (status && _face != 0)
 485         {
 486                 Con_Printf("Failed to load face %i of %s. Falling back to face 0\n", _face, name);
 487                 _face = 0;
 488                 status = qFT_New_Memory_Face(font_ft2lib, (FT_Bytes)data, datasize, 0, (FT_Face*)&font->face);
 489         }
 490         if (status)
 491         {
 492                 Con_Printf("ERROR: can't create face for %s\n"
 493                            "Error %i\n", // TODO: error strings
 494                            name, status);
 495                 Font_UnloadFont(font);
 496                 return false;
 497         }
 498
 499         // add the attachments
 500         for (i = 0; i < font->attachmentcount; ++i)
 501         {
 502                 FT_Open_Args args;
 503                 memset(&args, 0, sizeof(args));
 504                 args.flags = FT_OPEN_MEMORY;
 505                 args.memory_base = (const FT_Byte*)font->attachments[i].data;
 506                 args.memory_size = font->attachments[i].size;
 507                 if (qFT_Attach_Stream(font->face, &args))
 508                         Con_Printf("Failed to add attachment %u to %s\n", (unsigned)i, font->name);
 509         }
 510
 511         memcpy(font->name, name, namelen+1);
 512         font->image_font = false;
 513         font->has_kerning = !!(((FT_Face)(font->face))->face_flags & FT_FACE_FLAG_KERNING);
 514         return true;
 515 }
 516
 517 static float Font_SearchSize(ft2_font_t *font, FT_Face fontface, float size);
 518 static qboolean Font_LoadMap(ft2_font_t *font, ft2_font_map_t *mapstart, Uchar _ch, ft2_font_map_t **outmap);
 519 static qboolean Font_LoadSize(ft2_font_t *font, float size, qboolean check_only)
 520 {
 521         int map_index;
 522         ft2_font_map_t *fmap, temp;
 523
 524         if (!(size > 0.001f && size < 1000.0f))
 525                 size = 0;
 526
 527         if (!size)
 528                 size = 16;
 529         if (size < 2) // bogus sizes are not allowed - and they screw up our allocations
 530                 return false;
 531
 532         for (map_index = 0; map_index < MAX_FONT_SIZES; ++map_index)
 533         {
 534                 if (!font->font_maps[map_index])
 535                         break;
 536                 // if a similar size has already been loaded, ignore this one
 537                 //abs(font->font_maps[map_index]->size - size) < 4
 538                 if (font->font_maps[map_index]->size == size)
 539                         return true;
 540         }
 541
 542         if (map_index >= MAX_FONT_SIZES)
 543                 return false;
 544
 545         if (check_only) {
 546                 FT_Face fontface;
 547                 if (font->image_font)
 548                         fontface = (FT_Face)font->next->face;
 549                 else
 550                         fontface = (FT_Face)font->face;
 551                 return (Font_SearchSize(font, fontface, size) > 0);
 552         }
 553
 554         memset(&temp, 0, sizeof(temp));
 555         temp.size = size;
 556         temp.glyphSize = CeilPowerOf2(size*2);
 557         temp.sfx = (1.0/64.0)/(double)size;
 558         temp.sfy = (1.0/64.0)/(double)size;
 559         temp.intSize = -1; // negative value: LoadMap must search now :)
 560         if (!Font_LoadMap(font, &temp, 0, &fmap))
 561         {
 562                 Con_Printf("ERROR: can't load the first character map for %s\n"
 563                            "This is fatal\n",
 564                            font->name);
 565                 Font_UnloadFont(font);
 566                 return false;
 567         }
 568         font->font_maps[map_index] = temp.next;
 569
 570         fmap->sfx = temp.sfx;
 571         fmap->sfy = temp.sfy;
 572
 573         // load the default kerning vector:
 574         if (font->has_kerning)
 575         {
 576                 Uchar l, r;
 577                 FT_Vector kernvec;
 578                 for (l = 0; l < 256; ++l)
 579                 {
 580                         for (r = 0; r < 256; ++r)
 581                         {
 582                                 FT_ULong ul, ur;
 583                                 ul = qFT_Get_Char_Index(font->face, l);
 584                                 ur = qFT_Get_Char_Index(font->face, r);
 585                                 if (qFT_Get_Kerning(font->face, ul, ur, FT_KERNING_DEFAULT, &kernvec))
 586                                 {
 587                                         fmap->kerning.kerning[l][r][0] = 0;
 588                                         fmap->kerning.kerning[l][r][1] = 0;
 589                                 }
 590                                 else
 591                                 {
 592                                         fmap->kerning.kerning[l][r][0] = Font_SnapTo((kernvec.x / 64.0) / fmap->size, 1 / fmap->size);
 593                                         fmap->kerning.kerning[l][r][1] = Font_SnapTo((kernvec.y / 64.0) / fmap->size, 1 / fmap->size);
 594                                 }
 595                         }
 596                 }
 597         }
 598         return true;
 599 }
 600
 601 int Font_IndexForSize(ft2_font_t *font, float _fsize, float *outw, float *outh)
 602 {
 603         int match = -1;
 604         int value = 1000000;
 605         int nval;
 606         int matchsize = -10000;
 607         int m;
 608         float fsize_x, fsize_y;
 609         ft2_font_map_t **maps = font->font_maps;
 610
 611         fsize_x = fsize_y = _fsize * vid.height / vid_conheight.value;
 612         if(outw && *outw)
 613                 fsize_x = *outw * vid.width / vid_conwidth.value;
 614         if(outh && *outh)
 615                 fsize_y = *outh * vid.height / vid_conheight.value;
 616
 617         if (fsize_x < 0)
 618         {
 619                 if(fsize_y < 0)
 620                         fsize_x = fsize_y = 16;
 621                 else
 622                         fsize_x = fsize_y;
 623         }
 624         else
 625         {
 626                 if(fsize_y < 0)
 627                         fsize_y = fsize_x;
 628         }
 629
 630         for (m = 0; m < MAX_FONT_SIZES; ++m)
 631         {
 632                 if (!maps[m])
 633                         continue;
 634                 // "round up" to the bigger size if two equally-valued matches exist
 635                 nval = 0.5 * (abs(maps[m]->size - fsize_x) + abs(maps[m]->size - fsize_y));
 636                 if (match == -1 || nval < value || (nval == value && matchsize < maps[m]->size))
 637                 {
 638                         value = nval;
 639                         match = m;
 640                         matchsize = maps[m]->size;
 641                         if (value == 0) // there is no better match
 642                                 break;
 643                 }
 644         }
 645         if (value <= r_font_size_snapping.value)
 646         {
 647                 // do NOT keep the aspect for perfect rendering
 648                 if (outh) *outh = maps[match]->size * vid_conheight.value / vid.height;
 649                 if (outw) *outw = maps[match]->size * vid_conwidth.value / vid.width;
 650         }
 651         return match;
 652 }
 653
 654 ft2_font_map_t *Font_MapForIndex(ft2_font_t *font, int index)
 655 {
 656         if (index < 0 || index >= MAX_FONT_SIZES)
 657                 return NULL;
 658         return font->font_maps[index];
 659 }
 660
 661 static qboolean Font_SetSize(ft2_font_t *font, float w, float h)
 662 {
 663         if (font->currenth == h &&
 664             ((!w && (!font->currentw || font->currentw == font->currenth)) || // check if w==h when w is not set
 665              font->currentw == w)) // same size has been requested
 666         {
 667                 return true;
 668         }
 669         // sorry, but freetype doesn't seem to care about other sizes
 670         w = (int)w;
 671         h = (int)h;
 672         if (font->image_font)
 673         {
 674                 if (qFT_Set_Char_Size((FT_Face)font->next->face, (FT_F26Dot6)(w*64), (FT_F26Dot6)(h*64), 72, 72))
 675                         return false;
 676         }
 677         else
 678         {
 679                 if (qFT_Set_Char_Size((FT_Face)font->face, (FT_F26Dot6)(w*64), (FT_F26Dot6)(h*64), 72, 72))
 680                         return false;
 681         }
 682         font->currentw = w;
 683         font->currenth = h;
 684         return true;
 685 }
 686
 687 qboolean Font_GetKerningForMap(ft2_font_t *font, int map_index, float w, float h, Uchar left, Uchar right, float *outx, float *outy)
 688 {
 689         ft2_font_map_t *fmap;
 690         if (!font->has_kerning || !r_font_kerning.integer)
 691                 return false;
 692         if (map_index < 0 || map_index >= MAX_FONT_SIZES)
 693                 return false;
 694         fmap = font->font_maps[map_index];
 695         if (!fmap)
 696                 return false;
 697         if (left < 256 && right < 256)
 698         {
 699                 //Con_Printf("%g : %f, %f, %f :: %f\n", (w / (float)fmap->size), w, fmap->size, fmap->intSize, Font_VirtualToRealSize(w));
 700                 // quick-kerning, be aware of the size: scale it
 701                 if (outx) *outx = fmap->kerning.kerning[left][right][0];// * (w / (float)fmap->size);
 702                 if (outy) *outy = fmap->kerning.kerning[left][right][1];// * (h / (float)fmap->size);
 703                 return true;
 704         }
 705         else
 706         {
 707                 FT_Vector kernvec;
 708                 FT_ULong ul, ur;
 709
 710                 //if (qFT_Set_Pixel_Sizes((FT_Face)font->face, 0, fmap->size))
 711 #if 0
 712                 if (!Font_SetSize(font, w, h))
 713                 {
 714                         // this deserves an error message
 715                         Con_Printf("Failed to get kerning for %s\n", font->name);
 716                         return false;
 717                 }
 718                 ul = qFT_Get_Char_Index(font->face, left);
 719                 ur = qFT_Get_Char_Index(font->face, right);
 720                 if (qFT_Get_Kerning(font->face, ul, ur, FT_KERNING_DEFAULT, &kernvec))
 721                 {
 722                         if (outx) *outx = Font_SnapTo(kernvec.x * fmap->sfx, 1 / fmap->size);
 723                         if (outy) *outy = Font_SnapTo(kernvec.y * fmap->sfy, 1 / fmap->size);
 724                         return true;
 725                 }
 726 #endif
 727                 if (!Font_SetSize(font, fmap->intSize, fmap->intSize))
 728                 {
 729                         // this deserves an error message
 730                         Con_Printf("Failed to get kerning for %s\n", font->name);
 731                         return false;
 732                 }
 733                 ul = qFT_Get_Char_Index(font->face, left);
 734                 ur = qFT_Get_Char_Index(font->face, right);
 735                 if (qFT_Get_Kerning(font->face, ul, ur, FT_KERNING_DEFAULT, &kernvec))
 736                 {
 737                         if (outx) *outx = Font_SnapTo(kernvec.x * fmap->sfx, 1 / fmap->size);// * (w / (float)fmap->size);
 738                         if (outy) *outy = Font_SnapTo(kernvec.y * fmap->sfy, 1 / fmap->size);// * (h / (float)fmap->size);
 739                         return true;
 740                 }
 741                 return false;
 742         }
 743 }
 744
 745 qboolean Font_GetKerningForSize(ft2_font_t *font, float w, float h, Uchar left, Uchar right, float *outx, float *outy)
 746 {
 747         return Font_GetKerningForMap(font, Font_IndexForSize(font, h, NULL, NULL), w, h, left, right, outx, outy);
 748 }
 749
 750 static void UnloadMapRec(ft2_font_map_t *map)
 751 {
 752         if (map->texture)
 753         {
 754                 R_FreeTexture(map->texture);
 755                 map->texture = NULL;
 756         }
 757         if (map->next)
 758                 UnloadMapRec(map->next);
 759         Mem_Free(map);
 760 }
 761
 762 void Font_UnloadFont(ft2_font_t *font)
 763 {
 764         int i;
 765         if (font->attachments && font->attachmentcount)
 766         {
 767                 Mem_Free(font->attachments);
 768                 font->attachmentcount = 0;
 769                 font->attachments = NULL;
 770         }
 771         for (i = 0; i < MAX_FONT_SIZES; ++i)
 772         {
 773                 if (font->font_maps[i])
 774                 {
 775                         UnloadMapRec(font->font_maps[i]);
 776                         font->font_maps[i] = NULL;
 777                 }
 778         }
 779         if (ft2_dll)
 780         {
 781                 if (font->face)
 782                 {
 783                         qFT_Done_Face((FT_Face)font->face);
 784                         font->face = NULL;
 785                 }
 786         }
 787 }
 788
 789 static float Font_SearchSize(ft2_font_t *font, FT_Face fontface, float size)
 790 {
 791         float intSize = size;
 792         while (1)
 793         {
 794                 if (!Font_SetSize(font, intSize, intSize))
 795                 {
 796                         Con_Printf("ERROR: can't set size for font %s: %f ((%f))\n", font->name, size, intSize);
 797                         return -1;
 798                 }
 799                 if ((fontface->size->metrics.height>>6) <= size)
 800                         return intSize;
 801                 if (intSize < 2)
 802                 {
 803                         Con_Printf("ERROR: no appropriate size found for font %s: %f\n", font->name, size);
 804                         return -1;
 805                 }
 806                 --intSize;
 807         }
 808 }
 809
 810 static qboolean Font_LoadMap(ft2_font_t *font, ft2_font_map_t *mapstart, Uchar _ch, ft2_font_map_t **outmap)
 811 {
 812         char map_identifier[MAX_QPATH];
 813         unsigned long mapidx = _ch / FONT_CHARS_PER_MAP;
 814         unsigned char *data;
 815         FT_ULong ch, mapch;
 816         int status;
 817         int tp;
 818         FT_Int32 load_flags;
 819
 820         int pitch;
 821         int gR, gC; // glyph position: row and column
 822
 823         ft2_font_map_t *map, *next;
 824         ft2_font_t *usefont;
 825
 826         FT_Face fontface;
 827
 828         int bytesPerPixel = 4; // change the conversion loop too if you change this!
 829
 830         if (outmap)
 831                 *outmap = NULL;
 832
 833         if (r_font_use_alpha_textures.integer)
 834                 bytesPerPixel = 1;
 835
 836         if (font->image_font)
 837                 fontface = (FT_Face)font->next->face;
 838         else
 839                 fontface = (FT_Face)font->face;
 840
 841         switch(r_font_antialias.integer)
 842         {
 843                 case 0:
 844                         switch(r_font_hinting.integer)
 845                         {
 846                                 case 0:
 847                                         load_flags = FT_LOAD_NO_HINTING | FT_LOAD_NO_AUTOHINT | FT_LOAD_TARGET_MONO | FT_LOAD_MONOCHROME;
 848                                         break;
 849                                 case 1:
 850                                 case 2:
 851                                         load_flags = FT_LOAD_FORCE_AUTOHINT | FT_LOAD_TARGET_MONO | FT_LOAD_MONOCHROME;
 852                                         break;
 853                                 default:
 854                                 case 3:
 855                                         load_flags = FT_LOAD_TARGET_MONO | FT_LOAD_MONOCHROME;
 856                                         break;
 857                         }
 858                         break;
 859                 default:
 860                 case 1:
 861                         switch(r_font_hinting.integer)
 862                         {
 863                                 case 0:
 864                                         load_flags = FT_LOAD_NO_HINTING | FT_LOAD_NO_AUTOHINT | FT_LOAD_TARGET_NORMAL;
 865                                         break;
 866                                 case 1:
 867                                         load_flags = FT_LOAD_FORCE_AUTOHINT | FT_LOAD_TARGET_LIGHT;
 868                                         break;
 869                                 case 2:
 870                                         load_flags = FT_LOAD_FORCE_AUTOHINT | FT_LOAD_TARGET_NORMAL;
 871                                         break;
 872                                 default:
 873                                 case 3:
 874                                         load_flags = FT_LOAD_TARGET_NORMAL;
 875                                         break;
 876                         }
 877                         break;
 878         }
 879
 880         //status = qFT_Set_Pixel_Sizes((FT_Face)font->face, /*size*/0, mapstart->size);
 881         //if (status)
 882         if (font->image_font && mapstart->intSize < 0)
 883                 mapstart->intSize = mapstart->size;
 884         if (mapstart->intSize < 0)
 885         {
 886                 /*
 887                 mapstart->intSize = mapstart->size;
 888                 while (1)
 889                 {
 890                         if (!Font_SetSize(font, mapstart->intSize, mapstart->intSize))
 891                         {
 892                                 Con_Printf("ERROR: can't set size for font %s: %f ((%f))\n", font->name, mapstart->size, mapstart->intSize);
 893                                 return false;
 894                         }
 895                         if ((fontface->size->metrics.height>>6) <= mapstart->size)
 896                                 break;
 897                         if (mapstart->intSize < 2)
 898                         {
 899                                 Con_Printf("ERROR: no appropriate size found for font %s: %f\n", font->name, mapstart->size);
 900                                 return false;
 901                         }
 902                         --mapstart->intSize;
 903                 }
 904                 */
 905                 if ((mapstart->intSize = Font_SearchSize(font, fontface, mapstart->size)) <= 0)
 906                         return false;
 907                 Con_DPrintf("Using size: %f for requested size %f\n", mapstart->intSize, mapstart->size);
 908         }
 909
 910         if (!font->image_font && !Font_SetSize(font, mapstart->intSize, mapstart->intSize))
 911         {
 912                 Con_Printf("ERROR: can't set sizes for font %s: %f\n", font->name, mapstart->size);
 913                 return false;
 914         }
 915
 916         map = Mem_Alloc(font_mempool, sizeof(ft2_font_map_t));
 917         if (!map)
 918         {
 919                 Con_Printf("ERROR: Out of memory when loading fontmap for %s\n", font->name);
 920                 return false;
 921         }
 922
 923         // copy over the information
 924         map->size = mapstart->size;
 925         map->intSize = mapstart->intSize;
 926         map->glyphSize = mapstart->glyphSize;
 927         map->sfx = mapstart->sfx;
 928         map->sfy = mapstart->sfy;
 929
 930         pitch = map->glyphSize * FONT_CHARS_PER_LINE * bytesPerPixel;
 931         data = Mem_Alloc(font_mempool, (FONT_CHAR_LINES * map->glyphSize) * pitch);
 932         if (!data)
 933         {
 934                 Con_Printf("ERROR: Failed to allocate memory for font %s size %g\n", font->name, map->size);
 935                 Mem_Free(map);
 936                 return false;
 937         }
 938         memset(map->width_of, 0, sizeof(map->width_of));
 939
 940         // initialize as white texture with zero alpha
 941         tp = 0;
 942         while (tp < (FONT_CHAR_LINES * map->glyphSize) * pitch)
 943         {
 944                 if (bytesPerPixel == 4)
 945                 {
 946                         data[tp++] = 0xFF;
 947                         data[tp++] = 0xFF;
 948                         data[tp++] = 0xFF;
 949                 }
 950                 data[tp++] = 0x00;
 951         }
 952
 953         // insert the map
 954         map->start = mapidx * FONT_CHARS_PER_MAP;
 955         next = mapstart;
 956         while(next->next && next->next->start < map->start)
 957                 next = next->next;
 958         map->next = next->next;
 959         next->next = map;
 960
 961         gR = 0;
 962         gC = -1;
 963         for (ch = map->start;
 964              ch < (FT_ULong)map->start + FONT_CHARS_PER_MAP;
 965              ++ch)
 966         {
 967                 FT_ULong glyphIndex;
 968                 int w, h, x, y;
 969                 FT_GlyphSlot glyph;
 970                 FT_Bitmap *bmp;
 971                 unsigned char *imagedata, *dst, *src;
 972                 glyph_slot_t *mapglyph;
 973                 FT_Face face;
 974
 975                 mapch = ch - map->start;
 976
 977                 if (developer_font.integer)
 978                         Con_DPrint("glyphinfo: ------------- GLYPH INFO -----------------\n");
 979
 980                 ++gC;
 981                 if (gC >= FONT_CHARS_PER_LINE)
 982                 {
 983                         gC -= FONT_CHARS_PER_LINE;
 984                         ++gR;
 985                 }
 986
 987                 imagedata = data + gR * pitch * map->glyphSize + gC * map->glyphSize * bytesPerPixel;
 988                 //status = qFT_Load_Char(face, ch, FT_LOAD_RENDER);
 989                 // we need the glyphIndex
 990                 face = font->face;
 991                 usefont = NULL;
 992                 if (font->image_font && mapch == ch && img_fontmap[mapch])
 993                 {
 994                         map->glyphs[mapch].image = true;
 995                         continue;
 996                 }
 997                 glyphIndex = qFT_Get_Char_Index(face, ch);
 998                 if (glyphIndex == 0)
 999                 {
1000                         // by convention, 0 is the "missing-glyph"-glyph
1001                         // try to load from a fallback font
1002                         for(usefont = font->next; usefont != NULL; usefont = usefont->next)
1003                         {
1004                                 if (!Font_SetSize(usefont, mapstart->intSize, mapstart->intSize))
1005                                         continue;
1006                                 // try that glyph
1007                                 face = usefont->face;
1008                                 glyphIndex = qFT_Get_Char_Index(face, ch);
1009                                 if (glyphIndex == 0)
1010                                         continue;
1011                                 status = qFT_Load_Glyph(face, glyphIndex, FT_LOAD_RENDER | load_flags);
1012                                 if (status)
1013                                         continue;
1014                                 break;
1015                         }
1016                         if (!usefont)
1017                         {
1018                                 //Con_Printf("failed to load fallback glyph for char %lx from font %s\n", (unsigned long)ch, font->name);
1019                                 // now we let it use the "missing-glyph"-glyph
1020                                 face = font->face;
1021                                 glyphIndex = 0;
1022                         }
1023                 }
1024
1025                 if (!usefont)
1026                 {
1027                         usefont = font;
1028                         face = font->face;
1029                         status = qFT_Load_Glyph(face, glyphIndex, FT_LOAD_RENDER | load_flags);
1030                         if (status)
1031                         {
1032                                 //Con_Printf("failed to load glyph %lu for %s\n", glyphIndex, font->name);
1033                                 Con_DPrintf("failed to load glyph for char %lx from font %s\n", (unsigned long)ch, font->name);
1034                                 continue;
1035                         }
1036                 }
1037
1038                 glyph = face->glyph;
1039                 bmp = &glyph->bitmap;
1040
1041                 w = bmp->width;
1042                 h = bmp->rows;
1043
1044                 if (w > map->glyphSize || h > map->glyphSize) {
1045                         Con_Printf("WARNING: Glyph %lu is too big in font %s, size %g: %i x %i\n", ch, font->name, map->size, w, h);
1046                         if (w > map->glyphSize)
1047                                 w = map->glyphSize;
1048                         if (h > map->glyphSize)
1049                                 h = map->glyphSize;
1050                 }
1051
1052                 switch (bmp->pixel_mode)
1053                 {
1054                 case FT_PIXEL_MODE_MONO:
1055                         if (developer_font.integer)
1056                                 Con_DPrint("glyphinfo:   Pixel Mode: MONO\n");
1057                         break;
1058                 case FT_PIXEL_MODE_GRAY2:
1059                         if (developer_font.integer)
1060                                 Con_DPrint("glyphinfo:   Pixel Mode: GRAY2\n");
1061                         break;
1062                 case FT_PIXEL_MODE_GRAY4:
1063                         if (developer_font.integer)
1064                                 Con_DPrint("glyphinfo:   Pixel Mode: GRAY4\n");
1065                         break;
1066                 case FT_PIXEL_MODE_GRAY:
1067                         if (developer_font.integer)
1068                                 Con_DPrint("glyphinfo:   Pixel Mode: GRAY\n");
1069                         break;
1070                 default:
1071                         if (developer_font.integer)
1072                                 Con_DPrintf("glyphinfo:   Pixel Mode: Unknown: %i\n", bmp->pixel_mode);
1073                         Mem_Free(data);
1074                         Con_Printf("ERROR: Unrecognized pixel mode for font %s size %f: %i\n", font->name, mapstart->size, bmp->pixel_mode);
1075                         return false;
1076                 }
1077                 for (y = 0; y < h; ++y)
1078                 {
1079                         dst = imagedata + y * pitch;
1080                         src = bmp->buffer + y * bmp->pitch;
1081
1082                         switch (bmp->pixel_mode)
1083                         {
1084                         case FT_PIXEL_MODE_MONO:
1085                                 dst += bytesPerPixel - 1; // shift to alpha byte
1086                                 for (x = 0; x < bmp->width; x += 8)
1087                                 {
1088                                         unsigned char ch = *src++;
1089                                         *dst = 255 * !!((ch & 0x80) >> 7); dst += bytesPerPixel;
1090                                         *dst = 255 * !!((ch & 0x40) >> 6); dst += bytesPerPixel;
1091                                         *dst = 255 * !!((ch & 0x20) >> 5); dst += bytesPerPixel;
1092                                         *dst = 255 * !!((ch & 0x10) >> 4); dst += bytesPerPixel;
1093                                         *dst = 255 * !!((ch & 0x08) >> 3); dst += bytesPerPixel;
1094                                         *dst = 255 * !!((ch & 0x04) >> 2); dst += bytesPerPixel;
1095                                         *dst = 255 * !!((ch & 0x02) >> 1); dst += bytesPerPixel;
1096                                         *dst = 255 * !!((ch & 0x01) >> 0); dst += bytesPerPixel;
1097                                 }
1098                                 break;
1099                         case FT_PIXEL_MODE_GRAY2:
1100                                 dst += bytesPerPixel - 1; // shift to alpha byte
1101                                 for (x = 0; x < bmp->width; x += 4)
1102                                 {
1103                                         unsigned char ch = *src++;
1104                                         *dst = ( ((ch & 0xA0) >> 6) * 0x55 ); ch <<= 2; dst += bytesPerPixel;
1105                                         *dst = ( ((ch & 0xA0) >> 6) * 0x55 ); ch <<= 2; dst += bytesPerPixel;
1106                                         *dst = ( ((ch & 0xA0) >> 6) * 0x55 ); ch <<= 2; dst += bytesPerPixel;
1107                                         *dst = ( ((ch & 0xA0) >> 6) * 0x55 ); ch <<= 2; dst += bytesPerPixel;
1108                                 }
1109                                 break;
1110                         case FT_PIXEL_MODE_GRAY4:
1111                                 dst += bytesPerPixel - 1; // shift to alpha byte
1112                                 for (x = 0; x < bmp->width; x += 2)
1113                                 {
1114                                         unsigned char ch = *src++;
1115                                         *dst = ( ((ch & 0xF0) >> 4) * 0x11); dst += bytesPerPixel;
1116                                         *dst = ( ((ch & 0x0F) ) * 0x11); dst += bytesPerPixel;
1117                                 }
1118                                 break;
1119                         case FT_PIXEL_MODE_GRAY:
1120                                 // in this case pitch should equal width
1121                                 for (tp = 0; tp < bmp->pitch; ++tp)
1122                                         dst[(bytesPerPixel - 1) + tp*bytesPerPixel] = src[tp]; // copy the grey value into the alpha bytes
1123
1124                                 //memcpy((void*)dst, (void*)src, bmp->pitch);
1125                                 //dst += bmp->pitch;
1126                                 break;
1127                         default:
1128                                 break;
1129                         }
1130                 }
1131
1132                 // now fill map->glyphs[ch - map->start]
1133                 mapglyph = &map->glyphs[mapch];
1134
1135                 {
1136                         // old way
1137                         // double advance = (double)glyph->metrics.horiAdvance * map->sfx;
1138
1139                         double bearingX = (glyph->metrics.horiBearingX / 64.0) / map->size;
1140                         //double bearingY = (glyph->metrics.horiBearingY >> 6) / map->size;
1141                         double advance = (glyph->advance.x / 64.0) / map->size;
1142                         //double mWidth = (glyph->metrics.width >> 6) / map->size;
1143                         //double mHeight = (glyph->metrics.height >> 6) / map->size;
1144
1145                         mapglyph->txmin = ( (double)(gC * map->glyphSize) ) / ( (double)(map->glyphSize * FONT_CHARS_PER_LINE) );
1146                         mapglyph->txmax = mapglyph->txmin + (double)bmp->width / ( (double)(map->glyphSize * FONT_CHARS_PER_LINE) );
1147                         mapglyph->tymin = ( (double)(gR * map->glyphSize) ) / ( (double)(map->glyphSize * FONT_CHAR_LINES) );
1148                         mapglyph->tymax = mapglyph->tymin + (double)bmp->rows / ( (double)(map->glyphSize * FONT_CHAR_LINES) );
1149                         //mapglyph->vxmin = bearingX;
1150                         //mapglyph->vxmax = bearingX + mWidth;
1151                         mapglyph->vxmin = glyph->bitmap_left / map->size;
1152                         mapglyph->vxmax = mapglyph->vxmin + bmp->width / map->size; // don't ask
1153                         //mapglyph->vymin = -bearingY;
1154                         //mapglyph->vymax = mHeight - bearingY;
1155                         mapglyph->vymin = -glyph->bitmap_top / map->size;
1156                         mapglyph->vymax = mapglyph->vymin + bmp->rows / map->size;
1157                         //Con_Printf("dpi = %f %f (%f %d) %d %d\n", bmp->width / (mapglyph->vxmax - mapglyph->vxmin), bmp->rows / (mapglyph->vymax - mapglyph->vymin), map->size, map->glyphSize, (int)fontface->size->metrics.x_ppem, (int)fontface->size->metrics.y_ppem);
1158                         //mapglyph->advance_x = advance * usefont->size;
1159                         //mapglyph->advance_x = advance;
1160                         mapglyph->advance_x = Font_SnapTo(advance, 1 / map->size);
1161                         mapglyph->advance_y = 0;
1162
1163                         if (developer_font.integer)
1164                         {
1165                                 Con_DPrintf("glyphinfo:   Glyph: %lu   at (%i, %i)\n", (unsigned long)ch, gC, gR);
1166                                 Con_DPrintf("glyphinfo:   %f, %f, %lu\n", bearingX, map->sfx, (unsigned long)glyph->metrics.horiBearingX);
1167                                 if (ch >= 32 && ch <= 128)
1168                                         Con_DPrintf("glyphinfo:   Character: %c\n", (int)ch);
1169                                 Con_DPrintf("glyphinfo:   Vertex info:\n");
1170                                 Con_DPrintf("glyphinfo:     X: ( %f  --  %f )\n", mapglyph->vxmin, mapglyph->vxmax);
1171                                 Con_DPrintf("glyphinfo:     Y: ( %f  --  %f )\n", mapglyph->vymin, mapglyph->vymax);
1172                                 Con_DPrintf("glyphinfo:   Texture info:\n");
1173                                 Con_DPrintf("glyphinfo:     S: ( %f  --  %f )\n", mapglyph->txmin, mapglyph->txmax);
1174                                 Con_DPrintf("glyphinfo:     T: ( %f  --  %f )\n", mapglyph->tymin, mapglyph->tymax);
1175                                 Con_DPrintf("glyphinfo:   Advance: %f, %f\n", mapglyph->advance_x, mapglyph->advance_y);
1176                         }
1177                 }
1178                 map->glyphs[mapch].image = false;
1179         }
1180
1181         // create a texture from the data now
1182
1183         if (developer_font.integer > 100)
1184         {
1185                 // LordHavoc: why are we writing this?  And why not write it as TGA using the appropriate function?
1186                 // view using `display -depth 8 -size 512x512 name_page.rgba` (be sure to use a correct -size parameter)
1187                 dpsnprintf(map_identifier, sizeof(map_identifier), "%s_%u.rgba", font->name, (unsigned)map->start/FONT_CHARS_PER_MAP);
1188                 FS_WriteFile(map_identifier, data, pitch * FONT_CHAR_LINES * map->glyphSize);
1189         }
1190         dpsnprintf(map_identifier, sizeof(map_identifier), "%s_%u", font->name, (unsigned)map->start/FONT_CHARS_PER_MAP);
1191
1192         // probably use bytesPerPixel here instead?
1193         if (r_font_use_alpha_textures.integer)
1194         {
1195                 map->texture = R_LoadTexture2D(font_texturepool, map_identifier,
1196                                                map->glyphSize * FONT_CHARS_PER_LINE,
1197                                                map->glyphSize * FONT_CHAR_LINES,
1198                                                data, TEXTYPE_ALPHA, TEXF_ALPHA /*gone: | TEXF_ALWAYSPRECACHE*/ /* | TEXF_MIPMAP*/, NULL);
1199         } else {
1200                 map->texture = R_LoadTexture2D(font_texturepool, map_identifier,
1201                                                map->glyphSize * FONT_CHARS_PER_LINE,
1202                                                map->glyphSize * FONT_CHAR_LINES,
1203                                                data, TEXTYPE_RGBA, TEXF_ALPHA /*gone: | TEXF_ALWAYSPRECACHE*/ /* | TEXF_MIPMAP*/, NULL);
1204         }
1205
1206         Mem_Free(data);
1207         if (!map->texture)
1208         {
1209                 // if the first try isn't successful, keep it with a broken texture
1210                 // otherwise we retry to load it every single frame where ft2 rendering is used
1211                 // this would be bad...
1212                 // only `data' must be freed
1213                 Con_Printf("ERROR: Failed to generate texture for font %s size %f map %lu\n",
1214                            font->name, mapstart->size, mapidx);
1215                 return false;
1216         }
1217         if (outmap)
1218                 *outmap = map;
1219         return true;
1220 }
1221
1222 qboolean Font_LoadMapForIndex(ft2_font_t *font, int map_index, Uchar _ch, ft2_font_map_t **outmap)
1223 {
1224         if (map_index < 0 || map_index >= MAX_FONT_SIZES)
1225                 return false;
1226         // the first map must have been loaded already
1227         if (!font->font_maps[map_index])
1228                 return false;
1229         return Font_LoadMap(font, font->font_maps[map_index], _ch, outmap);
1230 }
1231
1232 ft2_font_map_t *FontMap_FindForChar(ft2_font_map_t *start, Uchar ch)
1233 {
1234         while (start && start->start + FONT_CHARS_PER_MAP <= ch)
1235                 start = start->next;
1236         if (start && start->start > ch)
1237                 return NULL;
1238         return start;
1239 }