blame: source/code/Libs/SDL_FontCache.c

/*

SDL_FontCache: A font cache for SDL and SDL_ttf

by Jonathan Dearborn

See SDL_FontCache.h for license info.

*/

#include "SDL_FontCache.h"

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

// Visual C does not support static inline

#ifndef static_inline

	#ifdef _MSC_VER

		#define static_inline static

	#else

		#define static_inline static inline

	#endif

#endif

#if SDL_VERSION_ATLEAST(2,0,0)

    #define FC_GET_ALPHA(sdl_color) ((sdl_color).a)

#else

    #define FC_GET_ALPHA(sdl_color) ((sdl_color).unused)

#endif

// Need SDL_RenderIsClipEnabled() for proper clipping support

#if SDL_VERSION_ATLEAST(2,0,4)

    #define ENABLE_SDL_CLIPPING

#endif

#define FC_MIN(a,b) ((a) < (b)? (a) : (b))

#define FC_MAX(a,b) ((a) > (b)? (a) : (b))

// vsnprintf replacement from Valentin Milea:

// http://stackoverflow.com/questions/2915672/snprintf-and-visual-studio-2010

#if defined(_MSC_VER) && _MSC_VER < 1900

#define snprintf c99_snprintf

#define vsnprintf c99_vsnprintf

__inline int c99_vsnprintf(char *outBuf, size_t size, const char *format, va_list ap)

{

    int count = -1;

    if (size != 0)

        count = _vsnprintf_s(outBuf, size, _TRUNCATE, format, ap);

    if (count == -1)

        count = _vscprintf(format, ap);

    return count;

}

__inline int c99_snprintf(char *outBuf, size_t size, const char *format, ...)

{

    int count;

    va_list ap;

    va_start(ap, format);

    count = c99_vsnprintf(outBuf, size, format, ap);

    va_end(ap);

    return count;

}

#endif

#define FC_EXTRACT_VARARGS(buffer, start_args) \

{ \

    va_list lst; \

    va_start(lst, start_args); \

    vsnprintf(buffer, fc_buffer_size, start_args, lst); \

    va_end(lst); \

}

// Extra pixels of padding around each glyph to avoid linear filtering artifacts

#define FC_CACHE_PADDING 1

static Uint8 has_clip(FC_Target* dest)

{

    #ifdef FC_USE_SDL_GPU

    return dest->use_clip_rect;

    #elif defined(ENABLE_SDL_CLIPPING)

    return SDL_RenderIsClipEnabled(dest);

    #else

    return 0;

    #endif

}

static FC_Rect get_clip(FC_Target* dest)

{

    #ifdef FC_USE_SDL_GPU

    return dest->clip_rect;

    #elif defined(ENABLE_SDL_CLIPPING)

    SDL_Rect r;

    SDL_RenderGetClipRect(dest, &r);

    return r;

    #else

    SDL_Rect r = {0, 0, 0, 0};

    return r;

    #endif

}

static void set_clip(FC_Target* dest, FC_Rect* rect)

{

    #ifdef FC_USE_SDL_GPU

    if(rect != NULL)

        GPU_SetClipRect(dest, *rect);

    else

        GPU_UnsetClip(dest);

    #elif defined(ENABLE_SDL_CLIPPING)

    SDL_RenderSetClipRect(dest, rect);

    #endif

}

static void set_color(FC_Image* src, Uint8 r, Uint8 g, Uint8 b, Uint8 a)

{

    #ifdef FC_USE_SDL_GPU

    GPU_SetRGBA(src, r, g, b, a);

    #else

    SDL_SetTextureColorMod(src, r, g, b);

    SDL_SetTextureAlphaMod(src, a);

    #endif

}

static char* new_concat(const char* a, const char* b)

{

    // Create new buffer

    unsigned int size = strlen(a) + strlen(b);

    char* new_string = (char*)malloc(size+1);

    // Concatenate strings in the new buffer

    strcpy(new_string, a);

    strcat(new_string, b);

    return new_string;

}

static char* replace_concat(char** a, const char* b)

{

    char* new_string = new_concat(*a, b);

    free(*a);

    *a = new_string;

    return *a;

}

// Shared buffer for variadic text

static char* fc_buffer = NULL;

static unsigned int fc_buffer_size = 1024;

static Uint8 fc_has_render_target_support = 0;

char* FC_GetStringASCII(void)

