Fix for space and punctuation characters. These one are weak/neutral and should not...

[open-ps2-loader.git] / src / fntsys.c

/*
 Copyright 2010, Volca
 Licenced under Academic Free License version 3.0
 Review OpenUsbLd README & LICENSE files for further details.
 */

#include "include/integers.h"
#include "include/usbld.h"
#include "include/fntsys.h"
#include "include/renderman.h"
#include "include/ioman.h"
#include "include/utf8.h"
#include "include/util.h"
#include "include/atlas.h"

#include <ft2build.h>

#include FT_FREETYPE_H

extern void* freesansfont_raw;
extern int size_freesansfont_raw;

/// Maximal count of atlases per font
#define ATLAS_MAX 4
/// Atlas width in pixels
#define ATLAS_WIDTH 128
/// Atlas height in pixels
#define ATLAS_HEIGHT 128

// freetype vars
static FT_Library font_library;

static int gCharHeight;
static int screenWidth;
static int screenHeight;

static s32 gFontSemaId;
static ee_sema_t gFontSema;

static GSCLUT fontClut;

/** Single entry in the glyph cache */
typedef struct {
        int isValid;
        // size in pixels of the glyph
        int width, height;
        // offsetting of the glyph
        int ox, oy;
        // advancements in pixels after rendering this glyph
        int shx, shy;
        
        // atlas for which the allocation was done
    atlas_t* atlas;

        // atlas allocation position
        struct atlas_allocation_t *allocation;

} fnt_glyph_cache_entry_t;

/** A whole font definition */
typedef struct {
        /** GLYPH CACHE. Every glyph in the ASCII range is cached when first used
         * this means no additional memory aside from the one needed to render the
         * character set is used.
         */
        fnt_glyph_cache_entry_t **glyphCache;

        /// Maximal font cache page index
        int cacheMaxPageID;

        /// Font face
        FT_Face face;

        /// Nonzero if font is used
        int isValid;

        /// Nonzero for custom fonts
        int isDefault;

        /// Texture atlases (default to NULL)
        atlas_t *atlases[ATLAS_MAX];
        
        /// Pointer to data, if allocation takeover was selected (will be freed)
        void *dataPtr;
} font_t;

#define FNT_MAX_COUNT (16)

/// Array of font definitions
static font_t fonts[FNT_MAX_COUNT];

static rm_quad_t quad;
static uint32_t codepoint, state;
static fnt_glyph_cache_entry_t* glyph;
static FT_Bool use_kerning;
static FT_UInt glyph_index, previous;
static FT_Vector delta;

#define GLYPH_CACHE_PAGE_SIZE 256

#define GLYPH_PAGE_OK(font,page) ((pageid <= font->cacheMaxPageID) && (font->glyphCache[page]))

void fntReloadScreenExtents() {
        rmGetScreenExtents(&screenWidth, &screenHeight);
}

static int fntPrepareGlyphCachePage(font_t *font, int pageid) {
        if (pageid > font->cacheMaxPageID) {
                fnt_glyph_cache_entry_t **np = realloc(font->glyphCache, (pageid + 1) * sizeof(fnt_glyph_cache_entry_t *));

                if (!np)
                        return 0;

                font->glyphCache = np;

                unsigned int page;
                for (page = font->cacheMaxPageID + 1; page <= pageid; ++page)
                        font->glyphCache[page] = NULL;

                font->cacheMaxPageID = pageid;
        }

        // if it already was allocated, skip this
        if (font->glyphCache[pageid])
                return 1;

        // allocate the page
        font->glyphCache[pageid] = malloc(sizeof(fnt_glyph_cache_entry_t) * GLYPH_CACHE_PAGE_SIZE);

        int i;
        for (i = 0; i < GLYPH_CACHE_PAGE_SIZE; ++i) {
                font->glyphCache[pageid][i].isValid = 0;
                font->glyphCache[pageid][i].atlas = NULL;
                font->glyphCache[pageid][i].allocation = NULL;
        }

        return 1;
}

static void fntResetFontDef(font_t *fnt) {
        LOG("fntResetFontDef\n");
        fnt->glyphCache = NULL;
        fnt->cacheMaxPageID = -1;
        fnt->isValid = 0;
        fnt->isDefault = 0;
        
        int aid;
        for(aid = 0; aid < ATLAS_MAX; ++aid)
                fnt->atlases[aid] = NULL;
                
        fnt->dataPtr = NULL;
}

