ft2.c File Reference

#include "quakedef.h"
#include "ft2.h"
#include "ft2_defs.h"
#include "ft2_fontdefs.h"
#include "image.h"

Include dependency graph for ft2.c:

Go to the source code of this file.

Data Structures
struct	font_postprocess_t
struct	fontfilecache_t

Macros
#define	bytes_per_pixel   4
#define	bytes_per_pixel   4
#define	calc_data_arguments(w, h)
#define	fix_glyph_coords_tier1(glyph, order)
#define	fix_glyph_coords_tier2(glyph, order)
#define	M   FONT_CHARS_PER_LINE
#define	MAX_FONTFILES   8
#define	N   FONT_CHAR_LINES
#define	POSTPROCESS_MAXRADIUS   8

Functions
static void	alert_legacy_font_api (const char *name)
ft2_font_t *	Font_Alloc (void)
static qbool	Font_Attach (ft2_font_t *font, ft2_attachment_t *attachment)
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 _fsize, float *outw, float *outh)
void	Font_Init (void)
static qbool	Font_LoadFile (const char *name, int _face, ft2_settings_t *settings, ft2_font_t *font)
qbool	Font_LoadFont (const char *name, dp_font_t *dpfnt)
static qbool	Font_LoadMap (ft2_font_t *font, ft2_font_map_t *mapstart, Uchar _ch, ft2_font_map_t **outmap, int *outmapch, qbool incmap_ok)
qbool	Font_LoadMapForIndex (ft2_font_t *font, int map_index, Uchar ch, ft2_font_map_t **outmap)
static qbool	Font_LoadSize (ft2_font_t *font, float size, qbool check_only)
ft2_font_map_t *	Font_MapForIndex (ft2_font_t *font, int index)
void	font_newmap (void)
qbool	Font_OpenLibrary (void)
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)
static void	Font_Postprocess_Update (ft2_font_t *fnt, int bpp, int w, int h)
static float	Font_SearchSize (ft2_font_t *font, FT_Face fontface, float size)
static qbool	Font_SetSize (ft2_font_t *font, float w, float h)
void	font_shutdown (void)
float	Font_SnapTo (float val, float snapwidth)
void	font_start (void)
void	Font_UnloadFont (ft2_font_t *font)
float	Font_VirtualToRealSize (float sz)
static void	fontfilecache_Free (const unsigned char *buf)
static void	fontfilecache_FreeAll (void)
static const unsigned char *	fontfilecache_LoadFile (const char *path, qbool quiet, fs_offset_t *filesizepointer)
ft2_font_map_t *	FontMap_FindForChar (ft2_font_map_t *start, Uchar ch)
static qbool	get_char_from_incmap (ft2_font_map_t *map, Uchar ch, ft2_font_map_t **outmap, int *outmapch)
static void	incmap_post_process (font_incmap_t *incmap, Uchar ch, unsigned char *data, ft2_font_map_t **outmap, int *outmapch)
static void	merge_single_map (ft2_font_map_t *targetmap, int targetindex, ft2_font_map_t *sourcemap, int sourceindex)
static qbool	should_use_incmap (Uchar ch)
static void	transform_glyph_coords (glyph_slot_t *glyph, float shiftx, float shifty, float scalex, float scaley)
static void	UnloadMapChain (ft2_font_map_t *map)
static void	update_pic_for_fontmap (ft2_font_map_t *fontmap, const char *identifier, int width, int height, unsigned char *data)

Variables
cvar_t	developer_font = {CF_CLIENT | CF_ARCHIVE, "developer_font", "0", "prints debug messages about fonts"}
static FT_Library	font_ft2lib = NULL
	FreeType library handle.
static mempool_t *	font_mempool = NULL
	Memory pool for fonts.
static fontfilecache_t	fontfiles [MAX_FONTFILES]
static dllhandle_t	ft2_dll = NULL
	Handle for FreeType2 DLL.
static dllfunction_t	ft2funcs []
static int	img_fontmap [256]
static qbool	legacy_font_loading_api_alerted = false
static font_postprocess_t	pp
(*	qFT_Attach_Stream )(FT_Face face, FT_Open_Args *parameters)
(*	qFT_Done_Face )(FT_Face face)
(*	qFT_Done_FreeType )(FT_Library library)
(*	qFT_Get_Char_Index )(FT_Face face, FT_ULong charcode)
(*	qFT_Get_Kerning )(FT_Face face, FT_UInt left_glyph, FT_UInt right_glyph, FT_UInt kern_mode, FT_Vector *akerning)
(*	qFT_Init_FreeType )(FT_Library *alibrary)
(*	qFT_Load_Char )(FT_Face face, FT_ULong char_code, FT_Int32 load_flags)
(*	qFT_Load_Glyph )(FT_Face face, FT_UInt glyph_index, FT_Int32 load_flags)
(*	qFT_New_Memory_Face )(FT_Library library, const FT_Byte *file_base, FT_Long file_size, FT_Long face_index, FT_Face *aface)
(*	qFT_Render_Glyph )(FT_GlyphSlot slot, FT_Render_Mode render_mode)
(*	qFT_Request_Size )(FT_Face face, FT_Size_Request req)
(*	qFT_Select_Size )(FT_Face face, FT_Int strike_index)
(*	qFT_Set_Char_Size )(FT_Face face, FT_F26Dot6 char_width, FT_F26Dot6 char_height, FT_UInt horz_resolution, FT_UInt vert_resolution)
(*	qFT_Set_Pixel_Sizes )(FT_Face face, FT_UInt pixel_width, FT_UInt pixel_height)
cvar_t	r_font_compress = {CF_CLIENT | CF_ARCHIVE, "r_font_compress", "0", "use texture compression on font textures to save video memory"}
cvar_t	r_font_disable_freetype = {CF_CLIENT | CF_ARCHIVE, "r_font_disable_freetype", "0", "disable freetype support for fonts entirely"}
cvar_t	r_font_disable_incmaps = {CF_CLIENT | CF_ARCHIVE, "r_font_disable_incmaps", "0", "always to load a full glyph map for individual unmapped character, even when it will mean extreme resources waste"}
cvar_t	r_font_diskcache = {CF_CLIENT | CF_ARCHIVE, "r_font_diskcache", "0", "[deprecated, not effective] save font textures to disk for future loading rather than generating them every time"}
cvar_t	r_font_kerning = {CF_CLIENT | CF_ARCHIVE, "r_font_kerning", "1", "Use kerning if available"}
cvar_t	r_font_nonpoweroftwo = {CF_CLIENT | CF_ARCHIVE, "r_font_nonpoweroftwo", "1", "use nonpoweroftwo textures for font (saves memory, potentially slower)"}
cvar_t	r_font_size_snapping = {CF_CLIENT | CF_ARCHIVE, "r_font_size_snapping", "1", "stick to good looking font sizes whenever possible - bad when the mod doesn't support it!"}
static const Uchar	unicode_bigblocks []

Macro Definition Documentation

bytes_per_pixel [1/2]

#define bytes_per_pixel   4

Referenced by Font_LoadMap().

bytes_per_pixel [2/2]

#define bytes_per_pixel   4

calc_data_arguments

#define calc_data_arguments	(		w,
			h )

Value:

        width = startmap->glyphSize * w;    \
        height = startmap->glyphSize * h;   \
        pitch = width * bytes_per_pixel;    \
        datasize = height * pitch;

Definition at line 1276 of file ft2.c.

#define calc_data_arguments(w, h)           \
        width = startmap->glyphSize * w;    \
        height = startmap->glyphSize * h;   \
        pitch = width * bytes_per_pixel;    \
        datasize = height * pitch;

Referenced by incmap_post_process().

fix_glyph_coords_tier1

