blame: source/code/Libs/SDL_FontCache.cpp

/*

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

	{

		int flip = SDL_FLIP_NONE;

		if (xscale < 0) {

			xscale = -xscale;

			flip |= SDL_FLIP_HORIZONTAL;

		}

		if (yscale < 0) {

			yscale = -yscale;

			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, (SDL_RendererFlip)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) {

	if (font == NULL || data_surface == NULL) {

		return 0;

	}

#ifdef FC_USE_SDL_GPU

	GPU_Image* new_level = GPU_CopyImageFromSurface(data_surface);

	if (FC_GetFilterMode(font) == FC_FILTER_LINEAR) {

		GPU_SetImageFilter(new_level, GPU_FILTER_LINEAR);

	}

	else {

		GPU_SetImageFilter(new_level, GPU_FILTER_NEAREST);

	}

#else

	SDL_Texture* new_level;

	if (!fc_has_render_target_support) {

		new_level = SDL_CreateTextureFromSurface(font->renderer, data_surface);

	}

	else {

		// Must upload with render target enabled so we can put more glyphs on later

		SDL_Renderer* renderer = font->renderer;

		// Set filter mode for new texture

		const char* old_filter_mode = SDL_GetHint(SDL_HINT_RENDER_SCALE_QUALITY);

		if (FC_GetFilterMode(font) == FC_FILTER_LINEAR) {

			SDL_SetHint(SDL_HINT_RENDER_SCALE_QUALITY, "1");

		}

		else {

			SDL_SetHint(SDL_HINT_RENDER_SCALE_QUALITY, "0");