static void fntPrepareCLUT() {
        fontClut.PSM = GS_PSM_T8;
        fontClut.ClutPSM = GS_PSM_CT32;
        fontClut.Clut = memalign(128, 256 * 4);
        fontClut.VramClut = 0;
        
        // generate the clut table
        size_t i;
        u32 *clut = fontClut.Clut;
        for (i = 0; i < 256; ++i) {
                u8 alpha =  i > 0x080 ? 0x080 : i;
                
                *clut = alpha << 24 | i << 16 | i << 8 | i;
                clut++; 
        }
}

static void fntDestroyCLUT() {
        free(fontClut.Clut);
        fontClut.Clut = NULL;
}

void fntInit(void) {
        LOG("fntInit\n");
        int error = FT_Init_FreeType(&font_library);

        if (error) {
                // just report over the ps2link
                LOG("Freetype init failed with %x!\n", error);
                // SleepThread();
        }

        fntPrepareCLUT();

        gFontSema.init_count = 1;
        gFontSema.max_count = 1;
        gFontSema.option = 0;
        gFontSemaId = CreateSema(&gFontSema);

        fntReloadScreenExtents();

        int i;
        for (i = 0; i < FNT_MAX_COUNT; ++i)
                fntResetFontDef(&fonts[i]);

        // load the default font (will be id=0)
        fntLoad(NULL, -1, 0);
}

static void fntCacheFlushPage(fnt_glyph_cache_entry_t *page) {
        LOG("fntCacheFlushPage\n");
        int i;

        for (i = 0; i < GLYPH_CACHE_PAGE_SIZE; ++i, ++page) {
                page->isValid = 0;
                // we're not doing any atlasFree or such - atlas has to be rebuild
                page->allocation = NULL;
                page->atlas = NULL;
        }
}

static void fntCacheFlush(font_t *fnt) {
        LOG("fntCacheFlush\n");
        
        int i;

        // Release all the glyphs from the cache
        for (i = 0; i <= fnt->cacheMaxPageID; ++i) {
                if (fnt->glyphCache[i]) {
                        fntCacheFlushPage(fnt->glyphCache[i]);
                        free(fnt->glyphCache[i]);
                        fnt->glyphCache[i] = NULL;
                }
        }

        free(fnt->glyphCache);
        fnt->glyphCache = NULL;
        fnt->cacheMaxPageID = -1;
        
        // free all atlasses too, they're invalid now anyway
        int aid;
        for(aid = 0; aid < ATLAS_MAX; ++aid) {
                atlasFree(fnt->atlases[aid]);
                fnt->atlases[aid] = NULL;
        }
}

static int fntNewFont() {
        LOG("fntNewFont\n");
        int i;
        for (i = 0; i < FNT_MAX_COUNT; ++i) {
                if (fonts[i].isValid == 0) {
                        fntResetFontDef(&fonts[i]);
                        return i;
                }
        }

        return FNT_ERROR;
}

void fntDeleteFont(font_t *font) {
        LOG("fntDeleteFont\n");
        
        // skip already deleted fonts
        if (!font->isValid)
                return;

        // free the glyph cache, atlases, unload the font
        fntCacheFlush(font);

        FT_Done_Face(font->face);

        if (font->dataPtr) {
                free(font->dataPtr);
                font->dataPtr = NULL;
        }

        font->isValid = 0;
}

int fntLoadSlot(font_t *fnt, void* buffer, int bufferSize) {
        LOG("fntLoadSlot\n");
        
        if (!buffer) {
                buffer = &freesansfont_raw;
                bufferSize = size_freesansfont_raw;
                fnt->isDefault = 1;
        }

        // load the font via memory handle
        int error = FT_New_Memory_Face(font_library, (FT_Byte*) buffer, bufferSize, 0, &fnt->face);

        if (error) {
                // just report over the ps2link
                LOG("Freetype: Font loading failed with %x!\n", error);
                // SleepThread();
                return -1;
        }

        gCharHeight = 16;

        error = FT_Set_Char_Size(fnt->face, 0, gCharHeight * 16, 300, 300);
        /*error = FT_Set_Pixel_Sizes( face,
         0, // pixel_width
         gCharHeight ); // pixel_height*/

        if (error) {
                // just report over the ps2link
                LOG("Freetype: Error setting font pixel size with %x!\n", error);
                // SleepThread();
                return -1;
        }

        fnt->isValid = 1;
        return 0;
}