{

    static char* buffer = NULL;

    if(buffer == NULL)

    {

        int i;

        char c;

        buffer = (char*)malloc(512);

        memset(buffer, 0, 512);

        i = 0;

        c = 32;

        while(1)

        {

            buffer[i] = c;

            if(c == 126)

                break;

            ++i;

            ++c;

        }

    }

    return U8_strdup(buffer);

}

char* FC_GetStringLatin1(void)

{

    static char* buffer = NULL;

    if(buffer == NULL)

    {

        int i;

        unsigned char c;

        buffer = (char*)malloc(512);

        memset(buffer, 0, 512);

        i = 0;

        c = 0xA0;

        while(1)

        {

            buffer[i] = 0xC2;

            buffer[i+1] = c;

            if(c == 0xBF)

                break;

            i += 2;

            ++c;

        }

        i += 2;

        c = 0x80;

        while(1)

        {

            buffer[i] = 0xC3;

            buffer[i+1] = c;

            if(c == 0xBF)

                break;

            i += 2;

            ++c;

        }

    }

    return U8_strdup(buffer);

}

char* FC_GetStringASCII_Latin1(void)

{

    static char* buffer = NULL;

    if(buffer == NULL)

        buffer = new_concat(FC_GetStringASCII(), FC_GetStringLatin1());

    return U8_strdup(buffer);

}

FC_Rect FC_MakeRect(float x, float y, float w, float h)

{

    FC_Rect r = {x, y, w, h};

    return r;

}

FC_Scale FC_MakeScale(float x, float y)

{

    FC_Scale s = {x, y};

    return s;

}

SDL_Color FC_MakeColor(Uint8 r, Uint8 g, Uint8 b, Uint8 a)

{

    SDL_Color c = {r, g, b, a};

    return c;

}

FC_Effect FC_MakeEffect(FC_AlignEnum alignment, FC_Scale scale, SDL_Color color)

{

    FC_Effect e;

    e.alignment = alignment;

    e.scale = scale;

    e.color = color;

    return e;

}

FC_GlyphData FC_MakeGlyphData(int cache_level, Sint16 x, Sint16 y, Uint16 w, Uint16 h)

{

    FC_GlyphData gd;

    gd.rect.x = x;

    gd.rect.y = y;

    gd.rect.w = w;

    gd.rect.h = h;

    gd.cache_level = cache_level;

    return gd;

}

// Enough to hold all of the ascii characters and some.

#define FC_DEFAULT_NUM_BUCKETS 300

typedef struct FC_MapNode

{

    Uint32 key;

    FC_GlyphData value;

    struct FC_MapNode* next;

} FC_MapNode;

typedef struct FC_Map

{

    int num_buckets;

    FC_MapNode** buckets;

} FC_Map;

static FC_Map* FC_MapCreate(int num_buckets)

{

    int i;

    FC_Map* map = (FC_Map*)malloc(sizeof(FC_Map));

    map->num_buckets = num_buckets;

    map->buckets = (FC_MapNode**)malloc(num_buckets * sizeof(FC_MapNode*));

    for(i = 0; i < num_buckets; ++i)

    {

        map->buckets[i] = NULL;

    }

    return map;

}

/*static void FC_MapClear(FC_Map* map)

{

    int i;

    if(map == NULL)

        return;

    // Go through each bucket

    for(i = 0; i < map->num_buckets; ++i)

    {

        // Delete the nodes in order

        FC_MapNode* node = map->buckets[i];

        while(node != NULL)

        {

            FC_MapNode* last = node;

            node = node->next;

            free(last);

        }

        // Set the bucket to empty

        map->buckets[i] = NULL;

    }

}*/

static void FC_MapFree(FC_Map* map)

{

    int i;

    if(map == NULL)

        return;

    // Go through each bucket

    for(i = 0; i < map->num_buckets; ++i)

    {

        // Delete the nodes in order

        FC_MapNode* node = map->buckets[i];

        while(node != NULL)

        {

            FC_MapNode* last = node;

            node = node->next;

            free(last);

        }

    }

    free(map->buckets);

    free(map);

}

// Note: Does not handle duplicates in any special way.

static FC_GlyphData* FC_MapInsert(FC_Map* map, Uint32 codepoint, FC_GlyphData glyph)

