Add GL_ExtensionSupported in vid_null.c because vid_shared.c relies on
[xonotic/darkplaces.git] / ft2.c
diff --git a/ft2.c b/ft2.c
index 54b0985..c8d7476 100644 (file)
--- a/ft2.c
+++ b/ft2.c
@@ -6,6 +6,7 @@
 #include "ft2.h"
 #include "ft2_defs.h"
 #include "ft2_fontdefs.h"
+#include "image.h"
 
 static int img_fontmap[256] = {
        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
@@ -35,6 +36,13 @@ CVars introduced with the freetype extension
 cvar_t r_font_disable_freetype = {CVAR_SAVE, "r_font_disable_freetype", "1", "disable freetype support for fonts entirely"};
 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"};
 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!"};
+cvar_t r_font_kerning = {CVAR_SAVE, "r_font_kerning", "1", "Use kerning if available"};
+cvar_t r_font_diskcache = {CVAR_SAVE, "r_font_diskcache", "0", "save font textures to disk for future loading rather than generating them every time"};
+cvar_t r_font_compress = {CVAR_SAVE, "r_font_compress", "0", "use texture compression on font textures to save video memory"};
+cvar_t r_font_nonpoweroftwo = {CVAR_SAVE, "r_font_nonpoweroftwo", "1", "use nonpoweroftwo textures for font (saves memory, potentially slower)"};
+cvar_t developer_font = {CVAR_SAVE, "developer_font", "0", "prints debug messages about fonts"};
+
+#ifndef DP_FREETYPE_STATIC
 
 /*
 ================================================================================
@@ -130,13 +138,177 @@ static dllfunction_t ft2funcs[] =
 /// Handle for FreeType2 DLL
 static dllhandle_t ft2_dll = NULL;
 
+#else
+
+FT_EXPORT( FT_Error )
+(FT_Init_FreeType)( FT_Library  *alibrary );
+FT_EXPORT( FT_Error )
+(FT_Done_FreeType)( FT_Library  library );
+/*
+FT_EXPORT( FT_Error )
+(FT_New_Face)( FT_Library   library,
+                const char*  filepathname,
+                FT_Long      face_index,
+                FT_Face     *aface );
+*/
+FT_EXPORT( FT_Error )
+(FT_New_Memory_Face)( FT_Library      library,
+                       const FT_Byte*  file_base,
+                       FT_Long         file_size,
+                       FT_Long         face_index,
+                       FT_Face        *aface );
+FT_EXPORT( FT_Error )
+(FT_Done_Face)( FT_Face  face );
+FT_EXPORT( FT_Error )
+(FT_Select_Size)( FT_Face  face,
+                   FT_Int   strike_index );
+FT_EXPORT( FT_Error )
+(FT_Request_Size)( FT_Face          face,
+                    FT_Size_Request  req );
+FT_EXPORT( FT_Error )
+(FT_Set_Char_Size)( FT_Face     face,
+                     FT_F26Dot6  char_width,
+                     FT_F26Dot6  char_height,
+                     FT_UInt     horz_resolution,
+                     FT_UInt     vert_resolution );
+FT_EXPORT( FT_Error )
+(FT_Set_Pixel_Sizes)( FT_Face  face,
+                       FT_UInt  pixel_width,
+                       FT_UInt  pixel_height );
+FT_EXPORT( FT_Error )
+(FT_Load_Glyph)( FT_Face   face,
+                  FT_UInt   glyph_index,
+                  FT_Int32  load_flags );
+FT_EXPORT( FT_Error )
+(FT_Load_Char)( FT_Face   face,
+                 FT_ULong  char_code,
+                 FT_Int32  load_flags );
+FT_EXPORT( FT_UInt )
+(FT_Get_Char_Index)( FT_Face   face,
+                      FT_ULong  charcode );
+FT_EXPORT( FT_Error )
+(FT_Render_Glyph)( FT_GlyphSlot    slot,
+                    FT_Render_Mode  render_mode );
+FT_EXPORT( FT_Error )
+(FT_Get_Kerning)( FT_Face     face,
+                   FT_UInt     left_glyph,
+                   FT_UInt     right_glyph,
+                   FT_UInt     kern_mode,
+                   FT_Vector  *akerning );
+FT_EXPORT( FT_Error )
+(FT_Attach_Stream)( FT_Face        face,
+                     FT_Open_Args*  parameters );
+
+#define qFT_Init_FreeType              FT_Init_FreeType
+#define qFT_Done_FreeType              FT_Done_FreeType
+//#define qFT_New_Face                 FT_New_Face
+#define qFT_New_Memory_Face            FT_New_Memory_Face
+#define qFT_Done_Face                  FT_Done_Face
+#define qFT_Select_Size                        FT_Select_Size
+#define qFT_Request_Size               FT_Request_Size
+#define qFT_Set_Char_Size              FT_Set_Char_Size
+#define qFT_Set_Pixel_Sizes            FT_Set_Pixel_Sizes
+#define qFT_Load_Glyph                 FT_Load_Glyph
+#define qFT_Load_Char                  FT_Load_Char
+#define qFT_Get_Char_Index             FT_Get_Char_Index
+#define qFT_Render_Glyph               FT_Render_Glyph
+#define qFT_Get_Kerning                        FT_Get_Kerning
+#define qFT_Attach_Stream              FT_Attach_Stream
+
+#endif
+
 /// Memory pool for fonts
 static mempool_t *font_mempool= NULL;
-static rtexturepool_t *font_texturepool = NULL;
 
 /// FreeType library handle
 static FT_Library font_ft2lib = NULL;
 
+#define POSTPROCESS_MAXRADIUS 8
+typedef struct
+{
+       unsigned char *buf, *buf2;
+       int bufsize, bufwidth, bufheight, bufpitch;
+       float blur, outline, shadowx, shadowy, shadowz;
+       int padding_t, padding_b, padding_l, padding_r, blurpadding_lt, blurpadding_rb, outlinepadding_t, outlinepadding_b, outlinepadding_l, outlinepadding_r;
+       unsigned char circlematrix[2*POSTPROCESS_MAXRADIUS+1][2*POSTPROCESS_MAXRADIUS+1];
+       unsigned char gausstable[2*POSTPROCESS_MAXRADIUS+1];
+}
+font_postprocess_t;
+static font_postprocess_t pp;
+
+typedef struct fontfilecache_s
+{
+       unsigned char *buf;
+       fs_offset_t len;
+       int refcount;
+       char path[MAX_QPATH];
+}
+fontfilecache_t;
+#define MAX_FONTFILES 8
+static fontfilecache_t fontfiles[MAX_FONTFILES];
+static const unsigned char *fontfilecache_LoadFile(const char *path, qboolean quiet, fs_offset_t *filesizepointer)
+{
+       int i;
+       unsigned char *buf;
+
+       for(i = 0; i < MAX_FONTFILES; ++i)
+       {
+               if(fontfiles[i].refcount > 0)
+                       if(!strcmp(path, fontfiles[i].path))
+                       {
+                               *filesizepointer = fontfiles[i].len;
+                               ++fontfiles[i].refcount;
+                               return fontfiles[i].buf;
+                       }
+       }
+
+       buf = FS_LoadFile(path, font_mempool, quiet, filesizepointer);
+       if(buf)
+       {
+               for(i = 0; i < MAX_FONTFILES; ++i)
+                       if(fontfiles[i].refcount <= 0)
+                       {
+                               strlcpy(fontfiles[i].path, path, sizeof(fontfiles[i].path));
+                               fontfiles[i].len = *filesizepointer;
+                               fontfiles[i].buf = buf;
+                               fontfiles[i].refcount = 1;
+                               return buf;
+                       }
+       }
+
+       return buf;
+}
+static void fontfilecache_Free(const unsigned char *buf)
+{
+       int i;
+       for(i = 0; i < MAX_FONTFILES; ++i)
+       {
+               if(fontfiles[i].refcount > 0)
+                       if(fontfiles[i].buf == buf)
+                       {
+                               if(--fontfiles[i].refcount <= 0)
+                               {
+                                       Mem_Free(fontfiles[i].buf);
+                                       fontfiles[i].buf = NULL;
+                               }
+                               return;
+                       }
+       }
+       // if we get here, it used regular allocation
+       Mem_Free((void *) buf);
+}
+static void fontfilecache_FreeAll(void)
+{
+       int i;
+       for(i = 0; i < MAX_FONTFILES; ++i)
+       {
+               if(fontfiles[i].refcount > 0)
+                       Mem_Free(fontfiles[i].buf);
+               fontfiles[i].buf = NULL;
+               fontfiles[i].refcount = 0;
+       }
+}
+
 /*
 ====================
 Font_CloseLibrary
@@ -146,16 +318,18 @@ Unload the FreeType2 DLL
 */
 void Font_CloseLibrary (void)
 {
+       fontfilecache_FreeAll();
        if (font_mempool)
                Mem_FreePool(&font_mempool);
-       if (font_texturepool)
-               R_FreeTexturePool(&font_texturepool);
        if (font_ft2lib && qFT_Done_FreeType)
        {
                qFT_Done_FreeType(font_ft2lib);
                font_ft2lib = NULL;
        }
+#ifndef DP_FREETYPE_STATIC
        Sys_UnloadLibrary (&ft2_dll);
+#endif
+       pp.buf = NULL;
 }
 
 /*
@@ -167,11 +341,14 @@ Try to load the FreeType2 DLL
 */
 qboolean Font_OpenLibrary (void)
 {
+#ifndef DP_FREETYPE_STATIC
        const char* dllnames [] =
        {
 #if defined(WIN32)
+               "libfreetype-6.dll",
                "freetype6.dll",
 #elif defined(MACOSX)
+               "libfreetype.6.dylib",
                "libfreetype.dylib",
 #else
                "libfreetype.so.6",
@@ -179,10 +356,12 @@ qboolean Font_OpenLibrary (void)
 #endif
                NULL
        };
+#endif
 
        if (r_font_disable_freetype.integer)
                return false;
 
+#ifndef DP_FREETYPE_STATIC
        // Already loaded?
        if (ft2_dll)
                return true;
@@ -190,6 +369,7 @@ qboolean Font_OpenLibrary (void)
        // Load the DLL
        if (!Sys_LoadLibrary (dllnames, &ft2_dll, ft2funcs))
                return false;
+#endif
        return true;
 }
 
@@ -220,25 +400,17 @@ void font_start(void)
                Font_CloseLibrary();
                return;
        }
