blame: source/code/Libs/SDL_FontCache.c

/*

SDL_FontCache v0.0.1: A font cache for SDL and SDL_ttf

by Jonathan Dearborn

Dedicated to the memory of Florian Hufsky

License:

    The short:

    Use it however you'd like, but keep the copyright and license notice 

    whenever these files or parts of them are distributed in uncompiled form.

    The long:

Copyright (c) 2015 Jonathan Dearborn

Permission is hereby granted, free of charge, to any person obtaining a copy

of this software and associated documentation files (the "Software"), to deal

in the Software without restriction, including without limitation the rights

to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

copies of the Software, and to permit persons to whom the Software is

furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in

all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN

THE SOFTWARE.

*/

#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))

#define FC_EXTRACT_VARARGS(buffer, start_args) \

{ \

    va_list lst; \

    va_start(lst, start_args); \

    vsprintf(buffer, 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 Uint8 fc_has_render_target_support = 0;

const 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 buffer;

}

const 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 buffer;

}

const char* FC_GetStringASCII_Latin1(void)

{

    static char* buffer = NULL;

    if(buffer == NULL)

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

    return 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 = strlen(string);

    int add_len = strlen(source);

    int ulen = U8_strlen(string);

    if(position == -1)

        position = ulen;

    if(string == NULL || source == NULL || 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 = flip | SDL_FLIP_HORIZONTAL;

        }

        if(yscale < 0)

        {

            yscale = -yscale;

            flip = flip | 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);

}

void FC_SetBufferSize(unsigned int size)

{

    free(fc_buffer);

    if(size > 0)

        fc_buffer = (char*)malloc(size);

    else

        fc_buffer = (char*)malloc(1024);

}

// 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 = U8_strdup(FC_GetStringASCII());

    if(fc_buffer == NULL)

        fc_buffer = (char*)malloc(1024);

}

static Uint8 FC_GrowGlyphCache(FC_Font* font)

{

    if(font == NULL)

        return 0;

    #ifdef FC_USE_SDL_GPU

    GPU_Image* new_level = GPU_CreateImage(font->height * 12, font->height * 12, GPU_FORMAT_RGBA);

    #else

    SDL_Texture* new_level = SDL_CreateTexture(font->renderer, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, font->height * 12, font->height * 12);

    #endif

    if(new_level == NULL || !FC_SetGlyphCacheLevel(font, font->glyph_cache_count, new_level))

    {

        FC_Log("Error: SDL_FontCache ran out of packing space and could not add another cache level.\n");

        #ifdef FC_USE_SDL_GPU

        GPU_FreeImage(new_level);

        #else

        SDL_DestroyTexture(new_level);

        #endif

        return 0;

    }

    return 1;

}

static Uint8 FC_UploadGlyphCache(FC_Font* font, int cache_level, SDL_Surface* data_surface)

{