#define fix_glyph_coords_tier1	(		glyph,
			order )

Value:

transform_glyph_coords(glyph, order / (float)FONT_CHARS_PER_LINE, 0.0f, 1.0f / (float)FONT_CHARS_PER_LINE, 1.0f)

Definition at line 1266 of file ft2.c.

Referenced by incmap_post_process().

fix_glyph_coords_tier2

#define fix_glyph_coords_tier2	(		glyph,
			order )

Value:

transform_glyph_coords(glyph, 0.0f, order / (float)FONT_CHARS_PER_LINE, 1.0f, 1.0f / (float)FONT_CHARS_PER_LINE)

Definition at line 1267 of file ft2.c.

Referenced by incmap_post_process().

M

#define M   FONT_CHARS_PER_LINE

Referenced by copy64(), incmap_post_process(), mdfour64(), mdfour_tail(), and mdfour_update().

MAX_FONTFILES

#define MAX_FONTFILES   8

Definition at line 267 of file ft2.c.

Referenced by fontfilecache_Free(), fontfilecache_FreeAll(), and fontfilecache_LoadFile().

N

#define N   FONT_CHAR_LINES

Referenced by incmap_post_process().

POSTPROCESS_MAXRADIUS

#define POSTPROCESS_MAXRADIUS   8

Definition at line 246 of file ft2.c.

Referenced by Font_Postprocess(), and Font_Postprocess_Update().

Function Documentation

alert_legacy_font_api()

static void alert_legacy_font_api ( const char * name )

inlinestatic

Definition at line 1889 of file ft2.c.

{
    if (!legacy_font_loading_api_alerted)
    {
        Con_DPrintf(CON_WARN "Warning: You are using an legacy API '%s', which have certain limitations; please use 'Font_GetMapForChar' instead\n", name);
        legacy_font_loading_api_alerted = true;
    }
}

References Con_DPrintf(), CON_WARN, legacy_font_loading_api_alerted, and name.

Referenced by Font_LoadMapForIndex(), and FontMap_FindForChar().

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_Attach()

static qbool Font_Attach ( ft2_font_t * font, ft2_attachment_t * attachment )

static

Definition at line 478 of file ft2.c.

{
    ft2_attachment_t *na;
 
    font->attachmentcount++;
    na = (ft2_attachment_t*)Mem_Alloc(font_mempool, sizeof(font->attachments[0]) * font->attachmentcount);
    if (na == NULL)
        return false;
    if (font->attachments && font->attachmentcount > 1)
    {
        memcpy(na, font->attachments, sizeof(font->attachments[0]) * (font->attachmentcount - 1));
        Mem_Free(font->attachments);
    }
    memcpy(na + sizeof(font->attachments[0]) * (font->attachmentcount - 1), attachment, sizeof(*attachment));
    font->attachments = na;
    return true;
}

References attachment, ft2_font_t::attachmentcount, ft2_font_t::attachments, font_mempool, Mem_Alloc, Mem_Free, and NULL.

Referenced by Font_LoadFile().

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	_fsize,
		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();
}

References Cvar_RegisterVariable(), developer_font, Font_OpenLibrary(), r_font_compress, r_font_disable_freetype, r_font_disable_incmaps, r_font_diskcache, r_font_kerning, r_font_nonpoweroftwo, and r_font_size_snapping.

Referenced by Render_Init().

Font_LoadFile()

static qbool Font_LoadFile ( const char * name, int _face, ft2_settings_t * settings, ft2_font_t * font )

static

Definition at line 628 of file ft2.c.

{
    size_t namelen;
    char filename[MAX_QPATH];
    int status;
    size_t i;
    const unsigned char *data;
    fs_offset_t datasize;
 
    memset(font, 0, sizeof(*font));
 
    if (!Font_OpenLibrary())
    {
        if (!r_font_disable_freetype.integer)
        {
            Con_Printf(CON_WARN "WARNING: can't open load font %s\n"
                   "You need the FreeType2 DLL to load font files\n",
                   name);
        }
        return false;
    }
 
    font->settings = settings;
 
    namelen = strlen(name);
    if (namelen + 5 > sizeof(filename))
    {
        Con_Printf(CON_WARN "WARNING: too long font name. Cannot load this.\n");
        return false;
    }
 
    // 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 = fontfilecache_LoadFile(filename, false, &datasize);
    }
    // try load .pfb/afm
    if (!data)
    {
        ft2_attachment_t afm;
 
        memcpy(filename + namelen, ".pfb", 5);
        data = fontfilecache_LoadFile(filename, false, &datasize);
 
        if (data)
        {
            memcpy(filename + namelen, ".afm", 5);
            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_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(CON_ERROR "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, _face, (FT_Face*)&font->face);
    }
    font->data = data;
    if (status)
    {
        Con_Printf(CON_ERROR "ERROR: can't create face for %s\n"
               "Error %i\n", // TODO: error strings
               name, status);
        Font_UnloadFont(font);
        return false;
    }
 
    // add the attachments
    for (i = 0; i < font->attachmentcount; ++i)
    {
        FT_Open_Args args;
        memset(&args, 0, sizeof(args));
        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((FT_Face)font->face, &args))
            Con_Printf(CON_ERROR "Failed to add attachment %u to %s\n", (unsigned)i, font->name);
    }
 
    dp_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;
}

References ft2_font_t::attachmentcount, ft2_font_t::attachments, Con_DPrintf(), CON_ERROR, Con_Printf(), CON_WARN, data, ft2_font_t::data, dp_strlcpy, ft2_font_t::face, FT_Open_Args::flags, Font_Attach(), font_ft2lib, Font_OpenLibrary(), Font_UnloadFont(), fontfilecache_LoadFile(), FT_FACE_FLAG_KERNING, FT_OPEN_MEMORY, ft2_font_t::has_kerning, i, ft2_font_t::image_font, cvar_t::integer, MAX_QPATH, FT_Open_Args::memory_base, FT_Open_Args::memory_size, ft2_font_t::name, name, qFT_Attach_Stream, qFT_New_Memory_Face, r_font_disable_freetype, ft2_font_t::settings, and strlen().

Referenced by Font_LoadFont().

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_LoadMap()

static qbool Font_LoadMap ( ft2_font_t * font, ft2_font_map_t * mapstart, Uchar _ch, ft2_font_map_t ** outmap, int * outmapch, qbool incmap_ok )

static

Definition at line 1385 of file ft2.c.