{

    Uint32 index;

    FC_MapNode* node;

    if(map == NULL)

        return NULL;

    // Get index for bucket

    index = codepoint % map->num_buckets;

    // If this bucket is empty, create a node and return its value

    if(map->buckets[index] == NULL)

    {

        node = map->buckets[index] = (FC_MapNode*)malloc(sizeof(FC_MapNode));

        node->key = codepoint;

        node->value = glyph;

        node->next = NULL;

        return &node->value;

    }

    for(node = map->buckets[index]; node != NULL; node = node->next)

    {

        // Find empty node and add a new one on.

        if(node->next == NULL)

        {

            node->next = (FC_MapNode*)malloc(sizeof(FC_MapNode));

            node = node->next;

            node->key = codepoint;

            node->value = glyph;

            node->next = NULL;

            return &node->value;

        }

    }

    return NULL;

}

static FC_GlyphData* FC_MapFind(FC_Map* map, Uint32 codepoint)

{

    Uint32 index;

    FC_MapNode* node;

    if(map == NULL)

        return NULL;

    // Get index for bucket

    index = codepoint % map->num_buckets;

    // Go through list until we find a match

    for(node = map->buckets[index]; node != NULL; node = node->next)

    {

        if(node->key == codepoint)

            return &node->value;

    }

    return NULL;

}

struct FC_Font

{

    #ifndef FC_USE_SDL_GPU

    SDL_Renderer* renderer;

    #endif

    TTF_Font* ttf_source;  // TTF_Font source of characters

    Uint8 owns_ttf_source;  // Can we delete the TTF_Font ourselves?

    FC_FilterEnum filter;

    SDL_Color default_color;

    Uint16 height;

    Uint16 maxWidth;

    Uint16 baseline;

    int ascent;

    int descent;

    int lineSpacing;

    int letterSpacing;

    // Uses 32-bit (4-byte) Unicode codepoints to refer to each glyph

    // Codepoints are little endian (reversed from UTF-8) so that something like 0x00000005 is ASCII 5 and the map can be indexed by ASCII values

    FC_Map* glyphs;

    FC_GlyphData last_glyph;  // Texture packing cursor

    int glyph_cache_size;

    int glyph_cache_count;

    FC_Image** glyph_cache;

    char* loading_string;

};

// Private

static FC_GlyphData* FC_PackGlyphData(FC_Font* font, Uint32 codepoint, Uint16 width, Uint16 maxWidth, Uint16 maxHeight);

static FC_Rect FC_RenderLeft(FC_Font* font, FC_Target* dest, float x, float y, FC_Scale scale, const char* text);

static FC_Rect FC_RenderCenter(FC_Font* font, FC_Target* dest, float x, float y, FC_Scale scale, const char* text);

static FC_Rect FC_RenderRight(FC_Font* font, FC_Target* dest, float x, float y, FC_Scale scale, const char* text);

static_inline SDL_Surface* FC_CreateSurface32(Uint32 width, Uint32 height)

{

    #if SDL_BYTEORDER == SDL_BIG_ENDIAN

        return SDL_CreateRGBSurface(SDL_SWSURFACE, width, height, 32, 0xFF000000, 0x00FF0000, 0x0000FF00, 0x000000FF);

    #else

        return SDL_CreateRGBSurface(SDL_SWSURFACE, width, height, 32, 0x000000FF, 0x0000FF00, 0x00FF0000, 0xFF000000);

    #endif

}

char* U8_alloc(unsigned int size)

{

    char* result;

    if(size == 0)

        return NULL;

    result = (char*)malloc(size);

    result[0] = '\0';

    return result;

}

void U8_free(char* string)

{

    free(string);

}

char* U8_strdup(const char* string)

{

    char* result;

    if(string == NULL)

        return NULL;

    result = (char*)malloc(strlen(string)+1);

    strcpy(result, string);

    return result;

}

int U8_strlen(const char* string)

{

    int length = 0;

    if(string == NULL)

        return 0;

    while(*string != '\0')

    {

        string = U8_next(string);

        ++length;

    }

    return length;

}

int U8_charsize(const char* character)

{

    if(character == NULL)

        return 0;

    if((unsigned char)*character <= 0x7F)

        return 1;

    else if((unsigned char)*character < 0xE0)

        return 2;

    else if((unsigned char)*character < 0xF0)

        return 3;

    else

        return 4;

    return 1;

}

int U8_charcpy(char* buffer, const char* source, int buffer_size)

{

    int charsize;

    if(buffer == NULL || source == NULL || buffer_size < 1)

        return 0;

    charsize = U8_charsize(source);

    if(charsize > buffer_size)

        return 0;

    memcpy(buffer, source, charsize);

    return charsize;

}

const char* U8_next(const char* string)

