#include "utf8lib.h"

Include dependency graph for ft2.h:

This graph shows which files directly or indirectly include this file:

Data Structures
struct	ft2_font_t

struct	ft2_kerning_t

Macros
#define	ft2_oldstyle_map ((ft2_font_map_t*)-1)

Typedefs
typedef float	ft2_kernvec[2]

typedef struct incmap_lookup_cache_s	incmap_lookup_cache_t

Functions
ft2_font_t *	Font_Alloc (void)

void	Font_CloseLibrary (void)

qbool	Font_GetKerningForMap (ft2_font_t font, int map_index, float w, float h, Uchar left, Uchar right, float outx, float *outy)

qbool	Font_GetKerningForSize (ft2_font_t font, float w, float h, Uchar left, Uchar right, float outx, float *outy)

qbool	Font_GetMapForChar (ft2_font_t font, int map_index, Uchar ch, ft2_font_map_t outmap, int outmapch)
	Query for or load a font map for a character, with the character's place on it.

int	Font_IndexForSize (ft2_font_t font, float size, float outw, float *outh)

void	Font_Init (void)

qbool	Font_LoadFont (const char name, dp_font_t dpfnt)

ft2_font_map_t *	Font_MapForIndex (ft2_font_t *font, int index)

qbool	Font_OpenLibrary (void)

float	Font_SnapTo (float val, float snapwidth)

void	Font_UnloadFont (ft2_font_t *font)

float	Font_VirtualToRealSize (float sz)

ft2_font_map_t *	FontMap_FindForChar (ft2_font_map_t *start, Uchar ch)

Macro Definition Documentation

◆ ft2_oldstyle_map

#define ft2_oldstyle_map ((ft2_font_map_t*)-1)

Definition at line 30 of file ft2.h.

Referenced by DrawQ_String_Scale(), and DrawQ_TextWidth_UntilWidth_TrackColors_Scale().

Typedef Documentation

◆ ft2_kernvec

typedef float ft2_kernvec[2]

Definition at line 33 of file ft2.h.

◆ incmap_lookup_cache_t

typedef struct incmap_lookup_cache_s incmap_lookup_cache_t

Definition at line 25 of file ft2.h.

Function Documentation

◆ Font_Alloc()

ft2_font_t * Font_Alloc ( void )

Definition at line 467 of file ft2.c.

{
#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));
}

References font_mempool, ft2_dll, cvar_t::integer, Mem_Alloc, NULL, and r_font_disable_freetype.

Referenced by Font_LoadFont().

◆ Font_CloseLibrary()

void Font_CloseLibrary ( void )

Definition at line 339 of file ft2.c.

{
    fontfilecache_FreeAll();
    if (font_mempool)
        Mem_FreePool(&font_mempool);
    if (font_ft2lib && qFT_Done_FreeType)
    {
        qFT_Done_FreeType(font_ft2lib);
        font_ft2lib = NULL;
    }
#ifndef DP_FREETYPE_STATIC
    Sys_FreeLibrary (&ft2_dll);
#endif
    pp.buf = NULL;
}

References font_postprocess_t::buf, font_ft2lib, font_mempool, fontfilecache_FreeAll(), ft2_dll, Mem_FreePool, NULL, pp, qFT_Done_FreeType, and Sys_FreeLibrary().

Referenced by font_shutdown(), and font_start().

◆ Font_GetKerningForMap()

qbool Font_GetKerningForMap	(	ft2_font_t *	font,
		int	map_index,
		float	w,
		float	h,
		Uchar	left,
		Uchar	right,
		float *	outx,
		float *	outy )

Definition at line 1085 of file ft2.c.

{
    ft2_font_map_t *fmap;
    if (!font->has_kerning || !r_font_kerning.integer)
        return false;
    if (map_index < 0 || map_index >= MAX_FONT_SIZES)
        return false;
    fmap = font->font_maps[map_index];
    if (!fmap)
        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);
        return true;
    }
    else
    {
        FT_Vector kernvec;
        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
            Con_Printf("Failed to get kerning for %s\n", font->name);
            return false;
        }
        ul = qFT_Get_Char_Index(font->face, left);
        ur = qFT_Get_Char_Index(font->face, right);
        if (qFT_Get_Kerning(font->face, ul, ur, FT_KERNING_DEFAULT, &kernvec))
        {
            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(CON_ERROR "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;
    }
}