{
    #define bytes_per_pixel 4
 
    char map_identifier[MAX_QPATH];
    unsigned long map_startglyph = _ch / FONT_CHARS_PER_MAP * FONT_CHARS_PER_MAP;
    unsigned char *data = NULL;
    FT_ULong ch = 0, mapch = 0;
    int status;
    int tp;
    FT_Int32 load_flags;
    int gpad_l, gpad_r, gpad_t, gpad_b;
 
    int pitch;
    int width, height, datasize;
    int glyph_row, glyph_column;
 
    int chars_per_line = FONT_CHARS_PER_LINE;
    int char_lines = FONT_CHAR_LINES;
    int chars_per_map = FONT_CHARS_PER_MAP;
 
    ft2_font_t *usefont;
    ft2_font_map_t *map, *next;
    font_incmap_t *incmap;
 
    FT_Face fontface;
 
    incmap = mapstart->incmap;
    if (use_incmap)
    {
        // only render one character in this map;
        // such small maps will be merged together later in `incmap_post_process`
        chars_per_line = char_lines = chars_per_map = 1;
        // and the index is incremental
        map_startglyph = incmap ? incmap->newmap_start : INCMAP_START;
    }
 
    if (font->image_font)
        fontface = (FT_Face)font->next->face;
    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)
        {
            if (!Font_SetSize(font, mapstart->intSize, mapstart->intSize))
            {
                Con_Printf("ERROR: can't set size for font %s: %f ((%f))\n", font->name, mapstart->size, mapstart->intSize);
                return false;
            }
            if ((fontface->size->metrics.height>>6) <= mapstart->size)
                break;
            if (mapstart->intSize < 2)
            {
                Con_Printf("ERROR: no appropriate size found for font %s: %f\n", font->name, mapstart->size);
                return false;
            }
            --mapstart->intSize;
        }
        */
        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))
    {
        Con_Printf(CON_ERROR "ERROR: can't set sizes for font %s: %f\n", font->name, mapstart->size);
        return false;
    }
 
    map = (ft2_font_map_t *)Mem_Alloc(font_mempool, sizeof(ft2_font_map_t));
    if (!map)
    {
        Con_Printf(CON_ERROR "ERROR: Out of memory when allocating fontmap for %s\n", font->name);
        return false;
    }
 
    map->start = map_startglyph;
 
    // create a 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_%lx",
        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) map_startglyph,
        // add pointer as a unique part to avoid earlier incmaps' state being trashed
        use_incmap ? (unsigned long)mapstart : 0x0);
    */
    /*
     * note 1: it appears that different font instances may have the same metrics, causing this pic being overwritten
     *         will use startmap's pointer as a unique part to avoid earlier incmaps' dynamic pics being trashed
     * note 2: if this identifier is made too long, significient performance drop will take place
     * note 3: blur/outline/shadow are per-font settings, so a pointer to startmap & map size
     *         already made these unique, hence they are omitted
     * note 4: font_diskcache is removed, this name can be less meaningful
     */
    dpsnprintf(map_identifier, sizeof(map_identifier), "%s_%g_%p_%u",
            font->name, mapstart->intSize, mapstart, (unsigned) map_startglyph);
 
    // 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, bytes_per_pixel, 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;
    map->glyphSize = mapstart->glyphSize;
    map->sfx = mapstart->sfx;
    map->sfy = mapstart->sfy;
 
    width = map->glyphSize * chars_per_line;
    height = map->glyphSize * char_lines;
    pitch = width * bytes_per_pixel;
    datasize = height * pitch;
    data = (unsigned char *)Mem_Alloc(font_mempool, datasize);
    if (!data)
    {
        Con_Printf(CON_ERROR "ERROR: Failed to allocate memory for font %s size %g\n", font->name, map->size);
        Mem_Free(map);
        return false;
    }
 
    if (use_incmap)
    {
        if (mapstart->incmap == NULL)
        {
            // initial incmap
            incmap = mapstart->incmap = (font_incmap_t *)Mem_Alloc(font_mempool, sizeof(font_incmap_t));
            if (!incmap)
            {
                Con_Printf(CON_ERROR "ERROR: Out of memory when allocating incremental fontmap for %s\n", font->name);
                return false;
            }
            // this will be the startmap of incmap
            incmap->fontmap = map;
            incmap->newmap_start = INCMAP_START;
        }
        else
        {
            // new maps for incmap shall always be the last one
            next = incmap->fontmap;
            while (next->next != NULL)
                next = next->next;
            next->next = map;
        }
    }
    else
    {
        // insert this normal map
        next = use_incmap ? incmap->fontmap : mapstart;
        while(next->next && next->next->start < map->start)
            next = next->next;
        map->next = next->next;
        next->next = map;
    }
 
    // initialize as white texture with zero alpha
    tp = 0;
    while (tp < datasize)
    {
        if (bytes_per_pixel == 4)
        {
            data[tp++] = 0xFF;
            data[tp++] = 0xFF;
            data[tp++] = 0xFF;
        }
        data[tp++] = 0x00;
    }
 
    glyph_row = 0;
    glyph_column = 0;
    ch = (FT_ULong)(use_incmap ? _ch : map->start);
    mapch = 0;
    while (true)
    {
        FT_ULong glyphIndex;
        int w, h, x, y;
        FT_GlyphSlot glyph;
        FT_Bitmap *bmp;
        unsigned char *imagedata = NULL, *dst, *src;
        glyph_slot_t *mapglyph;
        FT_Face face;
        int pad_l, pad_r, pad_t, pad_b;
 
        if (developer_font.integer)
            Con_DPrint("glyphinfo: ------------- GLYPH INFO -----------------\n");
 
        map->glyphchars[mapch] = (Uchar)ch;
 
        if (data)
        {
            imagedata = data + glyph_row * pitch * map->glyphSize + glyph_column * map->glyphSize * bytes_per_pixel;
            imagedata += gpad_t * pitch + gpad_l * bytes_per_pixel;
        }
        //status = qFT_Load_Char(face, ch, FT_LOAD_RENDER);
        // we need the glyphIndex
        face = (FT_Face)font->face;
        usefont = NULL;
        if (font->image_font && mapch == ch && img_fontmap[mapch])
        {
            map->glyphs[mapch].image = true;
            continue;
        }
        glyphIndex = qFT_Get_Char_Index(face, ch);
        if (glyphIndex == 0)
        {
            // by convention, 0 is the "missing-glyph"-glyph
            // try to load from a fallback font
            for(usefont = font->next; usefont != NULL; usefont = usefont->next)
            {
                if (!Font_SetSize(usefont, mapstart->intSize, mapstart->intSize))
                    continue;
                // try that glyph
                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 | load_flags);
                if (status)
                    continue;
                break;
            }
            if (!usefont)
            {
                //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 = (FT_Face)font->face;
                glyphIndex = 0;
            }
        }
 
        if (!usefont)
        {
            usefont = font;
            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);
                Con_DPrintf("failed to load glyph for char %lx from font %s\n", (unsigned long)ch, font->name);
                continue;
            }
        }
 
        glyph = face->glyph;
        bmp = &glyph->bitmap;
 
        w = bmp->width;
        h = bmp->rows;
 
        if (w > (map->glyphSize - gpad_l - gpad_r) || h > (map->glyphSize - gpad_t - gpad_b)) {
            Con_Printf(CON_WARN "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 - gpad_l - gpad_r;
            if (h > map->glyphSize)
                h = map->glyphSize;
        }
 
        if (imagedata)
        {
            switch (bmp->pixel_mode)
            {
            case FT_PIXEL_MODE_MONO:
                if (developer_font.integer)
                    Con_DPrint("glyphinfo:   Pixel Mode: MONO\n");
                break;
            case FT_PIXEL_MODE_GRAY2:
                if (developer_font.integer)
                    Con_DPrint("glyphinfo:   Pixel Mode: GRAY2\n");
                break;
            case FT_PIXEL_MODE_GRAY4:
                if (developer_font.integer)
                    Con_DPrint("glyphinfo:   Pixel Mode: GRAY4\n");
                break;
            case FT_PIXEL_MODE_GRAY:
                if (developer_font.integer)
                    Con_DPrint("glyphinfo:   Pixel Mode: GRAY\n");
                break;
            default:
                if (developer_font.integer)
                    Con_DPrintf("glyphinfo:   Pixel Mode: Unknown: %i\n", bmp->pixel_mode);
                Mem_Free(data);
                Con_Printf(CON_ERROR "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 += bytes_per_pixel - 1; // shift to alpha byte
                    for (x = 0; x < bmp->width; x += 8)
                    {
                        unsigned char c = *src++;
                        *dst = 255 * !!((c & 0x80) >> 7); dst += bytes_per_pixel;
                        *dst = 255 * !!((c & 0x40) >> 6); dst += bytes_per_pixel;
                        *dst = 255 * !!((c & 0x20) >> 5); dst += bytes_per_pixel;
                        *dst = 255 * !!((c & 0x10) >> 4); dst += bytes_per_pixel;
                        *dst = 255 * !!((c & 0x08) >> 3); dst += bytes_per_pixel;
                        *dst = 255 * !!((c & 0x04) >> 2); dst += bytes_per_pixel;
                        *dst = 255 * !!((c & 0x02) >> 1); dst += bytes_per_pixel;
                        *dst = 255 * !!((c & 0x01) >> 0); dst += bytes_per_pixel;
                    }
                    break;
                case FT_PIXEL_MODE_GRAY2:
                    dst += bytes_per_pixel - 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 += bytes_per_pixel;
                        *dst = ( ((c & 0xA0) >> 6) * 0x55 ); c <<= 2; dst += bytes_per_pixel;
                        *dst = ( ((c & 0xA0) >> 6) * 0x55 ); c <<= 2; dst += bytes_per_pixel;
                        *dst = ( ((c & 0xA0) >> 6) * 0x55 ); c <<= 2; dst += bytes_per_pixel;
                    }
                    break;
                case FT_PIXEL_MODE_GRAY4:
                    dst += bytes_per_pixel - 1; // shift to alpha byte
                    for (x = 0; x < bmp->width; x += 2)
                    {
                        unsigned char c = *src++;
                        *dst = ( ((c & 0xF0) >> 4) * 0x11); dst += bytes_per_pixel;
                        *dst = ( ((c & 0x0F) ) * 0x11); dst += bytes_per_pixel;
                    }
                    break;
                case FT_PIXEL_MODE_GRAY:
                    // in this case pitch should equal width
                    for (tp = 0; tp < bmp->pitch; ++tp)
                        dst[(bytes_per_pixel - 1) + tp*bytes_per_pixel] = 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, bytes_per_pixel, 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, bytes_per_pixel, w, h, &pad_l, &pad_r, &pad_t, &pad_b);
        }
 
 
        // now fill map->glyphs[ch - map->start]
        mapglyph = &map->glyphs[mapch];
 
        {
            // old way
            // double advance = (double)glyph->metrics.horiAdvance * map->sfx;
 
            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)(glyph_column * map->glyphSize) + (double)(gpad_l - pad_l) ) / ( (double)(map->glyphSize * chars_per_line) );
            mapglyph->txmax = mapglyph->txmin + (double)(bmp->width + pad_l + pad_r) / ( (double)(map->glyphSize * chars_per_line) );
            mapglyph->tymin = ( (double)(glyph_row * map->glyphSize) + (double)(gpad_r - pad_r) ) / ( (double)(map->glyphSize * char_lines) );
            mapglyph->tymax = mapglyph->tymin + (double)(bmp->rows + pad_t + pad_b) / ( (double)(map->glyphSize * 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 = Font_SnapTo(advance, 1 / map->size);
            mapglyph->advance_y = 0;
 
            if (developer_font.integer)
            {
                Con_DPrintf("glyphinfo:   Glyph: %lu   at (%i, %i)\n", (unsigned long)ch, glyph_column, glyph_row);
                Con_DPrintf("glyphinfo:   %f, %f, %lu\n", bearingX, map->sfx, (unsigned long)glyph->metrics.horiBearingX);
                if (ch >= 32 && ch <= 128)
                    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;
 
        ++mapch; ++ch;
        if ((int)mapch == chars_per_map)
            break;
        if (++glyph_column % chars_per_line == 0)
        {
            glyph_column = 0;
            ++glyph_row;
        }
    }
 
    // update the pic returned by Draw_CachePic_Flags earlier to contain our texture
    update_pic_for_fontmap(map, map_identifier, width, height, 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
        // this would be bad...
        // only `data' must be freed
        Con_Printf(CON_ERROR "ERROR: Failed to generate texture for font %s size %f map %lu\n",
               font->name, mapstart->size, map_startglyph);
        return false;
    }
 
    if (use_incmap)
    {
        *outmap = map;
        *outmapch = 0;
        // data will be kept in incmap for being merged later, freed afterward
        incmap_post_process(incmap, _ch, data, outmap, outmapch);
    }
    else if (data)
    {
        Mem_Free(data);
        *outmap = map;
        if (outmapch != NULL)
            *outmapch = _ch - map->start;
    }
 
    return true;
}

References glyph_slot_t::advance_x, glyph_slot_t::advance_y, ft2_settings_t::antialias, FT_Bitmap::buffer, bytes_per_pixel, Con_DPrint(), Con_DPrintf(), CON_ERROR, Con_Printf(), CON_WARN, data, developer_font, dpsnprintf(), Draw_IsPicLoaded(), ft2_font_t::face, FONT_CHAR_LINES, FONT_CHARS_PER_LINE, FONT_CHARS_PER_MAP, font_mempool, Font_Postprocess(), Font_SearchSize(), Font_SetSize(), Font_SnapTo(), FT_LOAD_FORCE_AUTOHINT, FT_LOAD_MONOCHROME, FT_LOAD_NO_AUTOHINT, FT_LOAD_NO_HINTING, FT_LOAD_RENDER, FT_LOAD_TARGET_LIGHT, FT_LOAD_TARGET_MONO, FT_LOAD_TARGET_NORMAL, FT_PIXEL_MODE_GRAY, FT_PIXEL_MODE_GRAY2, FT_PIXEL_MODE_GRAY4, FT_PIXEL_MODE_MONO, height, ft2_settings_t::hinting, glyph_slot_t::image, ft2_font_t::image_font, img_fontmap, incmap_post_process(), INCMAP_START, cvar_t::integer, MAX_QPATH, Mem_Alloc, Mem_Free, ft2_font_t::name, ft2_font_t::next, NULL, FT_Bitmap::pitch, FT_Bitmap::pixel_mode, qFT_Get_Char_Index, qFT_Load_Glyph, FT_Bitmap::rows, ft2_font_t::settings, src, glyph_slot_t::txmax, glyph_slot_t::txmin, glyph_slot_t::tymax, glyph_slot_t::tymin, update_pic_for_fontmap(), glyph_slot_t::vxmax, glyph_slot_t::vxmin, glyph_slot_t::vymax, glyph_slot_t::vymin, w, FT_Bitmap::width, width, x, and y.

Referenced by Font_GetMapForChar(), Font_LoadMapForIndex(), and Font_LoadSize().

Font_LoadMapForIndex()

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

Definition at line 1899 of file ft2.c.

{
    if (map_index < 0 || map_index >= MAX_FONT_SIZES)
        return false;
    // the first map must have been loaded already
    if (!font->font_maps[map_index])
        return false;
    alert_legacy_font_api("Font_LoadMapForIndex");
    return Font_LoadMap(font, font->font_maps[map_index], ch, outmap, NULL, false);
}

References alert_legacy_font_api(), Font_LoadMap(), ft2_font_t::font_maps, MAX_FONT_SIZES, and NULL.

Font_LoadSize()

static qbool Font_LoadSize ( ft2_font_t * font, float size, qbool check_only )

static

Definition at line 911 of file ft2.c.

{
    int map_index;
    ft2_font_map_t *fmap, temp;
    int gpad_l, gpad_r, gpad_t, gpad_b;
 
    if (!(size > 0.001f && size < 1000.0f))
        size = 0;
 
    if (!size)
        size = 16;
    if (size < 2) // bogus sizes are not allowed - and they screw up our allocations
        return false;
 
    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 (map_index >= MAX_FONT_SIZES)
        return false;
 
    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);
    }
 
    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, NULL, false))
    {
        Con_Printf(CON_ERROR "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;
 
    fmap->sfx = temp.sfx;
    fmap->sfy = temp.sfy;
 
    // load the default kerning vector:
    if (font->has_kerning)
    {
        Uchar l, r;
        FT_Vector kernvec;
        fmap->kerning = (ft2_kerning_t *)Mem_Alloc(font_mempool, sizeof(ft2_kerning_t));
        for (l = 0; l < 256; ++l)
        {
            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))
                {
                    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;
}

References CeilPowerOf2(), CON_ERROR, Con_Printf(), ft2_font_t::face, Font_LoadMap(), ft2_font_t::font_maps, font_mempool, Font_Postprocess(), Font_SearchSize(), Font_SnapTo(), Font_UnloadFont(), FT_KERNING_DEFAULT, ft2_font_t::has_kerning, ft2_font_t::image_font, cvar_t::integer, max, MAX_FONT_SIZES, Mem_Alloc, ft2_font_t::name, ft2_font_t::next, NULL, qFT_Get_Char_Index, qFT_Get_Kerning, r, r_font_nonpoweroftwo, size, FT_Vector::x, and FT_Vector::y.

Referenced by Font_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_newmap()

void font_newmap

(

void

)

Definition at line 439 of file ft2.c.

{
}

Referenced by gl_draw_newmap().

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_Postprocess()

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 )

static

Definition at line 787 of file ft2.c.

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

References font_postprocess_t::blur, font_postprocess_t::blurpadding_lt, font_postprocess_t::blurpadding_rb, bound, font_postprocess_t::buf, font_postprocess_t::buf2, font_postprocess_t::bufheight, font_postprocess_t::bufpitch, font_postprocess_t::bufwidth, font_postprocess_t::circlematrix, Font_Postprocess_Update(), font_postprocess_t::gausstable, i, int(), max, min, font_postprocess_t::outline, font_postprocess_t::outlinepadding_b, font_postprocess_t::outlinepadding_l, font_postprocess_t::outlinepadding_r, font_postprocess_t::outlinepadding_t, font_postprocess_t::padding_b, font_postprocess_t::padding_l, font_postprocess_t::padding_r, font_postprocess_t::padding_t, POSTPROCESS_MAXRADIUS, pp, font_postprocess_t::shadowx, font_postprocess_t::shadowy, font_postprocess_t::shadowz, w, x, x1, x2, y, and y2.

Referenced by Font_LoadMap(), and Font_LoadSize().

Font_Postprocess_Update()

static void Font_Postprocess_Update ( ft2_font_t * fnt, int bpp, int w, int h )

static

Definition at line 733 of file ft2.c.

{
    int needed, x, y;
    float gausstable[2*POSTPROCESS_MAXRADIUS+1];
    qbool need_gauss  = (!pp.buf || pp.blur != fnt->settings->blur || pp.shadowz != fnt->settings->shadowz);
    qbool 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;
    }
}