{

    return string + U8_charsize(string);

}

int U8_strinsert(char* string, int position, const char* source, int max_bytes)

{

    int pos_bytes;

    int len;

    int add_len;

    int ulen;

    if(string == NULL || source == NULL)

        return 0;

    len = strlen(string);

    add_len = strlen(source);

    ulen = U8_strlen(string);

    if(position == -1)

        position = ulen;

    if(position < 0 || position > ulen || len + add_len + 1 > max_bytes)

        return 0;

    // Move string pointer to the proper position

    pos_bytes = 0;

    while(*string != '\0' && pos_bytes < position)

    {

        string = (char*)U8_next(string);

        ++pos_bytes;

    }

    // Move the rest of the string out of the way

    memmove(string + add_len, string, len - pos_bytes + 1);

    // Copy in the new characters

    memcpy(string, source, add_len);

    return 1;

}

void U8_strdel(char* string, int position)

{

    if(string == NULL || position < 0)

        return;

    while(*string != '\0')

    {

        if(position == 0)

        {

            int chars_to_erase = U8_charsize(string);

            int remaining_bytes = strlen(string) + 1;

            memmove(string, string + chars_to_erase, remaining_bytes);

            break;

        }

        string = (char*)U8_next(string);

        --position;

    }

}

static_inline FC_Rect FC_RectUnion(FC_Rect A, FC_Rect B)

{

    float x,x2,y,y2;

    x = FC_MIN(A.x, B.x);

    y = FC_MIN(A.y, B.y);

    x2 = FC_MAX(A.x+A.w, B.x+B.w);

    y2 = FC_MAX(A.y+A.h, B.y+B.h);

    {

        FC_Rect result = {x, y, FC_MAX(0, x2 - x), FC_MAX(0, y2 - y)};

        return result;

    }

}

// Adapted from SDL_IntersectRect

static_inline FC_Rect FC_RectIntersect(FC_Rect A, FC_Rect B)

{

    FC_Rect result;

	float Amin, Amax, Bmin, Bmax;

	// Horizontal intersection

	Amin = A.x;

	Amax = Amin + A.w;

	Bmin = B.x;

	Bmax = Bmin + B.w;

	if(Bmin > Amin)

	        Amin = Bmin;

	result.x = Amin;

	if(Bmax < Amax)

	        Amax = Bmax;

	result.w = Amax - Amin > 0 ? Amax - Amin : 0;

	// Vertical intersection

	Amin = A.y;

	Amax = Amin + A.h;

	Bmin = B.y;

	Bmax = Bmin + B.h;

	if(Bmin > Amin)

	        Amin = Bmin;

	result.y = Amin;

	if(Bmax < Amax)

	        Amax = Bmax;

	result.h = Amax - Amin > 0 ? Amax - Amin : 0;

	return result;

}

FC_Rect FC_DefaultRenderCallback(FC_Image* src, FC_Rect* srcrect, FC_Target* dest, float x, float y, float xscale, float yscale)

{

    float w = srcrect->w * xscale;

    float h = srcrect->h * yscale;

    FC_Rect result;

    // FIXME: Why does the scaled offset look so wrong?

    #ifdef FC_USE_SDL_GPU

    {

        GPU_Rect r = *srcrect;

        GPU_BlitScale(src, &r, dest, x + xscale*r.w/2.0f, y + r.h/2.0f, xscale, yscale);

    }

    #else

    {

        SDL_RendererFlip flip = SDL_FLIP_NONE;

        if(xscale < 0)

        {

            xscale = -xscale;

            flip = (SDL_RendererFlip) ((int)flip | (int)SDL_FLIP_HORIZONTAL);

        }

        if(yscale < 0)

        {

            yscale = -yscale;

            flip = (SDL_RendererFlip) ((int)flip | (int)SDL_FLIP_VERTICAL);

        }

        SDL_Rect r = *srcrect;

        SDL_Rect dr = {(int)x, (int)y, (int)(xscale*r.w), (int)(yscale*r.h)};

        SDL_RenderCopyEx(dest, src, &r, &dr, 0, NULL, flip);

    }

    #endif

    result.x = x;

    result.y = y;

    result.w = w;

    result.h = h;

    return result;

}

static FC_Rect (*fc_render_callback)(FC_Image* src, FC_Rect* srcrect, FC_Target* dest, float x, float y, float xscale, float yscale) = &FC_DefaultRenderCallback;