int fntLoad(void* buffer, int bufferSize, int takeover) {
        LOG("fntLoad\n");
        
        // we need a new slot in the font array
        int fontID = fntNewFont();

        if (fontID == FNT_ERROR)
                return FNT_ERROR;

        font_t *fnt = &fonts[fontID];

        if (fntLoadSlot(fnt, buffer, bufferSize) == FNT_ERROR)
                return FNT_ERROR;

        if (takeover)
                fnt->dataPtr = buffer;

        return fontID;
}

int fntLoadFile(char* path) {
        LOG("fntLoadFile\n");
        // load the buffer with font
        int size = -1;
        void* customFont = readFile(path, -1, &size);

        if (!customFont)
                return FNT_ERROR;

        int fontID = fntLoad(customFont, size, 1);

        return fontID;
}

void fntRelease(int id) {
        LOG("fntRelease\n");
        if (id < FNT_MAX_COUNT)
                fntDeleteFont(&fonts[id]);
}

/** Terminates the font rendering system */
void fntEnd(void) {
        LOG("fntEnd\n");
        // release all the fonts
        int id;
        for (id = 0; id < FNT_MAX_COUNT; ++id)
                fntDeleteFont(&fonts[id]);

        // deinit freetype system
        FT_Done_FreeType(font_library);

        DeleteSema(gFontSemaId);
        
        fntDestroyCLUT();
}

static atlas_t *fntNewAtlas() {
        atlas_t *atl = atlasNew(ATLAS_WIDTH, ATLAS_HEIGHT, GS_PSM_T8);
        
        atl->surface.ClutPSM = GS_PSM_CT32;
        atl->surface.Clut = (u32*)(&fontClut);

        return atl;
}

static int fntGlyphAtlasPlace(font_t *fnt, fnt_glyph_cache_entry_t* glyph) {
        FT_GlyphSlot slot = fnt->face->glyph;
        
        LOG("fntGlyphAtlasPlace: Placing the glyph... %d x %d\n", slot->bitmap.width, slot->bitmap.rows);
        
        if (slot->bitmap.width == 0 || slot->bitmap.rows == 0) {
                // no bitmap glyph, just skip
                return 1;
        }
        
        int aid;
        
        for (aid = 0; aid < ATLAS_MAX; ++aid) {
                LOG("  * Placing aid %d...\n", aid);
                atlas_t **atl = &fnt->atlases[aid];
                if (!*atl) { // atlas slot not yet used
                        LOG("  * aid %d is new...\n", aid);
                        *atl = fntNewAtlas();
                }
                
                glyph->allocation = 
                        atlasPlace(*atl, slot->bitmap.width, slot->bitmap.rows, slot->bitmap.buffer);
                        
                if (glyph->allocation) {
                        LOG("  * found placement\n", aid);
                        glyph->atlas = *atl;
                        
                        return 1;
                }
        }
        
        LOG("  * ! no atlas free\n", aid);
        return 0;
}

/** Internal method. Makes sure the bitmap data for particular character are pre-rendered to the glyph cache */
static fnt_glyph_cache_entry_t* fntCacheGlyph(font_t *fnt, uint32_t gid) {
        // calc page id and in-page index from glyph id
        int pageid = gid / GLYPH_CACHE_PAGE_SIZE;
        int idx = gid % GLYPH_CACHE_PAGE_SIZE;

        // do not call on every char of every font rendering call
        if (!GLYPH_PAGE_OK(fnt,pageid))
                if (!fntPrepareGlyphCachePage(fnt, pageid)) // failed to prepare the page...
                        return NULL;

        fnt_glyph_cache_entry_t *page = fnt->glyphCache[pageid];

        /* Should never happen. 
        if (!page) // safeguard
                return NULL;
        */

        fnt_glyph_cache_entry_t* glyph = &page[idx];

        if (glyph->isValid)
                return glyph;

        // not cached but valid. Cache
        if (!fnt->face) {
                LOG("FNT: Face is NULL!\n");
        }

        int error = FT_Load_Char(fnt->face, gid, FT_LOAD_RENDER);

        if (error) {
                LOG("FNT: Error loading glyph - %d\n", error);
                return NULL;
        }

        // find atlas placement for the glyph
        if  (!fntGlyphAtlasPlace(fnt, glyph))
                return NULL;

        FT_GlyphSlot slot = fnt->face->glyph;
        glyph->width = slot->bitmap.width;
        glyph->height = slot->bitmap.rows;
        glyph->shx = slot->advance.x;
        glyph->shy = slot->advance.y;
        glyph->ox = slot->bitmap_left;
        glyph->oy = gCharHeight - slot->bitmap_top;

        glyph->isValid = 1;

        return glyph;
}