-
-       font_texturepool = R_AllocTexturePool();
-       if (!font_texturepool)
-       {
-               Con_Print("ERROR: Failed to allocate FONT texture pool!\n");
-               Font_CloseLibrary();
-               return;
-       }
 }
 
 void font_shutdown(void)
 {
        int i;
-       for (i = 0; i < MAX_FONTS; ++i)
+       for (i = 0; i < dp_fonts.maxsize; ++i)
        {
-               if (dp_fonts[i].ft2)
+               if (dp_fonts.f[i].ft2)
                {
-                       Font_UnloadFont(dp_fonts[i].ft2);
-                       dp_fonts[i].ft2 = NULL;
+                       Font_UnloadFont(dp_fonts.f[i].ft2);
+                       dp_fonts.f[i].ft2 = NULL;
                }
        }
        Font_CloseLibrary();
@@ -250,9 +422,17 @@ void font_newmap(void)
 
 void Font_Init(void)
 {
+       Cvar_RegisterVariable(&r_font_nonpoweroftwo);
        Cvar_RegisterVariable(&r_font_disable_freetype);
        Cvar_RegisterVariable(&r_font_use_alpha_textures);
        Cvar_RegisterVariable(&r_font_size_snapping);
+       Cvar_RegisterVariable(&r_font_kerning);
+       Cvar_RegisterVariable(&r_font_diskcache);
+       Cvar_RegisterVariable(&r_font_compress);
+       Cvar_RegisterVariable(&developer_font);
+
+       // let's open it at startup already
+       Font_OpenLibrary();
 }
 
 /*
@@ -265,12 +445,16 @@ Implementation of a more or less lazy font loading and rendering code.
 
 ft2_font_t *Font_Alloc(void)
 {
+#ifndef DP_FREETYPE_STATIC
        if (!ft2_dll)
+#else
+       if (r_font_disable_freetype.integer)
+#endif
                return NULL;
-       return Mem_Alloc(font_mempool, sizeof(ft2_font_t));
+       return (ft2_font_t *)Mem_Alloc(font_mempool, sizeof(ft2_font_t));
 }
 
-qboolean Font_Attach(ft2_font_t *font, ft2_attachment_t *attachment)
+static qboolean Font_Attach(ft2_font_t *font, ft2_attachment_t *attachment)
 {
        ft2_attachment_t *na;
 
@@ -288,13 +472,15 @@ qboolean Font_Attach(ft2_font_t *font, ft2_attachment_t *attachment)
        return true;
 }
 
-static float Font_VirtualToRealSize(float sz)
+float Font_VirtualToRealSize(float sz)
 {
-       int vh, vw, si;
+       int vh;
+       //int vw;
+       int si;
        float sn;
        if(sz < 0)
                return sz;
-       vw = ((vid.width > 0) ? vid.width : vid_width.value);
+       //vw = ((vid.width > 0) ? vid.width : vid_width.value);
        vh = ((vid.height > 0) ? vid.height : vid_height.value);
        // now try to scale to our actual size:
        sn = sz * vh / vid_conheight.value;
@@ -304,12 +490,18 @@ static float Font_VirtualToRealSize(float sz)
        return si;
 }
 
-static qboolean Font_LoadFile(const char *name, int _face, ft2_font_t *font);
-static qboolean Font_LoadSize(ft2_font_t *font, float size, qboolean no_texture, qboolean no_kerning);
+float Font_SnapTo(float val, float snapwidth)
+{
+       return floor(val / snapwidth + 0.5f) * snapwidth;
+}
+
+static qboolean Font_LoadFile(const char *name, int _face, ft2_settings_t *settings, ft2_font_t *font);
+static qboolean Font_LoadSize(ft2_font_t *font, float size, qboolean check_only);
 qboolean Font_LoadFont(const char *name, dp_font_t *dpfnt)
 {
        int s, count, i;
        ft2_font_t *ft2, *fbfont, *fb;
+       char vabuf[1024];
 
        ft2 = Font_Alloc();
        if (!ft2)
@@ -326,7 +518,7 @@ qboolean Font_LoadFont(const char *name, dp_font_t *dpfnt)
                        break;
        }
 
-       if (!Font_LoadFile(name, dpfnt->req_face, ft2))
+       if (!Font_LoadFile(name, dpfnt->req_face, &dpfnt->settings, ft2))
        {
                if (i >= MAX_FONT_FALLBACKS)
                {
@@ -354,16 +546,21 @@ qboolean Font_LoadFont(const char *name, dp_font_t *dpfnt)
                        Con_Printf("Failed to allocate font for fallback %i of font %s\n", i, name);
                        break;
                }
-               if (!Font_LoadFile(dpfnt->fallbacks[i], dpfnt->fallback_faces[i], fb))
+
+               if (!Font_LoadFile(dpfnt->fallbacks[i], dpfnt->fallback_faces[i], &dpfnt->settings, fb))
                {
-                       Con_Printf("Failed to allocate font for fallback %i of font %s\n", i, name);
+                       if(!FS_FileExists(va(vabuf, sizeof(vabuf), "%s.tga", dpfnt->fallbacks[i])))
+                       if(!FS_FileExists(va(vabuf, sizeof(vabuf), "%s.png", dpfnt->fallbacks[i])))
+                       if(!FS_FileExists(va(vabuf, sizeof(vabuf), "%s.jpg", dpfnt->fallbacks[i])))
+                       if(!FS_FileExists(va(vabuf, sizeof(vabuf), "%s.pcx", dpfnt->fallbacks[i])))
+                               Con_Printf("Failed to load font %s for fallback %i of font %s\n", dpfnt->fallbacks[i], i, name);
                        Mem_Free(fb);
-                       break;
+                       continue;
                }
                count = 0;
-               for (s = 0; s < MAX_FONT_SIZES; ++s)
+               for (s = 0; s < MAX_FONT_SIZES && dpfnt->req_sizes[s] >= 0; ++s)
                {
-                       if (Font_LoadSize(fb, Font_VirtualToRealSize(dpfnt->req_sizes[s]), true, false))
+                       if (Font_LoadSize(fb, Font_VirtualToRealSize(dpfnt->req_sizes[s]), true))
                                ++count;
                }
                if (!count)
@@ -388,9 +585,9 @@ qboolean Font_LoadFont(const char *name, dp_font_t *dpfnt)
        }
 
        count = 0;
-       for (s = 0; s < MAX_FONT_SIZES; ++s)
+       for (s = 0; s < MAX_FONT_SIZES && dpfnt->req_sizes[s] >= 0; ++s)
        {
-               if (Font_LoadSize(ft2, Font_VirtualToRealSize(dpfnt->req_sizes[s]), false, false))
+               if (Font_LoadSize(ft2, Font_VirtualToRealSize(dpfnt->req_sizes[s]), false))
                        ++count;
        }
        if (!count)
@@ -407,13 +604,13 @@ qboolean Font_LoadFont(const char *name, dp_font_t *dpfnt)
        return true;
 }
 
-static qboolean Font_LoadFile(const char *name, int _face, ft2_font_t *font)
+static qboolean Font_LoadFile(const char *name, int _face, ft2_settings_t *settings, ft2_font_t *font)
 {
        size_t namelen;
        char filename[MAX_QPATH];
        int status;
        size_t i;
-       unsigned char *data;
+       const unsigned char *data;
        fs_offset_t datasize;
 
        memset(font, 0, sizeof(*font));
@@ -429,47 +626,62 @@ static qboolean Font_LoadFile(const char *name, int _face, ft2_font_t *font)
                return false;
        }
 
+       font->settings = settings;
+
        namelen = strlen(name);
+       if (namelen + 5 > sizeof(filename))
+       {
+               Con_Printf("WARNING: too long font name. Cannot load this.\n");
+               return false;
+       }
 
-       memcpy(filename, name, namelen);
-       memcpy(filename + namelen, ".ttf", 5);
-       data = FS_LoadFile(filename, font_mempool, false, &datasize);
+       // try load direct file
+       memcpy(filename, name, namelen+1);
+       data = fontfilecache_LoadFile(filename, false, &datasize);
+       // try load .ttf
+       if (!data)
+       {
+               memcpy(filename + namelen, ".ttf", 5);
+               data = fontfilecache_LoadFile(filename, false, &datasize);
+       }
+       // try load .otf
        if (!data)
        {
                memcpy(filename + namelen, ".otf", 5);
-               data = FS_LoadFile(filename, font_mempool, false, &datasize);
+               data = fontfilecache_LoadFile(filename, false, &datasize);
        }
+       // try load .pfb/afm
        if (!data)
        {
                ft2_attachment_t afm;
 
                memcpy(filename + namelen, ".pfb", 5);
-               data = FS_LoadFile(filename, font_mempool, false, &datasize);
+               data = fontfilecache_LoadFile(filename, false, &datasize);
 
                if (data)
                {
                        memcpy(filename + namelen, ".afm", 5);
-                       afm.data = FS_LoadFile(filename, font_mempool, false, &afm.size);
+                       afm.data = fontfilecache_LoadFile(filename, false, &afm.size);
 
                        if (afm.data)
                                Font_Attach(font, &afm);
                }
        }
-
        if (!data)
        {
                // FS_LoadFile being not-quiet should print an error :)
                return false;
        }
-       Con_Printf("Loading font %s face %i...\n", filename, _face);
+       Con_DPrintf("Loading font %s face %i...\n", filename, _face);
 
        status = qFT_New_Memory_Face(font_ft2lib, (FT_Bytes)data, datasize, _face, (FT_Face*)&font->face);
        if (status && _face != 0)
        {
                Con_Printf("Failed to load face %i of %s. Falling back to face 0\n", _face, name);
                _face = 0;
-               status = qFT_New_Memory_Face(font_ft2lib, (FT_Bytes)data, datasize, 0, (FT_Face*)&font->face);
+               status = qFT_New_Memory_Face(font_ft2lib, (FT_Bytes)data, datasize, _face, (FT_Face*)&font->face);
        }
+       font->data = data;
        if (status)
        {
                Con_Printf("ERROR: can't create face for %s\n"
@@ -487,23 +699,201 @@ static qboolean Font_LoadFile(const char *name, int _face, ft2_font_t *font)
                args.flags = FT_OPEN_MEMORY;
                args.memory_base = (const FT_Byte*)font->attachments[i].data;
                args.memory_size = font->attachments[i].size;
-               if (qFT_Attach_Stream(font->face, &args))
+               if (qFT_Attach_Stream((FT_Face)font->face, &args))
                        Con_Printf("Failed to add attachment %u to %s\n", (unsigned)i, font->name);
        }
 
-       memcpy(font->name, name, namelen+1);
+       strlcpy(font->name, name, sizeof(font->name));
        font->image_font = false;
        font->has_kerning = !!(((FT_Face)(font->face))->face_flags & FT_FACE_FLAG_KERNING);
        return true;
 }
 
+static void Font_Postprocess_Update(ft2_font_t *fnt, int bpp, int w, int h)
+{
+       int needed, x, y;
+       float gausstable[2*POSTPROCESS_MAXRADIUS+1];
+       qboolean need_gauss  = (!pp.buf || pp.blur != fnt->settings->blur || pp.shadowz != fnt->settings->shadowz);
+       qboolean need_circle = (!pp.buf || pp.outline != fnt->settings->outline || pp.shadowx != fnt->settings->shadowx || pp.shadowy != fnt->settings->shadowy);
+       pp.blur = fnt->settings->blur;
+       pp.outline = fnt->settings->outline;
+       pp.shadowx = fnt->settings->shadowx;
+       pp.shadowy = fnt->settings->shadowy;
+       pp.shadowz = fnt->settings->shadowz;
+       pp.outlinepadding_l = bound(0, ceil(pp.outline - pp.shadowx), POSTPROCESS_MAXRADIUS);
+       pp.outlinepadding_r = bound(0, ceil(pp.outline + pp.shadowx), POSTPROCESS_MAXRADIUS);
+       pp.outlinepadding_t = bound(0, ceil(pp.outline - pp.shadowy), POSTPROCESS_MAXRADIUS);
+       pp.outlinepadding_b = bound(0, ceil(pp.outline + pp.shadowy), POSTPROCESS_MAXRADIUS);
+       pp.blurpadding_lt = bound(0, ceil(pp.blur - pp.shadowz), POSTPROCESS_MAXRADIUS);
+       pp.blurpadding_rb = bound(0, ceil(pp.blur + pp.shadowz), POSTPROCESS_MAXRADIUS);
+       pp.padding_l = pp.blurpadding_lt + pp.outlinepadding_l;
+       pp.padding_r = pp.blurpadding_rb + pp.outlinepadding_r;
+       pp.padding_t = pp.blurpadding_lt + pp.outlinepadding_t;
+       pp.padding_b = pp.blurpadding_rb + pp.outlinepadding_b;
+       if(need_gauss)
+       {
+               float sum = 0;
+               for(x = -POSTPROCESS_MAXRADIUS; x <= POSTPROCESS_MAXRADIUS; ++x)
+                       gausstable[POSTPROCESS_MAXRADIUS+x] = (pp.blur > 0 ? exp(-(pow(x + pp.shadowz, 2))/(pp.blur*pp.blur * 2)) : (floor(x + pp.shadowz + 0.5) == 0));
+               for(x = -pp.blurpadding_rb; x <= pp.blurpadding_lt; ++x)
+                       sum += gausstable[POSTPROCESS_MAXRADIUS+x];
+               for(x = -POSTPROCESS_MAXRADIUS; x <= POSTPROCESS_MAXRADIUS; ++x)
+                       pp.gausstable[POSTPROCESS_MAXRADIUS+x] = floor(gausstable[POSTPROCESS_MAXRADIUS+x] / sum * 255 + 0.5);
+       }
+       if(need_circle)
+       {
+               for(y = -POSTPROCESS_MAXRADIUS; y <= POSTPROCESS_MAXRADIUS; ++y)
+                       for(x = -POSTPROCESS_MAXRADIUS; x <= POSTPROCESS_MAXRADIUS; ++x)
+                       {
+                               float d = pp.outline + 1 - sqrt(pow(x + pp.shadowx, 2) + pow(y + pp.shadowy, 2));
+                               pp.circlematrix[POSTPROCESS_MAXRADIUS+y][POSTPROCESS_MAXRADIUS+x] = (d >= 1) ? 255 : (d <= 0) ? 0 : floor(d * 255 + 0.5);
+                       }
+       }
+       pp.bufwidth = w + pp.padding_l + pp.padding_r;
+       pp.bufheight = h + pp.padding_t + pp.padding_b;
+       pp.bufpitch = pp.bufwidth;
+       needed = pp.bufwidth * pp.bufheight;
+       if(!pp.buf || pp.bufsize < needed * 2)
+       {
+               if(pp.buf)
+                       Mem_Free(pp.buf);
+               pp.bufsize = needed * 4;
+               pp.buf = (unsigned char *)Mem_Alloc(font_mempool, pp.bufsize);
+               pp.buf2 = pp.buf + needed;
+       }
+}
+
+static void Font_Postprocess(ft2_font_t *fnt, unsigned char *imagedata, int pitch, int bpp, int w, int h, int *pad_l, int *pad_r, int *pad_t, int *pad_b)
+{
+       int x, y;
+
+       // calculate gauss table
+       Font_Postprocess_Update(fnt, bpp, w, h);
+
+       if(imagedata)
+       {
+               // enlarge buffer
+               // perform operation, not exceeding the passed padding values,
+               // but possibly reducing them
+               *pad_l = min(*pad_l, pp.padding_l);
+               *pad_r = min(*pad_r, pp.padding_r);
+               *pad_t = min(*pad_t, pp.padding_t);
+               *pad_b = min(*pad_b, pp.padding_b);
+
+               // outline the font (RGBA only)
+               if(bpp == 4 && (pp.outline > 0 || pp.blur > 0 || pp.shadowx != 0 || pp.shadowy != 0 || pp.shadowz != 0)) // we can only do this in BGRA
+               {
+                       // this is like mplayer subtitle rendering
+                       // bbuffer, bitmap buffer: this is our font
+                       // abuffer, alpha buffer: this is pp.buf
+                       // tmp: this is pp.buf2
+
+                       // create outline buffer
+                       memset(pp.buf, 0, pp.bufwidth * pp.bufheight);
+                       for(y = -*pad_t; y < h + *pad_b; ++y)
+                               for(x = -*pad_l; x < w + *pad_r; ++x)
+                               {
+                                       int x1 = max(-x, -pp.outlinepadding_r);
+                                       int y1 = max(-y, -pp.outlinepadding_b);
+                                       int x2 = min(pp.outlinepadding_l, w-1-x);
+                                       int y2 = min(pp.outlinepadding_t, h-1-y);
+                                       int mx, my;
+                                       int cur = 0;
+                                       int highest = 0;
+                                       for(my = y1; my <= y2; ++my)
+                                               for(mx = x1; mx <= x2; ++mx)
+                                               {
+                                                       cur = pp.circlematrix[POSTPROCESS_MAXRADIUS+my][POSTPROCESS_MAXRADIUS+mx] * (int)imagedata[(x+mx) * bpp + pitch * (y+my) + (bpp - 1)];
+                                                       if(cur > highest)
+                                                               highest = cur;
+                                               }
+                                       pp.buf[((x + pp.padding_l) + pp.bufpitch * (y + pp.padding_t))] = (highest + 128) / 255;
+                               }
+
+                       // blur the outline buffer
+                       if(pp.blur > 0 || pp.shadowz != 0)
+                       {
+                               // horizontal blur
+                               for(y = 0; y < pp.bufheight; ++y)
+                                       for(x = 0; x < pp.bufwidth; ++x)
+                                       {
+                                               int x1 = max(-x, -pp.blurpadding_rb);
+                                               int x2 = min(pp.blurpadding_lt, pp.bufwidth-1-x);
+                                               int mx;
+                                               int blurred = 0;
+                                               for(mx = x1; mx <= x2; ++mx)
+                                                       blurred += pp.gausstable[POSTPROCESS_MAXRADIUS+mx] * (int)pp.buf[(x+mx) + pp.bufpitch * y];
+                                               pp.buf2[x + pp.bufpitch * y] = bound(0, blurred, 65025) / 255;
+                                       }
+
+                               // vertical blur
+                               for(y = 0; y < pp.bufheight; ++y)
+                                       for(x = 0; x < pp.bufwidth; ++x)
+                                       {
+                                               int y1 = max(-y, -pp.blurpadding_rb);
+                                               int y2 = min(pp.blurpadding_lt, pp.bufheight-1-y);
+                                               int my;
+                                               int blurred = 0;
+                                               for(my = y1; my <= y2; ++my)
+                                                       blurred += pp.gausstable[POSTPROCESS_MAXRADIUS+my] * (int)pp.buf2[x + pp.bufpitch * (y+my)];
+                                               pp.buf[x + pp.bufpitch * y] = bound(0, blurred, 65025) / 255;
+                                       }
+                       }
+
+                       // paste the outline below the font
+                       for(y = -*pad_t; y < h + *pad_b; ++y)
+                               for(x = -*pad_l; x < w + *pad_r; ++x)
+                               {
+                                       unsigned char outlinealpha = pp.buf[(x + pp.padding_l) + pp.bufpitch * (y + pp.padding_t)];
+                                       if(outlinealpha > 0)
+                                       {
+                                               unsigned char oldalpha = imagedata[x * bpp + pitch * y + (bpp - 1)];
+                                               // a' = 1 - (1 - a1) (1 - a2)
+                                               unsigned char newalpha = 255 - ((255 - (int)outlinealpha) * (255 - (int)oldalpha)) / 255; // this is >= oldalpha
+                                               // c' = (a2 c2 - a1 a2 c1 + a1 c1) / a' = (a2 c2 + a1 (1 - a2) c1) / a'
+                                               unsigned char oldfactor     = (255 * (int)oldalpha) / newalpha;
+                                               //unsigned char outlinefactor = ((255 - oldalpha) * (int)outlinealpha) / newalpha;
+                                               int i;
+                                               for(i = 0; i < bpp-1; ++i)
+                                               {
+                                                       unsigned char c = imagedata[x * bpp + pitch * y + i];
+                                                       c = (c * (int)oldfactor) / 255 /* + outlinecolor[i] * (int)outlinefactor */;
+                                                       imagedata[x * bpp + pitch * y + i] = c;
+                                               }
+                                               imagedata[x * bpp + pitch * y + (bpp - 1)] = newalpha;
+                                       }
+                                       //imagedata[x * bpp + pitch * y + (bpp - 1)] |= 0x80;
+                               }
+               }
+       }
+       else if(pitch)
+       {
+               // perform operation, not exceeding the passed padding values,
+               // but possibly reducing them
+               *pad_l = min(*pad_l, pp.padding_l);
+               *pad_r = min(*pad_r, pp.padding_r);
+               *pad_t = min(*pad_t, pp.padding_t);
+               *pad_b = min(*pad_b, pp.padding_b);
+       }
+       else
+       {
+               // just calculate parameters
+               *pad_l = pp.padding_l;
+               *pad_r = pp.padding_r;
+               *pad_t = pp.padding_t;
+               *pad_b = pp.padding_b;
+       }
+}
+
+static float Font_SearchSize(ft2_font_t *font, FT_Face fontface, float size);
 static qboolean Font_LoadMap(ft2_font_t *font, ft2_font_map_t *mapstart, Uchar _ch, ft2_font_map_t **outmap);
