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 c706fb1..c8d7476 100644 (file)
--- a/ft2.c
+++ b/ft2.c
@@ -39,8 +39,11 @@ cvar_t r_font_size_snapping = {CVAR_SAVE, "r_font_size_snapping", "1", "stick to
 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
+
 /*
 ================================================================================
 Function definitions. Taken from the freetype2 headers.
@@ -135,6 +138,85 @@ 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;
 
@@ -244,7 +326,9 @@ void Font_CloseLibrary (void)
                qFT_Done_FreeType(font_ft2lib);
                font_ft2lib = NULL;
        }
+#ifndef DP_FREETYPE_STATIC
        Sys_UnloadLibrary (&ft2_dll);
+#endif
        pp.buf = NULL;
 }
 
@@ -257,6 +341,7 @@ Try to load the FreeType2 DLL
 */
 qboolean Font_OpenLibrary (void)
 {
+#ifndef DP_FREETYPE_STATIC
        const char* dllnames [] =
        {
 #if defined(WIN32)
@@ -271,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;
@@ -282,6 +369,7 @@ qboolean Font_OpenLibrary (void)
        // Load the DLL
        if (!Sys_LoadLibrary (dllnames, &ft2_dll, ft2funcs))
                return false;
+#endif
        return true;
 }
 
@@ -334,6 +422,7 @@ 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);
@@ -356,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 (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;
 
@@ -408,6 +501,7 @@ 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)
@@ -455,10 +549,10 @@ qboolean Font_LoadFont(const char *name, dp_font_t *dpfnt)
 
                if (!Font_LoadFile(dpfnt->fallbacks[i], dpfnt->fallback_faces[i], &dpfnt->settings, fb))
                {
-                       if(!FS_FileExists(va("%s.tga", dpfnt->fallbacks[i])))
-                       if(!FS_FileExists(va("%s.png", dpfnt->fallbacks[i])))
-                       if(!FS_FileExists(va("%s.jpg", dpfnt->fallbacks[i])))
-                       if(!FS_FileExists(va("%s.pcx", dpfnt->fallbacks[i])))
+                       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);
                        continue;
@@ -535,6 +629,11 @@ static qboolean Font_LoadFile(const char *name, int _face, ft2_settings_t *setti
        font->settings = settings;
 
        namelen = strlen(name);
+       if (namelen + 5 > sizeof(filename))
+       {
+               Con_Printf("WARNING: too long font name. Cannot load this.\n");
+               return false;
+       }
 
        // try load direct file
        memcpy(filename, name, namelen+1);
@@ -580,7 +679,7 @@ static qboolean Font_LoadFile(const char *name, int _face, ft2_settings_t *setti
        {
                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)
@@ -604,13 +703,13 @@ static qboolean Font_LoadFile(const char *name, int _face, ft2_settings_t *setti
                        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;
 }
 
-void Font_Postprocess_Update(ft2_font_t *fnt, int bpp, int w, int h)
+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];
@@ -664,14 +763,16 @@ void Font_Postprocess_Update(ft2_font_t *fnt, int bpp, int w, int h)
        }
 }
 
-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)
+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);
@@ -679,8 +780,6 @@ void Font_Postprocess(ft2_font_t *fnt, unsigned char *imagedata, int pitch, int
                *pad_t = min(*pad_t, pp.padding_t);
                *pad_b = min(*pad_b, pp.padding_b);
 
-               // calculate gauss table
-               
                // 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
                {
@@ -767,6 +866,15 @@ void Font_Postprocess(ft2_font_t *fnt, unsigned char *imagedata, int pitch, int
                                }
                }
        }
+       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
@@ -819,7 +927,9 @@ static qboolean Font_LoadSize(ft2_font_t *font, float size, qboolean check_only)
 
        memset(&temp, 0, sizeof(temp));
        temp.size = size;