void fntSetAspectRatio(float aw, float ah) {
        LOG("fntSetAspectRatio\n");
        // flush cache - it will be invalid after the setting
        int i;

        for (i = 0; i < FNT_MAX_COUNT; ++i) {
                if (fonts[i].isValid)
                        fntCacheFlush(&fonts[i]);
        }

        // set new aspect ratio (Is this correct, I wonder?)
        // TODO: error = FT_Set_Char_Size(face, 0, gCharHeight*64, ah*300, aw*300);
}

static void fntRenderGlyph(fnt_glyph_cache_entry_t* glyph, int pen_x, int pen_y) {
        // only if glyph has atlas placement
        if (glyph->allocation) {
                /* TODO: Ineffective on many parts:
                 * 1. Usage of floats for UV - fixed point should suffice (and is used internally by GS for UV)
                 *
                 * 2. GS_SETREG_TEX0 for every quad - why? gsKit should only set texture if demanded
                 *    We should prepare a special fnt render method that would step over most of the
                 *    performance problems under - begining with rmSetupQuad and continuing into gsKit
                 *    - this method would handle the preparetion of the quads and GS upload itself,
                 *    without the use of prim_quad_texture and rmSetupQuad...
                 *
                 * 3. We should use clut to keep the memory allocations sane - we're linear in the 32bit buffers
                 *    anyway, no reason to waste like we do!
                 */
                quad.ul.x = pen_x + glyph->ox;
                quad.br.x = quad.ul.x + glyph->width;
                quad.ul.y = pen_y + glyph->oy;
                quad.br.y = quad.ul.y + glyph->height;

                // UV is our own, custom thing here
                quad.txt = &glyph->atlas->surface;
                quad.ul.u = glyph->allocation->x;
                quad.br.u = quad.ul.u + glyph->width;
                quad.ul.v = glyph->allocation->y;
                quad.br.v = quad.ul.v + glyph->height;

                rmDrawQuad(&quad);
        }
}

#ifndef __RTL
int fntRenderString(int font, int x, int y, short aligned, size_t width, size_t height, const unsigned char* string, u64 colour) {
        // wait for font lock to unlock
        WaitSema(gFontSemaId);
        font_t *fnt = &fonts[font];
        SignalSema(gFontSemaId);

        if (aligned) {
                if (width) {
                        x -= min(fntCalcDimensions(font, string), width) >> 1;
                } else {
                        x -= fntCalcDimensions(font, string) >> 1;
                }
                y -= MENU_ITEM_HEIGHT >> 1;
        }

        rmApplyShiftRatio(&y);
        quad.color = colour;

        int pen_x = x;
        int xmax = x + width;
        int ymax = y + height;

        use_kerning = FT_HAS_KERNING(fnt->face);
        state = UTF8_ACCEPT;
        previous = 0;

        // Note: We need to change this so that we'll accumulate whole word before doing a layout with it
        // for now this method breaks on any character - which is a bit ugly

        // I don't want to do anything complicated though so I'd say
        // we should instead have a dynamic layout routine that'll replace spaces with newlines as appropriate
        // because that'll make the code run only once per N frames, not every frame

        // cache glyphs and render as we go
        for (; *string; ++string) {
                if (utf8Decode(&state, &codepoint, *string)) // accumulate the codepoint value
                        continue;

                glyph = fntCacheGlyph(fnt, codepoint);
                if (!glyph)
                        continue;

                // kerning
                if (use_kerning && previous) {
                        glyph_index = FT_Get_Char_Index(fnt->face, codepoint);
                        if (glyph_index) {
                                FT_Get_Kerning(fnt->face, previous, glyph_index, FT_KERNING_DEFAULT, &delta);
                                pen_x += delta.x >> 6;
                        }
                        previous = glyph_index;
                }

                if (width) {
                        if (codepoint == '\n') {
                                pen_x = x;
                                y += MENU_ITEM_HEIGHT; // hmax is too tight and unordered, generally
                                continue;
                        }

                        if (y > ymax) // stepped over the max
                                break;

                        if (pen_x + glyph->width > xmax) {
                                pen_x = xmax + 1; // to be sure no other cahr will be written (even not a smaller one just following)
                                continue;
                        }
                }

                fntRenderGlyph(glyph, pen_x, y);
                pen_x += glyph->shx >> 6;
        }

        return pen_x;
}