References CON_ERROR, Con_Printf(), ft2_font_t::face, ft2_font_t::font_maps, Font_SetSize(), Font_SnapTo(), FT_KERNING_DEFAULT, ft2_font_t::has_kerning, cvar_t::integer, MAX_FONT_SIZES, ft2_font_t::name, qFT_Get_Char_Index, qFT_Get_Kerning, r_font_kerning, right, w, FT_Vector::x, and FT_Vector::y.

Referenced by DrawQ_String_Scale(), DrawQ_TextWidth_UntilWidth_TrackColors_Scale(), and Font_GetKerningForSize().

◆ Font_GetKerningForSize()

qbool Font_GetKerningForSize	(	ft2_font_t *	font,
		float	w,
		float	h,
		Uchar	left,
		Uchar	right,
		float *	outx,
		float *	outy )

Definition at line 1143 of file ft2.c.

{
    return Font_GetKerningForMap(font, Font_IndexForSize(font, h, NULL, NULL), w, h, left, right, outx, outy);
}

References Font_GetKerningForMap(), Font_IndexForSize(), NULL, right, and w.

◆ Font_GetMapForChar()

qbool Font_GetMapForChar	(	ft2_font_t *	font,
		int	map_index,
		Uchar	ch,
		ft2_font_map_t **	outmap,
		int *	outmapch )

Query for or load a font map for a character, with the character's place on it.

Supports the incremental map mechanism; returning if the operation is done successfully

Definition at line 1971 of file ft2.c.

{
    qbool use_incmap;
    ft2_font_map_t *map;
 
    // startmap
    map = Font_MapForIndex(font, map_index);
 
    // optimize: the first map must have been loaded already
    if (ch < FONT_CHARS_PER_MAP)
    {
        *outmapch = ch;
        *outmap = map;
        return true;
    }
 
    // search for the character
 
    use_incmap = should_use_incmap(ch);
 
    if (!use_incmap)
    {
        // normal way
        *outmapch = ch % FONT_CHARS_PER_MAP;
        while (map && map->start + FONT_CHARS_PER_MAP <= ch)
            map = map->next;
        if (map && map->start <= ch)
        {
            *outmap = map;
            return true;
        }
    }
    else if (get_char_from_incmap(map, ch, outmap, outmapch))
        // got it
        return true;
 
    // so no appropriate map was found, load one
 
    if (map_index < 0 || map_index >= MAX_FONT_SIZES)
        return false;
    return Font_LoadMap(font, font->font_maps[map_index], ch, outmap, outmapch, use_incmap);
}

References FONT_CHARS_PER_MAP, Font_LoadMap(), Font_MapForIndex(), ft2_font_t::font_maps, get_char_from_incmap(), MAX_FONT_SIZES, and should_use_incmap().

Referenced by DrawQ_String_Scale(), and DrawQ_TextWidth_UntilWidth_TrackColors_Scale().

◆ Font_IndexForSize()

int Font_IndexForSize	(	ft2_font_t *	font,
		float	size,
		float *	outw,
		float *	outh )

Definition at line 999 of file ft2.c.

{
    int match = -1;
    float value = 1000000;
    float nval;
    int matchsize = -10000;
    int m;
    float fsize_x, fsize_y;
    ft2_font_map_t **maps = font->font_maps;
 
    fsize_x = fsize_y = _fsize * vid.mode.height / vid_conheight.value;
    if(outw && *outw)
        fsize_x = *outw * vid.mode.width / vid_conwidth.value;
    if(outh && *outh)
        fsize_y = *outh * vid.mode.height / vid_conheight.value;
 
    if (fsize_x < 0)
    {
        if(fsize_y < 0)
            fsize_x = fsize_y = 16;
        else
            fsize_x = fsize_y;
    }
    else
    {
        if(fsize_y < 0)
            fsize_y = fsize_x;
    }
 
    for (m = 0; m < MAX_FONT_SIZES; ++m)
    {
        if (!maps[m])
            continue;
        // "round up" to the bigger size if two equally-valued matches exist
        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;
            match = m;
            matchsize = maps[m]->size;
            if (value == 0) // there is no better match
                break;
        }
    }
    if (value <= r_font_size_snapping.value)
    {
        // do NOT keep the aspect for perfect rendering
        if (outh) *outh = maps[match]->size * vid_conheight.value / vid.mode.height;
        if (outw) *outw = maps[match]->size * vid_conwidth.value / vid.mode.width;
    }
    return match;
}