-static qboolean Font_LoadSize(ft2_font_t *font, float size, qboolean no_texture, qboolean no_kerning)
+static qboolean Font_LoadSize(ft2_font_t *font, float size, qboolean check_only)
 {
        int map_index;
        ft2_font_map_t *fmap, temp;
+       int gpad_l, gpad_r, gpad_t, gpad_b;
 
-       if (IS_NAN(size))
+       if (!(size > 0.001f && size < 1000.0f))
                size = 0;
 
        if (!size)
@@ -511,93 +901,106 @@ static qboolean Font_LoadSize(ft2_font_t *font, float size, qboolean no_texture,
        if (size < 2) // bogus sizes are not allowed - and they screw up our allocations
                return false;
 
-       if (!no_texture)
+       for (map_index = 0; map_index < MAX_FONT_SIZES; ++map_index)
        {
-               for (map_index = 0; map_index < MAX_FONT_SIZES; ++map_index)
-               {
-                       if (!font->font_maps[map_index])
-                               break;
-                       // if a similar size has already been loaded, ignore this one
-                       //abs(font->font_maps[map_index]->size - size) < 4
-                       if (font->font_maps[map_index]->size == size)
-                               return true;
-               }
+               if (!font->font_maps[map_index])
+                       break;
+               // if a similar size has already been loaded, ignore this one
+               //abs(font->font_maps[map_index]->size - size) < 4
+               if (font->font_maps[map_index]->size == size)
+                       return true;
+       }
 
-               if (map_index >= MAX_FONT_SIZES)
-                       return false;
+       if (map_index >= MAX_FONT_SIZES)
+               return false;
 
-               memset(&temp, 0, sizeof(temp));
-               temp.size = size;
-               temp.glyphSize = CeilPowerOf2(size*2);
-               temp.sfx = (1.0/64.0)/(double)size;
-               temp.sfy = (1.0/64.0)/(double)size;
-               temp.intSize = -1; // negative value: LoadMap must search now :)
-               if (!Font_LoadMap(font, &temp, 0, &fmap))
-               {
-                       Con_Printf("ERROR: can't load the first character map for %s\n"
-                                  "This is fatal\n",
-                                  font->name);
-                       Font_UnloadFont(font);
-                       return false;
-               }
-               font->font_maps[map_index] = temp.next;
+       if (check_only) {
+               FT_Face fontface;
+               if (font->image_font)
+                       fontface = (FT_Face)font->next->face;
+               else
+                       fontface = (FT_Face)font->face;
+               return (Font_SearchSize(font, fontface, size) > 0);
+       }
 
-               fmap->sfx = temp.sfx;
-               fmap->sfy = temp.sfy;
+       Font_Postprocess(font, NULL, 0, 4, size*2, size*2, &gpad_l, &gpad_r, &gpad_t, &gpad_b);
+
+       memset(&temp, 0, sizeof(temp));
+       temp.size = size;
+       temp.glyphSize = size*2 + max(gpad_l + gpad_r, gpad_t + gpad_b);
+       if (!r_font_nonpoweroftwo.integer)
+               temp.glyphSize = CeilPowerOf2(temp.glyphSize);
+       temp.sfx = (1.0/64.0)/(double)size;
+       temp.sfy = (1.0/64.0)/(double)size;
+       temp.intSize = -1; // negative value: LoadMap must search now :)
+       if (!Font_LoadMap(font, &temp, 0, &fmap))
+       {
+               Con_Printf("ERROR: can't load the first character map for %s\n"
+                          "This is fatal\n",
+                          font->name);
+               Font_UnloadFont(font);
+               return false;
        }
-       if (!no_kerning)
+       font->font_maps[map_index] = temp.next;
+
+       fmap->sfx = temp.sfx;
+       fmap->sfy = temp.sfy;
+
+       // load the default kerning vector:
+       if (font->has_kerning)
        {
-               // load the default kerning vector:
-               if (font->has_kerning)
+               Uchar l, r;
+               FT_Vector kernvec;
+               for (l = 0; l < 256; ++l)
                {
-                       Uchar l, r;
-                       FT_Vector kernvec;
-                       for (l = 0; l < 256; ++l)
+                       for (r = 0; r < 256; ++r)
                        {
-                               for (r = 0; r < 256; ++r)
+                               FT_ULong ul, ur;
+                               ul = qFT_Get_Char_Index((FT_Face)font->face, l);
+                               ur = qFT_Get_Char_Index((FT_Face)font->face, r);
+                               if (qFT_Get_Kerning((FT_Face)font->face, ul, ur, FT_KERNING_DEFAULT, &kernvec))
                                {
-                                       FT_ULong ul, ur;
-                                       ul = qFT_Get_Char_Index(font->face, l);
-                                       ur = qFT_Get_Char_Index(font->face, r);
-                                       if (qFT_Get_Kerning(font->face, ul, ur, FT_KERNING_DEFAULT, &kernvec))
-                                       {
-                                               fmap->kerning.kerning[l][r][0] = 0;
-                                               fmap->kerning.kerning[l][r][1] = 0;
-                                       }
-                                       else
-                                       {
-                                               fmap->kerning.kerning[l][r][0] = (kernvec.x >> 6) / fmap->size;
-                                               fmap->kerning.kerning[l][r][1] = (kernvec.y >> 6) / fmap->size;
-                                       }
+                                       fmap->kerning.kerning[l][r][0] = 0;
+                                       fmap->kerning.kerning[l][r][1] = 0;
+                               }
+                               else
+                               {
+                                       fmap->kerning.kerning[l][r][0] = Font_SnapTo((kernvec.x / 64.0) / fmap->size, 1 / fmap->size);
+                                       fmap->kerning.kerning[l][r][1] = Font_SnapTo((kernvec.y / 64.0) / fmap->size, 1 / fmap->size);
                                }
                        }
                }
        }
-
        return true;
 }
 
 int Font_IndexForSize(ft2_font_t *font, float _fsize, float *outw, float *outh)
 {
        int match = -1;
-       int value = 1000000;
-       int nval;
+       float value = 1000000;
+       float nval;
        int matchsize = -10000;
        int m;
-       int size;
-       float fsize;
+       float fsize_x, fsize_y;
        ft2_font_map_t **maps = font->font_maps;
 
-       fsize = _fsize * vid.height / vid_conheight.value;
+       fsize_x = fsize_y = _fsize * vid.height / vid_conheight.value;
+       if(outw && *outw)
+               fsize_x = *outw * vid.width / vid_conwidth.value;
+       if(outh && *outh)
+               fsize_y = *outh * vid.height / vid_conheight.value;
 
-       if (fsize < 0)
-               size = 16;
+       if (fsize_x < 0)
+       {
+               if(fsize_y < 0)
+                       fsize_x = fsize_y = 16;
+               else
+                       fsize_x = fsize_y;
+       }
        else
        {
-               // round up
-               size = (int)fsize;
-               if (fsize - (float)size >= 0.49)
-                       ++size;
+               if(fsize_y < 0)
+                       fsize_y = fsize_x;
        }
 
        for (m = 0; m < MAX_FONT_SIZES; ++m)
@@ -605,7 +1008,7 @@ int Font_IndexForSize(ft2_font_t *font, float _fsize, float *outw, float *outh)
                if (!maps[m])
                        continue;
                // "round up" to the bigger size if two equally-valued matches exist
-               nval = abs(maps[m]->size - size);
+               nval = 0.5 * (fabs(maps[m]->size - fsize_x) + fabs(maps[m]->size - fsize_y));
                if (match == -1 || nval < value || (nval == value && matchsize < maps[m]->size))
                {
                        value = nval;
@@ -617,14 +1020,9 @@ int Font_IndexForSize(ft2_font_t *font, float _fsize, float *outw, float *outh)
        }
        if (value <= r_font_size_snapping.value)
        {
-               if (outw && outh)
-               {
-                       if (!*outh) *outh = *outw;
-                       if (!*outw) *outw = *outh;
-               }
-               // keep the aspect
+               // do NOT keep the aspect for perfect rendering
                if (outh) *outh = maps[match]->size * vid_conheight.value / vid.height;
-               if (outw) *outw = maps[match]->size * vid_conwidth.value / vid.width * *outw / _fsize;
+               if (outw) *outw = maps[match]->size * vid_conwidth.value / vid.width;
        }
        return match;
 }
@@ -665,7 +1063,7 @@ static qboolean Font_SetSize(ft2_font_t *font, float w, float h)
 qboolean Font_GetKerningForMap(ft2_font_t *font, int map_index, float w, float h, Uchar left, Uchar right, float *outx, float *outy)
 {
        ft2_font_map_t *fmap;
-       if (!font->has_kerning)
+       if (!font->has_kerning || !r_font_kerning.integer)
                return false;
        if (map_index < 0 || map_index >= MAX_FONT_SIZES)
                return false;
@@ -674,9 +1072,10 @@ qboolean Font_GetKerningForMap(ft2_font_t *font, int map_index, float w, float h
                return false;
        if (left < 256 && right < 256)
        {
+               //Con_Printf("%g : %f, %f, %f :: %f\n", (w / (float)fmap->size), w, fmap->size, fmap->intSize, Font_VirtualToRealSize(w));
                // quick-kerning, be aware of the size: scale it
-               if (outx) *outx = fmap->kerning.kerning[left][right][0] * w / (float)fmap->size;
-               if (outy) *outy = fmap->kerning.kerning[left][right][1] * h / (float)fmap->size;
+               if (outx) *outx = fmap->kerning.kerning[left][right][0];// * (w / (float)fmap->size);
+               if (outy) *outy = fmap->kerning.kerning[left][right][1];// * (h / (float)fmap->size);
                return true;
        }
        else
@@ -685,6 +1084,7 @@ qboolean Font_GetKerningForMap(ft2_font_t *font, int map_index, float w, float h
                FT_ULong ul, ur;
 
                //if (qFT_Set_Pixel_Sizes((FT_Face)font->face, 0, fmap->size))
+#if 0
                if (!Font_SetSize(font, w, h))
                {
                        // this deserves an error message
@@ -695,8 +1095,23 @@ qboolean Font_GetKerningForMap(ft2_font_t *font, int map_index, float w, float h
                ur = qFT_Get_Char_Index(font->face, right);
                if (qFT_Get_Kerning(font->face, ul, ur, FT_KERNING_DEFAULT, &kernvec))
                {
-                       if (outx) *outx = kernvec.x * fmap->sfx;
-                       if (outy) *outy = kernvec.y * fmap->sfy;
+                       if (outx) *outx = Font_SnapTo(kernvec.x * fmap->sfx, 1 / fmap->size);
+                       if (outy) *outy = Font_SnapTo(kernvec.y * fmap->sfy, 1 / fmap->size);
+                       return true;
+               }
+#endif
+               if (!Font_SetSize(font, fmap->intSize, fmap->intSize))
+               {
+                       // this deserves an error message
+                       Con_Printf("Failed to get kerning for %s\n", font->name);
+                       return false;
+               }
+               ul = qFT_Get_Char_Index((FT_Face)font->face, left);
+               ur = qFT_Get_Char_Index((FT_Face)font->face, right);
+               if (qFT_Get_Kerning((FT_Face)font->face, ul, ur, FT_KERNING_DEFAULT, &kernvec))
+               {
+                       if (outx) *outx = Font_SnapTo(kernvec.x * fmap->sfx, 1 / fmap->size);// * (w / (float)fmap->size);
+                       if (outy) *outy = Font_SnapTo(kernvec.y * fmap->sfy, 1 / fmap->size);// * (h / (float)fmap->size);
                        return true;
                }
                return false;
@@ -710,10 +1125,10 @@ qboolean Font_GetKerningForSize(ft2_font_t *font, float w, float h, Uchar left,
 
 static void UnloadMapRec(ft2_font_map_t *map)
 {
-       if (map->texture)
+       if (map->pic)
        {
-               R_FreeTexture(map->texture);
-               map->texture = NULL;
+               //Draw_FreePic(map->pic); // FIXME: refcounting needed...
+               map->pic = NULL;
        }
        if (map->next)
                UnloadMapRec(map->next);
@@ -723,8 +1138,17 @@ static void UnloadMapRec(ft2_font_map_t *map)
 void Font_UnloadFont(ft2_font_t *font)
 {
        int i;
+
+       // unload fallbacks
+       if(font->next)
+               Font_UnloadFont(font->next);
+
        if (font->attachments && font->attachmentcount)
        {
+               for (i = 0; i < (int)font->attachmentcount; ++i) {
+                       if (font->attachments[i].data)
+                               fontfilecache_Free(font->attachments[i].data);
+               }
                Mem_Free(font->attachments);
                font->attachmentcount = 0;
                font->attachments = NULL;
@@ -737,7 +1161,11 @@ void Font_UnloadFont(ft2_font_t *font)
                        font->font_maps[i] = NULL;
                }
        }
+#ifndef DP_FREETYPE_STATIC
        if (ft2_dll)
+#else
+       if (!r_font_disable_freetype.integer)
+#endif
        {
                if (font->face)
                {
@@ -745,16 +1173,44 @@ void Font_UnloadFont(ft2_font_t *font)
                        font->face = NULL;
                }
        }
+       if (font->data) {
+           fontfilecache_Free(font->data);
+           font->data = NULL;
+       }
+}
+
+static float Font_SearchSize(ft2_font_t *font, FT_Face fontface, float size)
+{
+       float intSize = size;
+       while (1)
+       {
+               if (!Font_SetSize(font, intSize, intSize))
+               {
+                       Con_Printf("ERROR: can't set size for font %s: %f ((%f))\n", font->name, size, intSize);
+                       return -1;
+               }
+               if ((fontface->size->metrics.height>>6) <= size)
+                       return intSize;
+               if (intSize < 2)
+               {
+                       Con_Printf("ERROR: no appropriate size found for font %s: %f\n", font->name, size);
+                       return -1;
+               }
+               --intSize;
+       }
 }
 
 static qboolean Font_LoadMap(ft2_font_t *font, ft2_font_map_t *mapstart, Uchar _ch, ft2_font_map_t **outmap)
 {
        char map_identifier[MAX_QPATH];
        unsigned long mapidx = _ch / FONT_CHARS_PER_MAP;
-       unsigned char *data;
+       unsigned char *data = NULL;
        FT_ULong ch, mapch;
        int status;
        int tp;
+       FT_Int32 load_flags;
+       int gpad_l, gpad_r, gpad_t, gpad_b;
+       char vabuf[1024];
 
        int pitch;
        int gR, gC; // glyph position: row and column
@@ -777,12 +1233,52 @@ static qboolean Font_LoadMap(ft2_font_t *font, ft2_font_map_t *mapstart, Uchar _
        else
                fontface = (FT_Face)font->face;
 
+       switch(font->settings->antialias)
+       {
+               case 0:
+                       switch(font->settings->hinting)
+                       {
+                               case 0:
+                                       load_flags = FT_LOAD_NO_HINTING | FT_LOAD_NO_AUTOHINT | FT_LOAD_TARGET_MONO | FT_LOAD_MONOCHROME;
+                                       break;
+                               case 1:
+                               case 2:
+                                       load_flags = FT_LOAD_FORCE_AUTOHINT | FT_LOAD_TARGET_MONO | FT_LOAD_MONOCHROME;
+                                       break;
+                               default:
+                               case 3:
+                                       load_flags = FT_LOAD_TARGET_MONO | FT_LOAD_MONOCHROME;
+                                       break;
+                       }
+                       break;
+               default:
+               case 1:
+                       switch(font->settings->hinting)
+                       {
+                               case 0:
+                                       load_flags = FT_LOAD_NO_HINTING | FT_LOAD_NO_AUTOHINT | FT_LOAD_TARGET_NORMAL;
+                                       break;
+                               case 1:
+                                       load_flags = FT_LOAD_FORCE_AUTOHINT | FT_LOAD_TARGET_LIGHT;
+                                       break;
+                               case 2:
+                                       load_flags = FT_LOAD_FORCE_AUTOHINT | FT_LOAD_TARGET_NORMAL;
+                                       break;
+                               default:
+                               case 3:
+                                       load_flags = FT_LOAD_TARGET_NORMAL;
+                                       break;
+                       }
+                       break;
+       }
+
        //status = qFT_Set_Pixel_Sizes((FT_Face)font->face, /*size*/0, mapstart->size);
        //if (status)
        if (font->image_font && mapstart->intSize < 0)
                mapstart->intSize = mapstart->size;
        if (mapstart->intSize < 0)
        {
+               /*
                mapstart->intSize = mapstart->size;
                while (1)
                {
@@ -800,8 +1296,10 @@ static qboolean Font_LoadMap(ft2_font_t *font, ft2_font_map_t *mapstart, Uchar _
                        }
                        --mapstart->intSize;
                }
-               if (developer.integer)
-                       Con_Printf("Using size: %f for requested size %f\n", mapstart->intSize, mapstart->size);
+               */
+               if ((mapstart->intSize = Font_SearchSize(font, fontface, mapstart->size)) <= 0)
+                       return false;
+               Con_DPrintf("Using size: %f for requested size %f\n", mapstart->intSize, mapstart->size);
        }
 
        if (!font->image_font && !Font_SetSize(font, mapstart->intSize, mapstart->intSize))
@@ -810,13 +1308,32 @@ static qboolean Font_LoadMap(ft2_font_t *font, ft2_font_map_t *mapstart, Uchar _
                return false;
        }
 
-       map = Mem_Alloc(font_mempool, sizeof(ft2_font_map_t));
+       map = (ft2_font_map_t *)Mem_Alloc(font_mempool, sizeof(ft2_font_map_t));
        if (!map)
        {
                Con_Printf("ERROR: Out of memory when loading fontmap for %s\n", font->name);
                return false;
        }
 
+       // create a totally unique name for this map, then we will use it to make a unique cachepic_t to avoid redundant textures
+       dpsnprintf(map_identifier, sizeof(map_identifier),
+               "%s_cache_%g_%d_%g_%g_%g_%g_%g_%u",
+               font->name,
+               (double) mapstart->intSize,
+               (int) load_flags,
+               (double) font->settings->blur,
+               (double) font->settings->outline,
+               (double) font->settings->shadowx,
+               (double) font->settings->shadowy,
+               (double) font->settings->shadowz,
+               (unsigned) mapidx);
+
+       // create a cachepic_t from the data now, or reuse an existing one
+       if (developer_font.integer)
+               Con_Printf("Generating font map %s (size: %.1f MB)\n", map_identifier, mapstart->glyphSize * (256 * 4 / 1048576.0) * mapstart->glyphSize);
+
+       Font_Postprocess(font, NULL, 0, bytesPerPixel, mapstart->size*2, mapstart->size*2, &gpad_l, &gpad_r, &gpad_t, &gpad_b);
+
        // copy over the information
        map->size = mapstart->size;
        map->intSize = mapstart->intSize;
@@ -825,14 +1342,13 @@ static qboolean Font_LoadMap(ft2_font_t *font, ft2_font_map_t *mapstart, Uchar _
        map->sfy = mapstart->sfy;
 
        pitch = map->glyphSize * FONT_CHARS_PER_LINE * bytesPerPixel;
-       data = Mem_Alloc(font_mempool, (FONT_CHAR_LINES * map->glyphSize) * pitch);
+       data = (unsigned char *)Mem_Alloc(font_mempool, (FONT_CHAR_LINES * map->glyphSize) * pitch);
        if (!data)
        {
                Con_Printf("ERROR: Failed to allocate memory for font %s size %g\n", font->name, map->size);
                Mem_Free(map);
                return false;
        }
-
        // initialize as white texture with zero alpha
        tp = 0;
        while (tp < (FONT_CHAR_LINES * map->glyphSize) * pitch)
@@ -846,6 +1362,8 @@ static qboolean Font_LoadMap(ft2_font_t *font, ft2_font_map_t *mapstart, Uchar _
                data[tp++] = 0x00;
        }
 
+       memset(map->width_of, 0, sizeof(map->width_of));
+
        // insert the map
        map->start = mapidx * FONT_CHARS_PER_MAP;
        next = mapstart;
@@ -864,14 +1382,15 @@ static qboolean Font_LoadMap(ft2_font_t *font, ft2_font_map_t *mapstart, Uchar _
                int w, h, x, y;
                FT_GlyphSlot glyph;
                FT_Bitmap *bmp;
-               unsigned char *imagedata, *dst, *src;
+               unsigned char *imagedata = NULL, *dst, *src;
                glyph_slot_t *mapglyph;
                FT_Face face;
+               int pad_l, pad_r, pad_t, pad_b;
 
                mapch = ch - map->start;
 
-               if (developer.integer)
-                       Con_Print("glyphinfo: ------------- GLYPH INFO -----------------\n");
+               if (developer_font.integer)
+                       Con_DPrint("glyphinfo: ------------- GLYPH INFO -----------------\n");
 
                ++gC;
                if (gC >= FONT_CHARS_PER_LINE)
@@ -880,10 +1399,14 @@ static qboolean Font_LoadMap(ft2_font_t *font, ft2_font_map_t *mapstart, Uchar _
                        ++gR;
                }
 
-               imagedata = data + gR * pitch * map->glyphSize + gC * map->glyphSize * bytesPerPixel;
+               if (data)
+               {
+                       imagedata = data + gR * pitch * map->glyphSize + gC * map->glyphSize * bytesPerPixel;
+                       imagedata += gpad_t * pitch + gpad_l * bytesPerPixel;
+               }
                //status = qFT_Load_Char(face, ch, FT_LOAD_RENDER);
                // we need the glyphIndex
-               face = font->face;
+               face = (FT_Face)font->face;
                usefont = NULL;
                if (font->image_font && mapch == ch && img_fontmap[mapch])
                {
@@ -900,11 +1423,11 @@ static qboolean Font_LoadMap(ft2_font_t *font, ft2_font_map_t *mapstart, Uchar _
                                if (!Font_SetSize(usefont, mapstart->intSize, mapstart->intSize))
                                        continue;
                                // try that glyph
-                               face = usefont->face;
+                               face = (FT_Face)usefont->face;
                                glyphIndex = qFT_Get_Char_Index(face, ch);
                                if (glyphIndex == 0)
                                        continue;
-                               status = qFT_Load_Glyph(face, glyphIndex, FT_LOAD_RENDER);
+                               status = qFT_Load_Glyph(face, glyphIndex, FT_LOAD_RENDER | load_flags);
                                if (status)
                                        continue;
                                break;
@@ -913,7 +1436,7 @@ static qboolean Font_LoadMap(ft2_font_t *font, ft2_font_map_t *mapstart, Uchar _
                        {
                                //Con_Printf("failed to load fallback glyph for char %lx from font %s\n", (unsigned long)ch, font->name);
                                // now we let it use the "missing-glyph"-glyph
-                               face = font->face;
+                               face = (FT_Face)font->face;
                                glyphIndex = 0;
                        }
                }
@@ -921,13 +1444,12 @@ static qboolean Font_LoadMap(ft2_font_t *font, ft2_font_map_t *mapstart, Uchar _
                if (!usefont)
                {
                        usefont = font;
-                       face = font->face;
-                       status = qFT_Load_Glyph(face, glyphIndex, FT_LOAD_RENDER);
+                       face = (FT_Face)font->face;
+                       status = qFT_Load_Glyph(face, glyphIndex, FT_LOAD_RENDER | load_flags);
                        if (status)
                        {
                                //Con_Printf("failed to load glyph %lu for %s\n", glyphIndex, font->name);
-                               if (developer.integer)
-                                       Con_Printf("failed to load glyph for char %lx from font %s\n", (unsigned long)ch, font->name);
+                               Con_DPrintf("failed to load glyph for char %lx from font %s\n", (unsigned long)ch, font->name);
                                continue;
                        }
                }
@@ -938,94 +1460,112 @@ static qboolean Font_LoadMap(ft2_font_t *font, ft2_font_map_t *mapstart, Uchar _
                w = bmp->width;
                h = bmp->rows;
 
-               if (w > map->glyphSize || h > map->glyphSize) {
+               if (w > (map->glyphSize - gpad_l - gpad_r) || h > (map->glyphSize - gpad_t - gpad_b)) {
                        Con_Printf("WARNING: Glyph %lu is too big in font %s, size %g: %i x %i\n", ch, font->name, map->size, w, h);
                        if (w > map->glyphSize)
-                               w = map->glyphSize;
+                               w = map->glyphSize - gpad_l - gpad_r;
                        if (h > map->glyphSize)
                                h = map->glyphSize;
                }
 
-               switch (bmp->pixel_mode)
-               {
-               case FT_PIXEL_MODE_MONO:
-                       if (developer.integer)
-                               Con_Print("glyphinfo:   Pixel Mode: MONO\n");
-                       break;
-               case FT_PIXEL_MODE_GRAY2:
-                       if (developer.integer)
-                               Con_Print("glyphinfo:   Pixel Mode: GRAY2\n");
-                       break;
-               case FT_PIXEL_MODE_GRAY4:
-                       if (developer.integer)
-                               Con_Print("glyphinfo:   Pixel Mode: GRAY4\n");
-                       break;
-               case FT_PIXEL_MODE_GRAY:
-                       if (developer.integer)
-                               Con_Print("glyphinfo:   Pixel Mode: GRAY\n");
-                       break;
-               default:
-                       if (developer.integer)
-                               Con_Printf("glyphinfo:   Pixel Mode: Unknown: %i\n", bmp->pixel_mode);
-                       Mem_Free(data);
-                       Con_Printf("ERROR: Unrecognized pixel mode for font %s size %f: %i\n", font->name, mapstart->size, bmp->pixel_mode);
-                       return false;
-               }
-               for (y = 0; y < h; ++y)
+               if (imagedata)
                {
-                       dst = imagedata + y * pitch;
-                       src = bmp->buffer + y * bmp->pitch;
-
                        switch (bmp->pixel_mode)
                        {
                        case FT_PIXEL_MODE_MONO:
-                               dst += bytesPerPixel - 1; // shift to alpha byte
-                               for (x = 0; x < bmp->width; x += 8)
-                               {
-                                       unsigned char ch = *src++;
-                                       *dst = 255 * ((ch & 0x80) >> 7); dst += bytesPerPixel;
-                                       *dst = 255 * ((ch & 0x40) >> 6); dst += bytesPerPixel;
-                                       *dst = 255 * ((ch & 0x20) >> 5); dst += bytesPerPixel;
-                                       *dst = 255 * ((ch & 0x10) >> 4); dst += bytesPerPixel;
-                                       *dst = 255 * ((ch & 0x08) >> 3); dst += bytesPerPixel;
-                                       *dst = 255 * ((ch & 0x04) >> 2); dst += bytesPerPixel;
-                                       *dst = 255 * ((ch & 0x02) >> 1); dst += bytesPerPixel;
-                                       *dst = 255 * ((ch & 0x01) >> 0); dst += bytesPerPixel;
-                               }
+                               if (developer_font.integer)
+                                       Con_DPrint("glyphinfo:   Pixel Mode: MONO\n");
                                break;
                        case FT_PIXEL_MODE_GRAY2:
-                               dst += bytesPerPixel - 1; // shift to alpha byte
-                               for (x = 0; x < bmp->width; x += 4)
-                               {
-                                       unsigned char ch = *src++;
-                                       *dst = ( ((ch & 0xA0) >> 6) * 0x55 ); ch <<= 2; dst += bytesPerPixel;
-                                       *dst = ( ((ch & 0xA0) >> 6) * 0x55 ); ch <<= 2; dst += bytesPerPixel;
-                                       *dst = ( ((ch & 0xA0) >> 6) * 0x55 ); ch <<= 2; dst += bytesPerPixel;
-                                       *dst = ( ((ch & 0xA0) >> 6) * 0x55 ); ch <<= 2; dst += bytesPerPixel;
-                               }
+                               if (developer_font.integer)
+                                       Con_DPrint("glyphinfo:   Pixel Mode: GRAY2\n");
                                break;
                        case FT_PIXEL_MODE_GRAY4:
-                               dst += bytesPerPixel - 1; // shift to alpha byte
-                               for (x = 0; x < bmp->width; x += 2)
-                               {
-                                       unsigned char ch = *src++;
-                                       *dst = ( ((ch & 0xF0) >> 4) * 0x24); dst += bytesPerPixel;
-                                       *dst = ( ((ch & 0x0F) ) * 0x24); dst += bytesPerPixel;
-                               }
+                               if (developer_font.integer)
+                                       Con_DPrint("glyphinfo:   Pixel Mode: GRAY4\n");
                                break;
                        case FT_PIXEL_MODE_GRAY:
-                               // in this case pitch should equal width
-                               for (tp = 0; tp < bmp->pitch; ++tp)
-                                       dst[(bytesPerPixel - 1) + tp*bytesPerPixel] = src[tp]; // copy the grey value into the alpha bytes
-
-                               //memcpy((void*)dst, (void*)src, bmp->pitch);
-                               //dst += bmp->pitch;
+                               if (developer_font.integer)
+                                       Con_DPrint("glyphinfo:   Pixel Mode: GRAY\n");
                                break;
                        default:
-                               break;
+                               if (developer_font.integer)
+                                       Con_DPrintf("glyphinfo:   Pixel Mode: Unknown: %i\n", bmp->pixel_mode);
+                               Mem_Free(data);
+                               Con_Printf("ERROR: Unrecognized pixel mode for font %s size %f: %i\n", font->name, mapstart->size, bmp->pixel_mode);
+                               return false;
                        }
+                       for (y = 0; y < h; ++y)
+                       {
+                               dst = imagedata + y * pitch;
+                               src = bmp->buffer + y * bmp->pitch;
+
+                               switch (bmp->pixel_mode)
+                               {
+                               case FT_PIXEL_MODE_MONO:
+                                       dst += bytesPerPixel - 1; // shift to alpha byte
+                                       for (x = 0; x < bmp->width; x += 8)
+                                       {
+                                               unsigned char c = *src++;
+                                               *dst = 255 * !!((c & 0x80) >> 7); dst += bytesPerPixel;
+                                               *dst = 255 * !!((c & 0x40) >> 6); dst += bytesPerPixel;
+                                               *dst = 255 * !!((c & 0x20) >> 5); dst += bytesPerPixel;
+                                               *dst = 255 * !!((c & 0x10) >> 4); dst += bytesPerPixel;
+                                               *dst = 255 * !!((c & 0x08) >> 3); dst += bytesPerPixel;
+                                               *dst = 255 * !!((c & 0x04) >> 2); dst += bytesPerPixel;
+                                               *dst = 255 * !!((c & 0x02) >> 1); dst += bytesPerPixel;
+                                               *dst = 255 * !!((c & 0x01) >> 0); dst += bytesPerPixel;
+                                       }
+                                       break;
+                               case FT_PIXEL_MODE_GRAY2:
+                                       dst += bytesPerPixel - 1; // shift to alpha byte
+                                       for (x = 0; x < bmp->width; x += 4)
+                                       {
+                                               unsigned char c = *src++;
+                                               *dst = ( ((c & 0xA0) >> 6) * 0x55 ); c <<= 2; dst += bytesPerPixel;
+                                               *dst = ( ((c & 0xA0) >> 6) * 0x55 ); c <<= 2; dst += bytesPerPixel;
+                                               *dst = ( ((c & 0xA0) >> 6) * 0x55 ); c <<= 2; dst += bytesPerPixel;
+                                               *dst = ( ((c & 0xA0) >> 6) * 0x55 ); c <<= 2; dst += bytesPerPixel;
+                                       }
+                                       break;
+                               case FT_PIXEL_MODE_GRAY4:
+                                       dst += bytesPerPixel - 1; // shift to alpha byte
+                                       for (x = 0; x < bmp->width; x += 2)
+                                       {
+                                               unsigned char c = *src++;
+                                               *dst = ( ((c & 0xF0) >> 4) * 0x11); dst += bytesPerPixel;
+                                               *dst = ( ((c & 0x0F) ) * 0x11); dst += bytesPerPixel;
+                                       }
+                                       break;
+                               case FT_PIXEL_MODE_GRAY:
+                                       // in this case pitch should equal width
+                                       for (tp = 0; tp < bmp->pitch; ++tp)
+                                               dst[(bytesPerPixel - 1) + tp*bytesPerPixel] = src[tp]; // copy the grey value into the alpha bytes
+
+                                       //memcpy((void*)dst, (void*)src, bmp->pitch);
+                                       //dst += bmp->pitch;
+                                       break;
+                               default:
+                                       break;
+                               }
+                       }
+
+                       pad_l = gpad_l;
+                       pad_r = gpad_r;
+                       pad_t = gpad_t;
+                       pad_b = gpad_b;
+                       Font_Postprocess(font, imagedata, pitch, bytesPerPixel, w, h, &pad_l, &pad_r, &pad_t, &pad_b);
+               }
+               else
+               {
+                       pad_l = gpad_l;
+                       pad_r = gpad_r;
+                       pad_t = gpad_t;
+                       pad_b = gpad_b;
+                       Font_Postprocess(font, NULL, pitch, bytesPerPixel, w, h, &pad_l, &pad_r, &pad_t, &pad_b);
                }
 
+
                // now fill map->glyphs[ch - map->start]
                mapglyph = &map->glyphs[mapch];
 
@@ -1033,68 +1573,78 @@ static qboolean Font_LoadMap(ft2_font_t *font, ft2_font_map_t *mapstart, Uchar _
                        // old way
                        // double advance = (double)glyph->metrics.horiAdvance * map->sfx;
 
-                       double bearingX = (glyph->metrics.horiBearingX >> 6) / map->size;
-                       double bearingY = (glyph->metrics.horiBearingY >> 6) / map->size;
-                       double advance = (glyph->advance.x >> 6) / map->size;
-                       double mWidth = (glyph->metrics.width >> 6) / map->size;
-                       double mHeight = (glyph->metrics.height >> 6) / map->size;
-
-                       mapglyph->vxmin = bearingX;
-                       mapglyph->vxmax = bearingX + mWidth;
-                       mapglyph->vymin = -bearingY;
-                       mapglyph->vymax = mHeight - bearingY;
-                       mapglyph->txmin = ( (double)(gC * map->glyphSize) ) / ( (double)(map->glyphSize * FONT_CHARS_PER_LINE) );
-                       mapglyph->txmax = mapglyph->txmin + (double)bmp->width / ( (double)(map->glyphSize * FONT_CHARS_PER_LINE) );
-                       mapglyph->tymin = ( (double)(gR * map->glyphSize) ) / ( (double)(map->glyphSize * FONT_CHAR_LINES) );
-                       mapglyph->tymax = mapglyph->tymin + (double)bmp->rows / ( (double)(map->glyphSize * FONT_CHAR_LINES) );
+                       double bearingX = (glyph->metrics.horiBearingX / 64.0) / map->size;
+                       //double bearingY = (glyph->metrics.horiBearingY >> 6) / map->size;
+                       double advance = (glyph->advance.x / 64.0) / map->size;
+                       //double mWidth = (glyph->metrics.width >> 6) / map->size;
+                       //double mHeight = (glyph->metrics.height >> 6) / map->size;
+
+                       mapglyph->txmin = ( (double)(gC * map->glyphSize) + (double)(gpad_l - pad_l) ) / ( (double)(map->glyphSize * FONT_CHARS_PER_LINE) );
+                       mapglyph->txmax = mapglyph->txmin + (double)(bmp->width + pad_l + pad_r) / ( (double)(map->glyphSize * FONT_CHARS_PER_LINE) );
+                       mapglyph->tymin = ( (double)(gR * map->glyphSize) + (double)(gpad_r - pad_r) ) / ( (double)(map->glyphSize * FONT_CHAR_LINES) );
+                       mapglyph->tymax = mapglyph->tymin + (double)(bmp->rows + pad_t + pad_b) / ( (double)(map->glyphSize * FONT_CHAR_LINES) );
+                       //mapglyph->vxmin = bearingX;
+                       //mapglyph->vxmax = bearingX + mWidth;
+                       mapglyph->vxmin = (glyph->bitmap_left - pad_l) / map->size;
+                       mapglyph->vxmax = mapglyph->vxmin + (bmp->width + pad_l + pad_r) / map->size; // don't ask
+                       //mapglyph->vymin = -bearingY;
+                       //mapglyph->vymax = mHeight - bearingY;
+                       mapglyph->vymin = (-glyph->bitmap_top - pad_t) / map->size;
+                       mapglyph->vymax = mapglyph->vymin + (bmp->rows + pad_t + pad_b) / map->size;
+                       //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);
                        //mapglyph->advance_x = advance * usefont->size;
-                       mapglyph->advance_x = advance;
+                       //mapglyph->advance_x = advance;
+                       mapglyph->advance_x = Font_SnapTo(advance, 1 / map->size);
                        mapglyph->advance_y = 0;
 
-                       if (developer.integer)
+                       if (developer_font.integer)
                        {
-                               Con_Printf("glyphinfo:   Glyph: %lu   at (%i, %i)\n", (unsigned long)ch, gC, gR);
-                               Con_Printf("glyphinfo:   %f, %f, %lu\n", bearingX, map->sfx, (unsigned long)glyph->metrics.horiBearingX);
+                               Con_DPrintf("glyphinfo:   Glyph: %lu   at (%i, %i)\n", (unsigned long)ch, gC, gR);
+                               Con_DPrintf("glyphinfo:   %f, %f, %lu\n", bearingX, map->sfx, (unsigned long)glyph->metrics.horiBearingX);
                                if (ch >= 32 && ch <= 128)
-                                       Con_Printf("glyphinfo:   Character: %c\n", (int)ch);
-                               Con_Printf("glyphinfo:   Vertex info:\n");
-                               Con_Printf("glyphinfo:     X: ( %f  --  %f )\n", mapglyph->vxmin, mapglyph->vxmax);
-                               Con_Printf("glyphinfo:     Y: ( %f  --  %f )\n", mapglyph->vymin, mapglyph->vymax);
-                               Con_Printf("glyphinfo:   Texture info:\n");
-                               Con_Printf("glyphinfo:     S: ( %f  --  %f )\n", mapglyph->txmin, mapglyph->txmax);
-                               Con_Printf("glyphinfo:     T: ( %f  --  %f )\n", mapglyph->tymin, mapglyph->tymax);
-                               Con_Printf("glyphinfo:   Advance: %f, %f\n", mapglyph->advance_x, mapglyph->advance_y);
+                                       Con_DPrintf("glyphinfo:   Character: %c\n", (int)ch);
+                               Con_DPrintf("glyphinfo:   Vertex info:\n");
+                               Con_DPrintf("glyphinfo:     X: ( %f  --  %f )\n", mapglyph->vxmin, mapglyph->vxmax);
+                               Con_DPrintf("glyphinfo:     Y: ( %f  --  %f )\n", mapglyph->vymin, mapglyph->vymax);
+                               Con_DPrintf("glyphinfo:   Texture info:\n");
+                               Con_DPrintf("glyphinfo:     S: ( %f  --  %f )\n", mapglyph->txmin, mapglyph->txmax);
+                               Con_DPrintf("glyphinfo:     T: ( %f  --  %f )\n", mapglyph->tymin, mapglyph->tymax);
+                               Con_DPrintf("glyphinfo:   Advance: %f, %f\n", mapglyph->advance_x, mapglyph->advance_y);
                        }
                }
                map->glyphs[mapch].image = false;
        }
 
-       // create a texture from the data now
-
-       if (developer.integer)
        {
-               // view using `display -depth 8 -size 512x512 name_page.rgba` (be sure to use a correct -size parameter)
-               dpsnprintf(map_identifier, sizeof(map_identifier), "%s_%u.rgba", font->name, (unsigned)map->start/FONT_CHARS_PER_MAP);
-               FS_WriteFile(map_identifier, data, pitch * FONT_CHAR_LINES * map->glyphSize);
-       }
-       dpsnprintf(map_identifier, sizeof(map_identifier), "%s_%u", font->name, (unsigned)map->start/FONT_CHARS_PER_MAP);
+               int w = map->glyphSize * FONT_CHARS_PER_LINE;
+               int h = map->glyphSize * FONT_CHAR_LINES;
+               // update the pic returned by Draw_CachePic_Flags earlier to contain our texture
+               map->pic = Draw_NewPic(map_identifier, w, h, data, r_font_use_alpha_textures.integer ? TEXTYPE_ALPHA : TEXTYPE_RGBA, TEXF_ALPHA | TEXF_CLAMP | (r_font_compress.integer > 0 ? TEXF_COMPRESS : 0));
 
-       // probably use bytesPerPixel here instead?
-       if (r_font_use_alpha_textures.integer)
-       {
-               map->texture = R_LoadTexture2D(font_texturepool, map_identifier,
-                                              map->glyphSize * FONT_CHARS_PER_LINE,
-                                              map->glyphSize * FONT_CHAR_LINES,
-                                              data, TEXTYPE_ALPHA, TEXF_ALPHA /*gone: | TEXF_ALWAYSPRECACHE*/ /* | TEXF_MIPMAP*/, NULL);
-       } else {
-               map->texture = R_LoadTexture2D(font_texturepool, map_identifier,
-                                              map->glyphSize * FONT_CHARS_PER_LINE,
-                                              map->glyphSize * FONT_CHAR_LINES,
-                                              data, TEXTYPE_RGBA, TEXF_ALPHA /*gone: | TEXF_ALWAYSPRECACHE*/ /* | TEXF_MIPMAP*/, NULL);
+               if (r_font_diskcache.integer >= 1)
+               {
+                       // swap to BGRA for tga writing...
+                       int s = w * h;
+                       int x;
+                       int b;
+                       for (x = 0;x < s;x++)
+                       {
+                               b = data[x*4+0];
+                               data[x*4+0] = data[x*4+2];
+                               data[x*4+2] = b;
+                       }
+                       Image_WriteTGABGRA(va(vabuf, sizeof(vabuf), "%s.tga", map_identifier), w, h, data);
+#ifndef USE_GLES2
+                       if (r_font_compress.integer && Draw_IsPicLoaded(map->pic))
+                               R_SaveTextureDDSFile(Draw_GetPicTexture(map->pic), va(vabuf, sizeof(vabuf), "dds/%s.dds", map_identifier), r_texture_dds_save.integer < 2, true);
+#endif
+               }
        }
 
-       Mem_Free(data);
-       if (!map->texture)
+       if(data)
+               Mem_Free(data);
+
+       if (!Draw_IsPicLoaded(map->pic))
        {
                // if the first try isn't successful, keep it with a broken texture
                // otherwise we retry to load it every single frame where ft2 rendering is used
@@ -1121,7 +1671,7 @@ qboolean Font_LoadMapForIndex(ft2_font_t *font, int map_index, Uchar _ch, ft2_fo
 
 ft2_font_map_t *FontMap_FindForChar(ft2_font_map_t *start, Uchar ch)
 {
-       while (start && start->start + FONT_CHARS_PER_MAP < ch)
+       while (start && start->start + FONT_CHARS_PER_MAP <= ch)
                start = start->next;
        if (start && start->start > ch)
                return NULL;