void FC_SetRenderCallback(FC_Rect (*callback)(FC_Image* src, FC_Rect* srcrect, FC_Target* dest, float x, float y, float xscale, float yscale))

{

    if(callback == NULL)

        fc_render_callback = &FC_DefaultRenderCallback;

    else

        fc_render_callback = callback;

}

void FC_GetUTF8FromCodepoint(char* result, Uint32 codepoint)

{

    char a, b, c, d;

    if(result == NULL)

        return;

    a = (codepoint >> 24) & 0xFF;

    b = (codepoint >> 16) & 0xFF;

    c = (codepoint >> 8) & 0xFF;

    d = codepoint & 0xFF;

    if(a == 0)

    {

        if(b == 0)

        {

            if(c == 0)

            {

                result[0] = d;

                result[1] = '\0';

            }

            else

            {

                result[0] = c;

                result[1] = d;

                result[2] = '\0';

            }

        }

        else

        {

            result[0] = b;

            result[1] = c;

            result[2] = d;

            result[3] = '\0';

        }

    }

    else

    {

        result[0] = a;

        result[1] = b;

        result[2] = c;

        result[3] = d;

        result[4] = '\0';

    }

}

Uint32 FC_GetCodepointFromUTF8(const char** c, Uint8 advance_pointer)

{

    Uint32 result = 0;

    const char* str;

    if(c == NULL || *c == NULL)

        return 0;

    str = *c;

    if((unsigned char)*str <= 0x7F)

        result = *str;

    else if((unsigned char)*str < 0xE0)

    {

        result |= (unsigned char)(*str) << 8;

        result |= (unsigned char)(*(str+1));

        if(advance_pointer)

            *c += 1;

    }

    else if((unsigned char)*str < 0xF0)

    {

        result |= (unsigned char)(*str) << 16;

        result |= (unsigned char)(*(str+1)) << 8;

        result |= (unsigned char)(*(str+2));

        if(advance_pointer)

            *c += 2;

    }

    else

    {

        result |= (unsigned char)(*str) << 24;

        result |= (unsigned char)(*(str+1)) << 16;

        result |= (unsigned char)(*(str+2)) << 8;

        result |= (unsigned char)(*(str+3));

        if(advance_pointer)

            *c += 3;

    }

    return result;

}

void FC_SetLoadingString(FC_Font* font, const char* string)

{

    if(font == NULL)

        return;

    free(font->loading_string);

    font->loading_string = U8_strdup(string);

}

unsigned int FC_GetBufferSize(void)

{

    return fc_buffer_size;

}

void FC_SetBufferSize(unsigned int size)

{

    free(fc_buffer);

    if(size > 0)

    {

        fc_buffer_size = size;

        fc_buffer = (char*)malloc(fc_buffer_size);

    }

    else

        fc_buffer = (char*)malloc(fc_buffer_size);

}

// Constructors

static void FC_Init(FC_Font* font)

{

    if(font == NULL)

        return;

    #ifndef FC_USE_SDL_GPU

    font->renderer = NULL;

    #endif

    font->ttf_source = NULL;

    font->owns_ttf_source = 0;

    font->filter = FC_FILTER_NEAREST;

    font->default_color.r = 0;

    font->default_color.g = 0;

    font->default_color.b = 0;

    FC_GET_ALPHA(font->default_color) = 255;

    font->height = 0; // ascent+descent

    font->maxWidth = 0;

    font->baseline = 0;

    font->ascent = 0;

    font->descent = 0;

    font->lineSpacing = 0;

    font->letterSpacing = 0;

    // Give a little offset for when filtering/mipmaps are used.  Depending on mipmap level, this will still not be enough.

    font->last_glyph.rect.x = FC_CACHE_PADDING;

    font->last_glyph.rect.y = FC_CACHE_PADDING;

    font->last_glyph.rect.w = 0;

    font->last_glyph.rect.h = 0;

    font->last_glyph.cache_level = 0;

    if(font->glyphs != NULL)

        FC_MapFree(font->glyphs);

    font->glyphs = FC_MapCreate(FC_DEFAULT_NUM_BUCKETS);

    font->glyph_cache_size = 3;

    font->glyph_cache_count = 0;

    font->glyph_cache = (FC_Image**)malloc(font->glyph_cache_size * sizeof(FC_Image*));

	if (font->loading_string == NULL)

		font->loading_string = FC_GetStringASCII();

    if(fc_buffer == NULL)

        fc_buffer = (char*)malloc(fc_buffer_size);

}