-       temp.glyphSize = CeilPowerOf2(size*2 + max(gpad_l + gpad_r, gpad_t + gpad_b));
+       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 :)
@@ -1051,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)
                {
@@ -1096,6 +1210,7 @@ static qboolean Font_LoadMap(ft2_font_t *font, ft2_font_map_t *mapstart, Uchar _
        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
@@ -1204,17 +1319,18 @@ static qboolean Font_LoadMap(ft2_font_t *font, ft2_font_map_t *mapstart, Uchar _
        dpsnprintf(map_identifier, sizeof(map_identifier),
                "%s_cache_%g_%d_%g_%g_%g_%g_%g_%u",
                font->name,
-               mapstart->intSize,
-               load_flags,
-               font->settings->blur,
-               font->settings->outline,
-               font->settings->shadowx,
-               font->settings->shadowy,
-               font->settings->shadowz,
-               (unsigned)map->start/FONT_CHARS_PER_MAP);
+               (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
-       map->pic = Draw_CachePic_Flags(map_identifier, CACHEPICFLAG_QUIET);
+       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);
 
@@ -1226,27 +1342,24 @@ 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;
-//     if (map->pic->tex == r_texture_notexture)
+       data = (unsigned char *)Mem_Alloc(font_mempool, (FONT_CHAR_LINES * map->glyphSize) * pitch);
+       if (!data)
        {
-               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)
+               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)
+       {
+               if (bytesPerPixel == 4)
                {
-                       if (bytesPerPixel == 4)
-                       {
-                               data[tp++] = 0xFF;
-                               data[tp++] = 0xFF;
-                               data[tp++] = 0xFF;
-                       }
-                       data[tp++] = 0x00;
+                       data[tp++] = 0xFF;
+                       data[tp++] = 0xFF;
+                       data[tp++] = 0xFF;
                }
+               data[tp++] = 0x00;
        }
 
        memset(map->width_of, 0, sizeof(map->width_of));
@@ -1393,35 +1506,35 @@ static qboolean Font_LoadMap(ft2_font_t *font, ft2_font_map_t *mapstart, Uchar _
                                        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;
+                                               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 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;
+                                               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 ch = *src++;
-                                               *dst = ( ((ch & 0xF0) >> 4) * 0x11); dst += bytesPerPixel;
-                                               *dst = ( ((ch & 0x0F) ) * 0x11); dst += bytesPerPixel;
+                                               unsigned char c = *src++;
+                                               *dst = ( ((c & 0xF0) >> 4) * 0x11); dst += bytesPerPixel;
+                                               *dst = ( ((c & 0x0F) ) * 0x11); dst += bytesPerPixel;
                                        }
                                        break;
                                case FT_PIXEL_MODE_GRAY:
@@ -1443,6 +1556,15 @@ static qboolean Font_LoadMap(ft2_font_t *font, ft2_font_map_t *mapstart, Uchar _
                        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];
@@ -1493,16 +1615,11 @@ static qboolean Font_LoadMap(ft2_font_t *font, ft2_font_map_t *mapstart, Uchar _
                map->glyphs[mapch].image = false;
        }
 
-       if (map->pic->tex == r_texture_notexture)
        {
                int w = map->glyphSize * FONT_CHARS_PER_LINE;
                int h = map->glyphSize * FONT_CHAR_LINES;
-               rtexture_t *tex;
-               // abuse the Draw_CachePic system to keep track of this texture
-               tex = R_LoadTexture2D(drawtexturepool, map_identifier, w, h, data, r_font_use_alpha_textures.integer ? TEXTYPE_ALPHA : TEXTYPE_RGBA, TEXF_ALPHA | (r_font_compress.integer > 0 ? TEXF_COMPRESS : 0), -1, NULL);
-               // if tex is NULL for any reason, the pic->tex will remain set to r_texture_notexture
-               if (tex)
-                       map->pic->tex = tex;
+               // 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));
 
                if (r_font_diskcache.integer >= 1)
                {
@@ -1516,14 +1633,18 @@ static qboolean Font_LoadMap(ft2_font_t *font, ft2_font_map_t *mapstart, Uchar _
                                data[x*4+0] = data[x*4+2];
                                data[x*4+2] = b;
                        }
-                       Image_WriteTGABGRA(va("%s.tga", map_identifier), w, h, data);
-                       if (r_font_compress.integer && qglGetCompressedTexImageARB && tex)
-                               R_SaveTextureDDSFile(tex, va("dds/%s.dds", map_identifier), true, true);
+                       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->pic->tex == r_texture_notexture)
+       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