References fabs(), ft2_font_t::font_maps, viddef_mode_t::height, MAX_FONT_SIZES, viddef_t::mode, r_font_size_snapping, size, cvar_t::value, value, vid, vid_conheight, vid_conwidth, and viddef_mode_t::width.

Referenced by DrawQ_String_Scale(), DrawQ_TextWidth_UntilWidth_TrackColors_Scale(), and Font_GetKerningForSize().

◆ Font_Init()

void Font_Init ( void )

Definition at line 443 of file ft2.c.

{
    Cvar_RegisterVariable(&r_font_nonpoweroftwo);
    Cvar_RegisterVariable(&r_font_disable_freetype);
    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);
 
    Cvar_RegisterVariable(&r_font_disable_incmaps);
 
    // let's open it at startup already
    Font_OpenLibrary();
}

◆ Font_LoadFont()

qbool Font_LoadFont	(	const char *	name,
		dp_font_t *	dpfnt )

Definition at line 521 of file ft2.c.

{
    int s, count, i;
    ft2_font_t *ft2, *fbfont, *fb;
    char vabuf[1024];
 
    ft2 = Font_Alloc();
    if (!ft2)
    {
        dpfnt->ft2 = NULL;
        return false;
    }
 
    // check if a fallback font has been specified, if it has been, and the
    // font fails to load, use the image font as main font
    for (i = 0; i < MAX_FONT_FALLBACKS; ++i)
    {
        if (dpfnt->fallbacks[i][0])
            break;
    }
 
    if (!Font_LoadFile(name, dpfnt->req_face, &dpfnt->settings, ft2))
    {
        if (i >= MAX_FONT_FALLBACKS)
        {
            dpfnt->ft2 = NULL;
            Mem_Free(ft2);
            return false;
        }
        dp_strlcpy(ft2->name, name, sizeof(ft2->name));
        ft2->image_font = true;
        ft2->has_kerning = false;
    }
    else
    {
        ft2->image_font = false;
    }
 
    // attempt to load fallback fonts:
    fbfont = ft2;
    for (i = 0; i < MAX_FONT_FALLBACKS; ++i)
    {
        if (!dpfnt->fallbacks[i][0])
            break;
        if (! (fb = Font_Alloc()) )
        {
            Con_Printf(CON_ERROR "Failed to allocate font for fallback %i of font %s\n", i, name);
            break;
        }
 
        if (!Font_LoadFile(dpfnt->fallbacks[i], dpfnt->fallback_faces[i], &dpfnt->settings, fb))
        {
            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(CON_ERROR "Failed to load font %s for fallback %i of font %s\n", dpfnt->fallbacks[i], i, name);
            Mem_Free(fb);
            continue;
        }
        count = 0;
        for (s = 0; s < MAX_FONT_SIZES && dpfnt->req_sizes[s] >= 0; ++s)
        {
            if (Font_LoadSize(fb, Font_VirtualToRealSize(dpfnt->req_sizes[s]), true))
                ++count;
        }
        if (!count)
        {
            Con_Printf(CON_ERROR "Failed to allocate font for fallback %i of font %s\n", i, name);
            Font_UnloadFont(fb);
            Mem_Free(fb);
            break;
        }
        // at least one size of the fallback font loaded successfully
        // link it:
        fbfont->next = fb;
        fbfont = fb;
    }
 
    if (fbfont == ft2 && ft2->image_font)
    {
        // no fallbacks were loaded successfully:
        dpfnt->ft2 = NULL;
        Mem_Free(ft2);
        return false;
    }
 
    count = 0;
    for (s = 0; s < MAX_FONT_SIZES && dpfnt->req_sizes[s] >= 0; ++s)
    {
        if (Font_LoadSize(ft2, Font_VirtualToRealSize(dpfnt->req_sizes[s]), false))
            ++count;
    }
    if (!count)
    {
        // loading failed for every requested size
        Font_UnloadFont(ft2);
        Mem_Free(ft2);
        dpfnt->ft2 = NULL;
        return false;
    }
 
    //Con_Printf("%i sizes loaded\n", count);
    dpfnt->ft2 = ft2;
    return true;
}

