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