References font_postprocess_t::blur, ft2_settings_t::blur, font_postprocess_t::blurpadding_lt, font_postprocess_t::blurpadding_rb, bound, font_postprocess_t::buf, font_postprocess_t::buf2, font_postprocess_t::bufheight, font_postprocess_t::bufpitch, font_postprocess_t::bufsize, font_postprocess_t::bufwidth, ceil(), font_postprocess_t::circlematrix, floor(), font_mempool, font_postprocess_t::gausstable, Mem_Alloc, Mem_Free, font_postprocess_t::outline, ft2_settings_t::outline, font_postprocess_t::outlinepadding_b, font_postprocess_t::outlinepadding_l, font_postprocess_t::outlinepadding_r, font_postprocess_t::outlinepadding_t, font_postprocess_t::padding_b, font_postprocess_t::padding_l, font_postprocess_t::padding_r, font_postprocess_t::padding_t, POSTPROCESS_MAXRADIUS, pow(), pp, ft2_font_t::settings, font_postprocess_t::shadowx, ft2_settings_t::shadowx, font_postprocess_t::shadowy, ft2_settings_t::shadowy, font_postprocess_t::shadowz, ft2_settings_t::shadowz, sqrt(), w, x, and y.

Referenced by Font_Postprocess().

Font_SearchSize()