References CON_ERROR, Con_Printf(), count, dp_strlcpy, dp_font_t::fallback_faces, dp_font_t::fallbacks, Font_Alloc(), Font_LoadFile(), Font_LoadSize(), Font_UnloadFont(), Font_VirtualToRealSize(), FS_FileExists(), dp_font_t::ft2, ft2_font_t::has_kerning, i, ft2_font_t::image_font, MAX_FONT_FALLBACKS, MAX_FONT_SIZES, Mem_Free, ft2_font_t::name, name, ft2_font_t::next, NULL, dp_font_t::req_face, dp_font_t::req_sizes, dp_font_t::settings, and va().

Referenced by LoadFont().

◆ Font_MapForIndex()

ft2_font_map_t * Font_MapForIndex	(	ft2_font_t *	font,
		int	index )

Definition at line 1052 of file ft2.c.

{
    if (index < 0 || index >= MAX_FONT_SIZES)
        return NULL;
    return font->font_maps[index];
}

References ft2_font_t::font_maps, index, MAX_FONT_SIZES, and NULL.

Referenced by DrawQ_String_Scale(), DrawQ_TextWidth_UntilWidth_TrackColors_Scale(), Font_GetMapForChar(), and LoadFont().

◆ Font_OpenLibrary()

qbool Font_OpenLibrary ( void )

Definition at line 362 of file ft2.c.

{
#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",
        "libfreetype.so",
#endif
        NULL
    };
#endif
 
    if (r_font_disable_freetype.integer)
        return false;
 
#ifndef DP_FREETYPE_STATIC
    // Already loaded?
    if (ft2_dll)
        return true;
 
    // Load the DLL
    if (!Sys_LoadDependency (dllnames, &ft2_dll, ft2funcs))
        return false;
#endif
    return true;
}

References ft2_dll, ft2funcs, cvar_t::integer, NULL, r_font_disable_freetype, and Sys_LoadDependency().

Referenced by Font_Init(), Font_LoadFile(), and font_start().

◆ Font_SnapTo()

float Font_SnapTo	(	float	val,
		float	snapwidth )

Definition at line 514 of file ft2.c.

{
    return floor(val / snapwidth + 0.5f) * snapwidth;
}

References floor().

Referenced by Font_GetKerningForMap(), Font_LoadMap(), Font_LoadSize(), and LoadFont().

◆ Font_UnloadFont()

void Font_UnloadFont ( ft2_font_t * font )

Definition at line 1184 of file ft2.c.

{
    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;
    }
    for (i = 0; i < MAX_FONT_SIZES; ++i)
    {
        if (font->font_maps[i])
        {
            UnloadMapChain(font->font_maps[i]);
            font->font_maps[i] = NULL;
        }
    }
#ifndef DP_FREETYPE_STATIC
    if (ft2_dll)
#else
    if (!r_font_disable_freetype.integer)
#endif
    {
        if (font->face)
        {
            qFT_Done_Face((FT_Face)font->face);
            font->face = NULL;
        }
    }
    if (font->data) {
        fontfilecache_Free(font->data);
        font->data = NULL;
    }
}

References ft2_font_t::attachmentcount, ft2_font_t::attachments, ft2_font_t::data, ft2_font_t::face, ft2_font_t::font_maps, Font_UnloadFont(), fontfilecache_Free(), ft2_dll, i, int(), cvar_t::integer, MAX_FONT_SIZES, Mem_Free, ft2_font_t::next, NULL, qFT_Done_Face, r_font_disable_freetype, and UnloadMapChain().

Referenced by Font_LoadFile(), Font_LoadFont(), Font_LoadSize(), font_shutdown(), Font_UnloadFont(), and LoadFont().

◆ Font_VirtualToRealSize()

float Font_VirtualToRealSize ( float sz )

Definition at line 496 of file ft2.c.

{
    int vh;
    //int vw;
    int si;
    float sn;
    if(sz < 0)
        return sz;
    //vw = ((vid.width > 0) ? vid.width : vid_width.value);
    vh = ((vid.mode.height > 0) ? vid.mode.height : vid_height.value);
    // now try to scale to our actual size:
    sn = sz * vh / vid_conheight.value;
    si = (int)sn;
    if ( sn - (float)si >= 0.5 )
        ++si;
    return si;
}

References viddef_mode_t::height, int(), viddef_t::mode, cvar_t::value, vid, vid_conheight, and vid_height.