#else
static void fntRenderSubRTL(font_t *fnt, const unsigned char* startRTL, const unsigned char* string, fnt_glyph_cache_entry_t* glyph, int x, int y) {
        if (glyph) {
                x -= glyph->shx >> 6;
                fntRenderGlyph(glyph, x, y);
        }

        for (; startRTL != string; ++startRTL) {
                if (utf8Decode(&state, &codepoint, *startRTL))
                        continue;

                glyph = fntCacheGlyph(fnt, codepoint);
                if (!glyph)
                        continue;

                if (use_kerning && previous) {
                        glyph_index = FT_Get_Char_Index(fnt->face, codepoint);
                        if (glyph_index) {
                                FT_Get_Kerning(fnt->face, previous, glyph_index, FT_KERNING_DEFAULT, &delta);
                                x -= delta.x >> 6;
                        }
                        previous = glyph_index;
                }

                x -= glyph->shx >> 6;
                fntRenderGlyph(glyph, x, y);
        }
}

int fntRenderString(int font, int x, int y, short aligned, size_t width, size_t height, const unsigned char* string, u64 colour) {
        // wait for font lock to unlock
        WaitSema(gFontSemaId);
        font_t *fnt = &fonts[font];
        SignalSema(gFontSemaId);

        if (aligned) {
                if (width) {
                        x -= min(fntCalcDimensions(font, string), width) >> 1;
                } else {
                        x -= fntCalcDimensions(font, string) >> 1;
                }
                y -= MENU_ITEM_HEIGHT >> 1;
        }

        rmApplyShiftRatio(&y);
        quad.color = colour;

        int pen_x = x;
        /*int xmax = x + width;
        int ymax = y + height;*/

        use_kerning = FT_HAS_KERNING(fnt->face);
        state = UTF8_ACCEPT;
        previous = 0;

        short inRTL = 0;
        int delta_x, pen_xRTL = 0;
        fnt_glyph_cache_entry_t* glyphRTL = NULL;
        const unsigned char* startRTL = NULL;

        // cache glyphs and render as we go
        for (; *string; ++string) {
                if (utf8Decode(&state, &codepoint, *string)) // accumulate the codepoint value
                        continue;

                glyph = fntCacheGlyph(fnt, codepoint);
                if (!glyph)
                        continue;

                // kerning
                delta_x = 0;
                if (use_kerning && previous) {
                        glyph_index = FT_Get_Char_Index(fnt->face, codepoint);
                        if (glyph_index) {
                                FT_Get_Kerning(fnt->face, previous, glyph_index, FT_KERNING_DEFAULT, &delta);
                                delta_x = delta.x >> 6;
                        }
                        previous = glyph_index;
                }


                /*if (width) {
                        if (codepoint == '\n') {
                                x = xori;
                                y += MENU_ITEM_HEIGHT; // hmax is too tight and unordered, generally
                                continue;
                        }

                        if ((x + glyph_w > xmax) || (y > ymax)) // stepped over the max
                                break;
                }*/

                if (codepoint > 0xFF) {
                        if (!inRTL) {
                                inRTL = 1;
                                pen_xRTL = pen_x;
                                glyphRTL = glyph;
                                startRTL = string + 1;
                        }
                } else if ((codepoint > 96 && codepoint < 123) || (codepoint > 64 && codepoint < 91)) {
                        if (inRTL) { // render RTL
                                inRTL = 0;
                                pen_x = pen_xRTL;
                                fntRenderSubRTL(fnt, startRTL, string, glyphRTL, pen_xRTL, y);
                        }
                }

                if (inRTL) {
                        pen_xRTL += delta_x + (glyph->shx >> 6);
                } else {
                        pen_x += delta_x;
                        fntRenderGlyph(glyph, pen_x, y);
                        pen_x += glyph->shx >> 6;
                }

        }

        if (inRTL) {
                pen_x = pen_xRTL;
                fntRenderSubRTL(fnt, startRTL, string, glyphRTL, pen_xRTL, y);
        }

        return pen_x;
}
#endif