static float Font_SearchSize ( ft2_font_t * font, FT_Face fontface, float size )

static

Definition at line 1228 of file ft2.c.

{
    float intSize = size;
    while (1)
    {
        if (!Font_SetSize(font, intSize, intSize))
        {
            Con_Printf(CON_ERROR "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(CON_ERROR "ERROR: no appropriate size found for font %s: %f\n", font->name, size);
            return -1;
        }
        --intSize;
    }
}

References CON_ERROR, Con_Printf(), Font_SetSize(), ft2_font_t::name, and size.

Referenced by Font_LoadMap(), and Font_LoadSize().

Font_SetSize()

static qbool Font_SetSize ( ft2_font_t * font, float w, float h )

static

Definition at line 1059 of file ft2.c.

{
    if (font->currenth == h &&
        ((!w && (!font->currentw || font->currentw == font->currenth)) || // check if w==h when w is not set
         font->currentw == w)) // same size has been requested
    {
        return true;
    }
    // sorry, but freetype doesn't seem to care about other sizes
    w = (int)w;
    h = (int)h;
    if (font->image_font)
    {
        if (qFT_Set_Char_Size((FT_Face)font->next->face, (FT_F26Dot6)(w*64), (FT_F26Dot6)(h*64), 72, 72))
            return false;
    }
    else
    {
        if (qFT_Set_Char_Size((FT_Face)font->face, (FT_F26Dot6)(w*64), (FT_F26Dot6)(h*64), 72, 72))
            return false;
    }
    font->currentw = w;
    font->currenth = h;
    return true;
}

References ft2_font_t::currenth, ft2_font_t::currentw, ft2_font_t::face, ft2_font_t::image_font, int(), ft2_font_t::next, qFT_Set_Char_Size, and w.

Referenced by Font_GetKerningForMap(), Font_LoadMap(), and Font_SearchSize().

font_shutdown()

void font_shutdown

(

void

)

Definition at line 425 of file ft2.c.

{
    int i;
    for (i = 0; i < dp_fonts.maxsize; ++i)
    {
        if (dp_fonts.f[i].ft2)
        {
            Font_UnloadFont(dp_fonts.f[i].ft2);
            dp_fonts.f[i].ft2 = NULL;
        }
    }
    Font_CloseLibrary();
}

References dp_fonts, dp_fonts_t::f, Font_CloseLibrary(), Font_UnloadFont(), dp_font_t::ft2, i, dp_fonts_t::maxsize, and NULL.

Referenced by gl_draw_shutdown().

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_start()

void font_start

(

void

)

Definition at line 404 of file ft2.c.

{
    if (!Font_OpenLibrary())
        return;
 
    if (qFT_Init_FreeType(&font_ft2lib))
    {
        Con_Print(CON_ERROR "ERROR: Failed to initialize the FreeType2 library!\n");
        Font_CloseLibrary();
        return;
    }
 
    font_mempool = Mem_AllocPool("FONT", 0, NULL);
    if (!font_mempool)
    {
        Con_Print(CON_ERROR "ERROR: Failed to allocate FONT memory pool!\n");
        Font_CloseLibrary();
        return;
    }
}

References CON_ERROR, Con_Print(), Font_CloseLibrary(), font_ft2lib, font_mempool, Font_OpenLibrary(), Mem_AllocPool, NULL, and qFT_Init_FreeType.

Referenced by gl_draw_start().

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.

Referenced by Font_LoadFont().

fontfilecache_Free()

static void fontfilecache_Free ( const unsigned char * buf )

static

Definition at line 301 of file ft2.c.

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

References buf, fontfilecache_t::buf, fontfiles, i, MAX_FONTFILES, Mem_Free, and NULL.

Referenced by Font_UnloadFont().

fontfilecache_FreeAll()

static void fontfilecache_FreeAll ( void )

static

Definition at line 320 of file ft2.c.

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

References buf, fontfilecache_t::buf, fontfiles, i, MAX_FONTFILES, Mem_Free, NULL, and fontfilecache_t::refcount.

Referenced by Font_CloseLibrary().

fontfilecache_LoadFile()

static const unsigned char * fontfilecache_LoadFile ( const char * path, qbool quiet, fs_offset_t * filesizepointer )

static

Definition at line 269 of file ft2.c.

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

References buf, fontfilecache_t::buf, dp_strlcpy, font_mempool, fontfiles, FS_LoadFile(), i, fontfilecache_t::len, MAX_FONTFILES, and fontfilecache_t::refcount.

Referenced by Font_LoadFile().

FontMap_FindForChar()

ft2_font_map_t * FontMap_FindForChar	(	ft2_font_map_t *	start,
		Uchar	ch )

Definition at line 1911 of file ft2.c.

{
    ft2_font_map_t *map = start;
    while (map && map->start + FONT_CHARS_PER_MAP <= ch)
        map = map->next;
    if (map && map->start > ch)
        return NULL;
    alert_legacy_font_api("FontMap_FindForChar");
    return map;
}

References alert_legacy_font_api(), FONT_CHARS_PER_MAP, and NULL.

get_char_from_incmap()

static qbool get_char_from_incmap ( ft2_font_map_t * map, Uchar ch, ft2_font_map_t ** outmap, int * outmapch )

inlinestatic

Definition at line 1936 of file ft2.c.

{
    int i;
    font_incmap_t *incmap;
 
    incmap = map->incmap;
    *outmapch = 0;
 
    if (incmap != NULL)
    {
        map = incmap->fontmap;
        while (map != NULL)
        {
            for (i = 0; i < FONT_CHARS_PER_MAP; ++i)
            {
                if (map->glyphchars[i] == ch)
                {
                    *outmap = map;
                    *outmapch = i;
                    return true;
                }
                else if (map->glyphchars[i] == 0)
                    // this tier0/tier1 map ends here
                    break;
            }
            map = map->next;
        }
    }
    return false;
}

References FONT_CHARS_PER_MAP, i, and NULL.

Referenced by Font_GetMapForChar().

incmap_post_process()

static void incmap_post_process ( font_incmap_t * incmap, Uchar ch, unsigned char * data, ft2_font_map_t ** outmap, int * outmapch )

inlinestatic

Definition at line 1283 of file ft2.c.

{
    #define bytes_per_pixel 4
 
    int index, targetmap_at;
    // where will the next `data` be placed
    int tier1_data_index, tier2_data_index;
    // metrics of data to manipulate
    int width, height, pitch, datasize;
    int i, j, x, y;
    unsigned char *newdata, *chunk;
    ft2_font_map_t *startmap, *targetmap, *currentmap;
    #define M FONT_CHARS_PER_LINE
    #define N FONT_CHAR_LINES
 
    startmap = incmap->fontmap;
    index = incmap->charcount;
    tier1_data_index = index % M;
    tier2_data_index = incmap->tier1_merged;
 
    incmap->data_tier1[tier1_data_index] = data;
 
    if (index % M == M - 1)
    {
        // tier 1 reduction, pieces to line
        calc_data_arguments(1, 1);
        targetmap_at = incmap->tier2_merged + incmap->tier1_merged;
        targetmap = startmap;
        for (i = 0; i < targetmap_at; ++i)
            targetmap = targetmap->next;
        currentmap = targetmap;
        newdata = (unsigned char *)Mem_Alloc(font_mempool, datasize * M);
        for (i = 0; i < M; ++i)
        {
            chunk = incmap->data_tier1[i];
            if (chunk == NULL)
                continue;
            for (y = 0; y < datasize; y += pitch)
                for (x = 0; x < pitch; ++x)
                    newdata[y * M + i * pitch + x] = chunk[y + x];
            Mem_Free(chunk);
            incmap->data_tier1[i] = NULL;
            merge_single_map(targetmap, i, currentmap, 0);
            fix_glyph_coords_tier1(&targetmap->glyphs[i], (float)i);
            currentmap = currentmap->next;
        }
        update_pic_for_fontmap(targetmap, Draw_GetPicName(targetmap->pic), width * M, height, newdata);
        UnloadMapChain(targetmap->next);
        targetmap->next = NULL;
        incmap->data_tier2[tier2_data_index] = newdata;
        ++incmap->tier1_merged;
        incmap->tier1_merged %= M;
        incmap->newmap_start = INCMAP_START + targetmap_at + 1;
        // then give this merged map
        *outmap = targetmap;
        *outmapch = FONT_CHARS_PER_LINE - 1;
    }
    if (index % (M * N) == M * N - 1)
    {
        // tier 2 reduction, lines to full map
        calc_data_arguments(M, 1);
        targetmap_at = incmap->tier2_merged;
        targetmap = startmap;
        for (i = 0; i < targetmap_at; ++i)
            targetmap = targetmap->next;
        currentmap = targetmap;
        newdata = (unsigned char *)Mem_Alloc(font_mempool, datasize * N);
        for (i = 0; i < N; ++i)
        {
            chunk = incmap->data_tier2[i];
            if (chunk == NULL)
                continue;
            for (x = 0; x < datasize; ++x)
                newdata[i * datasize + x] = chunk[x];
            Mem_Free(chunk);
            incmap->data_tier2[i] = NULL;
            for (j = 0; j < M; ++j)
            {
                merge_single_map(targetmap, i * M + j, currentmap, j);
                fix_glyph_coords_tier2(&targetmap->glyphs[i * M + j], (float)i);
            }
            currentmap = currentmap->next;
        }
        update_pic_for_fontmap(targetmap, Draw_GetPicName(targetmap->pic), width, height * N, newdata);
        UnloadMapChain(targetmap->next);
        targetmap->next = NULL;
        Mem_Free(newdata);
        ++incmap->tier2_merged;
        incmap->newmap_start = INCMAP_START + targetmap_at + 1;
        // then give this merged map
        *outmap = targetmap;
        *outmapch = FONT_CHARS_PER_MAP - 1;
    }
 
    ++incmap->charcount;
    ++incmap->newmap_start;
 
    #undef M
    #undef N
}

References calc_data_arguments, data, Draw_GetPicName(), fix_glyph_coords_tier1, fix_glyph_coords_tier2, FONT_CHARS_PER_LINE, FONT_CHARS_PER_MAP, font_mempool, height, i, INCMAP_START, index, M, Mem_Alloc, Mem_Free, merge_single_map(), N, NULL, UnloadMapChain(), update_pic_for_fontmap(), width, x, and y.

Referenced by Font_LoadMap().

merge_single_map()

static void merge_single_map ( ft2_font_map_t * targetmap, int targetindex, ft2_font_map_t * sourcemap, int sourceindex )

inlinestatic

Definition at line 1270 of file ft2.c.

{
    targetmap->glyphs[targetindex] = sourcemap->glyphs[sourceindex];
    targetmap->glyphchars[targetindex] = sourcemap->glyphchars[sourceindex];
}

Referenced by incmap_post_process().

should_use_incmap()

static qbool should_use_incmap ( Uchar ch )

inlinestatic

Definition at line 1922 of file ft2.c.

{
    int i;
    // optimize: a simple check logic for usual conditions
    if (ch < unicode_bigblocks[0])
        return false;
    if (r_font_disable_incmaps.integer == 1)
        return false;
    for (i = 0; i < (int)(sizeof(unicode_bigblocks) / sizeof(Uchar)); i += 2)
        if (unicode_bigblocks[i] <= ch && ch <= unicode_bigblocks[i + 1])
            return true;
    return false;
}

References i, int(), cvar_t::integer, r_font_disable_incmaps, and unicode_bigblocks.

Referenced by Font_GetMapForChar().

transform_glyph_coords()

static void transform_glyph_coords ( glyph_slot_t * glyph, float shiftx, float shifty, float scalex, float scaley )

inlinestatic

Definition at line 1259 of file ft2.c.

{
    glyph->txmin = glyph->txmin * scalex + shiftx;
    glyph->txmax = glyph->txmax * scalex + shiftx;
    glyph->tymin = glyph->tymin * scaley + shifty;
    glyph->tymax = glyph->tymax * scaley + shifty;
}

References glyph_slot_t::txmax, glyph_slot_t::txmin, glyph_slot_t::tymax, and glyph_slot_t::tymin.

UnloadMapChain()

static void UnloadMapChain ( ft2_font_map_t * map )

static

Definition at line 1150 of file ft2.c.

{
    int i;
    ft2_font_map_t *nextmap;
    // these may only be in a startmap
    if (map->kerning != NULL)
        Mem_Free(map->kerning);
    if (map->incmap != NULL)
    {
        for (i = 0; i < FONT_CHARS_PER_LINE; ++i)
            if (map->incmap->data_tier1[i] != NULL)
                Mem_Free(map->incmap->data_tier1[i]);
            else
                break;
        for (i = 0; i < FONT_CHAR_LINES; ++i)
            if (map->incmap->data_tier2[i] != NULL)
                Mem_Free(map->incmap->data_tier2[i]);
            else
                break;
        Mem_Free(map->incmap);
    }
    while (map != NULL)
    {
        if (map->pic)
        {
            //Draw_FreePic(map->pic); // FIXME: refcounting needed...
            map->pic = NULL;
        }
        nextmap = map->next;
        Mem_Free(map);
        map = nextmap;
    }
}

References FONT_CHAR_LINES, FONT_CHARS_PER_LINE, i, Mem_Free, and NULL.

Referenced by Font_UnloadFont(), and incmap_post_process().

update_pic_for_fontmap()

static void update_pic_for_fontmap ( ft2_font_map_t * fontmap, const char * identifier, int width, int height, unsigned char * data )

inlinestatic

Definition at line 1251 of file ft2.c.

{
    fontmap->pic = Draw_NewPic(identifier, width, height, data, TEXTYPE_RGBA,
        TEXF_ALPHA | TEXF_CLAMP | (r_font_compress.integer > 0 ? TEXF_COMPRESS : 0));
}

References data, Draw_NewPic(), height, cvar_t::integer, r_font_compress, TEXF_ALPHA, TEXF_CLAMP, TEXF_COMPRESS, TEXTYPE_RGBA, and width.

Referenced by Font_LoadMap(), and incmap_post_process().

Variable Documentation

developer_font

cvar_t developer_font = {CF_CLIENT | CF_ARCHIVE, "developer_font", "0", "prints debug messages about fonts"}

Definition at line 61 of file ft2.c.

{CF_CLIENT | CF_ARCHIVE, "developer_font", "0", "prints debug messages about fonts"};

Referenced by FindFont(), Font_Init(), and Font_LoadMap().

font_ft2lib

FT_Library font_ft2lib = NULL

static

FreeType library handle.

Definition at line 244 of file ft2.c.

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

font_mempool

mempool_t* font_mempool = NULL

static

Memory pool for fonts.

Definition at line 241 of file ft2.c.

Referenced by Font_Alloc(), Font_Attach(), Font_CloseLibrary(), Font_LoadMap(), Font_LoadSize(), Font_Postprocess_Update(), font_start(), fontfilecache_LoadFile(), and incmap_post_process().

fontfiles

fontfilecache_t fontfiles[MAX_FONTFILES]

static

Definition at line 268 of file ft2.c.

Referenced by fontfilecache_Free(), fontfilecache_FreeAll(), and fontfilecache_LoadFile().

ft2_dll

dllhandle_t ft2_dll = NULL

static

Handle for FreeType2 DLL.

Definition at line 159 of file ft2.c.

Referenced by Font_Alloc(), Font_CloseLibrary(), Font_OpenLibrary(), and Font_UnloadFont().

ft2funcs

dllfunction_t ft2funcs[]

static

Initial value:

=
{
    {"FT_Init_FreeType",        (void **) &qFT_Init_FreeType},
    {"FT_Done_FreeType",        (void **) &qFT_Done_FreeType},
    
    {"FT_New_Memory_Face",      (void **) &qFT_New_Memory_Face},
    {"FT_Done_Face",        (void **) &qFT_Done_Face},
    {"FT_Select_Size",      (void **) &qFT_Select_Size},
    {"FT_Request_Size",     (void **) &qFT_Request_Size},
    {"FT_Set_Char_Size",        (void **) &qFT_Set_Char_Size},
    {"FT_Set_Pixel_Sizes",      (void **) &qFT_Set_Pixel_Sizes},
    {"FT_Load_Glyph",       (void **) &qFT_Load_Glyph},
    {"FT_Load_Char",        (void **) &qFT_Load_Char},
    {"FT_Get_Char_Index",       (void **) &qFT_Get_Char_Index},
    {"FT_Render_Glyph",     (void **) &qFT_Render_Glyph},
    {"FT_Get_Kerning",      (void **) &qFT_Get_Kerning},
    {"FT_Attach_Stream",        (void **) &qFT_Attach_Stream},
    {NULL, NULL}
}

Definition at line 138 of file ft2.c.

{
    {"FT_Init_FreeType",        (void **) &qFT_Init_FreeType},
    {"FT_Done_FreeType",        (void **) &qFT_Done_FreeType},
    //{"FT_New_Face",           (void **) &qFT_New_Face},
    {"FT_New_Memory_Face",      (void **) &qFT_New_Memory_Face},
    {"FT_Done_Face",        (void **) &qFT_Done_Face},
    {"FT_Select_Size",      (void **) &qFT_Select_Size},
    {"FT_Request_Size",     (void **) &qFT_Request_Size},
    {"FT_Set_Char_Size",        (void **) &qFT_Set_Char_Size},
    {"FT_Set_Pixel_Sizes",      (void **) &qFT_Set_Pixel_Sizes},
    {"FT_Load_Glyph",       (void **) &qFT_Load_Glyph},
    {"FT_Load_Char",        (void **) &qFT_Load_Char},
    {"FT_Get_Char_Index",       (void **) &qFT_Get_Char_Index},
    {"FT_Render_Glyph",     (void **) &qFT_Render_Glyph},
    {"FT_Get_Kerning",      (void **) &qFT_Get_Kerning},
    {"FT_Attach_Stream",        (void **) &qFT_Attach_Stream},
    {NULL, NULL}
};

Referenced by Font_OpenLibrary().

img_fontmap

int img_fontmap[256]

static

Initial value:

= {
    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 
    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 
    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 
    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 
    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 
    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
}

Definition at line 11 of file ft2.c.

                              {
    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // shift+digit line
    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // digits
    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // caps
    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // caps
    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // small
    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // small
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // specials
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // faces
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
};

Referenced by Font_LoadMap().

legacy_font_loading_api_alerted

qbool legacy_font_loading_api_alerted = false

static

Definition at line 1888 of file ft2.c.

Referenced by alert_legacy_font_api().

pp

font_postprocess_t pp

static

Definition at line 257 of file ft2.c.

Referenced by Font_CloseLibrary(), Font_Postprocess(), and Font_Postprocess_Update().

qFT_Attach_Stream

(* qFT_Attach_Stream) (FT_Face face, FT_Open_Args *parameters)	(	FT_Face	face,
		FT_Open_Args *	parameters )

Definition at line 63 of file ft2.c.

Referenced by Font_LoadFile().

qFT_Done_Face

(* qFT_Done_Face) (FT_Face face)

(

FT_Face

face

)

Definition at line 63 of file ft2.c.

Referenced by Font_UnloadFont().

qFT_Done_FreeType

(* qFT_Done_FreeType) (FT_Library library)

(

FT_Library

library

)

Definition at line 63 of file ft2.c.

Referenced by Font_CloseLibrary().

qFT_Get_Char_Index

(* qFT_Get_Char_Index) (FT_Face face, FT_ULong charcode)	(	FT_Face	face,
		FT_ULong	charcode )

Definition at line 63 of file ft2.c.

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

qFT_Get_Kerning

(* qFT_Get_Kerning) (FT_Face face, FT_UInt left_glyph, FT_UInt right_glyph, FT_UInt kern_mode, FT_Vector *akerning)	(	FT_Face	face,
		FT_UInt	left_glyph,
		FT_UInt	right_glyph,
		FT_UInt	kern_mode,
		FT_Vector *	akerning )

Definition at line 63 of file ft2.c.

Referenced by Font_GetKerningForMap(), and Font_LoadSize().

qFT_Init_FreeType

(* qFT_Init_FreeType) (FT_Library *alibrary)

(

FT_Library *

alibrary

)

Definition at line 63 of file ft2.c.

Referenced by font_start().

qFT_Load_Char

(* qFT_Load_Char) (FT_Face face, FT_ULong char_code, FT_Int32 load_flags)	(	FT_Face	face,
		FT_ULong	char_code,
		FT_Int32	load_flags )

Definition at line 63 of file ft2.c.

qFT_Load_Glyph

(* qFT_Load_Glyph) (FT_Face face, FT_UInt glyph_index, FT_Int32 load_flags)	(	FT_Face	face,
		FT_UInt	glyph_index,
		FT_Int32	load_flags )

Definition at line 63 of file ft2.c.

Referenced by Font_LoadMap().

qFT_New_Memory_Face

(* qFT_New_Memory_Face) (FT_Library library, const FT_Byte *file_base, FT_Long file_size, FT_Long face_index, FT_Face *aface)	(	FT_Library	library,
		const FT_Byte *	file_base,
		FT_Long	file_size,
		FT_Long	face_index,
		FT_Face *	aface )

Definition at line 63 of file ft2.c.

Referenced by Font_LoadFile().

qFT_Render_Glyph

(* qFT_Render_Glyph) (FT_GlyphSlot slot, FT_Render_Mode render_mode)	(	FT_GlyphSlot	slot,
		FT_Render_Mode	render_mode )

Definition at line 63 of file ft2.c.

qFT_Request_Size

(* qFT_Request_Size) (FT_Face face, FT_Size_Request req)	(	FT_Face	face,
		FT_Size_Request	req )

Definition at line 63 of file ft2.c.

qFT_Select_Size

(* qFT_Select_Size) (FT_Face face, FT_Int strike_index)	(	FT_Face	face,
		FT_Int	strike_index )

Definition at line 63 of file ft2.c.

qFT_Set_Char_Size

(* qFT_Set_Char_Size) (FT_Face face, FT_F26Dot6 char_width, FT_F26Dot6 char_height, FT_UInt horz_resolution, FT_UInt vert_resolution)	(	FT_Face	face,
		FT_F26Dot6	char_width,
		FT_F26Dot6	char_height,
		FT_UInt	horz_resolution,
		FT_UInt	vert_resolution )

Definition at line 63 of file ft2.c.

Referenced by Font_SetSize().

qFT_Set_Pixel_Sizes

(* qFT_Set_Pixel_Sizes) (FT_Face face, FT_UInt pixel_width, FT_UInt pixel_height)	(	FT_Face	face,
		FT_UInt	pixel_width,
		FT_UInt	pixel_height )

Definition at line 63 of file ft2.c.

r_font_compress

cvar_t r_font_compress = {CF_CLIENT | CF_ARCHIVE, "r_font_compress", "0", "use texture compression on font textures to save video memory"}

Definition at line 59 of file ft2.c.

{CF_CLIENT | CF_ARCHIVE, "r_font_compress", "0", "use texture compression on font textures to save video memory"};

Referenced by Font_Init(), and update_pic_for_fontmap().

r_font_disable_freetype

cvar_t r_font_disable_freetype = {CF_CLIENT | CF_ARCHIVE, "r_font_disable_freetype", "0", "disable freetype support for fonts entirely"}

Definition at line 55 of file ft2.c.

{CF_CLIENT | CF_ARCHIVE, "r_font_disable_freetype", "0", "disable freetype support for fonts entirely"};

Referenced by Font_Alloc(), Font_Init(), Font_LoadFile(), Font_OpenLibrary(), and Font_UnloadFont().

r_font_disable_incmaps

cvar_t r_font_disable_incmaps = {CF_CLIENT | CF_ARCHIVE, "r_font_disable_incmaps", "0", "always to load a full glyph map for individual unmapped character, even when it will mean extreme resources waste"}

Definition at line 63 of file ft2.c.

{CF_CLIENT | CF_ARCHIVE, "r_font_disable_incmaps", "0", "always to load a full glyph map for individual unmapped character, even when it will mean extreme resources waste"};

Referenced by Font_Init(), and should_use_incmap().

r_font_diskcache

cvar_t r_font_diskcache = {CF_CLIENT | CF_ARCHIVE, "r_font_diskcache", "0", "[deprecated, not effective] save font textures to disk for future loading rather than generating them every time"}

Definition at line 58 of file ft2.c.

{CF_CLIENT | CF_ARCHIVE, "r_font_diskcache", "0", "[deprecated, not effective] save font textures to disk for future loading rather than generating them every time"};

Referenced by Font_Init().

r_font_kerning

cvar_t r_font_kerning = {CF_CLIENT | CF_ARCHIVE, "r_font_kerning", "1", "Use kerning if available"}

Definition at line 57 of file ft2.c.

{CF_CLIENT | CF_ARCHIVE, "r_font_kerning", "1", "Use kerning if available"};

Referenced by Font_GetKerningForMap(), and Font_Init().

r_font_nonpoweroftwo

cvar_t r_font_nonpoweroftwo = {CF_CLIENT | CF_ARCHIVE, "r_font_nonpoweroftwo", "1", "use nonpoweroftwo textures for font (saves memory, potentially slower)"}

Definition at line 60 of file ft2.c.

{CF_CLIENT | CF_ARCHIVE, "r_font_nonpoweroftwo", "1", "use nonpoweroftwo textures for font (saves memory, potentially slower)"};

Referenced by Font_Init(), and Font_LoadSize().

r_font_size_snapping

cvar_t r_font_size_snapping = {CF_CLIENT | CF_ARCHIVE, "r_font_size_snapping", "1", "stick to good looking font sizes whenever possible - bad when the mod doesn't support it!"}

Definition at line 56 of file ft2.c.

{CF_CLIENT | CF_ARCHIVE, "r_font_size_snapping", "1", "stick to good looking font sizes whenever possible - bad when the mod doesn't support it!"};

Referenced by Font_IndexForSize(), and Font_Init().

unicode_bigblocks

const Uchar unicode_bigblocks[]

static

Initial value:

= {
    0x3400, 0x4DBF,     
    0x4E00, 0x9FFF,     
    0xAC00, 0xD7AF,     
    0xE000, 0xF8FF,     
    0x10000, 0x10FFFF   
}

Definition at line 41 of file ft2.c.

                                         {
    0x3400, 0x4DBF,     //   6592  CJK Unified Ideographs Extension A
    0x4E00, 0x9FFF,     //  20992  CJK Unified Ideographs
    0xAC00, 0xD7AF,     //  11184  Hangul Syllables
    0xE000, 0xF8FF,     //   6400  Private Use Area
    0x10000, 0x10FFFF   //         Everything above
};

Referenced by should_use_incmap().