void fntFitString(int font, unsigned char *string, size_t width) {
        size_t cw = 0;
        unsigned char *str = string;
        size_t spacewidth = fntCalcDimensions(font, " ");
        unsigned char *psp = NULL;
        
        while (*str) {
                // scan forward to the next whitespace
                unsigned char *sp = str;
                for (; *sp && *sp != ' ' && *sp != '\n'; ++sp);
                
                // store what was there before
                unsigned char osp = *sp;
                
                // newline resets the situation
                if (osp == '\n') {
                        cw = 0;
                        str = ++sp;
                        psp = NULL;
                        continue;
                }
                
                // terminate after the word
                *sp = '\0';
                
                // Calc the font's width...
                // NOTE: The word was terminated, so we're seeing a single word
                // on that position
                size_t ww = fntCalcDimensions(font, str);
                
                if (cw + ww > width) {
                        if (psp) {
                                // we have a prev space to utilise (wrap on it)
                                *psp = '\n';
                                *sp = osp;
                                cw = ww;
                                psp = sp;
                        } else {
                                // no prev. space to hijack, must break after the word
                                // this will mean overflowed text...
                                *sp = '\n';
                                cw = 0;
                        }
                } else {
                        cw += ww;
                        *sp = osp;
                        psp = sp;
                }
                
                cw += spacewidth;
                str = ++sp;
        }
}

int fntCalcDimensions(int font, const unsigned char* str) {
        int w = 0;

        WaitSema(gFontSemaId);
        font_t *fnt = &fonts[font];
        SignalSema(gFontSemaId);

        uint32_t codepoint;
        uint32_t state = UTF8_ACCEPT;
        FT_Bool use_kerning = FT_HAS_KERNING(fnt->face);
        FT_UInt glyph_index, previous = 0;
        FT_Vector delta;

        // cache glyphs and render as we go
        for (; *str; ++str) {
                if (utf8Decode(&state, &codepoint, *str)) // accumulate the codepoint value
                        continue;

                // Could just as well only get the glyph dimensions
                // but it is probable the glyphs will be needed anyway
                fnt_glyph_cache_entry_t* glyph = fntCacheGlyph(fnt, codepoint);
                if (!glyph)
                        continue;

                // kerning
                if (use_kerning && previous) {
                        glyph_index = FT_Get_Char_Index(fnt->face, codepoint);
                        if (glyph_index) {
                                FT_Get_Kerning(fnt->face, previous, glyph_index, FT_KERNING_DEFAULT, &delta);
                                w += delta.x >> 6;
                        }
                        previous = glyph_index;
                }

                w += glyph->shx >> 6;
        }

        return w;
}

void fntReplace(int id, void* buffer, int bufferSize, int takeover, int asDefault) {
        font_t *fnt = &fonts[id];

        font_t ndefault, old;
        fntResetFontDef(&ndefault);
        fntLoadSlot(&ndefault, buffer, bufferSize);
        ndefault.isDefault = asDefault;

        // copy over the new font definition
        // we have to lock this phase, as the old font may still be used
        WaitSema(gFontSemaId);
        memcpy(&old, fnt, sizeof(font_t));
        memcpy(fnt, &ndefault, sizeof(font_t));

        if (takeover)
                fnt->dataPtr = buffer;

        SignalSema(gFontSemaId);

        // delete the old font
        fntDeleteFont(&old);
}

void fntSetDefault(int id) {
        font_t *fnt = &fonts[id];

        // already default
        if (fnt->isDefault)
                return;

        font_t ndefault, old;
        fntResetFontDef(&ndefault);
        fntLoadSlot(&ndefault, NULL, -1);

        // copy over the new font definition
        // we have to lock this phase, as the old font may still be used
        // Note: No check for concurrency is done here, which is kinda funky!
        WaitSema(gFontSemaId);
        memcpy(&old, fnt, sizeof(font_t));
        memcpy(fnt, &ndefault, sizeof(font_t));
        SignalSema(gFontSemaId);

        // delete the old font
        fntDeleteFont(&old);
}